CAIJINBO

python基础03-容器类型

2020-07-26python

容器类型

一、列表

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])
  • 注意：从列表中取值时，如果 超出索引范围，程序会报错

2. 列表嵌套

  • 一个列表中的元素又是列表，那么这就是列表的嵌套
school_list = [['北京大学', '清华大学'], ['中山大学', '华南理工大学'], ['哈工大', '哈工程']]
#                  0                      1                         2

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

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

3. 列表常用操作

分类 关键字 / 函数 / 方法 说明
增加 列表.append(值) 在末尾追加数据
删除 列表.remove(值) 删除第一个出现的指定数据
修改 列表[索引] = 值 修改指定索引的数据，数据不存在会报错
查询 列表[索引] 根据索引取值，索引不存在会报错
len(列表) 列表长度(元素个数)
if 值 in 列表: 判断列表中是否包含某个值
排序 列表.sort() 升序排序

4. 循环遍历

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)

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

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的分支

二、元组

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. 元组常用操作

  • tuple（元组）与列表类似，不同之处在于元组的 元素不能修改
my_tuple = ('mike', 'yoyo', 'lily')
# 元组只读不能改
# TypeError: 'tuple' object does not support item assignment
# my_tuple[0] = 'rock' # err
分类 关键字 / 函数 / 方法 说明
查询 元组[索引] 根据索引取值，索引不存在会报错
len(元组) 元组长度(元素个数)
if 值 in 元组: 判断元组中是否包含某个值

三、字典

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'])

2. 字典常用操作

分类 关键字 / 函数 / 方法 说明
增加 字典[键] = 值 键不存在，会添加键值对
删除 字典.pop(键) 删除指定键值对,返回被删除的值,如果键不存在,会报错
修改 字典[键] = 值 键存在，会修改键值对的值
查询 字典[键] 根据键取值，键值对不存在会报错
字典.get(键) 根据键取值，键值对不存在返回None, 不会报错
for key, value in 字典.items() 遍历字典, 获取所有的键值对 (键, 值)

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 = int(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("输入错误，重新输入"

四、字符串

1. 字符串的定义

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

"""
my_str = 'python'
#         012345

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

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

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}')

3. 字符串的常用操作

分类 关键字 / 函数 / 方法 说明
查找 字符串.find(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1
替换 字符串.replace(原内容, 新内容, 替换次数) 返回一个替换了原内容的新字符串，可以指定替换次数
分割 字符串.split(分割符) 以分割符拆分字符串, 返回列表
拼接 字符串 + 字符串 拼接两个字符串
字符串.join(字符串列表) 以字符串来连接字符串列表中每个元素，合并为一个新的字符串

4. 字符串的切片

4.1 切片介绍

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

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

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

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

注意：

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

4.2 案例

演练需求

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

示例代码：

"""
字符串[开始索引:结束索引:步长]
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])

五、集合

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'}

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)

六、公共语法

1. Python 内置函数

Python 包含了以下内置函数：

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

2. 切片

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

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 被称为 成员运算符

七、容器常用方法汇总

1. 列表操作

分类 关键字 / 函数 / 方法 说明
增加 列表.append(值) 在末尾追加值
列表.insert(索引, 值) 在指定位置插入值, 超过索引会追加值
列表.extend(可迭代对象) 将可迭代对象 中 的元素 追加到列表
删除 列表.remove(值) 删除指定值的 第一个匹配项
del 列表[索引] 删除指定位置的值
列表.pop(索引) 删除指定索引的值, 并返回被删除的值
列表.clear() 清空列表
修改 列表[索引] = 值 修改指定索引的值，索引不存在会报错
查询 列表[索引] 根据索引取值，索引不存在会报错
len(列表) 列表长度(元素个数)
if 值 in 列表: 判断列表中是否包含某个值
列表.index(值) 根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
列表.count(值) 值在列表中出现的次数
排序 列表.sort() 排序
列表.reverse() 逆序、反转

2. 元组操作

分类 关键字 / 函数 / 方法 说明
查询 元组[索引] 根据索引取值，索引不存在会报错
len(元组) 元组长度(元素个数)
if 值 in 元组: 判断元组中是否包含某个值
元组.index(值) 根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
元组.count(值) 值在元组中出现的次数

3. 字典操作

分类 关键字 / 函数 / 方法 说明
增加 字典[键] = 值 键不存在，会添加键值对
删除 字典.pop(键) 根据键删除键值对,返回被删除的值
del 字典[键] 根据键删除键值对
字典.clear() 清空字典
修改 字典[键] = 值 键存在，会修改键值对的值
字典.update(字典2) 取出字典2的键值对对字典1操作，键值对不存在，添加键值对；存在则修改值
字典.setdefault(键，数据) 键值对不存在，添加键值对；存在则不做处理
查询 字典[键] 根据键取值，键值对不存在会报错
字典.get(键) 根据键取值，键值对不存在返回None, 不会报错
for key in 字典 遍历字典, 获取所有的键
for key in 字典.keys() 遍历字典, 获取所有的键
for value in 字典.values() 遍历字典, 获取所有的值
for item in 字典.items() 遍历字典, 获取所有的键值对 (键, 值)

4. 字符串操作

分类 关键字 / 函数 / 方法 说明
分割 字符串.split(分割符) 以分割符拆分字符串, 返回列表
字符串.partition(分割符) 返回元组，把字符串分成一个 3 元素的元组 (分割符前面, 分割符, 分割符后面)
拼接 字符串 + 字符串 拼接两个字符串
字符串.join(字符串列表) 以字符串来连接字符串列表中每个元素，合并为一个新的字符串
替换 字符串.replace(原内容, 新内容, 替换次数) 返回一个替换了原内容的新字符串，可以指定替换次数
查询 字符串.find(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1
字符串.rfind(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1, 从结尾处开始查找
字符串.index(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在会报错
判断 字符串.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True
字符串.isdecimal() 如果 string 只包含数字则返回 True
字符串.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
字符串.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
字符串.startswith(目标字符串) 检查字符串是否是以 目标字符串 开头，是则返回 True
字符串.endswith(目标字符串) 检查字符串是否是以 目标字符串 结尾，是则返回 True
大小写转换 字符串.lower() 返回新字符串，转换 字符串 中所有大写字符为小写
字符串.upper() 返回新字符串，转换 字符串 中所有大写字符为大写
文本对齐 字符串.center() 按照指定宽度返回新字符串，并基于原字符串居中，可设置两端空白位置的填充字符
字符串.ljust() 按照指定宽度返回新字符串，并基于原字符串左对齐，可设置两端空白位置的填充字符
字符串.rjust() 按照指定宽度返回新字符串，并基于原字符串右对齐，可设置两端空白位置的填充字符
去除两端字符 字符串.strip(目标字符串) 返回新字符串，去除 字符串 左右两边的目标字符串, 不设置目标字符串则去除空格
字符串.lstrip(目标字符串) 返回新字符串，去除 字符串 左边的目标字符串, 不设置目标字符串则去除空格
字符串.rstrip(目标字符串) 返回新字符串，去除 字符串 右边的目标字符串, 不设置目标字符串则去除空格
本文作者：caijinbo
本文链接：https://caijinbo.work/2020/07/26/2020-07-27-python基础03-容器类型/
版权声明：本博客所有文章除特殊声明外，均采用 CC BY-NC 4.0 许可协议。转载请注明出处 caijinbo的博客！
python