过一遍Python基础---Day3

---

文章声明⭐⭐⭐

1. 该文章为我（有编程语言基础，非编程小白）的 Python自学笔记
2. 知识来源为 Python官方文档 / 菜鸟教程 ，归纳为自己的语言与理解记录于此
3. 不出意外的话，我大抵会 持续更新
4. 想要了解前端开发（技术栈大致有：Vue2/3、微信小程序、uniapp、HarmonyOS、NodeJS、Typescript）与Python的小伙伴，可以关注我！谢谢大家！

---

让我们开始今天的学习吧！

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改
元组使用小括号 ( ) 来表示，列表使用方括号 [ ] 来表示，解释器中代码如下：

>>> tup1 = (1,2,3)
>>> tup1
(1, 2, 3)
>>> tup2 = 4,5,6 # 不加括号也可以
>>> tup2
(4, 5, 6)
>>> tup3 = ([1,2,3],[4,5,6],[tup1,tup2])
>>> tup3
([1, 2, 3], [4, 5, 6], [(1, 2, 3), (4, 5, 6)])

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，解释器中代码如下：

>>> tup1 = (10)
>>> tup1
10
>>> print(type(tup1))
<class 'int'>
>>> tup2 = (10,)
>>> tup2
(10,)
>>> print(type(tup2))
<class 'tuple'>

元组可以使用下标索引来访问元组中的值，也可以使用切片，解释器中代码如下：

>>> tup_1 = (1,2,3,4,5)
>>> tup_1[-1]
5
>>> tup_1[2:-1]
(3, 4)

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，解释器中代码如下：

>>> tup1 = (1,2,3)
>>> tup2 = (4,5,6)
>>> tup3 = tup1 + tup2
>>> tup3
(1, 2, 3, 4, 5, 6)
>>> tup1 *= 3
>>> tup1
(1, 2, 3, 1, 2, 3, 1, 2, 3)

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，解释器中代码如下：

>>> tup1
(1, 2, 3)
>>> del tup1
>>> tup1
NameError: name 'tup1' is not defined.

所谓元组的不可变指的是元组所指向的内存中的内容不可变，解释器中代码如下：

>>> tup = (1,2,3)
>>> id(tup)
1819510751744
>>> tup = (1,2,3)
>>> id(tup)
1819510757760

len() 函数同样可以计算元组的元素个数，解释器中代码如下：

>>> tup1 = (1,2,3)
>>> len(tup1)
3

---

字典

字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值key=>value对用冒号 : 分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中，解释器中代码如下：

>>> d1 = {'name':'Richie','age':22,'gender':'male'}
>>> d1
{'name': 'Richie', 'age': 22, 'gender': 'male'}
>>> type(d1)
<class 'dict'>

不允许同一个键出现两次，创建时如果同一个键被赋值两次，后一个值会被记住，解释器中代码如下：

>>> d = {'name':'Richie','age':22,'name':'StupidMan'}
>>> d
{'name': 'StupidMan', 'age': 22}

使用大括号 { } 创建空字典了，也可以使用内建函数 dict() 创建空字典，解释器中代码如下：

>>> d2 = {}
>>> d2
{}
>>> type(d2)
<class 'dict'>
>>> d3 = dict()
>>> d3
{}
>>> type(d3)
<class 'dict'>

dict() 构造函数可以直接用键值对序列创建字典，解释器中代码如下：

>>> d1 = dict([('name','Richie'),('age',22)])
>>> d1
{'name': 'Richie', 'age': 22}

字典推导式可以用任意键值表达式创建字典，解释器中代码如下：

>>> d1 = {x:x**2 for x in range(6)}
>>> d1
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

把相应的键放入到方括号中，即可查询相应的值，如果用字典里没有的键访问数据，会报错，解释器中代码如下：

>>> d1 = {'name':'Richie','age':22,'gender':'male'}
>>> d1['name']
'Richie'
>>> d1['score']
KeyError: 'score'

字典的增删改，解释器中代码如下：

>>> d = {'name':'Richie'}
>>> d['age'] = 22 # 增加一个键值对
>>> d
{'name': 'Richie', 'age': 22}
>>> del d['age'] # 删除一个键值对
>>> d
{'name': 'Richie'}
>>> del d # 删除整个字典
>>> d
NameError: name 'd' is not defined.

当对字典执行循环时，可以使用 items() 方法同时提取键及其对应的值，解释器中代码如下：

>>> for key,value in d.items():
...     print(key,value)
...
name Richie
age 22
gender male

字典函数&方法

>>> d = {'name':'Richie','age':22}
>>> len(d) # 计算字典元素个数，即键的总数
2
>>> str(d) # 输出字典，可以打印的字符串表示
"{'name': 'Richie', 'age': 22}"
>>> type(d) # 返回输入的变量类型，如果变量是字典就返回字典类型
<class 'dict'>
>>> d1 = d.copy() # 返回一个字典的浅拷贝
>>> d1
{'name': 'Richie', 'age': 22}
>>> d.get('name') # 返回指定键的值
'Richie'
>>> d.get('ag',18) # 返回指定键的值，如果键不在字典中返回设置的默认值，及函数中第二个参数
18
>>> 'name' in d # 键在字典dict里返回true
True
>>> 'age2' in d # 键不在字典dict里返回false
False
>>> d.items() # 以列表返回一个键与值的视图对象
dict_items([('name', 'Richie'), ('age', 22)])
>>> d.values() # 以列表返回一个值得视图对象
dict_values(['Richie', 22])
>>> d.pop('name') # 删除字典 key（键）所对应的整个键值对，返回被删除的值
'Richie'
>>> d
{'age': 22}
>>> d = {'name':'Richie','age':22}
>>> d.popitem() # 返回并删除字典中的最后一个键值对
('age', 22)
>>> d
{'name': 'Richie'}

---

集合

集合是一个无序的不重复元素序列，用 {} 来表示，解释器中代码如下：

>>> set1 = {1,2,3,4,4,3}
>>> set1
{1, 2, 3, 4}

注意：创建一个空集合必须用 set() 而不是 { } ，因为 {} 是用来创建一个空字典的

>>> s1 = {}
>>> type(s1)
<class 'dict'>
>>> s2 = set()
>>> type(s2)
<class 'set'>

集合可以进行如下运算（类似于高中求交集并集的操作），解释器中代码如下：

>>> s1 = {1,2,3,4,5}
>>> s2 = {2,4,6,8,10}
>>> s1 - s2 # s1有但s2没有的元素
{1, 3, 5}
>>> s1 | s2 # 两个集合的并集
{1, 2, 3, 4, 5, 6, 8, 10}
>>> s1 & s2 # 两个集合的交集
{2, 4}
>>> s1 ^ s2 # 两个集合所不共同拥有的元素
{1, 3, 5, 6, 8, 10}

集合推导式，解释器中代码如下：

>>> s1 = {x for x in range(11) if x % 2 != 0} # 1-10中的基数
>>> s1
{1, 3, 5, 7, 9}

集合函数&方法

>>> s = {1,2,3,4,5}
>>> len(s) # 计算集合元素个数
3
>>> s.add(6) # 为集合添加元素
>>> s
{1, 2, 3, 4, 5, 6}
>>> s1 = s.copy() # 拷贝一个集合
>>> s1
{1, 2, 3, 4, 5, 6}
>>> s.discard(6) # 删除集合中指定的元素
>>> s
{1, 2, 3, 4, 5}
>>> s.pop() # 随机移除元素并返回该元素
1
>>> s
{2, 3, 4, 5}
>>> s.remove(3) # 移除指定元素
>>> s
{2, 4, 5}
>>> s1 = {1,2,3,4,5}
>>> s2 = {2,4,6,8,10}
>>> s1.difference(s2) # 返回多个集合的差集
{1, 3, 5}
>>> s1.intersection(s2) # 返回集合的交集
{2, 4}
>>> s1.isdisjoint(s2) # 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
False
>>> s1.issubset(s2) # 判断指定集合是否为该方法参数集合的子集
False
>>> s1.union(s2) # 返回两个集合的并集
{1, 2, 3, 4, 5, 6, 8, 10}