Python基础_03_容器类型

已于 2022-01-26 23:11:50 修改
阅读量1k 收藏 2
点赞数
分类专栏： Python 文章标签： python 容器 开发语言
于 2022-01-26 23:02:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59939643/article/details/122710162
版权

Python基础3：容器类型

文章目录

一、列表

1.【重点】列表的定义和使用

1.1. 【重点】列表的定义和使用
"""
列表定义的格式：
列表变量的名字 = [元素1, 元素2, ……]

使用格式：
    列表变量[位置]
    位置：也叫下标、索引 (可以是正数或者负数)
"""

# 列表定义
name_list = ['rose', 'tom', 'mike', 'lily', 1, 2, 3]
#               0       1     2       3     4  5  6
#																			...	  	-2	-1
# 最后一个元素取出来
print(name_list[6])
print(name_list[-1])

# 访问列表元素，不要超出范围，不要越界
# print(name_list[10])    # IndexError: list index out of range
1.2. 【重点】列表的嵌套定义和使用

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


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

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

2.【知道】列表常用操作

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

tmp_list = [1,2,3]
print(tmp_list)

# 增加一个元素，值为4
tmp_list.append(4)
print(tmp_list)

# 删除值为2的元素
tmp_list.remove(2)
print(tmp_list)
2.2. 【知道】修改查询
"""
列表[索引] = 值	修改指定索引的数据，数据不存在会报错
列表[索引]        根据索引取值，索引不存在会报错
len(列表)	    列表长度(元素个数)
if 值 in 列表:	判断列表中是否包含某个值
"""

tmp_list = [1, 2, 3, 3]
print(tmp_list)

# 最后一个元素，修改为5
tmp_list[-1] = 5
print(tmp_list)

# 访问索引为1的元素
print(tmp_list[1])
# print(tmp_list[5])  # IndexError: list index out of range

# len(列表)	    列表长度(元素个数)
_len = len(tmp_list)
print(_len)

# 判断3，是否在列表中
if 3 in tmp_list:
    print("3在列表中")
else:
    print("3不在列表中")
2.3. 【知道】排序
my_list = [10, 20, 13]

# 列表.sort()	升序排序
my_list.sort()
print(my_list)

# reverse=True, 降序排序
my_list.sort(reverse=True)
print(my_list)

3.【重点】列表的遍历

3.1 【重点】通过for循环遍历
# 遍历，从头开始找，直到结束

name_list = ['tom', 'rose', 'lily', 'yoyo', 'mike']

# 通过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 变量 in 列表:		依次从列表中取出每一个元素赋值给变量
#			print(变量)

for name in name_list:
    print(name)
3.2 【重点】if…in 和 for…in 的区别
# if…in：判断某个元素是否在列表中，如果在，if的条件为True
# for…in：从头到尾 依次从 列表 中取出 每一个元素，这个元素给name赋值

name_list = ['tom', 'rose', 'lily', 'yoyo', 'mike']

name = 'rose'

# if…in：判断某个元素是否在列表中，如果在，if的条件为True
if name in name_list:
    print("%s在列表中" % name)


# for…in：从头到尾 依次从 列表 中取出 每一个元素，这个元素给name赋值
for name in name_list:
    print(name)
3.3 【重点】for…else的使用


name_list = ['tom', 'rose', 'lily', 'yoyo', 'mike']

# for循环中没有break，for循环执行结束，执行else的代码块
for name in name_list:
    print(name)

    if name == "rose":
        break

else:
    print("for循环中没有break，for循环执行结束，执行else的代码块")

二、元组

1.【重点】元组的定义和使用

# 元组：元组变量 = (元素1, 元素2, ……)
my_tuple = ('rose', 'tom', 'lily', 'mike')
print(my_tuple)

# 元组只有一个元素的时候，格式: (元素,)
# my_tuple2 = (250)
# print(type(my_tuple2))  # <class 'int'>

my_tuple2 = (250, )
print(type(my_tuple2))  # <class 'tuple'>

2.【知道】元组和列表的区别

  • 元组的 元素不能修改，列表中的元素可以修改
# 元组只有一个元素的时候，格式: (元素,)
# my_tuple2 = (250)
# print(type(my_tuple2))  # <class 'int'>

my_tuple2 = (250, )
print(type(my_tuple2))  # <class 'tuple'>

# 元组的元素只读，不能改
# my_tuple[0] = 'yoyo'    # TypeError: 'tuple' object does not support item assignment

print(len(my_tuple))

if "rose" in my_tuple:
    print("rose在元组中")
# 循环遍历和列表一样
for name in my_tuple:
    print(name)

三、字典

1.【重点】字典的定义和使用

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

取出元素的值：
    字典变量[键值]
"""
# 字典的定义
student_dict = {"name": "rose", "age": 18, "sex": "male"}

# 取出元素的值：字典变量[键值]
print(student_dict['age'])
print(student_dict['name'])
print(student_dict['sex'])

2. 【知道】字典常用操作

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

# 字典定义
student_dict = {"name": "rose", "age": 18, "sex": "male"}
print(student_dict)

# 字典[键] = 值	键不存在，会添加键值对
student_dict['class'] = 'python40期'
print(student_dict)

# 字典.pop(键)	    删除指定键值对,返回被删除的值,如果键不存在,会报错
old_value = student_dict.pop("sex")
print(student_dict)
print(old_value)

# student_dict.pop("sex")  # KeyError: 'sex'
2.2. 【知道】修改查询
"""
字典[键] = 值		 键存在，会修改键值对的值
字典[键]	        根据键取值，键值对不存在会报错
字典.get(键)	    根据键取值，键值对不存在返回None, 不会报错
"""

student_dict = {"name": "rose", "age": 18, "sex": "male"}
print(student_dict)

# 字典[键] = 值	键存在，会修改键值对的值
student_dict['age'] = 20
print(student_dict)

# 字典[键]	        根据键取值，键值对不存在会报错
print(student_dict['name'])
# print(student_dict['class'])    # KeyError: 'class'

print(student_dict.get('name'))
print(student_dict.get('class'))  # None


#扩展: get("key", 默认值) 如果key存在,返回value,如果不存在,返回默认值
print(student_dict.get("class", "班级待定"))

3. 【知道】字典遍历

"""
# 遍历字典, 获取所有的键值对 (键, 值)
for k, v in 字典变量.items():
    print(k, v)
"""

student_dict = {"name": "rose", "age": 18, "sex": "male"}

# 直接使用for变量, 依次获取字典的key
for key in student_dict:
    print("key: %s " % key)
    print("value: ", student_dict[key])

# 遍历字典, 获取所有的键值对 (键, 值)
# for k, v in 字典变量.items():
#     print(k, v)
for key, value in student_dict.items():
    print("key: ", key, " value: ", value)

4. 【应用】案例：登录注册系统

4.1. 【理解】登录注册系统-思路分析
"""
需求：1.用户注册 2.用户登录
用户1: {'name': '张三', 'pwd': 123456}
用户2: {'name': '李四', 'pwd': 123456}
.....

用户管理是列表：
[{'name': '张三', 'pwd': 123456}, {'name': '李四', 'pwd': 123456}]
"""
"""
# 1. 注册功能，新增加一个用户
# 1.1 用户信息
#   1.1.2. 判断某个用户，是否在列表中
#   1.1.3. 找到用户,说明用户已经注册了,不允许再次注册
# 1.2 创建一个字典
# 1.3 追加字典到列表中
"""

"""
# 2. 判断某个用户，是否在列表中
# 2.1 需要找的用户
# 2.2 通过for遍历列表，取出的每个元素是字典
    # 2.3 字典['name']和reg_name比较是否相等
        # 2.4 如果相等，打印提示名字在列表中
        # 2.5 跳出循环
# 2.6 for循环的else，循环里面没有执行到break，则会执行else
    # 2.7 打印，名字不在列表中
"""

# 3. 登陆功能：和上面流程差不多，同时判断用户名和密码是否相等
4.2. 【应用】登录注册系统-主界面逻辑
"""
登录注册系统需求：1.用户注册/ 2.用户登录/ 3.退出程序

# 1. 死循环 while True:
    # 2. 输入数字指令
    # 3. 判断指令，选择分支
"""

# 1. 死循环 while True:
while True:
    # 2. 输入数字指令
    num = int(input("登录注册系统需求：1.用户注册/ 2.用户登录/ 3.退出程序: "))
    # 3. 判断指令，选择分支
    if num == 1:
        pass
    elif num == 2:
        pass
    elif num == 3:
        print("结束程序")
        break
    else:
        print("输入错误,请重新输入")
4.3. 【应用】登录注册系统-用户注册
"""
登录注册系统需求：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 打印：注册成功
"""

# 0. 定义一个列表，用于存储用户字典
user_list = [{"name": "rose", "password": "123"}, {"name": "mike", "password": "456"}]


while True:
    num = int(input("请输入操作: 1.用户注册/ 2.用户登录/ 3.退出程序 : "))
    if num == 1:
    # 4. 用户注册功能
        # 4.1 输入注册的用户名
        user_name = input("请输入需要注册的用户名: ")
        # 4.2 通过for遍历列表，取出的每个元素是字典
        for user_dict in user_list:
            # 4.3 字典['name']和输入注册的用户名比较是否相等
            if user_dict['name'] == user_name:
                # 4.4 如果相等，打印提示：名字在列表中，不允许注册
                print("名字在列表中，不允许注册")
                # 4.5 跳出循环
                break
        # 4.6 for循环的else，循环里面没有执行到break，则会执行else
        else:
            # 4.7 输入注册的密码
            user_password = input("请求输入注册密码: ")
            # 4.8 创建一个字典
            new_dict = {"name": user_name, "password": user_password}
            # 4.9 字典追加到列表中
            user_list.append(new_dict)
            # 4.10 打印：注册成功
            print("注册成功")
            # 测试是否注册成功: 
            # print(user_list)
    elif num == 2:
        pass
    elif num == 3:
        print("退出程序")
        break
    else:
        print("输入错误,重新输入")
4.4. 【应用】登录注册系统-用户登录
"""
登录注册系统需求：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": "rose", "password": "123"}, {"name": "mike", "password": "456"}]

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

    elif num == 3:
        print("退出程序")
        break
    else:
        print("输入错误,重新输入")

四、字符串

1.【重点】字符串的定义和使用

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

my_str = "python"
#         012345
print(my_str)

# 说明：可以是单引号、双引号、三引号
my_str2 = 'python' \
          '.com'
print(my_str2)

my_str3 = '''
python
itcast            
itheima
....
'''
print(my_str3)


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

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

# 注意: 嵌套使用单引号和双引号
my_str4 = "字符串为'python'"
print(my_str4)

2.【了解】f-strings 字符串格式化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SINLhrQn-1643209347781)(assets/41_f格式化字符串.png)]


name = "tom"
age = 20
sex = "male"

# 格式化字符串
print("姓名: %s 年龄: %d 性别: %s" % (name, age, sex))

# fstrings的格式化字符串
print(f"姓名: {name} 年龄: {age} 性别: {sex}")
print(F"姓名: {name} 年龄: {age} 性别: {sex}")


# 扩展: format的格式化字符串
print("姓名: {} 年龄: {} 性别: {}".format(name, age, sex))

3. 【知道】字符串常用操作

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

str1 = "hello abc python"
#       012345678911
#                 01

# 在str1字符串中，查找’abc‘字符串，返回找到字符串所对应的索引
index = str1.find("abc")
print(index)

# 如果没有找到，返回-1
index = str1.find("88")
print(index)

# 指定区间查找子串, 从索引2到索引11-1为止
index = str1.find("py", 2, 11)  # [2,11) 包含开始索引,不包含结尾索引
print(index)
3.2. 【知道】替换
"""
字符串.replace(原内容, 新内容, 替换次数)	 返回一个替换了原内容的新字符串，可以指定替换次数
"""

str1 = "hello python2.5 python3.4 python3.5 python3.6 python3.8"

# 源字符串里的py，替换为Py，返回值才是替换后的内容
new_str = str1.replace("py", "Py")
print(str1)
print(new_str)

new_str = str1.replace("py", "Py", 2)
print(str1)
print(new_str)
3.3. 【知道】分割
# 字符串.split(分割符)	以分割符拆分字符串, 返回列表

str1 = "hello python hello world"

# str1中字符串内容以' '分隔，返回字符串列表['hello', 'python', 'hello', 'world']
new_list = str1.split(" ")
print(str1)
print(new_list)

# 扩展1: \t: tab键 \n: 回车键
str2 = "hello python\thello\nworld"
new_list = str2.split()  # split() 不指定分割字符,会以空白字符作为分割, 空白字符:空格,tab键,回车换行键.
print(new_list)


# 扩展2: split("分隔符", maxsplit=最大分割次数)
str3 = "hello python hello world"
new_list = str3.split(" ", maxsplit=2)
print(new_list)


# 注意:光标移动到查询的函数, ctrl+b, 可以进入代码帮助
3.4. 【知道】拼接
"""
字符串 + 字符串	        拼接两个字符串
字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串, 返回新的字符串
"""
# 多个字符串连接再一起

# 字符串 + 字符串	        拼接两个字符串
str1 = "hello "
str2 = "world "
str3 = "python"

new_str = str1 + str2 + str3
print(new_str)

# 字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串, 返回新的字符串

str4 = ","
str_list = ['rose', 'tom', 'lily', 'mike']

new_str = str4.join(str_list)
print(new_str)

4.【重点】字符串的切片操作

  • 字符串[开始位置:结束位置:步长]
    • 步长默认为1，步长理解为走几步
    • 字符串[开始位置:结束位置]： 开始位置 ~（结束位置-1）
    • 字符串[开始位置: ]： 开始位置 ~ 结束位置，末尾位置不写，默认能取到末尾那个位置
    • 字符串[ :结束位置]： 0 ~（结束位置-1），开始位置不写，默认从第0个元素开始
"""
切片适用于: 字符串,元组,列表
字符串[开始索引:结束索引:步长]
0. 步长默认为1，步长理解为走几步，正数从左往右，负数从右往左
1. 字符串[开始索引:结束索引]   开始索引 ~（结束索引-1）
2. 字符串[开始索引: ]       开始索引 ~ 结束索引，末尾索引不写，默认能取到末尾那个索引
3. 字符串[ :结束索引]       0 ~（结束索引-1），开始索引不写，默认从第0个元素开始
"""

my_str = "123456789"
#         012345678
#               -2-1

# 截取从 2 ~ 5 位置 的字符串
print(my_str[1:5])  # 取出下标1~4的所有字符
# 截取从 2 ~ 末尾 的字符串
print(my_str[1:])
# 截取从 开始 ~ 5 位置 的字符串
print(my_str[:5])   # 取出下标0-4的所有字符
# 从开始位置，每隔一个字符截取字符串，也就是说走2步
print(my_str[::2])
# 截取字符串末尾两个字符
print(my_str[-2:])
# 字符串的逆序（面试题）
print(my_str[::-1])

五、集合

1.【知道】通过set对list中的元素去重

  • 通过集合完成对列表中元素的去重功能：set(列表)
# 集合：元素不会重复，{元素1，元素2……}
# 定义集合
# 通过集合完成对列表去重功能

my_set = {1, 2, 1, 2, 1, 2}
print(my_set)
print(type(my_set))  # <class 'set'>

# 注意: 空集合定义不能使用{}, {}定义的是字典.空集合使用set()
# my_dict = {}  # <class 'dict'>
# print(type(my_dict))

# my_list = []
# print(type(my_list))    # <class 'list'>
#
# my_tuple = ()
# print(type(my_tuple))   # <class 'tuple'>

my_set = set()
print(type(my_set))  # <class 'set'>

print("=======================华丽分隔符=======================")

my_list = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
print(my_list)

my_set = set(my_list)
print(my_set)

my_list = list(my_set)
print(my_list)

2.【知道】list、tuple、set之间类型转换

函数说明
list(x)将 x 转换为列表类型
tuple(x)将 x 转换为元组类型
set(x)将 x 转换为集合类型
"""
列表类型名：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)
# 列表转换为集合类型
my_set = set(my_list)  # 集合不会出现重复
print(my_set)

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

# 元组转列表、集合 类型
my_tuple = (1, 2, 3, 5, 3, 5)
# 元组转换为列表 类型
my_list = list(my_tuple)
print(my_list)
# 元组转换为集合 类型
my_set = set(my_tuple)
print(my_set)

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

# 集合转元组、列表 类型
my_set = {1, 2, 3, 5}
# 集合转换为列表 类型
my_list = list(my_set)
print(my_list)
# 集合转换为元组 类型
my_tuple = tuple(my_set)
print(my_tuple)

# 扩展: 字符串转换:
print('============华丽分割线============')
my_str = "hello"
print(list(my_str))
print(tuple(my_str))
print(set(my_str))

my_list = ['h', 'e', 'l', 'l', 'o']
my_str = "".join(my_list)
print(my_str)

六、公共语法

1.【知道】容器公共语法：内置函数、切片、运算符

  1. 内置函数
    • len(容器变量)： 计算容器中元素个数
  2. 切片
    • 字符串、列表、元组都支持切片类型
  3. 运算符
    • +：合并
    • *：复制
# 内建（内置）函数
# 通过len获取容器类型的元素个数
my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_set = {1, 2, 3}
my_dict = {"k1": 1, "k2": 2, "k3": 3}
my_str = "123"

print(len(my_list), len(my_tuple), len(my_set), len(my_dict), len(my_str))

print(max(my_list), max(my_str), max(my_dict))

# 字符串、列表、元组都支持切片操作
print(my_list[::-1])
print(my_tuple[::-1])

# 运算符
# +：拼接，同类型的容器
# 字符串拼接合并
str1 = "hello "
str2 = "world"
print(str1 + str2)

# 列表元素拼接合并
list1 = [1, 2]
list2 = [3, 4]

new_list = list1 + list2
print(new_list)

# *: 复制
print("="*50, "华丽分割线", "="*50)
Sql_Boy_A_Liang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python对象和容器（各种数据类型）
weixin_42611675的博客
07-04 5570
python 对象类型​ 程序在启动以后，是以进程方式存在。进程中数据（变量，函数，类，容器等）保存在内存中。​ python中对象是什么？ ​ 由于python是弱类型语言，python中一切皆对象，对象包含：变量，函数，类，容器 对象存储在内存中的值。这就意味着在创建对象时会在内存中开辟一个内存空间。 基于变量的数据类型，解释器会分配指定内存，并决定什么数据...
Python-容器类型
weixin_43336407的博客
07-08 1868
容器总结：字符串、列表、字典、元组、结合 容器的基本基础知识
Python基础知识之容器类型
weixin_58487644的博客
04-01 1482
三、容器类型
Python学习日记：数据结构——容器类型
Jarvi_Clarke的博客
01-09 1300
在了解列表、字符串等其他数值类型前，先从整体层次上取了解一下什么是容器类型。
Python的列表操作
qq_21337539的博客
05-27 1726
1.列表创建 Python中用中括号[ ]来表示列表，并且用逗号来分隔元素。列表的创建方式如下： >>> list=['a','b','c','d',1,2,3,4] 当我们用print函数将该列表打印出来，中括号也会同步显示出来： >>> print(list) ['a', 'b', 'c', 'd', 1, 2, 3, 4] 2.列表访问 列表中的每个元素都有索引（index），最左边的index为0，从左到右index依次加1。我们可以根据元..
Python3之iterable类型和iterator类型
llf_cloud的博客
08-31 1840
凡是可作用于for循环的对象都是Iterable类型；凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列。 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。    ...
python基础知识笔记
热门推荐
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python基础（十六、数据容器汇总）
qq_35716085的博客
01-04 2万+
sorted(容器,reverse=True)
Python 基础教程：__dict__属性详解
python学习者的博客
01-12 1485
我们都知道Python一切皆对象，那么Python究竟是怎么管理对象的呢？ 1、无处不在的__dict__ 首先看一下类的__dict__属性和类对象的__dict__属性 # -*- coding: utf-8 -*- class A(object): """ Class A. """ a = 0 b = 1 def __init__(self): self.a = 2 self.b = 3 def test(se
python基础_python基础_
10-01
以上只是Python基础的一部分，实际学习过程中，还需要结合实践，通过编写小程序、解决实际问题来加深理解。对于初学者来说，阅读官方文档、参加在线课程和参与开源项目都是提升技能的好方法。在Python的世界里，只有...
CH01_Python语言基础_Python语言基础_
09-30
Python中的变量是用来存储数据的容器，无需提前声明类型。它支持多种数据类型，包括整型（int）、浮点型（float）、字符串（str）和布尔型（bool）。例如： ```python x = 10 # 整型 y = 3.14 # 浮点型 z = ...
Python.zip_python_python 实例_python 教程_python实例_python教程
07-13
首先，Python的基础知识包括变量、数据类型和操作符。变量是存储信息的容器，你可以将其想象为一个可以改变其值的标签。Python支持多种数据类型，如整型（int）、浮点型（float）、字符串（str）和布尔型（bool）。...
零基础学python_python_
09-30
列表、元组、集合和字典是Python的四种主要容器类型，它们用于存储和操作数据。列表是最常用的，支持动态添加和删除元素；元组是不可变的，常用于数据结构的固定部分；集合是无序不重复元素集，常用于去重或集合运算...
cv2读取和保存图片
最新发布
m0_53291740的博客
07-12 121
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 753
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1055
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 694
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
leetcode--验证二叉搜索树
liulanba的博客
07-09 662
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
Python学习教程：简明易懂的入门指南.pptx
03-24
这份教程提供了全面且实用的Python基础知识，适合初学者系统学习，逐步建立起对Python编程语言的扎实基础。通过学习数据类型和变量，以及流程控制，学员能够快速上手并为进一步的进阶学习打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值