主要內容：
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元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
