本文作者：林箖霖
本文原創，未經允許，禁止轉載！
輸入函數從鍵盤接收到的是字符類型（str）
a = input("輸入第一個數：") # 輸入第一個數：10
b = input("輸入第二個數：") # 輸入第二個數：20
print(a + b) # 輸出結果為：1020這裡的'+'是兩個字符串的連接符
print(int(a) + int(b)) # 輸出結果為：30，這裡要對從鍵盤接收到的數據進行類型轉換才可以進行運算
指定對齊方式
+，負數帶-。0表示寬度不足時補充 0，而不是補充空格。應用舉例：
print("hello world")
print('hello world')
# 指定最小輸出寬度
n = 1234567
str = 'ling'
# %10d 表示輸出的整數寬度至少為 10；
# %20s 表示輸出的字符串寬度至少為 20。
print("%10d" % n) # 00001234567（此處把0當作空格）
print("%7s" % str) # 0000ling（此處把0當作空格）
# 指定小數精度
f = 3.141592653
# 最小寬度為8，小數點後保留3位
print("%8.3f" % f) # 3.142
# 最小寬度為8，小數點後保留3位，左邊補0
print("%08.3f" % f) # 0003.142
# 最小寬度為8，小數點後保留3位，左邊補0，帶符號
print("%+08.3f" % f) # +003.142
# 指定對齊方式
n = 123456
# %09d 表示最小寬度為9，左邊補0
print("%09d" % n) # 000123456
# %+9d 表示最小寬度為9，帶上符號
print("%+9d" % n) #000+123456 （此處0為空格）
f = 140.5
# %-+010f 表示最小寬度為10，左對齊，帶上符號
print("%-+010f" % f) # +140.500000 （左對齊往右邊補0）
s = "Hello"
# %-10s 表示最小寬度為10，左對齊
print("%-10s." % s) # Hello .（左對齊往右邊補空格）
# 單行注釋
''' 多行注釋 注釋內容 '''
""" 多行注釋 注釋內容 """
應用舉例：
print("hello\b") #hell
print("hello\r")
print("hello\
world") #helloworld
print("hello\tworld") #hello world 其中hell占了四個位置，則\t表示o和三個空格
print("hellooo\tworld")#hellooo world 這個\t表示的是ooo和一個空格
print("\\\'\"") #\'"
# 可以使用單引號，也可以使用雙引號
str1 = 'abc'
str2 = "abcd"
print(str1, type(str1), str2, type(str2)) # abc <class 'str'> abcd <class 'str'>
# 賦值運算符
c = 10 # 十進制
e = 0b100 # 二進制
f = 0o100 # 八進制
g = 0x100 # 十六進制
print(c, e, f, g) # 10 4 64 256
布爾型（bool）中，True代表int類型中的 1 ，False代表int類型中的 0
a = True
b = False
# bool轉int
a = int(a)
b = int(b)
print(a, type(a), b, type(b)) # 1 <class 'int'> 0 <class 'int'>
# bool轉str
a = str(a)
b = str(b)
print(a, type(a), b, type(b)) # 1 <class 'str'> 0 <class 'str'>
# bool轉float
a = float(a)
b = float(b)
print(a, type(a), b, type(b)) # 1.0 <class 'float'> 0.0 <class 'float'>
所有類型都可以轉化為str類型，通常使用str（）函數，或者可以通過直接加 ’ ’ 的方法
# 其他類型可以無條件轉化為str類型
c = 123
d = 123.3
e = True
print(str(c), type(str(c)), str(d), type(str(d))) # 123 <class 'str'> 123.3 <class 'str'>
print(str(e), type(str(e))) # True <class 'str'>
# 也可以通過直接加''轉化，這個方法類似於定義字符串
f = '1234'
print(f, type(f)) # 1234 <class 'str'>
文字類和小數類字符型（str）無法轉化為整型（int）
# str類型轉化為int類型
str1 = '123'
str2 = '123.3'
str3 = '張三'
print(int(str1), type(int(str1))) # 123 <class 'int'>
print(int(str2), type(int(str2))) # ValueError: invalid literal for int() with base 10: '123.3'
print(int(str3), type(int(str3))) # ValueError: invalid literal for int() with base 10: '張三'
浮點型（float）轉化為整型（int）的時候，小數位會被抹掉
# float類型轉化為int類型
f1 = 123.33
f2 = 55.0
print(int(f1), type(int(f1))) # 123 <class 'int'>
print(int(f2), type(int(f2))) # 55 <class 'int'>
文字類字符串無法轉化為float類型
# str類型轉flaot類型
str4 = '123'
str5 = '123.4'
str6 = 'zhang'
print(float(str4), type(float(str4))) # 123.0 <class 'float'>
print(float(str5), type(float(str5))) # 123.4 <class 'float'>
print(float(str6), type(float(str6))) # ValueError: could not convert string to float: 'zhang'
整型（int）轉化為浮點型（float）會在其末尾加上 ’ .0 ’
# int類型轉float類型
a = 2
b = 10
print(float(a), type(float(a))) # 2.0 <class 'float'>
print(float(b), type(float(b))) # 10.0 <class 'float'>
浮點數存儲不確定性
使用浮點數進行計算時，可能會出現小數位數不確定的情況
# 加法、減法、乘法
# 加法
print(1 + 1) # 結果為2，整型
print(1.1 + 2.2) # 結果為3.300000000003，浮點數存儲不精確，小數位數不確定
print(1.1 + 2) # 結果為3.1，浮點型
# 減法
print(2 - 1) # 結果為1，整型
print(2.2 - 3.1) # 結果為-0.89999999999，浮點數存儲不精確，小數位數不確定
print(3.3 - 1) # 結果為2.3，浮點型
# 乘法
print(2 * 5) # 結果為10，整型
print(2.2 * 5.5) # 結果為12.100000000001，浮點數存儲不精確，小數位數不確定
print(5.5 * 3) # 結果為16.5，浮點型
# 解決方法，導入Decimal
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2')) # 輸出結果為3.3
print(Decimal('2.2') - Decimal('3.1')) # 輸出結果為-0.9
print(Decimal('2.2') * Decimal('5.5')) # 輸出結果為12.10
就是普通除法，帶小數運算
# 除法 (得出的結果為浮點型)
print(11 / 2) # 結果為5.5
print(-10 / 3) # 結果為-3.3333333333335 (後面是5是因為浮點數的不精確性)
# 解決方法，導入Decimal
from decimal import Decimal
print(Decimal('-10') / Decimal('3')) # 輸出結果為-3.3333333333333333
c = 9 / 3
print(c, type(c)) # 結果為3.0 (注意此處，得出的結果是浮點型)
在其他語言中，求商的符號是 / ，求余的符號是 %
向左取整（數軸的左邊，高斯函數），即11 // 2= 5.5 輸出的是 5
如果被除數和除數一正一負，也同樣適用，例如 (-10) // 3 = -4
print(-11//5) #商為-3
print(11//-5) #商為-3 一正一負，向左取整（數軸的左）高斯函數
print(-10//3) #商為-4
求余公式 ：余數 = 被除數 - 除數 * 商
#求商
print(10//4) #商為2
print(-10//4) #商為-3 向左取整 -2.5向左取整為-3
print(10//-4) #商為-3 向左取整 -2.5向左取整為-3
#求余
# Python 中的求余公式 余數=被除數-除數*商
print(10%4) #余數為2 10-4*2=8
print(-10%4) #余數為2 (-10)-4*(-3) --> (-10)+12=2
print(10%-4) #余數為-2 10-(-4)*(-3) --> 10-12=-2
指數運算
# 冪運算(得出的結果為整型)
print(2 ** 2) # 結果為4
print(2 ** 3) # 結果為8
d = 2 ** 6
print(d, type(d)) # 結果為64(輸出結果為整型)
應用舉例：
a = b = c = 10 # 鏈式賦值，其id為同一個，即指向同一個對象
print(a is b) # True,比較所指向對象的id
print(a == b) # True，比較所指向對象的value
# 兩個列表的值一樣，但是其對象的id不一樣
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
# list1 = list2 = [1, 2, 3, 4] 鏈式賦值，這種情況下兩個列表所指向的對象的id一樣
print(list1 is list2) # False，比較兩個列表的id
print(list1 is not list2) # True
print(list1 == list2) # True，比較兩個列表的值
應用舉例：
c = 10
d = 20
print(c == 10 and d == 20) # True
print(c != 10 or d == 20) # True
print(not (c == 10)) # False
應用舉例：
# 位運算符
a1 = 4 # 00000100
a2 = 8 # 00001000
b = 1
# 將整數化為二進制，將其向左\右移動b位，超出的位抹掉，缺的位補0
print(a1 << b) # 8 將4轉化為二進制（8位），再將其向左移一位
print(a2 >> b) # 4 同理，這個是右移一位，這裡的b是代表左移或者右移的位數
print(a1 & a2) # 0 逐位相與
print(a1 | a2) # 12 逐位相或
應用舉例：
# 賦值運算符
b1 = 2
b2 = 4
b1 += b2 # b1=b1+b2
print(b1)
用bool（）函數可以查看對象的布爾值
# 布爾值為False的情況
print(bool('')) # 空字符串
print(bool("")) # 空字符串
print(bool(0)) # 整型 0
print(bool(0.0)) # 浮點型 0.0
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(())) # 空元組
print(bool(tuple())) # 空元組
print(bool({
})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合
單分支（if）
寫法舉例（要注意縮進）：
a = 10
b = 20
if a >= b:
print(a)
雙分支（if…else）
寫法舉例（要注意縮進）：
a = 10
b = 20
if a >= b:
print(a)
else:
print(b)
多分支（if…elif…else）
寫法舉例（要注意縮進）：
a = 10
b = 20
c = 30
if a > b:
print(a)
elif a > c:
print(b)
else:
print(c)
if語句的嵌套
寫法舉例（要注意縮進）：
a = 10
b = 20
c = 30
if a < b:
if a < c:
print("最小值為%d" % a)
else:
print("最小值為%d" % c)
else:
pass
條件表達式
寫法舉例：
num1 = int(input('第一個整數:'))
num2 = int(input('第二個整數:'))
# if...else寫法
if num1 >= num2:
print(str(num1) + '大於' + str(num2))
else:
print(str(num1) + '小於' + str(num2))
# 條件表達式寫法
print((str(num1) + '大於' + str(num2)) if num1 >= num2 else (str(num1) + '小於' + str(num2)))
空語句可以讓程序正常運行，為未想好的代碼留下位置
應用舉例：
d = 100
e = 200
if d > e:
pass
else:
pass
range（）函數用於生成一個整數序列，其返回值是一個迭代器對象；不管range對象表示的整數隊列有多長，所有range對象占用的內存空間的都是相同的，因為僅需要存儲start（開始）、stop（結束）、step（步長），只有當用到range對象時，才會去計算序列中的相關元素；in與not in判斷幀數序列中是否存在（不存在指定的整數）
用法1（range（stop））
用法舉例：
# range(stop)
r = range(10) # 到10結束，不包括10，默認從0開始，序列長度為：10-0=10
print(r) # range(0, 10)
# 查看range對象中的整數序列
print(list(r)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
用法2（range（start，stop））
用法舉例：
# range(start,stop)
g = range(1, 10) # 從1開始，到10結束，不包括10，序列長度為：10-1=9
print(g) # range(1, 10)
print(list(g)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
用法3（range（start，stop，step））
用法舉例：
# range(start,stop,step),step為步長，即相鄰兩個元素相差的差
b = range(1, 10, 2)
print(b) # range(1, 10, 2)
print(list(b)) # [1, 3, 5, 7, 9]
print(10 in b) # False,10不在b這個整數序列中
print(3 in b) # True，3在這個整數序列中
# 倒序輸出，步長為負數，倒序輸出一定要寫步長，要不然用list()輸出為空
E = range(100, 0, -1)
print(list(E)) # [100, 99, 98, 97, 96, 95....]
while循環
寫法舉例：
a = 1
sum = 0
while a < 5:
sum += a
a += 1
print(sum)
for…in循環
for…in循環需要用到 range（）函數
寫法舉例：
D = range(0, 101, 2) # 從0開始到100的偶數序列
# print(list(D)) #[0, 2, 4, 6, 8, 10, 12.....]
sum = 0
for a in D: # 從整數序列D中依次取數值出來賦給變量a
sum += a # 求和
print(sum) #2550
break語句
break語句用於跳出當前循環體；一般搭配 if 使用
應用舉例：
a = 0
while a < 3:
str = input("請輸入密碼:")
if str == "8888":
print('密碼正確')
break # 當密碼正確的時候，直接跳出while循環
else:
print("密碼錯誤")
a += 1
應用舉例②：
for a in range(1, 11):
if a % 2 == 0:
print(a) # 只輸出一次
break
continue語句
continue語句用於結束當前循環，執行下一次循環；一般搭配 if 使用
應用舉例：
for a in range(1, 11):
if a % 2 != 0:
continue # 第一個數不是2的倍數，跳出a=1的循環，進行a=2的循環
else:
print(a)
else的三種應用
if…else
應用舉例：
if a < 10:
pass
else:
pass
for…in…else
應用舉例：
# 九九乘法表
for a in range(1, 10):
for b in range(1, a + 1):
print(a, '*', b, '=', a * b, end='\t')
print()
else:
print("打印完畢") # 執行完第一個for...in之後，就執行這個else
while…else
應用舉例：
a = 0
while a < 3:
str = input("請輸入密碼:")
if str == "8888":
print('密碼正確')
break # 當密碼正確的時候，直接跳出while循環
else:
print("密碼錯誤")
a += 1
else:
print("三次密碼都錯誤") # 跳出while循環之後，執行這個else語句
Python中的列表和數組很相似，但是列表存儲的對象的類型可以不一樣，而數組存儲的對象類型一樣
列表的特點： 1）列表元素按順序有序排序 2）索引映射唯一數據 3）列表可以存儲重復數據 4）任意數據類型混存 5）根據需要動態分配和回收內存 6）列表是一個可變序列
列表在內存中的存儲方式
使用中括號 [ ]
# 用中括號創建列表
List = ['hello', 1, 90, 'world']
print(List) # ['hello', 1, 90, 'wordl']
print(List[2]) # 90 順序索引: 'hello'的索引值0，1的索引值為1，以此類推
print(List[-1]) # world 逆序索引：'world'的索引值為-1，90的索引值為-2，以此類推
使用內置函數list（）
# 用list()函數
# 該方法和使用中括號的效果一樣
List = list(['hello', 1, 90, 'world'])
print(List) # ['hello', 1, 90, 'world']
# 如果list()裡面放的是字符串，那麼list()函數會將字符串分割為一個字符分別存儲到列表中
List2 = list('hello world')
print(List2) # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
List3 = list('123456')
print(List3) # ['1', '2', '3', '4', '5', '6']
# list()函數也可以搭配range()函數創建
List4 = list(range(1, 10, 2))
print(List4) # [1, 3, 5, 7, 9]
使用列表生成式
# 列表生成式
List = [i for i in range(1, 10, 1)]
print(List) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
查詢元素索引（使用 index（）方法）
#List.index(對象值)
List = list(['hello', 1, 90, 'world', 'hello'])
print(List.index('hello')) # 0 ;若列表中存在重復值，則只輸出查找到的第一個索引值（順序索引）
print(List.index(1)) # 1
獲取單個元素（通過元素索引查詢）
元素索引分為順序和逆序，順序的索引從0開始，到N-1結束；逆序的索引從 -1 開始
# 用中括號創建列表
List = ['hello', 1, 90, 'world']
print(List) # ['hello', 1, 90, 'world']
print(List[2]) # 90 順序索引: ' hello '的索引值0，1的索引值為1，以此類推
print(List[-1]) # world 逆序索引：' world '的索引值為-1，90的索引值為-2，以此類推
獲取多個元素
# 切片語法結構
# 列表名[start : stop :step]
# 切片所使用的索引號為順序索引號，從0開始，N+1結束
List = [10, 20, 30, 40, 50, 60]
# 步長為正數
list1 = List[1:5:] # 不標明step，步長默認為1，從索引號1開始，一直到索引號4結束，順序切割
print(list1) # [20, 30, 40, 50]
list2 = List[:5:2] # 不標明start，則默認從索引號為0的開始,步長為2
print(list2) # [10, 30, 50]
list3 = List[1::1] # 不標名stop，則默認到最後一個索引結束
print(list3) # [20, 30, 40, 50, 60]
# 步長為負數
# 由於不標明的step默認值為1，所以在逆序切片的時候一定要標明step值
list4 = List[5::-1] # 不標明stop,從索引號為5的元素開始往左切片（逆序切片）,切到最後一個索引
print(list4) # [60, 50, 40, 30, 20, 10]
list5 = List[:1:-2] # 不標明start，默認從最後一個元素開始切片（步長為負數，逆序切片）
print(list5) # [60, 40]
list6 = List[5:0:] # 不標明step，默認步長為1，由於start為5大於stop0，故切出來的是空列表
print(list6) # []
查詢該元素是否在列表中（in / not in）
# 使用 in/not in 判斷
List2 = [10, 20, 'hello', 'world']
print(10 in List2) # True
print(100 not in List2) # True
print("Hello" in List2) # False
print("hello" in List2) # True
增加元素
使用 append（）方法
# append()方法 在原列表的末尾添加一個元素
list1 = [10, 20, 'Hello']
list1.append(100)
print(list1) # [10, 20, 'Hello', 100]
list1.append("world")
print(list1) # [10, 20, 'Hello', 100, 'world']
lis = [10, 20]
list1.append(lis) # 將lis當作一個元素添加到列表尾部
print(list1) # [10, 20, 'Hello', 100, 'world', [10, 20]]
使用 extend（）方法
# extend()方法 在列表的末尾添加至少一個元素
list2 = [10, 20, 'Hello']
lis = ['world', 100]
list2.extend(lis)
print(list2) # [10, 20, 'Hello', 'world', 100]
使用 insert（）方法
# insert()方法 在列表的任意位置添加一個元素
list3 = [10, 20, 'Hello']
list3.insert(1, 'world') # 在索引為1的位置上添加'world'
print(list3) # [10, 'world', 20, 'Hello']
切片
# 切片在列表任意位置添加至少一個元素
list4 = [10, 20, 'Hello', "world1", 99]
lis = [1, "world2", 100]
# 順序切片（步長為1）添加多少個元素都行
# list4[1:3]=lis #從索引號1開始，將索引號為1，2的元素刪掉，並將lis中的元素放進去
# 輸出為 [10, 1, 'world2', 100, 'world1', 99]
# list4[1::1]=lis #從索引號1開始，將後面的所有元素切掉，並且將切掉的元素更改為lis列表中的元素
# 輸出為[10, 1, 'world2', 100]
# 間隔切片（步長不為1）的時候；逆序切片（步長為負數）時，切掉多少個元素，只能放多少個元素進去（不能多，不能少）
# 順序切片只能順序放入元素
# 逆序切片只能逆序放入元素
# list4[0:3:2]=lis
# 報錯，因為lis列表裡有三個元素，而切片只切掉了索引號為0，2的元素，位置不夠
# list4[0::2]=lis #從索引號0開始，因為只把索引號為0，2，4的元素切掉，所以只能插入三個元素
# 輸出為[1, 20, 'world2', 'world1', 100]
# list4[4::-2]=lis #從索引號4開始，逆序切片，把索引號為4，2，0的元素切掉
# 輸出為[100, 20, 'world2', 'world1', 1]，注意，逆序放入的！
# list4[:0:-1]=lis #從最後一個索引號開始，將索引號為5，4，3，2，1的元素切掉，但是由於是逆序，所以前面只能放四個元素
# 報錯，因為lis列表裡面只有三個元素，而切片切掉了四個元素
print(list4)
刪除元素
使用 remove（）方法
# remove()方法
# 一次只移除一個元素
List1 = [10, 20, 30, 40, 50, 60, 30]
List1.remove(30)
print(List1) # [10, 20, 40, 50, 60, 30] 只移除了20後面的30
# 如果需要移除的元素不在列表裡面，則會報錯
List1.remove(100) # ValueError: list.remove(x): x not in list
使用 pop（）方法
# pop()方法
# 刪除指定元素
List2 = [10, 20, 30, 40, 30]
List2.pop(1) # [10, 30, 40, 30] 20的索引為1，移除了20
print(List2)
# 指定索引不存在
List2.pop(5) # IndexError: pop index out of range
List2.pop() # [10, 30, 40] 移除了最後一個30
print(List2)
使用 clear（）方法
# clear()方法
# 清空列表所有元素
List4 = [1, 2, 3]
List4.clear()
print(List4) # []
使用 del語句
# def()語句
# 刪除列表對象
List5 = [1, 2, 3, 4]
del List5
print(List5) # NameError: name 'List5' is not defined
切片
# 切片
# 刪除至少一個元素
List3 = [10, 20, 30, 40, 60, 20]
# 連續刪除元素
List3[1:3:1] = [] # 將需要刪除的元素用空列表代替
print(List3) # [10, 40, 60, 20]，將索引號為1和2的元素刪除
# 間隔刪除元素（不可行）
# 刪除不了，會報錯 ValueError: attempt to assign sequence of size 0 to extended slice of size 2
# List3[1:5:2] = []
修改元素
通過索引
# 通過索引
List1 = [1, 2, 3, 50]
List1[2] = 30 # 將索引號為2的元素替換為30
print(List1) # [1, 2, 30, 50]
切片
# 切片
List2 = [1, 30, 1, 50]
# 順序切除（步長為1）
List2[1:3] = [100, 200, 300, 440] # 將切除的位置放入新元素
print(List2) # [1, 100, 200, 300, 440, 50]
使用sort（）方法
在原列表上進行操作，不產生新的列表對象
# sort()方法，默認升序排序
list1 = [1, 3, 8, 10, 14]
list1.sort()
print(list1) # [1, 3, 8, 10, 14]
# 當reverse為True時，進行降序排序，若不指定reverse，則默認值為False
list1.sort(reverse=True) # 降序排序
print(list1) # [14, 10, 8, 3, 1]
使用內置函數：sorted（）
排序會產生新的列表對象
# 調用內置函數sorted()，默認升序排序
list2 = [10, 11, 1, 0, 2, 4, 20]
new_list = sorted(list2)
print(list2) # [10, 11, 1, 0, 2, 4, 20]
print(new_list) # [0, 1, 2, 4, 10, 11, 20]
# 當reverse為True時，進行降序排序，若不指定reverse，則默認值為False
new_list = sorted(list2, reverse=True)
print(new_list) # [20, 11, 10, 4, 2, 1, 0]
使用花括號 { }
# 使用花括號
# {key:value,key:value}
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十', '李六': '九十'}
score2 = {} # 空字典
print(score, type(score)) # {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'} <class 'dict'>
使用內置函數dict()
# 使用dict()函數
# dict(key=value)
people = dict(name='zhang', age=100, address='beijing')
print(people, type(people)) # {'name': 'zhang', 'age': 100, 'address': 'beijing'} <class 'dict'>
使用字典生成式
內置函數zip ( )
# 內置函數zip()
Fruits = ['apple', 'orange', 'banana']
Numbers = [100, 200, 101]
new_dict = zip(Fruits, Numbers)
print(list(new_dict)) # 要轉化為列表才能輸出，因為zip()返回的是“由這些元組組成的列表”
for…in…
# 字典生成式
Fruits = ['apple', 'orange', 'banana']
Numbers = [100, 200, 101]
A = {Fruits: Numbers for Fruits, Numbers in zip(Fruits, Numbers)}
print(A)
# 如果兩個字典中的元素不相等,則以短的字典為主
Tools = ['rule', 'desk', 'pen']
Prices = [100, 10, 20, 30, 102]
B = {Tools: Prices for Tools, Prices in zip(Tools, Prices)}
print(B) # {'rule': 100, 'desk': 10, 'pen': 20}
使用[ ]
# 使用[]
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
print(score['張三']) # 通過key值查詢相應的value值 100
# print(score['zhang']) # 查找的key值不存在，拋出 KeyError: 'zhang'
使用get( )
# 使用get(),get(key,self)
print(score.get('李四')) # 通過key值查詢相應的value值 90
print(score.get('zhang', 99)) # 查找相應的鍵值不存在，返回默認值99
print(score.get('zhang')) # 查找相應的鍵值不存在，返回None
key的判斷
# in / not in
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
print('zhang' in score) # False
print('張三' not in score) # False
字典元素的增加
# 字典元素的添加
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
score['成七'] = 88
print(score) # {'張三': 100, '李四': 90, '王五': 80, '李六': '九十', '成七': 88}
字典元素的刪除
del
# 字典元素的刪除
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
del score['張三'] # 通過指定key刪除鍵值對
print(score) # {'李四': 90, '王五': 80, '李六': '九十'}
clear ( )
# 清空字典元素
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
score.clear()
print(score) # {}
字典元素的修改
# 字典元素的修改
score = {'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
score['成七'] = 400
print(score) # {'張三': 100, '李四': 90, '王五': 80, '李六': '九十', '成七': 400}
key ( )
# 獲取字典中的所有key
score = {'張三': 100, '李四': 90, '王五': 80, '李六': 100}
print(score.keys()) # dict_keys(['張三', '李四', '王五', '李六'])
print(type(score.keys())) # <class 'dict_keys'>
# 將key轉化成列表
print(list(score.keys())) # ['張三', '李四', '王五', '李六']
value ( )
# 獲取字典中的所有value
score = {
'張三': 100, '李四': 90, '王五': 80, '李六': '九十'}
print(score.values()) # dict_values([100, 90, 80, '九十'])
print(type(score.values())) # <class 'dict_values'>
# 將value轉化成列表
print(list(score.values())) # [100, 90, 80, '九十']
items ( )
# 獲取字典中的所有鍵值對
score = {
'張三': 100, '李四': 90, '王五': 80, '李六': 100}
print(score.items()) # dict_items([('張三', 100), ('李四', 90), ('王五', 80), ('李六', 100)])
print(type(score.items())) # <class 'dict_items'>
# 將鍵值對轉化為列表
print(list(score.items())) # [('張三', 100), ('李四', 90), ('王五', 80), ('李六', 100)]
# 字典元素的遍歷
score = {'張三': 100, '李四': 90, '王五': 80, '李六': 100}
for i in score:
print(i) # 獲取key
print(score[i]) # 獲取values
print(score.get(i)) # 獲取values
元組是Python內置的數據結構之一，是一個不可變序列
元組是元素不可變、元素可重復、元素有序排列的數據結構（不可以進行增、刪、改）
將元組設計成不可變序列的好處：在多任務環境下，同時操作對象時不需要加鎖
元組中存儲的是對象的應用，如果元組中對象本身不可變，則不能在引用其他對象；如果元組中的對象可變，則可變對象的引用不允許改變，但是數據可以改變
# 元組是不可變序列
A1 = (10, [10, 20], 30)
# A1[1]=10 # TypeError: 'tuple' object does not support item assignment
# 但是可以修改列表[10,20]
A1[1].append(101)
print(A1) # (10, [10, 20, 101], 30)
使用 ( )
# 使用()
A = ('Python', 10, 'Hello', 'Wordl')
print(A, type(A)) # ('Python', 10, 'Hello', 'Wordl') <class 'tuple'>
# ()也可以省略
C = 'Hello', 'Worle', 100
print(C, type(C)) # ('Hello', 'Worle', 100) <class 'tuple'>
# 當元組中只有一個元素的時候，要在該元素後面添加逗號
D = ('Hello',)
F = 'HELLO',
E = ('World')
print(D, type(D)) # ('Hello',) <class 'tuple'>
print(E, type(E)) # World <class 'str'>
print(F, type(F)) # ('HELLO',) <class 'tuple'>
# 空元組
G = ()
H = tuple()
使用內置函數tuple ( )
# 使用內置函數tuple()
B = tuple(('Hello', 'World', 100))
print(B, type(B)) # ('Hello', 'World', 100) <class 'tuple'>
使用for…in…
# 元組的遍歷
B1 = ('Hello', 'World', 10)
for i in B1:
print(i) # Hello World 10
使用索引
# 元組的遍歷
C1 = (10, 20, 30)
print(C1[1]) # 20
使用 { }
# 使用 { }
A = {1, 2, 'Hello'}
# 體現集合是無序序列
print(A, type(A)) # {1, 2, 'Hello'} <class 'set'>
使用內置函數set ( )
# 內置函數set()
B = set({1, 'Hello'})
print(B, type(B)) # {1, 'Hello'} <class 'set'>
C = set(range(5))
print(C, type(C)) # {0, 1, 2, 3, 4} <class 'set'>
D = set([1, 2, 3, 4])
print(D, type(D)) # {1, 2, 3, 4} <class 'set'>
E = set(('hello', 20))
print(E, type(E)) # {'hello', 20} <class 'set'>
F = set('Python')
print(F, type(F)) # {'y', 'o', 'P', 'n', 'h', 't'} <class 'set'>
# 空集合
G1 = {} # 這個是定義空字典
G = set()
print(G, type(G)) # set() <class 'set'>
使用集合生成式
# 集合生成式
A = {
i * i for i in range(1, 10)}
print(A) # 無序排序 {64, 1, 4, 36, 9, 16, 49, 81, 25}
集合元素的判斷
# in或not in
A1 = {
11, 22, 'Hello'}
print(11 in A1) # True
print('HELLO' in A1) # False
集合元素的增加
add ( )
# add() 一次添加一個元素
B1 = {
1, 2, 3}
B1.add(80)
print(B1) # {80, 1, 2, 3}
update ( )
# update() 至少添加一個元素
C1 = {
1, 2, 3}
C1.update({
22, 33})
C1.update([44, 55])
C1.update((66, 77))
print(C1) # {1, 2, 3, 66, 77, 22, 33, 44, 55}
集合元素的刪除
remove ( )
# remove() 一次刪除一個指定元素
D1 = {1, 2, 3}
D1.remove(1) # {2, 3}
print(D1)
# D1.remove(100) #KeyError: 100
discard ( )
# discard() 一次刪除一個指定元素
E1 = {11, 22, 10}
E1.discard(11)
print(E1) # {10, 22}
E1.discard(100) # 移除不存在的元素不會報錯
pop ( )
# pop() 一次只刪除一個元素,該元素索引號為0
F1 = {11, 12, 13}
# F1.pop(11) #報錯,pop()不可指定參數
print(F1) # {11, 12, 13}
F1.pop()
print(F1) # {12, 13}
F1.pop()
print(F1) # {13}
clear ( )
# clear() 清空集合
G1 = {
11, 22}
print(G1) # {11, 22}
G1.clear()
print(G1) # set(),空集合
是否相等
# 兩個集合是否相等
A = {40, 10, 20, 30}
B = {30, 20, 10, 40}
print(A == B) # True
print(A != B) # False
A是否是B的子集
# A是否為B的子集
C = {
11, 22, 33}
D = {
33}
print(D.issubset(C)) # True D是C的子集
A是否是B的超集
# A是否為B的超集
# 子集與超集的概念剛好相反
C = {11, 22, 33}
D = {33}
print(C.issuperset(D)) # True C是D的超集
是否沒有交集
# A與B是否沒有交集
C = {
11, 22, 33}
D = {
33}
print(C.isdisjoint(D)) # False C與D有交集
交集
# 交集
C = {
11, 22, 33}
D = {
33}
print(C.intersection(D)) # {33}
print(C & D) # {33}
# 集合並沒有發生改變
print(C) # {33, 11, 22}
print(D) # {33}
並集
# 並集
C = {
11, 22, 33}
D = {
33, 44}
print(C.union(D)) # {33, 22, 11, 44}
print(C | D) # {33, 22, 11, 44}
差集
# 差集
C = {
11, 22, 33}
D = {
33, 44}
print(C.difference(D)) # 屬於C但不屬於D的元素 {11, 22}
print(C - D) # {11, 22}
對稱差集
# 對稱差集
C = {
11, 22, 33}
D = {
33, 44}
print(C.symmetric_difference(D)) # 並集-交集 {11, 44, 22}
print(C ^ D) # {11, 44, 22}
print(F1) # {13}
```
clear ( )
# clear() 清空集合
G1 = {
11, 22}
print(G1) # {11, 22}
G1.clear()
print(G1) # set(),空集合
是否相等
# 兩個集合是否相等
A = {40, 10, 20, 30}
B = {30, 20, 10, 40}
print(A == B) # True
print(A != B) # False
A是否是B的子集
# A是否為B的子集
C = {
11, 22, 33}
D = {
33}
print(D.issubset(C)) # True D是C的子集
A是否是B的超集
# A是否為B的超集
# 子集與超集的概念剛好相反
C = {11, 22, 33}
D = {33}
print(C.issuperset(D)) # True C是D的超集
是否沒有交集
# A與B是否沒有交集
C = {
11, 22, 33}
D = {
33}
print(C.isdisjoint(D)) # False C與D有交集
交集
# 交集
C = {
11, 22, 33}
D = {
33}
print(C.intersection(D)) # {33}
print(C & D) # {33}
# 集合並沒有發生改變
print(C) # {33, 11, 22}
print(D) # {33}
並集
# 並集
C = {
11, 22, 33}
D = {
33, 44}
print(C.union(D)) # {33, 22, 11, 44}
print(C | D) # {33, 22, 11, 44}
差集
# 差集
C = {
11, 22, 33}
D = {
33, 44}
print(C.difference(D)) # 屬於C但不屬於D的元素 {11, 22}
print(C - D) # {11, 22}
對稱差集
# 對稱差集
C = {
11, 22, 33}
D = {
33, 44}
print(C.symmetric_difference(D)) # 並集-交集 {11, 44, 22}
print(C ^ D) # {11, 44, 22}
