Python学习七 —— 元组、字典、集合

最新推荐文章于 2023-06-26 05:45:14 发布

视野很重要

最新推荐文章于 2023-06-26 05:45:14 发布

阅读量253

点赞数

分类专栏： Python学习

本文链接：https://blog.csdn.net/weixin_45760172/article/details/108760429

版权

Python学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1. 元组 tuple

元组是不可变序列
如果元组不是空元组，序列中至少有一个逗号

例子：
```
tuple1 = (1, 2, 3, 4)
print(tuple1, type(tuple1))
tuple2 = 10,
print(tuple2, type(tuple2))
```
输出值为：

(1, 2, 3, 4) <class ‘tuple’>
(10,) <class ‘tuple’>
元组的拆包，拆包的Value值数量需和变量数量一致，如果不一样，可以使用* 通配符
字符串的拆包

例子：

tuple1 = ([1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'])
a, b, c, d = tuple1
print(a[1], b[1], c[1], d[1])

输出值为：

a b c d

例子：

	tuple1 = ([1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'])
	a, b, *c = tuple1
	print(a, b, c)
	str1 = 'abcde'
	*a, b, c = str1
	print(a, b, c)

输出值为：

>[1, 'a'] [2, 'b'] [[3, 'c'], [4, 'd']]
['a', 'b', 'c'] d e

2. 字典

在这里插入图片描述

数据类型{key:value} 称之为一项
字典的创建方式
- dict1 = {}
- dict2 = dict( , , ,)
- dict3 = dict ([ ( ), ( ), ( ) ])
- Python2中将字典转换为有序字典，需要先导入包import collections
例子：
```
import collections
dict1 = {'name': '郭靖', 'age':30, 'gender':'男'}
print(dict1)
dict2 = dict(name='郭靖', age= 30, gender= '男')
print(dict2)
dict3 = dict= (['name', '郭靖'], ['age', 30], ['gender', '男'])
print(dict3)
dict4 = collections.OrderedDict([('name', '郭靖'), ('age', 30), ('gender', '男')])
print(dict4)
```
输出值为：

{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’}
{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’}
([‘name’, ‘郭靖’], [‘age’, 30], [‘gender’, ‘男’])
OrderedDict([(‘name’, ‘郭靖’), (‘age’, 30), (‘gender’, ‘男’)])
当key有重复，则后面会代替前面的
例子：
```
dict1 = {'name': '郭靖', 'age':30, 'gender':'男' , 'age':50}
print(dict1)
```
输出值为：

{‘name’: ‘郭靖’, ‘age’: 50, ‘gender’: ‘男’}

字典的写法要求，需要换行

dict1 = {'name': '郭靖',
         'age':30,
         'gender':'男'
         }
print(dict1)

输出值为：

{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’}

字典的取值

dict1 = {'name': '郭靖',
         'age':30,
         'gender':'男'
         }
print(dict1['name'])

输出值为：

郭靖

双值序列，子序列，双值子序列的概念
- 双值序列：序列中有两个值{ [1,2] , ‘ab’, (a,b)}
- 子序列：如果序列中的二元素也是序列，例如【‘123’】
- 双值子序列 [’ab’, ‘cd’]

3.字典的增删改查

len() in not in（判断是否有指定的key）

dict1 = {'name': '郭靖',
         'age':30,
         'gender':'男'
         }
print(dict1['name'],len(dict1))
print('name' in dict1)

输出值为：

郭靖 3
True

3.1 字典查询方法（2种）

可以根据键获取字典当中的值 dict[key]

get(key,default) 通过key获取Value，如果没有找到对应的key，则返回的value值为default值，若没设定，则default值为None

dict1 = {'name': '郭靖',
         'age':30,
         'gender':'男'
         }
print(dict1['name'], dict1.get('age'), dict1.get('gender1'))

输出值为：

郭靖 30 None

3.2 字典的修改方法（3种）

dict[key] = value，如果Key值不存在，则向字典中追加key-value
setdefault(key,default) ，向字典中添加Key-value，如果这个key已经存在于字典中，则返回value值,不会对字典有任何影响，如果这个key不存在，则会将kye和default的值添加进字典
```
dict1 = {'name': '郭靖',
         'age':30,
         'gender':'男'
         }
print(dict1.setdefault('age','没有找到'))
print(dict1)
print(dict1.setdefault('gongfu', '降龙十八掌'))
print(dict1)
```
输出值为：

30
{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’}
降龙十八掌
{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’, ‘gongfu’: ‘降龙十八掌’}
update()，作用是将新的字典中的key-value键值对加入到旧字典中，并不是将整个对象加入进旧字典中，个人理解有点像list.extend函数的概念
例子：
```
dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男'
}
d1 = { 1: '1',
       2: '2'
}
dict1.update(d1)
print(dict1)
```
输出结果为：

{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’, 1: ‘1’, 2: ‘2’}

3.3 字典的删除方法（4种）

删除字典 del（key）
例子：

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男'
}
del(dict1['name'])
print(dict1)

输出值为：

{‘age’: 30, ‘gender’: ‘男’}

popitem() 随机删除一个键值对，一般默认删除最后一个，他会将删除之后的键值对作为返回值返回，返回的是一个元组
例子：
```
dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门'
}
print(dict1.popitem())
print(dict1)
```
输出值为：

(‘address’, ‘北京天安门’)
{‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’}
pop（key,default)，
If key is in the dictionary, remove it and return its value, else return default. If default is not given and key is not in the dictionary, a KeyError is raised.
```
dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门'
}
resault = dict1.pop('name', '我是谁我在干什么？')
print(resault, dict1)
resault = dict1.pop('age1', '我活多久了？')
print(resault, dict1)
resault = dict1.pop('gender1')
print(resault, dict1)
```
输出值为：

郭靖 {‘age’: 30, ‘gender’: ‘男’, ‘address’: ‘北京天安门’}
我活多久了？ {‘age’: 30, ‘gender’: ‘男’, ‘address’: ‘北京天安门’}
Traceback (most recent call last):
File “D:/pythonKYLE/kyle_welcomepython.py”, line 10, in
resault = dict1.pop(‘gender1’)
KeyError: ‘gender1’

clear()
例子：

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门'
}
dict1.clear()
print(dict1)

输出值为：

{}

4. 序列——字典的深拷贝和浅拷贝 copy和deepcopy

copy 是新建一个对象，id值重新赋予，但是对象中的二阶值ID是拿来直接用的
- copy的例子：
```
dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门',
         'family':{
             'name':'小龙女',
             'age':18,
             'gender':'女'
         }
}
dict2 = dict1.copy()
dict1['age'] = 50
dict1['family']['age'] = 100
print(id(dict1['family']), id(dict1), dict1 )
print(id(dict2['family']), id(dict2), dict2 )
```
输出值为：

36593168 36593240 {‘name’: ‘郭靖’, ‘age’: 50, ‘gender’: ‘男’, ‘address’: ‘北京天安门’, ‘family’: {‘name’: ‘小龙女’, ‘age’: 100, ‘gender’: ‘女’}}
36593168 36622408 {‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’, ‘address’: ‘北京天安门’, ‘family’: {‘name’: ‘小龙女’, ‘age’: 100, ‘gender’: ‘女’}}

deepcopy 关键点在于将原二阶值的Id忽略，重新分配内存ID

deepcopy的例子

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门',
         'family':{
             'name':'小龙女',
             'age':18,
             'gender':'女'
         }
}
import copy
dict2 = copy.deepcopy(dict1)
dict1['age'] = 50
dict1['family']['age'] = 100
print(id(dict1['family']), id(dict1), dict1 )
print(id(dict2['family']), id(dict2), dict2 )

输出值为：

34692624 34692696 {‘name’: ‘郭靖’, ‘age’: 50, ‘gender’: ‘男’, ‘address’: ‘北京天安门’, ‘family’: {‘name’: ‘小龙女’, ‘age’: 100, ‘gender’: ‘女’}}
38784240 38782872 {‘name’: ‘郭靖’, ‘age’: 30, ‘gender’: ‘男’, ‘address’: ‘北京天安门’, ‘family’: {‘name’: ‘小龙女’, ‘age’: 18, ‘gender’: ‘女’}}

5. 字典的遍历

字典的遍历 dict.keys(),返回的是一个序列，保存的是所有的key
再通过for循环遍历value
dict.values() 返回的是一个序列，保存的是字典中的所有的值

dict.items() 返回的是字典中所有的项，返回的也是一个序列，这个序列是双值子序列
例子：

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门'
}
dkeys = dict1.keys()
for d1 in dkeys:
    print(d1, end=' ')
print('')
dvalues = dict1.values()
for d2 in dvalues:
    print(d2, end=' ')
print('')
ditems = dict1.items()
for dk, dv in ditems:
    print(dk, '=', dv, end = ', ')
print('')

输出值为：

name age gender address
郭靖 30 男北京天安门
name = 郭靖, age = 30, gender = 男, address = 北京天安门,

3. 集合 set{}

和列表的不同点

只能存储不可变的对象：元组，int，字符串，布尔类型
存储的对象是无序的,没有索引
```
setjihe = {123, 'ab', ('tuble'), None, True, False}
print(setjihe)
```
输出值为：

{False, True, None, ‘tuble’, ‘ab’, 123}

不能出现重复元素，True = 1,Faluse = 0，这个需要注意，最大的作用是可以去除重复
例子1：

setjihe = {1, 0, 'ab','ab', ('tuble'), None, True, False}
print(setjihe)
print(type(setjihe))

输出值为：

{0, 1, ‘tuble’, None, ‘ab’}
<class ‘set’>

例子2：

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门',
         'age2':30,
         'gender2':'男'
}
set_test = {}
list_test = []
for dvalue in dict1.values():
    list_test.append(dvalue)
set_test = set(list_test)
print(list_test)
print(set_test)

输出值为：

[‘郭靖’, 30, ‘男’, ‘北京天安门’, 30, ‘男’]
{‘郭靖’, ‘男’, ‘北京天安门’, 30}

字典转化为集合，只传递字典中key值
例子：

dict1 = {'name': '郭靖',
         'age': 30,
         'gender': '男',
         'address': '北京天安门'
         }
set1 = set()
set1 = set(dict1)
print(type(set1), set1)

输出值为：

<class ‘set’> {‘address’, ‘name’, ‘age’, ‘gender’}

4. 集合的使用

创建空集合，只能通过set1 = set()来创建

in ， not in， len()
例子：

setjihe = {1, 0, 'ab','ab', ('tuble'), None, True, False}
print(1 in setjihe, 0 not in setjihe, len(setjihe))

输出值为：

True False 5

set.add()
set.update() ，将新的集合转换为元素再添加到另一个集合中，和列表函数extend对比，还需要去重
set.pop 随机删除set中的一个元素，会返回一个值，与列表相似
set.remove
set.clear
例子：
```
set1 = {123, 'abc', ('name', '杨过', 'age', 30)}
set1.add(456)
print(set1)
set2 = {1111, 2222}
set1.update(set2)
print(set1)
set1.pop()
print(set1)
set1.remove(456)
print(set1)
set1.clear()
print(set1)
```
输出值为：

{456, 123, (‘name’, ‘杨过’, ‘age’, 30), ‘abc’}
{1111, 456, 123, 2222, (‘name’, ‘杨过’, ‘age’, 30), ‘abc’}
{456, 123, 2222, (‘name’, ‘杨过’, ‘age’, 30), ‘abc’}
{123, 2222, (‘name’, ‘杨过’, ‘age’, 30), ‘abc’}
set()

5.集合的运算

& 交集运算：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 & set2
print(set3)

运行结果为：

{3, 4}

| 并集运算

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 | set2
print(set3)

运行结果为：

{1, 2, 3, 4, 5, 6}

-差集运算

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 - set2
print(set3)

运行结果为：

{1, 2}

^ 亦或集运算

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 ^ set2
print(set3)

数据结果为：

{1, 2, 5, 6}

<= 检查一个集合是否是另一个集合的子集
< 检查一个集合是否是另一个集合的真子集

set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 4}
print(set2 <= set1)  # set2是否是set1的子集
print(set2 < set1)   # set2是否是set1的真子集

输出结果为：

True
False

“>=” 检查一个集合是否是另一个集合超集
“>” 检查一个集合是否另一个集合的真超集

set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 4}
print(set2 >= set1)  # set2是否是set1的超集
print(set2 > set1)   # set2是否是set1的真超集

输出结果为：

True
False

视野很重要

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python学习七 —— 元组、字典、集合

1. 元组 tuple元组是不可变序列如果元组不是空元组，序列中至少有一个逗号元组的拆包tuple1 = (1, 2, 3, 4)a, b, c, d = tuple1字符串的拆包2. 字典数据类型{key:value} 这个一个称之为一项字典的创建方式dict1 = {}dict2 = dict( , , ,)dict3 = dict ([ ( ), ( ), ( ) ])import collectionsd1
复制链接

扫一扫