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,其类型是:<class 'NoneType'>
无返回值的函数,实际上就是返回了:None这个字面量
None表示:空的、无实际意义的意思
函数返回的None,就表示,这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
None类型的应用场景
None作为一个特殊的字面量,用于表示:空、无意义,其有非常多的应用场景。
-
用在函数无返回值上
-
用在if判断上
- 在if判断中,None等同于False
- 一般用于在函数中主动返回None,配合if判断做相关处理
-
用于声明无内容的变量上
- 定义变量,但暂时不需要变量有具体值,可以用None来代替
# 暂不赋予变量具体值
name = None
1.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)
-
输出结果:
-
按照返回值的顺序,写对应顺序的多个变量接收即可
-
变量之间用逗号隔开
-
支持不同类型的数据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[0])
print(name_list[2])
print(name_list[1])
输出
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 = [[1, 2, 3], [4, 5, 6]]
print(my_list[0][1])
print(my_list[1])
print(my_list[1][2])
输出
2
[4, 5, 6]
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 = [1, 2, 3, 4, 5]
# 正向下标
my_list[0] = 9
print(my_list) # 当前列表为 [9, 2, 3, 4, 5]
# 反向下标
my_list[-2] = 8
print(my_list) # 当前列表为 [9, 2, 3, 8, 5]
输出结果:
2.2.3.3 列表的修改功能
- 插入元素
- 语法:
列表.insert(下标,元素)
,在指定的下标位置,插入指定的元素
- 语法:
代码:
my_list = [1, 2, 3]
my_list.insert(1,"HeyStar")
print(my_list)
输出结果:
2.2.3.4 列表的追加元素功能
- 语法:
列表.append(元素)
,将指定元素,追加到列表的尾部 - 或者:
列表.extend(其他数据容器)
,将其他数据容器的内容取出,一次追加到列表尾部
代码:
# 追加单个元素
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)
# 追加一批元素
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)
输出结果:
2.2.3.5 列表的删除元素功能
- 语法1:
del 列表[下标]
- 语法2:
列表.pop(下标)
- 删除某元素在列表中的第一匹配项
- 语法
列表.remove(元素)
- 语法
代码:
# 语法1
my_list = [1, 2, 3]
del my_list[0]
print(my_list)
# 语法2
my_list = [1, 2, 3]
my_list.pop(1)
print(my_list)
# 删除某元素在列表中的第一匹配项
my_list = [1, 2, 3, 2, 1]
my_list.remove(2)
print(my_list)
输出结果:
2.2.3.6 列表的清空功能
- 语法:
列表.clear()
代码:
# 语法
my_list = [1, 2, 3]
my_list.clear()
print(my_list)
输出结果:
2.2.3.7 列表的统计元素功能
- 统计某元素在列表中的数量
- 语法:
列表.count(元素)
代码:
# 语法
my_list = [1, 2, 3, 2, 1]
print(my_list.count(1))
输出结果
2.2.3.8 列表的统计全部元素功能
- 统计列表中全部的元素的数量
- 语法:
len(列表)
代码:
# 语法
my_list = [1, 2, 3, 2, 1]
print(len(my_list))
输出结果:
2.2.3 列表的常用操作功能练习
有一个列表,内容是:[21,25,21,23,22,20],记录的是一批学生的年龄
请通过列表的功能(方法),对其进行
1.定义这个列表,并用变量接收它
2.追加一个数字31,到列表的尾部
3.追加一个新列表[29,33,30],到列表的尾部
4.取出第一个元素(应是:21)
5.取出最后一个元素(应是:30)
6.查找元素31,在列表中的下标位置
代码:
students_age = [21, 25, 21, 23, 22, 20]
print(f"进行操作1后,目前列表内容为:{students_age}")
students_age.append(31)
print(f"进行操作2后,目前列表内容为:{students_age}")
students_age.extend([29, 33, 30])
print(f"进行操作3后,目前列表内容为:{students_age}")
print(f"操作4:")
print(students_age[0])
print(f"操作5:")
print(students_age[-1])
print(f"操作6:")
print(students_age.index(31))
输出结果:
2.2.4 列表的循环遍历
- 将容器内的元素依次取出进行处理的行为,称之为:遍历、迭代
2.2.4.1 如何遍历列表的元素
- 使用while循环
2.2.4.2 如何在循环中取出列表的元素
- 使用列表[下标]的方式取出
2.2.4.3 while循环条件的控制
- 定义一个变量表示下标,从0开始
- 循环条件为
下标值 < 列表的元素数量
index = 0
while index < len(列表):
元素 = 列表[index]
对元素进行处理
index += 1
2.2.4.4 for循环条件的控制
- 语法
for 临时变量 in 数据容器:
对临时变量进行操作
表示,从容器内,依次取出元素并赋值到临时变量上。
在每一次的循环中,可以对临时变量(元素)进行处理。
2.2.4.5 代码练习
# while循环
def list_while_func():
my_list = [1, 2, 3, 4, 5, 6]
index = 0
print("while循环操作:")
print("列表的元素 { ", end='')
while index < len(my_list):
print(my_list[index], end='')
index += 1
print("}")
# for循环
def list_for_func():
my_list = [1, 2, 3, 4, 5, 6]
print("for循环操作:")
print("列表的元素 { ", end='')
for index in my_list:
print(index,end=' ')
print("}")
list_while_func()
list_for_func()
输出结果:
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}")
输出结果:
注意事项
如果元组只有一个数据,这个数据后面需要添加逗号。
如: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[1][2]}")
输出结果:
2.3.4 元组的相关操作
方法 | 作用 |
---|---|
index() |
查找某个数据,如果数据存在返回对应的下标,否则报错 |
count() |
统计某个数据在当前元组出现的次数 |
len(元组) |
统计元组内的元素个数 |
样例代码:
# 根据下标(索引)取出数据
t1 = (1, 2, 'hello')
print(t1[2]) # 结果:'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[index]}", 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[0]) # 输出: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()}\"")
- 输出结果:
- 语法:
-
字符串的规整操作(去前后指定字符串)
- 语法:
字符串.strip(字符串)
- 样例代码:
my_str = "12it is HeyStar21" print(f"将字符串\"{my_str}\"进行strip规整后得到:\"{ my_str.strip('12') }\" ")
- 输出结果:
- 注意:
传入的是"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]) 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 = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4:1] # 步长默认为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 = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3::-1]
print(f"结果5:{result5}")
# 对元组进行切片,从头开始,到尾结束,步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6:{result6}")
输出结果:
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)}")
输出结果:
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)
- 输出结果:
- 语法:
-
移除元素
- 语法:
集合.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)
- 输出结果:
- 语法:
-
清空集合
- 语法:
集合.clear()
。清空集合 - 结果:集合本身被清空
- 样例代码:
my_set = {"hello", "world", "HeyStar"} my_set.clear() print(my_set)
- 输出结果:
- 语法:
-
取两个集合的差集
- 语法:
集合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)
- 输出结果:
- 语法:
-
合并两个集合
- 语法:
集合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))
- 输出结果:
- 语法:
-
集合的遍历
由于集合不支持下标索引,所以不能使用while循环- 样例代码:
set1 = {1, 2, 3, 4, 5} for element in set1: print(f"集合的元素有:{element}")
- 输出结果:
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}")
- 结果输出:
2.7.4 字典的常用操作:
操作 | 说明 |
---|---|
字典[Key] |
获取指定Key对应的Value值 |
字典[Key] = value |
添加或更新键值对 |
字典.pop(Key) |
取出Key对应的Value并在字典内删除此Key的键值对 |
字典.clear() |
清空字典 |
字典.keys() |
获取字典的全部Key,可用于for循环遍历字典 |
len(字典) |
计算字典内的元素数量 |
-
新增元素
- 语法:
字典[Key]=Value
- 结果:字典被修改,新增了元素
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } stu_score_dict['Did'] = 88 print(f"{stu_score_dict}")
- 输出结果:
- 语法:
-
更新元素
- 语法:
字典[Key]=Value
- 结果:字典被修改,元素被更新
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } stu_score_dict['Cao'] = 88 print(f"{stu_score_dict}")
- 输出结果:
- 语法:
-
删除元素
- 语法:
字典.pop(Key)
- 结果:获得指定Key的Value,同时字典被修改,指定Key的数据被删除
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } stu_score_dict.pop("Bob") print(f"{stu_score_dict}")
- 输出结果:
- 语法:
-
清空字典
- 语法:
字典.clear()
- 结果:字典被修改,元素被清空
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } stu_score_dict.clear() print(f"{stu_score_dict}")
- 输出结果:
- 语法:
-
获取全部的Key
- 语法:
字典.keys()
- 结果:得到字典中的全部Key
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } keys = stu_score_dict.keys() print(f"{keys}")
- 输出结果:
- 语法:
-
遍历字典
- 样例代码:
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[key]}") # 方式2:直接对字典进行for循环,每次循环都得到key for key in stu_score_dict: print(f"字典2的key是:{key} 对应的Value是:{stu_score_dict[key]}")
- 输出结果:
-
统计字典内的元素数量
- 语法:
len(字典)
- 样例代码:
stu_score_dict = { "Aim": 66, "Bob": 77, "Cao": 99 } 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表示降序,得到一个排好序的列表 |