Python列表,元组,字典,集合详细操作

菜鸟学Python第五天
数据类型常用操作及内置方法
列表(list)
基本使用

用途
用来存取多个同属性的值，用索引对应值，索引反映的是位置

定义方式
在[]内用逗号分隔开多个任意类型的值

l = [1, 2.2, ‘str’, ‘list’, ‘…’] # l= list([1, 2.2, ‘str’, ‘list’, ‘…’])
类型转换

list可以将str、list、dict、tuple等可以被for循环循环的类型转换为列表。

注：list只可以将dict的key遍历出来

d = {‘name’: ‘Jason’, ‘age’: 23, ‘weight’: 78, ‘height’: 183}
L = list(d)
print(L)
​
[‘name’, ‘age’, ‘weight’, ‘height’]

常用操作+内置的方法
优先掌握的操作

按索引取值：可以正向存取、也可以反向存取

复制代码
names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
print(names[3]) # 正向取值
print(names[-3]) # 反向取值
names[1] = ‘irving’ # 按索引更改列表元素
print(names)
​
rose
curry
[‘james’, ‘irving’, ‘paul’, ‘rose’]
​
复制代码

注意：当索引超出范围时，按索引更改列表元素则会报错

切片(顾头不顾尾，步长)

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
print(names[1:4])
​
[‘curry’, ‘paul’, ‘rose’]
长度list.len()：统计列表元素个数

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
print(len(names))
​
4
成员运算in 、 not in：判断字符是否在列表内

list.append() & list.insert() : 追加&插入

复制代码
names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
names.append(‘ivring’)
print(names)
​
[‘james’, ‘curry’, ‘paul’, ‘rose’, ‘ivring’]

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
names.insert(1,‘ivring’)
print(names)
​
[‘james’, ‘ivring’, ‘curry’, ‘paul’, ‘rose’]
复制代码
注：append的只能从列表的末尾进行添加，insert可以在设定索引位置的前面添加，不设置索引时默认添加在开头

del list[索引]、list.remove(object)、list.pop(索引)：删除

del、remove、 pop的区别

del是通用的删除方式，并不为list特有

remove是按照list内的成员进行删除，而del、pop是按照索引进行删除操作。。

del、remove删除后没有返回值，pop则返回删除的那个成员

复制代码
names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
del names[3] # 删除’rose’
print(names.remove(‘paul’)) # 删除‘paul’并打印返回值
print(names.pop(1)) # 删除’curry’并打印返回值
print(names) #打印最终列表
​
None # remove返回值为空
curry # pop返回值为‘curry’
[‘james’] # 最终列表
复制代码
循环

for循环

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
for i in names:
print(i)
需要掌握内容

list.count(object):统计列表中某元素的个数

names = [‘james’, ‘curry’, ‘paul’, ‘rose’, ‘rose’, ‘rose’, ‘rose’]
print(names.count(‘rose’))
​
4
list.extend(iterable):将另一列表内元素添加到原列表中，并赋值给原列表

复制代码
names = [‘james’, ‘curry’, ‘paul’, ‘rose’]

print(names.count(‘rose’))

names1 = [‘love’, ‘Hardon’]
names.extend(names1) # 将names1添加到names后面并赋值给names，此操作无返回值
print(names)
​
[‘james’, ‘curry’, ‘paul’, ‘rose’, ‘love’, ‘Hardon’]
复制代码
list.index(iterable):从左到右查找列表中某元素第一次出现的位置

names = [‘james’, ‘curry’, ‘paul’, ‘rose’, ‘rose’, ‘rose’, ‘rose’]
print(names.index(‘rose’))
​
3
list.reverse()：将list翻转，并赋值给原列表

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
names.reverse() # 翻转，此操作无返回值
print(names)
​
[‘rose’, ‘paul’, ‘curry’, ‘james’]

list.sort()：排序（默认从小到大，列表内必须为同一可比较类型）

names = [‘james’, ‘curry’, ‘paul’, ‘rose’]
names.sort() # 排序操作，无返回值
print(names)
​
[‘curry’, ‘james’, ‘paul’, ‘rose’]

==该类型总结

存多个值

有序

可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

元组(tuple)
基本使用

用途
元组就是一个不可变的列表

定义方式
在()内用逗号分隔开多个任意类型的元素（逗号才是关键）

t = (1, 2.2, ‘aa’) # t = tuple()
print(type(t))
​
<class ‘tuple’>

类型转换：

复制代码
t1=tuple(‘hello’)
t2=tuple([1,2,3])
print(t1)
print(t2)
​
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(1, 2, 3)
复制代码

常用操作+内置的方法
优先掌握操作：

按照索引取值

切片

长度

成员运算

循环

复制代码
t = (1, 2, 3, 4, 5)
print(t[3]) # 索引取值
print(t[1: 3]) # 切片操作
print(len(t)) # 长度计算
print(2 in t) # 成员运算
​
4
(2, 3)
5
True
复制代码

需要掌握操作：

tuple.index(object):从左到右查找某元素在元组中第一次出现的位置

tuple.count(object):统计元组中某元素的个数

复制代码
t = (1, 2, 3, 3, 4, 5)
print(t.index(2))
print(t.count(3))
​
1
2
复制代码
==该类型总结

存多个值

有序

不可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

字典(dict)
基本使用

用途
记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性功能

定义方式
在{}内用逗号分隔开多个元素，每个元素都是key：value的形式，其中key是不可变类型，通常是字符串类型，而value可以是任意类型。

s = {‘name’:‘James’,‘age’:‘34’,‘height’:‘203 cm’, ‘T_tpye’:‘all_round’}

s = dict({‘name’:‘James’,‘age’:‘34’,‘height’:‘203 cm’, ‘T_tpye’:‘all_round’})

类型转换：加深理解

复制代码

第一种

d=dict(x=1,y=2,z=3)
print(d)
​
{‘x’: 1, ‘y’: 2, ‘z’: 3}

第二种

items = [(‘name’, ‘egon’), (‘age’, 18), (‘gender’, ‘male’)]
d = dict(items)
print(d)
​
{‘name’: ‘egon’, ‘age’: 18, ‘gender’: ‘male’}
复制代码

常用操作+内置的方法
优先掌握

按key存取值：可存可取

key存在则为赋值操作，key不存在则添加字典key：value

复制代码
msg = {‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
msg[‘name’] = ‘Lebron’ # 修改key对应的value
msg[‘team’] = ‘lakers’ # 添加字典key：value
print(msg)
​
{‘name’: ‘Lebron’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’, ‘team’: ‘lakers’}
复制代码
dict[‘key’]:没有则报错

dict.get(key):没有报none

复制代码
msg = {‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
print(dsg[‘team’]) # key 不存在字典中，会报错
print(msg.get(‘team’)) #key 不在字典中返回None
​
KeyError: ‘team’
None
复制代码
长度len()：统计字典中键值对的个数

成员运算in 或者not in（以字典的key为准）

pop 、popitem(随机删)：删除

使用方法同字典pop，并返回删除key

键keys()，值values()，键值对items()

复制代码

msg = {‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
msg.keys()
dict_keys([‘name’, ‘age’, ‘height’, ‘T_tpye’])

msg.values()
dict_values([‘James’, ‘34’, ‘203 cm’, ‘all_round’])

msg.items()
dict_items([(‘name’, ‘James’), (‘age’, ‘34’), (‘height’, ‘203 cm’), (‘T_tpye’, ‘all_round’)])
复制代码
循环

复制代码
msg = {‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
for k, v in msg.items(): # k,v=(‘name’, ‘egon’)
print(k, v)
​
name James
age 34
height 203 cm
T_tpye all_round
复制代码

需要掌握

dict.update():函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

复制代码
msg = {‘name’: ‘James’, ‘age’: ‘34’}
msg1 = {‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
msg.update(msg1) # 更新操作，无返回值
print(msg)
​
{‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203 cm’, ‘T_tpye’: ‘all_round’}
复制代码
dict.setdefault(key,value)：当key存在时不改原值，并返回原值，当key不存在时增加新value

复制代码
msg = {‘name’: ‘James’, ‘age’: ‘34’}
print(msg.setdefault(‘age’, ‘35’))
print(msg.setdefault(‘height’, ‘203’))
print(msg)
​
34
203
{‘name’: ‘James’, ‘age’: ‘34’, ‘height’: ‘203’}
复制代码
注：当返回的value不是输入的新value时，标明字典中包含该key，当返回value是输入的心value时则表明之前字典中不包含该key，可以用来判断字典中是否含有某元素。

==该类型总结 存多个值 无序

可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

集合(set)
基本使用

用途
关系运算

去重

定义方式
在{}内用逗号分隔开多个元素

S = {1,2,3,4,5} # S = set({1,2,3,4,5})
元素的特点：

集合内元素必须是不可变类型

集合内元素无序

集合内元素不可重复

类型转换：

set可以将能用for循环循环的数据类型转换为集合

3. 常用操作+内置的方法

优先掌握

长度len():返回集合内元素个数

成员运算in、not in：判断集合中是否存在某元素

并（合）集set.union(set1, set2…)，快捷键：|

交集set.intersection(set1, set2 … )，快捷键：&

差集set.difference(set)，快捷键：-

对称差集set.symmetric_difference(set)，快捷键：^

复制代码
a_club = {‘jason’, ‘tony’, ‘jay’, ‘allen’}
b_club = {‘rose’, ‘alice’, ‘allen’, ‘tony’}
print(a_club | b_club) # 并集
print(a_club & b_club) # 交集
print(a_club - b_club) # 差集，只在a_club中的成员
print(b_club - a_club) # 差集，只在b_club中的成员
print(a_club ^ b_club) # 对称差集 没有同时在两个集合的成员
​
{‘allen’, ‘jason’, ‘rose’, ‘jay’, ‘alice’, ‘tony’}
{‘allen’, ‘tony’}
{‘jason’, ‘jay’}
{‘alice’, ‘rose’}
{‘jason’, ‘rose’, ‘jay’, ‘alice’}
复制代码
==：集合中元素完全一致

父集和子集>=、<=：描述的是一种包含和被包含的关系

复制代码
s1 = {1, 2, 3}
s2 = {1, 2, 3}
s3 = {1, 2, 3, 4}
print(s1 == s2)
print(s3 >= s1)
print(s1 <= s3)
​
​
True
True
True
复制代码

需要掌握

update();更新

s1={1,2,3}
s1.update({3,4,5,6})
print(s1)
​
{1, 2, 3, 4, 5, 6}
pop():随机删，并返回删除元素

s1={1,‘aa’,‘bb’,3}
print(s1.pop())
​
1
remove()：按元素删，当元素不存在时报错

discard()：按元素删，当元素不存在时不报错

复制代码

remove

s1 = {1,‘aa’,‘bb’,3}
res = s1.remove(‘bbbbbb’)
print(s1) # 不存在即报错
print(res) # 打印返回值（无返回值）
​
KeyError:‘bbbbbb’
​

discard

s1 = {1,‘aa’,‘bb’,3}
res = s1.diiscard(‘bbbbbb’)
print(s1) # 不存在不报错
print(res) # 没有返回值
​
{3, 1, ‘aa’, ‘bb’}
None
复制代码
add()：添加

s1 = {1,‘aa’,‘bb’,3}
s1.add(4)
print(s1)
​
{1, 3, ‘aa’, 4, ‘bb’}
集合的去重的局限性：

只能针对不可变类型*

不能保证原来的顺序

==该类型总结

存多个值

无序

可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

———————————————————————————————————

一、列表
列表是Python中最基本的数据结构，是最常用的Python数据类型，列表的数据项不需要具有相同的类型
列表是一种有序的集合，可以随时添加和删除其中的元素
列表的索引从0开始
1、创建列表
复制代码

list1 = [‘python’, 2018, ‘python3’, 1994]
list1
[‘python’, 2018, ‘python3’, 1994]

list2 = [1, 2, 3, 4]
list2
[1, 2, 3, 4]

list3 = [‘a’, ‘b’, ‘c’, ‘d’]
list3
[‘a’, ‘b’, ‘c’, ‘d’]
复制代码
2、获取列表元素个数

len(list1)
4
3、访问列表中的值
（1）使用索引来访问列表中的值，列表的索引从0开始：

复制代码

list1[0]
‘python’

list1[1]
2018

list1[2]
‘python3’

list1[3]
1994

list1[4]
Traceback (most recent call last):
File “”, line 1, in
IndexError: list index out of range
复制代码
注意：当索引超出范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(list1) - 1。

（2）还可以获取列表最后一个元素：

list1[-1]
1994
以此类推，可以获取倒数第2个、倒数第3个、倒数第4个：

复制代码

list1[-2]
‘python3’

list1[-3]
2018

list1[-4]
‘python’

list1[-5]
Traceback (most recent call last):
File “”, line 1, in
IndexError: list index out of range
复制代码
当然，倒数第5个元素已越界，需要注意一下。

（3）切片

截取列表前3个元素：

list1[0:3]
[‘python’, 2018, ‘python3’]

list1[:3] #如果第一个索引是0，可以省略
[‘python’, 2018, ‘python3’]
倒数切片：

list1[-2:] #获取后2个元素
[‘python3’, 1994]

list1[-2:-1]
[‘python3’]
前4个元素，每两个取一个：

list1[:4:2]
[‘python’, ‘python3’]
所有元素，每3个取一个：

list1[::3]
[‘python’, 1994]
原样复制一个列表：

list1[:]
[‘python’, 2018, ‘python3’, 1994]
4、合并列表

list4 = list2 + list3
list4
[1, 2, 3, 4, ‘a’, ‘b’, ‘c’, ‘d’]
5、更新列表

list1
[‘python’, 2018, ‘python3’, 1994]

list1[1] = 2017
list1
[‘python’, 2017, ‘python3’, 1994]
6、删除列表

del list4
7、清空列表

list1
[‘python’, 2017, ‘python3’, 1994]

list1.clear()
list1
[]
8、列表操作的函数和方法
列表操作包含以下函数:

cmp(list1, list2) #比较两个列表的元素
len(list) 　　 #列表元素个数
max(list) 　　　　#返回列表元素最大值
min(list) 　　　　#返回列表元素最小值
list(seq) 　　　　#将元组转换为列表
列表操作包含以下方法:

复制代码
list.append(obj) 　　　　 #在列表末尾添加新的对象
list.count(obj)　　　　　　#统计某个元素在列表中出现的次数
list.extend(seq)　　　　 #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)　　　　　 #从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) #将对象插入列表
list.pop(obj=list[-1])　#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)　　　　 #移除列表中某个值的第一个匹配项
list.reverse()　　　　　　#反向列表中元素
list.sort([func])　　　　#对原列表进行排序
复制代码

二、元组
元组(tuple)和列表(list)非常类似，但是元组一旦初始化就不能修改，且元组使用小括号而列表使用中括号。

1、创建元组
复制代码

tup1 = (‘python’, 2018, ‘python3’, 1994)
tup1
(‘python’, 2018, ‘python3’, 1994)

tup2 = (1, 2, 3, 4)
tup2
(1, 2, 3, 4)

tup3 = (‘a’, ‘b’, ‘c’, ‘d’)
tup3
(‘a’, ‘b’, ‘c’, ‘d’)
复制代码
注意：元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

tup4 = (‘hello’,)
2、合并元组

tup5 = tup2 + tup3
tup5
(1, 2, 3, 4, ‘a’, ‘b’, ‘c’, ‘d’)
3、删除元组

del tup5
tup5 #此时tup5已不存在，所有报错
Traceback (most recent call last):
File “”, line 1, in
NameError: name ‘tup5’ is not defined
元组的操作基本与列表的操作一直，除了不能修改元组本身外。

三、字典
字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型
字典在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度
字典中键是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
1、创建字典
复制代码

dict1 = {‘a’: 1, ‘b’: 2, ‘b’: ‘3’}
dict1
{‘a’: 1, ‘b’: ‘3’} #因为键存在相同，所以后面的键值替换了前面的键值

dict2 = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
dict2
{‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}

dict3 = { ‘abc’: 123, 98.6: 37 }
dict3
{‘abc’: 123, 98.6: 37}
复制代码
2、访问字典中的值
复制代码

dict2[‘Beth’]
‘9102’

dict2[‘Beth1’] # 如果字典中没有的键访问值，会输出以下错误
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘Beth1’
复制代码
3、修改字典

dict1
{‘a’: 1, ‘b’: ‘3’}

dict1[‘b’] = 666
dict1
{‘a’: 1, ‘b’: 666}
4、删除字典元素
能删单一的元素也能清空字典，并且可以直接删除字典

复制代码

dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}
dict
{‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}

del dict[‘Name’] #删除键是’Name’的条目
dict
{‘Age’: 7, ‘Class’: ‘First’}

dict.clear() #清空词典所有条目
dict
{}

del dict #删除词典
复制代码
5、字典内置函数和方法
Python字典包含了以下内置函数：

cmp(dict1, dict2) #比较两个字典元素。
len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：

复制代码
dict.clear() 　　　　　　　　 #删除字典内所有元素
dict.copy() 　　　　　　　　 　　　　 #返回一个字典的浅复制
radiansdict.fromkeys() 　　　　　　 #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default=None) 　　　　 #返回指定键的值，如果值不在字典中返回default值
dict.has_key(key) 　　　　 #如果键在字典dict里返回true，否则返回false
dict.items() 　　　　　　　　　　　　 #以列表返回可遍历的(键, 值) 元组数组
dict.keys() 　　　　　　　　　　　　　　#以列表返回一个字典所有的键
dict.setdefault(key, default=None) #和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
dict.update(dict2) 　　　 #把字典dict2的键/值对更新到dict里
dict.values() 　　　　　　 #以列表返回字典中的所有值
复制代码
四、集合
集合（set）是一个无序不重复元素的序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1、创建集合
复制代码
#创建一个空集合

set1 = set()
set1
set()

#创建一个具有数据的集合

set2 = {1, ‘a’, ‘apple’, 11.22}
set2
{11.22, 1, ‘apple’, ‘a’}

set3 = set([1, 2, 3])
set3
{1, 2, 3}
复制代码
2、判断元素是否在集合内

‘apple’ in set2
True

‘apple’ not in set2
False
3、添加元素
复制代码
#将值添加到集合中，如果值存在，则不作任何操作

set2.add(‘car’)
set2
{1, ‘apple’, ‘car’, 11.22, ‘a’}

#另外一种添加方式，参数可以是列表、元组、字典等

set2.update({2,3})
set2
{1, ‘apple’, 2, 3, ‘car’, 11.22, ‘a’}

set2.update([1,4],[5,6])
set2
{1, ‘apple’, 2, 3, 4, 5, 6, ‘car’, 11.22, ‘a’}
复制代码
4、删除元素
复制代码

set2.remove(‘car’)
set2
{1, ‘apple’, 2, 3, 4, 5, 6, 11.22, ‘a’}

set2.remove(‘hello’) #如果元素不存在会发生错误
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘hello’

#这种方式如果元素不存在不会发生错误

set2.discard(‘hello’)
复制代码
5、计算集合元素个数

len(set2)
9
6、清空集合

set2.clear()
set2
set()