python集合、元組、字典

主要內容：

二、集合

三、元組

四、字典

複習:

　　字符串和元組同樣，只能讀不能寫。列表和字典能夠嵌套任何東西，列表能夠嵌套列表

　　L = list("hello")  # L = ['h', 'e', 'l', 'l', 'o']

　　集合、字典是無序的；列表、元組、字符串是有序的

　　集合、字典、列表是能夠修改的；元組、字符串、數字是不能修改的

　　for 語句中的else 語句，意思是for中的循環結束後，再走else中的代碼，字典中的鍵就至關於列表可中索引的數字

集合

　　集合是可修改的無序的不重複的序列，集合使用花括號{}

　　主要做用

• 去重，把一個列表變成集合，就自動去重了
• 關係測試，測試兩組數據以前的交集、差集、並集等關係

建立集合

　　語法：set(可迭代對象)

　　建立空集合：s = set()

s = set([3,4,5,6,7])    #建立一個數字集合{3, 4, 5, 6, 7}
w = set([2,3,4])
t = set("hello")# 遍歷字符串中的每一個字符,拆開成單個字符{'h', 'e', 'l', 'o'}

my_set1 = set(("hello",)) # 建立含有一個元素的集合，有逗號說明是元組
my_set2 = set(("haha","wode","en"))#建立一個含有多個元素的集合

print("s:",s)   # s: {3, 4, 5, 6, 7}
print("w:",w)   # w: {2, 3, 4}
print("my_set1:",my_set1) # {'hello'}
print("my_set2:",my_set2)   # {'en', 'haha', 'wode'}

View Code

s.add()　　#添加集合

s.updata(可迭代對象)　　# 添加多項

s.remove(x)　　#刪除指定元樹x，若是x不存在則會發生錯誤

s.discard()　　#和remove()同樣，可是當刪除指定元素不存在時，不會報錯

s.clear()　　#清空集合

s.pop()　　#彈出最後一個書或彈出指定數

s = set([4,5])    #建立一個數字集合{3, 4, 5}

s.add('w')
print("添加後的s：",s)   # {4, 5, 'w'}

s.update(['ni','hao','ya'])    # 添加多項
print("添加多項後的s：",s)     # {'hao', 'ya', 4, 5, 'w', 'ni'}

# 咱們輸入字符串試試
s.update("hid") # 將字符串拆分單個字符後，而後再一個個添加到集合中,有重複的會忽略。，
print(s)        # {'hao', 'ya', 4, 5, 'w', 'h', 'ni', 'i', 'd'}

s.remove("hao")         # 移除元素
print("移除元素",s)      # {'w', 'e', 'o', 'l', 12, 'h', 23}

s.discard('ya')         # 移除元素，不存在不會發生錯誤
print(s)                # {'d', 4, 5, 'i', 'ni', 'w', 'h'}

s.pop()                # 隨機刪除集合中的元素,這個方法返回值是刪除的數，不是返回None
print(s)                # {4, 5, 'i', 'ni', 'w', 'h'}

s.clear()
print(s)                # set()

View Code

|　　生成兩個集合的並集

&　　生成兩個集合的交集

-　　生成兩個集合的補集

^　　生成兩個集合的對稱補集（也就是兩個集合的並集減去交集）

>　　判斷一個集合是另外一個集合的超集

<　　判斷一個集合是另外一個集合的子集

==,  !=　　判斷集合是否相同

in , not in 　　判斷集合是否在另外一個集合中

len(s),　　sum(s),　　max(s),　　min(s),　　sum(s),　　any(s),　　all(s)

s = set([3,4,5,6,7])    #建立一個數字集合{3, 4, 5, 6, 7}
w = set([2,3,4])

print("求交集:",s&w)      # {3, 4}
print("求並集:",s | w)    # {2, 3, 4, 5, 6, 7}
print("求差集:",s-w)      # 減去相同的元素 {5, 6, 7}
print("求差集:",w-s)      # 減去相同的元素 {2}
print("並集減去交集:",s ^ w)    # {2, 5, 6, 7}

print(len(s))   # 5
print(3 in s)   # True

View Code

 

固定集合  frozenset

　　固定集合是不可變、無序的，含有惟一元素的不可迭代的集合，

　　做用：固定集合能夠做爲字典的鍵，還能夠做爲字典的值

固定集合的構造函數

　　frozenset()　　建立一個空的固定集合

　　frozenset(iterable)　　用可迭代對象建立一個固定的集合

固定集合的運算和集合的運算徹底同樣

集合推導式：　　{表達式  for  變量  in  可迭代對象  [if  真值表達式]}　# [ ]能夠省略

　　　　　　　　集合推導式一樣也能夠嵌套

　　　　　　　　{x for x in range(10)}　　#返回集合

元組

　　元組是不可修改的有序序列，元組使用小括號()，列表使用綜括號[]，能夠存儲任意的數據類型

　　元組只含一個元素時，須要在後面添加逗號，否者會被當作變量來處理

　　括號能夠省略

 1 tuple2 = (1,2,'wo',4,5)
 2 print(tuple2)   # (1, 2, 'wo', 4, 5)
 3 tuple3 = "wo","ai","ni"     # 不須要括號也能夠
 4 print(tuple3)   # ('wo', 'ai', 'ni')
 5 print(type(tuple3)) # <class 'tuple'>類型爲元組類型
 6 tup1 = ()       #()
 7 print(tup1)
 8 tup2 = (50)     # 不加逗號，類型爲整型
 9 print(tup2)     #50,
10 tup3 = (50,)    # 加逗號，類型爲元組
11 print(tup3)     #(50,)

元組

1 t = tuple()    #建立一個空元組
2 t = ()    #建立一個空元組
3 x, y, z = 100, 200, 300  # 序列賦值1 2 3 x,y,z是整型
4 x, y, z = (100, 200, 300)  # 序列賦值 100 200 300整型
5 x, y, z = [100, 200, 300]  # 序列賦值
6 x, y, z = 'ABC'            # 序列賦值 A B C 字符串
7 T.index(v[, begin[, end]]) #返回對應元素的索引下標
8 T.count(x)  #返回元組中對應的元素個數

1.訪問元組

tup1 =(11,2,33)
print("tup1[0]:",tup1[0])       # tup1[0]: 11
print("tup1[0:2]:",tup1[0:2])   # tup1[0:2]: (11, 2)

訪問元組

2.刪除元組

　　元組中的值是不能被刪除的，但咱們能夠刪除整個元組

tup = ('Google', 'Runoob', 1997, 2000)
del tup
print ("刪除後的元組 tup : ",tup) # name 'tup' is not defined

刪除整個元組

3.元組運算符

Python 表達式	結果	描述
len((1, 2, 3))	3	計算元素個數
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	鏈接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	複製
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3); print (x)	1 2 3	迭代

 

 元組的相加和相乘是建立了一個新的元組，原來的元組並無改變，也改變不了

4.元組索引，截取

L = ('Google', 'Taobao', 'Runoob')

Python 表達式	結果	描述
L[2]	'Runoob'	讀取第三個元素
L[-2]	'Taobao'	反向讀取；讀取倒數第二個元素
L[1:]	('Taobao', 'Runoob')	截取元素，從第二個開始後的全部元素。

 

5.元組的其餘內置函數

　　len　　max　　min　　

　　tuple(列表)　　將列表轉換成元組

reversed(可迭代對象)　　#返回反向順序的可迭代對象（臨時性的）
sorted(iterable, key=None, reverse=False)　　#返回已排序的列表

t = (4, 8, 6, 2, 7)
L = [x for x in reversed(t)]
# L = [7, 2, 6, 8, 4]  # 原來前後順序的反向
for x in reversed(t):
  print(x)  #  打印: 7  2  6  8  4

L2 = sorted(t)  # L2 = [2, 4, 6, 7, 8]
L3 = sorted(t, reverse=True)  # L3 = [8, 7, 6, 4, 2]

reversed和sorted的使用

字典

　　字典是可修改的無序序列，字典使用花括號{}，能夠存儲任意類型對象，

　　字典由鍵值對組成{key:value}

　　鍵在字典中是惟一的，若是重複，後面的鍵值對會替換前面的。

　　鍵必須是不可變的類型對象，只能用數字、字符串、元組充當，列表就不行，值能夠取任意的數據類型

d = {"key1":'value1',"key2":'value2'}
print(d)      # {'key2': 'value2', 'key1': 'value1'}
dict = {'a':2,'b':1,'b':3}    # 重複最後的一個鍵值對會替換前面的，值不須要惟一
print(dict)   # {'a': 2, 'b': 3}

鍵值對

建立字典，

　　當鍵不存在時，建立鍵，並綁定對應的值，當鍵存在時，修改鍵綁定的值

# 建立字典dict
dict1 = {'a':2,'b':1,'b':3}    # 重複最後的一個鍵值對會替換前面的，值不須要惟一
print(dict1)   # {'a': 2, 'b': 3}
dict1['c'] = 4   # 當鍵不存在時，增長鍵，並綁定對應的值，
print(dict1)     # {'a': 2, 'b': 3, 'c': 4}
dict1['c'] = 134   # 當鍵存在時，修改鍵綁定的值
print(dict1)     # {'a': 2, 'b': 3, 'c': 134}

建立字典

　　訪問字典，把鍵放入方括號中進行索引，可是訪問字典中不存在的鍵會出錯

1 print(dict['a'])#訪問字典，把鍵放入方括號中進行索引
2 print(dict["c"])#訪問字典中不存在的鍵會出錯

訪問字典

　　刪除字典、清空字典、刪除字典中的鍵值對

dict1 = {'a':2,'b':1,'c':3}

del dict1['a']  # 刪除字典中的鍵"a，就至關於刪除了值2
print(dict1)    # {'b': 1, 'c': 3}
dict1.clear()   # 清空字典的全部鍵
print(dict1)    # {}
del dict1       # 刪除字典

刪除字典、清空字典、刪除字典中的鍵值對

 

　　字典的內置函數

　　cmp(dict1, dict2)

　　# 比較兩個字典元素。若是兩個字典的元素相同返回0，
　　# 若是字典dict1大於字典dict2返回1，
　　# 若是字典dict1小於字典dict2返回-1。

　　len(dict) 　　 # 計算字典元素個數，即鍵的總數。
　　str(dict)　　# 輸出字典可打印的字符串表示。
　　type(variable)　　# 返回輸入的變量類型，若是變量是字典就返回字典類型。

 

　　字典方法

dict.clear()#刪除字典內全部元素
dict.copy()#返回一個字典的淺複製

dict.fromkeys(seq[, val])#建立一個新字典，以序列 seq 中元素作字典的鍵，val 爲字典全部鍵對應的初始值

 1 seq = ('Google', 'Runoob', 'Taobao')
 2 seq1 = 'fkjsahf'
 3 dict = dict.fromkeys(seq)
 4 print("新字典爲 : %s" % str(dict))
 5 dict = dict.fromkeys(seq, 10)
 6 print("新字典爲 : %s" % str(dict))
 7 dict = dict.fromkeys(seq1, 10)
 8 print("新字典爲 : %s" % str(dict))
 9 
10 #新字典爲 : {'Runoob': None, 'Taobao': None, 'Google': None}
11 #新字典爲 : {'Runoob': 10, 'Taobao': 10, 'Google': 10}
12 #新字典爲 : {'j': 10, 'k': 10, 'h': 10, 'a': 10, 'f': 10, 's': 10

View Code

 dict.get(key, default=None)#返回指定鍵key的值，若是值不在字典中返回default值，default = None

1 dict = {'Name': 'Zara', 'Age': 27}
2 
3 print "Value : %s" %  dict.get('Age')#Value : 27
4 print "Value : %s" %  dict.get('Sex', "Never")#Value : Never

dict.get

dict.has_key(key)#若是鍵在字典dict裏返回true，不然返回false
dict.items()#以列表形式返回可遍歷的(鍵, 值) 元組數組

 1 dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}
 2  
 3 print "字典值 : %s" %  dict.items()
 4  
 5 # 遍歷字典列表
 6 for key,values in  dict.items():
 7     print key,values
 8 
 9 #字典值 : [('Google', 'www.google.com'), ('taobao', #'www.taobao.com'), ('Runoob', 'www.runoob.com')]
10 #Google www.google.com
11 #taobao www.taobao.com
12 #Runoob www.runoob.com

dict.items()

dict.items()返回的是兩個數，一個是字典的鍵，一個是字典的值，

dict.keys()#以列表返回一個字典全部的鍵

1 dict = {'Name': 'Zara', 'Age': 7}
2 
3 print "Value : %s" %  dict.keys()#Value : ['Age', 'Name']

dict.keys

dict.setdefault(key, default=None)#和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default
dict.update(dict2)#把字典dict2的鍵-值對更新到dict裏
dict.values()#以列表返回字典中的全部值
pop(key[,default])#刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 不然，返回default值。

1 site= {'name': '菜鳥教程', 'alexa': 10000, 'url': 'www.runoob.com'}
2 pop_obj=site.pop('name')
3 print(pop_obj)    # 輸出 ：菜鳥教程
4 print(site)    #{'alexa': 10000, 'url': 'www.runoob.com'}

site.pop()

popitem()#隨機返回並刪除字典中的一對鍵和值。

 

序列相關函數：
　　len(),max(),min(),sum(),any(),all(){所有都爲真都返回真}
列表中的方法：
　　　　L.index(v) #返回元素對應的索引下標
　　　　L.insert(index,obj)
　　L.count(x)
　　L.remove(obj)
　　L.copy()
　　L.append(x)
　　L.extend(lst) #L +=lit
　　L.clear()
　　L.sort()
　　L.pop(索引)
　　L.reverse() #列表的反轉
深拷貝deep copy,淺拷貝shallow copy
字符串的方法：
　　str.split() 分割 把字符串的空格用逗號分隔，返回列表
　　str.join() 鏈接 字符串的分隔符換成join裏面的數

小總結

1. 數據類型:
　　數值類型：
　　　　int, float, complex, bool
　　容器:
　　　　不可變的容器
　　　　　　str, tuple, frozenset, bytes(字節串)
　　　　可變的容器
　　　　　　list, dict, set, bytearray(字節數組)

　　　　有序的容器

　　　　　　str(字符串) list(列表) tuple(元組) bytes(字節串) bytearray(字節數組)

　　　　無序的容器

　　　　　　set(集合) dict(字典) 

 推導式總結：

　　　　列表：[x for x in range(10)]返回列表

　　　　集合：{x for x in range(10)}返回集合

　　　　字典：{x:x**2 for x in range(10)}返回字典

2.值:
　　None, False, True

3. 運算符
　　算術運算符
　　　　+ - * / //（保留整數）  %（求餘）  **（平方）
　　比較運算符:
　　　　< <= > >= == !=
　　　　in / not in 
　　　　is, is not
　　布爾運算:
　　　　not（非）, and（與）, or（或）
　　　　+(正號) -(負號)
　　　　&（按位與） |（按位或） ^（按位異或） ~（按位取反）
　　　　[] (索引,切片,鍵索引)

　　表達式:
　　1
　　1 + 2
　　max(1,2,3) # 函數調用是表達式
　　x if x > y else y, 條件表達式，把三條語句融合爲一條

語句
表達式語句:
　　全部的表達式均可以單獨寫在一行，造成一個語句,例:
　　print("hello world")
　　1 + 2
賦值語句:
　　a = 100
　　a = b = c = 100
　　x, y = 100, 200　　#交叉賦值
　　a[0] = 100　　#序列索引賦值
　　dict['name'] = 'tarena' 字典賦值
　　del 語句
　　if 語句
　　while 語句
　　for 語句
　　break 語句
　　continue語句
　　pass 語句

內建函數:

　　len(x), max(x), min(x), sum(x), any(x), all(x)
　　構造函數(用來建立同類型的數據對象)
　　布爾值 bool(x), int(x), float(x), complex(x),
　　list(x), tuple(x), str(x), dict(x), set(x),
　　frozenset(x)
　　abs(x)
　　round(x[,n])　　#四捨五入

1 print(round(80.63756, 2))   # 80.64保留小數點後兩位，對第三位進行四捨五入
2 print(round(56.6))  #57

round(x[,[n])

　　pow(x, y, z=None)

1 print(pow(2,2)) #   2**2 = 4
2 print(pow(2,2,2))   # 2 ** 2 % 2 = 0

pow(x,y[,z])

　　bin(x),返回一個整形int或者長整形long int的二進制表示

print(bin(10))  #0b1010

bin(int)

　　oct(x)將一個整數轉換成8進制字符串

print(oct(10))  #0o12

oct(int)

　　hex(x)將10進制整數轉換成16進制，以字符串形式表示

print(hex(195))  #0xc3

hex(int)

　　chr(x),用一個範圍在0～255整數(ASCII)做參數，返回一個對應的字符

1 >>>print chr(0x30), chr(0x31), chr(0x61)   # 十六進制
2 0 1 a
3 >>> print chr(48), chr(49), chr(97)         # 十進制
4 0 1 a

chr(10進制或者16進制)

　　ord(x)以一個字符做爲參數，返回對應的 ASCII 數值，或者 Unicode 數值，

1 >>>ord('a')
2 97
3 >>> ord('b')
4 98
5 >>> ord('c')
6 99

ord("一個字符")

　　range(start, stop, step)
　　input(x), print(x)