Python学习笔记（三）----复合数据类型

一、列表

列表，即"list"对象；用方括号把一群用逗号分隔开的数据项括起来就成为一个列表（例如：[2，"a"，6.6]），列表的一个重要特点是其元素的值是可以进行修改的；

创建列表有三种方法（可能你还知道某些其他我不知道的方法，请你告诉我一下），具体看代码如何创建列表（代码中的方法二暂时不考虑）：

# 用方法一创建第一个列表：list_one
list_one = [1, 3, 5] # 输出为：[1, 3, 5]
# 用方法二创建第二个列表：list_two
list_two = list(iterable) #将可迭代对象iterable转化成列表
# 用方法三创建第三个列表：list_three（实质上属于方法二，range本身就是一个可迭代对象）
list_three = list(range(1, 6, 2)) # 输出为：[1, 3, 5]

列表元素的访问（索引访问，其他访问之后介绍）：

列表中每一个元素都有其索引号，索引号从0开始，到列表长度减1结束（在老外看来，数字是从0开始的，这和我们的习惯稍有不同，因此第一个元素的索引为0，依此类推，索引不能越界），具体如以下代码所示：

# 创建一个列表list_one
list_one = [1, 2, 3, 4]
# 访问某个元素
list_one[0] # 输出：1
list_one[1] # 输出：2
list_one[2] # 输出：3
list_one[3] # 输出：4
# 如果索引值大于等于列表的长度就会报错
list_one[4] # 报错：IndexError: list index out of range

# 列表也支持逆向索引
list_one[-1] #输出：4
list_one[-2] #输出：3
list_one[-3] #输出：2
list_one[-4] #输出：1

更新列表（之后会有一些列表函数也能更新列表）：

前面我们说过在Python列表中元素的值是可以进行修改的，利用这个性质我们可以来对列表进行更新（不要忘了索引是从0开始的），代码如下：

# 创建一个列表：test_list
test_list = [1, 2, 4, 4]
print(test_list) # 输出结果为：[1, 2, 4, 4]
test_list[2] = 3 # # 更新列表，使第3个元素变为3
print(test_list) # 输出结果为：[1, 2, 3, 4]

删除列表元素（通过索引）：

test_list = [1, 2, 4, 4] # 创建一个列表：test_list
print(test_list) # 输出结果为：[1, 2, 4, 4]
del test_list[2] # 删除列表中的第三个元素
print(test_list) # 输出结果为：[1, 2, 4]
del test_list # 删除整个列表
print(test_list) # 报错：name 'test_list' is not defined

Python中的一些操作符可以用于列表进行某些计算：

list_one = [1, 2, 3]
print(len(list_one)) # len()函数返回列表的长度；输出为：3
list_two = [1, 2, 3] + [4, 5, 6] # "+"可以实现列表的拼接
print(list_two) # 输出为：[1, 2, 3, 4, 5, 6]
list_three = [1, 2, 3]*2 # "*"可以实现列表的重复
print(list_three) # 输出为：[1, 2, 3, 1, 2, 3]
print(max(list_one)) # 用max()函数求列表中的最大元素；输出为：3 
print(min(list_one)) # 用min()函数求列表中的最小元素输出为：1

Python中的列表是可以嵌套的，即列表里面可以包含列表（其实在Python中几乎所有对象都是可以嵌套的）：

list_one = [1, 3, [4, 5]]
# 用索引访问"[4, 5]"
print(list_one[2]) # 输出为：[4, 5]
# 只访问"4"
print(list_one[2][0]) # 输出为：4

Python列表中的一些基本函数操作：

list_test = [1, 1, 2, 3]
# 在列表末尾添加新的对象：append()
list_test = list_test.append(4) # 此时list_test为：[1, 1, 2, 3, 4]
# 统计某个元素在列表中出现的次数
num = list_test.count(1) # 输出为：2
# 在列表末尾一次性追加另一个序列中的多个值
list_new = [5, 6, 7]
list_test = list_test.extend(list_new) # 此时list_test为：[1, 1, 2, 3, 4, 5, 6, 7]
# 从列表中找出某个值第一次出现的位置索引
index = list_test.index(1) # 输出为：0
# 将某个对象插入列表
list_test = list_test.insert(2, 8) # 此时list_test为：[1, 1, 8, 2, 3, 4, 5, 6, 7]
# 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(list_test.pop(1)) # 此时list_test为：[1, 8, 2, 3, 4, 5, 6, 7]
# 移除列表中某个值的第一个出现
list_test = list_test.remove(8) # 此时list_test为：[1, 2, 3, 4, 5, 6, 7]
# 将列表中的元素反向调整
list_test.reverse()
print(list_test) #  此时list_test为：[7, 6, 5, 4, 3, 2, 1]
# 对列表进行排序
list_test.sort(reverse=False) # 升序；输出为：[1, 2, 3, 4, 5, 6, 7]
list_test.sort(reverse=True) # 降序；输出为：[7, 6, 5, 4, 3, 2, 1]
# 列表的拷贝（深拷贝）
list_one = list_test.copy()
print(list_one) # list_one为：[7, 6, 5, 4, 3, 2, 1]
# 清空列表
list_test.clear() #此时list_test为：[]

关于深浅拷贝问题可以参考我的另一篇博客：https://blog.csdn.net/qq_40627333/article/details/82952114

二、元组

元组，即"tuple"对象；用小括号把一群用逗号分隔开的数据项括起来就成为一个元祖（例如：（2，"a"，6.6））元祖的一个重要特点是其元素的值是不能进行修改的（一经定义不能修改，除非创建新的元祖），这和列表是相对的；

这里对元祖不再进行过多解释，因为元祖和列表很多地方是相通的（除了不能进行更新、修改之外），只简要谈一下元祖和列表的转换：

list_test = [1, 2, 3]
# 将列表转化为元祖
tuple_test = tuple(list_test) # 输出元祖为：(1, 2, 3)
# 想要对元祖进行修改，可以先将其转化为列表
list_test = list(tuple_test) # 输出列表为：[1, 2, 3]
# 修改列表
list_test[0] = 0
print(list_test) # 输出为：[0, 2, 3]
# 转化为元祖，即实现了对元祖的修改
tuple_test = tuple(list_test) # 输出元祖为：(0, 2, 3)

三、字典

字典是另一种可变模型，且可存储任意类型数据；字典的每个键值(key，value)对用冒号" : "分割，每个对之间用逗号" ，"分割，整个字典包括在花括号" {} "中 ,格式如下所示：

dict = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必；值可以取任何数据类型，但键必须是不可变的。

字典创建：

# 创建一个空字典
dict1 = {}
dict2 = dict()
# 创建一个非空字典
dict3 = {"a":1, "b":2, "c":3, "d":2, "e":3}

字典访问、修改和删除：

# 创建一个字典
dict1 = {"a":1, "b":2, "c":3, "d":2, "e":3} 
# 访问字典中c的值
print(dict1["c"]) # 结果为：3
# 修改d的值
dict1["d"] = 4 # 此时dict1为：{"a":1, "b":2, "c":3, "d":4, "e":3}
# 删除字典中的b
del dict1["b"] # 此时dict1为：{"a":1, "c":3, "d":4, "e":3}
# 删除整个字典
del dict1
print(dict1) # 报错：NameError: name 'dict3' is not defined

Python字典包含了以下内置方法：

dict_test = {"a":1, "b":2, "c":3, "d":2}
# 删除字典内所有元素
dict_test.clear() # 此时为空
dict_test = {"a":1, "b":2, "c":3, "d":2}
# 返回一个字典的浅复制
dict1 = dict_test.copy() #这是dict1和dict_test指向相同的对象
# 返回指定键的值，如果值不在字典中返回default值
dict_test.get(d, default=0) # 输出为：2
dict_test.get(e, default=0) # 输出为：0
# 以列表返回可遍历的(键, 值) 元组数组
dict_test.items() # 输出为：[('a', 1), ('b', 2), ('c', 3), ('d', 2)]
# 如果键不存在于字典中，将会添加键并将值设为default
dict_test.setdefault(e, default=5) # 此时dict_test为：{"a":1, "b":2, "c":3, "d":2, "e":5}
# 将字典的键用列表输出，没有list()的话返回的是键的对象
list(dict_test.keys()) # 输出为：['a', 'b', 'c', 'd'，'e']
# 将字典的值用列表输出，没有list()的话返回的是值的对象
list(dict_test.values()) # 输出为：[1, 2, 3, 2, 5]
# 将字典dict1的键/值对更新到dict里
dict1 = {"f":1}
dict_test.update(dict1) # 输出为：{"a":1, "b":2, "c":3, "d":2, "e":5, "f":1}

四、集合

集合是一个无序的不重复元素序列（注意和列表与元组进行比较，后者都是可重复的）；

在创建空集合的时候不可以用 "{}" 创建，因为这样创建出的是字典；创建集合的方法如代码所示：

set_one = {1, 2, 3, 3}
print(set_one) # 注意集合中的元素不可重复，因此输出的是：{1, 2, 3}
set_two = set() 
print(set_two) # 创建一个空集合，反回：set()
set_three = set([1, 2, 3])
print(set_three) # 将一个列表转换为集合，结果为：{1, 2, 3}
set_four = set((1, 2, 3))
print(set_four) # 将一个元组转换为集合，结果为：{1, 2, 3}

向集合中添加元素：

set_test = {1, 2, 3}
set_test.add(4) # add()方法
print(set_test) # 结果为：{1, 2, 3, 4}

将另一个集合中的元素更新到现有集合：

set_test = {1, 2, 3}
set_update = {3, 5, 6, 7}
set_test.update(set_update)
print(set_test) # 输出为：{1, 2, 3, 5, 6, 7}

移除集合中某元素或清空列表：

set_test = {1, 2, 3}
# 移除元素1
set_test.remove(1)
print(set_test) # 输出为：{2, 3}
# 清空集合元素
set_test.clear()
print(set_test) # 输出为：set()；即空集合

判断某元素是否在集合中（用in方法）：

set_test = {1, 2, 3}
print(1 in set_test) # 返回：True
print(4 in set_test) # 返回：False

集合的运算也包括两个集合的并集、交集、差集，在Python中有专门函数来实现这些功能：

set_one = {1, 2, 3}
set_two = {2, 3, 4}
print(set_one.union(set_two)) # 计算并集：{1, 2, 3, 4}
print(set_one.intersection(set_two)) # 计算交集：{2, 3}
print(set_one.difference(set_two)) # 计算差集：{1}

Python学习笔记（三）----复合数据类型

猜你喜欢