一、列表(list)
?列表（list）是python以及其他語言中最常用到的數據結構之一。Python使用中括號 [ ] 來解析列表。列表是可變的（mutable）——可以改變列表的內容。
列表是Python的序列類型之一，也支持索引、切片等操作。
1.1 列表的定義
1
list1 = [
'
Google
'
,
'
Runoob
'
, 1997, 2000
]
2
list2 = [1, 2, 3, 4, 5
]
3
list3 = [
"
a
"
,
"
b
"
,
"
c
"
,
"
d
"
]
與字符串的索引一樣，列表索引從0開始。列表可以進行截取、組合等。
1.2 列表的查詢
1
#
!/usr/bin/env python
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
names = [
'
張三
'
,
"
李四
"
,
"
王五
"
,
"
趙六
"
]
9
10
print
(names[2
])
11
12
print
(names[0:3
])
13
14
print
(names[0:7
])
15
16
print
(names[-1
])
17
18
print
(names[0:3:1
])
19
20
print
(names[3:0:-1
])
21
22
print
(names[:])
1.2 增加數據
insert 方法用于將對象插入到列表中
append方法則用于在列表末尾追加新的對象
extend 方法可以在列表的末尾一次性追加另一個序列中的多個值。
names_class2.append(
'
aa
'
)
names_class2.insert(
2,
'
alvin
'
)
print
(names_class2)
>>> a = [1, 2, 3
]
>>> b = [4, 5, 6
]
>>>
a.extend(b)
>>>
a
[
1, 2, 3, 4, 5, 6]
extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。
>>> a = [1, 2, 3
]
>>> b = [4, 5, 6
]
>>>
a.extend(b)
>>>
a
[
1, 2, 3, 4, 5, 6
]
>>>
>>> a +
b
[
1, 2, 3, 4, 5, 6, 4, 5, 6
]
>>>
a
[
1, 2, 3, 4, 5, 6]
1.3 修改數據
names_class2 = [
'
張三
'
,
'
李四
'
,
'
王五
'
,
'
趙六
'
]
names_class2[
3] =
'
趙七
'
names_class2[0:
2] = [
'
su
'
,
'
alvin
'
]
print
(names_class2)
#
['su', 'alvin', '王五', '趙七']
1.4 刪除數據
1
#
!/usr/bin/env python
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
names_class2 = [
'
張三
'
,
'
李四
'
,
'
王五
'
,
'
趙六
'
]
9
10
#
刪除第一個元素del
11
del
names_class2[0]
12
13
print
(names_class2)
#
['李四', '王五', '趙六']
14
15
#
pop 默認刪除的是最后一個元素 注意,pop是有一個返回值的，返回的是被刪除的內容
16
name2 =
names_class2.pop()
17
print
(name2)
#
趙六
18
print
(names_class2)
#
['李四', '王五']
19
20
#
remove 需要指定刪除的元素
21
names_class2.remove(
'
李四
'
)
22
print
(names_class2)
23
24
#
clear 清空列表
25
lst1 = [1, 2, 3, 4
]
26
lst1.clear()
27
print
(lst1)
#
[]
1.5 其它的常用操作
1.5.1 count
統計某個元素在列表中出現的次數
>>> [
'
to
'
,
'
be
'
,
'
or
'
,
'
not
'
,
'
to
'
,
'
be
'
].count(
'
to
'
)
2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2
]]]
>>> x.count(1
)
2
>>> x.count([1,2
])
1
1.5.2 index
從列表中找出某個值第一個匹配項的索引位置
names_class2 = [
'
張三
'
,
'
李四
'
,
'
王五
'
,
'
趙六
'
,
'
李四
'
]
print
(names_class2.index(
"
李四
"
))
#
1
1.5.3 reverse
reverse 方法將列表中的元素進行反轉。
list1 = [
'
s
'
,
'
b
'
,
'
c
'
,
'
d
'
]
list1.reverse()
print
(list1)
#
結果為：['d', 'c', 'b', 's']
?1.5.4 sort
sort用于列表排序
x = [4, 6, 2, 1, 7, 9
]
#
正序
x.sort()
print
(x)
#
[1, 2, 4, 6, 7, 9]
#
倒序
x.sort(reverse=
True)
print
(x)
#
[9, 7, 6, 4, 2, 1]
二、元組(tuple)
- python中元組與列表很類似，為只讀列表，即數據可以被查詢，但不能被修改，所以，列表的切片操作同樣適用于元組。
- 元組寫在小括號()里，元素之間用逗號隔開。
- 另外，元組的意義還在于，元組可以在映射（和集合的成員）中當作鍵使用——而列表則不行；元組作為很多內建函數和方法的返回值存在。
tup1 = (
'
a
'
,
'
b
'
,
'
c
'
,
'
d
'
, 11, 12
)
print
(tup1[0])
print
(tup1[0:3
])
print
(len(tup1))
2.1 元組的拆包
元組拆包可以應用到任何可迭代對象上， 唯一的硬性要求是， 被可迭代對象中的元素數量必須要跟接受這些元素的元組的空檔數一致。 除非我們用 * 來表示忽略多余的元素
1
#
!/usr/bin/env python
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/7/9
7
"""
8
9
#
平行賦值拆包
10
a, b = (11, 22
)
11
print
(a)
#
11
12
print
(b)
#
22
13
14
15
#
優雅的寫法: 數據交換
16
a, b =
b, a
17
18
#
用_來替代
19
_, _, c = (33, 44, 55
)
20
print
(c)
#
55
21
22
#
用*來替代
23
a1, *a2, a3 = (11, 22, 33, 44, 55, 66
)
24
print
(a1)
#
11
25
print
(a2)
#
[22, 33, 44, 55]
26
print
(a3)
#
66
2.2 具名元組
collections.namedtuple 是一個工廠函數， 它可以用來構建一個帶字段名的元組和一個有名字的類——這個帶名字的類對調試程序有很大幫助。
用 namedtuple 構建的類的實例所消耗的內存跟元組是一樣的， 因為字段名都被存在對應的類里面。 這個實例跟普通的對象實例比起來也要小一些， 因為 Python不會用 __dict__ 來存放這些實例的屬性。
1
#
!/usr/bin/env python
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/7/9
7
"""
8
import
collections
9
10
"""
11
創建一個具名元組需要兩個參數， 一個是類名， 另一個是類的各個字段的名字。 后者可以是由數個字符串組成的可迭代對象， 或者是由空格分隔開的字段名組成的字符串。
12
存放在對應字段里的數據要以一串參數的形式傳入到構造函數中（注意， 元組的構造函數卻只接受單一的可迭代對象）
13
你可以通過字段名或者位置來獲取一個字段的信息
14
"""
15
city = collections.namedtuple(
'
City
'
,
'
name country population coordinates
'
)
16
17
tokyo = city(
'
Tokyo
'
,
'
JP
'
, 36.933, (25.689722, 129.691667
))
18
19
print
(tokyo)
#
City(name='Tokyo', country='JP', population=36.933, coordinates=(25.689722, 129.691667))
20
print
(type(tokyo))
#
?
三、字典
字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。
字典(dictionary)是除列表之外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
?
3.1 創建字典
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
#
方式一
dic1 =
{
"
name
"
:
"
zhangsan
"
,
"
age
"
: 36
,
"
sex
"
:
"
female
"
}
print
(dic1)
#
{'name': 'zhangsan', 'age': 36, 'sex': 'female'}
#
方式二
dic2 = dict(((
"
name
"
,
"
abc
"
), ))
print
(dic2)
#
{'name': 'abc'}
#
空字典
dic3 =
dict()
print
(dic3)
#
{}
# 或者
dic4 = {}
3.2 字典添加數據
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
dic1
=
dict()
dic1[
'
name
'
] =
'
zhangsan
'
dic1[
'
age
'
] = 18
print
(dic1)
#
{'name': 'zhangsan', 'age': 18}
#
如果鍵不存在于字典中，將會添加鍵并將值設為default,如果存在，則不會做任何操作
a = dic1.setdefault(
'
name
'
,
'
abc
'
)
print
(a)
#
zhangsan
b
= dic1.setdefault(
'
cc
'
,
'
dd
'
)
print
(b)
#
dd
print
(dic1)
#
{'name': 'zhangsan', 'age': 18, 'cc': 'dd'}
3.3 查詢字典數據
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
dic3
= {
'
name
'
:
'
aa
'
,
'
age
'
: 18
}
print
(dic3[
'
name
'
])
#
aa
#
print(dic3['names']) # 字典中沒有這個key時，會報錯KeyError: 'names'
print
(dic3.get(
'
age
'
, False))
#
18
print
(dic3.get(
'
ages
'
, False))
#
get不到key時，會返回默認值False
#
items 以列表返回可遍歷的(鍵, 值) 元組數組
print
(dic3.items())
#
keys返回一個迭代器，可以使用 list() 來轉換為列表,包含字典的額所有的鍵
print
(dic3.keys())
#
返回一個迭代器，可以使用 list() 來轉換為列表，包含字典的所有value
print
(dic3.values())
#
用成員運算符 in 判斷key是否在字典中
print
(
'
name
'
in
dic3)
#
python2中用has_key判斷 dic3.has_key('name')
print
(list(dic3.values()))
3.4 修改字典的數據
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
dic3
= {
'
name
'
:
'
aa
'
,
'
age
'
: 18
}
dic3[
"
name
"
] =
"
alivn
"
print
(dic3)
#
{'name': 'alivn', 'age': 18}
#
update 把字典dict4的鍵/值對更新到dict3里
dic4 = {
'
sex
'
:
'
male
'
,
'
hobby
'
:
'
girl
'
,
'
age
'
: 36
}
dic3.update(dic4)
print
(dic3)
#
{'name': 'alivn', 'age': 36, 'sex': 'male', 'hobby': 'girl'}
3.5 刪除字典中的數據
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
dic3
= {
'
name
'
:
'
aa
'
,
'
age
'
: 18
}
#
刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。
aa = dic3.pop(
'
name
'
)
print
(aa)
#
aa
print
(dic3)
#
{'age': 18}
#
clear() 刪除字典內所有元素
dic3.clear()
print
(dic3)
#
{}
#
del 刪除字典中指定的鍵值對
dic4 = {
"
name
"
:
"
cc
"
,
"
age
"
: 19,
"
male
"
:
"
sex
"
}
del
dic4[
"
name
"
]
print
(dic4)
#
{'age': 19, 'male': 'sex'}
#
刪除字典，包括變量的內存空間
del
dic4
print
(dic4)
#
報錯 NameError: name 'dic4' is not defined
3.6 其它操作及涉及的方法
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
#
fromkeys 創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
d1 = dict.fromkeys([
'
host1
'
,
'
host2
'
,
'
host3
'
],
'
Mac
'
)
print
(d1)
#
{'host1': 'Mac', 'host2': 'Mac', 'host3': 'Mac'}
d1[
'
host1
'
] =
'
xiaomi
'
print
(d1)
#
######
d2 = dict.fromkeys([
'
host1
'
,
'
host2
'
,
'
host3
'
], [
'
Mac
'
,
'
huawei
'
])
print
(d2)
#
結果：{'host1': ['Mac', 'huawei'], 'host2': ['Mac', 'huawei'], 'host3': ['Mac', 'huawei']}
d2[
'
host1
'
][0] =
'
xiaomi
'
print
(d2)
dic
= {
"
a
"
:
"
123
"
}
dic1
= dic.fromkeys(
"
王健林
"
,
"
王思聰
"
)
print
(dic1)
#
結果：{'王': '王思聰', '健': '王思聰', '林': '王思聰'}
3.7 字典的嵌套與遍歷
字典的嵌套操作：
av_catalog =
{
"
歐美
"
: {
"
www.youporn.com
"
: [
"
很多免費的,世界最大的
"
,
"
質量一般
"
],
"
www.pornhub.com
"
: [
"
很多免費的,也很大
"
,
"
質量比yourporn高點
"
],
"
letmedothistoyou.com
"
: [
"
多是自拍,高質量圖片很多
"
,
"
資源不多,更新慢
"
],
"
x-art.com
"
:[
"
質量很高,真的很高
"
,
"
全部收費,屌比請繞過
"
]
},
"
日韓
"
:{
"
tokyo-hot
"
:[
"
質量怎樣不清楚,個人已經不喜歡日韓范了
"
,
"
聽說是收費的
"
]
},
"
大陸
"
:{
"
1024
"
:[
"
全部免費,真好,好人一生平安
"
,
"
服務器在國外,慢
"
]
}
}
av_catalog[
"
大陸
"
][
"
1024
"
][1] +=
"
,可以用爬蟲爬下來
"
print
(av_catalog[
"
大陸
"
][
"
1024
"
])
#
ouput ['全部免費,真好,好人一生平安', '服務器在國外,慢,可以用爬蟲爬下來']
字典的遍歷
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
s
dic1
=
{
"
name
"
:
"
aaa
"
,
"
age
"
: 18
,
'
sex
'
:
"
male
"
}
for
key, value
in
dic1.items():
print
(key, value)
"""
結果：
name aaa
age 18
sex male
"""
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
data
=
{
'
山東
'
: {
'
青島
'
: [
'
四方
'
,
'
黃島
'
,
'
嶗山
'
,
'
李滄
'
,
'
城陽
'
],
'
濟南
'
: [
'
歷城
'
,
'
槐蔭
'
,
'
高新
'
,
'
長青
'
,
'
章丘
'
],
'
煙臺
'
: [
'
龍口
'
,
'
萊山
'
,
'
牟平
'
,
'
蓬萊
'
,
'
招遠
'
]
},
'
江蘇
'
: {
'
蘇州
'
: [
'
滄浪
'
,
'
相城
'
,
'
平江
'
,
'
吳中
'
,
'
昆山
'
],
'
南京
'
: [
'
白下
'
,
'
秦淮
'
,
'
浦口
'
,
'
棲霞
'
,
'
江寧
'
],
'
無錫
'
: [
'
崇安
'
,
'
南長
'
,
'
北塘
'
,
'
錫山
'
,
'
江陰
'
]
},
}
exit_flag
= False
#
設置全局變量，用來退出循環，實現任意一級菜單都可以退出
while
not
exit_flag:
for
i1
in
data:
#
讀取第一級菜單
print
(i1)
choice
= input(
'
選擇進入1,第一級，按q退出：
'
)
if
choice
in
data:
while
not
exit_flag:
for
i2
in
data[choice]:
#
讀取第二級菜單
print
(i2)
choice2
= input(
'
選擇進入2,按b返回上一級，按q退出：
'
)
if
choice2
in
data[choice]:
while
not
exit_flag:
for
i3
in
data[choice][choice2]:
#
讀取第三級菜單
print
(i3)
choice3
= input(
'
選擇進入3,按b返回上一級，按q退出：
'
)
if
choice3
in
data[choice][choice2]:
for
i4
in
data[choice][choice2][choice3]:
print
(i4)
choice4
= input(
'
最后一層，按b返回上一級，按q退出：
'
)
if
choice4 ==
'
b
'
:
pass
#
占位符
if
choice4 ==
'
q
'
:
exit_flag
=
True
if
choice3 ==
'
b
'
:
break
if
choice3 ==
'
q
'
:
exit_flag
=
True
if
choice2 ==
'
b
'
:
break
if
choice2 ==
'
q
'
:
exit_flag
=
True
if
choice ==
'
q
'
:
exit_flag
= True
四、集合(set)
集合是一個無序的，不重復的數據組合，它的主要作用如下：
-
去重，把一個列表變成集合，就自動去重了
-
關系測試，測試兩組數據之前的交集、差集、并集等關系
集合(set)：把不同的元素組成一起形成集合，是python基本的數據類型。
集合中的元素必須是可hash的，但是set本身是不可hash的
集合元素(set elements):組成集合的成員(不可重復)
集合的分類：
- 可變集合(set)：可添加和刪除元素，非可哈希的，不能用作字典的鍵，也不能做其他集合的元素
- 不可變集合(frozenset): 與上面正好相反
初識集合：
li = [1, 2,
'
a
'
,
'
b
'
]
s
=
set(li)
print
(s)
#
{1, 2, 'a', 'b'}
li2
= [1, 2, 1,
'
a
'
,
'
a
'
]
s
=
set(li2)
print
(s)
#
{1, 2, 'a'}
集合不允許嵌套：
li = [[1, 2],
'
a
'
,
'
b
'
]
s
= set(li)
#
TypeError: unhashable type: 'list'
print
(s)
4.1 集合的創建
由于集合沒有自己的語法格式，只能通過集合的工廠方法set()和frozenset()創建
s1 = set(
'
alvin
'
)
s2
= frozenset(
'
yuan
'
)
print
(s1, type(s1))
#
{'l', 'v', 'i', 'a', 'n'}
集合用作字典的鍵：
lst1 = [1, 2, 4
]
#
dic1 = {set(lst1): "aa"} # TypeError: unhashable type: 'set'
# 字典的鍵可以是不可變集合，可hash的，不能是可變集合
aa
=
frozenset(lst1)
dic1
= {aa:
"
bb
"
}
print
(dic1)
#
{frozenset({1, 2, 4}): 'bb'}
4.2 訪問集合
s1 = set(
'
alvin
'
)
print
(
'
a
'
in
s1)
print
(
'
b
'
in
s1)
#
s1[1] #TypeError: 'set' object does not support indexing
for
i
in
s1:
print
(i)
#
#
True
#
False
#
v
#
n
#
l
#
i
4.3 更新集合
s.add()
s.update()
s.remove()
注意只有可變集合才能更新
#
s1 = frozenset('alvin')
#
s1.add(0) # AttributeError: 'frozenset' object has no attribute 'add'
s2
= set(
'
alvin
'
)
s2.add(
'
mm
'
)
print
(s2)
#
{'mm', 'l', 'n', 'a', 'i', 'v'}
s2.update(
'
HO
'
)
#
添加多個元素
print
(s2)
#
{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}
s2.remove(
'
l
'
)
print
(s2)
#
{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}
4.4 刪除集合
del? 可以刪除集合
4.5 集合的操作符
- in ,not in
- 集合等價與不等價(==, !=)
- 子集、超集
#
!/usr/bin/env python
#
-*-coding:utf-8-*-
"""
@author:fyh
@time:2019/5/31
"""
#
聯合 聯合(union)操作與集合的or操作其實等價的，聯合符號有個等價的方法，union()。
s1 = set(
'
alvin
'
)
s2
= set(
'
yuan
'
)
s3
= s1|
s2
print
(s3)
#
{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
print
(s1.union(s2))
#
{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
#
交集 與集合and等價，交集符號的等價方法是intersection()
a1 = set(
'
alvin
'
)
a2
= set(
'
yuan
'
)
a3
= a1 &
a2
print
(a3)
#
{'n', 'a'}
print
(s1.intersection(s2))
#
{'n', 'a'}
#
差集 等價方法是difference()
b1 = set(
'
alvin
'
)
b2
= set(
'
yuan
'
)
b3
= b1 -
b2
print
(b3)
#
{'v', 'i', 'l'}
print
(s1.difference(s2))
#
{'v', 'i', 'l'}
#
對稱差集 等價方法symmetric_difference
c1 = set(
'
alvin
'
)
c2
= set(
'
yuan
'
)
c3
= c1 ^
c2
print
(c3)
#
{'l', 'v', 'y', 'u', 'i'}
print
(s1.symmetric_difference(s2))
#
{'l', 'v', 'y', 'u', 'i'}
4.6 集合應用
'''
最簡單的去重方式
'''
lis
= [1,2,3,4,1,2,3,4
]
print
(list(set(lis)))
#
[1, 2, 3, 4]
?
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
