Python学习笔记4：入门知识(四)

写在最前面：作者学习入门知识是通过算法金大佬的语雀笔记学习的，作者只是归纳自己学习的过程并进行记录。大佬公共号【算法金】，欢迎大家关注。

刚入门，大家可以暂时不用安装环境，找个能在线运行Python代码的网站。这里贴两个算法金大佬推荐的网站，也是我现在入门学习的时候用的。

https://www.sciclass.cn/python

https://c.runoob.com/compile/9

Python编写代码都要在英文输入法状态下完成！本文代码中所有的符号也都是英文状态下的符号。当你尝试练习也一定要注意。

新手多写代码多写注释，尤其是学习的时候。另外从学习开始就要注意一下代码风格的问题，防止学到后面习惯了难以改正。

作者刚开始学，如果文章中有写的不好的地方欢迎大家指正。

作者的个人博客也有这篇文章，也欢迎大家去我的个人观看

https://blog.xieqin.online/archives/python-4

容器

列表：List。

列表的创建比较简单，将元素放入中括号[]中，用逗号分隔即可。

列表基本的一些特性：

1. 动态数组。动态数组意味着列表的大小可以根据需要自行调整大小，同时列表的大小在程序运行时是可以改变的。

2. 有序。列表有序指的是元素在列表中的位置是有固定顺序的，这意味着列表中的每一个元素都有一个特定的位置或索引(有的时候也叫下标)。那么我们可以通过索引快捷的访问这个元素。Python中列表的索引是从0开始的。

3. 可包含不同类型。可包含不同类型指列表中的元素，可以是同一个类型，也可以是不同一个类型。比如列表中可以全是整数类型，可以同时包含整数，字符串，浮点数三个类型甚至更多类型。

4. 可变。可变指列表中的元素是可变得，可以随时增加，修改，删除列表中的元素。增加删除要和特性动态数组结合一起看。

5. 可重复。可重复指的是列表中的元素并不是唯一的，一个元素可以出现多次。

6. 切片。切片指可以获取列表的一部分数据进行操作。

列表还有其他特性，但是入门的我们目前了解到这里就差不多，我问AI说列表的特性还有多维，内存，性能啥的，这个太深入了，现在不需要。

# 同元素类型的列表
list = [1,2,3,4,5]
print("list = ", list)
print("========  分隔符  ========")
# 不同元素类型的列表
list = [1, '我', 1.23]
print("list = ", list)

列表的增删改查

增：将元素添加到容器里面。

1. append()方法，将元素添加到容器的末尾。

2. insert()方法，在自定的索引位置插入一个元素。

list = [0,1,2,3,4] 
print("list = ", list)
print("=====================")

# 在末尾添加5
list.append(5) 
print("list = ", list)
print("=====================")

# 在索引0的位置添加一个6.记住列表的索引从0开始
list.insert(0,6)
print("list = ", list)

删：将元素从列表中删除

1. remove()，删除列表中第一个匹配到的元素。

2. pop(),删除并返回指定索引位置的元素，如果不指定索引，默认删除并返回最后一位元素。

list = ['你','我','他','你','我','他'] 
print("最开始的list = ", list)
# 删除列表中第一个匹配到的你
list.remove('你')
print("删掉第一个你的list = ", list)

# 不指定删除
result = list.pop()
print("result = ", result)
print("删除最后一位的list = ", list)

# 指定删除
result = list.pop(0)
print("result = ", result)
print("指定删除第一位的list = ", list)

改：修改元素的值

# 修改比较简单，通过索引赋值就可以了
list = [0,1,3,3,4,5]
# 把第一个3改成2,第一个3的索引是2,索引从0开始
list[2] = 2
print("list = ", list)

查：查询元素的值

1. 通过索引获取值。列表有序的特性，列表中的每个元素都对应一个索引，所以可以直接根据索引来查询元素的值。

2. 使用in来判断元素在不在列表中。之前在成员运算中用的是字符串的例子，实际列表也能用，那么其他的容器是不是也可以用呢？

3. 切片。可以将列表的一部分截取出来。

list = [1,2,3,4,5]

# 索引下标
result = list[2]
print("result = ", result)

# 超过索引值,会报错
result = list[5]

# in
result = 1 in list
print("result = ", result)

# 切片,切片需要输入两个参数,中间用冒号隔开,一个开始索引，一个结束索引，左闭右开
sub_list = list[1:4]
print("sub_list = ", sub_list )

字典：是一种存储键值对的数据结构。

字典用大括号 {} 包围，每个键值对用冒号 : 分隔，键值对之间用逗号 , 分隔。

字典基本的一些特性：

1. 键值对。字典是以键值对的形式出现的，一个键对应一个值。

2. 无序。无序意味着键值对的顺序随着程序的运行会发生改变。这个特性在Python 3.6之前一直存在，但是在Python 3.7以后，字典是有序的。

3. 可变。可变意味着字典在创建出来以后，可以进行增加，修改和删除。

4. 唯一键。唯一键意味着在字典中，键的存在是唯一的。如果尝试添加一个键已经存在的键值对，那么新的值会覆盖旧的值。

5. 散列键。字典的键必须可以散列(哈希)。因为字典的键必须是不可变类型。当前可以是任何的不可变类型。

6. 任意值。字典的值可以是任意值，可以不是不可变类型。

字典的特性不止这些，但是入门的话这些也够了。

dict = {1:1,'age':28, 'name':'明月望秋思'}

字典的增删改查

增：添加键值对到字典中，直接通过键进行添加

dict = {1:1,'age':28, 'name':'明月望秋思'}
print("dict = ", dict)
dict[2] = 2
print("dict = ", dict)

删：删除字典中的键值对

1. del关键字。通过关键字删除字典中的键值对。

2. pop()方法。通过该方法删除字典中的键值对并返回值。

dict = {1:1.1, 2:2.2, 'age':28, 'name':'明月望秋思'}
print("dict = ", dict)
# 关键字删除键值对
del dict[1]
print("dict = ", dict)

# pop删除并返回值
result = dict.pop(2)
print("result = ", result )
print("dict = ", dict)

改：修改键值对中的值。由于字典唯一键的特性，想要修改键值对的值，直接使用同键新增的方式即可

dict = {1:1.1, 'age':28, 'name':'明月望秋思'}
print("dict = ", dict)
dict[1] = 1
print("dict = ", dict)

查：查询键值对中的值。

字典可以直接使用键查询。

1. 使用get()方法查询。方法的参数有两个，一个是键，一个是默认值。当键不存在时，返回你填入的默认值，如果你不填默认值，返回None。

2. 使用keys()方法，返回所有的键。

3. 使用values()方法，返回所有的值。

4. 使用items()方法，返回所有的键值对。

dict = {1:1.1, 2:2.2, 3:3.3}

# 键查询
print("键查询: ", dict[1])

# get无默认值查询
print("get无默认值查询: ",dict.get(6))

# get有默认值查询
print("get有默认值查询: ",dict.get(6, 6.6))

# keys查询
print("keys查询: ",dict.keys())

# values查询
print("values查询: ",dict.values())

# items查询
print("items查询: ",dict.items())

集合：Set。

一种无序且不重复的容器。集合用｛｝包围，元素用逗号分隔。

集合基本的特性：

1. 无序性。集合的元素没有顺序，在程序运行过程中，集合元素的顺序会发生改变，

2. 唯一性。集合的元素具备唯一性，及同一个元素只会在集合中出现一次。

3. 可变性。集合的元素可以随时进行增加和删除。

4. 可包含不同类型。集合像列表一样，可以包含同步类型的元素。

集合的特性当然也不止这些。剩下的后面学。

my_set = {"明月望秋思"， 28}

集合的增删改查

增：增加集合的元素

1. add()方法，用于添加一个元素。

2. update()方法，可以同添加多个元素，可以传入列表或者集合

my_set = set()
print("刚创建的set = ", my_set )
my_set.add("明月望秋思")
print("add添加完的set = ", my_set )
my_set.update({"男",1996})
print("update添加集合的set = ", my_set )
my_set.update([2024,2024,"晚上"])
# 你会发现2024最后在集合中只有一个，这就是唯一性
print("update添加列表的set = ", my_set )

删：删除集合中的元素

1. remove() 方法用于删除指定的元素，如果元素不存在会抛出异常。

2. discard() 方法用于删除指定的元素，如果元素不存在不会抛出异常。

3. pop() 方法随机删除一个元素并返回它，如果集合为空会抛出异常。

my_set = {1, 2, 3}
# 删除元素2
my_set.remove(2) 
print("删除2后的集合：", my_set) 

# 删除元素4,会报错
# my_set.remove(4) 
# print("删除2后的集合：", my_set) 

# 删除元素4，如果不存在也不会出错
my_set.discard(4)  
print("删除4后的集合：", my_set) 

# 随机删除一个元素并返回它
element = my_set.pop()  
# 输出可能是1或3
print("随机删除的原始是：", element) 
# 输出可能是{3}或{1}
print("随机删除后的集合：", my_set) 

改：修改集合中的元素。

集合没有修改的概念，因为集合中的元素是无序且唯一的，改值可能元素的顺序都发生了变化，是一个没有意义的操作。对集合来说，只有删除元素，再增加元素，以达到类似修改的效果。

my_set = {1, 2, 3}
print("最开始的集合：", my_set) 
# 删除元素2
my_set.remove(2) 
print("删除2后的集合：", my_set) 
# 添加一个元素
my_set.add(5)
print("添加5后的集合：", my_set) 

查：查询集合的元素。

由于集合无序的特性，集合无法通过索引查询元素的值，只能通过成员运算in关键字查询元素是否在集合中。

my_set = {1, 2, 3}
print("1在集合中：", 1 in my_set)

拓展：构建方法和清空方法。

列表，字典，集合都有各自的构造方法，可以创建一个空的容器出来。入门的直接使用符号比较方便，后面深入学习写程序的时候可能会用到构造方法。

# 列表的构造方法
my_list = list()
print("我的列表：", my_list)

# 字典的构造方法
my_dict = dict()
print("我的字典：", my_dict)

# 集合的构造方法
my_set = set()
print("我的集合：", my_set)

列表，字典，结合都可以调用clear()方法清空所有元素。

# 列表的构造方法
my_list = [1,2]
print("我的列表：", my_list)
my_list.clear()
print("清空后的列表：", my_list)

# 字典的构造方法
my_dict = {1:1, 2:2}
print("我的字典：", my_dict)
my_dict.clear()
print("清空后的字典：", my_dict)

# 集合的构造方法
my_set = {1,2}
print("我的集合：", my_set)
my_set.clear()
print("清空后的集合：", my_set)

最后

python中的容器当前不止这些。还有元组，队列，栈等等呀。但是入门的话已经够了，其他的我们学到后面会接触的到。

那么今天就学习到这里了。记得完成作业哦！

作业：

有动态数组，那么有没有静态数组？什么是静态数组？

什么是散列？什么是不可变类型？那么什么是可变类型？