二、Python的五种容器和函数（有C语言基础速成版）

一、函数介绍

函数:是组织好的，可重复使用的，用来实现特定功能的代码段。

好处：

• 将功能封装在函数内，可供随时随地重复利用
• 提高代码的复用性，减少重复代码，提高开发效率

二、函数的定义

• 参数 和 返回值可以 省略
• 函数需要先定义后调用函数
• 形参（函数声明时用的）和实参（传入的参数）
• 函数不管写不写return ，本质都是有返回值的，若不写，则默认返回None
• 函数可以嵌套调用
• 函数中的变量为局部变量

def 函数名 (传入的参数1,传入的参数n):"""函数说明:param x: 形参x说明:param y: 形参y说明:return:  返回值的说明"""函数体return 返回值

注意：

• return后的代码部分不会执行
• 注意加**：**号

三、列表

1. 数据容器介绍

**数据容器：**一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等，并且允许重复元素的存在，可以增删查改等…

数据容器根据特点的不同：

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

2. 列表的定义

列表中的每个数据，都叫元素

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

• 列表支持嵌套，如：

列表的两个元素都是列表

名称名称 = [ [元素1，元素2，元素3],[ 元素1，元素2，元素3] ]

3. 列表可以通过下标索引

索引可以是正向，也可以反向

用法：

name_list = ['1','2','3']
print(name_list[0])   >'1'
print(name_list[1])   >'2'
print(name_list[2])   >'3'print(name_list[-1])   >'3'
print(name_list[-2])   >'2'
print(name_list[-3])   >'1'

对于嵌套了列表的列表：在后面再进行索引就行。name_list[1][2]

• 列表的注意事项：

注意下标索引的范围不要超出元素的最大值（- 1 ）

4. 引入：方法

列表除了可以:

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能插入元素

• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

等等功能，这些功能我们都称之为：列表的方法

在Python中，如果将函数定义为class(类)的成员，那么函数会称之为：方法。如：

1. 定义类，在类中创建方法

class Student:def add(x, y)return x + y

1. 调用类中的方法

studen = Studen() #创建实例
num = studen.add(1, 2)

5. 列表的方法

1. 查找某元素下标：
   • 查找指定元素在列表的下标。如果找不到，报错ValueError!
   • 语法：列表.index(元素)
2. 对某下标的元素重新赋值
   • 语法：列表[] = xxx
3. 插入元素
   • 在指定的下标位置，插入指定的元素，后面的元素往后排
   • 语法：列表.insert(下标, xxx)
4. 追加元素（1）
   • 将指定元素，追加到列表尾部
   • 语法：列表.append(元素)
5. 追加元素（2）
   • 将其他容器的内容取出，依次 追加到列表尾部
   • 语法：列表.extend(其他数据容器)3
6. 删除元素
   • 语法1： 列表.pop(下标)
   • 语法2：del 列表[下标]
7. 删除元素
   • 删除某元素在列表中的第一个匹配项
   • 语法：列表.remove(元素)
8. 清空列表
   • 语法：列表.clear(列表)
9. 统计元素在列表中的数量
   • 语法：列表.count(元素)
10. 统计元素的数量
    • 语法：len(列表)

6. 列表的循环遍历

遍历：把容器内的数据依次取出，并处理。又叫迭代

while循环和for循环，都是循环语句，但细节不同:

在循环控制上:

• while循环可以自定循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上:

• while循环可以通过条件控制做到无限循环
• for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上:

• while循环适用于任何想要循环的场景
• for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

四、元组

1. 介绍

元组和列表的最大不同！ 元组一旦定义完成，就不可修改

2.元组的定义

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

# 定义元组字面量
(元素1，元素2，元素……)
# 定义元组变量
变量名 = (元素1，元素2，元素……)
# 定义空元组
变量名 = ()
变量名 = tuple()    #得到一个元组的类对象

定义的注意事项：

• 定义1个元素的元组必须带有逗号，否则不是元组类型

  #定义3个元素的元组
  t1=(1，'Hello', True)
  #定义1个元素的元组
  t2=('Hello',) 
  

3. 元组的常用操作方法

1. index()
   • 查找某个数据，如果数据存在返回对应的下标，否则报错
   • 语法：元组.index（查找的元素）
   • 返回查找的元素的下标
2. count()
   • 统计某个数据在当前元组出现的次数
   • 语法：元组.count（要统计的元素）
   • 返回这个元素的个数
3. len(元组)
   • 统计元组内的元素个数
   • 语法：len(元组)
   • 返回元素个数

4. 元组的特点

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

五、字符串

1. 介绍

字符串时字符的容器，一个字符串可以存放任意数量的字符

• 和其他容器一样，字符串也是支持下标的
• 字符串不可以 修改 移出 或者追加
• 字符串可以 查找、和替换

2. 字符串的常用操作方法

1. 字符串的替换

   • **语法：**字符串.replace(字符串1，字符串2)
   • 功能：将字符串内的全部:字符串1替换为字符串2
   • 注意：是局部替换，但是要注意，这个返回值是一个新的字符串，不是在老字符串上进行修改

2. 字符串的分割

   • **语法：**字符串.split(分隔符字符串)

   • **功能：**按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

   • 注意：字符串本身不变，而是得到了一个列表对象

   • 示例：

     my_str = "hello world"
     my_str_list = mystr.split(" ")
     print(f"my_str切分后，得到{my_str_list}类型是：{type(my_str_list)}")>my_str切分后，得到['hello', 'world']类型是：<class 'list'>}
     

3. 字符串的规整操作

   1. 去除前后空格

      • 语法：字符串.strip()

      • 示例：

        my_str = "  hello world  "
        print(my_str.strip())>"hello world"
        

   2. 去除前后指定字符串

      • 语法：字符串.strip(字符串)

      • 注意：传入“12”，的意思是，‘’1‘和‘’2’‘都会移出，是按照单个字符

      • 示例：

        my_str = "12hello world21"
        print(my_str.strip(12))>"hello world"
        

4. 统计字符串中某个字符出现的次数

   • 统计某个数据在当前元组出现的次数
   • 语法：字符串.count（要统计的元素）
   • 返回这个元素的个数

5. 统计字符串的长度

   • 统计元组内的元素个数
   • 语法：len(字符串)
   • 返回元素个数

3. 字符串的特点

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

六、数据容器（序列）的切片操作

1. 什么是序列

• 序列是指：内容连续、有序，可使用下标索引的一类数据容器
• 列表、元组、字符串，均可以可以视为序列

2. 序列的常用操作

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

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

切片不会影响序列本身，而是得到一个新的序列 起始和结束的下标也能不写，默认为从头到尾。步长也可以不写，默认为1 范围为 左闭右开 可以这样用my_str[::-1][9:14]

七、集合

1. 集合的介绍：

• 集合 set
• 集合会去重，不能重复
• 集合内容是无序的（所以不支持下标索引访问）

2. 集合的定义

集合 set

# 定义集合字面量
{元素1, 元素2, 元素N}
# 定义集合变量
变量名 = {元素1, 元素2, 元素N}
# 定义空集合
变量名 = set()

3. 集合的一些方法

1. 添加新元素
   • 语法：集合.add(元素)
2. 移出元素
   • 语法：集合.remove(元素)
3. 随机取出一个元素
   • 语法：集合.pop()
   • 注意：真 取出来了，原本的集合没了
4. 清空集合
   • 语法：集合.clear()
5. 取出2个集合的差集
   • 语法：集合1.difference(集合2)
   • 功能：**取出集合1和集合2的差集.，**集合1有 而 集合2没有的
   • 结果：得到一个新集合，集合1和集合2不变
6. 消除2个集合的差集
   • 语法：集合1.difference_update(集合2)
   • 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
   • 结果：集合1被修改，集合2不变
7. 2个集合合并
   • 语法：集合1.unior(集合2)
   • 功能：将集合1和集合2组合成新集合
   • 结果：得到新集合，集合1和集合2不变
8. 统计集合元素的数量
   • 语法：len(集合)
9. 集合的遍历
   • 集合不支持下标索引，所以不支持 while循环
   • 集合支持for循环

4. 集合的特点

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

八、字典

通过字典，可以实现用key 取出 value的操作

1. 字典的定义

字典中存储的元素 叫 ： 键值对

# 定义字典字面量
{key:value, key:value, key:value}
# 定义典变量
变量名 = {元key:value, key:value, key:value}
# 定义空空典
变量名 = {}
变量名 = dict{}# 获取字典的value
value = 字典变量名[key]

• 字典不允许重复，新的会把老的覆盖掉
• 字典不允许下标索引
• 字典的key不允许为字典，value 不受限制，可以嵌套字典

stu_score_dict = {"张三": {"语文": 77,"数学": 66,"英语": 88}"李四": {"语文": 77,"数学": 66,"英语": 88}"王五": {"语文": 77,"数学": 66,"英语": 88}
}score = stu_score_dict[“张三”][“英语”]

2. 字典的常用操作

1. 新增元素
   • 语法：字典[Key] = Value
   • 结果：字典被修改，新增了元素
2. 更新元素
   • 语法：字典[Key] = Value
   • 结果：字典被修改，元素被更新
   • 注意：字典key不可以重复，如果key已经有了，再执行就是更新元素
3. 删除元素
   • 语法：字典.pop(key)
   • 结果：获得指定key的value，同时字典被修改，指定key的数据被删除
4. 清空元素
   • 语法：字典.clear()
5. 获取全部的Key
   • 语法：字典.keys()
6. 统计字典内的元素数量
   • 语法：len(字典)
7. 遍历字典

   • 通过获取全部的key来遍历字典

     # 获取全部的key
     my_dict = {"张三":99,"李四":77,“王五”:88}
     keys = my_dict.keys()
     # 遍历字典
     for key in keys:print(f"字典的key是{key}")print(f"字典的value是{my_dict[key]}")

   • 直接对字典进行for循环，每次循环都是直接得到key

     my_dict = {"张三":99,"李四":77,“王五”:88}
     for key in my_dictprint(f"字典的key是{key}")print(f"字典的value是{my_dict[key]}")
     

3.字典的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过Key获取到Value，Ktv不可重复(重复会覆盖)
• 不支持下标索引
• 可以修改(增加或删除更新元素等)
• 支持for循环，
• 不支持while循环

九、五种容器总结

1. 容器的分类

分类	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key: Value Key: 除字典外任意类型 Value: 任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以 Key 检索 Value 的数据记录场景

• 五类容器都支持for循环
• 集合和字典不支持while循环

2. 容器的通用操作

通用统计功能

1. len(容器)
   • 统计元素个数
2. max(容器)
   • 统计容器的最大元素
3. min(容器)
   • 统计容器的最小元素

通用转换功能

• 注意字典在转换为非字符串的时候，会丢失value

1. list(容器)
   • 将给定容器转换为列表
2. str(容器)
   • 将给定容器转换为字符串
3. tuple(容器)
   • 将给定容器转换为元组
4. set(容器)
   • 将给定容器转换为集合

通用排序功能

1. sorted(容器,[reverse=True])
   • 将给定容器进行排序
   • 注意：会放到列表中，字典在排序的时候会丢失value