python基本數據類型
運算符
(1) "+" , 兩個對象相加python
(2) "-" ,兩個對象相減git
(3) " * " ,兩個對象相乘api
(4) "/" ,兩個對象相除app
(5) "%" ,相除返回商的餘數ide
(6) "//" ,返回商的整數部分(整除)函數
(7) " ** ",返回x的y次方冪結果spa
比較運算
(1)"=",等於 , 用於比較兩個對象是否相等code
(2)">",大於,用於比較大於號左邊的對象是否大於右邊的對象orm
(3)"<",小於,用於比較小於號左邊的對象是否小於右邊的對象對象
(4)"!=",不等於,用於比較兩個對象是否不相等
(5)"<>",不等於,同!=
(6)">=",大於等於,用於比較左邊對象是否大於等於右邊對象
(7)"<="小於等於,用於比較左邊對象是否小於等於右邊對象
布爾值 >>> bool
(1)True:表示結果成立,爲真,用"1"表示
(2)False:表示結果不成立,爲假,用"0"表示
注意:(None," ",(),{},[],0) 用bool斷定都爲False
邏輯運算
(1) "和">>>>>>>用and表示,and兩邊條件都成立則返回true,只有一個成立或兩個都不成立則返回False(a and b[a爲非零,則返回b,a爲零,返回a])
(2) "或">>>>>>>用or表示,or兩邊至少有一個成立則返回true(a or b,a爲非零返回a,a爲零返回b)
(3) not 非真即假
注意:先算not,and和or運算沒有前後順序,在python中遵循從左向右的順序作判斷,若是有括號,括號裏的運算優先
(4)in>>>>>>>>>表示在, a in b,表示a在b裏
(5)not in >>>>>>表示不在, a not in b,表示a不在b裏
基本數據類型
(1)數據>>>>int類型
注意:數據不可迭代
1,int(x,base=10)表示將x字符串轉換爲十進制數字表示
num = a v = int(num,base=16)#int(x,base=10)表示將x字符串轉換爲十進制數字表示 print(v)>>>>>11
2,bit_length(self)表示當前數字用二進制表示須要多少位數
num = 11 v = num.bit_length() #bit_length(self)表示當前數字用二進制表示須要多少位數 print(v)>>>>#4
(2)字符串>>>>str類型
########字符串一旦建立,不可修改(不可變)
########能夠迭代,有序
字符串用法:
1.capitalize(self)表示將字符串首字母變大寫
n1 = "aaabbbccc" n2 = "apple" v = n1.capitalize() #capitalize(self)表示將字符串首字母變大寫 print(v)>>>>>>>#Aaabbbccc
2.casefold(self)表示將字符串中的大寫字母所有轉換爲小寫
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v1 = n1.casefold()#casefold(self)表示將字符串中的大寫字母所有轉換爲小寫 4 print(v)#>>>>>aaabbbccc
3.center表示設置寬度,並將內容居中
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v=n1.center(20,"*")#center表示設置寬度，並將內容居中,20表明字符串總位數，*表示空位用它表示 4 print(v)#>>>>>>*****aaabBBccc******
4.count表示統計字符串中有多少子序列
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v=n1.count("a",1,7)#count表示統計字符串中有多少子序列，後面參數表示起始位置與結束位置 4 print(v)#>>>>>2
5.endswith表示以什麼結尾，參數表示起始位置與結束位置，若存在,返回true,不然返回false
同理，startswith表示以什麼開始
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v=n1.endswith("c",1,8)#endswith表示以什麼結尾，參數表示起始位置與結束位置,若存在,返回true,不然返回false 4 print(v)#>>>>True
6.find表示字符串從開始日後找，找到第一個以後，獲取其位置，參數表示起始位置與結束位置，若沒找到返回「-1」
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v=n1.find("b",1,7)#find表示字符串從開始日後找，找到第一個以後，獲取其位置，參數表示起始位置與結束位置，若沒找到返回「-1」 4 print(v)#>>>>>>3
7.index表示字符串從開始日後找，找到第一個以後，獲取其位置，參數表示起始位置與結束位置，若沒找到會報錯
1 n1 = "aaabBBccc" 2 n2 = "apple" 3 v=n1.index("b",1,8)#index表示字符串從開始日後找，找到第一個以後，獲取其位置，參數表示起始位置與結束位置，若沒找到會報錯 4 print(v)#>>>>>>3
8.format表示格式化，將一個字符串中的佔位符替換爲指定的值
1 test = 'i am {name}, age {a}' 2 v = test.format(name='tom',a=19)#format表示格式化，將將一個字符串中的佔位符替換爲指定的值 3 print(v)#>>>>>i am tom, age 19
1 test = 'i am {0}, age {1}' 2 v = test.format('tom',19)#用下標也可替換爲指定的值 3 print(v)#>>>>>>>i am tom, age 19
9.format_map表示格式化，將指定的值替換爲字符串中的佔位符
1 test = 'i am {name}, age {a}' 2 v2 = test.format_map({"name": 'tom', "a": 19})#format_map表示格式化，將指定的值替換爲字符串中的佔位符 3 print(v2)#>>>>>>i am tom, age 19
10.isalnum表示字符串中是否只含有字母和數字或漢字，若結果爲真則返回True,不然False
1 test = "123" 2 v = test.isalnum()#isalnum表示字符串中是否只含有字母和數字或漢字，若結果爲真則返回True,不然False 3 print(v)#>>>>>>True
11.isalpha判斷字符串中是否只含有字母
1 n1="aaa" 2 v=n1.isalpha()#isalpha判斷字符串中是否只含有字母 3 print(v)#>>>>>>>True
12.isdecimal判斷當前輸入字符串是不是數字
isdigit判斷字符串是否爲二進制數字及特殊符號表示的數字，但不能識別文字形式數字
isnumeric判斷字符串是否爲數字，能夠識別各類形式表示的數字
1 n1="二" 2 n2="2②" 3 n3="2②二" 4 v1=n1.isdecimal()#isdecimal判斷當前輸入字符串是不是數字,只能判斷是不是十進制形式數字 5 v2=n2.isdigit()#isdigit判斷字符串是否爲二進制數字及特殊符號表示的數字，但不能識別文字形式數字 6 v3=n3.isnumeric()#isnumeric判斷字符串是否爲數字，能夠識別各類形式表示的數字 7 print(v1)#>>>>>>>>False 8 print(v2)#>>>>>>>True 9 print(v3)#>>>>>>>>True
13.isprintable判斷是否存在不可顯示的字符，若存在返回False,不然True,("\n"爲換行符，「\t」爲製表，都爲不可顯示字符）
1 n1="fjkajfk\nafkfj" 2 v1=n1.isprintable()#isprintable判斷是否存在不可顯示的字符，若存在返回False,不然True 3 print(v1)#》》》》False
14.isspace判斷是否全是空格
1 n1=" " 2 v1=n1.isspace()#isspace判斷是否全是空格 3 print(v1)#>>>>>>>True
15.istitle判斷是不是標題，即每一個子序列是不是大寫字母開頭
title將字符串轉換成標題，即每一個子序列都是大寫字母開頭
1 n1="Afjkdjf ejfiejf mkejfkejfk" 2 v1=n1.istitle()#istitle判斷是不是標題，即每一個子序列是不是大寫字母開頭 3 v2=n1.title()#title將字符串轉換成標題，即每一個子序列都是大寫字母開頭 4 print(v1)#》》》》False 5 print(v2)#》》》》Afjkdjf Ejfiejf Mkejfkejfk
16.join將字符串中的每個元素按照指定分隔符進行拼接
1 n1="今天是星期幾" 2 v1="*".join(n1)#join將字符串中的每個元素按照指定分隔符進行拼接 3 print(v1)#>>>>>>今*天*是*星*期*幾
17.islower判斷字符串是否都是小寫
lower將字符串全轉換成小寫
isupper判斷字符串是否全爲大寫
upper將字符串所有轉換成大寫
1 test = "Apple" 2 v1 = test.islower()#islower判斷字符串是否都是小寫 3 v2 = test.lower()#lower將字符串全轉換成小寫 4 print(v1, v2)#>>>>>>>>>False apple 5 v1 = test.isupper()#isupper判斷字符串是否全爲大寫 6 v2 = test.upper()#upper將字符串所有轉換成大寫 7 print(v1,v2)#》》》False APPLE
18.lstrip從左邊移除指定字符串，有限最多匹配,能夠移除空白
rstrip從右邊移除指定字符串，有限最多匹配
strip從兩邊邊移除指定字符串，有限最多匹配
1 test = "aexxxxaxa" 2 v1= test.lstrip('xa')#lstrip從左邊移除指定字符串，有限最多匹配 3 v2 = test.rstrip('axx')#lstrip從右邊移除指定字符串，有限最多匹配 4 v3 = test.strip('xa')#lstrip從兩邊邊移除指定字符串，有限最多匹配 5 print(v1)#》》》》》exxxxaxa 6 print(v2)#>>>>ae 7 print(v3)#》》》》》e
19.maketrans建立對應關係
1 v = "asidufkasd;fiuadkf;adfkjalsdjf" 2 m = str.maketrans("aeiou", "12345")#maketrans建立對應關係 3 new_v = v.translate(m) 4 print(new_v)
20.partition從左邊以指定字符將字符串分割三部分
rpartition從右邊以指定字符將字符串分割三部分
1 test = "testasdsddfg" 2 v = test.partition('s')#partition從左邊以指定字符將字符串分割三部分 3 print(v)#》》》》》('te', 's', 'tasdsddfg') 4 v = test.rpartition('s')#rpartition從右邊以指定字符將字符串分割三部分 5 print(v)#》》》》》('testasd', 's', 'ddfg')
21.split以指定字符將字符串從左往右分割爲幾部分，輸出結果不包含分割字符，爲列表形式
rsplit以指定字符將整個字符串分割，不包含分割字符
1 test = "testasdsddfg" 2 v = test.split('s',2)#split以指定字符將字符串從左往右分割爲幾部分，輸出結果不包含分割字符，爲列表形式 3 print(v)#>>>>>['te', 'ta', 'dsddfg'] 4 v2=test.rsplit("s")#rsplit以指定字符將整個字符串分割，不包含分割字符 5 print(v2)#》》》》》['te', 'ta', 'd', 'ddfg']
22.splitlines分割，只能根據，true，false：是否保留換行
1 test = "asdfadfasdf\nasdfasdf\nadfasdf" 2 v = test.splitlines(False)#splitlines分割，只能根據，true，false：是否保留換行 3 print(v)#>>>>>['asdfadfasdf', 'asdfasdf', 'adfasdf']
23.swapcase大小寫轉換
1 test = "appLE" 2 v = test.swapcase()#swapcase大小寫轉換 3 print(v)#>>>>>APPle
24.isidentifier判斷字符串是否以字母、下劃線開頭
1 a = "a_ajajf" 2 v = a.isidentifier()#isidentifier判斷字符串是否以字母、下劃線開頭 3 print(v)#>>>>True
25.replace表示將指定字符串替換，參數表示要替換的數量，默認從左往右所有替換，參數表示須要替換的數量
1 test = "appleppal" 2 v = test.replace("pp",'www')#replace表示將指定字符串替換，參數表示要替換的數量，默認從左往右所有替換，參數表示須要替換的數量 3 print(v)#>>>>>awwwlewwwal
26.expandtabs表示斷句，以參數爲寬度從頭至尾開始斷句，遇到"\t"則空格補全一段寬度，沒有出現"\t"則繼續開始下一段
1 n1="ajkajkajk\tjkjqiqjijqi" 2 v=n1.expandtabs(13)#expandtabs表示斷句，以參數爲寬度從頭至尾開始斷句，遇到"\t"則空格補全一段寬度，沒有出現"\t"則繼續開始下一段 3 print(v)#》》》》》》ajkajkajk jkjqiqjijqi，結果說明後一段j前面一段長度爲13，k後用空格補全
(3)列表>>>>>list
######列表用[]表示，裏面的每一個元素用",'隔開,列表建立完能夠進行修改，列表元素在內存中以鏈表形式存在(可變類型)
######列表中的元素能夠是 數字，字符串,列表，布爾值..全部的都能放進去
######列表有序，元素能夠被修改，刪除，增長
列表用法：
(1) 循環 for
1 li = ["a","faaaa",11132,["jfakjfkalj","jfkjfk",454545],44444] 2 for i in li: 3 print(i)#循環輸出列表中每個元素 4 print(li[2:3] )#切片輸出的結果是列表
(2)索引取值,對象[下標]
(3)索引修改,對象[下標]=新值
(4)索引刪除 del.對象[下標]
(5)切片取值,對象[下標:下標]
(6)切片刪除,對象[下標:下標]
(7)切片修改,對象[下標:下標] = [新值,新值]
注意:切片時顧頭不顧尾
in用法v="a" in li #判斷元素在不在列表裏面,注意元素只用逗號隔開的整個元素
列表內置方法
(1) append追加,表示將值做爲一個元素追加到列表最後一個元素後面
1 li = [11,22,33,44,55] 2 li.append(33)#append追加，表示將值做爲一個元素追加到列表最後一個元素後面 3 print(li)#》》》》》[11, 22, 33, 44, 55, 33]
(2) clear清空列表
1 li = [11, 22, 33, 44, 55] 2 li.clear()#clear清空列表 3 print(li)#》》》》》[]
(3) copy拷貝 (淺拷貝)
li = [11, 22, 33, 44, 55] v=li.copy()#copy拷貝（淺拷貝） print(v)#>>>>>[11, 22, 33, 44, 55]
(4）count計算元素出現的次數
1 li = [11, 22, 33, 44,33,55] 2 v=li.count(33)#count計算元素出現的次數 3 print(v)#>>>>>>>2
(5）extend拓展原列表，拓展元素必須能夠迭代，且對象會以元素形式添加到原列表後面
1 li = [11, 22, 33, 44,33,.55] 2 li.extend("abcd")#extend拓展原列表，拓展元素必須能夠迭代，且對象會以元素形式添加到原列表後面 3 print(li)#>>>>>>>>.[11, 22, 33, 44, 33, 0.55, 'a', 'b', 'c', 'd']
1 li = [1,2,3,4] 2 l = [6,7,8,9] 3 li.extend(l) 4 print(li) #[1, 2, 3, 4, 6, 7, 8, 9]
(6) index查找對象並輸出對象在列表中的下標,從左邊開始，參數表明起始位置與結束位置
1 li = [11, 22, 33, 44,33,.55] 2 v=li.index(33)#index查找對象並輸出對象在列表中的下標,從左邊開始，參數表明起始位置與結束位置 3 print(v)#>>>>>>>2
(7)insert在指定位置插入元素
1 li = [11, 22, 33, 44,33,.55] 2 li.insert(2,123)#insert在指定位置插入元素 3 print(li)#>>>>>>>>>[11, 22, 123, 33, 44, 33, 0.55]
(8)pop刪除指定下標對應的元素，默認刪除最後一個元素
1 li = [11, 22, 33, 44,33,.55] 2 li.pop(3)#pop刪除指定下標對應的元素，默認刪除最後一個元素 3 print(li)#>>>>>>>>>>[11, 22, 33, 44, 33]
(9)remove刪除指定元素，從左邊開始
1 li = [11, 22, 33, 44, 33, .55] 2 li.remove(33)#remove刪除指定元素，從左邊開始 3 print(li)#》》》》》》》[11, 22, 44, 33, 0.55]
(10)reverse反轉列表
1 li = [11, 22, 33, 44, 33,55] 2 li.reverse()#reverse反轉列表 3 print(li)#>>>>>>>>>>[55, 33, 44, 33, 22, 11]
(11）sort將列表排序，默認從小往大排，在參數位置加入reverse=True，列表將從大往小排
注意，列表中各元素爲同一類型時候才能夠排序
1 li = [11, 22, 33, 44, 33,55] 2 li.sort()#sort將列表排序，默認從小往大排，在參數位置加入reverse=True，列表將從大往小排 3 print(li)#>>>>>>>>[11, 22, 33, 33, 44, 55]
(4)元組 >>>> tuple
#########元組由（）組成，各元素由「，」隔開，元素能夠是數字，字符串，列表等
#########元組一經建立，一級元素不可修改，增長，刪除
#########元組有序，能夠迭代
#########元組也可經過索引查找其元素位置，，可切片
1 tu=(11,22,33,44,["aa",(11,"bb")],123,23) 2 tu[2]=12 3 print(tu) 4 tu[4][0]=11 5 print(tu)#>>>>>>>>>(11, 22, 33, 44, [11, (11, 'bb')], 123, 23) 6 tu[4][1]="abc"#元組中一級元素不可被修改、刪除、添加 7 print(tu)#>>>>>>>(11, 22, 33, 44, ['aa', 'abc'], 123, 23) 8 tu[4][1][0]=123 9 print(tu)#元組中一級元素不可被修改、刪除、添加
元組內置方法:
(1) count統計元組中指定元素的個數
1 tu=(11,22,33,44,["aa",(11,"bb")],22,123,23) 2 v=tu.count(22)#count統計元組中指定元素的個數 3 print(v)#>>>>>>>2
(2) index尋找指定元素的下標，參數表示起始位置與結束位置
1 tu=(11,22,33,44,["aa",(11,"bb")],22,123,23) 2 v=tu.index(22,0,-1)#index尋找指定元素的下標，參數表示起始位置與結束位置 3 print(v)#>>>>>>>>1
(5)字典 >>>> dict
#########字典是無序的，支持增刪改查，key:value一一對應，value能夠是任意值，不能用列表,字典作key(字典的key是可哈希的,不可變的)
#########字典能夠迭代
字典內置方法：
(1) clear清空字典
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 dic.clear()#clear清空字典 13 print(dic)#>>>>{}
(2) copy淺拷貝字典
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 v=dic.copy()#copy淺拷貝字典 13 print(v)#>>>>{10: 'aaa', 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}
(3) dict.fromkeys根據序列,建立指定的字典
1 v=dict.fromkeys([1111,22222])#dict.fromkeys根據序列，建立指定的字典 2 print(v)#>>>>{22222: None, 1111: None}
(4)get根據key找到對應的value
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 v=dic.get(3)#get根據key找到對應的value 13 print(v)#>>>>123
(5)keys經過for循環輸出全部的key,根據key獲取值,key不存在時,能夠指定默認值(None)
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 for i in dic.keys():#>>>>keys經過for循環輸出全部的key 13 print(i)#>>>>>10 14 3 15 6
(6)values經過for循環輸出全部的values
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 for i in dic.values():#>>>>values經過for循環輸出全部的values 13 print(i)#>>>>>aaa 14 123 15 {123: [], 'abcd': {'a': 123}, 222: ()}
(7)items經過循環表示輸出全部的key及其對應Values
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 for i,v in dic.items():#>>>>items經過循環表示輸出全部的key及其對應values 13 print(i,v)#>>>>>10 aaa 14 3 123 15 6 {'abcd': {'a': 123}, 123: [], 222: ()}
(8)pop根據Key刪除指定的values,若字典中沒有,則返回參數值
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 v=dic.pop(15,1111)#pop根據key刪除指定的values，若字典中沒有，則返回參數值 13 print(v)#>>>>>1111
(9)popitem隨機刪除字典中的一組值
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 v=dic.popitem()#popitem隨機刪除字典中的一組值 13 print(v)#>>>>>(10, 'aaa')
(10)設置值,已存在,不設置,獲取當前key對應的值,不存在,設置,獲取當前key對應的值
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 v=dic.setdefault(10,5555)#setdefault設置值，已存在，不設置，獲取當前key對應的值，不存在，設置，獲取當前key對應的值 13 print(v)#>>>>>aaa
(11)update,更新，若key已存在，則將values更換，若不存在，則將新組添加到字典中
1 dic={ 2 3:"123", 3 10:"aaa", 4 6:{ 5 123:[], 6 222:(), 7 "abcd":{ 8 "a":123 9 } 10 } 11 } 12 dic.update({10:5555})#update,更新，若key已存在，則將values更換，若不存在，則將新組添加到字典中 13 print(dic)#>>>>>{10: 5555, 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}
(6)集合 >>>>> set
集合特色:是一個無序且不重複的元素集合,元素不可變
經過內置函數set可將對象轉換爲集合，會自動去重
1 s = {1,2,3,4,5,5,6,2,2,23} 2 s = set(s)#set將元素轉換成集合，會自動去重 3 print(s)#{1, 2, 3, 4, 5, 6, 23}
集合內置函數
s = {1,2,3,4,5,5,6,2,2,23}
s.add("abc")#添加元素到隨機位置
print(s)#{1, 2, 3, 4, 5, 6, 23, 'abc'}
s.clear()#清空集合
print(s)#set()
s1 = s.copy()#拷貝集合
print(s1)#{1, 2, 3, 4, 5, 6, 'abc', 23}
s.pop()#隨機刪除元素
print(s)#{1, 2, 3, 4, 5, 6, 23}
s.remove(8)#指定元素刪除，若不存在，會報錯
print(s)
s.discard(8)#指定元素刪除，若不存在不會報錯
print(s)
print(s.union(s2))#union求兩個集合並集，用「|"表示,即兩個集合相加去重 print(s.intersection(s2))#intersection求兩個集合交集，用「&」表示，即求兩個集合共有部分 print(s.difference(s2))#difference求兩個集合差集，用「-」表示，即求s中有的元素而s2中沒有 print(s.symmetric_difference(s2))#symmetric_difference求交叉補集，即減去兩個集合共有的元素，剩下的即爲交叉補集 s.difference_update(s2)#difference_update差集更新 print(s.isdisjoint(s2))#isdisjoint判斷是否有交集，若是沒有交集，返回True，不然返回False" print(s.issubset(s2))#issubset判斷是不是子序列 print(s.issuperset(s2))#issuperset判斷是不是父序列 s.symmetric_difference_update(s2)#對稱差集，並更新到a中
數據轉換
字符串(str) , 列表(list) , 元組(tuple) , 字典(dict) 可經過for循環或者join等方法相互轉換
(1)字符串與列表的轉換
# 字符串轉換列表 li = list("asdfasdfasdf"), 內部使用for循環 s = "pouaskdfauspdfiajsdkfj" new_li = list(s) print(new_li)#>>>>>>>>>>['p', 'o', 'u', 'a', 's', 'k', 'd', 'f', 'a', 'u', 's', 'p', 'd', 'f', 'i', 'a', 'j', 's', 'd', 'k', 'f', 'j']
列表轉換成字符串
1 # 列表轉換成字符串， 2 # 既有數字又有字符串,須要本身寫for循環一個一個處理 3 li = [11,22,33,"123","321"] 4 r = str(li)#若是列表中含數字元素，不能直接轉換，會報錯，由於數字不可迭代 5 print(r)#》》》》》》》報錯<br>############################################# 6 li = [11,22,33,"123","321"] 7 s = "" 8 for i in li:#經過for循環，先將列表中一個個元素單個轉換成字符串，再進行字符串的疊加 9 s = s + str(i) 10 print(s)#112233123321<br>#################################################
# 列表中的元素只有字符串，直接使用字符串join方法 li = ["123","567"] v = "".join(li) print(v)#》》》》》》》123567
(2)字符串,元組,列表間的相互轉換
字符串轉換元組
字符串轉換爲元組 s = "asdfasdf0" v = tuple(s) print(v)#》》》》》》('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')
列表轉換元組
1 li = ["asdf","asdfasdf"] 2 v = tuple(li) 3 print(v)#》》》》》》('asdf', 'asdfasdf')
元組轉換列表
1 tu = ("asdf","asdf") 2 v = list(tu) 3 print(v)#》》》》》》['asdf', 'asdf']
元組轉換字符串
1 tu = ("asdf","asdf") 2 v = "_".join(tu) 3 print(v)#》》》》》》asdf_asdf
- 1. python基本數據類型
- 2. Python基本數據類型
- 3. Python - 基本數據類型
- 4. Python 基本數據類型
- 5. Python---基本數據類型
- 6. python 基本數據類型
- 7. Python 數據基本類型
- 8. 【Python】基本數據類型
- 9. python--基本數據類型
- 更多相關文章...
- • Kotlin 基本數據類型 - Kotlin 教程
- • C# 數據類型 - C#教程
- • Kotlin學習（二）基本類型
- • Flink 數據傳輸及反壓詳解
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python基本數據類型
- 2. Python基本數據類型
- 3. Python - 基本數據類型
- 4. Python 基本數據類型
- 5. Python---基本數據類型
- 6. python 基本數據類型
- 7. Python 數據基本類型
- 8. 【Python】基本數據類型
- 9. python--基本數據類型