元组
- 元组的创建
创建空元组
- 拆包
字典
- 字典的创建
- 字典的使用
删除指定的值
删除整个字典
清空字典
copy()
集合
- 集合的创建
- 集合的操作
添加
更新
删除

元组

元组是序列结构，但属于不可变类型，可以理解为不可变的列表，用tuple表示

元组的创建

把逗号分隔的不同的数据元素使用圆括号括起来
用tuple()进行创建 ```python
创建空元组
tup1 = () tup2 = tuple()

tu1 = tuple(9526) #报错 tu2 = tuple(‘63198’) #(‘6’,’3’,’1’,’9’,’8’) tu3 = (87,)或 87, #(,)形式 tu4 = (87) #


- 当创建的元组里面的元素类型为不可迭代时，会报错 形如 TypeError: 'int' object is not iterable
- 当以(,)方式来创建，只有一个元素时记得跟上英文状态下的逗号，否则就会觉得是普通小括号
<a name="O69fD"></a>
## 元组的操作
1. 与列表相同的操作
- 利用下标来访问元素
- 切片（形成新元组对象）
- tuple.count() / tuple.index()
- python内置函数：reversed()，sorted()
- 加法（做拼接）及乘法（只能与数乘，做扩展）
```python
# 访问元素
tupe1 = tuple('12345')
print(tupe1[2])            #3
print(tupe1[2:4])        #(3,4)
print(tupe1[-1:-4:2])    #(5,3)
# tuple.count() 和 tuple.index()
tupe2 = (6,8,3,4,8,5,1,6,9,8,6)
print(tupe2.count(8))    #3
print(tupe2.index(6))    #0 第一次出现该元素的索引值
# reversed()，sorted()
tupe3 = (6,8,10)
print(tuple(reversed(tu3)))        #(10,8,6) 一定要加tuple！！！
tupe4 = (3,8,0)
print(sorted(tu4)))        #[0,3,8]升序，返回的是列表 当改成prin(tuple(sorted(tu4)))，返回的是(0,3,8)且类型为元组

不允许的操作

不允许修改、新增元素。(一级)
不允许删除某个元素（但可以删除整个元组）
元组没有任何会对内部元素发生修改动作的方法，如remove、append、pop等 ```python tu = (1,2,3) tu[1] = 5 #报错，TypeError: ‘tuple’ object does not support item assignment

print(tu+(4,)) #(1,2,3,4)这种方法只能创建新的元组，不能修改元组 print(tu+(4,5)) #(1,2,3,4,5) ——————-可以更改 tu1 = (1,2,3,[‘xiaopang’,5]) tu1[3][0] = 4 print(tu1) #(1,2,3,[4,5]) ——————-不可以更改 tu2 = (1,2,3,(‘xiaopang’,5)) tu2[3][0] = 4 print(tu2) #报错，TypeError: ‘tuple’ object does not support item assignment

根据上面应用总结如下：

- 元组所消耗的内存要比列表少
- 当你的元素**不需要改变**时，推荐使用**元组**；当你的元素**需要改变**时，推荐使用**列表**
<a name="FGAhn"></a>
## 元组与列表的转换

- list-->tuple    tuple(iterable)
- tuple-->list    list(iterable)
```python
li = [1,2,3]
print(tuple(li))    #(1,2,3)

tu = (1,2,3)
print(list(tu))        #[1,2,3]

拆包

#元组的拆包
tupel = (2,3)
a,b = tupel    #a = 2,b = 3
a,b,c = tupel    # 报错 元素太多

a,*b = (4,5,6)    # a = 4  b = [5,6]
*a,*b = (1,2,3,4)    # 会报错，变量中只能有一个带星
*a,b = (7,9,8,6)    # a = [7,9,8]  b = 6
a,*b,c = (7,9,8,6)    # a= 7  b = [9,8]  c = 6

#字符串的拆包
a,*b = 'wasfegrt'        #a='w'  b= ['a','s','f','e','g','r','t']

#列表的拆包
a,*b = [4,6,1,3,5]    #a = 4  b = [6,1,3,5]

带星的接收后数据类型是列表

字典

Python的字典数据类型是基于hash散列算法实现的，采用键值对 (key:value) 的形式，根据key的值计算 value 的地址，具有非常快的查取和插入速度。它是一种可变对象 ，所以支持修改、插入、删除等操作。
字典属于的数据结构称为映射（mapping），与列表一样是用来储存对象的容器
列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素，这个唯⼀的名字我们称之为key；通过key可以快速查询value也可以称之为值。因此字典也称之为键值对(key-value)结构
每个字典中都可以有多个键值对，每⼀个键值对我们称其为⼀项(item)
```
d = {key1 : value1, key2 : value2 }
```
字典的创建
创建空字典 ```python d1 = {} print(d1,type(d1)) # {}

d2 = dict() print(d2,type(d2)) # {}

创建⼀个有数据的字典  语法 {key:value}
```python
dic1 = {'name':'xiaopang','age':18}
print(dic1,type(dic1))

dic2 = dict('name'='xiaopang','age'=18)
print(dic2,type(dic2))

dic2 = dict[('name','xiaopang'),('age',18)]
print(dic3,type(dic3))

dic1 == dic2 == dic3    # {'name':'xiaopang','age':18}  <class 'dict'>

注意：

字典的值可以是任意对象字典的键可以是任意的不可变对象(int str bool tuple….)
字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

字典的使用
访问字典：字典属于集合类型，不属于序列类型，它没有下标的概念，更没有切片的说法。因此不允许用下标索引值，而是把相应的键放入方括号来访问对应值。
```
dic = {'name':'amy','age':18}
print(dic['name'])        # 'amy'
print(dic[1])            # 报错，字典不属于序列类型
print(dic['gender'])    # 报错，key值不存在
```

添加和修改

dic = {'name':'amy','age':18}
dic['name'] = 'xiaopang'
print(dic)        # 修改value {'name':'xiaopang','age':18}
dic['gender'] = 'male'
print(dic)        # 添加 key-value {'name':'xiaopang','age':18,'gender':'male'}

字典的删除 ```python

删除指定的值
snacks = {‘薯片’:11.2,’瓜子’:8.8,’牛奶’:5,’坚果’:18.5} del snacks[‘瓜子’] print(snacks) # {‘薯片’:11.2,’牛奶’:5,’坚果’:18.5} snacks.pop(‘牛奶’) # pop里面必须传参数，否则会报错 TypeError: pop expected at least 1 arguments, goto print(snacks) # {‘薯片’:11.2,’坚果’:18.5}

删除整个字典

del snacks print(snacks) # 报错，该名称未定义 NameError: name ‘snacks’ is not defined 证明整个字典已经被删除

清空字典

snacks.clear() print(snacks) # {}


- 字典的方法
   - update()：把一个字典的键值对更新到另一个字典中，无返回值
   - get()：返回指定键的值，如果不存在，则返回默认值
   - items()：以列表返回字典的所有键值对（常与循环使用）常用于遍历字典
   - keys()：以列表返回字典所有的键
   - values()：以列表返回字典所有的值
```python
# update()
dic1 = {'王铭':1001,'张莉':1002}
dic2 = {'余温':1003}
dic1.update(dic2)
print(dic1)            # {'王铭':1001,'张莉':1002,'余温':1003}

# get()
snacks = {'薯片': 11.2,'瓜子': 8.8,'牛奶': 5,'坚果': 18.5,'大白兔': 8.8,'绿豆糕': 12.3}
print(snacks.get('大白兔'))    # 8.8
print(snacks.get('榴莲糖'))    # None

# items()
snacks = {'薯片': 11.2,'瓜子': 8.8,'牛奶': 5,'坚果': 18.5,'大白兔': 8.8,'绿豆糕': 12.3}
for k,v in snakes.items():
    print('键：', k, end=' ')
    print('值：', v)
# 结果如下：
键: 薯片 值: 11.2
键: 瓜子 值: 8.8
键: 牛奶 值: 5
键: 坚果 值: 18.5
键: 大白兔 值: 8.8
键: 绿豆糕 值: 12.3

# keys()、values()
print(snacks.keys())        # dict_keys(['薯片', '瓜子', '牛奶', '坚果', '大白兔', '绿豆糕'])
print(snacks.values())        # dict_valus([11.2, 8.8, 5, 18.5, 8.8, 12.3])

copy()

深拷贝和浅拷贝（可参照可变数据类型和不可变数据类型的id值是否变化）

浅拷贝只能对第一层的数据进行拷贝，如果第一层的数据同样为可变类型，那么浅拷贝无需重新拷贝一份形成新的id
深拷贝可以对所有数据类型进行拷贝，形成新的id
集合
集合是一个无序不重复的元素集，是可变数据类型，它的核心在于自动去重
集合的创建
集合使用大括号({})框定元素，并以逗号进行分隔。但是注意：如果要创建一个空集合，必须用 set() 而不是 {} ，因为后者创建的是一个空字典。
```
s = {}
print(s,type(s))        # {} <class 'dict'>
s1 = set()
print(s,type(s))        # set() <class 'set'>
s2 = set([1, 2, 3, 1, 2, 6, 3, 12])
print(s2)        # {1, 2, 3, 6, 12} 集合具有自动去重功能
s3 = set('hello kugou')
print(s3)        # {'o', 'u', ' ', 'k', 'g', 'l', 'h', 'e'} 容全部拆开，去重，无序
```
集合的操作

添加元素：通过add()将元素添加到集合中

注意：①可以重复添加，但是会自动去重果；②不能添加可变对象
更新元素：通过update()将一个对象更新到已有的集合中，同样会进行去重
删除元素：
- set.remove(key)：删除指定元素
- set.pop()：随机删除元素(注意：无参数) ```python
  添加
  s1 = set([1,2,3,4,5]) s1.add(3) print(s1) # {1, 2, 3, 4, 5} 自动去重 s1.add(8) print(s1) # {1, 2, 3, 4, 5, 8} s1.add(‘xiaopang’) print(s1) # {1, 2, 3, 4, 5, ‘xiaopang’} 添加的元素可以使不可变类型 s1.add([54,26]) print(s1) # 报错，它只能添加不可变对象

更新

s1 = set(5,6,8,2,3) s1.update(‘xiaopang’) print(s1) # {5, 6, 8, 2, 3, ‘x’, ‘i’, ‘a’, ‘o’, ‘p’, ‘n’, ‘g’}

删除

s = set(‘胖’, 571, ‘y’, ‘u’, 666) del s[2] # 报错集合是无序的，没有索引下标的概念 s.remove(571) print(s) # {‘胖’, ‘y’, ‘u’, 666} s.remove(‘x’) # 元素不存在时会报错 s.pop() # 随机删除集合内元素

<a name="pluqB"></a>
## 集合的运算
集合的操作符

| **操作符及运算** | **描述** |
| :---: | :---: |
| S - T  差集运算 | 返回新的集合，包含在S中但不在T中的元素 |
| S & T  交集运算 | 返回新的集合，包含同时在S和T中的元素 |
| S ^ T 亦或运算 | 返回新的集合，包含在S和T中非公共元素 |
| S &#124; T  并集运算 | 返回新的集合，包含在S和T中的所有元素 |

集合使用方法

| **方法** | **描述** |
| :---: | :---: |
| s.issubset(t) | 若 s 是 t 的子集，返回 True，否则返回 False |
| s.issuperset(t) | 若 s 是 t 的超集，返回 True，否则返回 False |
| s.union(t) | 返回新的集合，s 和 t 的并集 |
| s.intersection(t) | 返回新的集合，s 和 t 的交集 |
| s.difference(t) | 返回新的集合，元素属于s 但不属于 t |
| s.symmertric_difference(t) | 返回新的集合，s 和 t 的不重复元素 |
| s.copy(t) | 返回新的集合，s 的浅复制 |

<a name="CBE8K"></a>
# 数据类型总结

- 可变类型主要有list、dict、set，当里面的元素发生改变时，它的id()值不会发生变化
- 不可变类型主要有int、float、str、tuple、byte，当里面的元素发生改变时，它的id()值会发生变化
<a name="Ogyd2"></a>
# 练习

1. 在a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}} 找到python1/python2/python3。
```python
# 通过索引值即可获取到这三个元素
a = {"name":"123","data"}
print(a['data']['result'][0]['src'])    #python1
print(a['data']['result'][1]['src'])    #python2
print(a['data']['result'][2]['src'])    #python3

有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key中，将小于66值保存至第⼆个key的值中。

a = [11,22,33,44,55,66,77,88,99,90]
dic = {}
lst1 = []
lst2  =[]
for i in a:
 if i > 66:
     lst1.append(i)
 else:
     lst2.append(i)
print(lst1,lst2)
dic['key1'] = lst1
dic['key2'] = lst2
print(dic)

Python基础

数据类型(三)

元组

元组的创建

创建空元组

拆包

字典

字典的创建

字典的使用

删除指定的值

删除整个字典

清空字典

copy()

集合

集合的创建

集合的操作

添加

更新

删除