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

最新推荐文章于 2024-05-29 22:35:37 发布
最新推荐文章于 2024-05-29 22:35:37 发布
阅读量812 收藏 1
点赞数 4
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tingbaobaoo/article/details/120422337
版权

学习目标：

  • 能够说出常用 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))  # <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]重复字符串、列表、元组
in3 in (1, 2, 3)True元素是否存在字符串、列表、元组、字典
not in4 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
去除两端字符字符串.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("不能")

王络不稳定
关注
01-python核心编程
南柯一梦的江湖
06-10 250
python入门 1.python初步 1.1 计算机基础结构 1.1.1 硬件 1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。 五大组成部分：运算器、控制器、存储器、输入设备、输出设备。 – 运算器：按照程序中的指令，对数据进行加工处理。 – 控制器：根据程序需求，指挥计算机的各个部件协调工作。 通常将运算器和控制器集成在中央处理器（CPU）中。 – 存储器：保存各类程序的数据信息。 ​ 内存RAM – 容量小，速度快，临时存储数据 ​ 硬盘HDD – 容量大，速度慢，
python语言实例-Python代码样例列表
weixin_37988176的博客
11-01 3765
├─algorithm│ Python用户推荐系统曼哈顿算法实现.py│ NFA引擎,Python正则测试工具应用示例.py│ Python datetime计时程序的实现方法.py│ python du熊学斐波那契实现.py│ python lambda实现求素数的简短代码.py│ Python localtime()方法计算今天是一...
python中容器的练习题
weixin_54408166的博客
05-13 498
1.两个列表进行合并操作 2.使用列表判断一个列表是否在另外一个列表中 3.列表的反转 4.列表的排序 5.实现对列表的增删改查功能 6.如何将0-10随机存入列表中 7.求出元组(90,34,-23,18,12)中的最大值和最小值 8. 针对列表[90,34,-23,18,12]从小到大进行排序， 然后输出排序后结果 “”" 1 ls1 = list([1,2,3,4,5]) ls2 = list([5,4,3,2,1]) ls1.extend(ls2) print(ls1) 2.使用列表判断一个列表是否
python容器基础练习
weixin_56105279的博客
03-31 1689
作业1：有一堆硬币[10, 8, 5, 3, 27, 99]，每次只能拿一个或者两个，求最少多少次可以拿完硬币 ls = [10, 8, 5, 3, 27, 99] def get_coin(): count = 0 for i in ls: if i % 2 == 0: count += i // 2 else: count += i // 2 + 1 return count print(get_coin()) 作业2：如果两个素数之差为2,这样的两个素数就叫作"孪生数"
python基础—“容器”练习 2021-11-08
weixin_52714299的博客
11-08 718
1，如果两个素数之差为2,这样的两个素数就叫作"孪生数",找出100以内的所有"孪生数". ls = [] for i in range(2, 101): flag = True for j in range(2, i): if i % j == 0: flag = False break if flag: ls.append(i) # 判断哪些素数构成孪生素数 index = 0 print(ls) while index < len(ls) - 1: first =
Python容器练习
ln2385650611的博客
11-30 432
【代码】Python容器练习。
python练习之内置容器
weixin_63543838的博客
03-12 176
6：一个五位数,若在它的后面写上一个7,得到一个六位数A,若在它前面写上一个7,得到一个六位数B,B是A的五倍,求此五位数.|-- pop([index=-1]) # append对应，会默认移除最后一个元素。|-- insert(index, 新元素) # 在固定位置插入新的元素。|-- remove(元素) # 移除对应的元素。|-- count(元素) # 统计元素的个数。
2021-09-22大数据学习日志——Python基础——基础知识（附练习题）
tingbaobaoo的博客
09-22 1265
学习目标: 能够使用 PyCharm 完成第一个 Python 程序 能够应用变量记录数据，例如：数量 知道至少3种 Python 常见数据类型，例如：整型、浮点型、字符串 知道使用 int/float/str 函数能够实现类型转换 能够运用运算符做常规运算，例如：加减乘除等 掌握输出、输入的使用，例如：输出小数、字符串，从键盘输入内容 01_计算机组成原理 学习目标: 了解计算机由硬件和软件两部分组成 了解操作系统的作用 了解语言处理程序的作用 1.1 什么是计算机？ 计算机（com
2021-09-25大数据学习日志——Python基础——函数（附练习题）
tingbaobaoo的博客
09-25 673
学习目标： 掌握无参数函数的定义和调用 掌握带参数函数的定义和调用，例如：普通参数、缺省参数、不定长参数 掌握return的使用，例如：中断函数、中断函数同时返回一个结果 知道函数调用的执行流程，例如：普通函数调用流程、嵌套调用流程 知道局部变量和全局变量的区别 知道函数内如何修改全局变量 01_函数的基本使用 学习目标： 知道函数的作用 掌握无参数函数的定义和调用 1.1 函数基本概念 所谓函数，就是把具有独立功能的代码块组织为一个整体，在需要的时候调用 函数的使用包含两个步骤...
python基础语法--python语言及其应用
博客
10-09 3915
python基础语法 python python语言是一种高级动态、完全面向对象的语言。 python中函数、模块、数字、字符串都是对象。 python完全支持继承、重载、派生、多继承。 python程序 运行方式1：交互式运行python语句 运行方式2：保存源文件运行程序 交互式运行python’语句 打开IDLE–科学计算器 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2020092819524773.png#pic_r 第一行程序代码编写 ID
Python代码练习(二)：容器
01-06
Python代码练习(二)：容器 七月在线课程的练习题 使用循环和列表推导找出单词长度大于某个数字的单词 words = [“apple”, “banana”, “orange”, “peach”,“kiwi”] #法一： words = [apple, banana, orange, peach,kiwi] l=int(input()) # [x for x in words if len(x)>=l] for x in words: if len(x)>=l: print(x) #法二： words = [apple, ban
python练习3——数据容器
weixin_45908554的博客
03-20 2067
Python中的数据容器： 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
python -【五】数据容器
最新发布
qq_38800175的博客
05-29 1630
本文主要是针对 python 内置提供的数据容器( list，set，tuple, dict, str)的基础用法讲解并提供了相应的案例，且针对不同容器的切片进行举例，最后对各个容器之间相互转换举例说明
容器型数据类型练习题 （有答案版）
Z_qin007的博客
08-27 459
摘要：容器型数据类型知识点总结，课后习题练习。
【Python】第三章（容器）综合练习
fftx_00的博客
12-29 1096
scores = {"Zhang San": 45, "Li Si": 78, "Wang Wu": 40, \ "Zhou Liu": 96, "Zhao Qi": 65, "Sun Ba": 90, \ "Zheng Jiu": 78, "Wu Shi": 99, "Dong Shiyi": 60} print(max(scores.values())) print(min(scores.values())) print(sum(scores.values()...
五、python的数据容器--附代码案例
CSDN_crossover的博客
09-29 2171
五、数据容器（站在前辈们的肩膀上注入自己的理解，强势总结，适合入门，也适合复习）
python 容器练习题
weixin_53049621的博客
11-14 1559
一、元组练习 fruits = ("apple","banana","strawberry","pear") #a. 1计算元组长度并输出 a = len(fruits) #全局函数len() print("元组长度为:",a) print("---------------------------------") #a.2 num = 0 for i in fruits: num += 1 print(num) print("---------------------------------
第五章 Python数据容器 08-容器综合案例
shawn
02-04 206
跟我一起学习Python吧
Python与Spark ETL工具开发——spark-etl-0.0.6介绍
资源摘要信息:"Python库 | spark-etl-0.0.6.tar.gz" 知识点一：Python库概述 Python库是一组预先编写的代码，它能为特定的应用提供功能，比如数据处理、网络通信、图形用户界面等。在本次提供的资源中，“spark-etl...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值