北京公司网站建设报价深圳市网络seo推广平台

1、列表

1.1 列表的表达

1. 序列类型：内部元素有位置关系，能通过位置序号访问其中元素
2. 序列特点：可使用多种类型元素，支持元素的增删查改

lst = ["python", 2025, True, {"age": 20}]
print(lst)
# 输出：['python', 2025, True, {'age': 20}]

• list(可迭代类型)

1.1.1 字符串转列表

lst1 = list("人工智能")
print(lst1)
# 输出：['人', '工', '智', '能']

1.1.2 元组转列表

lst2 = list(("我", "们", "爱", "中", "国"))
print(lst2)
# 输出：['我', '们', '爱', '中', '国']

1.1.3 集合转列表

lst3 = list({"Mike", "Jim", "Tim", "Jerry", "Tom"})
print(lst3)
# 输出：['Tom', 'Tim', 'Jerry', 'Jim', 'Mike']

1.1.4 特殊的range(开始数据, 结束数据, 数字间隔)

for i in [1,2,3]:print(i)
# 输出：1
#      2
#      3for i in range(3):print(i)
# 输出：0
#      1
#      2

注意：
  1. 开始数据若为0，则可以省略
  2. 结束数据不可以省略
  3. 数字间隔默认为1

for i in range(1, 11, 2):print(i)
# 输出：1
#      3
#      5
#      7
#      9print(list(range(1, 11, 2)))
# 输出：[1, 3, 5, 7, 9]

1.2 列表的性质

1.2.1 列表的长度——len(列表)

lst = [1,2,3,4,5,6,7,8,9]
print(len(lst))
# 输出：9

1.2.2 列表的索引——变量名[位置编号]

cars = ["BYD", "BMW", "HRV"]
print(cars[0])
# 输出：BYD
print(cars[-1])
# 输出：HRV

用法与字符串完全相同

1.2.3 列表的切片——变量名[开始位置:结束位置:切片间隔]

cars = ["BYD", "BMW", "HRV", "AUDI"]
print(cars[1:4:2])  # 正向切片
# 输出：['BMW', 'AUDI']
print(cars[:-4:-1])  # 反向切片
# 输出：['AUDI', 'HRV', 'BMW']
print(cars[:])  # 遍历
# 输出：['BYD', 'BMW', 'HRV', 'AUDI']

1.3 列表的操作符

1.3.1 列表的拼接——lst1 + lst2

lst1 = [1, 2]
lst2 = [3, 4, 5]
c = lst1 + lst2
print(c)
# 输出：[1, 2, 3, 4, 5]

1.3.2 列表的成倍复制——lst*n

lst3 = [0]*10
print(lst3)
# 输出：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

初始化列表的一种方式

1.4 列表的操作方法

1.4.1 增加元素

（1）在末尾增加——lst.append(待增元素)

language = ["Python", "Java", "C++", "JavaScript", "PHP", "C#"]
language.append("R")
print(language)
# 输出：['Python', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R']

（2）在任意位置增加——lst.insert(位置编号, 待增元素)

language.insert(1, "C")
print(language)
# 输出：['Python', 'C', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R']

（3）在末尾整体并入另一列表

language.append(["MySQL", "CSS"])  # 整体添加
print(language)
# 输出：['Python', 'C', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R', ['MySQL', 'CSS']]language.extend(["SQL", "go"])  # 逐个添加
print(language)
# 输出：['Python', 'C', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R', ['MySQL', 'CSS'], 'SQL', 'go']

1.4.2 删除元素

（1）删除位置i处的元素——lst.pop(位置编号)

language.pop(0)
print(language)
# 输出：['C', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R', ['MySQL', 'CSS'], 'SQL', 'go']
language.pop()  # 若空白，则默认删除最后一个
print(language)
# 输出：['C', 'Java', 'C++', 'JavaScript', 'PHP', 'C#', 'R', ['MySQL', 'CSS'], 'SQL']

（2）删除列表第一次出现的待删元素——lst.remove(待删元素)

language.remove("Java")
print(language)
# 输出：['C', 'C++', 'JavaScript', 'PHP', 'C#', 'R', ['MySQL', 'CSS'], 'SQL']while "R" in language:language.remove("R")
print(language)
# 输出：['C', 'C++', 'JavaScript', 'PHP', 'C#', ['MySQL', 'CSS'], 'SQL']

1.4.3 查找元素

lst.index(待查元素)：查找列表中第一次出现待查元素的位置

idx = language.index("C++")
print(idx)
# 输出：1

1.4.4 修改元素

lst[位置]=新值：先索引，后赋值

language[1] = "R"
print(language)
# 输出：['C', 'R', 'JavaScript', 'PHP', 'C#', ['MySQL', 'CSS'], 'SQL']

1.4.5 列表的复制

（1）错误的方式

codes = ["python", "java", "C"]
codes1 = codes
print(codes1)
# 输出：['python', 'java', 'C']codes.pop()
print(codes)
# 输出：['python', 'java']
print(codes1)
# 输出：['python', 'java']

（2）浅拷贝

# lst.copy()
codes2 = codes.copy()
codes.pop()
print(codes)
# 输出：['python']
print(codes2)
# 输出：['python', 'java']# --------------------------------------------------# lst[:]
codes3 = codes2[:]
codes2.pop()
print(codes2)
# 输出：['python']
print(codes3)
# 输出：['python', 'java']

1.4.6 列表的排序

（1）lst.sort()——永久排序，原列表改变，无返回值

lst = [1, 3, 5, 11, 2, 9]
lst.sort()
print(lst)
# 输出：[1, 2, 3, 5, 9, 11]
lst.sort(reverse=True)  # 递减排序
print(lst)
# 输出：[11, 9, 5, 3, 2, 1]

（2）sorted(列表名)——临时排序，原列表不变，返回值是排序后的类别

lst = [2, 5, 1, 20, 7]
lst1 = sorted(lst)
lst2 = sorted(lst1, reverse=True)
print(lst)
# 输出：[2, 5, 1, 20, 7]
print(lst1)
# 输出：[1, 2, 5, 7, 20]
print(lst2)
# 输出：[20, 7, 5, 2, 1]

1.4.7 列表的翻转

lst.reverse()：永久翻转，原列表改变，无返回值

lst = [1, 2, 3, 4, 5, 6]
print(lst[::-1])
# 输出：[6, 5, 4, 3, 2, 1]
print(lst)
# 输出：[1, 2, 3, 4, 5, 6]
lst.reverse()
print(lst)
# 输出：[6, 5, 4, 3, 2, 1]

1.4.8 for循环遍历

lst = [1, 2, 3, 4, 5, 6]
for i in lst:print(i)
# 输出：1
#      2
#      3
#      4
#      5
#      6

2、元组

2.1 元组的表达

特点：
  1. 支持多种类型的元素
  2. 内部元素不支持增删改的序列操作

names = ["Mike", "Jim", "Tim", "Jerry", "Tom"]

2.2 元组的操作

1. 不支持元素增加、元素删除、元素修改
2. 其他操作与列表一致

2.3 元组的常见用处——打包与解包

• 例1

def f1(x):  # 返回x的平方和立方return x**2, x**3  # 实现打包返回print(f1(3))
# 输出：(9, 27)
print(type(f1(3)))
# 输出：<class 'tuple'>

• 例2

numbers = [202501, 202502, 202503]
names = ["小红", "小蓝", "小绿"]
list(zip(numbers, names))  # 实现打包返回for number, name in zip(numbers, names):print(number, name)
# 输出：202501 小红
#      202502 小蓝
#      202503 小绿

3、字典

3.1 字典的表达

1. 映射类型：通过“键”-“值”的映射实现数据存储和查找
2. 常规的字典是无序的

students = {202501: "小红", 202502: "小蓝", 202503: "小绿"}
print(students)
# 输出：{202501: '小红', 202502: '小蓝', 202503: '小绿'}

字典键的要求：

• 字典键不能重复

students = {202501: "小红", 202502: "小蓝", 202501: "小红"}
print(students)
# 输出：{202501: '小红', 202502: '小蓝'}

• 字典键是不可变类型

1. 不可变类型：数字、字符串、元组
2. 可变类型：列表、字典、集合

d1 = {1: 3}
d2 = {"a": 1}
d3 = {(1, 2): 3}# --------------------------------------------------d = {[1, 2]: 3}
# 输出：TypeError: unhashable type: 'list'
d = {{1: 2}: 3}
# 输出：TypeError: unhashable type: 'dict'
d = {{1, 2}: 3}
# 输出：TypeError: unhashable type: 'set'

3.2 字典的性质

3.2.1 字典的长度——键值对的个数

children = {2025: "小明", 2024: "李华", 2023: "张三"}
print(len(children))
# 输出：3

3.2.2 字典的索引——d[键]

print(children[2024])
# 输出：李华

3.3 字典的操作方法

3.3.1 增加键值对——变量名[新键]=新值

students = {2025: "张三", 2024: "李四", 2023: "赵五"}
students[2023] = "小雪"
print(students)
# 输出：{2025: '张三', 2024: '李四', 2023: '小雪'}

3.3.2 删除键值对

（1）del 变量名[待删除键]

del students[2025]  # del 变量名[待删除键]
print(students)
# 输出：{2024: '李四', 2023: '小雪'}

（2）变量名.pop(待删除键)

value = students.pop(2024)  # 变量名.pop(待删除键)
print(value)
# 输出：李四
print(students)
# 输出：{2023: '小雪'}

（3）变量名.popitem()

随机删除一个键值对，并以元组返回待删除的键值对

key, value = students.popitem()  # 变量名.popitem()--随机删除一个键值对，并以元组返回待删除的键值对
print(key, value)
# 输出：2023 小雪
print(students)
# 输出：{}

3.3.3 修改值

students = {2025: "小明", 2024: "小强"}
students[2025] = "小雪"
print(students)
# 输出：{2025: '小雪', 2024: '小强'}

3.3.4  d.get(key, default())

从字典中获取key对应的value，若没有这个键，则返回default

s = "牛奶奶找刘奶奶买牛奶"
d = {}
print(d)
for i in s:d[i] = d.get(i, 0) + 1print(d)
# 输出：{}
#      {'牛': 1}
#      {'牛': 1, '奶': 1}
#      {'牛': 1, '奶': 2}
#      {'牛': 1, '奶': 2, '找': 1}
#      {'牛': 1, '奶': 2, '找': 1, '刘': 1}
#      {'牛': 1, '奶': 3, '找': 1, '刘': 1}
#      {'牛': 1, '奶': 4, '找': 1, '刘': 1}
#      {'牛': 1, '奶': 4, '找': 1, '刘': 1, '买': 1}
#      {'牛': 2, '奶': 4, '找': 1, '刘': 1, '买': 1}
#      {'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}

3.3.5  d.keys()   d.values()

students = {2025: "小明", 2024: "小强", 2023: "小雪"}
print(list(students.values()))
# 输出：['小明', '小强', '小雪']
print(list(students.keys()))
# 输出：[2025, 2024, 2023]

3.3.6  d.items()

print(list(students.items()))
# 输出：[(2025, '小明'), (2024, '小强'), (2023, '小雪')]
for k, v in students.items():print(k, v)
# 输出：2025 小明
#      2024 小强
#      2023 小雪

4、集合

4.1 集合的表达

特点：
  1. 一系列互不相等的无序集合
  2. 元素必须是不可变类型（数字、字符串或元组），可视为字典的键
  3. 可看作没有值或者值为None的字典

teachers = {"小明", "小强", "小雪"}
print(teachers)
# 输出：{'小明', '小强', '小雪'}

4.2 集合的运算

4.2.1  S&T

返回一个新集合，包括同时在S和T中的元素

Chinese = {"小明", "小雪", "小强", "小红", "小绿"}
maths = {"小雪", "小绿", "小蓝"}
print(Chinese & maths)
# 输出：{'小绿', '小雪'}

4.2.2  S|T

返回一个新集合，包括所有在S和T中的元素

print(Chinese | maths)
# 输出：{'小绿', '小明', '小蓝', '小雪', '小强', '小红'}

4.2.3  S^T

返回一个新集合，包括集合S和T中的非共同元素

print(Chinese^maths)
# 输出：{'小红', '小蓝', '小明', '小强'}

4.2.4  S-T

返回一个新集合，包括在集合S但不在集合T中的元素

print(Chinese-maths)
# 输出：{'小红', '小明', '小强'}

4.3 集合的操作方法

4.3.1 增加元素——s.add(x)

stars = {"wjk", "wy", "yyqx"}
stars.add("薛之谦")
print(stars)
# 输出：{'wjk', 'yyqx', '薛之谦', 'wy'}

4.3.2 移除元素——s.remove(x)

stars.remove("wjk")
print(stars)
# 输出：{'薛之谦', 'yyqx', 'wy'}

4.3.3 集合的长度——len(s)

print(len(stars))
# 输出：3

4.3.4 集合的遍历

for star in stars:print(star)
# 输出：wy
#      yyqx
#      薛之谦

---

微语录：在年轻的飞奔里，你是迎面而来的风。