2021-09-24——大数据学习日志——Python基础——容器类型（附练习题）

学习目标：

• 能够说出常用 Python 容器类型的名字：列表、元组、字典、字符串、集合
• 掌握容器类型的基本操作：定义和使用、增删改查、遍历等

01_列表

学习目标：

• 知道定义列表的基本格式
• 知道列表的常用操作：增删改查
• 能够使用 for 循环实现对列表中所有元素的遍历

---

1.1 列表的定义

• list（列表） 是 Python 中使用 最频繁 的数据类型
• 专门用于存储 一组数据，存储的每个数据 称为 元素
• 列表用 [] 定义，元素 之间使用 , 分隔
• 列表的 索引(下标) 从 0 开始
  • 索引(下标) 就是元素在 列表 中的位置编号

"""
列表定义的格式：
列表变量的名字 = [元素1, 元素2, ……]

使用格式：
    列表变量[下标]
"""

# 列表定义
name_list = ['mike', 'yoyo', 'rock', 'lily']
#              0       1        2       3
#             -4       -3      -2       -1

# 最后一个元素取出来
print(name_list[3])
print(name_list[-1])

# 访问列表元素，不要超出范围，不要越界
# IndexError: list index out of range
# print(name_list[4])

• 注意：从列表中取值时，如果 超出索引(下标)范围，程序会报错

1.2 列表嵌套

• 一个列表中的元素又是列表，那么这就是列表的嵌套

school_list = [['北京大学', '清华大学'], ['中山大学', '华南理工大学'], ['哈工大', '哈工程']]
#                  0                      1                         2

# 取出第 2 个元素，也就是下标为 1 的元素
print(school_list[1])  # ['中山大学', '华南理工大学']

# 先取出下标为 1 的元素，再继续取下标为 1 的元素
# ['中山大学', '华南理工大学']
#   0            1
print(school_list[1][1])  # '华南理工大学'

1.3 列表常用操作

分类	关键字 / 函数 / 方法	说明	举例
增加	列表.append(值)	在末尾追加数据	list1 = [13, 5] # 在列表结尾追加8 list1.append(8) print(list1) # [13, 5, 8]
删除	列表.remove(值)	删除第一个出现的指定数据	list1 = [13, 5, 8, 5] # 删除第一个匹配到的5 list1.remove(5) print(list1) # [13, 8, 5]
修改	列表[索引] = 值	修改指定索引的数据，数据不存在会报错	list1 = [13, 5] # 修改 索引1 对应的值 list1[1] = 2 print(list1) # [13, 2] list1[10] = 3 # 索引不存在,程序报错
查询	列表[索引]	根据索引取值，索引不存在会报错	list1 = [13, 5, 8] # 获取索引1 对应的值 print(list1[1]) # 5 print(list1[10]) # 索引不存在,程序报错
	len(列表)	列表长度(元素个数)	list1 = [13, 5, 8] # 获取列表中元素的个数 length = len(list1) print(length) # 3
	值 in 列表	判断列表中是否包含某个值，结果是 True 或 False	list1 = [13, 5, 8] # 判断列表中是否包含数据5 if 5 in list1: # 包含数据,返回True; 不包含,返回False print("列表中包含该数据") else: print("列表中不包含该数据") # 输出: 列表中包含该数据
排序	列表.sort()	升序排序	list1 = [13, 5, 8] # 升序排列 list1.sort() print(list1) # [5, 8, 13] # 降序排列 list1.sort(reverse=True) print(list1) # [13, 8, 5]

1.4 循环遍历

1.4.1 通过for循环遍历

• 遍历 就是 从头到尾 依次 从 列表 中取出 每一个元素
• Python中专门提供 for循环 实现遍历

# 遍历，从头开始找，直到结束
name_list = ['mike', 'yoyo', 'rock', 'lily']

# 通过while实现遍历
# 1. 定义条件变量i = 0
i = 0

# 2. while i < 列表元素个数:
while i < len(name_list):
    # 3. 取出某个元素，打印
    name = name_list[i]
    print(name)

    # 4. 条件变量的修改
    i += 1

print('==========华丽分割线=============')

# for遍历循环，和上面的while效果等价
# 从头到尾 依次从 列表 中取出 每一个元素
for name in name_list:
    print(name)

1.4.2 if…in 和 for…in 的区别

• if…in：判断某个元素是否在列表中，如果在，if的条件为True
• for…in：从头到尾 依次从 列表 中取出 每一个元素

name_list = ['mike', 'yoyo', 'rock', 'lily']

# if…in：判断某个元素是否在列表中，如果在，if的条件为True
name = 'yoyo'

# name的内容'yoyo'是否在name_list列表中，如果在，name in name_list结果为True
if name in name_list:
    print('%s 在列表中' % name)

print('==========华丽分割线=============')

# for…in：从头到尾 依次从 列表 中取出 每一个元素，这个元素给name赋值
for name in name_list:
    print(name)

运行结果：

yoyo 在列表中
==========华丽分割线=============
mike
yoyo
rock
lily

1.4.3 for…else的使用

• for循环里面没有遇到break语句，for执行完后，则会执行else的分支

name_list = ['mike', 'yoyo', 'rock', 'lily']

for name in name_list:
    print(name)

    # 测试有break，和没有break的else执行情况
    # if name == 'yoyo':
    #     break
else:
    print('for循环里面没有遇到break语句，for执行完后，则会执行else的分支')

运行结果：

mike
yoyo
rock
lily
for循环里面没有遇到break语句，for执行完后，则会执行else的分支

02_元组

学习目标：

• 知道定义元组的基本格式
• 知道元组和列表的区别

---

2.1 元组的定义

• 元组用 () 定义
• 也用于存储 一组 数据，元素 之间使用 , 分隔
• 元组的 索引(下标) 从 0 开始

# 列表：列表变量 = [元素1, 元素2, ……]
# 元组：元组变量 = (元素1, 元素2, ……)
my_tuple = ('mike', 'yoyo', 'lily')
#             0       1        2

# 取出第0个元素
print(my_tuple[0])  # 输出：'mike'

• 元组中 只包含一个元素 时，需要 在元素后面添加逗号

# 元组只有一个元素的时候，格式: (元素,)
my_tuple1 = (250,)
# 打印my_tuple1的类型
print(type(my_tuple1))

2.2 元组常用操作

• tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

my_tuple = ('mike', 'yoyo', 'lily')
# 元组只读不能改
# TypeError: 'tuple' object does not support item assignment
# my_tuple[0] = 'rock' # err

分类	关键字 / 函数 / 方法	说明	举例
查询	元组[索引]	根据索引取值，索引不存在会报错	tuple1 = (13, 5, 8) # 获取索引1 对应的值 print(tuple1[1]) # 5 print(tuple1[10]) # 索引不存在,程序报错
	len(元组)	元组长度(元素个数)	tuple1 = (13, 5, 8) # 获取元组中元素的个数 length = len(tuple1) print(length) # 3
	值 in 元组	判断元组中是否包含某个值	tuple1 = (13, 5, 8) # 判断元组中是否包含数据5 if 5 in tuple1: # 包含数据,返回True; 不包含,返回False print("元组中包含该数据") else: print("元组中不包含该数据") # 输出: 元组中包含该数据

03_字典

学习目标：

• 知道定义字典的基本格式
• 知道字典的常用操作：增删改查
• 能够通过for循环完成对字典的遍历

---

3.1 字典的定义

• 字典同样可以用来 存储多个数据
  • 通常用于存储 描述一个 物体 的相关信息
• 字典用 {} 定义
• 字典使用 键值对 存储数据，键值对之间使用 , 分隔
  • 键 key 是索引，值 value 是数据
  • 键 和 值 之间使用 : 分隔
  • 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
  • 键必须是唯一的

 

"""
字典定义格式：
    字典变量 = {k1:v1, k2:v2,……}

取出元素的值：
    字典变量[键值]
"""
# 字典的定义
info = {'name': 'mike', 'age': 34, 'city': 'sz'}
print(info)  # {'name': 'mike', 'age': 34, 'city': 'sz'}

# 取出元素的值：字典变量[键值]
print(info['city'])

3.2 字典常用操作

分类	关键字 / 函数 / 方法	说明	举例
增加	字典[键] = 值	键不存在，会添加键值对	dict1 = {"name": "张三"} # 给字典添加键值对 dict1["age"] = 20 print(dict1) # {"name": "张三", "age": 20}
删除	字典.pop(键)	删除指定键值对,返回被删除的值,如果键不存在,会报错	dict1 = {"name": "张三", "age": 20} # 删除键值对 value = dict1.pop("age") print(dict1) # {"name": "张三"} print(value) # 20 # 键不存在, 会报错 dict1.pop("height")
修改	字典[键] = 值	键存在，会修改键值对的值	dict1 = {"name": "张三"} # 给字典添加键值对 dict1["name"] = "李四" print(dict1) # {"name": "李四"}
查询	字典[键]	根据键取值，键值对不存在会报错	list1 = [13, 5] dict1 = {"name": "张三"} # 获取键值对的值 print(dict1["name"]) # "张三" # 键不存在, 会报错 print(dict1["height"])
	字典.get(键)	根据键取值，键值对不存在返回None, 不会报错	dict1 = {"name": "张三"} # 获取键值对的值 print(dict1["name"]) # "张三" # 键不存在, 返回None print(dict1.get('height')) # None
遍历	for key, value in 字典.items()	遍历字典, 获取所有的键值对 (键, 值)	dict1 = {"name": "张三", "age": 20} # 遍历字典所有的键值对 for key, value in dict1.items(): print(key, value) # 输出: # "name", "张三" # "age", 20

3.3 案例：登录注册系统

• 在开发中，字典的应用场景是：

  • 使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息

  • 将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

    用户1: {'name': 'mike', 'pwd': '123456'}
    用户2: {'name': 'yoyo', 'pwd': '123456'}
    
    用户管理列表：
    user_list = [{'name': 'mike', 'pwd': '123456'}, {'name': 'yoyo', 'pwd': '123456'}]
    

• 登录注册系统需求：完成用户注册、用户登录功能

"""
登录注册系统需求：1.用户注册/ 2.用户登录/ 3.退出程序

0. 定义一个列表，用于存储用户字典

1. 死循环 while True:
    2. 输入数字指令
    3. 判断指令，选择分支
    4. 用户注册功能
        4.1 输入注册的用户名
        4.2 通过for遍历列表，取出的每个元素是字典
            4.3 字典['name']和输入注册的用户名比较是否相等
                4.4 如果相等，打印提示：名字在列表中，不允许注册
                4.5 跳出循环
        4.6 for循环的else，循环里面没有执行到break，则会执行else
            4.7 输入注册的密码
            4.8 创建一个字典
            4.9 字典追加到列表中
            4.10 打印：注册成功
    5. 用户登陆功能
        5.1 输入登陆的用户名和密码
        5.2 通过for遍历列表，取出的每个元素是字典
            5.3 字典['name']和登陆用户名比较 and 字典['pwd']和登陆密码比较
                5.4 如果都相等，打印提示：登陆成功
                5.5 跳出循环
        5.6 for循环的else，循环里面没有执行到break，则会执行else
            5.7 打印：用户名或密码错误，请重新登陆
"""
# 0. 定义一个列表，用于存储用户字典
user_list = [{'name': 'mike', 'pwd': '123456'}, {'name': 'yoyo', 'pwd': '123456'}]

# 1. 死循环 while True:
while True:
    #  2. 输入数字指令
    cmd_num = input('请输入操作: 1.用户注册/ 2.用户登录/ 3.退出程序')

    # 3. 判断指令，选择分支
    # 4. 用户注册功能
    if cmd_num == '1':
        # print('用户注册')
        # 4.1 输入注册的用户名
        reg_name = input('请输入注册的名字：')
        # 4.2 通过for遍历列表，取出的每个元素是字典
        for user_dict in user_list:
            # 4.3 字典['name']和输入注册的用户名比较是否相等
            if user_dict['name'] == reg_name:
                # 4.4 如果相等，打印提示：名字在列表中，不允许注册
                print(reg_name, '名字在列表中，不允许注册')
                # 4.5 跳出循环
                break
        # 4.6 for循环的else，循环里面没有执行到break，则会执行else
        else:
            # 4.7 输入注册的密码
            reg_pwd = input('请输入注册的密码：')
            # 4.8 创建一个字典
            user_dict = {'name': reg_name, 'pwd': reg_pwd}
            # 4.9 字典追加到列表中
            user_list.append(user_dict)
            # 4.10 打印：注册成功
            print('注册成功')
    # 5. 用户登陆功能
    elif cmd_num == '2':
        # print('用户登录')
        # 5.1 输入登陆的用户名和密码
        login_name = input('请输入登录用户名:')
        login_pwd = input('请输入登录密码:')
        # 5.2 通过for遍历列表，取出的每个元素是字典
        for user_dict in user_list:
            # 5.3 字典['name']和登陆用户名比较 and 字典['pwd']和登陆密码比较
            if user_dict['name'] == login_name and user_dict['pwd'] == login_pwd:
                # 5.4 如果都相等，打印提示：登陆成功
                print('登陆成功')
                # 5.5 跳出循环
                break
        # 5.6 for循环的else，循环里面没有执行到break，则会执行else
        else:
            # 5.7 打印：用户名或密码错误，请重新登陆
            print('用户名或密码错误，请重新登陆')
    elif cmd_num == '3':
        print('退出程序')
        break
    else:
        print("输入错误，重新输入")

04_字符串

学习目标：

• 能够使用两个单引号、双引号、三引号定义字符串
• 知道字符串的常用操作：查找、替换等
• 能够使用切片语法获取字符串指定区间内的子串

---

4.1 字符串的定义

• 字符串 就是 一串字符，是编程语言中用来存储文本的数据类型

• 在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串 或者 一对三引号 ''' 定义一个字符串

• 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始

• 也可以使用 for 循环遍历 字符串中每一个字符

"""
字符串变量 = '字符串内容'
说明：可以是单引号、双引号、三引号

"""
my_str = 'python'
#         012345

# 取某个元素，和列表一样
print(my_str[0])

# 遍历取所有元素
for c in my_str:
    print(c)

4.2 f-strings 字符串格式化

• f-strings是Python 3.6之后的一种新的字符串格式化方法，要使用f-strings，只需在字符串前加上f、或F：

name = 'mike'
age = 34
sex = 'male'

# 传统方式格式化
print('我叫%s, 年龄为%d, 性别为：%s' % (name, age, sex))

# 和上面打印效果一样
print(f'我叫{name}, 年龄为{age}, 性别为：{sex}')
print(F'我叫{name}, 年龄为{age}, 性别为：{sex}')

4.3 字符串的常用操作 

分类	关键字 / 函数 / 方法	说明	举例
查找	字符串.find(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1	str1 = "hello python" # 查找"py"对应的索引(能找到的话, 返回"p"对应的索引) index = str1.find("py") print(index) # 6 # 查找"88"对应的索引, 不存在, 返回-1 index = str1.find("88") print(index) # -1
替换	字符串.replace(原内容, 新内容, 替换次数)	返回一个替换了原内容的新字符串，可以指定替换次数	str1 = "hello python" # 对内容进行替换, 返回新字符串 new_str = str1.replace("py", "Py") print(new_str) # hello Python
分割	字符串.split(分割符)	以分割符拆分字符串, 返回列表	str1 = "hello python hello world" # 以空格分割字符串,每段一个元素,返回列表 str_list = str1.split(" ") print(str_list) # ["hello", "python", "hello", "world"]
拼接	字符串 + 字符串	拼接两个字符串	str1 = "hello" str2 = "python" # 拼接字符串 str3 = str1 + str2 print(str3) # "hellopython"
	字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串	str1 = "," name_list = ["beijing", "shenzhen", "shanghai", "guangzhou"] # 以字符串为连接符拼接字符串列表的元素,生成新的字符串 str2 = str1.join(name_list) print(str2) # "beijing,shenzhen,shanghai,guangzhou"

4.4 字符串的切片

4.4.1 切片介绍

• 切片 译自英文单词 slice，翻译成另一个解释更好理解: 一部分

• 切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列

• 切片 方法适用于 字符串、列表、元组

  字符串[开始索引:结束索引:步长]

注意：

1. 指定的区间属于 左闭右开 型 [开始索引, 结束索引) 对应 开始索引 <= 范围 < 结束索引
   • 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引 数字和冒号都可以省略
4. 步长：理解为走的步数，正数说明是从左往右，负数是从右往左，默认步长为+1
   • 步长默认为 1，如果元素连续，数字和冒号都可以省略

4.4.2 案例

演练需求

• 截取从 2 ~ 5 位置 的字符串
• 截取从 2 ~ 末尾 的字符串
• 截取从 开始 ~ 5 位置 的字符串
• 从开始位置，每隔一个字符截取字符串
• 截取字符串末尾两个字符
• 字符串的逆序（面试题）

示例代码：

"""
字符串[开始索引:结束索引:步长]
0. 步长默认为1，步长理解为走几步，正数从左往右，负数从右往左
1. 字符串[开始索引:结束索引]   开始索引 ~（结束索引-1）
2. 字符串[开始索引: ]       开始索引 ~ 结束索引，末尾索引不写，默认能取到末尾那个索引
3. 字符串[ :结束索引]       0 ~（结束索引-1），开始索引不写，默认从第0个元素开始
"""
temp_str = '12345678'
#           01234567
#                -2-1

# 站在用户角度，第1个元素才开始算第1个位置
# 截取从 2 ~ 5 位置 的字符串
print(temp_str[1:5])

# 截取从 2 ~ 末尾 的字符串
print(temp_str[1:]) # 没有指定结尾索引，默认取到末尾

# 截取从 开始 ~ 5 位置 的字符串
print(temp_str[:5]) # 没有指定开头索引，默认从0开始

# 从开始位置，每隔一个字符截取字符串，也就是说走2步
print(temp_str[::2]) # 没有指定开头、结尾索引，默认从头到尾

# 截取字符串末尾两个字符
print(temp_str[-2:])  # 没有指定结尾索引，默认取到末尾

# 字符串的逆序（面试题）
print(temp_str[::-1])

05_集合

学习目标：

• 能够通过集合完成对列表中元素的去重功能
• 知道list、tuple、set之间可以进行类型转换

---

5.1 通过集合完成对列表去重功能

• 集合用 {} 定义，元素 之间使用 , 分隔
• 可通过集合对列表中的元素完成去重功能

# 集合：元素不会重复，{元素1，元素2……}
# 定义集合
my_set = {1, 2, 1, 2, 1, 2}
print(my_set)  # {1, 2}
print(type(my_set))  # 

# 通过集合完成对列表去重功能
name_list = ['mike', 'yoyo', 'mike']
# set(name_list)：给列表转换为set类型，即可完成去重功能
temp_set = set(name_list)
print(temp_set)  # {'mike', 'yoyo'}

5.2 list、tuple、set之间类型转换

函数	说明
list(x)	将 x 转换为列表类型
tuple(x)	将 x 转换为元组类型
set(x)	将 x 转换为集合类型

示例代码：

# 列表转元组、集合 类型
my_list = [1, 2, 3, 5, 3, 5]

# 列表转换为元组类型
my_tuple = tuple(my_list)
print(my_tuple)  # (1, 2, 3, 5, 3, 5)

# 列表转换为集合类型
my_set = set(my_list)
print(my_set)   # {1, 2, 3, 5}

print('============华丽分割线============')

# 元组转列表、集合 类型
my_tuple = (1, 2, 3, 5, 3, 5)

# 元组转换为列表 类型
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3, 5, 3, 5]

# 元组转换为集合 类型
my_set = set(my_tuple)
print(my_set)   # {1, 2, 3, 5}

print('============华丽分割线============')

# 集合转元组、列表 类型
my_set = {1, 2, 3}

# 集合转换为列表 类型
my_list = list(my_set)
print(my_list)  # [1, 2, 3]

# 集合转换为元组 类型
my_tuple = tuple(my_set)
print(my_tuple)  # (1, 2, 3)

06_公共语法

学习目标：

• 知道公共语法为大部分容器类型的通用方法

---

6.1 Python 内置函数

Python 包含了以下内置函数：

函数	描述	备注
len(item)	计算容器中元素个数
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较

6.2 切片

描述	Python 表达式	结果	支持的数据类型
切片	[1, 2, 3, 4][::2]	[1, 3]	字符串、列表、元组

6.3 运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[1, 2] * 2	[1, 2, 1, 2]	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 6) < (1, 3, 4)	True	元素比较	字符串、列表、元组

注意

• in 在对 字典 操作时，判断的是 字典的键
• in 和 not in 被称为 成员运算符

07_容器常用方法汇总

学习目标：

• 了解容器常用方法，现用现查，当做手册用

---

7.1 列表操作

分类	关键字 / 函数 / 方法	说明	举例
增加	列表.append(值)	在末尾追加值	list1 = [13, 5] # 在列表结尾追加8 list1.append(8) print(list1) # [13, 5, 8]
	列表.insert(索引, 值)	在指定位置插入值, 超过索引会追加值	list1 = [13, 5, 8] # 在 索引1的位置 插入数据20 list1.insert(1, 20) print(list1) # [13, 20, 5, 8] # 在 索引10的位置 插入数据4(没有索引10, 追加4) list1.insert(10, 4) print(list1) # [13, 20, 5, 8, 4]
	列表.extend(可迭代对象)	将可迭代对象 中 的元素 追加到列表	list1 = [13, 5, 8] list2 = [20, 21] # 将list2中的元素追加到list1中 list1.extend(list2) print(list1) # [13, 5, 8, 20, 21]
删除	列表.remove(值)	删除指定值的 第一个匹配项	list1 = [13, 5, 8, 5] # 删除第一个匹配到的5 list1.remove(5) print(list1) # [13, 8, 5]
	del 列表[索引]	删除指定位置的值	list1 = [13, 5, 8] # 删除 索引1 对应的值 del list1[1] print(list1) # [13, 8]
	列表.pop(索引)	删除指定索引的值, 并返回被删除的值	list1 = [13, 5, 8] # 删除 索引1 对应的值, 并返回被删除的值 ret = list1.pop(1) print(list1) # [13, 8] print(ret) # 5
	列表.clear()	清空列表	list1 = [11, 2, 8] # 清空list1中值 list1.clear() print(list1) # []
修改	列表[索引] = 值	修改指定索引的值，索引不存在会报错	list1 = [13, 5] # 修改 索引1 对应的值 list1[1] = 2 print(list1) # [13, 2] list1[10] = 3 # 索引不存在,程序报错
查询	列表[索引]	根据索引取值，索引不存在会报错	list1 = [13, 5, 8] # 获取索引1 对应的值 print(list1[1]) # 5 print(list1[10]) # 索引不存在,程序报错
	len(列表)	列表长度(元素个数)	list1 = [13, 5, 8] # 获取列表中元素的个数 length = len(list1) print(length) # 3
	if 值 in 列表:	判断列表中是否包含某个值	list1 = [13, 5, 8] # 判断列表中是否包含数据5 if 5 in list1: # 包含数据,返回True; 不包含,返回False print("列表中包含该数据") else: print("列表中不包含该数据") # 输出: 列表中包含该数据
	列表.index(值)	根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错	list1 = [13, 5, 8, 5] # 获取第一个5对应的索引 index = list1.index(5) print(index) # 1 index = list1.index(20) # 没有20对应的索引, 程序报错
	列表.count(值)	值在列表中出现的次数	list1 = [13, 5, 8, 13] # 获取列表中 13 出现的次数 count = list1.count(13) print(count) # 2
排序	列表.sort()	排序	list1 = [13, 5, 8] # 升序排列 list1.sort() print(list1) # [5, 8, 13] # 降序排列 list1.sort(reverse=True) print(list1) # [13, 8, 5]
	列表.reverse()	逆序、反转	list1 = [13, 5, 8] # 将列表中的数据反转排列 list1.reverse() print(list1) # [8, 5, 13]

7.2 元祖操作

分类	关键字 / 函数 / 方法	说明	举例
查询	元组[索引]	根据索引取值，索引不存在会报错	tuple1 = (13, 5, 8) # 获取索引1 对应的值 print(tuple1[1]) # 5 print(tuple1[10]) # 索引不存在,程序报错
	len(元组)	元组长度(元素个数)	tuple1 = (13, 5, 8) # 获取元组中元素的个数 length = len(tuple1) print(length) # 3
	if 值 in 元组:	判断元组中是否包含某个值	tuple1 = (13, 5, 8) # 判断元组中是否包含数据5 if 5 in tuple1: # 包含数据,返回True; 不包含,返回False print("元组中包含该数据") else: print("元组中不包含该数据") # 输出: 元组中包含该数据
	元组.index(值)	根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错	tuple1 = (13, 5, 8, 5) # 获取第一个5对应的索引 index = tuple1.index(5) print(index) # 1 index = tuple1.index(20) # 没有20对应的索引, 程序报错
	元组.count(值)	值在元组中出现的次数	tuple1 = (13, 5, 8, 13) # 获取元组中 13 出现的次数 count = tuple1.count(13) print(count) # 2

7.3 字典操作

分类	关键字 / 函数 / 方法	说明	举例
增加	字典[键] = 值	键不存在，会添加键值对	dict1 = {"name": "张三"} # 给字典添加键值对 dict1["age"] = 20 print(dict1) # {"name": "张三", "age": 20}
删除	字典.pop(键)	根据键删除键值对,返回被删除的值	dict1 = {"name": "张三", "age": 20} # 删除键值对 value = dict1.pop("age") print(dict1) # {"name": "张三"} print(value) # 20 # 键不存在, 会报错 dict1.pop("height")
	del 字典[键]	根据键删除键值对	dict1 = {"name": "张三", "age": 20} # 删除键值对 del dict1["age"] print(dict1) # {"name": "张三"} # 键不存在, 会报错 del dict1["height"]
	字典.clear()	清空字典	dict1 = {"name": "张三", "age": 20} # 清空键值对 dict1.clear() print(dict1) # {}
修改	字典[键] = 值	键存在，会修改键值对的值	dict1 = {"name": "张三"} # 给字典添加键值对 dict1["name"] = "李四" print(dict1) # {"name": "李四"}
	字典.update(字典2)	取出字典2的键值对对字典1操作，键值对不存在，添加键值对；存在则修改值	dict1 = {"name": "张三", "age": 20} # 更新键值对 dict1.update({"age": 22, "height": 1.8}) print(dict1) # {"name": "张三", "age": 22, "height": 1.8}
	字典.setdefault(键，数据)	键值对不存在，添加键值对；存在则不做处理	dict1 = {"name": "张三", "age": 20} # 键不存在, 添加键值对 dict1.setdefault("height", 1.8) print(dict1) # {"name": "张三", "age": 20, "height": 1.8} # 键存在, 不做处理 dict1.setdefault("age", 22) print(dict1) # {"name": "张三", "age": 20, "height": 1.8}
查询	字典[键]	根据键取值，键值对不存在会报错	list1 = [13, 5] dict1 = {"name": "张三"} # 获取键值对的值 print(dict1["name"]) # "张三" # 键不存在, 会报错 print(dict1["height"])
	字典.get(键)	根据键取值，键值对不存在返回None, 不会报错	dict1 = {"name": "张三"} # 获取键值对的值 print(dict1["name"]) # "张三" # 键不存在, 返回None print(dict1.get('height')) # None
	for key in 字典	遍历字典, 获取所有的键	dict1 = {"name": "张三", "age": 20} # 遍历字典 for key in dict1: print(key) # 输出: name age
	for key in 字典.keys()	遍历字典, 获取所有的键	dict1 = {"name": "张三", "age": 20} # 遍历字典 for key in dict1.keys(): print(key) # 输出: name age
	for value in 字典.values()	遍历字典, 获取所有的值	dict1 = {"name": "张三", "age": 20} # 遍历字典所有的值 for value in dict1.values(): print(value) # 输出: "张三" 20
	for item in 字典.items()	遍历字典, 获取所有的键值对 (键, 值)	dict1 = {"name": "张三", "age": 20} # 遍历字典所有的键值对 for key, value in dict1.items(): print(key, value) # 输出: # "name", "张三" # "age", 20

7.4 字符串操作

分类	关键字 / 函数 / 方法	说明	举例
分割	字符串.split(分割符)	以分割符拆分字符串, 返回列表	str1 = "hello python hello world" # 以空格分割字符串,每段一个元素,返回列表 str_list = str1.split(" ") print(str_list) # ["hello", "python", "hello", "world"]
	字符串.partition(分割符)	返回元组，把字符串分成一个 3 元素的元组 (分割符前面, 分割符, 分割符后面)	str1 = "[email protected]" # 以@分割字符串,分成三段式 str_tuple = str1.partition("@") print(str_tuple) # ("zhangsan", "@", "163.com")
拼接	字符串 + 字符串	拼接两个字符串	str1 = "hello" str2 = "python" # 拼接字符串 str3 = str1 + str2 print(str3) # "hellopython"
	字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串	str1 = "," name_list = ["beijing", "shenzhen", "shanghai", "guangzhou"] # 以字符串为连接符拼接字符串列表的元素,生成新的字符串 str2 = str1.join(name_list) print(str2) # "beijing,shenzhen,shanghai,guangzhou"
替换	字符串.replace(原内容, 新内容, 替换次数)	返回一个替换了原内容的新字符串，可以指定替换次数	str1 = "hello python" # 对内容进行替换, 返回新字符串 new_str = str1.replace("py", "Py") print(new_str) # hello Python
查询	字符串.find(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1	str1 = "hello python" # 查找"py"对应的索引(能找到的话, 返回"p"对应的索引) index = str1.find("py") print(index) # 6 # 查找"88"对应的索引, 不存在, 返回-1 index = str1.find("88") print(index) # -1
	字符串.rfind(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1, 从结尾处开始查找	str1 = "hello python" # 查找"o"对应的索引(能找到的话, 返回"o"对应的索引, 从结尾处开始查找) index = str1.rfind("o") print(index) # 10 # 查找"88"对应的索引, 不存在, 返回-1 index = str1.rfind("88") print(index) # -1
	字符串.index(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在会报错	str1 = "hello python" # 查找"py"对应的索引(能找到的话, 返回"p"对应的索引) index = str1.index("py") print(index) # 6 # 查找"88"对应的索引, 不存在, 会报错 index = str1.index("88") print(index) # 报错
判断	字符串.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True	str1 = "hello python" # 判断字符串是否都为字母 if str1.isalpha(): print("都是字母") # 输出 else: print("不都是字母")
	字符串.isdecimal()	如果 string 只包含数字则返回 True	str1 = "666" # 判断字符串是否都是数字 if str1.isdecimal(): print("都是数字") # 输出 else: print("不都是数字")
	字符串.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True	str1 = "hello" # 判断字符串中的字母是否都是小写 if str1.islower(): print("字母都是小写") # 输出 else: print("字母不都是小写")
	字符串.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True	str1 = "HELLO" # 判断字符串中的字母是否都是大写 if str1.isupper(): print("字母都是大写") # 输出 else: print("字母不都是大写")
	字符串.startswith(目标字符串)	检查字符串是否是以 目标字符串 开头，是则返回 True	str1 = "hello" # 判断字符串是否以目标字符串开头 if str1.startswith("he"): print("以he开头") # 输出 else: print("不以he开头")
	字符串.endswith(目标字符串)	检查字符串是否是以 目标字符串 结尾，是则返回 True	str1 = "hello" # 判断字符串是否以目标字符串结尾 if str1.endswith("lo"): print("以lo结尾") # 输出 else: print("不以lo结尾")
大小写转换	字符串.lower()	返回新字符串，转换 字符串 中所有大写字符为小写	str1 = "HELLO" # 转换大写字母为小写 str2 = str1.lower() print(str2) # hello
	字符串.upper()	返回新字符串，转换 字符串 中所有大写字符为大写	str1 = "hello" # 转换小写字母为大写 str2 = str1.upper() print(str2) # HELLO
文本对齐	字符串.center()	按照指定宽度返回新字符串，并基于原字符串居中，可设置两端空白位置的填充字符	str1 = "hello" # 设置居中 str2 = str1.center(11, "-") print(str2) # ---hello---
	字符串.ljust()	按照指定宽度返回新字符串，并基于原字符串左对齐，可设置两端空白位置的填充字符	str1 = "hello" # 设置左对齐 str2 = str1.ljust(11, "-") print(str2) # hello------
	字符串.rjust()	按照指定宽度返回新字符串，并基于原字符串右对齐，可设置两端空白位置的填充字符	str1 = "hello" # 设置右对齐 str2 = str1.rjust(11, "-") print(str2) # ------hello
去除两端字符	字符串.strip(目标字符串)	返回新字符串，去除 字符串 左右两边的目标字符串, 不设置目标字符串则去除空格	str1 = "--hello---" # 去除两端目标字符串 str2 = str1.strip("-") print(str2) # hello
	字符串.lstrip(目标字符串)	返回新字符串，去除 字符串 左边的目标字符串, 不设置目标字符串则去除空格	str1 = "--hello---" # 去除左边目标字符串 str2 = str1.lstrip("-") print(str2) # hello---
	字符串.rstrip(目标字符串)	返回新字符串，去除 字符串 右边的目标字符串, 不设置目标字符串则去除空格	str1 = "--hello---" # 去除右边目标字符串 str2 = str1.rstrip("-") print(str2) # --hello

容器类型——附练习题

能力目标：

• 能够说出定义列表的基本格式
• 能够使用for循环实现对列表中所有元素的遍历
• 知道in/not in能够判断列表中是否存在某个元素
• 能够说出定义元组的基本格式
• 能够说出定义字典的基本格式
• 能够通过键对字典进行添加/修改元素操作
• 能够使用两个单引号、双引号、三引号定义字符串
• 知道replace方法能够实现替换指定子串

关卡一：基础题

1. 写出 for 循环遍历列表的完整格式，并简单描述 for 循环的执行过程

答案

格式如下:
    for 临时变量 in 列表变量
        循环执行的代码
执行过程:
首先从被遍历的数据里取出一个元素，并赋值给临时变量
在循环里可以直接使用临时变量的值
当循环里的代码执行结束，会再次回到 for 循环起始的位置，取出一个元素赋值给临时变量，并开始循环
直到循环已经无法再次取出元素，才会结束循环，然后开始执行循环后的代码

2. 简述你对列表的理解（存什么样的数据？什么是元素？列表如何定义？什么是索引？）

答案

list(列表) 是python中使用最频繁的数据类型
专门用于存储一串数据,存储的数据称为元素
列表用[]定义,元素之间用 , 分隔
列表的索引从 0 开始
索引就是元素在列表中的位置编号

3. 简述你对元组的理解（存什么样的数据？与列表的区别是什么？）

答案

元组用 () 定义
用于存储一串数据,元素之间使用,分隔
元组的 索引 从 0 开始
Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

4. 简述你对字典的理解（存什么样的数据？字典如何定义？）

答案

字典同样可以用来 存储多个数据
通常用于存储 描述一个 物体 的相关信息
字典用 {} 定义
字典使用 键值对 存储数据，键值对之间使用 , 分隔
  键 key 是索引
  值 value 是数据
  键 和 值 之间使用 : 分隔
  值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
  键必须是唯一的

5. 解释什么是索引越界

答案

索引越界是指列表的下标超过了该列表的下标的最大值

6. 简述你对字符串的理解（存储什么样的数据？字符串如何定义？如何获取指定位置的字符？）

答案

字符串 就是 一串字符，是编程语言中表示文本的数据类型
在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串 或者 一对三引号 ''' 定义一个字符串
可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历 字符串中每一个字符

关卡二：综合题

1. 设计一个程序

有一个列表 a = [11, 22, 33]

• 获取列表的元素 22

• 向列表中添加（增）新元素 44

• 删除（删）列表中的元素 33

• 修改（改）列表中的元素 22 为 55

• 查找（查）列表中的元素 55 的下标

提示: 增加和删除, 可以使用多种方式实现, 具体可以参考课件的其他语法

答案

ret = (a[1])
a.append(44)
a.remove(33)
a[1] = 55
index = a.index(55)

2. 设计一个程序

按下述步骤实现代码:

• 创建一个空字典{}，变量名为 info

• 向字典 info 中添加新的键值对，保存如下信息：姓名是张三

• 获取字典中元素 name 的值

• 修改字典中的元素 'name' 的值为 '李四'

• 存在字典 info = {'name':'李四'}, 删除元素 name

答案

info = {}
info['name'] = '张三'
ret = (info['name'])
info['name'] = '李四'
info.pop('name')

3. 设计一个程序:

• 要求用户输入一个字符串，遍历当前字符串并打印，如果遇见“q”,则跳出循环。如果遇见“ ”（空格）则跳过当前输出。

• 提示：for循环可以遍历字符串

答案

input_str = input("请输入一个字符串：")
for i in input_str:
    if i == "q":
        break
    elif i == " ":
        continue
    print(i)

4. 设计一个程序

已知变量如下：

 a = "itheima"

• 从键盘上输入一个字母，判断此字母 是否在变量 a 中，如果在则输出 找到了， 如果不在 则输出 查无此字母

答案

a = 'itheima'
b = input('请从键盘上输入一个字母:')
for i in a:
    if i == b:
        print('找到了')
        break
else:
    print('查无此字母')

5. 设计一个程序

现有字典dict1 = {'name':'chuanzhi','age':18} 要求：

• 1.使用循环将字典中所有的键输出到屏幕上

• 2.使用循环将字典中所有的值输出到屏幕上

• 3.使用循环将字典中所有的键值对输出到屏幕上 输出方式： name：chuanzhi age:18

答案

dict1 = {'name':'chuanzhi','age':18}
for key in dict1.keys():
    print(key)
for value in dict1.values():
    print(value)
for key, value in dict1.items():
    print(key, value)

关卡三：扩展题

1. 设计一个程序

有这样的一个列表

product_list = [
    {"name": "电脑", "price": 7000},
    {"name": "鼠标", "price": 30},
    {"name": "usb电动小风扇", "price": 20},
    {"name": "遮阳伞", "price": 50},
]

然后小明一共有8000块钱，那么他能不能买下这所有商品？ 如果能，请输出“能”，否则输出“不能”

提示: 可以使用循环嵌套和非循环嵌套2种方式

1. 循环嵌套: 先遍历列表, 再遍历字典

2. 非嵌套: 遍历列表, 直接取字典的值

使用循环嵌套仅仅是为了熟悉语法, 正常开发中, 使用非嵌套即可.

答案

# 方式一: 使用for循环嵌套, 遍历列表取到字典时, 再遍历字典的键值
product_list = [
    {"name": "电脑", "price": 7000},
    {"name": "鼠标", "price": 30},
    {"name": "usb电动小风扇", "price": 20},
    {"name": "遮阳伞", "price": 50},
]
money = 8000
sum_num = 0  # sum_num初始化为0，是用来存放总价格
for product in product_list:
    for key, value in product.items():
        if key == "price":
            sum_num += value
if money >= sum_num:
    print("能")
else:
    print("不能")

    
# 方式二: 使用for, 根据字典key取值(推荐)
product_list = [
    {"name": "电脑", "price": 7000},
    {"name": "鼠标", "price": 30},
    {"name": "usb电动小风扇", "price": 20},
    {"name": "遮阳伞", "price": 50},
]
money = 8000
sum_num = 0  # sum_num初始化为0，是用来存放总价格
for product in product_list:
    sum_num += product['price']
if money >= sum_num:
    print("能")
else:
    print("不能")