主要內容:
2、集合
3、元組
4、字典
復習:
字符串和元組一樣,只能讀不能寫。列表和字典可以嵌套任何東西,列表可以嵌套列表
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'}
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()
| 生成兩個集合的并集
& 生成兩個集合的交集
- 生成兩個集合的補集
^ 生成兩個集合的對稱補集(也就是兩個集合的并集減去交集)
> 判斷一個集合是另一個集合的超集
< 判斷一個集合是另一個集合的子集
==, ?!= 判斷集合是否相同
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
?
固定集合? 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)) #類型為元組類型 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]
字典
字典是 可修改 的 無序 序列,字典使用 花括號 {},可以存儲任意類型對象,
字典由 鍵值對 組成{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
? 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.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.keys() #以列表返回一個字典所有的鍵

1 dict = { ' Name ' : ' Zara ' , ' Age ' : 7 } 2 3 print " Value : %s " % dict.keys() # Value : ['Age', 'Name']
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'}
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
pow(x, y, z=None)

1 print (pow(2,2)) # 2**2 = 4 2 print (pow(2,2,2)) # 2 ** 2 % 2 = 0
bin(x), 返回一個整形int或者長整形long int的二進制表示

print (bin(10)) # 0b1010
oct(x) 將一個整數轉換成8進制字符串

print (oct(10)) # 0o12
hex(x) 將10進制整數轉換成16進制,以字符串形式表示

print (hex(195)) # 0xc3
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
ord(x) 以 一個字符 作為參數,返回對應的 ASCII 數值,或者 Unicode 數值,

1 >>>ord( ' a ' ) 2 97 3 >>> ord( ' b ' ) 4 98 5 >>> ord( ' c ' ) 6 99
range(start, stop, step)
input(x), print(x)
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索:z360901061

微信掃一掃加我為好友
QQ號聯系: 360901061
您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。
【本文對您有幫助就好】元
