上篇指路：Python 的基本操作与数据类型
​

0. 数据类型概览

此处分别生成最简单的列表、元组、字典和集合，以便了解其基本形式

#列表（list）
list = [1,2,3]

#元组（tuple）
tuple =(1, 2, 3)

#字典（dictionary）
dict = {'age':24, 'name':'tom', 'school':'xmu'}

#集合（set）
set = set((1,1,2,2,3,3))

列表: 1,2,3]
元组: (1, 2, 3)
字典: {'age':24, 'name':'tom', 'school':'xmu'}
集合: {1, 2, 3}

1. 列表

• 可变、有序的数据结构，用[ ]括起来，用逗号分隔列表中的元素。

• 比如[1, 2, 3]就是一个列表，里面有三个元素1, 2, 3。

• 列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（称作列表嵌套）。

• 列表的操作非常灵活，可以实现增删查改等功能，是python中最常使用的数据结构之一

#定义最简单的列表
a = [1,2,3]
print(a)

#包含不同类型元素的列表
list = [123, 3.14, 'XMU', True, None, a]
print(list)

[1, 2, 3]
[123, 3.14, 'XMU', True, None, [1, 2, 3]]

1.1. 查 →（截取）元素

• 列表中每个元素都有默认的检索值，可以使用方括号 [ ] 来访问对应的元素并截取列表，截取的语法格式如下：

• list[start:stop:step]（左闭右开，不包含终止元素）

• list：此处代指想要截取的列表的名称

• start: 截取开始位置的索引值（包含该位置）

• stop：截取结束位置的索引值（不包含该位置）

• step：输出的步长，默认为1，可以设置为负数（倒序输出）

• 正向索引值从0开始,逆向索引值从-1开始

list = [123, 3.14, 'XMU', True, None, a]

# 输出完整列表
print (list)            

# 输出列表长度
print(len(list))        

# 输出列表第一个元素
print (list[0])         

# 输出从列表开始到第四个元素之间的所有元素（不包含四）
print (list[:3])  

#练习
#print (list[3:-1])       

# 每隔一个元素输出一次
print (list[::2]) 

# 倒序输出
print (list[::-2]) 

#切片--将检索出的列表片段保存下来
list_new = list[1:3]
print(list_new)

[123, 3.14, 'XMU', True, None, [1, 2, 3]]
6
123
[123, 3.14, 'XMU']
[123, 'XMU', None]
[[1, 2, 3], True, 3.14]
[3.14, 'XMU']

1.2. 增 → 添加元素

list1 = [1,2,3]

#添加（append）
list1.append(4)
list1.append('XMU')
print(list1)

[1, 2, 3, 4, 'XMU']

list1 = [1,2,3]

#插入（insert）,在该位置之前
list1.insert(0, 'XMU')
print(list1)

['XMU', 1, 2, 3]

• 加号 + 是列表连接运算符，星号 * 是重复操作。

#星号将list重复两次
print(list * 2)

#加号将list1与list2相连，而不是数值相加
list1 = [1,2,3]
list2 = [3,2,1]
print(list1 + list2)

[123, 3.14, 'XMU', True, None, [1, 2, 3], 123, 3.14, 'XMU', True, None, [1, 2, 3]]
[1, 2, 3, 3, 2, 1]

1.3. 删 → 删除元素

list1 = [1,2,3]

#删除（pop）
#默认删除最后一个元素
list1.pop() 
print(list1)

#删除索引值为1的元素
list1.pop(1) 
print(list1)

[1, 2]
[1]

list2 = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

#删除（remove）
#删除值为1的第一个元素
list2.remove(1) 
print(list2)

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

1.4. 改 → 替换元素

list1 = [1,2,3]

#替换
list1[2] = 'XMU'
print(list1)

[1, 2, 'XMU']

更多有关列表的内容可以点击以下链接学习：

Python列表（list）的相关操作及方法

2. 元组（tuple）

• 不可变、有序的数据结构，用( )括起来，用逗号分隔不同元素。

• 比如(1, 2, 3)就是一个元组，里面有三个元素

• 元组中元素也可以是不同类型，可以将元组看做“元素不可改变”的列表

2.1. 创建、索引与切片

• 索引、切片方式和列表相同

a =(1, 2, 3)

#索引
print(a[0])
print(a[-1])

#切片，左闭右开，打印索引为1和2的值
print(a[1:3]) 

1
3
(2, 3)

• 创建1个元素的元组有一些特殊规则

# 一个元素，需要在元素后添加逗号,否则会被识别为数字或字符串储存
tuple1 = (20)
tuple2 = (20,) 

print(tuple1)
print(tuple2)

20
(20,)

2.2. 不可变特性

• 不可变意味着，一旦元组被定义，其内部元素不可更改

• 这也导致元组只有查的操作，不能直接增、删、改

a =(1, 2, 3)

a[1] = 'XMU' 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_14876\3848164597.py in <module>
      1 a =(1, 2, 3)
      2 
----> 3 a[1] = 'XMU'

TypeError: 'tuple' object does not support item assignment

• 有了列表，为什么还需要元组？→ 元组的不可变性带来安全性
• 关于元组和列表的辨析可以参考：Python高效编程：深入理解列表与元组的差异及应用场景

3. 字典（dict）

• 可变、无序的数据结构，用 { } 括起来表示。

• 字典是一种映射类型，它是一个 {键(key) : 值(value)} 的集合→键值对。

3.1. 创建、存取与索引

• 字典当中的元素是通过“键”来存取和索引的，而不是通过列表那样的有序索引。

• 键(key)必须使用不可变类型，且键(key)必须是唯一的。值（value）可以是任何数据类型。

#字典的简单例子
a = {'age':24, 123:100, 'school':'xmu'}

print(a)

#通过键key索引
#print(a[0])
print(a['age'])

#输出dict的所有key值
print(a.keys()) 

#输出dict的所有value值
print(a.values()) 

{'age': 24, 123: 100, 'school': 'xmu'}
24
dict_keys(['age', 123, 'school'])
dict_values([24, 100, 'xmu'])

3.2. 增加、删除、修改

• 字典有增删改的操作

#如果有键，则直接修改对应的值
a['age'] = 30
print(a)

#如果没有键，则添加对应的键值对
a['name'] = 'tom'
print(a)

#pop函数删除key所对应的键值对
a.pop(123)
print(a)

{'age': 30, 123: 100, 'school': 'xmu'}
{'age': 30, 123: 100, 'school': 'xmu', 'name': 'tom'}
{'age': 30, 'school': 'xmu', 'name': 'tom'}

3.3. 字典嵌套

• 字典的值比较灵活，可以是列表，也可以字典嵌套字典

#字典的值可以是列表
a = {'fruits':['apple', 'banana', 'orange'], 'animals':['lion', 'dog', 'monkey']}
print(a)

#字典可以嵌套，即value也是一个字典
dictionary = {'A': {'apple': '苹果','airplane': '飞机'},'B': {'banana': '香蕉','book': '书籍'}}
print(dictionary)

{'fruits': ['apple', 'banana', 'orange'], 'animals': ['lion', 'dog', 'monkey']}
{'A': {'apple': '苹果', 'airplane': '飞机'}, 'B': {'banana': '香蕉', 'book': '书籍'}}

• 可以类比现实中的字典来理解，Aa是一个“键”，用于索引所有a开头的内容，而Aa对应的“值”是一个嵌套的小字典，这个小字典中的“键”是一个个单词，如abandon，这些“单词键”对应的值是其汉语解释和例句。
• Python中“字典”储存数据的方式就类似于现实中的字典。

4. 集合（set）

• 可变、无序的数据结构，使用大括号 { } 表示，元素之间用逗号 , 分隔。

• 可以看做是只有keys的字典，用于存储唯一的元素，集合中的元素不会重复

4.1. 创建集合

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

a = set((1,1,2,2,3,3))
print(a)

{1, 2, 3}

#集合中的元素没有索引值，无法通过索引修改
a[1]=1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [34], in <cell line: 2>()
      1 #无法赋值
----> 2 a[1]=1

TypeError: 'set' object does not support item assignment

4.2. 增加元素

#add函数添加元素
a.add(4)
print(a)

#3已经在set当中，不会重复添加
a.add(3)
print(a)

{1, 2, 3, 4}
{1, 2, 3, 4}

4.3. 移除元素

#remove函数把元素4移除
a.remove(4) 
print(a)

#remove函数把元素4移除
a.remove(4) 
print(a)

4.4. 逻辑运算

• 逻辑运算，& 取交集，| 取并集

a1 = set((1,2,3))
a2 = set((1,2,4))

#取交集
print(a1 & a2)

#取并集 
print(a1 | a2) 

{1, 2}
{1, 2, 3, 4}

5. 类（class）

• 在 Python 中，类（class） 是一种用于定义对象的属性（数据）和方法（行为）的模型，是面向对象编程（OOP）的核心概念之一。
• 类本身并不在python中创建对象，而是提供了创建对象的方法，举一个汽车工厂的例子：

• 类：汽车工厂，定义了汽车的属性（如品牌、颜色）和功能（如启动、刹车）。
• 对象：工厂生产出来的具体汽车，比如一辆红色的特斯拉。

class Car:  
    def __init__(self, brand, color):  
        self.brand = brand  
        self.color = color  

    def drive(self):  
        print(f" {self.color} {self.brand} 已被创建.")  

# 创建对象  
car1 = Car("特斯拉", "红色")  
car2 = Car("比亚迪", "蓝色")  

car1.drive()  # 输出: 红色特斯拉已被创建.  
car2.drive()  # 输出: 蓝色比亚迪已被创建.  

• 前半部分的class Car只是给了创建对象的方法，只有后面调用class中的函数，才能真正在python中创建一个对象。

• 关于类的更多操作，可以参考：深入探究 Python 类定义：从基础到高级特性的全面解析

6. 可变不可变？

• 前面每种数据类型都会出现可变/不可变的概念，前文只是简单解释其应用层面的区别，关于这一点的辨析，可以参考：最详细并且直观理解Python中的可变数据类型和不可变数据类型