Python | 函数、数据容器
1.函数函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
1.1 简单案例
重复使用计算字符串的长度
str1 = "heystar"
str2 = "python"
str3 = "abcd"
count = 0
for _ in str1:
count += 1
print(f"字符串{str1}的长度是：{count}")
count = 0
for _ in str2:
count += 1
print(f"字符串{str2}的长度是：{count}")
count = 0
for _ in str3:
count += 1
print(f"字符串{str3}的长度是：{count}")使用函数计算字符串的长度
# 以下为优化：
str1 = "heystar"
str2 = "python"
str3 = "abcd"
def my_len(data):
cnt = 0
for _ in data:
cnt += 1
print(f"字符串{data}的长度是：{cnt}")
my_len(str1)
my_len(str2)
my_len(str3)1.2 使用函数的好处：
为了得到一个针对特定需求、可供重复利用的代码段
提高程序的复用性，减少重复性代码，提高开发效率
1.3 函数的基本定义
函数的定义
def 函数名(传入参数)
函数体
return 返回值函数的调用
函数名(参数)
注意事项
[*]参数如不需要,可以省略
[*]返回值如不需要，可以省略
[*]函数必须先定义后使用
简单案例
# 定义一个函数，输出相关信息
def say_hi():
print("Hi~ o(*￣▽￣*)ブ")
# 调用函数
say_hi()1.4 函数的参数
传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据
多个参数案例
def add(x, y):
result = x + y
print(f"{x}+{y}={x + y}")
add(5, 6)语法解析
[*]函数定义中，提供的x和y，称之为∶形式参数（形参)，表示函数声明将要使用2个参数
[*]参数之间使用逗号进行分隔
[*]函数调用中，提供的5和6，称之为:实际参数（实参)，表示函数执行时真正使用的参数值
[*]传入的时候,按照顺序传入数据,使用逗号分隔
函数的传入参数
传入参数的数量是不受限制的。
[*]可以不使用参数
[*]也可以仅使用任意N个参数
以上代码增加参数：
def add(x, y, z):
result = x + y + z
print(f"{x}+{y}+{z}={x + y + z}")
add(1, 2, 3)1.5 函数的返回值
返回值：就是程序中函数完成事情后，最后给调用者的结果
函数体在遇到retuen后就结束了，所以写在return后的代码不会执行
语法格式
def 函数(参数...)
函数体
return 返回值
变量 = 函数(参数)简单案例
def add(x, y, z):
result = x + y + z
return result
Sum = add(1, 2, 3)
print(Sum)None类型
Python中有一个特殊的字面量：None，其类型是：
无返回值的函数，实际上就是返回了：None这个字面量
None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
None类型的应用场景
None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。
[*]用在函数无返回值上
[*]用在if判断上
[*]在if判断中，None等同于False
[*]一般用于在函数中主动返回None，配合if判断做相关处理
[*]用于声明无内容的变量上
[*]定义变量，但暂时不需要变量有具体值，可以用None来代替
# 暂不赋予变量具体值
name = None1.6 函数的说明文档
需要给函数添加说明文档，辅助理解函数的作用。
通过多行注释的形式，对函数进行说明解释
[*]内容应写在函数体之前
格式：
def 函数名(参数)
"""
函数说明
:param x:形参x的说明
:param y:形参y的说明
:return: 返回值的说明
"""
函数体
return 返回值1.7 函数的嵌套调用
所谓函数嵌套调用是指：一个函数里面调用了另外一个函数
简单案例
def fun_b():
print("2")
def fun_a():
print("1")
fun_b()
print("3")
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，用来记录客户姓名
[*]定义如下函数：
[*]查询余额函数
[*]存款函数
[*]取款函数
[*]主菜单函数
[*]要求：
[*]查询余额、存款、取款后都会返回主菜单
[*]存款、取款后，都应显示一下当前余额
[*]客户选择退出或输入错误，程序会退出，否则一直运行
代码
# ATM
money = 5000000
name = "HeyStar"
def menu():
print(f"-------------主菜单-------------")
print(f"\t查询余额\t\t[输入1]")
print(f"\t存 款\t[输入2]")
print(f"\t取 款\t[输入3]")
print(f"\t退 出\t[输入4]")
opt = int(input(f"\t请输入您的选择："))
return opt
# 查询余额
def check_balance(user_name):
print(f"------------查询余额-------------")
print(f"{user_name}，您好，您的余额剩余：{money}")
# 存款
def deposit(user_name, user_money):
print(f"-------------存款--------------")
print(f"{user_name},您好，您存款50000元成功")
user_money += 50000
print(f"{user_name}，您好，您的余额剩余：{user_money}")
return user_money
# 取款
def withdraw_money(user_name, user_money):
print(f"-------------取款--------------")
print(f"{user_name},您好，您取款50000元成功")
user_money -= 50000
print(f"{user_name}，您好，您的余额剩余：{user_money}")
return user_money
while 1:
op = menu()
if op == 1:
check_balance(name)
elif op == 2:
money = deposit(name, money)
elif op == 3:
money = withdraw_money(name, money)
elif op == 4:
break
else:
print(f"您输入的序号有误，请重新输入")输出结果
1.10 函数返回多个返回值
[*]样例代码
def test_return():
return 1, 2
x, y = test_return()
print(x)
print(y)
[*]输出结果：
https://img1.imgtp.com/2023/08/09/t7UYkJys.png
[*]按照返回值的顺序,写对应顺序的多个变量接收即可
[*]变量之间用逗号隔开
[*]支持不同类型的数据return
1.11 函数的多种传参方式
1.11.1 位置参数
调用函数时，根据函数定义的参数位置来传递参数
传递的参数和定义的参数的顺序及个数必须一致
def user_info(name, age, gender):
print(f"您的姓名是{name},年龄是{age},性别是{gender}")
user_info('Tom', 20, '男')1.11.2 关键字参数
关键字参数：函数调用时通过 “键=值” 形式传递参数.
作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.
样例代码：
def user_info(name, age, gender):
print(f"您的姓名是{name},年龄是{age},性别是{gender}")
# 关键字传参：
user_info(name='Tom', age=20, gender='男')
# 不按照固定顺序：
user_info(age=20, name='Tom', gender='男')
# 与位置参数混用，但位置参数必须在前
user_info('Tom', age=20, gender='男')函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
1.11.3 缺省参数（默认值）
def user_info(name, age, gender='男'):
print(f"您的姓名是{name},年龄是{age},性别是{gender}")
user_info('Tom', 20)
user_info('Aim', 20, '女')输出结果：
1.11.4 不定长参数
不定长参数:不定长参数也叫可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
作用:当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：
[*]位置传递
[*]样例代码：
def user_info(*args):
print(args)
# ('Tom')
user_info('Tom')
# ('Tom',18)
user_info('Tom',18)传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递
[*]关键字传递
[*]样例代码：
def user_info(**kwargs):
print(kwargs)
# ('name'='Tom','age'=18,'id'=123)
user_info(name='Tom', age=18, id=123)`参数是 “键=值” 形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典
1.12 函数作为参数传递
样例代码：
def test_func(compute):
result = compute(1, 2)
print(result)
def compute(x, y):
return x + y
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个形式参数
[*]函数体，就是函数的执行逻辑，要注意:只能写一行，无法写多行代码
样例代码：
def test_func(compute):
result = compute(1, 2)
print(result)
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，元素3，元素4，...]
# 定义变量
变量名称 = [元素1，元素2，元素3，元素4，...]
# 定义空列表
变量名称 = []
变量名称 = list() 列表中的每一个数据，称之为元素
[*]以[]作为标识
[*]列表内每一个元素之间用，逗号隔开
列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。
2.2.2 列表的下标索引
下标索引
可以从列表中取出特定位置的数据
列表中的每一个元素，都有其下标索引，从前往后，从0开始，依次递增
# 语法，列表[下标索引]
name_list = ['Tom', 'Lily', 'Rose']
print(name_list)
print(name_list)
print(name_list)输出
Tom
Rose
Lily反向索引
可以反向索引，也就是从右向左，从后向前：从-1开始，依次递减(-1、-2、-3......)
# 语法，列表[下标索引]
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])输出
Rose
Lily
Tom嵌套列表的下标
两层嵌套类似于二维列表
my_list = [, ]
print(my_list)
print(my_list)
print(my_list)输出
2
6注意事项
[*]要注意下标索引的取值范围，超出范围无法取出元素，并且会报错
2.2.3 列表的常用操作
列表除了可以:
[*]定义
[*]使用下标索引获取值
以外，列表也提供了一系列功能:
[*]插入元素
[*]删除元素
[*]清空列表
[*]修改元素
[*]统计元素个数
等等功能，这些功能我们都称之为:列表的方法
2.2.3.1 列表的查询功能
[*]查找某元素的下标
[*]功能：查找指定元素在列表的下标，如果找不到，报错ValueError
[*]语法：列表.index(元素)
index 就是列表对象（变量）内置的方法（函数）
[*]代码
my_list = ["hey", "hello", "star", "hi"]
# 下标存在
index = my_list.index("hello")
print(index)
# 下标不存在，会报错
index = my_list.index("he")
print(index)输出结果
2.2.3.2 列表的修改功能
[*]修改特定位置（索引）的元素值
[*]语法：列表{下标} = 值
可以使用如上的语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
[*]代码
my_list =
# 正向下标
my_list = 9
print(my_list)# 当前列表为
# 反向下标
my_list[-2] = 8
print(my_list)# 当前列表为 输出结果：
https://img1.imgtp.com/2023/08/08/A7euCPfl.png
2.2.3.3 列表的修改功能
[*]插入元素
[*]语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素
代码：
my_list =
my_list.insert(1,"HeyStar")
print(my_list)输出结果：
2.2.3.4 列表的追加元素功能
[*]语法：列表.append(元素)，将指定元素，追加到列表的尾部
[*]或者：列表.extend(其他数据容器)，将其他数据容器的内容取出，一次追加到列表尾部
代码：
# 追加单个元素
my_list =
my_list.append(4)
print(my_list)
# 追加一批元素
my_list =
my_list.extend()
print(my_list)输出结果：
https://img1.imgtp.com/2023/08/08/jWG0iAvP.png
2.2.3.5 列表的删除元素功能
[*]语法1：del 列表[下标]
[*]语法2：列表.pop(下标)
[*]删除某元素在列表中的第一匹配项
[*]语法列表.remove(元素)
代码：
# 语法1
my_list =
del my_list
print(my_list)
# 语法2
my_list =
my_list.pop(1)
print(my_list)
# 删除某元素在列表中的第一匹配项
my_list =
my_list.remove(2)
print(my_list)输出结果：
2.2.3.6 列表的清空功能
[*]语法：列表.clear()
代码：
# 语法
my_list =
my_list.clear()
print(my_list)输出结果：
https://img1.imgtp.com/2023/08/08/KsyP1ocv.png
2.2.3.7 列表的统计元素功能
[*]统计某元素在列表中的数量
[*]语法：列表.count(元素)
代码：
# 语法
my_list =
print(my_list.count(1))输出结果
https://img1.imgtp.com/2023/08/08/BCX9W3Ds.png
2.2.3.8 列表的统计全部元素功能
[*]统计列表中全部的元素的数量
[*]语法：len(列表)
代码：
# 语法
my_list =
print(len(my_list))输出结果：
https://img1.imgtp.com/2023/08/08/2jsj5ROd.png
2.2.3 列表的常用操作功能练习
有一个列表，内容是:，记录的是一批学生的年龄
请通过列表的功能（方法)，对其进行
1．定义这个列表，并用变量接收它
2．追加一个数字31，到列表的尾部
3．追加一个新列表，到列表的尾部
4．取出第一个元素（应是:21)
5．取出最后一个元素（应是:30)
6．查找元素31，在列表中的下标位置代码：
students_age =
print(f"进行操作1后，目前列表内容为：{students_age}")
students_age.append(31)
print(f"进行操作2后，目前列表内容为：{students_age}")
students_age.extend()
print(f"进行操作3后，目前列表内容为：{students_age}")
print(f"操作4：")
print(students_age)
print(f"操作5：")
print(students_age[-1])
print(f"操作6：")
print(students_age.index(31))输出结果：
https://img1.imgtp.com/2023/08/08/K4ZIU3HI.png
2.2.4 列表的循环遍历
[*]将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代
2.2.4.1 如何遍历列表的元素
[*]使用while循环
2.2.4.2 如何在循环中取出列表的元素
[*]使用列表[下标]的方式取出
2.2.4.3 while循环条件的控制
[*]定义一个变量表示下标，从0开始
[*]循环条件为下标值 < 列表的元素数量
index = 0
while index < len(列表):
元素 = 列表
对元素进行处理
index += 12.2.4.4 for循环条件的控制
[*]语法
for 临时变量 in 数据容器:
对临时变量进行操作表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，可以对临时变量（元素）进行处理。
2.2.4.5 代码练习
# while循环
def list_while_func():
my_list =
index = 0
print("while循环操作：")
print("列表的元素 { ", end='')
while index < len(my_list):
print(my_list, end='')
index += 1
print("}")
# for循环
def list_for_func():
my_list =
print("for循环操作：")
print("列表的元素 { ", end='')
for index in my_list:
print(index,end=' ')
print("}")
list_while_func()
list_for_func()输出结果：
https://img1.imgtp.com/2023/08/08/9iCytH6h.png
2.3 数据容器：tuple(元组)
元组和列表一样，都是可以封装多个、不同类型的元素在内。
不同点在于：元组一旦定义完成，就不可修改
2.3.1 元组的定义
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
# 定义元组字面量
(元素,元素,元素,......,元素)
# 定义元组变量
变量名称 = (元素,元素,元素,......,元素)
# 定义空元组
变量名称 = () # 方法1
变量名称 = tuple() # 方法2代码练习：
# 定义元组
my_tuple1 = (1, 2, 3, "Hello", True)
my_tuple2 = ()
my_tuple3 = tuple()
print(f"my_tuple1的类型是：{type(my_tuple1)} , 内容是：{my_tuple1}")
print(f"my_tuple2的类型是：{type(my_tuple2)} , 内容是：{my_tuple2}")
print(f"my_tuple3的类型是：{type(my_tuple3)} , 内容是：{my_tuple3}")输出结果：
https://img1.imgtp.com/2023/08/09/ijkTRg07.png
注意事项
如果元组只有一个数据，这个数据后面需要添加逗号。
如：my_tuple1 = ("Hello",)
2.3.2 元组的嵌套
样例代码：
# 定义一个嵌套元组
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"my_tuple的类型是：{type(my_tuple)}，内容是：{my_tuple}")输出结果：
2.3.3 元组的下标索引
样例代码：
# 下标索引取出内容
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"{my_tuple}")输出结果：
2.3.4 元组的相关操作
方法作用index()查找某个数据，如果数据存在返回对应的下标，否则报错count()统计某个数据在当前元组出现的次数len(元组)统计元组内的元素个数样例代码：
# 根据下标(索引)取出数据
t1 = (1, 2, 'hello')
print(t1)# 结果：'hello'
# 根据index()，查找特定元素的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))# 结果：2
# 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello'))# 结果：2
# 统计元组内的元素个数
t1 = (1, 2, 3)
print(len(t1))# 结果：3输出结果：
2.3.5 元组的遍历
样例代码：
t1 = (1, 2, 3, 4, 5)
# 元组的遍历：while
index = 0
print(f"while循环遍历：", end='')
while index < len(t1):
print(f"{t1}", end=' ')
index += 1
print()
# 元组的遍历：for
print(f"for循环遍历：", end='')
for element in t1:
print(f"{element}", end=' ')输出结果：
2.3.6 元组的注意事项
[*]不可以修改元组的内容，否则会直接报错
[*]可以修改元组内的List内容(修改元素、增加、删除、反转等)
2.3.7 元组的特点
[*]可以容纳多个数据
[*]可以容纳不同类型的教据（混装)
[*]数据是有序存储的(下标索引)
[*]允许重复数据存在
[*]不可以修改（增加或删除元素等)
[*]支持for循环
2.4 数据容器：str(字符串)
2.4.1 字符串的下标(索引)
与列表、元组一样，字符串也可以通过下标进行访问
[*]从前往后，下标从0开始
[*]从后向前，下标从-1开始
样例代码：
# 通过下标获取特定位置字符
name = "HeyStar"
print(name)# 输出：H
print(name[-1])# 输出：r同元组一样，字符串是一个：无法修改的数据容器。
所以：
[*]修改指定下标的字符
[*]移除特定下标的字符
[*]追加字符等
均无法完成。
2.4.2 字符串的常用操作
操作说明字符串[下标]根据下标索引取出特定位置字符字符串.index(字符串)查找给定字符的第一个匹配项的下标字符串.replace(字符串1,字符串2)将字符串内的全部字符串1，替换为字符串2。不会修改原字符串，而是得到一个新的字符串.split(字符串)按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表字符串.strip()移除首尾的空格和换行符或指定字符串字符串.strip(字符串)统计字符串内某字符串的出现次数len(字符串)统计字符串内某字符串的出现次数
[*]查找特定字符串的下标索引值
[*]语法：字符串.index(字符串)
[*]样例代码：
my_str = "it is HeyStar"
print(my_str.index("is"))# 结果：3
[*]字符串的替换
[*]语法：字符串.replace(字符串1，字符串2)
[*]功能：将字符串内的全部:字符串1，替换为字符串2
[*]注意：不是修改字符串本身，而是得到了一个新字符串哦
[*]样例代码：
my_str = "it is HeyStar"
new_my_str = my_str.replace("it", "This")
print(f"将字符串{my_str} ，进行替换后得到：{new_my_str}")
[*]输出结果：
[*]字符串的分割
[*]语法：字符串.split(分隔符字符串)
[*]功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
[*]注意：字符串本身不变，而是得到了一个列表对象
[*]样例代码：
my_str = "it is HeyStar"
my_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_list}")
[*]输出结果：
[*]字符串的规整操作(去前后空格)
[*]语法：字符串.strip()
[*]样例代码：
my_str = " it is HeyStar "
print(f"将字符串\"{my_str}\"进行strip规整后得到：\"{my_str.strip()}\"")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/HyyT0JHs.png
[*]字符串的规整操作(去前后指定字符串)
[*]语法：字符串.strip(字符串)
[*]样例代码：
my_str = "12it is HeyStar21"
print(f"将字符串\"{my_str}\"进行strip规整后得到：\"{ my_str.strip('12') }\" ")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/p4qcCBBZ.png
[*]注意：
传入的是"12"，其实就是"1"和"2"都会移除，是按照单个字符
[*]统计字符串中某字符串出现次数count
[*]语法：字符串.count(字符串)
[*]样例代码：
my_str = "it is HeySitar"
count = my_str.count("it")
print(f"字符串\"{my_str}\"中it出现的次数是：{count}")
[*]输出结果：
[*]统计字符串长度len
[*]语法：len(字符串)
[*]样例代码：
my_str = "it is HeySitar"
print(f"字符串\"{my_str}\"的长度{len(my_str)}")
[*]输出结果：
2.4.3 字符串的遍历
与列表、元组一样，字符串支持while循环和for循环进行遍历
[*]while循环my_str = "it is HeySitar"
index = 0
while index < len(my_str):
print(my_str)
index += 1
[*]for循环my_str = "it is HeySitar"
for element in my_str:
print(element)
[*]输出结果相同：
2.4.4 字符串的特点
作为数据容器，字符串有如下特点:
[*]只可以存储字符串
[*]长度任意（取决于内存大小)
[*]支持下标索引
[*]允许重复字符串存在
[*]不可以修改（增加或删除元素等）
[*]支持for循环
2.5 数据容器(序列)的切片
2.5.1 序列
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
2.5.2 序列的常用操作 - 切片
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
[*]起始下标表示从何处开始，可以留空，留空视作从头开始
[*]结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
[*]步长表示，依次取元素的间隔
[*]步长1表示，一个个取元素
[*]步长2表示，每次跳过1个元素取
[*]步长N表示，每次跳过N-1个元素取
[*]步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记)
本操作，不会影响序列本身，而是会得到一个新的序列
样例代码：
# 对list进行切片，从1开始，4结束，步长1
my_list =
result1 = my_list# 步长默认为1,可省略
print(f"结果1：{result1}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[::]
print(f"结果2：{result2}")
# 对str进行切片,从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"结果4：{result4}")
# 对列表进行切片,从3开始，到结束,步长-1
my_list =
result5 = my_list
print(f"结果5：{result5}")
# 对元组进行切片,从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")输出结果：
https://img1.imgtp.com/2023/08/09/IJHr6TkV.png
2.6 数据容器：set(集合)
2.6.1 集合的定义
内容无序
基本语法：
# 定义集合字面量
{元素, 元素, ......, 元素}
# 定义集合变量
变量名称 = {元素, 元素, ......, 元素}
# 定义空集合
变量名称 = set()样例代码：
# 定义集合
my_set = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
my_set_empty = set()
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")输出结果：
https://img1.imgtp.com/2023/08/09/fFuDh0tg.png
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(元素)。将指定元素，添加到集合内
[*]结果：集合本身被修改，添加了新元素
[*]样例代码：
my_set = {"hello", "world"}
my_set.add("HeyStar")
print(my_set)
[*]输出结果：
https://img1.imgtp.com/2023/08/09/qrLupgUG.png
[*]移除元素
[*]语法：集合.remove(元素)。将指定元素，从集合内移除
[*]结果：集合本身被修改，移除了新元素
[*]样例代码：
my_set = {"hello", "world", "HeyStar"}
my_set.remove("HeyStar")
print(my_set)
[*]输出结果：
[*]从集合中随机取出元素
[*]语法：集合.pop(元素)。从集合中随机取出元素
[*]结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
[*]样例代码：
my_set = {"hello", "world", "HeyStar"}
element = my_set.pop()
print(my_set)
print(element)
[*]输出结果：
https://img1.imgtp.com/2023/08/09/wgGW2Hmb.png
[*]清空集合
[*]语法：集合.clear()。清空集合
[*]结果：集合本身被清空
[*]样例代码：
my_set = {"hello", "world", "HeyStar"}
my_set.clear()
print(my_set)
[*]输出结果：
https://img1.imgtp.com/2023/08/09/NiqqpFL4.png
[*]取两个集合的差集
[*]语法：集合1.difference(集合2)。取出集合1和集合2的差集(集合1有而集合2没有的)
[*]结果：得到一个新集合，集合1和集合2不变
[*]样例代码：
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set3 = set1.difference(set2)
print(set3)
print(set1)
print(set2)
[*]输出结果：
[*]消除两个集合的差集
[*]语法：集合1.difference_update(集合2)。
[*]功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
[*]结果：集合1被修改，集合2不变
[*]样例代码：
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set1.difference_update(set2)
print(set1)
print(set2)
[*]输出结果：
https://img1.imgtp.com/2023/08/09/cqiTIxle.png
[*]合并两个集合
[*]语法：集合1.union(集合2)。
[*]功能：将集合1和集合2合并成新集合
[*]结果：得到新集合，集合1和集合2不变
[*]样例代码：
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set3 = set1.union(set2)
print(set3)
print(set1)
print(set2)
[*]输出结果：
[*]统计集合元素数量
[*]语法：len(集合)。
[*]功能：统计一个集合里元素的数量
[*]样例代码：
set1 = {1, 2, 3}
print(len(set1))
[*]输出结果：
https://img1.imgtp.com/2023/08/09/Cpf4ej6g.png
[*]集合的遍历
由于集合不支持下标索引，所以不能使用while循环
[*]样例代码：
set1 = {1, 2, 3, 4, 5}
for element in set1:
print(f"集合的元素有：{element}")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/lGPHYxz3.png
2.7 数据容器：dict(字典、映射)
2.7.1 字典的定义
Key:Value可以按照Key找出Value
字典的定义，使用{}，不过存储的元素是一个个的键值对：
# 定义字典字面量
{Key:value, Key:value, Key:value, ..., Key:value}
# 定义字典变量
my_dict = {Key:value, Key:value, Key:value, ..., Key:value}
# 定义空字典
my_dict = {} # 方式1
my_dict = dict() # 方式2如果一个字典内出现重复的Key，则这个Key的Value使用最新的Value
2.7.2 字典数据的获取
不可以使用下标索引！
只可以通过Key来取得相对应的Value
[*]样例代码：my_dict = {"it": 90, "is": 80,"HeyStar": 70}
print(my_dict["it"])
print(my_dict["is"])
print(my_dict["HeyStar"])
[*]输出结果：
2.7.3 定义嵌套字典
字典的Key和Value可以是任意数据类型(Key不可为字典)
变量1 = {
Key1:{
Key2:Value,
Key2:Value,
Key2:Value,
},
Key1:{
Key2:Value,
Key2:Value,
Key2:Value,
}
}
[*]样例代码：stu_score_dict = {
"Aim": {
"语文": 77,
"数学": 66,
"英语": 60
},
"Bob": {
"语文": 99,
"数学": 88,
"英语": 77
},
"Cao": {
"语文": 99,
"数学": 99,
"英语": 99
}
}
score = stu_score_dict["Aim"]["语文"]
print(f"Aim的语文成绩：{score}")
[*]结果输出：
https://img1.imgtp.com/2023/08/09/0GNuX0Ey.png
2.7.4 字典的常用操作：
操作说明字典获取指定Key对应的Value值字典 = value添加或更新键值对字典.pop(Key)取出Key对应的Value并在字典内删除此Key的键值对字典.clear()清空字典字典.keys()获取字典的全部Key，可用于for循环遍历字典len(字典)计算字典内的元素数量
[*]新增元素
[*]语法：字典=Value
[*]结果：字典被修改，新增了元素
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
stu_score_dict['Did'] = 88
print(f"{stu_score_dict}")
[*]输出结果：
[*]更新元素
[*]语法：字典=Value
[*]结果：字典被修改，元素被更新
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
stu_score_dict['Cao'] = 88
print(f"{stu_score_dict}")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/hkWWW8XM.png
[*]删除元素
[*]语法：字典.pop(Key)
[*]结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
stu_score_dict.pop("Bob")
print(f"{stu_score_dict}")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/yyiy7Bcg.png
[*]清空字典
[*]语法：字典.clear()
[*]结果：字典被修改，元素被清空
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
stu_score_dict.clear()
print(f"{stu_score_dict}")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/kFi4GJIv.png
[*]获取全部的Key
[*]语法：字典.keys()
[*]结果：得到字典中的全部Key
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
keys = stu_score_dict.keys()
print(f"{keys}")
[*]输出结果：
https://img1.imgtp.com/2023/08/09/XQrxZJSk.png
[*]遍历字典
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
# 方式1：通过获取到全部的Key来遍历
keys = stu_score_dict.keys()
for key in keys:
print(f"字典的key是：{key} 对应的Value是：{stu_score_dict}")
# 方式2：直接对字典进行for循环，每次循环都得到key
for key in stu_score_dict:
print(f"字典2的key是：{key} 对应的Value是：{stu_score_dict}")
[*]输出结果：
[*]统计字典内的元素数量
[*]语法：len(字典)
[*]样例代码：
stu_score_dict = {
"Aim": 66,
"Bob": 77,
"Cao": 99
}
print(len(stu_score_dict))
[*]输出结果：
2.8 数据容器汇总
2.8.1 数据容器的分类
[*]是否支持下标索引
[*]支持:列表、元组、字符串 – 序列类型
[*]不支持:集合、字典 – 非序列类型
[*]是否支持重复元素:
[*]支持:列表、光组、字符串 – 序列类型
[*]不支持:集合、字典– 非序列类型
[*]是否可以修改
[*]支持:列表、集合、字典
[*]不支持:元组、字符串
2.8.2 数据容器的特点对比
来源@黑马程序员
https://img1.imgtp.com/2023/08/09/HjwGCy2F.png
2.8.3 数据容器的通用功能
[*]len(容器)
统计容器的元素个数
[*]max(容器)
统计容器的最大元素
[*]min(容器)
统计容器的最小元素
[*]{sorted(容器)}
对容器进行排序
[*]{sorted(容器),reverse=True}
对容器进行反向排序
功能描述通用for循环遍历容器（字典是遍历key)max容器内最大元素min()容器内最小元素len()容器元素个数list()转换为列表tuple()转换为元组str()转换为字符串set()转换为集合sorted(序列,)排序，reverse=True表示降序，得到一个排好序的列表
来源:https://www.cnblogs.com/heystar/p/17605818.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！
页:
[1]