學習來源：B站 黑馬程式設計師

註釋

1. 單行註釋 # 規範：程式碼[兩個空格]#[空格]註釋
2. 多行註釋 """ """ 或 ''' '''

資料型別

int，float，bool(True\False)，str(字串)，list（列表），tuple（元組），set（集合），dict（字典）

格式化輸出

age = 18    name="TOM"
print("年齡:%d" % age)  # 年齡:18
print("姓名:%s 年齡:%d" % (name, age) )  # 姓名:TOM 年齡:18

%06d 佔6位，不足以0補全，若超出則原樣輸出

%.2f 保留兩位小數

f 格式化字串 f “{表示式}” python3.6新增

print(f "姓名：{name} 年齡：{age}") # 姓名：TOM 年齡：18

結束符

print("輸出內容"，end="\n")

print("hello", end="\n")  # 預設
print("world", end="\t")
print("hello", end="...")  # 自定義
print("world")

hello
world	hello...world

輸入

input("提示資訊")

1. 程式執行到input，等待使用者輸入
2. input接收使用者輸入後，一般儲存到變數
3. 接收到的資料都當做字串處理

t = input("請輸入：")  # 123
print(t)  # 123
print(type(t))  # <class 'str'>

型別轉換

int()，float()，str()，list()，tuple()，eval()，，，

eval() 用來計算在字串中的有效python表示式，並返回一個物件

s1 = "1.1"
print(type(eval(s1)))  # <class 'float'>
s2 = "[1,2,3]"
print(type(eval(s2)))  # <class 'list'>
 

運算子

算術運算子

+，-、*、/(除)，//(整除)，%，**(指數)，，，

多變數賦值

n1, f1, s1 = 1, 1.1, "hello"
print(n1)  # 1
print(f1)  # 1.1
print(s1)  # hello
a = b = 10  # 多變數賦相同值

邏輯運算子 and or not

18 <= age <=60 Python中可以這樣寫

三目運算子

a = 1
b = 2
c = a if a > b else b
print(c)  # 2

迴圈

if

語法

if 條件:
    條件成立執行的程式碼1
    條件成立執行的程式碼2
    ......

多重判斷

if 條件1:
    條件1成立執行的程式碼1
    條件1成立執行的程式碼2
    ......
elif 條件2:
    條件2成立執行的程式碼1
    條件2成立執行的程式碼2
    ......
else:
    以上條件都不成立執行的程式碼
    ......

while

語法

while 條件:
    條件成立執行的程式碼1
    條件成立執行的程式碼2
    ......

while...else

while 條件:
    條件成立重複執行的程式碼
else:
    迴圈正常結束之後要執行的程式碼

else是迴圈正常結束之後要執行的程式碼，在continue控制下可以正常執行

for

語法

for 臨時變數 in 序列:
    重複執行的程式碼1
    重複執行的程式碼2
    ......

s1 = "hello"
for i in s1:
    print(i)

輸出
h
e
l
l
o

for...else

for 臨時變數 in 序列:
    重複執行的程式碼
    ...
else:
    迴圈正常結束之後要執行的程式碼

字串

a = "hello" \
    "world"
print(a)

b = """hello
world"""
print(b)

c = 'I\'am TOM'  # 轉義 \'
print(c)

輸出
helloworld
hello
world
I'am TOM

切片

切片是指對操作的物件擷取其中一部分的操作。字串、列表、元組都支援切片操作。

語法：

序列[開始位置下標 : 結束位置下標 : 步長]

注意：

1. 不包含結束位置下標對應的資料，正負整數均可
2. 步長是選取間隔，正負整數均可，預設步長為1。

str1 = "0123456789"
print(str1[2:5:1])  # 234
print(str1[2:5:2])  # 24
print(str1[2:5])  # 234
print(str1[2:])  # 23456789
print(str1[:5])  # 01234
print(str1[:])  # 0123456789
print(str1[::-1])  # 9876543210   如果步長為負數，表示倒敘選取
print(str1[-4:-1])  # 678   下標-1表示最後一個數據，依次向前類推
print(str1[-4:-1:-1])  # 不能選取出資料：-4到-1，選取方向為從左到右，但是-1步長，從右到左選取
# 如果選取方向（下標開始到結束的方向）和 步長的方向衝突，則無法選取
print(str1[-1:-4:-1])  # 987

查詢

1. find() 返回子串第一次出現的位置，沒有則返回-1 字串序列.find(子串，開始位置下標，結束位置下標)
2. rfind() 和find()功能相同，但查詢方向為從右側開始
3. rindex() 和rindex()功能相同，但查詢方向為從右側開始
4. index() 檢測某個子串是否包含於這個字串中，有則返回開始位置下標，否則報錯 字串序列.index(子串，開始位置下標，結束位置下標)
5. count() 返回子串出現的次數 字串序列.count(子串，開始位置下標，結束位置下標)

修改

1. replace() 替換 字串序列.replace(舊子串，新子串，替換次數)

2. split() 按照指定字元分割字串 字串序列.split(分割字元，num) num表示分割字元出現的次數，即 將來返回資料個數為num+1個 分割會丟失分割字元

3. join() 用一個字元或字串合併字串，即是將多個字串合併為一個新的字串 字元或子串.join(多字串組成的序列)

   l1 = ["a", "b", "c"]
   str2 = "...".join(l1)
   print(str2)  # a...b...c
   

4. capitalize() 將字串第一個字元轉換成大寫

5. title() 將字串每個單詞首字母轉換成大寫

6. lower() 將字串中大寫轉小寫

7. upper() 將字串中小寫轉大寫

8. lstrip() 刪除字串左側空白字元

9. rstrip() 刪除字串右側空白字元

10. strip() 刪除字串兩側空白字元

11. ljust() 返回一個原字串左對齊，並使用指定字元（預設空格）填充至對應長度的新字串

    str1 = "hello"
    print(str1.ljust(10, "."))  # hello.....
    

12. rjust() 右對齊

13. center() 居中

判斷

1. startswith() 檢查字串是否以指定子串開頭，是則返回True，否則返回False。 字串序列.startswith(子串，開始位置下標，結束位置下標)
2. endswith() 是否以指定子串結尾
3. isalpha() 如果字串至少有一個字元並且所有字元都是字母則返回True，否則返回False
4. isdigit() 如果字串只包含數字則返回True，否則返回False
5. isalnum() 如果字串至少有一個字元並且所有字元都是字母或數字則返回True，否則返回False
6. isspace() 如果字串中只包含空白，則返回True，否則返回False

列表

格式

[資料1，資料2，資料3，資料4......]

列表可以一次性儲存多個數據，且可以為不同資料型別

常用操作

查詢

1. 下標

   name_list = ["Tom", "Jerry", "Rose"]
   print(name_list[0])  # Tom
   print(name_list[1])  # Jerry
   print(name_list[2])  # Rose
   

2. 函式

   1. index() 返回指定資料所在位置的下標

      name_list = ["Tom", "Jerry", "Rose"]  
      print(name_list.index("Rose", 0, 3))  # 2  區間左閉右開
      

   2. count() 統計指定資料在當前列表中出現的次數

   3. len() 列表長度，即列表中資料的個數

判斷是否存在

in 判斷指定資料在某個列表序列，如果在返回True，否則返回False

name_list = ["Tom", "Jerry", "Rose"]
print("Jerry" in name_list)  # True
print("Jerrys" in name_list)  # False

not in 判斷指定資料不在某個列表序列，如果不在返回True，否則返回False

增加

1. append() 列表結尾追加資料

2. extend() 列表結尾追加資料，如果資料是一個序列，則將這個序列的資料逐一新增到列表

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.extend("Jack")
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'J', 'a', 'c', 'k']
   
   name_list = ["Tom", "Jerry", "Rose"]
   name_list.extend(["Jack", "xiaoming"])
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'Jack', 'xiaoming']
   

3. insert() 指定位置新增資料

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.insert(3, "Jack")
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'Jack']
   

刪除

1. del

   # 刪除列表
   name_list = ["Tom", "Jerry", "Rose"]
   del name_list
   print(name_list)  # NameError: name 'name_list' is not defined
   # 刪除資料
   name_list = ["Tom", "Jerry", "Rose"]
   del name_list[1]
   print(name_list)  # ['Tom', 'Rose']
   

2. pop() 刪除指定下標的資料（預設為最後一個），並返回該資料

   name_list = ["Tom", "Jerry", "Rose"]
   del_name = name_list.pop(1)
   print(del_name)  # Jerry
   print(name_list)  # ['Tom', 'Rose']
   

3. remove() 移除列表中某個資料的第一個匹配項

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.remove("Jerry")
   print(name_list)  # ['Tom', 'Rose']
   

4. clear() 清空列表

修改

1. reverse() 逆置

2. sort() 排序

   列表序列.sort(key = None, reverse = False)
   reverse=True 降序  reverse=False 升序（預設）
   
   l1 = [3, 5, 1, 2, 4]
   l1.sort()
   print(l1)  # [1, 2, 3, 4, 5]
   l1.sort(reverse=True)
   print(l1)  # [5, 4, 3, 2, 1]
   

複製

copy()

name_list = ["Tom", "Jerry", "Rose"]
name_list2 = name_list.copy()
print(name_list2)  # ['Tom', 'Jerry', 'Rose']

列表巢狀

name_list = [["小明", "小紅", "小黑"], ["Tom", "Jerry", "Rose"], ["1", "2", "3"]]
print(name_list[1][1])  # Jerry

元組

一個元組可以儲存多個數據，元組內的資料是不能修改的

定義

t1 = (10, 20, 30)  # 多個數據元組
t2 = (10,)  # 單個數據元組

常用操作

查詢

1. 下標
2. index()
3. count()
4. len()

修改

元組內的直接資料如果修改則立即報錯

但是如果元組裡面有列表，修改列表裡面的資料則是支援的

t1 = (10, 20, ["a", "b", "c"])
print(t1)  # (10, 20, ['a', 'b', 'c'])
t1[2][0] = "A"
print(t1)  # (10, 20, ['A', 'b', 'c'])

字典

字典裡面的資料是以鍵值對形式出現，字典資料和資料順序沒有關係，即字典不支援下標，後期無論資料如何變化，只需要按照對應的鍵的名字查詢資料即可。

建立

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
dict2 = {}
dict3 = dict()

常用操作

修改

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
dict1["name"] = "Jerry"
print(dict1)  # {'name': 'Jerry', 'age': 20, 'gender': '男'}
dict1["id"] = "001"
print(dict1)  # {'name': 'Jerry', 'age': 20, 'gender': '男', 'id': '001'}

刪除

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
del dict1["gender"]
print(dict1)  # {'name': 'TOM', 'age': 20}

dict1.clear()  # 清空
print(dict1)  # {}

del(dict1)   # 刪除字典

查詢

1.get() 字典序列.get(key, 預設值)

如果key不存在則返回第二個引數，預設為None

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.get("name"))  # TOM
print(dict1.get("id", 999))  # 999 
print(dict1.get("id"))  # None

2.keys()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

3.values()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.values())  # dict_values(['TOM', 20, '男'])

4.items()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.items())  # dict_items([('name', 'TOM'), ('age', 20), ('gender', '男')])  返回可迭代物件，內部是元組

遍歷

for key in dict1.keys():
    print(key)

for value in dict1.values():
    print(value)

for item in dict1.items():
    print(item)

for key,value in dict1.items():
    print(f"{key} = {value}")

集合

建立

使用{}或set()，如果建立空集合，只能用set()建立，因為使用{}會建立空字典

set1 = {10, 10, 20, 30}  # {10, 20, 30}
set2 = set("abcdef")  # {'c', 'a', 'b', 'f', 'e', 'd'} 
set3 = set()  # set()

常用操作

增加

1. add() s1.add(10)
2. update() s1.update([10,20])

刪除

1. remove() s1.remove(10) 資料不存在則報錯
2. discard() s1.discard(10) 資料不存在不報錯
3. pop() del_num = s1.pop() 隨機刪除某個資料，並返回這個資料

查詢

1. in：判斷資料在集合序列

2. not in ：判斷資料不在集合序列

   set1 = {10, 20, 30}
   print(10 in set1)  # True
   print(10 not in set1)  # False
   

公共操作

運算子

方法

1. len() 計算容器元素個數

2. del或del() 刪除

3. max() 返回容器中元素最大值

4. min() 返回容器中元素最小值

5. range(start, end, step) 生成從start到end的數字，步長為step，供for迴圈使用

6. enumerate() 將一個可遍歷的資料物件（如列表、元組或字串）組合為一個索引序列，同時列出資料和資料下標，一般用在for迴圈當中

   enumerate(可遍歷物件，start = 0)   start為遍歷下標的起始值
   list1 = ["abc", "acb"]
   for i in enumerate(list1):
       print(i)
   
   for index, char in enumerate(list1, start=1):
       print(f"下標是{index}，對應的字元是{char}")
   

容器型別轉換

1. tuple() 將某個序列轉換成元組
2. list() 將某個序列轉換成列表
3. set() 將某個序列轉換成集合

推導式

一、列表推導式

list1 = [i for i in range(10)]
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list1 = [i for i in range(0, 10, 2)]
print(list1)  # [0, 2, 4, 6, 8]

list1 = [i for i in range(10) if i % 2 == 0]
print(list1)  # [0, 2, 4, 6, 8]

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)  # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

二、字典推導式

dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}

# 將兩個列表合併為一個字典
list1 = ["name", "age", "gender"]
list2 = ["Tom", 20, "man"]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)  # {'name': 'Tom', 'age': 20, 'gender': 'man'}

# 提取字典中目標資料
counts = {"MBP": 268, "HP": 125, "DELL": 201, "Lenovo": 199, "acer": 99}
# 提取電腦數量大於等於200的字典資料
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)  # {'MBP': 268, 'DELL': 201}

三、集合推導式

list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1)  # {1, 4}