Python基础入门 --- 6.数据容器

已于 2024-05-17 13:29:02 修改
阅读量1.6k 收藏 14
点赞数 53
分类专栏： Python基础入门 文章标签： python windows 开发语言
于 2024-03-20 17:56:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongziqia/article/details/136884086
版权

文章目录

Python基础入门

第六章：

6.数据容器

定义：一种可容纳多份数据的数据类型，容纳的每一份数据称为1个元素，每个元素，都可是任意类型的数据。

作用：一个容器可以容纳多份数据。

分为5类：

  • 列表(list)

  • 元组(tuple)

  • 字符串(str)

  • 集合(set)

  • 字典(dict)

6.1 列表

列表内的每一个数据，称为元素。

语法结构：

# 字面量
[元素1, 元素2, 元素3, ....]

# 定义变量
变量名 = [元素1, 元素2, 元素3, ....]

# 定义空列表
变量名 = []
变量名 = list()

  • 以[]为标识

  • 列表内的每一个元素之间用逗号分隔

name_list1 = ['hello', 100, False]
print(name_list1)
print(type(name_list1))
name_list2 = [[1, 2, 3], [4, 5, 6]]
print(name_list2)
print(type(name_list2))))

在这里插入图片描述

补充：列表可以依次存储多个数据，可以是不同的数据类型，支持嵌套使用。

6.1.1 列表下标索引

作用：从列表出取出特定位置的数据。

元素元素元素元素元素
01234
-5-4-3-2-1

正向索引：从前到后的方向，从0开始，依次递增。

反向索引：从后到前的反向，从-1开始，依次递减。

name_list1 = ['hello', 100, False]
print(name_list1[0])
print(name_list1[1])
print(name_list1[2])

print(name_list1[-1])
print(name_list1[-2])
print(name_list1[-3])

name_list2 = [[1, 2, 3], [4, 5, 6]]
print(name_list2[0][1])
print(name_list2[1][2])
print(name_list2[1][1])

在这里插入图片描述
9YA-1710927932866)

6.1.2 列表常用操作

功能：

  • 插入元素

  • 删除元素

  • 修改元素

  • 统计元素个数

  • 清空列表

查找指定某元素的下标

语法结构：列表.index(元素)

name_list = ["he", "ll", "o"]
index = name_list.index("ll")
print(f"ll在列表中的下标索引值为：{index}")
# 输出：ll在列表中的下标索引值为：1
修改指定位置的元素值

语法结构：列表[下标] = 值

name_list = ["he", "ll", "o"]
name_list[1] = "he"
print(f"列表中的下标1的值被改后，结果是：{name_list}")
# 输出：列表中的下标1的值被改后，结果是：['he', 'he', 'o']
插入元素

说明：在指定的位置，插入指定的元素。

语法结构：列表.insert(下标, 元素)

name_list = ["he", "ll", "o"]
name_list.insert(1, "ha")
print(f"列表中的下标1的位置被插入指定元素后，结果是：{name_list}")
# 输出：列表中的下标1的位置被插入指定元素后，结果是：['he', 'ha', 'll', 'o']
追加元素方式1

说明：将指定元素，追加到列表的尾部。

语法结构：列表.append(元素)

name_list = ["he", "ll", "o"]
name_list.append("hehe")
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'hehe']
追加元素方式2

说明：将其他数据容器的内容取出，依次追加到列表尾部。

语法结构：列表.extend(其他数据类型)

name_list = ["he", "ll", "o"]
name_list.extend(["wo", "r", "ld"])
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'wo', 'r', 'ld']
删除元素

语法结构1：del 列表[下标]

语法结构2：列表.pop(下标)

# 方法1
name_list = ["he", "ll", "o"]
del name_list[1]
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']

# 方法2
name_list = ["he", "ll", "o"]
name_list.pop(1)
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']
删除某元素在列表中的第一个匹配项

语法结构：列表.remove(元素)

name_list = ["he", "ll", "o", "he"]
name_list.remove("he")
print(f"列表被移除元素后，结果是：{name_list}")
# 输出：列表被移除元素后，结果是：['ll', 'o', 'he']
清空列表

语法结构：列表.clear()

name_list = ["he", "ll", "o", "he"]
name_list.clear()
print(f"列表被清空后，结果是：{name_list}")
# 输出：列表被清空后，结果是：[]
统计某元素在列表中的数量

语法结构：列表.count(元素)

name_list = ["he", "ll", "o", "he"]
print(f"列表中he的数量是：{name_list.count("he")}")
# 输出：列表中he的数量是：2
统计列表元素个数

语法结构：len(列表)

name_list = ["he", "ll", "o", "he"]
print(f"列表中的元素个数有：{len(name_list)}")
# 输出：列表中的元素个数有：4
总结：
编号使用方法作用
1列表.append(元素)在列表中追加一个元素到尾部
2列表.extend(容器)其他数据容器内容取出，依次追加到列表尾部。
3列表.insert(下标, 元素)在指定的位置，插入指定的元素。
4del 列表[下标]删除列表指定下标元素
5列表.pop(下标)删除列表指定下标元素
6列表.remove(元素)删除某元素在列表中的第一个匹配项
7列表.clear()清空列表
8列表.count(元素)统计某元素在列表中的数量
9列表.index(元素)查找指定某元素的下标
10len(列表)统计列表元素个数
6.1.3 列表的特点

  • 可容纳多个元素

  • 可容纳不同类型的元素

  • 有序存储数据

  • 允许重复数据

  • 可修改

6.1.4 列表的遍历 — while循环

语法结构：

index = 0
while index < len(列表):
    元素 = 列表[index]
    元素的处理
    index += 1

name_list = ["he", "l", "l", "0", "!"]
index = 0
while index < len(name_list):
    element = name_list[index]
    print(f"列表下标为{index}的元素是{element}")
    index += 1

在这里插入图片描述

6.1.5 列表的遍历 — for循环

语法结构：

for 临时变量 in 数据容器:
    临时变量的处理

name_list = ["he", "l", "l", "0", "!"]
index = 0
for element in name_list:
    print(f"列表元素有{element}")

在这里插入图片描述

6.1.6 while循环与for循环的区别

循环控制：

  • while可自定义循环条件，并自行控制

  • for循环不可自定义循环条件，只能从容器中一个个取出数据

无限循环：

  • while循环可通过相应的条件使条件控制无限循环

  • for循环不可通过相应的条件使条件控制无限循环，因为被遍历的容器容量不是无限的

使用场景：

  • while循环适用于任意想要循环的场景

  • for循环适用于遍历数据容器的场景或者是简单的固定循环次数的场景

6.2 元组

作用：可以封装多个、不同类型的元素在内，一旦定义成功，就不可修改。

语法结构：

# 定义元组字面量
(元素, 元素, 元素, ...., 元素)
# 定义元组变量
变量名称 = (元素, 元素, ...., 元素)
# 定义空元组
变量名称 = ()       #方式1
变量名称 = touple() #方式2

# 定义元组
t1 = (123, "he", False)
t2 = ()
t3 = tuple()
print(f"t1的数据类型是：{type(t1)}，内容是：{t1}")
print(f"t2的数据类型是：{type(t2)}，内容是：{t2}")
print(f"t3的数据类型是：{type(t3)}，内容是：{t3}")

# 定义1个元素的元组
t4 = ("he", )
print(f"t4的数据类型是：{type(t4)}，内容是：{t4}")

# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的数据类型是：{type(t5)}，内容是：{t5}")

# 通过下标索引取出元组中的元素
num = t5[0][1]
print(f"num从t5[0][1]中取出的元素是{num}")

在这里插入图片描述

6.2.1元组相关操作

  • 查找方法：index

  • 统计方法：count

  • 统计元组元素数量：len

# 查找方法
t1 = ("he", "l", "l", "0", "!")
index = t1.index("0")
print(f"t1元组中的元素o的下标是：{index}")

# 统计方法
t2 = ("he", "l", "l", "l", "o", "!")
num = t2.count("l")
print(f"t2元组中的元素l的数量有：{num}")

# 统计元组元素数量
t3 = ("he", "l", "l", "o", "!")
num = len(t3)
print(f"t3元组的元素的数量有：{num}")

在这里插入图片描述

总结：
1index(元素)查找某个数据对应的下标，不存在就报错
2count(元素)统计某个数据在当前元组所出现的次数
3len(元组)统计元组内元素的数量
6.2.2 元组的遍历 — while循环
t1 = ("he", "l", "l", "0", "!")
index = 0
while index < len(t1):
    element = t1[index]
    print(f"元组t1的元素有：{element}")
    index += 1

在这里插入图片描述

6.2.3 元组的遍历 — for循环
t1 = ("he", "l", "l", "0", "!")
index = 0
for element in t1:
    print(f"元组t1的元素有：{element}")

在这里插入图片描述

6.2.4 注意事项
  • 不可修改元组的内容，否则直接报错
t1 = (1, 2, 3, 4, 5)
t1[0] = 6 #报错TypeError: 'tuple' object does not support item assignment
  • 可修改元组内list的内容
t1 = (1, 2, 3, ["he", "ha"])
t1[3][1] = "llo"
print(f"修改后的内容为：{t1}") # 修改后的内容为：(1, 2, 3, ['he', 'llo'])
6.2.5 元组的特点

  • 可容纳多个数据

  • 可容纳不同类型的数据

  • 数据有序存储

  • 允许重复数据存在

  • 不可修改

  • 支持for循环

6.3 字符串
6.3.1 下标索引

  • 从前向后，下标从0开始

  • 从后向前，下标从-1开始

name_str = "hello"
print(name_str[0])  # h
print(name_str[-1]) # o

# 修改数据
name_str[0] = "l"  # 报错：TypeError: 'str' object does not support item assignment
6.3.2 常用操作
查找特定字符串的下标索引值

语法结构：字符串.index(字符串)

names_str = "Hello"
print(names_str.index("o")) # 4
字符串的替换

语法结构：字符串.replace(字符串1, 字符串2)

作用：字符串1替换字符串2，字符串内的全部。

字符串的分割

语法结构：字符串.split(分隔符字符串)

作用：按指定的分隔符字符串，划分为多个字符串存入列表对象中。

字符串的规整操作
  • 去前后空格

语法结构：字符串.strip()

name_str = " he l l o  "
print(name_str.strip()) # "he l l o"
  • 去前后指定字符串

语法结构：字符串.strip(字符串)

name_str = "hellooeh"
print(name_str.strip('he')) # "llo"

传入的是”he“,其实"h"和"e"都会被移除，按照单个字符。

统计某字符串中某字符串出现的次数

语法结构：字符串.count(字符串)

name_str = "hello"
count = name_str.count("l")
print(f"l在字符串{name_str}中出现的次数是{count}") # l在字符串hello中出现的次数是2
统计字符串的字符个数

语法结构：len(字符串)

num = len(name_str)
print(f"字符串{name_str}的长度是：{num}") # 字符串hello的长度是：5
总结：
1字符串[下标]据下标索引取出特定位置的字符
2字符串.index(字符串)查找特定字符串的下标索引值
3字符串.replace(字符串1, 字符串2)字符串1替换字符串2，字符串内的全部。
4字符串.split(分隔符字符串)按指定的分隔符字符串，划分为多个字符串存入列表对象中。
5字符串.strip() 字符串.strip(字符串)移除首尾的空格或指定字符串
6字符串.count(字符串)统计某字符串中某字符串出现的次数
7len(字符串)统计字符串的字符个数
6.3.3 字符串的遍历 - while循环
str = "hello"
index = 0
while index < len(str):
    print(str[index])
    index += 1
6.3.4 字符串的遍历 - for循环
str = "hello"
index = 0
for i in str:
    print(i)
6.3.5 特点

  • 只可存储字符串

  • 长度任意

  • 支持下标索引

  • 允许重复字符串存在

  • 不可修改

  • 支持for循环

6.4 序列

定义：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串均可视为序列。

6.4.1 序列常用操作 - 切片

切片：从一个序列中，取出一个子序列。

语法结构：序列[起始下标:结束下标:步长]

说明：从序列中，从指定位置开始，依次取出元素，到指定位置时结束，得到一个新序列。

  • 起始下标表示的是从哪开始，可以留空，留空视为从头开始

  • 结束下标表示从哪结束，可以留空，留空视为到结尾结束

  • 步长表示，依次取出元素的间隔，如步长1表示一个个取出元素，步长2表示每次跳过一个元素取，步长为负数时，反向取元素。

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret1 = num_list[1:5]   # 步长可省略不写，默认为1
print(f"结果1为{ret1}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret2 = num_list[:]
print(f"结果2为{ret2}")

num_str = "12345678910"
ret3 = num_list[::2]
print(f"结果3为{ret3}")

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret4 = num_list[::-1]   # 步长可省略不写，默认为1
print(f"结果4为{ret4}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret5 = num_list[3:1:-1]
print(f"结果5为{ret5}")

num_str = "12345678910"
ret6 = num_str[::-2]
print(f"结果6为{ret6}")

在这里插入图片描述

6.5 集合

集合是无序的，不支持下标索引访问。

语法结构：

# 定义集合字面量
{元素1, 元素2, ....元素n}
# 定义集合变量
变量名 = {元素1, 元素2, ....元素n}
# 定义空集合
变量名 = set()

my_set = {"ha", "he", "he"}
my_set_empty = set()
print(f"my_set的内容是{my_set}, 类型是{type(my_set)}")
print(f"my_set_empty的内容是{my_set_empty}, 类型是{type(my_set_empty)}")

在这里插入图片描述

6.5.1 常用操作
添加新元素

语法结构：集合.add(元素)

结果：将指定元素添加到集合内，集合本身被修改，添加了新元素。

my_set = {"hello", "world"}
my_set.add("hahe")
print(f"my_set添加元素后的结果是{my_set}") # my_set添加元素后的结果是{'hahe', 'hello', 'world'}
移除元素

语法结构：j集合.remove(元素)

**结果：**将指定元素从集合内移除，集合本身被修改，移除了元素。

my_set = {"hello", "world"}
my_set.remove("hello")
print(f"my_set移除元素后的结果是{my_set}") # my_set移除元素后的结果是{'world'}
从集合中随机取出元素

语法结构：集合.pop()

结果：从集合中随机取出一个元素，会得到一个元素的结果，集合本身被修改，元素被移除。

my_set = {"hello", "world"}
element = my_set.pop()
print(f"my_set被随机移除{element}后结果是{my_set}") # my_set被随机移除world后结果是{'hello'}
清空集合

语法结构：集合.clear()

结果：清空集合，集合本身被清空。

my_set = {"hello", "world"}
my_set.clear()
print(f"my_set被清空后的结果是{my_set}") # my_set移除元素后的结果是{'world'} # my_set被清空后的结果是set()
取出2个集合的差集

语法结构：集合1.difference(集合2)

结果：取出集合1和集合2的差集(集合1有集合2没有的元素)，得到一个新集合，集合1和集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set3 = set1.difference(set2)
print(set1) # {1, 3, 4}
print(set2) # {1, 2, 3}
print(set3) # {4}
消除2个集合的差集(交集)

语法结构：集合1.difference_update(集合2)

结果：在集合1中，删除和集合2相同的元素，集合1被修改，集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set1.difference_update(set2)
print(set1) # {4}
print(set2) # {1, 2, 3}
2个集合合并

语法结构：集合1.union(集合2)

结果：将集合1和集合2组合成新集合，得到一个新集合，集合1和集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set3 = set1.union((set2))
print(set1) # {1, 3, 4}
print(set2) # {1, 2, 3}
print(set3) # {1, 2, 3, 4}
统计集合元素数量

语法结构：len(集合)

set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
num = len(set1)
print(f"set1统计集合元素数量是{num}") # set1统计集合元素数量是10
集合的遍历

语法结构：for 临时变量 in 集合:{}

# 集合不支持下标索引，所以不能使用while循环
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
for element in set1:
    print(f"set1中的元素有{element}")
总结：
编号操作功能
1集合.add(元素)集合内添加一个元素
2集合.remove(元素)移集合内指定的元素
3集合.pop()从集合中随机取出一个元素
4集合.clear()集合清空
5集合1.difference(集合2)取出集合1和集合2的差集(集合1有集合2没有的元素)，得到一个新集合，集合1和集合2不变。
6集合1.difference_update(集合2)在集合1中，删除和集合2相同的元素，集合1被修改，集合2不变。
7集合1.union(集合2)2个集合合并，得到1个新集合，原有的2个集合不变。
8len(集合)统计集合元素数量
6.5.2 特点

  • 可容纳多个数据

  • 可容纳不同类型的数据

  • 数据是无序存储的

  • 不允许重复数据存在

  • 可修改

  • 支持for循环

6.6 字典
6.6.1 定义

作用：可通过Key，取到对应的Value。

语法结构：

# 定义字典字面量
{key: value, key: value, .......,key: value}
# 定义字典常量
my_dict = {key: value, key: value, ......, key: value}
# 定义空字典
my_dict = {}
my_dict = dict()

my_dict1 = {"小明": 18, "小红": 19, "小王": 20}
my_dict2 = {}
my_dict3 = dict()
print(f"mydict1字典的内容是{my_dict1},类型是{type(my_dict1)}")
print(f"mydict2字典的内容是{my_dict2},类型是{type(my_dict2)}")
print(f"mydict3字典的内容是{my_dict3},类型是{type(my_dict3)}")

# 重复Key的字典
my_dict4 = {"小明": 18, "小明": 20, "小红": 19}
print(f"重复Key的my_dict4的内容是{my_dict4}")

在这里插入图片描述

数据的获取

语法结构：字典[Key]

my_dict = {"小明": 18, "小红": 19, "小王": 20}
print(my_dict["小明"]) # 18
print(my_dict["小红"]) # 19
print(my_dict["小王"]) # 20
嵌套

字典中的Key和Value可以是任意数据类型，Key不可为字典。

score_dict = {"小明": {"语文": 80, "数学": 90, "英语": 81},
             "小红": {"语文": 85, "数学": 88, "英语": 83},
             "小王": {"语文": 87, "数学": 80, "英语": 87}}
print(f"考试信息是：{score_dict}")
Xiaohong_English_score = score_dict["小红"]["英语"]
print(f"小红的英语成绩是{Xiaohong_English_score}")

在这里插入图片描述

6.6.2 常用操作
新增元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小李"] = 84
print(student_score) # {'小明': 80, '小红': 90, '小王': 88, '小李': 84}
更新元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小明"] = 84
print(student_score) # {'小明': 84, '小红': 90, '小王': 88}
删除元素

语法结构：字典.pop(Key)

student_score = {"小明": 80, "小红": 90, "小王": 88}
delete_score = student_score.pop("小明")
print(delete_score)  # 80
print(student_score) # {'小红': 90, '小王': 88}
清空字典

语法结构：字典.clear()

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score.clear()
print(student_score) # {}
获取全部的Key

语法结构：字典.Keys()

student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
print(obtain_value) # dict_keys(['小明', '小红', '小王'])
字典的遍历
student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
for key in obtain_value:
    print(f"Key：{key}")
    print(f"Value：{student_score[key]}")
# Key：小明
# Value：80
# Key：小红
# Value：90
# Key：小王
# Value：88
统计字典内的元素数量

语法结构：len(字典)

student_score = {"小明": 80, "小红": 90, "小王": 88}
num = len(student_score )
print(num) # 3

总结：

编号操作说明
1字典[Key] = Value新增元素
2字典[Key] = Value更新元素
3字典.pop(Key)删除元素
4字典.clear()清空字典
5字典.Keys()获取字典内全部的Key
6len(字典)统计字典内的元素数量
6.6.3 特点

  • 可容纳多个数据

  • 可容纳多个不同类型的数据

  • 每份数据是Key与Value值对应

  • 可通过Key去获取Value，Key不可重复

  • 不支持下标索引

  • 可修改

  • 支持for循环

6.7 数据容器分类

是否支持下标索引：

  • 支持：列表、元组、字符串 - 序列类型

  • 不支持：集合、字典 - 非序列类型

是否支持重复元素：

  • 支持：列表、元组、字符串 - 序列类型

  • 不支持：集合、字典 - 非序列类型

是否可修改：

  • 支持：列表、集合、字典

  • 不支持：元组、字符串

6.7.1 总结
特点列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意Key：除字典外任意类型 Value：任意
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改、可重复的一批数据不可修改、可重复的一批数据一串字符不可重复的数据以Key检索Value的数据
6.8 数据容器的通用操作
6.8.1 遍历

5类数据容器都支持for循环遍历。列表、元组、字符串支持while循环，集合、字典不支持。

6.8.2 统计容器的元素个数

语法结构：len(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(len(my_list))  # 10
print(len(my_tuple)) # 5
print(len(my_str))   # 5
print(len(my_set))   # 5
print(len(my_dict))  # 3
6.8.3 统计容器的最大元素

语法结构：max(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(max(my_list))  # 10
print(max(my_tuple)) # 5
print(max(my_str))   # o
print(max(my_set))   # 5
print(max(my_dict))  # key3
6.8.4 统计容器的最小元素

语法结构：min(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(min(my_list))  # 1
print(min(my_tuple)) # 1
print(min(my_str))   # e
print(min(my_set))   # 1
print(min(my_dict))  # key1
6.9数据容器的通用转换功能
6.9.1 给定容器转换为列表

语法结构：list(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转列表：{list(my_list)}")
print(f"元组转列表：{list(my_tuple)}")
print(f"字符串转列表：{list(my_str)}")
print(f"集合转列表：{list(my_set)}")
print(f"字典转列表：{list(my_dict)}")

在这里插入图片描述

6.9.2 给定容器转换为字符串

语法结构：str(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转字符串：{str(my_list)}")
print(f"元组转字符串：{str(my_tuple)}")
print(f"字符串转字符串：{str(my_str)}")
print(f"集合转字符串：{str(my_set)}")
print(f"字典转字符串：{str(my_dict)}")

在这里插入图片描述

6.9.3 给定容器转换为元组

语法结构：tuple(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转元组：{tuple(my_list)}")
print(f"元组转元组：{tuple(my_tuple)}")
print(f"字符串转元组：{tuple(my_str)}")
print(f"集合转元组：{tuple(my_set)}")
print(f"字典转元组：{tuple(my_dict)}")

在这里插入图片描述

6.9.4 给定容器转换为集合

语法结构：set(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转集合：{set(my_list)}")
print(f"元组转集合：{set(my_tuple)}")
print(f"字符串转集合：{set(my_str)}")
print(f"集合转集合：{set(my_set)}")
print(f"字典转集合：{set(my_dict)}")

在这里插入图片描述

6.10 数据容器的通用排序功能

语法结构：sorted(容器, [reverse=True])

my_list = [7, 5, 9, 4, 2, 6, 1, 10, 3, 8]
my_tuple = (3, 5, 1, 4, 3)
my_str = "afedcb"
my_set =  {5, 3, 2, 4, 1}
my_dict = {"key3": 1, "key2": 2, "key1": 3}
print(f"列表排序后：{sorted(my_list)}")
print(f"元组排序后：{sorted(my_tuple)}")
print(f"字符串排序后：{sorted(my_str)}")
print(f"集合排序后：{sorted(my_set)}")
print(f"字典排序后：{sorted(my_dict)}")

在这里插入图片描述

my_list = [7, 5, 9, 4, 2, 6, 1, 10, 3, 8]
my_tuple = (3, 5, 1, 4, 3)
my_str = "afedcb"
my_set =  {5, 3, 2, 4, 1}
my_dict = {"key3": 1, "key2": 2, "key1": 3}
print(f"列表反向排序后：{sorted(my_list, reverse = True)}")
print(f"元组反向排序后：{sorted(my_tuple,reverse = True)}")
print(f"字符串反向排序后：{sorted(my_str,reverse = True)}")
print(f"集合反向排序后：{sorted(my_set,reverse = True)}")
print(f"字典反向排序后：{sorted(my_dict,reverse = True)}")

在这里插入图片描述

6.11 通用功能总结
功能描述
for循环遍历容器
len(容器)统计容器的元素个数
max(容器)统计容器的最大元素
min(容器)统计容器的最小元素
list(容器)给定容器转换为列表
str(容器)给定容器转换为字符串
tuple(容器)给定容器转换为元组
set(容器)给定容器转换为集合
sorted(容器, [reverse=True])排序

下一章：Python基础入门 — 5.函数

子期cod
关注
  • 53
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Python安全攻防-从入门到入狱
Yasso的博客
01-31 1万+
Python安全攻防-从入门到入狱
Python-100-Days-master.zip
03-17
1. **Python基础知识**：这是入门阶段，学习者会接触到Python的基本语法，如变量、数据类型（整型、浮点型、字符串、布尔型等）、运算符、流程控制（条件语句、循环语句）以及函数的定义与调用。 2. **列表、元组、...
Python进阶编程 --- 2.MySQL、pymysql、PySpark
zhongziqia的博客
04-15 1709
SQL：结构化查询语言，用于访问和处理数据库的标准的计算机语言。
python入门容器-元组tuple Day05
LOVE_Me__的博客
01-27 1438
元组 tuple 定义 由一系列变量组成的不可变序列容器。 不可变是指一但创建，不可以再添加/删除/修改元素。 基础操作 创建空元组： 元组名 = () 元组名 = tuple() 创建非空元组： 元组名 = (20,) 元组名 = (1, 2, 3) 元组名 = 100,200,300 元组名 = tuple(可迭代对象) #1.创建 # 语法1：元组名 = （元素1，元素2）...
2.Python从入门到精通—Python 基础语法详细讲解-上
热门推荐
Java 技术专栏，从入门到精通，熟悉企业级开发
05-06 1万+
在Python中，变量是用来存储数据的容器。Python不需要声明变量的类型，变量的类型是根据所赋的值自动推导出来的。
Python入门--列表的创建
周周的博客
02-09 1222
#为什么需要列表 #变量可以存储一个元素，而列表是一个‘大容器’可以以存储N多个元素，程序可以方便的对这些数据进行整体操作 #列表相当于其他语言中的数组 #列表字符串，整数，浮点数等等都可以放一起，可以存储不同的数据类型，而且可以存储多个 #类似于书包（列表）里可以放书，电脑，笔等等 #################################################################################### lst=['hello','world',98] pr.
编程语言python入门-Python基础教程 - 全文
q6q6q的专栏
10-28 2381
本章将介绍Python的最基本语法，以及一些和深度学习还有计算机视觉最相关的基本使用。Python简介Python是一门解释型的高级编程语言，特点是简单明确。Python作者是荷兰人Guido van Rossum，1982年他获得数学和计算机硕士学位后，在荷兰数学与计算科学研究所（Centrum Wiskunde & InformaTIca, CWI）谋了份差事。在CWI期间，Guido参与到了...
Python教程笔记----6小时完全入门
Echo_165的博客
11-13 2651
掌握基本的Python环境搭建和基础语法规则
Python基础学习-简要记录
watson_pillow的博客
02-22 3097
python入门
【零基础入门学习Python---Python的五大数据类型之字典类型】
Coder_ljw的博客
06-25 3099
【零基础入门学习Python---Python的五大数据类型之字典类型】字典的键必须是唯一的，而值则可以是任意类型的对象，如字符串、数字、列表、元组等。字典的键是不可变类型，如字符串、数字、元组，而列表等可变类型则不能作为键。字典的实现是通过哈希表实现的，因此查找、插入和删除操作的时间复杂度都是O(1)。总的来说，Python中的字典类型是一种非常有用的数据类型，可以用来存储键值对，其基本用法和列表、元组等数据类型类似，但是字典的键值对是无序的，且键必须是不可变类型。字典类型的基本用法包括创建字典
Python基础详解教程------目录大纲
Python基础详解教程，让编程变得简单！
11-13 1080
Python基础详解教程的目录大纲，列举了编程中常用的知识点。
PyPI 官网下载 | python-ioc-0.1.17.tar.gz
01-15
基于标签 "Python库"，我们可以推测"python-ioc-0.1.17"是一个Python实现的Inversion of Control容器或者依赖注入框架。依赖注入是一种编程范式，它允许程序在运行时动态地将依赖关系注入到对象中，而不是由对象自行...
python入门教程-python入门神图一张.pdf
06-11
【Python入门教程】 Python是一种广泛使用的高级编程语言，以其简洁明了的语法和强大的功能深受程序员喜爱。本文档提供了一张Python入门神图，旨在帮助初学者在短时间内快速掌握Python的基本概念。以下是对其中关键...
PyPI 官网下载 | tencentcloud-sdk-python-tke-3.0.459.tar.gz
02-13
6. **README**：通常包含SDK的基本介绍、安装方法、快速入门等内容，是初学者的向导。 安装这个SDK，可以通过Python的`pip`工具，命令如下： ```bash pip install tencentcloud-sdk-python-tke==3.0.459 ``` 安装...
Python-程序设计快速入门教学.docx
07-20
#### 三、Python 数据类型与容器 1. **列表(List)**：有序的元素集合，元素可以是不同类型的，并且支持修改。 - 示例：`my_list = [1, "two", 3.0]` 2. **元组(Tuple)**：有序不可变的元素集合。 - 示例：`my_...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
最新发布
qq_64603703的博客
07-27 661
详细解说数据分析pandas库中的常用方法
随机数种子的作用
帆的博客
07-23 1306
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 772
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 480
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
大数据分析入门：Python与IPython-Jupyter实战
"本资源是一份关于大数据分析入门的教程，重点讲解了使用Python作为数据分析语言的基础知识，包括科学计算库Numpy、Scipy、Pandas，以及绘图工具Matplotlib，同时深入介绍了数据分析环境Ipython和Jupyter的使用。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值