Python元组相关知识
1. 元组简介
1.1 元组基本介绍
- Python 的元组与列表类似，不同之处在于元组的元素不能修改。
- 元组表现形式tuple。
- 元组是⼀个不可变序列(⼀般当我们希望数据不改变时，我们使⽤元组，其他情况下基本都⽤列表。
- 元组使用小括号，列表使用方括号。元组不是空元组⾄少有⼀个 逗号(,) 当元组不是空元组时括号可以省略。
- 元组解包指将元组当中的每⼀个元素都赋值给⼀个变量。
tup1 = ('python', 'liuyu', 1984, 99.88)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d" # 不需要括号也可以
print(type(tup1)) # <class 'tuple'>
print(type(tup2)) # <class 'tuple'>
print(type(tup3)) # <class 'tuple'>
- 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
tup1 = (50)
print(type(tup1)) # <class 'int'>
tup2 = (50,)
print(type(tup2)) # <class 'tuple'>
1.2 访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
tup1 = ('python', 'liuyu', 1984, 99.88)
tup2 = (1,2,3,4,5)
print(tup1[0]) # python
print(tup1[1:3]) # ('liuyu', 1984)
# tup1[0] = 'Python'
# print(tup1) # TypeError: 'tuple' object does not support item assignment 修改元组元素操作是非法的。
tup3 = tup1 + tup2
print(tup3) # ('python', 'liuyu', 1984, 99.88, 1, 2, 3, 4, 5)
1.3 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup1 = ('python', 'liuyu', 1984, 99.88)
# tup1.pop() # AttributeError: 'tuple' object has no attribute 'pop'
# tup1.remove() # AttributeError: 'tuple' object has no attribute 'remove' 元组元素值是不允许删除的
del tup1
print(tup1) # NameError: name 'tup1' is not defined 可以通过del进行删除
1.4 元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| 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 | 迭代 |
1.5 元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
L = ('Google', 'Taobao', 'Runoob')
print(L[0]) # Google
print(L[-1]) # Runoob
print(L[0:2]) # ('Google', 'Taobao')
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | ‘Runoob’ | 读取第三个元素 |
| L[-2] | ‘Taobao’ | 反向读取，读取倒数第二个元素 |
| L[1:] | (‘Taobao’, ‘Runoob’) | 截取元素，从第二个开始后的所有元素。 |
1.6 元组内置函数
Python元组包含了以下内置函数
| 序号 | 方法及描述 | 实例 |
|---|---|---|
| 1 | len(tuple) 计算元组元素个数。 | >>> tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’) |
len(tuple1)
3|
| 2 | max(tuple)
返回元组中元素最大值。 | >>> tuple2 = (‘5’, ‘4’, ‘8’)max(tuple2)
‘8’|
| 3 | min(tuple)
返回元组中元素最小值。 | >>> tuple2 = (‘5’, ‘4’, ‘8’)min(tuple2)
‘4’|
| 4 | tuple(iterable)
将可迭代系列转换为元组。 | >>> list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’]tuple1=tuple(list1)
tuple1
(‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’) |
1.7 关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
L = ('Google', 'Taobao', 'Runoob')
L[0]= 'liuyu' # TypeError: 'tuple' object does not support item assignment 元组中的元素值无法进行修改
print(L)
list1 = ('Google', 'Taobao', 'Runoob')
print(id(list1)) # 2602683897896
list1 = (1,2,3,4,5)
print(id(list1)) # 2602680296200 内存地址发生了变化
2. 可变对象
Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。⽽列表list、字典dict、集合set是可变类型
可变对象中都保存了三个数据
- id(标识)
- type(类型)
- value(值)
可变对象指的就是我们可以对对象里面的value进行改变，可变对象中的值发生变化，但是内存地址不变。
list4 = ['python', 'liuyu', 1984, 99.88, 'Hello World', 'python', 'python']
print(id(list4)) # 3127787033800 内存地址未发生变化
list4.pop(1)
print(list4) # ['python', 1984, 99.88, 'Hello World', 'python', 'python'] 删除列表中的值，但是内存地址未发生变化
print(id(list4)) # 3127787033800 内存地址未发生变化
list4[5]='test'
print(list4) # ['python', 1984, 99.88, 'Hello World', 'python', 'test'] 改变列表中的值，但是内存地址未发生变化
print(id(list4)) # 3127787033800 内存地址未发生变化
list4.append('好玩的')
print(list4) # ['python', 1984, 99.88, 'Hello World', 'python', 'test', '好玩的'] 增加列表中的值，但是内存地址未发生变化
print(id(list4)) # 3127787033800 内存地址未发生变化
3. 字典简介
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号(**{})**中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
#键必须是唯一的，但值则不必。
#值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
#一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
- 字典属于⼀种新的数据结构称为映射(mapping)
- 字典的作⽤和列表类似，都是⽤来存储对象的容器
- 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
- 在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素。
- 这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
- 字典我们也称之为键值对(key-value)结构
- 每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)
- 创建⼀个有数据的字典 语法 {key:value}
- 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str booltuple…)
- 字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的
3.1 访问字典里的值
把相应的键放入到方括号中，如下实例:
dic = {'name': 'liuyu', 'age': 18, '体重': 69.5}
# 通过key返回value
print("name:", dic['name']) # name: liuyu
print("age:", dic['age']) # age: 18
print("体重:", dic['体重']) # 体重: 69.5
# 如果字典中没有key，则报错
print("身高：", dic['身高']) # KeyError: '身高'
3.2 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
dic = {'name': 'liuyu', 'age': 18, '体重': 69.5}
# 通过key返回value
dic['name'] = 'python'
dic['age'] = 30
dic['体重'] = 75
print("dic内容:", dic) # dic内容: {'name': 'python', 'age': 30, '体重': 75}
3.3 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
dic = {'name': 'liuyu', 'age': 18, '体重': 69.5}
del dic['name'] # 删除键 'name' {'age': 18, '体重': 69.5}
print(dic)
dic.clear() # 清空字典 {}
print(dic)
del dic # 删除字典,NameError: name 'dic' is not defined
print(dic)
3.4 字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
dic = {'name': 'liuyu', 'age': 18, '体重': 69.5, 'name': 'python'}
print(dic) # {'name': 'python', 'age': 18, '体重': 69.5} name被赋值两次，最后打印的为最后一次的值
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
dic = {['name']: 'liuyu', 'age': 18, '体重': 69.5, 'name': 'python'}
print(dic)
# Traceback (most recent call last):
# File "C:/Users/MAC/PycharmProjects/phl/Moudule/test1.py", line 7, in <module>
# dic = {['name']: 'liuyu', 'age': 18, '体重': 69.5, 'name': 'python'}
# TypeError: unhashable type: 'list'
3.5 字典内置函数&方法
Python字典包含了以下内置函数：
| 序号 | 函数及描述 | 实例 |
|---|---|---|
| 1 | len(dict) 计算字典元素个数，即键的总数。 | >>> dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} |
len(dict)
3 |
| 2 | str(dict)
输出字典，以可打印的字符串表示。 | >>> dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}str(dict)
“{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}” |
| 3 | type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。 | >>> dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}type(dict)
<class ‘dict’> |
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | radiansdict.clear() 删除字典内所有元素 |
| 2 | radiansdict.copy() 返回一个字典的浅复制 |
| 3 | radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | key in dict 如果键在字典dict里返回true，否则返回false |
| 6 | radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表 |
| 8 | radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 随机返回并删除字典中的最后一对键和值。 |
# 可以通过dict()函数来创建字典
a = dict(name='liuyu', age=18, 体重=69.5) # {'name': 'liuyu', 'age': 18, '体重': 69.5}
print(a)
# 双值子序列
# 双值序列 序列中只有两个值,('x',1),'ab',[5,6]
# 子序列 如果序列中元素也是序列 那么我们就称这个元素为子序列 [(4,5),(6,7)]
b = dict([('name', 'liuyu'), ('age', 18), ('体重', 69.5)])
print(b, type(b))
# len()函数可以获取字典中键值对的个数
print(len(b)) # 3
# in 检查字典中是否包含指定的键
a = 'name' in b
print(a) # True
# not in 检查字典中是否不包含指定的键
a = 'name' not in b
print(a) # False
# get(key[,default]) 该方法可以根据字典中的key来获取值
print(b.get('name')) # liuyu
# 如果获取字典中的键不存在 就会返回None
print(b.get('python')) # None
# 也可以指定一个默认值来作为第二个参数 这样获取不到值的时候回返回默认值
print(b.get('python','该值不存在')) # 该值不存在
# 修改字典 dict[key] = value
c = {'name': 'liuyu', 'age': 18, '体重': 69.5}
c['身高'] = 175 # 像字典中添加key-value
print(c) # {'name': 'liuyu', 'age': 18, '体重': 69.5, '身高': 175}
# dict.setdefault(key[,default]) 字典中添加key-value
# 如果key已经存在到字典当中，则返回key的值 不会对字典做任何操作
# 如果key不存在，则像字典中添加这个Key 并设置value
c.setdefault('name','liuyu')
print(c) # {'name': 'liuyu', 'age': 18, '体重': 69.5, '身高': 175} 不做任何操作
r = c.setdefault('python','liuyu')
print(r) # 新增python的这个key，同时设置值为：liuyu
print(c) # {'name': 'liuyu', 'age': 18, '体重': 69.5, '身高': 175, 'python': 'liuyu'}
# update()
# 将其他字典中的key-value添加到当前的字典当中
# 如果有重复的key 则后面的会替换到当前的
d = {'name': 'liuyu', 'age': 18, '体重': 69.5}
e = {'d':4,'e':5,'f':6,'a':7}
d.update(e)
print(d) # {'name': 'liuyu', 'age': 18, '体重': 69.5, 'd': 4, 'e': 5, 'f': 6, 'a': 7}
# popitem() 一般都会删除最后一个
# 删除之后它会将key-value作为返回值返回
# 返回的是一个元组 元组中有2个元素 第一个元素时key 第二个元素时value
d.popitem()
print(d) # {'name': 'liuyu', 'age': 18, '体重': 69.5, 'd': 4, 'e': 5, 'f': 6}
r = d.popitem()
print(d) # {'name': 'liuyu', 'age': 18, '体重': 69.5, 'd': 4, 'e': 5}
print(r) # ('f', 6)
# pop(key[,default]) 根据key删除字典中的key-value
# 会将删除的值返回
e = {'d':4,'e':5,'f':6,'a':7}
r = e.pop('d') # 4 降删除的值返回
d = e.pop('z','没有这个key值') # 没有这个key值
print(r)
print(d)
3.6 copy()
copy() ⽅法⽤来对字典进⾏潜复制
注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进⾏复制的
# 采用正常的赋值语句
d = {'a':1,'b':2,'c':3}
d2 = d
print(d2) # {'a': 1, 'b': 2, 'c': 3}
d['b'] = 50
print(d2) # {'a': 1, 'b': 50, 'c': 3} d2受到了影响
# 复制后的对象和原对象是独立，修改一个不会影响另一个
e = {'a':1,'b':2,'c':3}
e2 = e.copy()
e['b'] =50
print('e =',e,id(e)) # e = {'a': 1, 'b': 50, 'c': 3} 2387552784032
print('e2 =',e2,id(e2)) # e2 = {'a': 1, 'b': 2, 'c': 3} 2387552817296 e2没有受到e改变的影响
# -------------------------------------------------
# 浅复制只会复制字典本身,如果字典中还有个字典是不会被复制的
# 浅复制会简单复制对象内部的值,如果值也是个可变对象，这个可变对象不会被复制
f = {'a':{'name':'蜘蛛侠','age':10},'b':2,'c':3}
f2 = f.copy()
f2['a']['name'] = 'liuyu'
print('f =',f,id(f))
print('f2 =',f2,id(f2))
4. 遍历字典
- keys() 该方法返回的是字典所有的Key
- values() 返回一个序列，该序列中保存有字典的值
- items() 返回字典所有的项 它返回的是一个序列 序列包含的是双值子序列
- 双值分别是 字典中的Key和value
d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys()) # dict_keys(['a', 'b', 'c'])
print(d.values()) # dict_values([1, 2, 3])
for k in d.keys():
print(k, end=' ') # a b c 遍历所有key
for v in d.values():
print(v, end=' ') # 1 2 3 遍历所有values
for k, v in d.items():
print(k, v, end=' ') # a 1 b 2 c 3 遍历所有values
5. 集合
5.1 集合简介
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用** set()** 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
a = {'liuyu', 12345, 'python'} # 返回<class 'set'>
print(type(a))
b = set('liuyu') # 返回<class 'set'>
print(type(b))
- 集合表现形式set 集合和列表⾮常相似
不同点
- 集合只能存储不可变对象
- 集合中存储的对象是⽆序的
- 集合不能出现重复元素
- 使⽤{}来创建集合
- 可以通过set()来将序列和字典转换成集合
- len() 使⽤len()来获取集合中元素的数量
- add()像集合中添加元素
- update()将⼀个集合中的元素添加到另⼀个集合当中
- pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
- remove() 删除集合中指定的元素
- clear() 清空集合
5.2 集合操作
5.2.1 添加元素
语法格式如下：
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
a = set(('liuyu', 12345, 'python')) # 返回{12345, 'python', 'liuyu'}
print(a)
a.add('liuyu') # 返回：{12345, 'liuyu', 'python'} 如果元素已经存在，则不进行任何操作
print(a)
a.add('test')
print(a) # 返回：{12345, 'test', 'python', 'liuyu'} 新增test新元素
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
a = set(('liuyu', 12345, 'python')) # 返回{12345, 'python', 'liuyu'}
a.update('test') # 更新字符串
print(a)
a.update({6,7,8}) # 更新字典
print(a)
a.update([22,'Hello']) # 更新列表
print(a)
a.update(set('movie')) # 更新元组
print(a)
# {'python', 'e', 's', 'liuyu', 't', 12345}
# # # {'python', 'e', 6, 7, 's', 8, 'liuyu', 't', 12345}
# # # {'python', 'e', 6, 7, 's', 8, 'Hello', 'liuyu', 't', 22, 12345}
# # # {'python', 'e', 6, 7, 's', 8, 'i', 'Hello', 'liuyu', 't', 'o', 'm', 22, 12345, 'v'}
5.2.2 移除元素
语法格式如下：
# s.remove( x ) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
# s.discard( x ) 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。
# s.pop() 我们也可以设置随机删除集合中的一个元素
a = set(('liuyu', 12345, 'python')) # 返回{12345, 'python', 'liuyu'}
a.remove('liuyu') # 更新字符串
print(a) # {'python', 12345}
# a.remove('test')
# print(a)
# 没有元素则会发生报错
# Traceback (most recent call last):
# File "C:/Users/MAC/PycharmProjects/phl/Moudule/test1.py", line 10, in <module>
# a.remove('test')
# KeyError: 'test'
a.discard('python')
print(a) # {12345}
b = set(('宝马','奔驰','路虎','大众'))
b.pop()
print(b) # {'路虎', '宝马', '奔驰'}
5.2.3 计算集合元素个数
语法格式如下：
len(s)
计算集合元素个数示例：
a = set(('liuyu', 12345, 'python'))
print(len(a)) # 返回：3
a.remove('liuyu')
print(len(a)) # 返回：2
5.2.4 清空集合
语法格式如下：
s.clear()
示例：
a = set(('liuyu', 12345, 'python'))
print(len(a)) # 返回：3
a.clear()
print(len(a)) # 返回：0
5.2.5 判断元素是否在集合中存在
语法格式如下：
x in s
判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。示例：
a = set(('liuyu', 12345, 'python'))
print('liuyu' in a) # 返回：True
print('test' in a) # 返回：False
集合内置方法完整列表
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
5.2 集合的运算
- & 交集运算
- | 并集运算
-
- 差集运算
- ^ 亦或集
- <= 检查⼀个集合是否是另⼀个集合的⼦集
- < 检查⼀个集合是否是另⼀个集合的真⼦集
-
=检查⼀个集合是否是另⼀个集合的超集
-
检查⼀个集合是否是另⼀个集合的真超集
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) # 这里演示的是去重功能{'orange', 'pear', 'banana', 'apple'}
# 下面展示两个集合间的运算.
a = set('abracadabra')
b = set('alacazam')
print(a) # {'a', 'b', 'c', 'd', 'r'}
print(b) # {'a', 'z', 'l', 'c', 'm'}
print(a - b) # 集合a中包含而集合b中不包含的元素{'d', 'b', 'r'}
print(a | b) # 集合a或b中包含的所有元素{'c', 'a', 'd', 'r', 'l', 'z', 'b', 'm'}
print(a & b) # 集合a和b中都包含了的元素{'a', 'c'}
print(a ^ b) # 不同时包含于a和b的元素{'z', 'm', 'b', 'r', 'l', 'd'}
print(a > b) # False
print(a >= b) # False
print(a < b) # False
print(a <= b) # False
6. 练习
a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到
python1/python2/python3
a = {"name": "123", "data": {"result": [{"src": "python1"}, {"src": "python2"}, {"src": "python3"}]}} # 设置字典a
print(type(a)) # <class 'dict'> #查看a的类型
b = (a["data"]) # 通过key提取data的值赋予b
print(b, type(b)) # {'result': [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]} <class 'dict'> 查看b的元素值和类型
c = b["result"] # 再通过key提取result的值赋予c
print(c, type(
c)) # [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}] <class 'list'> 查看c的元素值和类型，此刻c为多个字典组成的列表，那么开始遍历此列表，通过索引的方式切片得到每一个子字典
i = 0
for i in range(len(c)): # i在c范围内进行循环
d = c[i] # 通过索引得到c中的每个子字典赋予d
e = d['src'] # 针对d中字典key提取value
print(e, end='/') # python1/python2/python3/
扫一扫
2154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
