Python | 函数、数据容器

山头之上

1.函数

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
1.1 简单案例

重复使用计算字符串的长度

1. str1 = "heystar"
2. str2 = "python"
3. str3 = "abcd"
5. count = 0
6. for _ in str1:
7.     count += 1
8. print(f"字符串{str1}的长度是：{count}")
10. count = 0
11. for _ in str2:
12.     count += 1
13. print(f"字符串{str2}的长度是：{count}")
15. count = 0
16. for _ in str3:
17.     count += 1
18. print(f"字符串{str3}的长度是：{count}")

复制代码

使用函数计算字符串的长度

1. # 以下为优化：
2. str1 = "heystar"
3. str2 = "python"
4. str3 = "abcd"
7. def my_len(data):
8.     cnt = 0
9.     for _ in data:
10.         cnt += 1
11.     print(f"字符串{data}的长度是：{cnt}")
14. my_len(str1)
15. my_len(str2)
16. my_len(str3)

复制代码

1.2 使用函数的好处：

为了得到一个针对特定需求、可供重复利用的代码段
提高程序的复用性，减少重复性代码，提高开发效率
1.3 函数的基本定义

函数的定义

1. def 函数名(传入参数)
2.         函数体
3.         return 返回值

复制代码

函数的调用

函数名(参数)
注意事项

• 参数如不需要,可以省略
  
• 返回值如不需要，可以省略
  
• 函数必须先定义后使用
  

简单案例

1. # 定义一个函数，输出相关信息
2. def say_hi():
3.     print("Hi~ o(*￣▽￣*)ブ")
6. # 调用函数
7. say_hi()

复制代码

1.4 函数的参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据
多个参数案例

1. def add(x, y):
2.     result = x + y
3.     print(f"{x}+{y}={x + y}")
6. add(5, 6)

复制代码

语法解析

• 函数定义中，提供的x和y，称之为∶形式参数（形参)，表示函数声明将要使用2个参数
  
  
  
  • 参数之间使用逗号进行分隔
    
  
  
• 函数调用中，提供的5和6，称之为:实际参数（实参)，表示函数执行时真正使用的参数值
  
  
  
  • 传入的时候,按照顺序传入数据,使用逗号分隔
    
  
  

函数的传入参数

传入参数的数量是不受限制的。

• 可以不使用参数
  
• 也可以仅使用任意N个参数
  

以上代码增加参数：

1. def add(x, y, z):
2.     result = x + y + z
3.     print(f"{x}+{y}+{z}={x + y + z}")
7. add(1, 2, 3)

复制代码

1.5 函数的返回值

返回值：就是程序中函数完成事情后，最后给调用者的结果
函数体在遇到retuen后就结束了，所以写在return后的代码不会执行
语法格式

1. def 函数(参数...)
2.         函数体
3.         return 返回值
6. 变量 = 函数(参数)

复制代码

简单案例

1. def add(x, y, z):
2.     result = x + y + z
3.     return result
6. Sum = add(1, 2, 3)
7. print(Sum)

复制代码

None类型

Python中有一个特殊的字面量：None，其类型是：
无返回值的函数，实际上就是返回了：None这个字面量
None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
None类型的应用场景

None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。

• 用在函数无返回值上
  
• 用在if判断上
  
  
  
  • 在if判断中，None等同于False
    
  • 一般用于在函数中主动返回None，配合if判断做相关处理
    
  
  
• 用于声明无内容的变量上
  
  
  
  • 定义变量，但暂时不需要变量有具体值，可以用None来代替
    
  
  

1. # 暂不赋予变量具体值
2. name = None

复制代码

1.6 函数的说明文档

需要给函数添加说明文档，辅助理解函数的作用。
通过多行注释的形式，对函数进行说明解释

• 内容应写在函数体之前
  

格式：

1. def 函数名(参数)
2.         """
3.         函数说明
4.         :param x:形参x的说明
5.         :param y:形参y的说明
6.         :return: 返回值的说明
7.         """
8.         函数体
9.         return 返回值

复制代码

1.7 函数的嵌套调用

所谓函数嵌套调用是指：一个函数里面调用了另外一个函数
简单案例

1. def fun_b():
2.     print("2")
5. def fun_a():
6.     print("1")
7.     fun_b()
8.     print("3")
12. fun_a()

复制代码

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置.
1.8 函数的变量作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量
1.8.1 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量
1.8.2 全局变量

所谓全局变量,指的是在函数体内、外都能生效的变量
1.8.3 global关键字

使用global关键字，可以在函数内部声明变量为全局变量
1.9 函数的基本案例

模拟ATM机

• 定义一个全局变量：money，用来记录银行卡余额(默认5000000)
  
• 定义一个全局变量：name，用来记录客户姓名
  
• 定义如下函数：
  
  
  
  • 查询余额函数
    
  • 存款函数
    
  • 取款函数
    
  • 主菜单函数
    
  
  
• 要求：
  
  
  
  • 查询余额、存款、取款后都会返回主菜单
    
  • 存款、取款后，都应显示一下当前余额
    
  • 客户选择退出或输入错误，程序会退出，否则一直运行
    
  
  

代码

1. # ATM
2. money = 5000000
3. name = "HeyStar"
6. def menu():
7.     print(f"-------------主菜单-------------")
8.     print(f"\t查询余额\t\t[输入1]")
9.     print(f"\t存    款\t[输入2]")
10.     print(f"\t取    款\t[输入3]")
11.     print(f"\t退    出\t[输入4]")
12.     opt = int(input(f"\t请输入您的选择："))
13.     return opt
16. # 查询余额
17. def check_balance(user_name):
18.     print(f"------------查询余额-------------")
19.     print(f"{user_name}，您好，您的余额剩余：{money}")
22. # 存款
23. def deposit(user_name, user_money):
24.     print(f"-------------存款--------------")
25.     print(f"{user_name},您好，您存款50000元成功")
26.     user_money += 50000
27.     print(f"{user_name}，您好，您的余额剩余：{user_money}")
28.     return user_money
31. # 取款
32. def withdraw_money(user_name, user_money):
33.     print(f"-------------取款--------------")
34.     print(f"{user_name},您好，您取款50000元成功")
35.     user_money -= 50000
36.     print(f"{user_name}，您好，您的余额剩余：{user_money}")
37.     return user_money
40. while 1:
41.     op = menu()
42.     if op == 1:
43.         check_balance(name)
44.     elif op == 2:
45.         money = deposit(name, money)
46.     elif op == 3:
47.         money = withdraw_money(name, money)
48.     elif op == 4:
49.         break
50.     else:
51.         print(f"您输入的序号有误，请重新输入")

复制代码

输出结果

1.10 函数返回多个返回值

• 样例代码
  1. def test_return():
  2.         return 1, 2
  5. x, y = test_return()
  6. print(x)
  7. print(y)

  复制代码
• 输出结果：
  
  
  
  
• 按照返回值的顺序,写对应顺序的多个变量接收即可
  
• 变量之间用逗号隔开
  
• 支持不同类型的数据return
  

1.11 函数的多种传参方式

1.11.1 位置参数

调用函数时，根据函数定义的参数位置来传递参数
传递的参数和定义的参数的顺序及个数必须一致

1. def user_info(name, age, gender):
2.     print(f"您的姓名是{name},年龄是{age},性别是{gender}")
4. user_info('Tom', 20, '男')

复制代码

1.11.2 关键字参数

关键字参数：函数调用时通过 “键=值” 形式传递参数.
作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.
样例代码：

1. def user_info(name, age, gender):
2.     print(f"您的姓名是{name},年龄是{age},性别是{gender}")
4. # 关键字传参：
5. user_info(name='Tom', age=20, gender='男')
6. # 不按照固定顺序：
7. user_info(age=20, name='Tom', gender='男')
8. # 与位置参数混用，但位置参数必须在前
9. user_info('Tom', age=20, gender='男')

复制代码

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
1.11.3 缺省参数（默认值）

1. def user_info(name, age, gender='男'):
2.     print(f"您的姓名是{name},年龄是{age},性别是{gender}")
5. user_info('Tom', 20)
7. user_info('Aim', 20, '女')

复制代码

输出结果：

1.11.4 不定长参数

不定长参数:不定长参数也叫可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
作用:当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：

• 位置传递
  
  
  
  • 样例代码：
    
  1. def user_info(*args):
  2. print(args)
  5. # ('Tom')
  6. user_info('Tom')
  8. # ('Tom',18)
  9. user_info('Tom',18)

  复制代码
  传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递
  
  
• 关键字传递
  
  
  
  • 样例代码：
    
  1. def user_info(**kwargs):
  2.     print(kwargs)
  5. # ('name'='Tom','age'=18,'id'=123)
  6. user_info(name='Tom', age=18, id=123)`

  复制代码
  参数是 “键=值” 形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典
  
  

1.12 函数作为参数传递

样例代码：

1. def test_func(compute):
2.     result = compute(1, 2)
3.     print(result)
6. def compute(x, y):
7.     return x + y
10. test_func(compute)  # 结果：3

复制代码

函数compute，作为参数，传入了test_func函数中使用。

• test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定
  
• compute函数接收2个数字对其进行计算，compute函数作为参数，传递给了test_func函数使用
  
• 最终，在test_func函数内部，由传入的compute函数，完成了对数字的计算操作
  所以，这是一种，计算逻辑的传递，而非数据的传递
  就像上述代码那样，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入。
  

1.13 lambda匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
  
• lambda关键字，可以定义匿名函数（无名称)
  有名称的函数，可以基于名称重复使用。
  无名称的匿名函数，只可临时使用一次。
  

定义语法：lambda 传入参数：函数体（一行代码）

• lambda是关键字，表示定义匿名函数
  
• 传入参数表示匿名函数的形式参数，如:x, y表示接收2个形式参数
  
• 函数体，就是函数的执行逻辑，要注意:只能写一行，无法写多行代码
  

样例代码：

1. def test_func(compute):
2.     result = compute(1, 2)
3.     print(result)
6. test_func(lambda x, y: x + y)  # 结果：3

复制代码

注意事项：

• 匿名函数用于临时构建一个函数，只用一次的场景
  
• 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数
  

2.数据容器

2.1 Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同：

• 是否支持重复元素
  
• 是否可以修改
  
• 是否有序
  
• 等
  分为5类：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
  

2.2 数据容器：List(列表)

2.2.1 列表的定义

基本语法：

1. # 字面量
2. [元素1，元素2，元素3，元素4，...]
4. # 定义变量
5. 变量名称 = [元素1，元素2，元素3，元素4，...]
7. # 定义空列表
8. 变量名称 = []
9. 变量名称 = list()

复制代码

列表中的每一个数据，称之为元素

• 以[]作为标识
  
• 列表内每一个元素之间用，逗号隔开
  

列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。
2.2.2 列表的下标索引

下标索引

可以从列表中取出特定位置的数据
列表中的每一个元素，都有其下标索引，从前往后，从0开始，依次递增

1. # 语法，列表[下标索引]
3. name_list = ['Tom', 'Lily', 'Rose']
4. print(name_list[0])
5. print(name_list[2])
6. print(name_list[1])

复制代码

输出

1. Tom
2. Rose
3. Lily

复制代码

反向索引

可以反向索引，也就是从右向左，从后向前：从-1开始，依次递减(-1、-2、-3......)

1. # 语法，列表[下标索引]
3. name_list = ['Tom', 'Lily', 'Rose']
4. print(name_list[-1])
5. print(name_list[-2])
6. print(name_list[-3])

复制代码

输出

1. Rose
2. Lily
3. Tom

复制代码

嵌套列表的下标

两层嵌套类似于二维列表

1. my_list = [[1, 2, 3], [4, 5, 6]]
3. print(my_list[0][1])
4. print(my_list[1])
5. print(my_list[1][2])

复制代码

输出

1. 2
2. [4, 5, 6]
3. 6

复制代码

注意事项

• 要注意下标索引的取值范围，超出范围无法取出元素，并且会报错
  

2.2.3 列表的常用操作

列表除了可以:

• 定义
  
• 使用下标索引获取值
  以外，列表也提供了一系列功能:
  
• 插入元素
  
• 删除元素
  
• 清空列表
  
• 修改元素
  
• 统计元素个数
  等等功能，这些功能我们都称之为:列表的方法
  

2.2.3.1 列表的查询功能

• 查找某元素的下标
  
  
  
  • 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
    
  • 语法：列表.index(元素)
    index 就是列表对象（变量）内置的方法（函数）
    
  
  
• 代码
  

1. my_list = ["hey", "hello", "star", "hi"]
3. # 下标存在
4. index = my_list.index("hello")
5. print(index)
7. # 下标不存在，会报错
8. index = my_list.index("he")
9. print(index)

复制代码

输出结果

2.2.3.2 列表的修改功能

• 修改特定位置（索引）的元素值
  
  
  
  • 语法：列表{下标} = 值
    可以使用如上的语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
    
  
  
• 代码
  

1. my_list = [1, 2, 3, 4, 5]
3. # 正向下标
4. my_list[0] = 9
5. print(my_list)  # 当前列表为 [9, 2, 3, 4, 5]
7. # 反向下标
8. my_list[-2] = 8
9. print(my_list)  # 当前列表为 [9, 2, 3, 8, 5]

复制代码

输出结果：

2.2.3.3 列表的修改功能

• 插入元素
  
  
  
  • 语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素
    
  
  

代码：

1. my_list = [1, 2, 3]
3. my_list.insert(1,"HeyStar")
4. print(my_list)

复制代码

输出结果：

2.2.3.4 列表的追加元素功能

• 语法：列表.append(元素)，将指定元素，追加到列表的尾部
  
• 或者：列表.extend(其他数据容器)，将其他数据容器的内容取出，一次追加到列表尾部
  

代码：

1. # 追加单个元素
2. my_list = [1, 2, 3]
4. my_list.append(4)
5. print(my_list)
8. # 追加一批元素
9. my_list = [1, 2, 3]
11. my_list.extend([4, 5, 6])
12. print(my_list)

复制代码

输出结果：

2.2.3.5 列表的删除元素功能

• 语法1：del 列表[下标]
  
• 语法2：列表.pop(下标)
  
• 删除某元素在列表中的第一匹配项
  
  
  
  • 语法列表.remove(元素)
    
  
  

代码：

1. # 语法1
2. my_list = [1, 2, 3]
4. del my_list[0]
5. print(my_list)
7. # 语法2
8. my_list = [1, 2, 3]
10. my_list.pop(1)
11. print(my_list)
13. # 删除某元素在列表中的第一匹配项
14. my_list = [1, 2, 3, 2, 1]
16. my_list.remove(2)
17. print(my_list)

复制代码

输出结果：

2.2.3.6 列表的清空功能

• 语法：列表.clear()
  

代码：

1. # 语法
2. my_list = [1, 2, 3]
4. my_list.clear()
5. print(my_list)

复制代码

输出结果：

2.2.3.7 列表的统计元素功能

• 统计某元素在列表中的数量
  
• 语法：列表.count(元素)
  

代码：

1. # 语法
2. my_list = [1, 2, 3, 2, 1]
4. print(my_list.count(1))

复制代码

输出结果

2.2.3.8 列表的统计全部元素功能

• 统计列表中全部的元素的数量
  
• 语法：len(列表)
  

代码：

1. # 语法
2. my_list = [1, 2, 3, 2, 1]
4. print(len(my_list))

复制代码

输出结果：

2.2.3 列表的常用操作功能练习

1. 有一个列表，内容是:[21,25,21,23,22,20]，记录的是一批学生的年龄
2. 请通过列表的功能（方法)，对其进行
4. 1．定义这个列表，并用变量接收它
5. 2．追加一个数字31，到列表的尾部
6. 3．追加一个新列表[29,33,30]，到列表的尾部
7. 4．取出第一个元素（应是:21)
8. 5．取出最后一个元素（应是:30)
9. 6．查找元素31，在列表中的下标位置

复制代码

代码：

1. students_age = [21, 25, 21, 23, 22, 20]
3. print(f"进行操作1后，目前列表内容为：{students_age}")
5. students_age.append(31)
6. print(f"进行操作2后，目前列表内容为：{students_age}")
8. students_age.extend([29, 33, 30])
9. print(f"进行操作3后，目前列表内容为：{students_age}")
11. print(f"操作4：")
12. print(students_age[0])
14. print(f"操作5：")
15. print(students_age[-1])
17. print(f"操作6：")
18. print(students_age.index(31))

复制代码

输出结果：

2.2.4 列表的循环遍历

• 将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代
  

2.2.4.1 如何遍历列表的元素

• 使用while循环
  

2.2.4.2 如何在循环中取出列表的元素

• 使用列表[下标]的方式取出
  

2.2.4.3 while循环条件的控制

• 定义一个变量表示下标，从0开始
  
• 循环条件为下标值 < 列表的元素数量
  

1. index = 0
2. while index < len(列表):
3.         元素 = 列表[index]
4.         对元素进行处理
5.         index += 1

复制代码

2.2.4.4 for循环条件的控制

• 语法
  

1. for 临时变量 in 数据容器:
2.         对临时变量进行操作

复制代码

表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，可以对临时变量（元素）进行处理。
2.2.4.5 代码练习

1. # while循环
2. def list_while_func():
3.     my_list = [1, 2, 3, 4, 5, 6]
4.     index = 0
5.     print("while循环操作：")
6.     print("列表的元素 { ", end='')
8.     while index < len(my_list):
9.         print(my_list[index], end='')
10.         index += 1
12.     print("}")
15. # for循环
16. def list_for_func():
17.     my_list = [1, 2, 3, 4, 5, 6]
18.     print("for循环操作：")
19.     print("列表的元素 { ", end='')
20.     for index in my_list:
21.         print(index,end=' ')
23.     print("}")
26. list_while_func()
27. list_for_func()

复制代码

输出结果：

2.3 数据容器：tuple(元组)

元组和列表一样，都是可以封装多个、不同类型的元素在内。
不同点在于：元组一旦定义完成，就不可修改
2.3.1 元组的定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

1. # 定义元组字面量
2. (元素,元素,元素,......,元素)
3. # 定义元组变量
4. 变量名称 = (元素,元素,元素,......,元素)
5. # 定义空元组
6. 变量名称 = ()                          # 方法1
7. 变量名称 = tuple()                # 方法2

复制代码

代码练习：

1. # 定义元组
2. my_tuple1 = (1, 2, 3, "Hello", True)
3. my_tuple2 = ()
4. my_tuple3 = tuple()
6. print(f"my_tuple1的类型是：{type(my_tuple1)} , 内容是：{my_tuple1}")
7. print(f"my_tuple2的类型是：{type(my_tuple2)} , 内容是：{my_tuple2}")
8. print(f"my_tuple3的类型是：{type(my_tuple3)} , 内容是：{my_tuple3}")

复制代码

输出结果：

注意事项
如果元组只有一个数据，这个数据后面需要添加逗号。
如：my_tuple1 = ("Hello",)
2.3.2 元组的嵌套

样例代码：

1. # 定义一个嵌套元组
2. my_tuple = ((1, 2, 3), (4, 5, 6))
3. print(f"my_tuple的类型是：{type(my_tuple)}，内容是：{my_tuple}")

复制代码

输出结果：

2.3.3 元组的下标索引

样例代码：

1. # 下标索引取出内容
2. my_tuple = ((1, 2, 3), (4, 5, 6))
3. print(f"{my_tuple[1][2]}")

复制代码

输出结果：

2.3.4 元组的相关操作

方法作用index()查找某个数据，如果数据存在返回对应的下标，否则报错count()统计某个数据在当前元组出现的次数len(元组)统计元组内的元素个数样例代码：

1. # 根据下标(索引)取出数据
2. t1 = (1, 2, 'hello')
3. print(t1[2])  # 结果：'hello'
5. # 根据index()，查找特定元素的第一个匹配项
6. t1 = (1, 2, 'hello', 3, 4, 'hello')
7. print(t1.index('hello'))  # 结果：2
9. # 统计某个数据在元组内出现的次数
10. t1 = (1, 2, 'hello', 3, 4, 'hello')
11. print(t1.count('hello'))  # 结果：2
13. # 统计元组内的元素个数
14. t1 = (1, 2, 3)
15. print(len(t1))  # 结果：3

复制代码

输出结果：

2.3.5 元组的遍历

样例代码：

1. t1 = (1, 2, 3, 4, 5)
2. # 元组的遍历：while
3. index = 0
4. print(f"while循环遍历：", end='')
5. while index < len(t1):
6.     print(f"{t1[index]}", end=' ')
7.     index += 1
9. print()
11. # 元组的遍历：for
12. print(f"for循环遍历：", end='')
13. for element in t1:
14.     print(f"{element}", end=' ')

复制代码

输出结果：

2.3.6 元组的注意事项

• 不可以修改元组的内容，否则会直接报错
  
• 可以修改元组内的List内容(修改元素、增加、删除、反转等)
  

2.3.7 元组的特点

• 可以容纳多个数据
  
• 可以容纳不同类型的教据（混装)
  
• 数据是有序存储的(下标索引)
  
• 允许重复数据存在
  
• 不可以修改（增加或删除元素等)
  
• 支持for循环
  

2.4 数据容器：str(字符串)

2.4.1 字符串的下标(索引)

与列表、元组一样，字符串也可以通过下标进行访问

• 从前往后，下标从0开始
  
• 从后向前，下标从-1开始
  样例代码：
  

1. # 通过下标获取特定位置字符
2. name = "HeyStar"
3. print(name[0])  # 输出：H
4. print(name[-1])  # 输出：r

复制代码

同元组一样，字符串是一个：无法修改的数据容器。
所以：

• 修改指定下标的字符
  
• 移除特定下标的字符
  
• 追加字符等
  均无法完成。
  

2.4.2 字符串的常用操作

操作说明字符串[下标]根据下标索引取出特定位置字符字符串.index(字符串)查找给定字符的第一个匹配项的下标字符串.replace(字符串1,字符串2)将字符串内的全部字符串1，替换为字符串2。不会修改原字符串，而是得到一个新的字符串.split(字符串)按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表字符串.strip()移除首尾的空格和换行符或指定字符串字符串.strip(字符串)统计字符串内某字符串的出现次数len(字符串)统计字符串内某字符串的出现次数

• 查找特定字符串的下标索引值
  
  
  
  • 语法：字符串.index(字符串)
    
  • 样例代码：
    
  1. my_str = "it is HeyStar"
  2. print(my_str.index("is"))  # 结果：3

  复制代码
• 字符串的替换
  
  
  
  • 语法：字符串.replace(字符串1，字符串2)
    
  • 功能：将字符串内的全部:字符串1，替换为字符串2
    
  • 注意：不是修改字符串本身，而是得到了一个新字符串哦
    
  • 样例代码：
    
  1. my_str = "it is HeyStar"
  2. new_my_str = my_str.replace("it", "This")
  3. print(f"将字符串{my_str} ，进行替换后得到：{new_my_str}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 字符串的分割
  
  
  
  • 语法：字符串.split(分隔符字符串)
    
  • 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
    
  • 注意：字符串本身不变，而是得到了一个列表对象
    
  • 样例代码：
    
  1. my_str = "it is HeyStar"
  2. my_list = my_str.split(" ")
  3. print(f"将字符串{my_str}进行split切分后得到：{my_list}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 字符串的规整操作(去前后空格)
  
  
  
  • 语法：字符串.strip()
    
  • 样例代码：
    
  1. my_str = "     it   is   HeyStar   "
  2. print(f"将字符串"{my_str}"进行strip规整后得到："{my_str.strip()}"")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 字符串的规整操作(去前后指定字符串)
  
  
  
  • 语法：字符串.strip(字符串)
    
  • 样例代码：
    
  1. my_str = "12it is HeyStar21"
  2. print(f"将字符串"{my_str}"进行strip规整后得到："{ my_str.strip('12') }" ")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  • 注意：
    传入的是"12"，其实就是"1"和"2"都会移除，是按照单个字符
    
  
  
• 统计字符串中某字符串出现次数count
  
  
  
  • 语法：字符串.count(字符串)
    
  • 样例代码：
    
  1. my_str = "it is HeySitar"
  2. count = my_str.count("it")
  3. print(f"字符串"{my_str}"中it出现的次数是：{count}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 统计字符串长度len
  
  
  
  • 语法：len(字符串)
    
  • 样例代码：
    
  1. my_str = "it is HeySitar"
  2. print(f"字符串"{my_str}"的长度{len(my_str)}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  

2.4.3 字符串的遍历

与列表、元组一样，字符串支持while循环和for循环进行遍历

• while循环
  1. my_str = "it is HeySitar"
  2. index = 0
  3. while index < len(my_str):
  4.         print(my_str[index])
  5.         index += 1

  复制代码
• for循环
  1. my_str = "it is HeySitar"
  2. for element in my_str:
  3.         print(element)

  复制代码
• 输出结果相同：
  
  
  

2.4.4 字符串的特点

作为数据容器，字符串有如下特点:

• 只可以存储字符串
  
• 长度任意（取决于内存大小)
  
• 支持下标索引
  
• 允许重复字符串存在
  
• 不可以修改（增加或删除元素等）
  
• 支持for循环
  

2.5 数据容器(序列)的切片

2.5.1 序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
2.5.2 序列的常用操作 - 切片

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
  
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
  
• 步长表示，依次取元素的间隔
  
  
  
  • 步长1表示，一个个取元素
    
  • 步长2表示，每次跳过1个元素取
    
  • 步长N表示，每次跳过N-1个元素取
    
  
  
• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记)
  

本操作，不会影响序列本身，而是会得到一个新的序列
样例代码：

1. # 对list进行切片，从1开始，4结束，步长1
2. my_list = [0, 1, 2, 3, 4, 5, 6]
3. result1 = my_list[1:4:1]  # 步长默认为1,可省略
4. print(f"结果1：{result1}")
6. # 对tuple进行切片，从头开始，到最后结束，步长1
7. my_tuple = (0, 1, 2, 3, 4, 5, 6)
8. result2 = my_tuple[::]
9. print(f"结果2：{result2}")
11. # 对str进行切片,从头开始，到最后结束，步长2
12. my_str = "01234567"
13. result3 = my_str[::2]
14. print(f"结果3：{result3}")
16. # 对str进行切片，从头开始，到最后结束，步长-1
17. my_str = "01234567"
18. result4 = my_str[::-1]
19. print(f"结果4：{result4}")
21. # 对列表进行切片,从3开始，到结束,步长-1
22. my_list = [0, 1, 2, 3, 4, 5, 6]
23. result5 = my_list[3::-1]
24. print(f"结果5：{result5}")
26. # 对元组进行切片,从头开始，到尾结束，步长-2
27. my_tuple = (0, 1, 2, 3, 4, 5, 6)
28. result6 = my_tuple[::-2]
29. print(f"结果6：{result6}")

复制代码

输出结果：

2.6 数据容器：set(集合)

2.6.1 集合的定义

内容无序
基本语法：

1. # 定义集合字面量
2. {元素, 元素, ......, 元素}
3. # 定义集合变量
4. 变量名称 = {元素, 元素, ......, 元素}
5. # 定义空集合
6. 变量名称 = set()

复制代码

样例代码：

1. # 定义集合
2. my_set = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
3. my_set_empty = set()
4. print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
5. print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")

复制代码

输出结果：

2.6.2 集合的常用操作

集合是无序的，所以集合不支持：下标索引访问
操作说明集合.add(元素)集合内添加一个元素集合.remove(元素)移除集合内指定的元素集合.pop()从集合中随机取出一个元素集合.clear()将集合清空集合1.difference(集合2)得到一个新集合，内含2个集合的差集,原有的2个集合内容不变集合1.difference_update(集合2)在集合1中，删除集合2中存在的元素,集合1被修改，集合2不变集合1.union(集合2)得到1个新集合，内含2个集合的全部元素,原有的2个集合内容不变len(集合)得到一个整数，记录了集合的元素数量

• 添加新元素
  
  
  
  • 语法：集合.add(元素)。将指定元素，添加到集合内
    
  • 结果：集合本身被修改，添加了新元素
    
  • 样例代码：
    
  1. my_set = {"hello", "world"}
  2. my_set.add("HeyStar")
  3. print(my_set)

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 移除元素
  
  
  
  • 语法：集合.remove(元素)。将指定元素，从集合内移除
    
  • 结果：集合本身被修改，移除了新元素
    
  • 样例代码：
    
  1. my_set = {"hello", "world", "HeyStar"}
  2. my_set.remove("HeyStar")
  3. print(my_set)

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 从集合中随机取出元素
  
  
  
  • 语法：集合.pop(元素)。从集合中随机取出元素
    
  • 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
    
  • 样例代码：
    
  1. my_set = {"hello", "world", "HeyStar"}
  2. element = my_set.pop()
  3. print(my_set)
  4. print(element)

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 清空集合
  
  
  
  • 语法：集合.clear()。清空集合
    
  • 结果：集合本身被清空
    
  • 样例代码：
    
  1. my_set = {"hello", "world", "HeyStar"}
  2. my_set.clear()
  3. print(my_set)

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 取两个集合的差集
  
  
  
  • 语法：集合1.difference(集合2)。取出集合1和集合2的差集(集合1有而集合2没有的)
    
  • 结果：得到一个新集合，集合1和集合2不变
    
  • 样例代码：
    
  1. set1 = {1, 2, 3}
  2. set2 = {1, 4, 5}
  3. set3 = set1.difference(set2)
  4. print(set3)
  5. print(set1)
  6. print(set2)

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 消除两个集合的差集
  
  
  
  • 语法：集合1.difference_update(集合2)。
    
  • 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
    
  • 结果：集合1被修改，集合2不变
    
  • 样例代码：
    
  1. set1 = {1, 2, 3}
  2. set2 = {1, 4, 5}
  3. set1.difference_update(set2)
  4. print(set1)
  5. print(set2)

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 合并两个集合
  
  
  
  • 语法：集合1.union(集合2)。
    
  • 功能：将集合1和集合2合并成新集合
    
  • 结果：得到新集合，集合1和集合2不变
    
  • 样例代码：
    
  1. set1 = {1, 2, 3}
  2. set2 = {1, 4, 5}
  3. set3 = set1.union(set2)
  4. print(set3)
  5. print(set1)
  6. print(set2)

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 统计集合元素数量
  
  
  
  • 语法：len(集合)。
    
  • 功能：统计一个集合里元素的数量
    
  • 样例代码：
    
  1. set1 = {1, 2, 3}
  2. print(len(set1))

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 集合的遍历
  由于集合不支持下标索引，所以不能使用while循环
  
  
  
  • 样例代码：
    
  1. set1 = {1, 2, 3, 4, 5}
  2. for element in set1:
  3.         print(f"集合的元素有：{element}")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  

2.7 数据容器：dict(字典、映射)

2.7.1 字典的定义

1. Key:Value

复制代码

可以按照Key找出Value
字典的定义，使用{}，不过存储的元素是一个个的键值对：

1. # 定义字典字面量
2. {Key:value, Key:value, Key:value, ..., Key:value}
3. # 定义字典变量
4. my_dict = {Key:value, Key:value, Key:value, ..., Key:value}
5. # 定义空字典
6. my_dict = {}                         # 方式1
7. my_dict = dict()                # 方式2

复制代码

如果一个字典内出现重复的Key，则这个Key的Value使用最新的Value
2.7.2 字典数据的获取

不可以使用下标索引！
只可以通过Key来取得相对应的Value

• 样例代码：
  1. my_dict = {"it": 90, "is": 80,"HeyStar": 70}
  2. print(my_dict["it"])
  3. print(my_dict["is"])
  4. print(my_dict["HeyStar"])

  复制代码
• 输出结果：
  
  
  

2.7.3 定义嵌套字典

字典的Key和Value可以是任意数据类型(Key不可为字典)

1. 变量1 = {
2.         Key1:{
3.                 Key2:Value,
4.                 Key2:Value,
5.                 Key2:Value,
6.         },
7.         Key1:{
8.                 Key2:Value,
9.                 Key2:Value,
10.                 Key2:Value,
11.         }
12. }

复制代码

• 样例代码：
  1. stu_score_dict = {
  2.         "Aim": {
  3.                 "语文": 77,
  4.                 "数学": 66,
  5.                 "英语": 60
  6.         },
  7.         "Bob": {
  8.                 "语文": 99,
  9.                 "数学": 88,
  10.                 "英语": 77
  11.         },
  12.         "Cao": {
  13.                 "语文": 99,
  14.                 "数学": 99,
  15.                 "英语": 99
  16.         }
  17. }
  19. score = stu_score_dict["Aim"]["语文"]
  20. print(f"Aim的语文成绩：{score}")

  复制代码
• 结果输出：
  
  
  
  

2.7.4 字典的常用操作：

操作说明字典[Key]获取指定Key对应的Value值字典[Key] = value添加或更新键值对字典.pop(Key)取出Key对应的Value并在字典内删除此Key的键值对字典.clear()清空字典字典.keys()获取字典的全部Key，可用于for循环遍历字典len(字典)计算字典内的元素数量

• 新增元素
  
  
  
  • 语法：字典[Key]=Value
    
  • 结果：字典被修改，新增了元素
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. stu_score_dict['Did'] = 88
  7. print(f"{stu_score_dict}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 更新元素
  
  
  
  • 语法：字典[Key]=Value
    
  • 结果：字典被修改，元素被更新
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. stu_score_dict['Cao'] = 88
  7. print(f"{stu_score_dict}")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 删除元素
  
  
  
  • 语法：字典.pop(Key)
    
  • 结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. stu_score_dict.pop("Bob")
  7. print(f"{stu_score_dict}")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 清空字典
  
  
  
  • 语法：字典.clear()
    
  • 结果：字典被修改，元素被清空
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. stu_score_dict.clear()
  7. print(f"{stu_score_dict}")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 获取全部的Key
  
  
  
  • 语法：字典.keys()
    
  • 结果：得到字典中的全部Key
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. keys = stu_score_dict.keys()
  7. print(f"{keys}")

  复制代码
  
  
  • 输出结果：
    
    
    
    
  
  
• 遍历字典
  
  
  
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. # 方式1：通过获取到全部的Key来遍历
  7. keys = stu_score_dict.keys()
  8. for key in keys:
  9.         print(f"字典的key是：{key}   对应的Value是：{stu_score_dict[key]}")
  11. # 方式2：直接对字典进行for循环，每次循环都得到key
  12. for key in stu_score_dict:
  13.         print(f"字典2的key是：{key}   对应的Value是：{stu_score_dict[key]}")

  复制代码
  
  
  • 输出结果：
    
    
    
  
  
• 统计字典内的元素数量
  
  
  
  • 语法：len(字典)
    
  • 样例代码：
    
  1. stu_score_dict = {
  2.         "Aim": 66,
  3.         "Bob": 77,
  4.         "Cao": 99
  5. }
  6. print(len(stu_score_dict))

  复制代码
  
  
  • 输出结果：
    
    
    
  
  

2.8 数据容器汇总

2.8.1 数据容器的分类

• 是否支持下标索引
  
  
  
  • 支持:列表、元组、字符串   – 序列类型
    
  • 不支持:集合、字典   – 非序列类型
    
  
  
• 是否支持重复元素:
  
  
  
  • 支持:列表、光组、字符串   – 序列类型
    
  • 不支持:集合、字典  – 非序列类型
    
  
  
• 是否可以修改
  
  
  
  • 支持:列表、集合、字典
    
  • 不支持:元组、字符串
    
  
  

2.8.2 数据容器的特点对比

来源@黑马程序员

2.8.3 数据容器的通用功能

• len(容器)
  统计容器的元素个数
  
• max(容器)
  统计容器的最大元素
  
• min(容器)
  统计容器的最小元素
  
• {sorted(容器)}
  对容器进行排序
  
• {sorted(容器),reverse=True}
  对容器进行反向排序
  

功能描述通用for循环遍历容器（字典是遍历key)max容器内最大元素min()容器内最小元素len()容器元素个数list()转换为列表tuple()转换为元组str()转换为字符串set()转换为集合sorted(序列,[reverse=True])排序，reverse=True表示降序，得到一个排好序的列表
来源:https://www.cnblogs.com/heystar/p/17605818.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！