【python】列表元组与字典

于 2024-12-27 09:40:09 发布
阅读量682 收藏 22
点赞数 16
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gma999/article/details/144432888
版权

列表与元组

创建与访问

总结

  • 列表的创建：可以通过 [] 或 list() 来创建列表，它们都属于 Python 的内建数据类型 list
  • 访问与修改元素：通过索引可以访问和修改列表中的元素，支持正向和负向索引。正向索引从 0 开始，而负向索引从 -1 开始，表示列表的最后一个元素
  • 列表的长度：可以使用 len(a) 来获取列表的元素数量
  • 列表元素的多样性：列表可以包含不同类型的元素，包括整数、字符串、布尔值、嵌套列表等
# 创建一个空列表，使用的是字面量 [] 来定义
a = []
# 打印 a 的类型，输出应该是 <class 'list'>
print(type(a))

# 创建一个空列表，使用 list() 函数来定义
b = list()
# 打印 b 的类型，输出也应该是 <class 'list'>
print(type(b))

# 创建一个包含整数的列表
a = [1, 2, 3, 4]
# 打印列表 a
print(a)
# 打印列表 a 中索引为 2 的元素，输出是 3，因为索引从 0 开始
print(a[2])

# 修改列表 a 中索引为 2 的元素的值，将其修改为 1000
a[2] = 1000
# 打印修改后的 a[2]，输出应为 1000
print(a[2])
# 打印修改后的整个列表 a，应该是 [1, 2, 1000, 4]
print(a)

# 如果我们尝试访问索引为 4 的元素，代码会引发 IndexError 错误，因为 a 只包含 4 个元素（索引从 0 到 3）
# print(a[4])  # 这行代码被注释掉了

# 使用 len(a)-1 来访问列表 a 的最后一个元素
print(a[len(a)-1])
# 通过负索引 -1 直接访问列表 a 的最后一个元素
print(a[-1])

# 创建一个包含多种数据类型的列表
a = [1, 'h', "hello", True, [666, 888]]
# 打印包含不同数据类型的列表 a
print(a)
# 打印列表 a 的长度，应该输出 5，因为 a 中有 5 个元素
print(len(a))

切片

总结

  • 切片语法 切片操作 a[start:end:step] 用于从列表 a 中提取一个子列表
    • start 是起始索引（包括该索引位置）
    • end 是结束索引（不包括该索引位置）
    • step 是步长，决定了每次移动多少个位置
  • 如果省略某个部分
  • start 默认为 0（从列表的第一个元素开始）
  • end 默认为列表的末尾
  • step 默认为 1（连续提取元素）

# 创建一个包含整数的列表 a
a = [1, 2, 3, 4]

# 使用切片操作访问 a 的一部分。a[1:3] 会返回索引从 1 到 2（不包括 3）之间的元素，结果是 [2, 3]
print(a[1:3])

# 使用切片操作访问 a 中索引从 1 到结束的部分，结果是 [2, 3, 4]
print(a[1:])

# 使用切片操作访问 a 中从开始到索引 2（不包括 3）之间的部分，结果是 [1, 2, 3]
print(a[:3])

# 使用负索引访问 a 中最后一个元素的部分，结果是 [4]（切片语法会返回列表，即使只有一个元素）
print(a[-1:])

# 使用切片操作访问 a 中从开始到倒数第二个元素的部分，结果是 [1, 2, 3]
print(a[:-1])

# 使用切片操作访问整个列表，结果是 [1, 2, 3, 4]
print(a[:])

# 创建一个包含整数的列表 a，长度为 9
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用切片操作访问整个列表，步长为 1，等同于 a[::1]，结果是 [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[::1])

# 使用切片操作访问列表中的元素，步长为 2，结果是 [1, 3, 5, 7, 9]
print(a[::2])

# 使用切片操作访问列表中的元素，步长为 3，结果是 [1, 4, 7]
print(a[::3])

# 使用切片操作访问列表中从索引 1 到倒数第一个元素之间，步长为 2，结果是 [2, 4, 6, 8]
print(a[1:-1:2])

# 使用负步长切片操作反转列表，结果是 [9, 8, 7, 6, 5, 4, 3, 2, 1]
print(a[::-1])

# 使用负步长切片操作反转列表，并跳过一个元素，结果是 [9, 7, 5, 3, 1]
print(a[::-2])

# 使用切片操作访问从索引 1 到索引 100 之间的元素，由于索引超出范围，Python 会返回索引范围内的元素 [2, 3, 4, 5, 6, 7, 8, 9]
print(a[1:100])

遍历

总结

遍历列表

  • 使用 for 循环和 in 语法可以简洁地遍历列表中的每个元素
  • 使用 range() 和 for 循环可以通过索引访问列表元素，适合需要修改元素值的情况
  • while 循环也可以遍历列表，但需要手动控制索引的更新

使用 range() 生成索引序列

  • range(0, len(a)) 用于生成一个从 0 到 len(a)-1 的序列，适合在 for 循环中访问列表的索引
# 创建一个包含整数的列表 a
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用 for 循环遍历列表 a，逐个打印列表中的元素
for elem in a:
    print(elem)

# 使用 range 和 for 循环遍历列表 a，逐个访问并修改列表中的元素
# 这里我们使用 range(0, len(a)) 来生成从 0 到 len(a)-1 的索引
for i in range(0, len(a)):
    a[i] = a[i] + 10  # 每个元素加 10

# 打印修改后的列表 a
print(a)

# 使用 while 循环遍历列表 a，逐个打印列表中的元素
# 通过 while 循环控制索引 i 的增加
i = 0
while i < len(a):
    print(a[i])
    i += 1  # 每次循环后，i 自增 1

新增元素

总结

  • append（）
    • 将一个元素放到列表的末尾，操作可以直接修改列表
  • insert（）
    • 用于在指定的索引位置插入元素，元素插入时，列表中原来该位置的元素及其后续元素会向后移动
    • 如果插入的index大于当前列表的长度，那么会将元素直接添加到列表的末尾
# 创建一个包含整数的列表 a
a = [1, 2, 3, 4]

# 使用 append() 方法在列表末尾添加一个元素 5
a.append(5)
# 使用 append() 方法在列表末尾添加一个字符串 "hello"
a.append("hello")

# 打印修改后的列表 a，输出 [1, 2, 3, 4, 5, 'hello']
print(a)

# 使用 insert() 方法在索引 1 的位置插入一个元素 "world"
# insert(index, element) 会将 element 插入到列表中的 index 位置，现有元素会向后移动
a.insert(1, "world")
# 打印修改后的列表 a，输出 [1, 'world', 2, 3, 4, 5, 'hello']
print(a)

# 使用 insert() 方法尝试在索引 100 处插入一个元素 "ggm"
# 由于索引 100 超出了当前列表的范围，insert() 会将 "ggm" 添加到列表末尾
a.insert(100, "ggm")
# 打印修改后的列表 a，输出 [1, 'world', 2, 3, 4, 5, 'hello', 'ggm']
print(a)

查找与删除元素

总结

  • in 和 not in 操作符

    • in 用于检查元素是否在列表中，返回 True 或 False
    • not in 用于检查元素是否不在列表中，返回 True 或 False

  • index() 方法

    • index() 返回指定元素在列表中的索引位置。如果元素不存在，会引发 ValueError 错误

  • pop() 方法

    • pop() 用于删除并返回列表中的一个元素。如果没有指定索引，默认删除最后一个元素
    • 如果提供了索引，pop(index) 会删除指定索引位置的元素，并返回该元素

  • remove() 方法

    • remove() 用于删除列表中的第一个匹配的元素。如果元素在列表中不存在，会引发 ValueError 错误
    • 与 pop() 不同，remove() 根据值删除元素，而不是根据索引
# 创建一个包含整数的列表 a
a = [1, 2, 3, 4]

# 检查元素 1 是否在列表 a 中，输出结果为 True，因为 1 存在于列表 a 中
print(1 in a)

# 检查元素 10 是否在列表 a 中，输出结果为 False，因为 10 不在列表 a 中
print(10 in a)

# 检查元素 1 是否不在列表 a 中，输出结果为 False，因为 1 在列表 a 中
print(1 not in a)

# 检查元素 5 是否不在列表 a 中，输出结果为 True，因为 5 不在列表 a 中
print(5 not in a)

# 获取列表 a 中第一个出现的元素 2 的索引位置，输出结果为 1（索引从 0 开始）
print(a.index(2))

# 如果尝试查找不存在的元素 5 的索引，会引发 ValueError 错误
# print(a.index(5))  # 这行代码被注释掉了，避免运行时错误

# 打印列表 a，输出 [1, 2, 3, 4]
print(a)

# 使用 pop() 方法删除列表中的最后一个元素（默认行为），并返回该元素，删除的是 4
a.pop()
# 打印删除后的列表，输出 [1, 2, 3]
print(a)

# 使用 pop(1) 删除索引位置 1 的元素，即删除元素 2
a.pop(1)
# 打印删除后的列表，输出 [1, 3]
print(a)

# 创建一个包含字符串的列表 b
b = ['aa', 'bb', 'cc']

# 使用 remove() 方法删除列表中的元素 'cc'，如果列表中存在该元素，会删除第一个匹配的元素
b.remove('cc')
# 打印删除后的列表，输出 ['aa', 'bb']
print(b)

连接列表

总结

  •  + 运算符会创建一个新的列表，适用于需要合并并返回一个新列表的场景，但要注意它会创建新的内存空间，可能相对较慢
  • extend() 和 += 操作是在原列表上进行修改，性能更优，因为它们不会创建新的列表对象，而是直接在原列表上添加元素
# 创建两个列表 a 和 b
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]

# 使用加法运算符 + 连接两个列表 a 和 b，创建一个新的列表 c
# c 是列表 a 和 b 的元素合并，结果是 [1, 2, 3, 4, 5, 6, 7, 8]
c = a + b
# 打印新列表 c
print(c)

# 使用 extend() 方法将列表 b 中的元素添加到列表 a 的末尾
# 注意：extend() 是修改原始列表 a 的，而不是创建新的列表
# 结果是列表 a 变为 [1, 2, 3, 4, 5, 6, 7, 8]
a.extend(b)
# 打印修改后的列表 a
print(a)
# 打印列表 b，b 没有改变，仍然是 [5, 6, 7, 8]
print(b)

# 使用 += 运算符将列表 b 中的元素添加到列表 a 的末尾
# += 运算符与 extend() 方法类似，都会修改原列表 a
a += b
# 打印修改后的列表 a，结果是 [1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 7, 8]
print(a)
# 打印列表 b，b 仍然没有改变，仍然是 [5, 6, 7, 8]
print(b)

元组

总结

  • 元组的定义与创建

    • 元组通过小括号 () 创建，也可以使用 tuple() 构造函数。元组是不可变类型，一旦创建就不能修改

  • 元组的不可变性

    • 元组一旦创建后，它的内容不能被修改（不能添加、删除或修改元素）。这与列表不同，列表是可变的

  • 访问元组元素

    • 元组支持通过索引和切片来访问元素。索引从 0 开始，切片支持获取元组的子集

  • in 和 index() 方法

    • in 用于检查元素是否在元组中，而 index() 用于返回元素在元组中的索引位置。若元素不存在，index() 会抛出 ValueError

  • 遍历元组

    • 可以使用 for 循环遍历元组，逐个访问其中的元素

  • + 运算符

    • 使用 + 运算符可以连接两个元组，返回一个新的元组，原元组不变
# 创建一个空的元组 a
a = ()
# 打印 a 的类型，输出 <class 'tuple'>，表示 a 是一个元组
print(type(a))

# 创建一个空的元组 b
b = tuple()
# 打印 b 的类型，输出 <class 'tuple'>，表示 b 是一个元组
print(type(b))

# 创建一个包含整数的元组 b
b = (1, 2, 3, 4)
# 打印元组 b，输出 (1, 2, 3, 4)
print(b)

# 打印元组 b 中索引为 1 的元素，输出 2
print(b[1])

# 打印元组 b 中索引为 2 的元素，输出 3
print(b[2])

# 使用切片操作，打印元组 b 中索引 1 到 3（不包括 3）之间的元素，输出 (2, 3)
print(b[1:3])

# 打印元组 b 的所有元素，使用默认步长，输出 (1, 2, 3, 4)
print(b[::])

# 创建一个包含不同类型元素的元组 c
c = (1, 2, "hello", True, [2333, 4555])
# 打印元组 c，输出 (1, 2, 'hello', True, [2333, 4555])
print(c)

# 创建一个包含整数的元组 d
d = (1, 2, 3, 45)

# 使用 for 循环遍历元组 d，逐个打印其中的元素
for elem in d:
    print(elem)

# 创建一个包含整数的元组 e
e = (1, 2, 3, 4)

# 检查元素 3 是否在元组 a 中，输出 False，因为元组 a 为空
print(3 in a)

# 使用 index() 方法查找元素 1 在元组 e 中的索引位置，输出 0（索引从 0 开始）
print(e.index(1))

# 尝试修改元组 e 中的第一个元素，元组是不可变的，所以这行代码会抛出 TypeError 错误
# e[0] = 100  # 这一行代码被注释掉了，避免抛出异常

# 使用 + 运算符连接元组 d 和 e，返回一个新的元组，输出 (1, 2, 3, 45, 1, 2, 3, 4)
print(d + e)

字典

创建字典

总结

  • 键值对的规则：

    • 键必须是不可变的（如字符串、数字、元组），且键是唯一的
    • 值可以是任意类型（如字符串、数字、列表、字典等）

  • 创建字典的常用方式：

    • 使用 {} 直接创建字典（常用）
    • 使用 dict() 构造函数（灵活）
    • 通过字典推导式动态生成
    • 从键值对的列表或元组创建

  • 创建空字典：

    • 使用 {} 或 dict()

  • 适用场景：

    • 静态字典： {} 定义初始内容
    • 动态字典： 使用空字典 dict() 并逐步添加键值对
    • 复杂字典： 从其他数据结构（如列表、元组）生成

# 创建一个字典 a，使用字典字面量 {}，包含两个键值对：'id': 1 和 'name': '猪粑粑'
a = {'id': 1, 'name': '猪粑粑'}
# 打印 a 的类型，输出 <class 'dict'>，表示 a 是一个字典
print(type(a))
# 打印字典 a 的内容，输出 {'id': 1, 'name': '猪粑粑'}
print(a)

# 创建一个空字典 b，使用 dict() 构造函数
b = dict()
# 打印 b 的类型，输出 <class 'dict'>，表示 b 是一个字典
print(type(b))

# 创建一个字典 d，使用 dict() 构造函数并传递键值对参数
# 键值对通过 key=value 的形式传递（键必须是字符串类型）
d = dict(key1="v1", key2="v2")
# 打印字典 d，输出 {'key1': 'v1', 'key2': 'v2'}
print(d)

# 创建一个字典 e，使用 dict() 构造函数并传递一个由元组组成的列表
# 每个元组表示一个键值对，键和值可以是任意类型
e = dict([("key1", "value1"), ("key2", "value2")])
# 打印字典 e，输出 {'key1': 'value1', 'key2': 'value2'}
print(e)

查找Key

总结

  • 检查键是否存在：
    • 使用 in 和 not in 检查键是否存在或不存在
  • 访问值：
    • 使用键访问值，格式为：字典[键]
  • 注意 KeyError：
    • 在访问字典中不存在的键时会报 KeyError，可以通过 get() 方法设置默认值来避免

# 创建一个字典 a，包含两个键值对：'id': 1 和 'name': '小钱'
a = {
    'id': 1,
    'name': '小钱'
}

# 使用 `in` 操作符检查字典 a 中是否存在键 'id'，结果为 True，因为字典中有这个键
print('id' in a)

# 使用 `in` 操作符检查字典 a 中是否存在键 'class'，结果为 False，因为字典中没有这个键
print('class' in a)

# 使用 `in` 操作符检查字典 a 中是否存在值 "小钱"，结果为 False，因为 `in` 只检查字典的键，不会检查值
print("小钱" in a)

# 使用 `not in` 操作符检查字典 a 中是否不存在键 'class'，结果为 True，因为字典中没有这个键
print('class' not in a)


# 创建另一个字典 b，包含两个键值对：'id': 1 和 'name': 'xiaowang'
b = {
    'id': 1,
    'name': 'xiaowang'
}

# 使用键访问字典 b 中的值，打印键 'id' 对应的值，结果为 1
print(b['id'])

# 使用键访问字典 b 中的值，打印键 'name' 对应的值，结果为 'xiaowang'
print(b['name'])

# 尝试访问字典中不存在的键 '100'，会引发 KeyError 错误（这一行代码被注释掉了，避免运行时报错）
# print(a[100])  # KeyError: 100

c = dict([("name", "小明"), ("age", 25), ("city", "北京"), ("hobby", "足球")])
for key,value in c.items():
    print(f"{key}:{value}")

del c['name']
print(c

新增修改与删除

总结

  • 动态添加键值对： 使用 字典[键] = 值
  • 修改字典中的值： 如果键已存在，赋值操作会覆盖原值
  • 删除键值对： 使用 pop(键) 删除指定的键及其对应值
  • 字典的可变性： 字典支持动态修改（添加、更新和删除），可以灵活调整内容
  • 常用方法：
    • pop()：删除指定键
    • get()：安全获取键的值
    • in：判断键是否存在

# 创建一个字典 a，包含两个键值对：'id': 1 和 'name': 'xiaomign'
a = {
    'id': 1,
    'name': 'xiaomign'
}

# 打印字典 a，输出 {'id': 1, 'name': 'xiaomign'}
print(a)

# 向字典 a 中添加一个新的键值对 'score': 100
a['score'] = 100
# 打印字典 a，输出 {'id': 1, 'name': 'xiaomign', 'score': 100}
print(a)

# 修改字典中已有键 'score' 的值，将其从 100 修改为 99
a['score'] = 99
# 打印字典 a，输出 {'id': 1, 'name': 'xiaomign', 'score': 99}
print(a)

# 删除字典中的键 'name' 及其对应的值
a.pop('name')
# 打印字典 a，输出 {'id': 1, 'score': 99}
print(a)

遍历字典

总结

  • 遍历键：for key in a 
  • 遍历键值对：for key , value in a.items()
  • 获取字典视图对象
    • key()：返回所有键
    • values()：返回所有值
    • items()：返回所有键值

# 定义一个字典 a，包含三个键值对：'id': 1, 'name': 'xiaomign', 'score': 90
a = {
    'id': 1,
    'name': 'xiaomign',
    'score': 90
}

# 遍历字典的键，通过键访问对应的值
# 遍历字典 a 中的每个键，打印键和值
for key in a:
    print(key, a[key])  # 输出键和值，格式为：键 值

# 打印字典的所有键
# a.keys() 方法返回字典中所有的键，结果是一个字典视图对象
print(a.keys())  # 输出：dict_keys(['id', 'name', 'score'])

# 打印字典的所有值
# a.values() 方法返回字典中所有的值，结果是一个字典视图对象
print(a.values())  # 输出：dict_values([1, 'xiaomign', 90])

# 打印字典的所有键值对
# a.items() 方法返回字典中的所有键值对，结果是一个字典视图对象，每个元素是一个元组 (key, value)
print(a.items())  # 输出：dict_items([('id', 1), ('name', 'xiaomign'), ('score', 90)])

# 使用 a.items() 遍历字典的键值对
# for 循环同时解包键和值，分别赋值给变量 key 和 value
for key, value in a.items():
    print(key, value)  # 输出格式为：键 值

合法key的类型

总结

def is_hashable(obj):
    try:
        hash(obj)
        return True
    except TypeError:
        return False

# 示例：
print(is_hashable(42))          # True
print(is_hashable("hello"))     # True
print(is_hashable([1, 2, 3]))   # False
print(is_hashable((1, 2, 3)))   # True
print(is_hashable({"a": 1}))    # False

gma999
关注
python--字典和列表
FunnyPrince_的博客
10-29 2179
study
python 列表、元组、字典、集合的区别
xmp65535的博客
03-29 2052
介绍 python中字典 (Dictionary)、元组 (Tuple)、字典 (Dict)、集合 (Set)的区别
Python字典列表
weixin_43666331的博客
01-06 2695
字典(dictionary) 键值对(key-value)的集合。定义时使用花括号“{}” eg：Name = {key1:value1,key2:value2} dic = {'name':'zhangsan','id':123,'score':96} “这个是随便写的” key可以是数字或者字符串类型(也可以时布尔类型，比较少) value可以是任意类型的数据。 字典访问：print(Nam...
python: 列表、字典
天涯明月的专栏
01-15 985
1. 首先给出一个字典对象a： >>> a = {'a':'a_v','b':'b_v'} 2. 下面对字典进行遍历： 方式1：（错误方式） >>> for key in a: print %(key, a[key]) SyntaxError: invalid syntax 方式2：（正确方式）>>> for key in a:print 'key: %s, value: %
【Python】列表和字典
loyd3的博客
06-05 863
元祖之间的比较，每个元素都进行比较，如果两个元素相同就接着比较下一个位置上的元素，直到两个元祖的元素不同，找到不同的元素后，后面元素的大小比较就不考虑了。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。zip对象算是一种迭代器，某方面和列表很相似，但是与列表不同的是，不能使用索引来选取元素。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
Python 列表与字典
zouxiaoyou的博客
02-28 3812
列表 列表特点： 利用中括号表示列表 列表内元素使用逗号分割 逗号是英文输入法下边的逗号 列表内容是可变的 内置函数list()可以将输入的字符串切分为包含字符的列表。 列表内元素索引从0开始。 内置函数len()可以获取列表长度，注意，这里的长度与索引不同，是从1开始的。 修改列表元素：列表名[编号]=新值。 添加列表元素：列表名.append(要添加的元素)。 删除列表
头歌Python入门之元组与字典
09-26
1.元组的使用:元组与列表,创建元组,访问元组,修改元组,元组内置函数 len(tuple)：计算元组中元素个数。 max(tuple)：返回元组中元素的最大值。 min(tuple)：返回元组中元素的最小值。 tuple(seq)：将列表转换为元组...
【python】Python中常用的数据结构——列表、元组和字典
翡翠泪滴的博客
07-05 1711
需要注意的是，列表和字典是可变的，可以直接对其进行修改操作，而元组是不可变的，无法直接对其进行修改操作。例如，在一个字典中，可以嵌套多个字典，每个字典都代表一个实体，从而更清晰地表示出实体之间的关系。以上是字典的三种基本遍历方法，可以根据需要选择适合的方法来遍历字典的元素。需要注意的是，列表和字典是可变的，可以直接对其进行修改操作，而元组是不可变的，无法直接对其进行修改操作。需要注意的是，嵌套的数据结构可以是任意的，可以是元组，字典，列表的组合，也可以是其他对象。是两个不同的列表对象，它们的地址是不同的。
7. Python的元组&字典&集合
12-20
Python中的元组、字典和集合是三种不同的数据结构，每一种都有其特定的用途和特点。 1. **元组(Tuples)** 元组是不可变序列，这意味着一旦创建，就不能更改其内容。元组用圆括号 `()` 表示，元素间用逗号分隔。 ...
头歌python元组与字典通关代码
12-19
在这些Python编程挑战中，我们主要涉及了四个核心知识点：元组、字典、字典的遍历以及嵌套数据结构。以下是关于这些知识点的详细说明： 1. **元组(Tuples)**： 元组是Python中的不可变序列类型，一旦创建就不能...
python的列表(List)、 元组、字典(Dictionary)
北巷番茄鱼的博客
07-01 392
@[TOC](列表(List)、 元组、字典(Dictionary)) 列表(List) 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型 list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"] 对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项。 list = []
python列表字典_Python常用对字典、列表的操作
weixin_39657094的博客
11-30 88
Python常用对字典、列表的操作
python 字典 列表基本操作
qingyu3044的博客
07-15 580
1.一般格式:格式: 字典名={元素1,元素2,…}元素以键值对存在==key(键值):value(实值)2.空字典:格式: 字典名={} 或者 字典名=dict()3.举例:dict = {“nane”: “张三”, “age”: 20, “sex”: “男”}dict1={}dict2={}结果:注意:key不可以重复,否则只会保留第一个;value值可以重复;key可以是任意的数据类型,但不能出现可变的数据类型,保证key唯一;
Python学习笔记——列表和字典
kuangweihan的博客
12-13 2346
一个列表需要用中括号[ ]把里面的各种数据框起来，里面的每一个数据叫作“元素”。每个元素之间都要用英文逗号隔开。
(Python)Python—常用的几种列表、字典
weixin_45905741的博客
04-27 3341
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。list的检索原理是：假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。len() 函数可以获得list元素的个数；append() 可以往list中追加元素到末尾；pop(i) 可以删除指定位置的元素；insert() 可以把元素插入到指定的位置；
【Python】基础数据结构：列表——元组——字典——集合
风高秋月白，雨霁晚霞红
08-06 8139
Python基础数据结构。
python 列表list 元组tuple 字典dict 集合set 介绍
热门推荐
Johnny's Lab
03-17 1万+
序列序列的两个特点： 1.索引操作符，从序列中抓取一个特定项目 2.和切片操作符，获取序列的一个切片，即一部分序列列表、元组和字符串都是序列，字符串是字符的序列，列表和元祖是任意类型的序列列表list，用中括号“[ ]”表示1.任意对象的有序集合 列表是一组任意类型的值，按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被标识一个索引，第一个索引
Python基础【列表和字典的基本操作】
功不唐捐，玉汝于成
06-17 885
Python中子字典和列表的基本操作
【Python数据结构】深入理解Python中的列表、字典和集合！
最新发布
萧鼎的博客
10-14 1447
列表（List）是Python中最常用的数据结构之一。它是一个有序、可变的集合，可以包含任意类型的对象，如数字、字符串、其他列表等。定义列表# 定义一个空列表# 定义一个包含多个元素的列表列表的特点有序：列表中的元素有确定的顺序，可以通过索引访问元素。可变：可以动态添加、删除或修改列表中的元素。支持任意类型的元素：列表中的元素可以是不同类型的数据，如整数、字符串、对象等。字典（Dictionary）是一种无序的、键值对（key-value pair）的数据结构。
python列表元组集合字典
05-18
2. 元组（Tuple）：元组也是一种有序的集合，与列表相似，不同之处在于元组的元素不能修改。元组用圆括号()表示，元素之间用逗号分隔。 3. 集合（Set）：集合是一种无序的集合，不允许有重复的元素。可以进行交、并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值