Python数据结构详解：字典、列表、元组、集合与字符串的使用

已于 2025-03-20 10:27:43 修改
阅读量1.1k 收藏 12
点赞数 10
文章标签： python 开发语言
于 2025-03-20 10:09:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_77248325/article/details/146388589
版权

在Python编程中，掌握各种数据结构的使用方法是至关重要的。本文将详细介绍字典、列表、元组、集合和字符串的创建方式、实例应用、特点以及它们之间的区别，帮助你在实际开发中更高效地选择和使用这些数据结构。

一、列表（list）

（一）创建方式

列表是Python中最常用的数据结构之一，它是一个有序的元素序列，可以包含不同类型的元素。创建列表非常简单，只需要将元素用方括号[]括起来，并用逗号分隔即可。如果要创建一个空列表，只需写空列表 = []。

# 创建一个包含多种类型元素的列表
mixed_list = [1, "hello", 3.14, True]
# 创建一个空列表
empty_list = []

（二）特点

列表具有以下特点：

  1. 有序：列表中的元素是有顺序的，可以通过索引来访问特定位置的元素。

  2. 可变：列表的大小和内容可以随时修改，例如添加、删除或修改元素。

  3. 允许重复：列表中可以有重复的元素。

  4. 类型灵活：列表中的元素可以是不同数据类型。

（三）列表的常见方法

方法名说明参数说明返回值示例代码及输出
列表.append(元素)向列表中追加一个元素元素：要添加的元素Nonefruits = ["apple", "banana"]\<br>fruits.append("cherry")<br>print(fruits) 输出：["apple", "banana", "cherry"]
列表.extend(容器)将数据容器的内容依次取出，追加到列表尾部容器：可迭代对象（如列表、元组等）Nonefruits = ["apple", "banana"]<br>fruits.extend(["cherry", "orange"])<br>print(fruits) 输出：["apple", "banana", "cherry", "orange"]
列表.insert(下标, 元素)在指定下标处，插入指定的元素下标：插入位置索引<br>元素：要插入的元素Nonefruits = ["apple", "banana"]<br>fruits.insert(1, "cherry")<br>print(fruits) 输出：["apple", "cherry", "banana"]
del 列表[下标]删除列表指定下标元素下标：要删除元素的索引Nonefruits = ["apple", "banana", "cherry"]<br>del fruits[1]<br>print(fruits) 输出：["apple", "cherry"]
列表.pop(下标)删除列表指定下标元素下标：要删除元素的索引（可选，默认为最后一个元素）被删除的元素fruits = ["apple", "banana", "cherry"]<br>popped = fruits.pop(1)<br>print(fruits) 输出：["apple", "cherry"]<br>print(popped) 输出：banana
列表.remove(元素)从前向后，删除此元素第一个匹配项元素：要删除的元素Nonefruits = ["apple", "banana", "apple"]<br>fruits.remove("apple")<br>print(fruits) 输出：["banana", "apple"]
列表.clear()清空列表无Nonefruits = ["apple", "banana", "cherry"]<br>fruits.clear()<br>print(fruits) 输出：[]
列表.count(元素)统计此元素在列表中出现的次数元素：要统计的元素出现次数fruits = ["apple", "banana", "apple"]<br>count = fruits.count("apple")<br>print(count) 输出：2
列表.index(元素)查找指定元素在列表的下标，找不到报错ValueError元素：要查找的元素下标fruits = ["apple", "banana", "cherry"]<br>index = fruits.index("banana")<br>print(index) 输出：1
len(列表)统计容器内有多少元素列表：要统计的列表元素数量fruits = ["apple", "banana", "cherry"]<br>length = len(fruits)<br>print(length) 输出：3

（四）实例应用

列表适用于需要频繁修改和访问元素的场景，比如存储一组数据并进行排序、筛选等操作。

# 访问列表元素
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # 输出：apple

# 修改列表元素
fruits[1] = "orange"
print(fruits)  # 输出：['apple', 'orange', 'cherry']

# 添加元素到列表
fruits.append("grape")
print(fruits)  # 输出：['apple', 'orange', 'cherry', 'grape']

# 删除列表元素
del fruits[0]
print(fruits)  # 输出：['orange', 'cherry', 'grape']

# 列表切片
print(fruits[1:3])  # 输出：['cherry', 'grape']

# 遍历列表
for fruit in fruits:
    print(fruit)

# 列表排序
numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
print(numbers)  # 输出：[1, 1, 2, 3, 4, 5, 9]

# 列表长度
print(len(numbers))  # 输出：7

二、元组（tuple）

（一）创建方式

元组与列表类似，也是一个有序的元素序列，但元组是不可变的。创建元组时，将元素用圆括号()括起来，元素之间用逗号分隔。空元组的创建方式是空元组 = ()。

# 创建一个元组
coordinates = (3, 5)
# 创建一个空元组
empty_tuple = ()

（二）特点

元组的特点包括：

  1. 有序：可以通过索引来访问元素。

  2. 不可变：元组的大小和内容一旦创建就不能修改。

  3. 元素可为不同数据类型。

（三）元组的常见操作

操作名说明参数说明返回值示例代码及输出
元组[下标]根据下标访问元组中的元素下标：元素的位置索引元素值t = (1, 2, 3)<br>print(t[1]) 输出：2
元组.index(元素)查找元素在元组中的索引位置，若不存在则报错ValueError元素：要查找的元素索引值t = (1, 2, 3)<br>print(t.index(2)) 输出：1
元组.count(元素)统计元素在元组中出现的次数元素：要统计的元素出现次数t = (1, 2, 2, 3)<br>print(t.count(2)) 输出：2
len(元组)获取元组中元素的数量元组：要获取长度的元组元素数量t = (1, 2, 3)<br>print(len(t)) 输出：3
元组 + 元组将两个元组连接成一个新的元组另一个元组新元组t1 = (1, 2)<br>t2 = (3, 4)<br>t3 = t1 + t2<br>print(t3) 输出：(1, 2, 3, 4)
元组 * 倍数将元组重复指定倍数生成一个新的元组倍数：整数新元组t = (1, 2)<br>print(t * 3) 输出：(1, 2, 1, 2, 1, 2)
元组[起始:结束:步长]对元组进行切片操作，获取指定范围的元素起始：起始索引（可选）<br>结束：结束索引（可选）<br>步长：步长值（可选）新元组t = (0, 1, 2, 3, 4)<br>print(t[1:4]) 输出：(1, 2, 3)<br>print(t[::2]) 输出：(0, 2, 4)

（四）实例应用

元组适用于存储一组固定不变的数据，比如坐标点、日期等。

# 访问元组元素
print(coordinates[0])  # 输出：3

# 元组解包
x, y = coordinates
print(x, y)  # 输出：3 5

# 遍历元组
for num in coordinates:
    print(num)

# 元组长度
print(len(coordinates))  # 输出：2

三、字典（dict）

（一）创建方式

字典是一个无序的键值对集合，每个键值对由冒号:分隔，整个字典用大括号{}括起来。创建空字典的方式是空字典 = {}。

# 创建一个字典
person = {"name": "Alice", "age": 25, "city": "New York"}
# 创建一个空字典
empty_dict = {}

（二）特点

字典具有以下特点：

  1. 无序：字典中的键值对没有固定的顺序。

  2. 可变：可以随时添加、删除或修改键值对。

  3. 键唯一：每个键在字典中必须是唯一的。

  4. 键不可变：键必须是不可变类型，如字符串、数字或元组。

（三）字典的常见方法

方法名说明参数说明返回值示例代码及输出
字典.keys()获取字典中所有键无视图对象（可迭代）person = {"name": "Alice", "age": 25}<br>keys = person.keys()<br>print(list(keys)) 输出：['name', 'age']
字典.values()获取字典中所有值无视图对象（可迭代）person = {"name": "Alice", "age": 25}<br>values = person.values()<br>print(list(values)) 输出：['Alice', 25]
字典.items()获取字典中所有的键值对无视图对象（可迭代）person = {"name": "Alice", "age": 25}<br>items = person.items()<br>print(list(items)) 输出：[('name', 'Alice'), ('age', 25)]
字典.get(键, 默认值)获取指定键的值，如果键不存在，返回默认值键：要查找的键<br>默认值：键不存在时返回的值（可选）键对应的值或默认值person = {"name": "Alice"}<br>age = person.get("age", 0)<br>print(age) 输出：0
字典.pop(键)删除并返回指定键的值键：要删除的键被删除的值person = {"name": "Alice", "age": 25}<br>age = person.pop("age")<br>print(age) 输出：25<br>print(person) 输出：{"name": "Alice"}
字典.popitem()删除并返回字典中的最后一个键值对无被删除的键值对person = {"name": "Alice", "age": 25}<br>item = person.popitem()<br>print(item) 输出：("age", 25)<br>print(person) 输出：{"name": "Alice"}
字典.update(其他字典)将其他字典的键值对更新到当前字典中其他字典：要合并的字典Noneperson = {"name": "Alice"}<br>person.update({"age": 25})<br>print(person) 输出：{"name": "Alice", "age": 25}
字典.setdefault(键, 默认值)如果键存在，返回其值；否则插入键并设置为默认值键：要查找的键<br>默认值：键不存在时设置的值（可选）键对应的值或默认值person = {"name": "Alice"}<br>age = person.setdefault("age", 25)<br>print(age) 输出：25<br>print(person) 输出：{"name": "Alice", "age": 25}
字典.clear()清空字典无Noneperson = {"name": "Alice", "age": 25}<br>person.clear()<br>print(person) 输出：{}

（四）实例应用

字典常用于根据键快速查找对应的值，比如存储用户信息、配置参数等。

# 访问字典值
print(person["name"])  # 输出：Alice

# 添加键值对
person["email"] = "alice@example.com"
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

# 修改字典值
person["age"] = 26
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

# 删除键值对
del person["city"]
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}

# 遍历字典
for key in person:
    print(key, person[key])

# 获取字典的键、值和键值对
print(person.keys())   # 输出：dict_keys(['name', 'age', 'email'])
print(person.values()) # 输出：dict_values(['Alice', 26, 'alice@example.com'])
print(person.items())  # 输出：dict_items([('name', 'Alice'), ('age', 26), ('email', 'alice@example.com')])

四、集合（set）

（一）创建方式

集合是一个无序且不重复的元素集合，用于存储唯一的元素。创建集合时，将元素用大括号{}括起来，或者使用set()函数。创建空集合必须使用空集合 = set()，因为{}会被识别为空字典。

# 创建一个集合
unique_numbers = {1, 2, 3, 4, 5}
# 创建一个空集合
empty_set = set()

（二）特点

集合的特点包括：

  1. 无序：元素没有固定的顺序。

  2. 不可重复：集合中的元素是唯一的。

  3. 可变：可以添加或删除元素。

（三）集合的常见方法

方法名说明参数说明返回值示例代码及输出
集合.add(元素)集合内添加一个元素元素：要添加的元素Nones = {1, 2}<br>s.add(3)<br>print(s) 输出：{1, 2, 3}
集合.remove(元素)移除集合内指定的元素元素：要移除的元素Nones = {1, 2, 3}<br>s.remove(2)<br>print(s) 输出：{1, 3}
集合.discard(元素)移除集合内指定的元素，若元素不存在，不报错元素：要移除的元素Nones = {1, 2, 3}<br>s.discard(4)<br>print(s) 输出：{1, 2, 3}
集合.pop()从集合中随机取出一个元素无被取出的元素s = {1, 2, 3}<br>popped = s.pop()<br>print(popped) 输出：1（可能因集合无序而不同）<br>print(s) 输出：{2, 3}
集合.clear()将集合清空无Nones = {1, 2, 3}<br>s.clear()<br>print(s) 输出：set()
集合1.difference(集合2)得到一个新集合，内含2个集合的差集，原有的2个集合内容不变集合2：另一个集合新集合s1 = {1, 2, 3}<br>s2 = {3, 4, 5}<br>diff = s1.difference(s2)<br>print(diff) 输出：{1, 2}
集合1.difference_update(集合2)在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变集合2：另一个集合Nones1 = {1, 2, 3}<br>s2 = {3, 4, 5}<br>s1.difference_update(s2)<br>print(s1) 输出：{1, 2}
集合1.union(集合2)得到一个新集合，内含2个集合的全部元素，原有的2个集合内容不变集合2：另一个集合新集合s1 = {1, 2}<br>s2 = {3, 4}<br>union = s1.union(s2)<br>print(union) 输出：{1, 2, 3, 4}
集合1.update(集合2)将集合2的元素添加到集合1中，集合1被修改，集合2不变集合2：另一个集合Nones1 = {1, 2}<br>s2 = {3, 4}<br>s1.update(s2)<br>print(s1) 输出：{1, 2, 3, 4}
集合1.intersection(集合2)得到一个新集合，内含2个集合的共有元素，原有的2个集合内容不变集合2：另一个集合新集合s1 = {1, 2, 3}<br>s2 = {3, 4, 5}<br>inter = s1.intersection(s2)<br>print(inter) 输出：{3}
集合1.intersection_update(集合2)修改集合1，保留集合2中存在的元素，集合1被修改，集合2不变集合2：另一个集合Nones1 = {1, 2, 3}<br>s2 = {3, 4, 5}<br>s1.intersection_update(s2)<br>print(s1) 输出：{3}
集合1.issubset(集合2)判断集合1是否是集合2的子集集合2：另一个集合布尔值（是返回True，否返回False）s1 = {1, 2}<br>s2 = {1, 2, 3}<br>is_sub = s1.issubset(s2)<br>print(is_sub) 输出：True
集合1.issuperset(集合2)判断集合1是否是集合2的超集集合2：另一个集合布尔值（是返回True，否返回False）s1 = {1, 2, 3}<br>s2 = {1, 2}<br>is_super = s1.issuperset(s2)<br>print(is_super) 输出：True
len(集合)统计集合内有多少元素集合：要统计的集合元素数量s = {1, 2, 3}<br>length = len(s)<br>print(length) 输出：3

（四）实例应用

集合适用于需要去重或进行集合运算（如交集、并集）的场景。

# 添加元素到集合
unique_numbers.add(6)
print(unique_numbers)  # 输出：{1, 2, 3, 4, 5, 6}

# 删除集合元素
unique_numbers.remove(1)
print(unique_numbers)  # 输出：{2, 3, 4, 5, 6}

# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))        # 输出：{1, 2, 3, 4, 5}（并集）
print(set1.intersection(set2)) # 输出：{3}（交集）
print(set1.difference(set2))   # 输出：{1, 2}（差集）

# 遍历集合
for num in unique_numbers:
    print(num)

# 集合长度
print(len(unique_numbers))  # 输出：5

五、字符串（str）

（一）创建方式

字符串是由字符组成的序列，用于表示文本数据。创建字符串时，可以用单引号''、双引号""或三引号''' '''（用于多行字符串）。空字符串的创建方式是空字符串 = ""。

# 创建字符串
greeting = "Hello, World!"
# 创建多行字符串
multi_line = """This is a
multi-line string."""
# 创建空字符串
empty_str = ""

（二）特点

字符串的特点：

  1. 不可变：字符串一旦创建，内容不能修改，但可以基于原字符串创建新字符串。

  2. 有序：可以通过索引访问特定位置的字符。

  3. 支持多种编码：如ASCII、Unicode等。

（三）字符串的常见方法

方法名说明参数说明返回值示例代码及输出
字符串[下标]根据下标索引取出特定位置字符下标：字符位置索引字符s = "hello"<br>print(s[1]) 输出：e
字符串.index(子字符串)查找子字符串在字符串中的第一个匹配项的起始下标，找不到报错ValueError子字符串：要查找的字符串下标s = "hello"<br>index = s.index("l")<br>print(index) 输出：2
字符串.find(子字符串)查找子字符串在字符串中的第一个匹配项的起始下标，找不到返回-1子字符串：要查找的字符串下标或-1s = "hello"<br>index = s.find("x")<br>print(index) 输出：-1
字符串.replace(旧子字符串, 新子字符串)将字符串内的全部旧子字符串替换为新子字符串，不会修改原字符串，而是得到一个新的字符串旧子字符串：要被替换的字符串<br>新子字符串：替换后的字符串新字符串s = "hello"<br>new_s = s.replace("l", "x")<br>print(new_s) 输出：hexo<br>print(s) 输出：hello
字符串.split(分隔符)按照分隔符将字符串分割成多个子字符串，返回一个列表，不会修改原字符串，而是得到一个新的列表分隔符：分割的依据（默认为空格）列表s = "hello world"<br>parts = s.split()<br>print(parts) 输出：["hello", "world"]<br>print(s) 输出：hello world
字符串.strip([字符集])移除字符串首尾的空格、换行符或指定的字符集，默认移除首尾的空白字符字符集：要移除的字符集合（可选）新字符串s = " hello "<br>new_s = s.strip()<br>print(new_s) 输出：hello
字符串.lstrip([字符集])移除字符串左侧的空格、换行符或指定的字符集，默认移除左侧的空白字符字符集：要移除的字符集合（可选）新字符串s = " hello "<br>new_s = s.lstrip()<br>print(new_s) 输出：hello
字符串.rstrip([字符集])移除字符串右侧的空格、换行符或指定的字符集，默认移除右侧的空白字符字符集：要移除的字符集合（可选）新字符串s = " hello "<br>new_s = s.rstrip()<br>print(new_s) 输出： hello
字符串.count(子字符串)统计字符串内某子字符串的出现次数子字符串：要统计的字符串出现次数s = "hello"<br>count = s.count("l")<br>print(count) 输出：2
字符串.upper()将字符串中的小写字母转换为大写无新字符串s = "hello"<br>upper_s = s.upper()<br>print(upper_s) 输出：HELLO
字符串.lower()将字符串中的大写字母转换为小写无新字符串s = "HELLO"<br>lower_s = s.lower()<br>print(lower_s) 输出：hello
字符串.capitalize()将字符串的第一个字符转换为大写，其余转换为小写无新字符串s = "hELLO"<br>cap_s = s.capitalize()<br>print(cap_s) 输出：Hello
字符串.title()将字符串中每个单词的首字母转换为大写无新字符串s = "hello world"<br>title_s = s.title()<br>print(title_s) 输出：Hello World
字符串.startswith(子字符串)检查字符串是否以指定的子字符串开头子字符串：要检查的字符串布尔值（是返回True，否返回False）s = "hello"<br>starts = s.startswith("he")<br>print(starts) 输出：True
字符串.endswith(子字符串)检查字符串是否以指定的子字符串结尾子字符串：要检查的字符串布尔值（是返回True，否返回False）s = "hello"<br>ends = s.endswith("lo")<br>print(ends) 输出：True
字符串.join(可迭代对象)将可迭代对象中的元素用字符串连接成一个新字符串可迭代对象：包含字符串的元素的可迭代对象新字符串parts = ["hello", "world"]<br>s = " ".join(parts)<br>print(s) 输出：hello world
字符串.format(*args, **kwargs)格式化字符串，将参数插入到字符串中的占位符位置*args：位置参数<br>**kwargs：关键字参数新字符串s = "My name is {} and I'm {} years old".format("Alice", 25)<br>print(s) 输出：My name is Alice and I'm 25 years old
f字符串使用f-string进行格式化，将表达式嵌入到字符串中表达式：要嵌入的表达式新字符串name = "Alice"<br>age = 25<br>s = f"My name is {name} and I'm {age} years old"<br>print(s) 输出：My name is Alice and I'm 25 years old
len(字符串)统计字符串的字符个数字符串：要统计的字符串字符数量s = "hello"<br>length = len(s)<br>print(length) 输出：5

（四）实例应用

字符串用于处理文本数据，如文件操作、用户输入输出等。

# 访问字符串字符
print(greeting[0])  # 输出：H

# 字符串拼接
full_name = "John " + "Doe"
print(full_name)  # 输出：John Doe

# 字符串格式化
formatted = f"Hello, {full_name}!"
print(formatted)  # 输出：Hello, John Doe!

# 字符串长度
print(len(greeting))  # 输出：13

# 字符串切片
print(greeting[0:5])  # 输出：Hello

# 遍历字符串
for char in greeting:
    print(char)

# 字符串方法
print(greeting.lower())  # 输出：hello, world!
print(greeting.upper())  # 输出：HELLO, WORLD!
print(greeting.replace("Hello", "Hi"))  # 输出：Hi, World!

六、数据结构之间的区别

为了更清晰地理解这些数据结构，以下是它们之间的主要区别：

特性列表（list）元组（tuple）字典（dict）集合（set）字符串（str）
有序是是否否是
可变是否是是否
元素唯一性否否是（键唯一）是否
主要用途存储有序可变序列存储固定数据键值对存储唯一元素集合文本数据存储

七、总结

在Python中，列表、元组、字典、集合和字符串各有其独特的用途和特点：

  • 列表适合存储有序且可变的元素序列。

  • 元组用于存储固定不变的有序数据。

  • 字典提供高效的键值对存储和查找。

  • 集合用于存储唯一的元素，并支持集合运算。

  • 字符串用于处理文本数据。

●^●
关注
python--字典和列表
FunnyPrince_的博客
10-29 2190
study
【解释型语言】Python-数据结构-字典
努力，奋斗！
08-16 638
Python字典： - 创建：无参创建，带参创建，dict()函数创建：键，映射+键，可迭代对象+键 - 判断键是否存在：in 和 not in - 获取值：[]，dict.get() - 遍历：keys()，values()，items() - 修改：字典更新：[]覆盖，dict.setdefault()，dict.update()，字典删除dict.pop，dict.popitem()，字典赋值：dict.copy().........
【0017】Python数据类型-字典类型详解（全网最细教程）
最新发布
一个结构化、系统化学习IT知识的优秀博客
03-11 1554
Python字典是一种内置的数据结构，它以键值对（key-value pair）的形式存储数据。字典是Python中非常强大且灵活的数据类型之一，广泛应用于各种编程场景中。掌握它的使用对于提高编程效率和解决实际问题具有重要意义。无论是初学者还是有经验的程序员，都应该熟练掌握字典的相关操作和应用场景。
Python基础篇（三）-- 列表、元组、字典、集合、字符串
CarpeDiem
01-21 8315
本篇主要介绍Python里的数据结构，包括列表、元组、字典、集合、字符串的使用，学习这些序列的方法以及性质。
Python 中的字典、列表和数组详细介绍与实例演示
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
07-15 2880
Python 中的字典、列表和数组详细介绍与实例演示
Python基础【列表和字典的基本操作】
功不唐捐，玉汝于成
06-17 886
Python中子字典和列表的基本操作
Python数据结构详解：列表、元组、字典、集合
Python中常见的数据结构可以统称为容器（container），主要包括序列（如列表和元组）、映射（如字典）以及集合（set）三类。下面对Python中常见的数据结构进行详细的解释和介绍。 **序列（列表、元组和字符串）** ...
Python数据结构详解：列表、元组、集合与字典操作
"本章深入探讨了Python的数据结构，包括列表、元组、集合和字典，以及如何高效地使用循环和条件控制。此外，还介绍了列表的各种操作方法，如添加、删除、查找和排序元素。" 在Python编程中，数据结构是存储和组织...
Python3数据结构详解：列表、元组、字典与字符串操作
"这篇资源总结了Python3中的四个基本数据结构——列表、元组、字典和字符串的主要知识，包括它们的创建、方法调用以及常用操作。文章以列表作为重点，详细展示了列表的创建、索引访问、切片、添加、删除、修改等操作...
Python基础数据结构详解：列表、元组、字符串等
本课程名为"Python的基本数据结构（课件）"，主要介绍了Python语言中几种核心的数据结构，包括列表（list）、元组（tuple）、字符串（string）、集合（set）和字典（dict）。这些数据结构在Python编程中扮演着关键...
Python数据结构详解：列表、元组、字典与集合
资源摘要信息:"老男孩Python自动化开发课程的第二部分，专注于Python语言的核心数据结构——列表、元组、字典和集合。本部分教程总共包含16页的演示文稿，内容丰富详尽，涵盖了上述数据结构的基本概念、操作方法以及...
Python学习笔记——列表和字典
kuangweihan的博客
12-13 2374
一个列表需要用中括号[ ]把里面的各种数据框起来，里面的每一个数据叫作“元素”。每个元素之间都要用英文逗号隔开。
Python字典列表
weixin_43666331的博客
01-06 2696
字典(dictionary) 键值对(key-value)的集合。定义时使用花括号“{}” eg：Name = {key1:value1,key2:value2} dic = {'name':'zhangsan','id':123,'score':96} “这个是随便写的” key可以是数字或者字符串类型(也可以时布尔类型，比较少) value可以是任意类型的数据。 字典访问：print(Nam...
【Python】列表和字典
loyd3的博客
06-05 868
元祖之间的比较，每个元素都进行比较，如果两个元素相同就接着比较下一个位置上的元素，直到两个元祖的元素不同，找到不同的元素后，后面元素的大小比较就不考虑了。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。zip对象算是一种迭代器，某方面和列表很相似，但是与列表不同的是，不能使用索引来选取元素。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
python之列表、元组、字符串、集合、字典总结
qq_45253758的博客
07-31 1317
列表、元组、字符串、集合、字典总结 这周学习了列表、元组、字符串、集合、字典，五种容器类型，下面对五种容器类型做一个简单的总结，使人更好的去认识他们。 在python中的表现形式 列表（list)----------->[元素，元素，元素 ] 元组（tuple)-------->(元素，元素，元素) 字符串(str)----------> ‘字符数据’ 集合（set)---------->{元素，元素，元素，元素} 字典（dict)---------->{键：值，键：值} 举例
Python中列表（List）、元组（Tuple）、字符串（Str）、集合（Set）和字典（Dict）的区别
qq_41189226的博客
10-16 4458
1.四种数据结构之间的关系 列表 元组 集合 字典 英文 List Tuple Set Dict 可否读写 读写 只读 读写 读写 可否重复 是 是 否 是 存储方式 值 值 键（键唯一） 键值对（键唯一） 是否有序 有序 有序 无序 无序（自动正序） 初始化 [value1, value2] (value1, value2) {value1, value2} {key1 : value1, key2 : value2 } 增 list.append(value)
Python：列表、元组和字典
2302_79085918的博客
02-02 1893
但方法有一个额外的功能——当程序要获取的key在字典中不存在，该方法会先为这个不存在的key设置一个默认的value，然后再返回该key对应的value。提示：此处随机其实是假的，正如列表的pop()方法总是弹出列表中的最后一个元素，实际上字典的popitem()其实也是弹出字典的最后一个key-value对。由于字典存储key-value对的顺序是不可知的，因此开发者感觉字典的popitem()方法是“随机”弹出的，但实际上字典的popitem()方法总是弹出底层存储的最后一个key-value对。
python 元组 与 字典
weixin_58520733的博客
04-18 2535
元组 使用圆括号创建元组 使用圆括号“()”创建元组，并将元组中的元素用逗号进行分隔。 当使用圆括号“()”创建元组时，如果元组中只包含一个元素，那么需要在该元素的后面添加逗号，从而保证Python解释器能够识别其为元组类型。 tu_one = () # 空元组 tu_two = (‘t’, ‘u’, ‘p’, ‘l’, ‘e’) # 元组中元素类型相同 tu_three = (0.3, 1, 'python',
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值