目錄
Pythone變量類型
變量賦值
標准數據類型
數據類型轉換
Python 變量類型
變量存儲在內存中的值。這就意味着在創建變量時會在內存中開辟一個空間。基於變量的數據類型，解釋器會分配指定內存，並決定什么數據可以被存儲在內存中。因此，變量可以指定不同的數據類型，這些變量可以存儲整數，小數或字符。
變量賦值
Python 中的變量賦值不需要類型聲明。每個變量在內存中創建，都包括變量的標識，名稱和數據這些信息。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。等號（=）用來給變量賦值。等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。
[root@tanbaobao myPy]# vi variable.py #!/usr/bin/python3.8 # -*- conding:UTF-8 -*- name = "thy" sex = 20; weight = 100.0; print(name) print(sex) print(weight) [root@tanbaobao myPy]# python3.8 variable.py thy 20 100.0
另外還有多個變量一起賦值（多變量賦值）。
# 創建一個整型對象，值為2，三個變量被分配到相同的內存空間上。 >>> a=b=c=2 >>> print a 2 # 兩個整型對象 1 和 2 分別分配給變量 a 和 b，字符串對象 "thy" 分配給變量 c。 >>> a,b,c=1,2,"thy" >>> print(a) 1 >>> print(b) 2 >>> print(c) thy
標准數據類型
Python 定義了一些標准類型，用於存儲各種類型的數據。
Python有五個標准的數據類型：
是不可改變的數據類型，這意味着改變數字數據類型會分配一個新的對象。當你指定一個值時，Number對象就會被創建。
可以使用del語句刪除對象的引用
del var1[,var2[,var3[....,varN]]]]
# 刪除單個或多個 del var del var_a, var_b
數字類型有四種：
- int（有符號整型）
- long（長整型[也可以代表八進制和十六進制]）
- float（浮點型）
- complex（復數）
- 長整型也可以使用小寫 l，建議使用大寫 L，避免與數字 1 混淆。Python使用 L 來顯示長整型。
- Python 還支持復數，復數由實數部分和虛數部分構成，可以用 a + bj,或者 complex(a,b) 表示， 復數的實部 a 和虛部 b 都是浮點型。
PS：long 類型只存在於 Python2.X 版本中，在 2.2 以后的版本中，int 類型數據溢出后會自動轉為long類型。在 Python3.X 版本中 long 類型被移除，使用 int 替代。
字符串或串(String)是由數字、字母、下划線組成的一串字符。
s="a1a2···an"(n>=0)
python的字串列表有2種取值順序：
- 從左到右索引默認0開始的，最大范圍是字符串長度少1
- 從右到左索引默認-1開始的，最大范圍是字符串開頭
如果你要實現從字符串中獲取一段子字符串的話，可以使用 [頭下標:尾下標] 來截取相應的字符串，其中下標是從 0 開始算起，可以是正數或負數，下標可以為空表示取到頭或尾。[頭下標:尾下標] 獲取的子字符串包含頭下標的字符，但不包含尾下標的字符。
>>> s = 'abcdef' >>> s[1:5] 'bcde'
上面的結果包含了 s[1] 的值 b，而取到的最大范圍不包括尾下標，就是 s[5] 的值 f。
加號（+）是字符串連接運算符，星號（*）是重復操作。
[root@tanbaobao myPy]# cat demo02.py #!/usr/bin/python3.8 # -*- conding:UTF-8 -*- str = 'Hello World!' print(str) print(str[0]) print(str[2:5]) print(str[2:]) print(str[:-2]) print(str * 2) print(str + "test") [root@tanbaobao myPy]# python3.8 demo02.py Hello World! H llo llo World! Hello Worl Hello World!Hello World! Hello World!test
>>> str1 = 'hello tanbaobao' >>> str1[:6] 'hello ' >>> str1[6] 't' >>> str1[:6] + 'add' + str1[6:] 'hello addtanbaobao'
str()常用函數：
a）字符串處理字母的函數：
.upper() #全部轉為大寫字母 .lower() #全部轉為小寫字母 .title() #首字母大寫 .capitalize() #首字母大寫 .swapcase() #大小寫相互轉換
.lstrip() #去掉左邊的空格
.rstrip() # 刪除右邊，也就是末尾的空格
.strip([chars]) # 去掉左右兩邊的空格，中間的空格不作處理。默認不帶參數是去掉空格，如果帶參數，則去掉指定的chars
實例
# capitalize()將首字母轉換為大寫 >>> str2 = 'xiaoxiao' >>> str2.capitalize() 'Xiaoxiao' # casefold()將字符串轉換為小寫 >>> str2 = "DFNCDOSVNxncn" >>> str2.casefold() 'dfncdosvnxncn' # center(width)將字符串填充，使用空格來填充至長度width的新字符串
# ljust(width)左對齊，rjust(width)右對齊
>>> str2.center(20) ' DFNCDOSVNxncn ' # endswith(sub)檢查字符是否是以sub字符結束，如果是返回True，不是則返回False
# startswith(prefix[,start][,end])檢測是否以什么開始
>>> str2.endswith('c') False >>> KeyboardInterrupt >>> str2.endswith('n') True # expandtabs(tabsize=8)將字符中的\t符轉換為空格,不指定參數，默認空格數為8 >>> str3 = 'i\tlove\tanbaobao!' >>> str3.expandtabs() 'i love anbaobao!'
b）關於查找字符串相關的函數：
.find(sub,start[,end]) #查找指定的字符串，沒有則返回-1，找到會返回索引位置 ，find(sub,start,end) .rfind(sub,start[,end]) #從字符串的右邊開始查找
.lfind(sub,start[,end]) # 從字符串左邊開始查找
.count() #獲取指定字符在該字符串中出現的次數
.index() #和find()功能類似，但是找不指定字符會報錯，而find()則會返回-1 (也有rindex，lindex)
find方法和index方法有三個參數, sub=想查找的字符，start=指定位置，end=結束位置
實例
# count(sub,start[,end])返回sub中重現的字符次數，start和end表示參數范圍 >>> str2.count('n') 2 # find(sub,start[,end])檢查sub是否包含在字符串中，如果有則返回索引值，沒有則返回-1 >>> str3.find('cr') -1 >>> str3.find('ao') 10 # index(sub,start[,end])和find方法一樣，但是如果sub不在字符串內會報異常 >>> str3.index('b') 9 >>> str3.index('t') Traceback (most recent call last): File "<pyshell#22>", line 1, in <module> str3.index('t') ValueError: substring not found
c）與字符串判斷相關：
.isalnum() #判斷字符串是否全部是數字或者字母 .isupper() #判斷是否全是大寫 .islower #判斷是否全是是小寫 .isalpha() #判斷是否全是字母 .isdecamal() #判斷字符串是都只包含十進制字符 定義一個十進制字符串，只需要在字符串前面加個“u”前綴即可 .isdigit() #判斷是否全部是數字 .isidentifier() #判斷變量名是否是python的標識符 .isspace() #判斷是否全是空格
.istitle() # 符合標題，首字母大寫，返回True，否則返回False
PS：返回是布爾類型
注意：
join()：以字符串作為分隔，插入到sub中所有字符之間
>>> str4 = 'Tanbaobao' >>> str4.join('123') '1Tanbaobao2Tanbaobao3'
partition()：找到子字符串sub，把字符分為3個元組(pre_sub,sub,fol_sub)，如果字符串不包含sub則返回源字符串('原字符串','','')
>>> str6 = 'i love tanbaobao' >>> str6.partition('ve') ('i lo', 've', ' tanbaobao')
replace(old,new[,count])：將舊字符串替換為新字符串
>>> str6.replace('i','I') 'I love tanbaobao'
split(sep=None,maxsplit=-1)：不帶參數默認以空格為分隔符切片字符串，如果maxsplit有設置則僅分隔maxsplit個子字符串，返回切片后的子字符串拼接列表
>>> str6 'i love tanbaobao' # 默認按空格切 >>> str6.split() ['i', 'love', 'tanbaobao'] # 按i切，將i去除了 >>> str6.split('i') ['', ' love tanbaobao'] # 按a來切，a去除 >>> str6.split('a') ['i love t', 'nb', 'ob', 'o']
translate(table)：根據table的規則（可以由str.maketrans('a','b')定制），轉換字符串中的字符
>>> str7 ' aaaassss ddff' # 將s轉換為b >>> str7.translate(str.maketrans('s','b')) ' aaaabbbb ddff' # 輸出的是ASCII編碼 >>> str.maketrans('s','b') {115: 98}
zfill(width)：返回長度為width的字符串，原字符串右對齊，前邊用0填充
>>> str3.zfill(30) '00000000000000i\tlove\tanbaobao!'
字符串格式化
a）位置參數
>>> "{0} love {1}.{2}".format("I","Love","tanbaobao") 'I love Love.tanbaobao'
b）關鍵字參數
>>> "{a} love {b}.{c}".format(a="I",b="Love",c="tanbaobao") 'I love Love.tanbaobao'
c）將位置、關鍵字參數綜合使用（位置參數一定要在關鍵字參數之前）
>>> "{0} love {b}.{c}".format("I",b="Love",c="tanbaobao") 'I love Love.tanbaobao'
d）格式化符號意義
>>> "{{0}}".format("a") '{0}' >>> "{{0}}".format("不打印") '{0}' # .1f保留1位小數，f表示四舍五入 >>> '{0:.1f}{1}'.format(22.222,'GB') '22.2GB' >>> '{0:.1f}{1}'.format(22.252,'GB') '22.3GB'
實例
# 格式化字符 >>> '%c' %97 'a' >>> '%c %c %c' %(97,98,99) 'a b c' # 格式化字符串 >>> '%s' % 'i love tanbaobao' 'i love tanbaobao' # 格式化整數 >>> '%d + %d = %d' % (4,5,4+5) '4 + 5 = 9'
e）格式化操作輔助命令
# m總長度，n保留多少位 >>> '%5.1f' % 22.222 ' 22.2' >>> '%.2e' % 22.222 '2.22e+01' >>> '%10d' % 5 ' 5' # 左邊對齊 >>> '%-10d' % 5 '5 ' >>> '%+10d' % 5 # 右邊對齊 ' +5' >>> '%+10d' % +5 ' +5' >>> '%+10d' % -5 ' -5'
f）字符串轉義字符
List（列表） 是 Python 中使用最頻繁的數據類型。列表可以完成大多數集合類的數據結構實現。它支持字符，數字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 標識，是 python 最通用的復合數據類型。列表中值的切割也可以用到變量 [頭下標:尾下標] ，就可以截取相應的列表，從左到右索引默認 0 開始，從右到左索引默認 -1 開始，下標可以為空表示取到頭或尾。
加號 + 是列表連接運算符，星號 * 是重復操作。和字符串的類似。
實例1
[root@tanbaobao myPy]# vi demo03.py #!/usr/bin/python3.8 # -*- conding:UTF-8 -*- list = ['Hello',20,155.50,'thy',100.5] addlist = ['123','thy'] print(list) print(list[0]) print(list[1:3]) print(list[2:]) # 輸出第三個及后面所有 print(list[:-2]) # 從左邊開始打印，不包括結尾索引-2（也就是到結尾-2索引截止） print(list[-2:]) # 從右邊開始打印，包括開始索引-2 print(addlist * 2) # 輸出addlist兩次 print(list + addlist) # 打印組合列表 [root@tanbaobao myPy]# python3.8 demo03.py ['Hello', 20, 155.5, 'thy', 100.5] Hello [20, 155.5] [155.5, 'thy', 100.5] ['Hello', 20, 155.5] ['thy', 100.5] ['123', 'thy', '123', 'thy'] ['Hello', 20, 155.5, 'thy', 100.5, '123', 'thy']
實例2
>>> member = ['thy','譚寶寶',3.1415926,[1,3,5]] >>> member ['thy', '譚寶寶', 3.1415926, [1, 3, 5]] >>> member.append('zs') >>> member ['thy', '譚寶寶', 3.1415926, [1, 3, 5], 'zs'] >>> len(member) 5
向列表添加元素：append()，extend()，insert()
a）append()：一次只能添加一個元素，添加一個以上的元素會報錯
b）extend()：一個列表來擴展一個列表。需要注意格式要用[]列表的標識符括起來
c）insert()：在指定位置插入元素，索引從0開始
從列表中獲取元素單個（）：通過索引值來獲取對應的元素，列表索引值都是從0開始
實例3
# 一個簡單的數據交換 >>> member ['thy', '譚醬', '譚寶寶', 3.1415926, [1, 3, 5], 'zs', 'xw', 'zl'] >>> member[0] 'thy' >>> member[1] '譚醬' >>> temp = member[0] >>> member[0] = member[1] >>> member ['譚醬', '譚醬', '譚寶寶', 3.1415926, [1, 3, 5], 'zs', 'xw', 'zl'] >>> member[1] = temp >>> member ['譚醬', 'thy', '譚寶寶', 3.1415926, [1, 3, 5], 'zs', 'xw', 'zl']
從列表刪除元素：remove()，del()，pop()：
a）remove()：前提是知道要移除的元素在列表中有存在：
>>> member ['譚醬', 'thy', '譚寶寶', 3.1415926, [1, 3, 5], 'zs', 'xw', 'zl'] >>> member.remove(3.1415926) >>> member ['譚醬', 'thy', '譚寶寶', [1, 3, 5], 'zs', 'xw', 'zl'] # 如果不存在，會報錯 >>> member.remove(2.1415926) Traceback (most recent call last): File "<pyshell#21>", line 1, in <module> member.remove(2.1415926) ValueError: list.remove(x): x not in list
b）del()語句：del不是方法，是一個語句：
# del后面直接跟member對象，會直接將member列表才能夠內存中刪除 >>> member ['譚醬', 'thy', '譚寶寶', [1, 3, 5], 'zs', 'xw', 'zl'] >>> del member[3] >>> member ['譚醬', 'thy', '譚寶寶', 'zs', 'xw', 'zl']
c）pop()：從列表中取出元素並返回給你，默認從最后一個元素刪除，如果要指定刪除元素，在pop()中指定參數索引
# 默認從元素最后一個刪除，每次只刪除一個元素 >>> member ['譚醬', 'thy', '譚寶寶', 'zs', 'xw', 'zl'] >>> member.pop() 'zl' >>> member ['譚醬', 'thy', '譚寶寶', 'zs', 'xw'] # 賦值刪除 >>> name = member.pop() >>> name 'xw' # 指定索引刪除 >>> member.pop(1) 'thy' >>> member ['譚醬', '譚寶寶', 'zs']
列表切片（分片slice）：可以一次獲取多個元素
# member[0:2]左邊數包括，右邊的數不包括在內 >>> member ['譚醬', '譚寶寶', 'zs', 'thy'] >>> member[0:2] ['譚醬', '譚寶寶'] # 獲取索引3簽名的所有數 >>> member[:3] ['譚醬', '譚寶寶', 'zs'] # 獲取索引1后面的所有數 >>> member[1:] ['譚寶寶', 'zs', 'thy'] # 相當於拷貝列表 >>> member[:] ['譚醬', '譚寶寶', 'zs', 'thy'] 或 >>> member2 = member[:] >>> member2 ['譚醬', '譚寶寶', 'zs', 'thy']
列表操作符：列表盡量不使用+號添加元素，最好使用extend()方法來添加
# 單個元素比較 >>> a = [123] >>> b = [234] >>> a > b False # 多個元素比較（只要第一個元素比另一個列表的第一個元素大，就不會再比較后面的元素） >>> list = [123,456] >>> list2 = [234,123] >>> list > list2 False # 用and進行比較，在上面的基礎，添加list3 >>> list3 = [123,456] >>> (list < list2) and (list == list3) True # 拼接字符 +。類似列表的extend()擴展列表方法。 # +號兩邊的類型必須一致 >>> list4 = list + list2 >>> list4 [123, 456, 234, 123] # *號 >>> list3 * 3 [123, 456, 123, 456, 123, 456] >>> list3 *= 5 >>> list3 [123, 456, 123, 456, 123, 456, 123, 456, 123, 456] # in包含和not in不包含 >>> 123 in list3 True >>> 241 in list3 False >>> 241 not in list3 True # 只能判斷列表中的元素，如果要判斷列表中列表的元素還需要進行其他操作指定列表的索引 >>> list5 = [123,['譚寶寶','譚醬'],456] >>> '譚醬' in list5 False >>> '譚醬' in list5[1] True # 對於列表中列表的值的訪問，相當於二元數組的操作 >>> list5[1][1] '譚醬'
列表的內置函數：
>>> list3 [123, 456, 123, 456, 123, 456, 123, 456, 123, 456] # 查看列表中元素出現的次數 >>> list3.count(123) 5 # 查看指定元素在指定索引內出現的位置，其中第二個參數表示開始索引，第三個參數表示結束索引 >>> list3.index(123) 0 >>> list3.index(123,3,7) 4 # 逆序輸出reverse >>> list3.reverse(); >>> list3 [456, 123, 456, 123, 456, 123, 456, 123, 456, 123] # 排序sort（從小到大），使用sort從小到大之后可以使用reverse從大到小排序哈 >>> list6 = [1,3,5,1,2,3,6,8,2] >>> list6.sort() >>> list6 [1, 1, 2, 2, 3, 3, 5, 6, 8] # sort帶參數sort(reverse=True)，從大到小，默認是False，從小到大 >>> list6.sort(reverse=True) >>> list6 [8, 6, 5, 3, 3, 2, 2, 1, 1] >>> list6.sort(reverse=False) >>> list6 [1, 1, 2, 2, 3, 3, 5, 6, 8] # 另外如果將list6賦值給list7，然后將list6進行排序，會改變兩個列表的順序，如果加上切片方式進行拷貝，則不會修改兩個列表的值，只會修改指定排序的列表值 # 即使用=號只是多添加一個標簽，使用切片進行的拷貝，會開辟一個內存 >>> list6 [1, 1, 2, 2, 3, 3, 5, 6, 8] >>> list7 = list6 >>> list7 [1, 1, 2, 2, 3, 3, 5, 6, 8] >>> list8 = list6[:] >>> list8 [1, 1, 2, 2, 3, 3, 5, 6, 8] >>> list6.sort(reverse=True) >>> list6 [8, 6, 5, 3, 3, 2, 2, 1, 1] >>> list7 [8, 6, 5, 3, 3, 2, 2, 1, 1] >>> list8 [1, 1, 2, 2, 3, 3, 5, 6, 8]
實例
>>> a = list() >>> a [] # 將字符串轉換為列表 >>> b = 'i love tanbaobao' >>> b = list(b) >>> b ['i', ' ', 'l', 'o', 'v', 'e', ' ', 't', 'a', 'n', 'b', 'a', 'o', 'b', 'a', 'o'] # 將元組轉換為列表 >>> c = (1,22,33,11,56) >>> c = list(c) >>> c [1, 22, 33, 11, 56]
# 返回長度 >>> len(b) 16 >>> b ['i', ' ', 'l', 'o', 'v', 'e', ' ', 't', 'a', 'n', 'b', 'a', 'o', 'b', 'a', 'o'] >>> max(b) 'v' # 返回最大值（數據類型需要一致） >>> max(c) 56 # 返回序列或參數集合中的最小值（數據類型需要一致） >>> min(c) 1
# sum(iterable[,start=0]):返回序列iterable和可選參數start總和。也需要同類型
>>> tuple2 = (3.2,3.1,3.4
>>> dum(tuple2)
>>> sum(tuple2)
9.700000000000001
元組是另一個數據類型，類似於 List（列表）。元組用 () 標識。內部元素用逗號隔開。但是元組不能二次賦值，相當於只讀列表。列表可以二次賦值。
實例
[root@tanbaobao myPy]# cat demo04.py #!/usr/bin/python3.8 # -*- conding:UTF-8 -*- tuple = ('Hello',20,155.50,'thy',100.5) addtuple = ('123','thy') print(tuple) print(tuple[0]) print(tuple[1:3]) print(tuple[2:]) print(tuple[:-2]) print(tuple[-2:]) print(addtuple * 2) print(tuple + addtuple) [root@tanbaobao myPy]# python3.8 demo04.py ('Hello', 20, 155.5, 'thy', 100.5) Hello (20, 155.5) (155.5, 'thy', 100.5) ('Hello', 20, 155.5) ('thy', 100.5) ('123', 'thy', '123', 'thy') ('Hello', 20, 155.5, 'thy', 100.5, '123', 'thy')
這里講下元組和列表的不同：
區分元組不能僅僅看()來識別，“,”逗號才是關鍵，如：
創建空列表，和空元組：
>>> temp = [] >>> type(temp) <class 'list'> >>> temp =() >>> type(temp) <class 'tuple'>
注意*號操作：
>>> 8 * (1) 8 >>> 8 * (1,) (1, 1, 1, 1, 1, 1, 1, 1) # 列表 >>> 8 * [1] [1, 1, 1, 1, 1, 1, 1, 1]
# 可以通過以下這種方法進行添加元素 >>> temp1 = ('譚醬', '譚寶寶', '嗶', '周小獅') >>> temp1 = temp1[:2] + ('小林',) + temp1[2:] >>> temp1 ('譚醬', '譚寶寶', '小林', '嗶', '周小獅')
不能用del語句來刪除元組，機制會在過段時間來清理一些沒有被指定的標簽。
字典(dictionary)是除列表以外python之中最靈活的內置數據結構類型。列表是有序的對象集合，字典是無序的對象集合。
兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。字典用"{ }"標識。字典由索引(key)和它對應的值value組成。
實例demo05.py
[root@tanbaobao myPy]# vi demo05.py #!/usr/bin/python3.8 # -*- conding:UTF-8 -*- dict = {} dict['one'] = "This is one" dict[2] = "This is two" adddict = {'name':'thy','age':'20','sex':'女'} print(dict['one']) print(dict[2]) print(adddict) print(adddict.keys()) print(adddict.values()) [root@tanbaobao myPy]# python3.8 demo05.py This is one This is two {'name': 'thy', 'age': '20', 'sex': '女'} dict_keys(['name', 'age', 'sex']) dict_values(['thy', '20', '女'])
創建和訪問字典：
>>> brand = ['李寧', '耐克', '阿迪達斯', '譚醬'] >>> slogan = ['Impossible is nothing', 'Just do it', 'Let\'s go', 'OK'] >>> slogan ['Impossible is nothing', 'Just do it', "Let's go", 'OK'] >>> print('譚醬:', slogan[brand.index('阿迪達斯')]) 譚醬: Let's go >>> >>> dict = {'李寧':'Impossible is nothing', '耐克':'Just do it', '阿迪達斯':'Let\'s go', '譚醬':'OK'} >>> print('譚醬：', dict['譚醬']) 譚醬： OK >>>
由於之前定義了dict變量，當我后面調用dict函數時回報錯誤：
解決：將之前定義的dict變量刪除：del(dict)
fromkeys()創建新的字典
以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應的初始值。
語法
dict.fromkeys(seq[, value])
實例：
>>> dict1 = {} >>> dict1.fromkeys((1,2,3)) {1: None, 2: None, 3: None} >>> dict1.fromkeys((1,2,3),'an') {1: 'an', 2: 'an', 3: 'an'} # 如果是向修改值，可能並不是修改，而是直接賦值了 >>> dict1.fromkeys((1, 3), '數字') {1: '數字', 3: '數字'}
獲取字典的鍵，值，鍵值對：
# 定義32個字典元素 >>> dict1 = dict1.fromkeys(range(32), '贊') >>> dict1 {0: '贊', 1: '贊', 2: '贊', 3: '贊', 4: '贊', 5: '贊', 6: '贊', 7: '贊', 8: '贊', 9: '贊', 10: '贊', 11: '贊', 12: '贊', 13: '贊', 14: '贊', 15: '贊', 16: '贊', 17: '贊', 18: '贊', 19: '贊', 20: '贊', 21: '贊', 22: '贊', 23: '贊', 24: '贊', 25: '贊', 26: '贊', 27: '贊', 28: '贊', 29: '贊', 30: '贊', 31: '贊'} # for遍歷獲取鍵，值，鍵值對，這里的end=" "是不換行輸出，""雙引號之間的字符是以什么換行，我這里是以空格 >>> for eachKey in dict1.keys(): print (eachKey, end=" ") 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 >>> for eachValue in dict1.values(): print (eachValue, end=" ") 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 贊 >>> for eachItem in dict1.items(): print (eachItem, end=" ") (0, '贊') (1, '贊') (2, '贊') (3, '贊') (4, '贊') (5, '贊') (6, '贊') (7, '贊') (8, '贊') (9, '贊') (10, '贊') (11, '贊') (12, '贊') (13, '贊') (14, '贊') (15, '贊') (16, '贊') (17, '贊') (18, '贊') (19, '贊') (20, '贊') (21, '贊') (22, '贊') (23, '贊') (24, '贊') (25, '贊') (26, '贊') (27, '贊') (28, '贊') (29, '贊') (30, '贊') (31, '贊')
PS：使用in可以查詢字典中是否包含這個元素（get(索引,設置沒有包含或包含的提示信息)也可以）
清空字典使用clear()方法：
拷貝copy()方法：
直接賦值只是添加了一個標簽，改變原來的字典內容，c也會跟着改變，但是b的內容不會改變
更新update()方法：
從另一個字典更新當前字典
>>> a {'1': 'one', '小': None} >>> b = {'nihao':'ncsn'} >>> a.update(b) >>> a {'1': 'one', '小': None, 'nihao': 'ncsn'}
補充：集合
以花括號標識但是沒有映射關系的是集合。
集合中的元素是唯一的，且會自動從小到大排序顯示
創建集合的方法有兩種：
1）直接把一堆元素使用{}花括號括起來，如上面所示
2）使用set()工廠函數，set()中可以傳入字符，元組，列表類型。如下所示：
實例：去除列表中重復的元素
# 沒有學集合之前，普通方法 >>> num1 = [1,2,3,4,5,5,3,1,0] >>> temp = [] >>> for each in num1: if each not in temp: temp.append(each) >>> temp [1, 2, 3, 4, 5, 0] # 學了集合之后處理的方法 >>> num1 = list(set(num1)) >>> num1 [0, 1, 2, 3, 4, 5]
訪問集合中的值：
1）使用for把集合中的元素一個一個讀取出來
2）使用in和not in判斷一個元素是否在集合中已經存在
不可變集合：
>>> num3 = frozenset([1,2,3,4,5]) >>> num3 frozenset({1, 2, 3, 4, 5})
Python數據類型轉換
有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。以下幾個內置的函數可以執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。
