Python | 函数、数据容器

阅读原文时间：2023年08月09日阅读：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 = 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.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))
- 输出结果：