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

Posted 2021-10-13 成长的小狮子

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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
- 步长默认为 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))  # <class '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 = "zhangsan@163.com" # 以@分割字符串,分成三段式 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`
去除两端字符	大数据学习——日志分析 python基础学习日志day8-socket发送大数据包问题 2021-09-15大数据学习日志——Linux终端命令 CK2255-以慕课网日志分析为例进入大数据 Spark SQL 的世界 2021-09-14大数据学习日志——Linux系统目录 python基础学习日志day5---os模块 (c)2006-2024 SYSTEM All Rights Reserved IT常识