python各种数据类型的常用方法_Python之数据类型的常用方法
常用方法匯總
1. int類
方法匯總：
變量名.to_bytes('數字'，"little"\"big") # (把數字轉換成bytes)
# 數字表示轉換后幾個字節表示 little在前面，big在后面(大小端)
int.from_bytes("要轉換的東西","little"\"big") # 字節轉換成數字
bit_length() # 判斷當前十進制數字占二進制的位數
# 新加功能：big 和little 在這里是一個大小端，big 在后，little在前
# to_bytes() 從數字轉換字節
a =5
new_bytes = a.to_bytes(2,"big")
print(new_bytes)
a =5
new_bytes = a.to_bytes(2,"little")
print(new_bytes)
# from_bytes() 從字節轉換成數字
a =5
new_bytes = a.to_bytes(1,"little")
new_a = int.from_bytes(new_bytes,"big")
print(new_bytes)
print(new_a)
# 結果：
b'\x00\x05'
b'\x05\x00'
b'\x05'
5
2. str類
方法匯總：
str.lower() # 只能做英文
str.casefold() # 包含小語種 β-->ss的大寫
str.center('總長度',"前后填充")
str.ljust('總長度',"后面填充")
str.rjust('總長度',"前面填充")
str.count("序列","起始位","結束位") # 查看序列是否存在
str.expandtabs('總位數') # xxx\t 一共占多少位，可以做簡單表格形式
# \n 或 \r\n 換行符 \t制表符
str.find("字符") # 找到字符所在第一個位置的索引，沒有時，返回-1
str.index("字符") # 找到字符所在第一個位置的索引，沒有時，報錯
str.format() # 字符串格式化(重點)
name = "我叫{name}，年齡{age}-{name}"
1 val= name.format("aaa","dddd")
2 val= name.format(*["aaa","dddd"])
3 val= name.format(name="aaa",dddd)
4 dic = {"name":"aaa","age":"dddd"}
val= name.format(**dic)
# 1 和 4 常用
str.format_map() # 字符串格式化
dic = {"name":"aaa","age":"dddd"}
val= name.format_map(dic) # (只能寫字典)
str.isalnum() # 判斷中文或字母或數字存在---True
str.isalpha() # 判斷中文和字母
str.isdecimal() # 數字
str.isdigit() # 數字
str.isnumeric() # 數字
str.isidentifier() # 判斷是否為關鍵字或python內置使用，叫做標識符(python已經賦予意義)
str.islower() # 是否全為小寫
str.isprintable() # 是否可以全部打印
str.isspace() # 是否全為空格
str.title() # 變成標題
str.istitle() # 是否為標題(首字母變大寫)
str.partition() # 分割并且保留分割符(結果是元組)
str.splitlines() # 根據換行符分割
str.swapcase() # 大寫變小寫 小寫變大寫
str.maketrans("原內容"，"新內容") # 依次替換
# str.capitalize() 首字母變大寫
v = "adgdakl13235"
new_v = v.capitalize()
print(new_v)
# str.casefold() 變小寫有英語，還包含小語種
v = "aDGHHdak"
new_v = v.casefold()
print(new_v)
# str.islower() 是否全為小寫
v = "aDGHHdak"
new_v = v.islower()
print(new_v)
# str.isupper() 是否全為大寫
v = "aDGHHdak"
new_v = v.isupper()
print(new_v)
# str.lower() 變小寫
v = "aDGHHdak"
new_v = v.lower()
print(new_v)
# str.uppper() 變小寫
v = "aDGHHdak"
new_v = v.upper()
print(new_v)
# str..swapcase() 大寫變小寫 小寫變大寫
v = "aDGHHdak"
new_v = v.swapcase()
print(new_v)
# str.center(總長度,"前后填充")
v = "aDGHHdak"
new_v = v.center(25,"%")
print(new_v)
# str.ljust(總長度,"后面填充")
v = "aDGHHdak"
new_v = v.ljust(25,"%")
print(new_v)
# str.rjust(總長度,"前面填充")
v = "aDGHHdak"
new_v = v.rjust(25,"%")
print(new_v)
# str.zfill() 給定一個總長度，只能從前面填充，只能填充0
name = 'alex'
v = name.zfill(20)
print(v)
# str.count("序列","起始位","結束位") 查看序列是否存在
v = "aDGHHdaHkFHFGJH"
print(v.count("H",3,7))
# str.encode() 字符串(Unicode編碼)轉換成其他編碼形式
v = "海角"
new_v = v.encode("utf-8")
print(new_v)
# str.expandtabs(總位數) xxx\t 一共占多少位，可以做簡單表格形式
# \n 或 \r\n 換行符 \t制表符
v = "aDG\tHH\tdaH\naDG\tHH\tdaH\naDG\tHH\tdaH"
new_v = v.expandtabs(10)
print(new_v)
# str.find("字符") 找到字符所在第一個位置的索引，沒有時，返回-1
v = "aDGHHdaHkFHFGJH"
new_v = v.find("H")
print(new_v)
v = "aDGHHdaHkFHFGJH"
new_v = v.find("b")
print(new_v)
# str.rfind("字符") 右邊開始找到字符所在第一個位置的索引，沒有時，返回-1
v = "aDGHHdaHkFHFGJH"
new_v = v.rfind("H")
print(new_v)
v = "aDGHHdaHkFHFGJH"
new_v = v.rfind("b")
print(new_v)
# str.index("字符") 找到第一個字符所在位置的索引，沒有時，報錯
v = "aDGHHdaHkFHFGJH"
new_v = v.index("H")
print(new_v)
v = "aDGHHdaHkFHFGJH"
new_v = v.index("b")
print(new_v)
# str.index("字符") 找到第一個字符所在位置的索引，沒有時，報錯
v = "aDGHHdaHkFHFGJH"
new_v = v.rindex("H")
print(new_v)
v = "aDGHHdaHkFHFGJH"
new_v = v.rindex("b")
print(new_v)
# (重點)變量名.format() 字符串格式化
v = "我叫{name}，年齡{age}-{name}"
val = v.format("aaa","dddd")
print(val)
val= v.format(*["aaa","dddd"])
print(val)
val= v.format(name="aaa",age = "11")
print(val)
dic = {"name":"aaa","age":"dddd"}
val= v.format(**dic)
print(val)
# 標注：1 和 4 常用
# str.format_map() 字符串格式化
v = "我叫{name}，年齡{age}-{name}"
dic = {"name":"aaa","age":"dddd"}
val= v.format_map(dic) #(只能寫字典)
print(val)
# str.isalnum() 判斷中文或字母或數字存在---True
v = "aagkf243變量"
print(v.isalnum())
.isalpha() # 判斷中文和字母
v = "aagkf243變量"
print(v.isalpha())
# str.isdecimal() 判斷數字是否存在
name = '123'
print(name.isdecimal()) # 123
# str.isdigit() 數字
name = '②123'
print(name.isdigit()) # 123 ②
# str.isnumeric() 數字
name = '二十②123'
print(name.isnumeric()) # 123 ② 二十
# 連接符.join(可迭代對象)
li = ["978","6745","435","24","12"]
new_li = "*".join(li)
print(new_li)
# str.strip() 去空格
name = ' aff '
val = name.strip()
print(name)
print(val)
# str.lstrip() 去左邊空格
name = ' aff '
val = name.lstrip()
print(name)
print(val)
# str.rstrip() 去右邊空格
name = ' aff '
val = name.rstrip()
print(name)
print(val)
# str.replace() 替換
msg = "asdefasdfja"
val = msg.replace("a","##",2)
print(val)
# str.maketrans("原內容"，"新內容") 依次替換
# str.translate() 轉換，把maketrans替換的內容轉換出來
table = str.maketrans("aeiou",'12345')
msg = "asdefasdfjasdifw[kmnakjudfasdf"
val = msg.translate(table)
print(val)
# str.partition() 分割并且保留分割符，(結果是元組)
v = "akl\nalf\nkal\nakl"
val = v.partition("\n") #只有一次
print(val)
# str.rpartition() 從右分割并且保留分割符，(結果是元組)
v = "akl\nalf\nkal\nakl"
val = v.rpartition("\n") #只有一次
print(val)
# str.split() 分割不保留分割符，結果是列表
v = "akl\nalf\nkal\nakl"
val = v.split("\n")
print(val)
# str.rsplitl() 從右邊分割 ，分割不保留分割符， 結果是列表
v = "akl\nalf\nkal\nakl"
val = v.rsplit("\n")
print(val)
# str.splitlines() 根據換行符分割 ， 結果是列表
v = "akl\nalf\nkal\nakl"
val = v.splitlines()
print(val)
# str.startswith() 檢測是否以xxx開頭
v = "aklalfkalakl"
val = v.startswith("a")
print(val)
# str.endswith() 檢測是否以xxx結尾
v = "aklalfkalakl"
val = v.endswith("kl")
print(val)
# str.isidentifier() 判斷是否為關鍵字或python內置使用，叫做標識符(python已經賦予意義)目前有歧義
# str.isprintable() 是否可以全部打印
name = '二十\n123'
val = name.isprintable()
print(val)
# str.isspace() 是否全為空格
name = '二十\n123' #空字符串也是False
val = name.isspace()
print(val)
# str.title() 變成標題，首字母大寫
name = 'afklsdssdf'
val = name.title()
print(val)
3. list類
list.count("元素") # 判斷元素是否存在于列表中，并且返回個數
list.clear() # 列表.clear()
list.extand("可迭代對象") # 傳遞 批量append,批量傳遞，如果是字符串，會把每個字符拆開來放進去，所以里面要放可迭代對象
v= list.pop('索引') # 刪除并且獲取到賦值給變量
# v 就是被刪掉的東西
list.remove('值') # 重復時只能刪第一個
list.sort(reverse=True) # 排序 默認False從小到大 True從大到小
list.index("值", '起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯
# 深淺拷貝的規則和基本形式：列表里才會這樣
li = ["11","22","33"]
val = li.append("44")
print(val) # val沒有意義，為none
li1 = ["11","22","33"]
li2 = li1 # 指向同一個內存
print(li1,li2)
val = li.append("44") #li2也會發生變化
print(li1,li2)
li1 = ["11","22","33"]
li2 = ["11","22","33"] #指向兩塊內存
# copy 復制
# 淺拷貝 列表.copy() 只拷貝最外層，改變后一樣
li1 = ["11", "22", "33"]
li2 = li.copy()
# 深拷貝 import copy 所有層都拷貝，最后一層補不拷貝，改變后不一樣
import copy
li1 = ["11","22","33"]
li2 = copy.deepcopy()
# ****單個列表時，在只有數字，字符串的時候，深淺拷貝一樣****
# *****嵌套時才有區別*****
# 列表'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
append() # 尾部添加，
li = [11,22,11,33,44]
li.append(666)
print(li)
# 淺拷貝的一種形式，列表里才會這樣
li = ["11","22","33"]
val = li.append("44")
print(val) #val沒有意義，為none
li1 = ["11","22","33"]
li2 = li1 #指向同一個內存
print(li1,li2)
val = li.append("44") #li2也會發生變化
print(li1,li2)
li1 = ["11","22","33"]
li2 = ["11","22","33"]#指向兩塊內存
#copy 淺拷貝 只拷貝最外層，指向同一塊內存
# ****單個列表時，在只有數字，字符串的時候，深淺拷貝一樣****
li1 = ["11","22","33"]
li2 = li1.copy() #這里相當于重新創建了一個列表 但是列表內元素所指向的是同一塊內存
print(li2)
li1.append(666)
print(li1)
print(li2)
# 結果:
['11', '22', '33']
['11', '22', '33', 666]
['11', '22', '33']
# 深拷貝 所有層都拷貝，最后一層補不拷貝，改變后不一樣。單個列表時，在只有數字，字符串的時候，深淺拷貝一樣
import copy
li1 = ["11","22","33"]
li2 = copy.deepcopy(li1)
print(li2)
li1.append(666)
print(li1)
print(li2)
# 結果：
['11', '22', '33']
['11', '22', '33', 666]
['11', '22', '33']
# *****嵌套時才有區別*****
# 淺拷貝
li1 = ["11","22","33",[11,22,33]]
li2 = li1.copy() #這里相當于重新創建了一個列表 但是列表內元素所指向的是同一塊內存
print(li2)
li1[3].append(666) #因為指向同一塊內存，所以li2也會改變
print(li1)
print(li2)
# 結果：
['11', '22', '33', [11, 22, 33]]
['11', '22', '33', [11, 22, 33, 666]]
['11', '22', '33', [11, 22, 33, 666]]
# 深拷貝
import copy
li1 = ["11","22","33",[11, 22, 33]]
li2 = copy.deepcopy(li1)# 這里是把li1里所有的東西都重新創建了一份 ，li1 li2指向不同的內存，
print(li2)
li1.append(666) #因為指向不同的內存，所以li1改變 li2不會改變
print(li1)
print(li2)
# 結果：
['11', '22', '33', [11, 22, 33]]
['11', '22', '33', [11, 22, 33], 666]
['11', '22', '33', [11, 22, 33]]
# .clear 全部清空 列表.clear()
li = [11, 22, 11, 33, 44]
li.clear()
print(li)
# 判斷元素是否存在于列表中，并且返回個數
.count("元素")
li = [11,22,11,33,44]
v = li.count(11)
print(v)
# .extand("可迭代對象") 傳遞 批量append
# 如果是字符串，會把每個字符拆開來放進去，所以里面要放可迭代對象
li = [11,22,33,44]
li.extend("aaa")
print(li)
li = [11,22,33,44]
li2 = ["aaa","bbb"]
li.extend(li2)
print(li)
# pop 刪除 v= li.pop(索引) 刪除并且獲取到賦值給變量 v 就是被刪掉的東西
li = [11,22,33,44]
li.pop(1) #默認刪除最后一個，也可以指定
print(li)
# .remove(值) 重復時只能刪第一個
li = [11,22,33,44,33]
li.remove(33)
print(li)
.sort(reverse=True) # 排序 默認False從小到大 True從大到小
li = [11,22,33,44,33]
li.sort()
print(li)
li = [11,22,33,44,33]
li.sort(reverse=True)
print(li)
# .index("值",起始位置，終止位置) 找到字符所在第一個位置的索引，沒有時，報錯
li = [11,22,33,44,33]
v = li.index(33)
print(v)
li = [11,22,33,44,33]
v = li.index(666)
print(v)
# .insert() 在指定位置插入
li = [11,22,33,44,33]
li.insert(2,"8888")
print(li)
# .reverse() 反轉
li = [11,22,33,44,]
li.reverse()
print(li)
4. tuple類
方法匯總：
index("值", '起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯
count() # 判斷元素是否存在于列表中，并且返回個數
count() # 判斷元素是否存在列表中，并返回個數
tu = (11,22,11,33,44)
v = tu.count(22)
print(v)
tuple.index("值",'起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯
tu = (11,22,33,44,33)
v = tu.index(33)
print(v)
5. dict類 方法匯總：
# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
dict.clear() # 清空
dict.copy() # 和列表一樣
dict.pop("key","默認值") # 刪掉key值對應的值，并取出來，，，key不存在時報錯，加了默認值，就不會報錯，打印默認值
dict.popitem() # 隨機刪掉鍵值對 操作完位為元組類型
dict.setdefalut("key","value") # 設置：只添加不修改，有key時，不改變
dict.update({"key":"value"}) # 更新 不存在加進去，存在時更新
dict.fromkeys() # 生成一個字典
val = dict.fromkeys(["k1","k2","k3"],value)
# value 是一個可變數據類型時，對val做操作后，所有的key對應的value都變化
# value 是一個不可變類型時，更改其中一個時不會全部改變，只改變其中一個
# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
# clear 清空
d = {"k1":"v1","k2":"v2","k3":"v3"}
d.clear()
print(d)
# copy 淺拷貝 只拷貝最外層，指向同一塊內存
# ****單個字典時，在只有數字，字符串的時候，深淺拷貝一樣****
d1 = {"k1":"v1","k2":"v2","k3":"v3"}
d2 = d1.copy() # 這里是重新創建了一個字典，但是字典內的元素指向同一個內存
print(d2)
d1["k1"] = 666
print(d1)
print(d2)
# 深拷貝,所有層都拷貝，最后一層補不拷貝，改變后不一樣
# ****單個字典時，在只有數字，字符串的時候，深淺拷貝一樣****
import copy
d1 = {"k1":"v1","k2":"v2","k3":"v3"}
d2 = copy.deepcopy(d1) # 這里是重新創建了一個字典，
print(d2)
d1["k1"] = 666
print(d1)
print(d2)
# *****嵌套時才有區別*****
# 淺拷貝
d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}
d2 = d1.copy() # 這里是重新創建了一個字典，但是字典內的元素指向同一個內存
print(d2)
d1["k1"].append(666) #因為指向同一個內存，所以d1改變d2也會改變
print(d1)
print(d2)
# 深拷貝
import copy
d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}
d2 = copy.deepcopy(d1) # 這里是重新創建了一個字典，d1 d2 指向不同的內存
print(d2)
d1["k1"] = 666 # 因為指向不同的內存，所以d2不會改變
print(d1)
print(d2)
# 重點 類.fromkeys() dict.fromkeys() 生成一個字典
# value 是一個可變數據類型時，對val做操作后，所有的key對應的value都變化
# value 是一個不可變類型時，更改其中一個時不會全部改變，只改變其中一個
val = dict.fromkeys(["k1","k2","k3"],6666)
print(val)
val["k1"] = "aaa"
print(val)
val = dict.fromkeys(["k1","k2","k3"],[11,22,33])
print(val)
val["k1"].append("qqqq")
print(val)
# get() 取到key，沒有時返回None
d = {"k1":"v1","k2":"v2","k3":"v3"}
print(d.get("k2"))
# keys() 取到所有key 常和for循環一起用
d = {"k1":"v1","k2":"v2","k3":"v3"}
for v in d.keys():
print(v)
# values() 取到所有value 常和for循環一起用
d = {"k1":"v1","k2":"v2","k3":"v3"}
for v in d.values():
print(v)
# items() 取到所有鍵值對 常和for循環一起用
d = {"k1":"v1","k2":"v2","k3":"v3"}
for v in d.items():
print(v)
# pop("key","默認值") 刪掉key值對應的值，并取出來，，，key不存在時報錯，加了默認值，就不會報錯，打印默認值
d = {"k1":"v1","k2":"v2","k3":"v3"}
v = d.pop("k2")
print(v)
print(d)
d = {"k1":"v1","k2":"v2","k3":"v3"}
v = d.pop("k12",888)
print(v)
print(d)
# popitem() 隨機刪掉鍵值對 操作完為元組類型
d = {"k1":"v1","k2":"v2","k3":"v3"}
v1,v2 = d.popitem()
print(v1,v2)
print(d)
# setdefalut("key","value") 設置：只添加不修改，有key時，不改變
d = {"k1":"v1","k2":"v2","k3":"v3"}
d.setdefault("k5","v5")
print(d)
d = {"k1":"v1","k2":"v2","k3":"v3"}
d.setdefault("k2","v5")
print(d)
# update({"key":"value"}) 更新 不存在加進去，存在時更新
d = {"k1":"v1","k2":"v2","k3":"v3"}
d.update({"k2":"v5"})
print(d)
d = {"k1":"v1","k2":"v2","k3":"v3"}
d.update({"k5":"v5"})
print(d)
6. set類
方法匯總：
add() # 添加，如果存在不添加
copy() # 拷貝
update() # 更新，沒有返回值
# 差集(后面的元素一般是可迭代對象)
v.difference(n) # v中存在n中不存在的數據，并取出
v.difference_update(n) # 找到v中存在n中不存在的數據，并更新v中的值，
# 對稱差集
v.symmetric_difference(n) # 去掉v,n中相同的元素，并取出
v.symmetric_difference——update(n) # 去掉v,n中相同的元素，并更新v中的值
# 交集
intersection()
intersection_update()
# 并集
union()
isdisjoint() # 有交集False，沒有True
v.issubset(n) # 判斷v是否是n的子集
v.issuperset() # 判斷v是否是n的父集
# 刪除集合元素
pop() # 隨機刪除
remove() # 沒有時報錯
discard() # 沒有時不報錯
# add() 添加，如果存在不添加
s = {"a1","a2"}
s.add("a3")
print(s)
# copy 淺拷貝 只拷貝最外層，指向同一塊內存
# ****單個集合時，在只有數字，字符串的時候，深淺拷貝一樣****
s = {"a1","a2"}
s1 = s.copy() # 重新創建了一個集合，
print(s1)
s.add("a3") # 所以s改變，s1不改變
print(s)
print(s1)
# 深拷貝 所有層都拷貝，最后一層補不拷貝，改變后不一樣
# ****單個集合時，在只有數字，字符串的時候，深淺拷貝一樣****
import copy
s = {"a1","a2"}
s1 = copy.deepcopy(s) # 重新創建了一個集合，
print(s1)
s.add("a3") # 所以s改變，s1不改變
print(s)
print(s1)
# *****嵌套時才有區別*****
# 淺拷貝 只拷貝最外層，指向同一塊內存， 重新創建了一個集合，但是集合中的元素指向一個內存,,所以會都改變
# 深拷貝 除最后一層全部拷貝，拷貝后指向兩個內存，所以不會一起改變
# clear()清空
s = {"a1","a2"}
s.clear()
print(s)
# 刪除集合元素
# pop() 隨機刪除
v = {"11", "22", "33", "44", "55"}
v.pop()
print(v)
# remove() 在集合中刪除指定值 沒有時報錯
v = {"11", "22", "33", "44", "55"}
v.remove("22")
print(v)
v = {"11", "22", "33", "44", "55"}
v.remove("77")
print(v)
# discard() 在集合中刪除指定值 沒有時不報錯
v = {"11", "22", "33", "44", "55"}
v.discard("22")
print(v)
v = {"11", "22", "33", "44", "55"}
v.discard("77")
print(v)
# update() 更新 不用接收
v = {"11", "22", "33", "44", "55"}
n = {"aaa","sss"}
v.update(n)
print(v)
# 差集(后面的元素一般是可迭代對象)
# v.difference(n) v中存在n中不存在的數據，并取出
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
a = v.difference(n)
print(a)
# v.difference_update(n) 找到v中存在n中不存在的數據，并更新v中的值，
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
v.difference_update(n)
print(v)
# 對稱差集
# v.symmetric_difference(n) 去掉v,n中相同的元素，并取出
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
a = v.symmetric_difference(n)
print(a)
# v.symmetric_difference_update(n) 去掉v,n中相同的元素，并更新v中的值
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
v.symmetric_difference_update(n)
print(v)
# 交集
# intersection() 找到v,n中相同的元素，并取出
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
a = v.intersection(n)
print(a)
# intersection_update() 找到v,n中相同的元素，并更新v中的值
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
v.intersection_update(n)
print(v)
# isdisjoint() 判斷是否無交集 有交集False，沒有True
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
a = v.isdisjoint(n)
print(a)
# union() 并集
v = {"11","22","33","44","55"}
n = {"44","55","66","77","88"}
a = v.union(n)
print(a)
# v.issubset(n) 判斷v是否是n的子集
v = {"44","55"}
n = {"44","55","66","77","88"}
a = v.issubset(n)
print(a)
# v.issuperset(n) 判斷v是否是n的父集
v = {"44","55","66","77","88"}
n = {"44","55"}
a = v.issuperset(n)
print(a)
# 去重 相當于變成集合類型的數
li = ["44","55","66","77","88","44","44"]
v = set(li)
print(v)
總結
以上是生活随笔為你收集整理的python各种数据类型的常用方法_Python之数据类型的常用方法的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 【Pytorch神经网络理论篇】 21
- 下一篇： OSError: [Errno 22]