您好！此筆記的文本和代碼以網盤形式分享於文末！
因個人能力有限，錯誤處歡迎大家交流和指正！基礎部分內容簡單，但多且零散！
| Python數據類型二 | ||
| 1、數字（int、float、complex）數字數據類型用於存儲數值，數字類型是不允許改變的， 改變數值需重新分配內存空間 |
||
| int：整型，正或負整數 | ||
| float：浮點型，由整數部分與小數部分組成 | ||
| complex：複數，由實數部分和虛數部分構成,複數的實部和虛部都是浮點型 | ||
| 用法 | 栗子 | 結果 |
| 十六進制和八進制 | a = 0x0F # 十六進制 b = 0o17 # 八進制 print(a, b) |
15 15 |
| .bit_length() | # int類型 轉換爲二進制的至少有效位數 a = 1 b = 2 c = 4 d = 8 e = 15 print(a.bit_length(), b.bit_length(), c.bit_length(), d.bit_length(), e.bit_length()) |
1 2 3 4 4 |
| 數字類型轉換 | x = 18 y = 2 z = 19.535 p = 19.435 print(int(z), int(p), float(x), complex(x), complex(x, y)) |
19 19 18.0 (18+0j) (18+2j) |
| 2、布爾值（bool）布爾值僅有Ture和False兩種；反應條件的正確與否， | ||
| 用法 | 栗子 | 結果 |
| int ---> bool | # 非零即True，零即False a = 100 b = 0 print(bool(a), bool(b)) |
True False |
| bool ---> int | # True就是1，False就是零 a = True b = False print(int(a), int(b)) |
1 0 |
| str ---> bool | # 非空即True 空即False s1 = 'trglion' s2 = '' print(bool(s1), bool(s2)) |
True False |
| bool ---> str | a = True b = False c = str(a) d = str(b) print(a, c, b, d, type(a), type(c)) |
True True False False <class 'bool'> <class 'str'> |
| int ---> str | a = 108 b = str(a) print(a, b, type(a), type(b)) |
108 108 <class 'int'> <class 'str'> |
| str ---> int | # 必須是數字組成的字符串才能轉換 s1 = '109' b = int(s1) print(s1, b, type(s1), type(b)) |
109 109 <class 'str'> <class 'int'> |
| 3、字符串（str） 用引號引起來的數據可以稱爲字符串類型，存儲少量數據， 組成字符串的每個元素稱之爲字符 |
||
| 用法 | 栗子 | 結果 |
| 索引 | # 索引,下標從0開始 # s1 = 'six六6' 共有5個字符 s1 = 'six六6' print(s1[0], s1[2], s1[-1], s1[-2]) |
s x 6 六 |
| 切片 | # 切片，截取一段字符串成新字符串 # 取值範圍： a =< x < b s1 = 'six六6777seven7七666' print(s1[:5]) # 從零開始可不寫 print(s1[2:5], s1[:], s1[:-1]) print(s1[0:6:3]) # 其中3爲間隔字符步長 print(s1[-1:-7:-2]) # 其中-2 爲反向步長 # 避免s1[:7:-3]、s1[-1:-5]、s1[-1:0]、s1[-1:-7:3]等這些形式 |
six六6 x六6 six六6777seven7七666 six六6777seven7七66 s六 667 |
| 僅首字母大寫 .capitalize() |
s2 = s1.capitalize() print(s2) |
Six六6777seven7七666 |
| 字母全部大寫 .upper() |
s2 = s1.upper() print(s2) |
SIX六6777SEVEN7七666 |
| 字母全部小寫 .lower() |
s3 = "sixSEVENSIX" s2 = s3.lower() print(s2) |
sixsevensix |
| 字母大小寫翻轉 .swapcase() |
s2 = s3.swapcase() print(s2) |
SIXsevensix |
| 標題模式 .title() |
# 標題方式，單詞首字母大寫 s4 = "disc on the app of multi" s2 = s4.title() print(s2) |
Disc On The App Of Multi |
| 居中，自動填充 .center() |
s5 = "trglion" s2 = s5.center(20, "*") # 20爲總字符個數 print(s2) |
******trglion******* |
| 是否僅有數字組成 .isdigit() |
ret1 = s1.isdigit() print(ret1) |
FALSE |
| 是否僅字母組成 .isalpha() |
ret1 = s1.isalpha() print(ret1) |
FALSE |
| 字符數 len() |
# 字符串的字符數 a = len(s1) print(a) |
18 |
| 某元素的個數 .count() |
# 字符串中元素出現的個數 ret1 = s1.count("e") ret2 = s1.count("e", 0, 10) ret3 = s1.count("e", -1, -10) # 不要使用這種格式 print(ret1, ret2, ret3) |
2 1 0 |
| 否以…開頭或結尾 .startswith() .endswith() |
# 判斷字符串是否以…開頭或結尾 ret1 = s1.startswith("si") ret2 = s1.endswith("666") ret3 = s1.endswith("666", 10, 17) # 切片的取值範圍 print(ret1, ret2, ret3) |
True True False |
| 切分 以…爲分割爲一個列表 .split() |
# 以…爲分割且形成一個列表 ret1 = s1.split("6") ret2 = s1.split("6", 1) # 其中1爲分割次數 ret3 = s1.split("6", 2) ret4 = s1.split("6", 3) ret5 = s1.split("6", 3)[0] print(ret1, type(ret1)) print(ret2) print(ret3) print(ret4) print(ret5, type(ret5)) |
['six六', '777seven7七', '', '', ''] <class 'list'> ['six六', '777seven7七666'] ['six六', '777seven7七', '66'] ['six六', '777seven7七', '', '6'] six六 <class 'str'> |
| 查找元素 .find() |
# 查找元素，返回索引，找不到返回-1 a = s1.find("s") b = s1.find("A") print(a, b, type(a), type(b)) |
0 -1 <class 'int'> <class 'int'> |
| 查找元素 .find() |
# 查找元素，返回索引，找不到報錯 a = s1.index("s") print(a, type(a)) |
0 <class 'int'> |
| 去除指定字符 .strip() |
# strip 默認去除字符串首尾空格 # 去除指定字符， s6 = " x 567 x " s7 = "six666SEVEN77si" s2 = s6.strip() sa = s7.strip("7") sb = s7.strip("6") sc = s7.strip("si") se = s7.rstrip("si") # 自左刪除 sd = s7.lstrip("si") # 自右刪除 print(s2, sa, sb, sc, se, sd) |
x 567 x six666SEVEN77si six666SEVEN77si x666SEVEN77 six666SEVEN77 x666SEVEN77si |
| 替換相關字符 .replace(old,new,count) |
sa = s1.replace("6", "8", 1) sb = s1.replace("6", "8", 2) sc = s1.replace("6", "8", 5) print(sa, sb, sc) |
six六8777seven7七666 six六8777seven7七866 six六8777seven7七888 |
| 格式化輸出 format 這幾個字符串輸出的內容是一樣的 |
sx = "我是{}，我在{}，我學{}, I am {}".format("trglion", "上海", "python", "trglion") sy = "我是{0}，我在{1}，我學{2}, I am {0}".format("trglion", "上海", "python") sz = "我是{name}，我在{city}，我學{tech}, I am {name}".format(name="trglion", city="上海", tech="python") name = input('請輸入名字：') sn = "我是{name}，我在{city}，我學{tech}, I am {name}".format(name=name, city="上海", tech="python") print(sx, sy, sz, sn) |
我是trglion，我在上海，我學python, I am trglion |
| 4、列表(list) 屬於容器類的數據類型，可以存儲稍大量的數據 | ||
| 用法 | 栗子 | 結果 |
| 創建列表 | li = [123, "trglion", "天涯社區", [1, 'abs', '小明13歲'], "Lilei12"] | |
| 索引 | l1 = li[0] l2 = li[3] l3 = li[3][2] print(l1, type(l1)) print(l2, type(l2)) print(l3, type(l3)) |
123 <class 'int'> [1, 'abs', '小明13歲'] <class 'list'> 小明13歲 <class 'str'> |
| 切片 | l1 = li[0:3] l2 = li[0:6:2] l3 = li[-1:-6:-2] print(l1, l2, l3) |
[123, 'trglion', '天涯社區'] [123, '天涯社區', 'Lilei12'] ['Lilei12', '天涯社區', 123] |
| 追加 .append 在最後追加元素 |
li.append(456) li.append([7, '1a']) print(li) |
[123, 'trglion', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12', 456, [7, '1a']] |
| 迭代追加 .extend 在最後迭代追加元素 |
li.extend(["8e", [1, '9F']]) li.extend("王7D") print(li) |
[123, 'trglion', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12', '8e', [1, '9F'], '王', '7', 'D'] |
| 插入 .insert 在任意位置插入元素 |
li.insert(2, '2c') print(li) |
[123, 'trglion', '2c', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 刪除 .pop 通過索引刪除 並返回被刪除元素 |
ret = li.pop(2) print(ret, li) |
天涯社區 [123, 'trglion', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 刪除. .remove 通過元素刪除 無此元素則報錯 |
li.remove(123) li.remove("Lilei12") print(li) |
['trglion', '天涯社區', [1, 'abs', '小明13歲']] |
| 清空列表 clear |
li.clear() print(li, type(li)) |
[] <class 'list'> |
| 索引刪除 不能刪除li[3]中的元素 |
del li[3] print(li) |
[123, 'trglion', '天涯社區', 'Lilei12'] |
| 切片刪除 | del li[0:2] print(li) |
['天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 切片(步長)刪除 | del li[::2] print(li) |
['trglion', [1, 'abs', '小明13歲']] |
| 改 按索引改 |
li[1] = "tianya" print(li) |
[123, 'tianya', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 改 按切片改 |
li[1:3] = "王7De[2,c]" print(li) |
[123, '王', '7', 'D', 'e', '[', '2', ',', 'c', ']', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 改 按照切片（步長） 必須一一對應 |
li[::2] = "對應值" print(li) |
['對', 'trglion', '應', [1, 'abs', '小明13歲'], '值'] |
| 查 切片和 循環 |
for i in li: print(i) print(li[0:2]) |
123 trglion 天涯社區 [1, 'abs', '小明13歲'] Lilei12 [123, 'trglion'] |
| 查看元素的個數 len() |
ret = len(li) print(ret) |
5 |
| 淺拷貝 .copy |
l1 = li.copy() print(l1) |
[123, 'trglion', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] |
| 查看某個元素出現次數 .count |
print(li.count("i")) l1 = ['t', 'r', 'g', 'l', 'i', 'o', 'n'] print(l1.count("i")) |
0 1 |
| 找出某元素的索引 無此元素則報錯 .index |
ret = li.index(123) ret1 = li.index("trglion") print(ret, ret1) |
0 1 |
| 排序 正向排序 僅適字符串和整型元素 |
l1 = ['c', 'f', 'b', 'a', 'e', 'dog'] l1.sort() print(l1) l2 = [1, 0, 8, 9, 10, 7] l2.sort() print(l2) |
['a', 'b', 'c', 'dog', 'e', 'f'] [0, 1, 7, 8, 9, 10] |
| 倒序 reverse = True |
l2 = [1, 0, 8, 9, 10, 7] l2.sort(reverse=True) print(l2) |
[10, 9, 8, 7, 1, 0] |
| 反轉 .reverse |
l2 = [1, 0, 8, 9, 10, 7] l2.reverse() print(l2) |
[7, 10, 9, 8, 0, 1] |
| 列表的相乘和相加 | l1 = [1, 'a'] l2 = [5, 'b', [2, '3C']] print(l1+l2) print(l2+l1) print(l1*3) |
[1, 'a', 5, 'b', [2, '3C']] [5, 'b', [2, '3C'], 1, 'a'] [1, 'a', 1, 'a', 1, 'a'] |
| 列表的嵌套 | print(li[1][2]) li[1] = li[1].capitalize() print(li) print(li[2].replace("社區", "論壇")) print(li) li[2] = li[2].replace("社區", "論壇") print(li) li[3][1] = li[3][1].upper() print(li) |
g [123, 'Trglion', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] 天涯論壇 [123, 'Trglion', '天涯社區', [1, 'abs', '小明13歲'], 'Lilei12'] [123, 'Trglion', '天涯論壇', [1, 'abs', '小明13歲'], 'Lilei12'] [123, 'Trglion', '天涯論壇', [1, 'ABS', '小明13歲'], 'Lilei12'] |
| 字符串與列表 | s = 'lion' s1 = 'trg'.join(s) print(s1) li = ["123", 'tan', "天Ya5"] s2 = '++'.join(li) print(s2) |
ltrgitrgotrgn 123++tan++天Ya5 |
| 5、元組 tuple：容器類的數據類型，存儲稍大量的數據，是元素不可增刪改的列表， 元素不可以改，但是元素的“元素(非元組)”可以修改 |
||
| 用法 | 栗子 | 結果 |
| 元組的創建 | tu = (123, "Lion", "4R9f6e", [1, 'LeeLei', '3c6E'], 'Lion') | |
| 索引 | print(tu[0], type(tu[0])) print(tu[1][2], type(tu[1][2])) print(tu[2][0], type(tu[2][0])) print(tu[2][1], type(tu[2][1])) |
123 <class 'int'> o <class 'str'> 4 <class 'str'> R <class 'str'> |
| 切片 | print(tu[0:3]) print(tu[::2]) print(tu[::-2]) |
(123, 'Lion', '4R9f6e') (123, '4R9f6e', 'Lion') ('Lion', '4R9f6e', 123) |
| 循環 | for i in tu: print(i) |
123 Lion 4R9f6e [1, 'LeeLei', '3c6E'] Lion |
| 查找元素索引 .index |
ret = tu.index(123) ret1 = tu.index("Lion") print(ret, ret1) |
0 1 |
| 查找元素的出現次數 .count |
tu = (123, "Lion", "3c6E", [1, 'LeeLei', '3c6E'], 'Lion') ret = tu.count("3c6E") ret1 = tu.count('Lion') print(ret, ret1) |
1 2 |
| 查看元素的個數 len() |
print(len(tu)) | 5 |
| 元素的“元素”可變 | tu[3][1] = tu[3][1].upper() print(tu) tu[3].append("Trg") print(tu) |
(123, 'Lion', '3c6E', [1, 'LEELEI', '3c6E'], 'Lion') (123, 'Lion', '3c6E', [1, 'LEELEI', '3c6E', 'Trg'], 'Lion') |
| 6、字典dict：容器型的數據類型，按照鍵值對的方式存儲關係型數據，其中key是不可變數據類型， 且唯一不可重複；Value任意數據，py3.6後字典爲第一次插入的順序。 |
||
| 不可變（可哈希）的數據類型：int，str，bool，tuple。可變（不可哈希）的數據類型：list，dict，set。 | ||
| 用法 | 栗子 | 結果 |
| 字典的創建 | dic = {'name': 'Lion', 'age': '8', 'sex': 'Male'} | |
| 增 鍵值對直接增加 無則增加，有則變值 |
dic['weight'] = 300 dic['age'] = 9 print(dic) |
{'name': 'Lion', 'age': 9, 'sex': 'Male', 'weight': 300} |
| 增 .setdefault 無則增加，有則不動作 |
dic.setdefault('weight', '300') dic.setdefault('age', '9') ret = dic.setdefault('age') print(dic, ret) |
{'name': 'Lion', 'age': '8', 'sex': 'Male', 'weight': '300'} 8 |
| 刪 .pop 刪除相應鍵值對， 返回鍵值對的值； 無鍵值對則無動作， 可設置返回值 |
ret1 = dic.pop('name') print(ret1, dic) ret2 = dic.pop('n', None) print(ret2, dic) ret3 = dic.pop('age', None) print(ret3, dic) |
Lion {'age': '8', 'sex': 'Male'} None {'age': '8', 'sex': 'Male'} 8 {'sex': 'Male'} |
| 刪 .popitem py3.6後爲刪除最後一個 有返回值 |
ret1 = dic.popitem() print(ret1, type(ret1), dic) |
('sex', 'Male') <class 'tuple'> {'name': 'Lion', 'age': '8'} |
| 刪 del 無保留刪除 |
del dic['name'] print(dic) del dic # 將字典無保留刪除 # print(dic) # 報錯 |
{'age': '8', 'sex': 'Male'} |
| 刪 .clear 清空字典 |
dic.clear() print(dic) |
{} |
| 改 通過鍵值對改值 |
dic['age'] = 7 print(dic) |
{'name': 'Lion', 'age': 7, 'sex': 'Male'} |
| 改 .update 字典升級 |
dic.update(sex='Female', height='100') print(dic) dic.update([('sex', '男'), ('weight', '300')]) print(dic) dic1 = {'age': '6', 'sex': 'Male', 'color': 'brown'} dic.update(dic1) print(dic) |
{'name': 'Lion', 'age': '8', 'sex': 'Female', 'height': '100'} {'name': 'Lion', 'age': '8', 'sex': '男', 'height': '100', 'weight': '300'} {'name': 'Lion', 'age': '6', 'sex': 'Male', 'height': '100', 'weight': '300', 'color': 'brown'} |
| 查 查看字典的鍵、值、 鍵和值； |
print(dic.keys(), type(dic.keys())) print(dic.values()) print(dic.items()) |
dict_keys(['name', 'age', 'sex']) <class 'dict_keys'> dict_values(['Lion', '8', 'Male']) dict_items([('name', 'Lion'), ('age', '8'), ('sex', 'Male')]) |
| 查看鍵和值 | for k, v in dic.items(): print(k, v) |
name Lion age 8 sex Male |
| 查看鍵和值 以元組形式 |
for i in dic.items(): print(i) |
('name', 'Lion') ('age', '8') ('sex', 'Male') |
| 查 通過鍵查詢， 無此鍵則報錯 |
v = dic['name'] print(v) |
Lion |
| 查 .get 可設置返回值 |
print(dic.get('sex')) v = dic.get('age') print(v) v1 = dic.get('name') print(v1) v2 = dic.get('name1') print(v2) v3 = dic.get('name2', '無此名') print(v3) |
Male 8 Lion None 無此名 |
| 創建字典 .fromkeys |
dic1 = dict.fromkeys('abcd', 'Lion') print(dic1) dic2 = dict.fromkeys([1, 2, 3, 4], 'Lion') print(dic2) |
{'a': 'Lion', 'b': 'Lion', 'c': 'Lion', 'd': 'Lion'} {1: 'Lion', 2: 'Lion', 3: 'Lion', 4: 'Lion'} |
| 字典的嵌套 1、獲取獅王第一個孩子的名字 2、添加獅王的第三個孩子的信息 |
dic1 = { 'name': 'LionKing', 'age': '7', 'children': [{'first': 'XiaoMing', 'age': '3', }, {'second': 'XiaoHong', 'sex': 'Female'}] } v1 = dic1['children'] print(v1, type(v1)) v2 = dic1['children'][0] print(v2, type(v2)) first_name = dic1['children'][0]['first'] print(first_name, type(first_name)) dic1['children'].append({'three': 'XiaoDong', 'weight': '200'}) print(dic1) |
[{'first': 'XiaoMing', 'age': '3'}, {'second': 'XiaoHong', 'sex': 'Female'}] <class 'list'> {'first': 'XiaoMing', 'age': '3'} <class 'dict'> XiaoMing <class 'str'> {'name': 'LionKing', 'age': '7', 'children': [{'first': 'XiaoMing', 'age': '3'}, {'second': 'XiaoHong', 'sex': 'Female'}, {'three': 'XiaoDong', 'weight': '200'}]} |
| 7、集合set：可變的數據類型，但元素必須是不可變的數據類型， 無序、不可重複 | ||
| 不可變（可哈希）的數據類型：int，str，bool，tuple；元組內不可出現可變數據類型的元素 | ||
| 用法 | 栗子 | 結果 |
| 創建集合 | set1 = {1, 'Ab3', True, } | |
| 增 .add |
set1.add(123) set1.add('獅王') set1.add(('ghs', 123, )) print(set1) |
{False, 1, '獅王', ('ghs', 123), 123, 'Ab3'} |
| 增 .update 迭代增加， 參數爲可迭代對象 |
# set1.update(123) #錯誤的 set1.update('獅王') set1.update(('ghs', 123, )) set1.update([1, 8, 9]) set1.update({'d': 3, 'e': 'f', }) print(set1) |
{False, 1, 'Ab3', 'ghs', 8, 9, 123, 'd', 'e', '王', '獅'} |
| 刪 .remove 刪除一個元素， 無則報錯 |
set1.remove('Ab3') print(set1) |
{False, 1} |
| 刪 .pop 隨機刪除一個元素 |
set1.pop() print(set1) |
{1, 'Ab3'} |
| 刪 .clear 清空集合 |
set1.clear() print(set1) |
set() |
| 刪 del 無保留刪除 |
del set1 print(set1) |
報錯 not defined |
| 集合的其他操作 | set2 = {1, 2, 3, 'a', 'b', } set3 = {3, 4, 'a', 'c', 'd', } set4 = {1, 2, 3, } set5 = {1, 2, 3, 'a', 'b', } |
|
| 集合的交集 & intersection |
print(set2 & set3) print(set2.intersection(set3)) |
{3, 'a'} {3, 'a'} |
| 集合的並集 | union |
print(set2 | set3) print(set2.union(set3)) |
{1, 2, 3, 4, 'a', 'b', 'c', 'd'} {1, 2, 3, 4, 'a', 'b', 'c', 'd'} |
| 集合的差集 - difference |
print(set2 - set3) print(set3.difference(set2)) |
{1, 2, 'b'} {'c', 4, 'd'} |
| 集合的反交集 ^ symmetric_difference |
print(set2 ^ set3) print(set3.symmetric_difference(set2)) set2.symmetric_difference_update(set3) print(set2) |
{1, 2, 4, 'd', 'b', 'c'} {1, 2, 4, 'd', 'b', 'c'} {1, 2, 4, 'b', 'd', 'c'} |
| 集合的子集 < .issubset |
print(set4 < set2) print(set2.issubset(set4)) |
True False |
| 集合的超集 > .issuperset |
print(set2 > set4) print(set5 > set2) print(set4.issuperset(set4)) |
True False True |
| 不可變集合 forzenset |
set6 = frozenset({1, 2, 3, }) print(set6) s1 = frozenset([1, 2, 'aB3']) print(s1) s2 = frozenset({'a': 1, 'b': 2, }) print(s2) |
frozenset({1, 2, 3}) frozenset({1, 2, 'aB3'}) frozenset({'a', 'b'}) |
| 8、其他 | ||
| enumerate：枚舉，對於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串）， enumerate將其組成一個索引序列，利用它可以同時獲得索引和值 |
||
| 用法 | 栗子 | 結果 |
| li = [1, '23', 'a3B4', 'Lion', '獅王'] | ||
| for i in enumerate(li): print(i, type(i)) |
(0, 1) <class 'tuple'> (1, '23') <class 'tuple'> (2, 'a3B4') <class 'tuple'> (3, 'Lion') <class 'tuple'> (4, '獅王') <class 'tuple'> |
|
| for index, nam in enumerate(li, 0): print(index, nam) |
0 1 1 23 2 a3B4 3 Lion 4 獅王 |
|
| for index, nam in enumerate(li, 50): print(index, nam) |
50 1 51 23 52 a3B4 53 Lion 54 獅王 |
|
| range：指定範圍，生成指定數字 | ||
| 用法 | 栗子 | 結果 |
| for i in range(1, 7): print(i) |
1 2 3 4 5 6 |
|
| 指定步長 | for i in range(1, 7, 2): print(i) |
1 3 5 |
| 反向步長 | for i in range(7, 1, -2): print(i) |
7 5 3 |
| Python運算符的優先級 | ||
| 優先級 | 運算符 | 描述 |
| 1 | lambda | Lambda表達式 |
| 2 | or | 布爾“或” |
| 3 | and | 布爾“與” |
| 4 | not x | 布爾“非” |
| 5 | in，not in | 成員測試 |
| 6 | is，is not | 同一性測試 |
| 7 | <，<=，>，>=，!=，== | 比較 |
| 8 | | | 按位或 |
| 9 | ^ | 按位異或 |
| 10 | & | 按位與 |
| 11 | <<，>> | 移位 |
| 12 | +，- | 加法與減法 |
| 13 | *，/，% | 乘法、除法與取餘 |
| 14 | +x，-x | 正負號 |
| 15 | ~x | 按位翻轉 |
| 16 | ** | 指數 |
| 17 | x.attribute | 屬性參考 |
| 18 | x[index] | 下標 |
| 19 | x[index:index] | 尋址段 |
| 20 | f(arguments...) | 函數調用 |
| 21 | (experession,...) | 綁定或元組顯示 |
| 22 | [expression,...] | 列表顯示 |
| 23 | {key:datum,...} | 字典顯示 |
| 24 | 'expression,...' | 字符串轉換 |
| Python小數據池和深淺拷貝 | |||||||
| 副標題：“你以爲你把數據備份好了！” | |||||||
| 1、bytes類型：py3後以Unicode編碼方式存儲，bytes的編碼方式爲非Unicode | |||||||
|
|||||||
| 用法 | 栗子 | 結果 | |||||
| 編碼 .encode 把str轉換成bytes, unicode轉換成 utf-8或gbk |
s1 = 'sun' s2 = '太陽' print(s1.encode('utf-8')) print(s2.encode('utf-8')) print(s1.encode('gbk')) print(s2.encode('gbk')) |
b'sun' b'\xe5\xa4\xaa\xe9\x98\xb3' b'sun' b'\xcc\xab\xd1\xf4' |
|||||
| 解碼 .decode 把bytes，utf-8 轉換成unicode |
s3 = s1.encode() s4 = s2.encode() s5 = s2.encode('gbk') print(s3) print(s3.decode('utf-8')) print(s3.decode('gbk')) print(s4) print(s4.decode('utf-8')) print(s5) print(s5.decode('gbk')) |
b'sun' sun sun b'\xe5\xa4\xaa\xe9\x98\xb3' 太陽 b'\xcc\xab\xd1\xf4' 太陽 |
|||||
| 2、代碼塊：塊是一個python程序的文本，他是作爲一個單元執行的，一個模塊， 一個函數，一個類，一個文件等都是一個代碼塊 |
|||||||
| 補充id is == ： id就是內存地址，is是比較對象的內存地址，==比較對象的值 | |||||||
| 代碼塊緩存機制:在同一代碼塊內，執行初始化對象時會將其內的“變量”和“值”存儲在一個字典中 如果兩個變量值相同，則指向1個對象 所以滿足緩存機制則他們在內存中只存在一個，即：id相同。適用對象： int（float），str，bool。 |
|||||||
| 優點：值相同的字符串和整數，直接從“字典”取出，避免重複的創建和銷燬，提升效率節約內存 | |||||||
| 用法 | 栗子 | 結果 | |||||
| 整型 | a = 55 b = 55 print(a is b) |
True | |||||
| 浮點 | c = 63.57 d = 63.57 print(c is d) |
True | |||||
| 非乘法字符串 | s1 = 'Lion$~' s2 = 'Lion$~' print(s1 is s2) |
True | |||||
| 乘法字符串， 僅含大小寫字母、數字 下劃線； 相乘後總長度<=20 |
s3 = 'Ab6_' * 5 s4 = 'Ab6_' * 5 print(s3 is s4) s5 = 'Ab6_' * 6 s6 = 'Ab6_' * 6 print(s5 is s6) |
True False |
|||||
| 3、小數據池：不同代碼塊的緩存機制，爲節省內存，適用對象：int、str、bool； 兩個值相同的變量指向小數據池裏的同一地址，整數數字範圍-5~256。 |
|||||||
| 補充：在cmd進入python解釋器稱爲交互方式，交互方式下輸入的每個指令都是一個代碼塊 | |||||||
| 用法 | 栗子 | 結果 | |||||
| 整型 |
|
 |
|||||
| 字符串 字符串長度<=1時， 默認駐留 |
|
 |
|||||
| 字符串 字符串長度>1時， 僅含字母、數字、下劃線 默認駐留 |
|
||||||
| 乘法字符串 乘 <= 1 時 默認駐留 |
|
||||||
| 乘法字符串 乘數>1時， 僅含字母、數字、下劃線 總長度<=20 時 默認駐留 |
|
 |
|||||
| 指定駐留 from sys import intern |
|
||||||
| 4、深淺拷貝（你以爲你把數據備份好了） | |||||||
| 淺拷貝：數據半共享，複製的數據獨立存放在其他內存中，但是隻複製第一層。 如果是列表等可變數據類型，拷貝的是內存地址，所以修改這類元素，還是會全都改變。 |
|||||||
| 深拷貝：數據完全不共享，複製的數據完全獨立放到另一個內存中，包括可變數據類型的內容 | |||||||
| 用法 | 栗子 | 結果 | |||||
| 淺拷貝 .copy 數據半共享 |
li1 = [1, 3, [5, 6]] li2 = li1.copy() li1[1] = 4 print(li1) print(li2) li1[2][0] = 7 li2[2][1] = 8 print(li1) print(li2) |
[1, 4, [5, 6]] [1, 3, [5, 6]] [1, 4, [7, 8]] [1, 3, [7, 8]] |
|||||
| 深拷貝 copy.deepcopy 數據完全不共享 |
import copy li1 = [1, 3, [5, 6]] li2 = copy.deepcopy(li1) li1[1] = 4 print(li1) print(li2) li1[2][0] = 7 li2[2][1] = 8 print(li1) print(li2) |
[1, 4, [5, 6]] [1, 3, [5, 6]] [1, 4, [7, 6]] [1, 3, [5, 8]] |
|||||
| python文件處理 | |||
| 1、文件操作的方法 | |||
| 方法 | 用法 | 栗子 | 結果 |
| 打開文件 open() |
open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): file: 必需，文件路徑（相對或者絕對路徑）mode: 可選，文件打開模式 buffering: 設置緩衝 encoding: 一般使用utf8 errors: 報錯級別 newline: 區分換行符 closefd: 傳入的file參數類型 |
r模式打開文件：只讀模式 f = open('E:\Lion獅王.txt', mode='r', encoding='utf-8') rb模式：二進制打開文件只讀，操作非文字文件 w模式：寫模式 wb模式：二進制格式寫入，操作圖片、音頻、視頻等 a模式：追加模式，最後位置追加內容 r+模式：用於文件的讀寫，默認光標在開頭 先讀後寫，避免寫入覆蓋原有內容。 |
|
| .close() 關閉文件 |
.close() 無參數 該方法無返回值 |
f = open('E:\Lion獅王.txt', mode='r', encoding='utf-8') print("文件名：", f.name) f.close() |
文件名： E:\Lion獅王.txt |
| flush() 主動將緩衝區數據立即寫入文件 |
.flush() 無參數 該方法無返回值 |
f = open('E:\Lion獅王.txt', mode='r', encoding='utf-8') print("文件名：", f.name) f.flush() f.close() （栗子不好） |
文件名： E:\Lion獅王.txt |
| .fileno() 返回文件描述符 |
.fileno() 無參數 返回整型文件描述符 |
f = open('E:\Lion獅王.txt', mode='r', encoding='utf-8') print("文件名：", f.name) fid = f.fileno() print("文件描述符：", fid) f.close() |
文件名： E:\Lion獅王.txt 文件描述符： 3 |
| .isatty() 是否連接到終端 |
..isatty() 無參數 如果連接到一個終端設備返回 True， 否則返回 False。 |
f = open('E:\Lion獅王.txt', mode='r', encoding='utf-8') print("文件名：", f.name) ret = f.isatty() print("已連接其它終端：", ret) f.close() |
文件名： E:\Lion獅王.txt 已連接其它終端： False |
| .read() 讀取文件 |
.read([size]) [size]: 設定從文件讀取的字節數 |
f = open('E:\Lion獅王.txt', mode='r', encoding='gbk') lin1 = f.read(6) print("讀取的內容爲：%s" % (lin1)) lin2 = f.read() print("讀取的內容爲：%s" % (lin2)) f.close() |
（注意第二次的開始位置） 讀取的內容爲：a1A!&獅 讀取的內容爲：王^ 第二行 第三行 第四行 |
| .readline() 讀取整行 包含‘\n’字符 |
.readline([size]) [size]: 設定從文件讀取的字節數 |
f = open('E:\Lion獅王.txt', mode='r', encoding='gbk') lin1 = f.readline() print("讀內容爲：%s" % (lin1)) lin2 = f.readline(2) print("讀內容爲：%s" % (lin2)) lin3 = f.readline(15) print("讀內容爲：%s" % (lin3)) f.close() |
讀內容爲：a1A!&獅王^ 讀內容爲：第二 讀內容爲：行 |
| .readlines() 讀取所有行， 並返回列表 |
.readlines 無參數 返回列表，包括所有行 |
f = open('E:\Lion獅王.txt', mode='r', encoding='gbk') # lin1 = f.readlines() # print("結果爲：%s" % (lin1)) # # 結果爲：['a1A!&獅王^\n', '第二行\n', '第三行\n', '第四行'] for line in f.readlines(): line = line.strip() # 去掉每行頭尾空白 print("讀內容爲： %s" % (line)) f.close() |
讀內容爲： a1A!&獅王^ 讀內容爲： 第二行 讀內容爲： 第三行 讀內容爲： 第四行 |
| .seek() 設置光標的位置 |
seek(self, offset: int, whence: int = 0) offset: 開始的偏移量，負數爲倒數第幾位； whence：默認爲0，從哪個位置開始偏移； 0代表從頭，1代表當前位置，2代表文末 返回值：操作成功返回新的位置， 操作失敗則返回-1 |
f = open('E:\Lion獅王.txt', mode='r', encoding='gbk') lin1 = f.readlines() print("結果爲：%s" % (lin1)) f.seek(0, 0) for line in f.readlines(): line = line.strip() # 去掉每行頭尾空白 print("讀內容爲： %s" % (line)) f.close() |
結果爲：['a1A!&獅王^\n', '第二行\n', '第三行\n', '第四行'] 讀內容爲： a1A!&獅王^ 讀內容爲： 第二行 讀內容爲： 第三行 讀內容爲： 第四行 |
| .tell() 返回文件當前位置 |
.tell() 無參數 返回文件的當前位置 |
f = open('E:\Lion獅王.txt', mode='r', encoding='gbk') lin1 = f.readline() print("結果爲：%s" % (lin1)) pos = f.tell() print("當前位置：%d" % pos) f.close() |
結果爲：a1A!&獅王^ 當前位置：12 |
| .truncate() 截取 |
truncate( [ size ]) 從文件的首行首字符開始截斷， 截斷文件爲 size 個字符； Widnows 系統下的換行代表2個字符大小 參數可選 無返回值 |
f = open('E:\Lion獅王.txt', mode='r+', encoding='gbk') f.truncate(20) s1 = f.read() print("讀取爲：%s" % s1) f.close() |
讀取爲：a1A!&獅王^ 第二行 |
| .write() 寫入 返回寫入字符長度 |
.write( [ str ]) [str] 要寫入的字符串 返回寫入的字符長度 |
f = open('E:\Lion獅王.txt', mode='r+', encoding='gbk') s1 = '第五行%……&^&' f.seek(0, 2) ret1 = f.write(s1) print('寫入字符長度： %d' % ret1) f.seek(0, 0) lin1 = f.read() print('讀內容爲：%s' % lin1) f.close() |
寫入字符長度： 9 讀內容爲：a1A!&獅王^ 第二行 第五行%……&^& |
| .writelines() 寫入 系列字符串列表 |
.writelines( [ str ]) [str] 要寫入的字符串序列 無返回值 |
f = open('E:\Lion獅王.txt', mode='r+', encoding='gbk') f.seek(0, 2) sli1 = ['第六行', 'ENDING'] f.writelines(sli1) f.seek(0, 0) lin1 = f.read() print('讀內容爲：%s' % lin1) f.close() |
讀內容爲：a1A!&獅王^ 第二行 第五行%……&^& 第六行ENDING |
| 2、各種模式下的文件操作 | |||
| 方法 | 栗子 | 結果 | |
| rb + wb 模式 複製圖片 |
# 第1步，將原圖片通過rb模式讀取出來 f = open('sexy1.png', mode='rb') content = f.read() f.close() # 第2步，將讀取到的content數據寫入新的文件 f1 = open('sexy2.png', mode='wb') f1.write(content) f1.close() |
得到另外一張新圖片 | |
| W模式 無文件則創建文件 |
f = open('L1', encoding='utf-8', mode='w') f.write('這是一次測試內容') f.close() |
創建了L1，且添加了內容 | |
| W模式 文件存在 則先清空文件 |
f = open('L1', encoding='utf-8', mode='w') f.write('第二次輸入內容') f.flush() # 強制保存 f.close() |
文件內容僅剩第二次的輸入內容 | |
| a 追加模式 無文件則創建文件 有則在文末追加 |
f = open('L1', encoding='utf-8', mode='a') f.write('第三次輸入內容') f.flush() # 強制保存 f.close() |
在文末追加了新寫入的內容 | |
| r+模式 打開文件用於讀寫 寫讀後寫是保障 |
f = open('L1', encoding='utf-8', mode='r+') content = f.read() print(content) f.write('模式R+寫入內容') f.flush() f.seek(0, 0) con1 = f.read() print(con1) f.close() |
第二次輸入內容第三次輸入內容 第二次輸入內容第三次輸入內容模式R+寫入內容 |
|
| with 打開文件方式 | with open('L1',encoding='utf-8') as f1, open('E:\Lion獅王.txt',encoding='gbk') as f2: s1 = f1.read() s2 = f2.read() print(s1) print(s2) |
第二次輸入內容第三次輸入內容模式R+寫入內容 a1A!&獅王^ 第二行 第五行%……&^& 第六行ENDING |
|
| 文件的修改 | |||
願有更多的朋友，在網頁筆記結構上分享更邏輯和易讀的形式：
鏈接：https://pan.baidu.com/s/1PaFbYL1sYoUcRj0xgm8W8Q
提取碼：暫無