ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python | 函数、数据容器 [打印本页]
作者: 曹旭辉    时间: 2023-8-9 22:22
标题: 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)
复制代码
语法解析

函数的传入参数

传入参数的数量是不受限制的。
以上代码增加参数：
  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作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。
  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机

代码
  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.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.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函数中使用。
1.13 lambda匿名函数

函数的定义中
定义语法：lambda 传入参数：函数体（一行代码）
样例代码：
  1. def test_func(compute):
  2.     result = compute(1, 2)
  3.     print(result)
  6. test_func(lambda x, y: x + y)  # 结果：3
复制代码
注意事项：

2.数据容器

2.1 Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同：
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 列表的查询功能

  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 列表的修改功能

代码：
  1. my_list = [1, 2, 3]
  3. my_list.insert(1,"HeyStar")
  4. print(my_list)
复制代码
输出结果：

2.2.3.4 列表的追加元素功能

代码：
  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. # 语法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 列表的清空功能

代码：
  1. # 语法
  2. my_list = [1, 2, 3]
  4. my_list.clear()
  5. print(my_list)
复制代码
输出结果：

2.2.3.7 列表的统计元素功能

代码：
  1. # 语法
  2. my_list = [1, 2, 3, 2, 1]
  4. print(my_list.count(1))
复制代码
输出结果

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

代码：
  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 如何遍历列表的元素

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

2.2.4.3 while循环条件的控制

  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 元组的注意事项

2.3.7 元组的特点

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

2.4.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(字符串)统计字符串内某字符串的出现次数
2.4.3 字符串的遍历

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

作为数据容器，字符串有如下特点:
2.5 数据容器(序列)的切片

2.5.1 序列

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

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
本操作，不会影响序列本身，而是会得到一个新的序列
样例代码：
  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(集合)得到一个整数，记录了集合的元素数量
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
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. }
复制代码
2.7.4 字典的常用操作：

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

2.8.1 数据容器的分类

2.8.2 数据容器的特点对比

来源@黑马程序员

2.8.3 数据容器的通用功能

功能描述通用for循环遍历容器（字典是遍历key)max容器内最大元素min()容器内最小元素len()容器元素个数list()转换为列表tuple()转换为元组str()转换为字符串set()转换为集合sorted(序列,[reverse=True])排序，reverse=True表示降序，得到一个排好序的列表
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4