本文主要是介绍Python青少年简明教程：列表（List）、元组（tuple）和字典（dict），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
Python青少年简明教程：列表（List）、元组（tuple）和字典（dict）
在Python中，列表（List）、元组（Tuple）和字典（Dict）既是常用的数据类型，也是常用的数据结构。
【数据类型：在编程语言中，数据类型定义了一个变量的存储方式以及可以对该变量执行的操作。从 Python 语言的角度来看，Python 中的列表、元组和字典都属于数据类型。
数据结构：数据结构是指一种组织和存储数据的方式，使得数据可以被有效地访问和修改。从计算机科学的角度来看，列表、元组和字典在Python中也是常用的数据结构，因为它们定义了组织和存储数据的方式。列表是动态数组结构，元组是静态数组结构，字典是哈希表结构。】
列表（list）
在Python中，没有传统意义上像C或Java那样的“数组”数据类型，但Python提供了几种可以模拟数组行为的数据结构，如列表（list）、元组（tuple）其中最常用的是列表（List）。
列表是一种可变的、有序的数据结构，可以随时添加和删除其中的元素。
说明：从列表中取值时，如果 超出索引范围，程序会报错。
列表（list）的元素是按顺序存储的，每个元素都有一个对应的序号，也称为索引（index）。理解列表的索引对于访问和操作列表元素至关重要。
正向索引：
从左到右，从0开始递增，第一个元素的索引是0，第二个元素的索引是1，以此类推。
负向索引：
从右到左，从-1开始递减，最后一个元素的索引是-1，倒数第二个元素的索引是-2，以此类推。
Python 的列表是一个可变的序列，允许你存储不同类型的元素。
创建列表（List）的方法或方式
1.使用方括号 []：
my_list = [1, 2, 3, 4, 5]
list1 = [1, 'a', True, 3.14]
2.使用 list() 构造函数：
my_list = list(range(1, 6)) # 创建一个包含1到5的列表
list2 = list() # 创建空列表
list3 = list("hello") # 将字符串转换为字符列表
list4 = list(range(5)) # 使用 range 创建列表
3.列表推导式（后面还有介绍）：
my_list = [x * 2 for x in range(5)] # 生成 [0, 2, 4, 6, 8]
遍历列表中的所有元素
可以使用 for 循环遍历列表中的所有元素。例如：
fruits = ["苹果", "香蕉", "橘子", "草莓"]
for fruit in fruits:print(fruit)
列表切片（slicing）
在Python中，允许你获取列表中的一部分元素，并可以返回一个新的列表。切片操作的基本语法如下：
list[start:stop:step]
其中
start（开始位置）: 切片开始的位置（包括该位置的元素）。如果省略，默认为列表的开始位置（索引0）。
stop（结束位置）: 切片结束的位置（不包括该位置的元素）。如果省略，默认为列表的结束位置（即列表的长度）。
step（步长）: 切片时元素之间的间隔。如果省略，默认为1。步长可以是正数也可以是负数，分别代表向前或向后切片。
列表切片示例：
# 创建一个示例列表
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 基本切片
print(my_list[2:5]) # 输出：[2, 3, 4]# 从起始位置开始切片
print(my_list[:4]) # 输出：[0, 1, 2, 3]# 从特定位置切片到结束
print(my_list[5:]) # 输出：[5, 6, 7, 8, 9]# 使用步长
print(my_list[::2]) # 输出：[0, 2, 4, 6, 8]# 反向切片
print(my_list[::-1]) # 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]# 指定步长
print(my_list[1:8:3]) # 输出：[1, 4, 7]# 使用负索引
print(my_list[-3:]) # 输出：[7, 8, 9]
print(my_list[:-3]) # 输出：[0, 1, 2, 3, 4, 5, 6]
print(my_list[-5:-2]) # 输出：[5, 6, 7]
print(my_list[::-1]) # 使用负步长可以反转列表：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
列表（List）的方法
“方法”指的是绑定到某个对象的函数，或者说，“方法”是指属于某个对象的函数，能够直接操作或查询该对象的数据。
在Python中，对于列表（list）这样的对象，方法是指那些可以在列表上调用的函数，这些函数能够直接操作列表中的数据。换句话说，方法是属于特定对象的函数，它们定义了对象的行为。
在Python中，列表（list）是一个非常灵活的数据结构，它提供了多种方法来操作和管理数据。以下是一些常用的列表方法及其示例：
1. append()
向列表末尾添加一个新元素。
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # 输出: [1, 2, 3, 4]
2. extend()
将另一个可迭代对象的元素添加到列表末尾。
my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # 输出: [1, 2, 3, 4, 5]
3. insert()
在指定位置插入一个元素。
my_list = [1, 2, 3]
my_list.insert(1, 'a')
print(my_list) # 输出: [1, 'a', 2, 3]
4. remove()
删除列表中第一个匹配的元素。如果元素不存在，会引发 ValueError。
my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list) # 输出: [1, 3, 2]
还可以使用clear() 方法，用于清空列表中的所有元素。
lst = [1, 2, 3, 4]
lst.clear() # lst 变为 []
5. pop()
移除并返回列表中指定位置的元素（默认最后一个元素）。如果列表为空，会引发 IndexError。
my_list = [1, 2, 3]
last_element = my_list.pop()
print(last_element) # 输出: 3
print(my_list) # 输出: [1, 2]
6. index()
返回指定元素的第一个索引。如果元素不存在，会引发 ValueError。
my_list = [1, 2, 3]
index_of_2 = my_list.index(2)
print(index_of_2) # 输出: 1
7. count()
返回列表中指定元素的出现次数。
my_list = [1, 2, 2, 3, 2]
count_of_2 = my_list.count(2)
print(count_of_2) # 输出: 3
8. sort()
对列表中的元素进行排序。排序是原地进行的，即改变原列表。可以通过 reverse=True 参数进行降序排序。
my_list = [3, 1, 2]
my_list.sort()
print(my_list) # 输出: [1, 2, 3]
my_list.sort(reverse=True)
print(my_list) # 输出: [3, 2, 1]
9. reverse()
反转列表中的元素。排序是原地进行的，即改变原列表。
my_list = [1, 2, 3]
my_list.reverse()
print(my_list) # 输出: [3, 2, 1]
10. copy()
返回列表的浅拷贝。即创建一个新的列表，其中包含原列表的相同元素。
my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list) # 输出: [1, 2, 3]
还可以使用del 语句删除列表中的单个元素或切片或整个列表。注意，它是 Python 的一个语句，而不是列表的方法。例如：
lst = [1, 2, 3, 4]
del lst[1] # lst 变为 [1, 3, 4]
del lst # 完全删除列表
del语句删除切片例子
lst2= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del lst2 [::2] # 删除带步长的切片，lst2变为[1, 3, 5, 7, 9]
列表（List）的常用操作
Python中的列表（List）其它常用操作（不是方法但常用）：
1. len(list)
功能：返回列表中的元素个数。
my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length) # 输出: 5
2. in 操作符
功能：检查某个元素是否存在于列表中。如果存在，返回 True；否则，返回 False。
my_list = [1, 2, 3, 4, 5]
print(3 in my_list) # 输出: True
print(6 in my_list) # 输出: False
3. 列表连接（+）：将两个列表连接成一个新的列表。
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list) # 输出: [1, 2, 3, 4, 5, 6]
4. 列表重复（*）：重复列表中的元素。
my_list = [1, 2, 3]
repeated_list = my_list * 3
print(repeated_list) # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]
5. 列表拆包：将列表的元素拆分到多个变量中（通常用于函数返回值）。
my_list = [1, 2, 3]
a, b, c = my_list
print(a, b, c) # 输出: 1 2 3
列表（list）模拟二维数组
Python本身没有内置的二维数组类型，但可以使用嵌套列表来实现类似的功能。示例：
# 创建一个3x3的二维数组
matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 访问元素
print(matrix[0][0]) # 输出: 1
print(matrix[1][2]) # 输出: 6# 修改元素
matrix[2][1] = 10
print(matrix) # 输出: [[1, 2, 3], [4, 5, 6], [7, 10, 9]]# 遍历二维数组
for row in matrix:for element in row:print(element, end=' ')print() # 换行
列表综合例题
例1、创建一个包含100以内所有素数的列表
def is_prime(num):"""判断一个数是否为素数。"""if num <= 1:return Falsefor i in range(2, int(num**0.5) + 1):if num % i == 0:return Falsereturn Trueprimes = [num for num in range(2, 100) if is_prime(num)]
print(f"100 以内的所有素数：{primes}")
例2、使用列表的猜数字游戏
import randomdef play_guessing_game():"""猜数字游戏。"""secret_number = random.randint(1, 100)guesses = []attempts = 0print("欢迎来到猜数字游戏！")print("我已选择一个 1 到 100 之间的数字。")while True:try:guess = int(input("请输入你的猜测："))guesses.append(guess)attempts += 1if guess < secret_number:print("太低了！")elif guess > secret_number:print("太高了！")else:print(f"恭喜你！你猜对了！你用了 {attempts} 次尝试。")print(f"你猜过的数字：{guesses}")breakexcept ValueError:print("请输入一个有效的数字。")play_guessing_game()
列表推导
使用列表推导可以简洁地创建新的列表。
列表推导(List Comprehension)是一种简洁而强大的 Python 语法，它允许你通过一行代码创建新的列表，而无需使用传统的 for 循环。它以一种紧凑且易读的方式表达列表创建逻辑。
列表推导的语法：
[expression for item in iterable if condition]
expression: 你想要在新的列表中包含的元素的表达式。
item: 迭代器中的每个元素。
iterable: 可迭代对象，例如列表、元组、字符串等。
condition (可选): 一个条件表达式，用于过滤可迭代对象中的元素。只有满足条件的元素才会被包含在新的列表中。
举例：
1)创建包含平方数的列表：
squares = [x**2 for x in range(10)]
print(squares) # 输出： [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
在这个例子中，x**2 是表达式，x 是迭代器中的每个元素，range(10) 是可迭代对象。代码将遍历 range(10) 中的每个数字，计算其平方，并将结果添加到新的列表 squares 中。
2)创建包含所有偶数的列表：
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers) # 输出： [0, 2, 4, 6, 8]
在这个例子中，x 是表达式，x 是迭代器中的每个元素，range(10) 是可迭代对象，x % 2 == 0 是条件表达式。代码将遍历 range(10) 中的每个数字，检查它是否为偶数，如果是，则将其添加到新的列表 even_numbers 中。
3)创建包含偶数的列表:
even_numbers = [x for x in range(20) if x % 2 == 0]
4)将列表中的所有字符串转换为大写：
words = ["apple", "banana", "orange"]
uppercase_words = [word.upper() for word in words]
print(uppercase_words) # 输出： ['APPLE', 'BANANA', 'ORANGE']
在这个例子中，word.upper() 是表达式，word 是迭代器中的每个元素，words 是可迭代对象。代码将遍历 words 列表中的每个单词，将其转换为大写，并将结果添加到新的列表 uppercase_words 中。
除了列表推导式，Python还支持字典推导式和集合推导式，语法类似。
列表推导的优势：
简洁性： 列表推导比传统的 for 循环更简洁，代码更易读。
效率： 列表推导通常比传统的 for 循环更有效率，因为它们在底层使用 Python 的迭代器协议，减少了循环的开销。
可读性： 列表推导使代码更易于理解，因为它将列表创建逻辑集中在一个表达式中。
元组（tuple）
元组是一个有序的不可变序列，可以包含多个元素，元素可以是不同的数据类型。
Python中元组（tuple）的元素索引与列表（list）的索引在索引和切片操作上表现相同，主要区别在于元组是不可变的，而列表是可变的。
括号的使用：虽然元组可以用圆括号 () 来定义，但实际上，如果元素之间用逗号分隔，Python 也会自动识别为元组。例如，1, 2, 3 被视为一个元组，在不使用括号的情况下。决定生成元组的其实是逗号而不是圆括号。
不可变性：元组一旦创建，就不能修改（例如，不能添加、删除或更改元素）。这与列表不同，列表是可变的。
元组的创建：可以通过以下方式创建元组：
使用括号：t = (1, 2, 3)
不使用括号：t = 1, 2, 3
单个元素元组需加逗号：t = (1,)
如果创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则 Python 解释器会将它视为字符串。
创建元组（Tuple）的方法或方式：
1.使用小括号 ()：
my_tuple = (1, 2, 3, 4, 5)
也可以不使用圆括号（推荐在多元素时使用圆括号）：
Tuple1 = 1, 2, 3, 4, 5
2.使用 tuple() 构造函数：
Tuple2 = tuple() # 创建空元组
Tuple3 = tuple([1, 2, 3]) # 将列表转换为元组
Tuple4 = tuple("hello") # 将字符串转换为字符元组
创建单元素元组，要注意使用逗号：
Tuple5 = (42,)
Tuple6 = 42,
访问元组元素
可以通过索引访问元组中的元素，例如，t[0] 将访问第一个元素。
t = (1, 'hello', [3, 4])
print(t[0]) # 输出: 1
print(t[-1]) # 输出: [3, 4]
元组常用方法
count(): 计算元素出现的次数
index(): 查找元素的索引
t = (1, 2, 2, 3, 4)
print(t.count(2)) # 输出: 2
print(t.index(3)) # 输出: 3
元组切片
Python中元组(tuple)的切片操作与列表(list)非常相似。两者都使用相同的切片语法，主要区别在于元组是不可变的，而列表是可变的。
元组切片都语法：
tuple[start:stop:step]
start 是切片的起始索引（包括该索引所在的元素）。
stop 是切片的结束索引（不包括该索引所在的元素）。
step 是步长，默认为 1。
示例：
# 创建一个元组和一个列表
my_tuple = (0, 1, 2, 3, 4, 5)# 基本切片
print(my_tuple[1:4]) # 输出: (1, 2, 3)# 使用步长
print(my_tuple[::2]) # 输出: (0, 2, 4)# 反向切片
print(my_tuple[::-1]) # 输出: (5, 4, 3, 2, 1, 0)
注意：
对元组进行切片会返回一个新的元组，而对列表进行切片会返回一个新的列表。您可以对列表切片的结果进行修改，但不能修改元组切片的结果。
python元组嵌套
元组可以嵌套，这意味着你可以在一个元组中包含其他元组。下面是一个关于元组嵌套的简单示例：
nested = ((1, 2), (3, 4))
元组与列表可以转换
t = (1, 2, 3)
l = list(t) # 元组转列表
t2 = tuple(l) # 列表转元组
元组特性（特点）及解释
☆不可变性：
含义：一旦创建，元组的内容就不能被改变。
解释：
不能修改现有元素的值。
不能添加新元素。
不能删除现有元素。
示例：
t = (1, 2, 3)
# t[0] = 4 # 这会引发 TypeError
# t.append(4) # 元组没有 append 方法
# del t[0] # 这也会引发 TypeError
注意：如果元组中包含可变对象（如列表），这些对象的内容可以改变。
☆有序：
含义：元组中的元素保持它们被创建时的顺序。
解释：
可以通过索引访问元素。
索引从 0 开始。
支持正向和反向索引。
示例：
t = ('a', 'b', 'c', 'd')
print(t[0]) # 输出: 'a'
print(t[-1]) # 输出: 'd'
☆允许重复元素：
含义：元组可以包含多个相同的值。
解释：
重复元素各自占据独立的位置和索引。
这与集合（set）不同，集合不允许重复。
示例：
t = (1, 2, 2, 3, 1)
print(t.count(1)) # 输出: 2
☆可以包含不同类型的数据：
含义：单个元组可以存储不同数据类型的元素。
解释：
这提供了很大的灵活性。
可以混合使用整数、字符串、列表等。
示例：
t = (1, "hello", [1, 2], (3, 4))
print(type(t[0])) # 输出: <class 'int'>
print(type(t[1])) # 输出: <class 'str'>
print(type(t[2])) # 输出: <class 'list'>
print(type(t[3])) # 输出: <class 'tuple'>
思考题，python元组能排序吗？
元组本身是不可变的（immutable），所以不能直接对元组进行排序。但是，我们可以使用sorted() 函数创建一个排序后的新元组。
sorted() 函数是 Python 内置的一个函数，用于对可迭代对象进行排序并返回一个新的列表。它不会修改原始数据，而是返回一个新的已排序列表。例如：
# 创建一个新的排序元组
original_tuple = (3, 1, 4, 1, 5, 9, 2)
sorted_tuple = tuple(sorted(original_tuple))
print(sorted_tuple) # 输出: (1, 1, 2, 3, 4, 5, 9)
字典(dict、dictionary)
字典是一种可变的、无序的数据结构，存储键值对（key-value pairs）。每个键（key）都是唯一的，并且可以通过键来快速查找对应的值（value）。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
可以使用大括号 {} 或 dict() 函数来创建字典。
创建字典（Dict）的方法或方式：
1.使用花括号 {}：
my_dict = {'name': 'Alice', 'age': 25 , 'city': 'Beijing' }
dict1 = {1: 'one', 2: 'two', 3: 'three'}
dict2 = {"西瓜": 2.6, "桃子": 2, "苹果":3, "樱桃":10.5}
dict3 = {"西瓜":"2.6元", "桃子": "2元", "苹果":"3元", "樱桃":"10.5元"}
2.使用 dict() 构造函数：
my_dict = dict(name='Alice', age=25) # 关键字参数
dict4 = dict() # 创建空字典
3.使用键值对列表：
my_dict = dict([('name', 'Alice'), ('age', 25)]) # 从列表创建字典
4.字典推导式：
my_dict = {x: x ** 2 for x in range(5)} # 生成 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
访问字典的值
可以通过键访问字典中的值。
print(my_dict["name"]) # 输出: Alice
print(my_dict["age"]) # 输出: 25
修改字典
可以为字典中的键赋值、删除键值对或添加新键值对。例如：
# 修改值
my_dict["age"] = 26
# 添加新键值对
my_dict["city"] = "New York"
# 删除键值对
del my_dict["is_student"]
字典的方法
字典提供了多种内置方法来操作数据：
my_dict.keys()：返回字典中的所有键。
my_dict.values()：返回字典中的所有值。
my_dict.items()：返回字典中的所有键值对。
my_dict.get(key)：安全地获取键的值，如果键不存在返回 None。
my_dict.pop(key)：删除指定键并返回其值。
my_dict.update(another_dict)：用另一个字典更新当前字典。
字典的基本特性
☆键唯一性：
每个键在字典中必须是唯一的（字典使用哈希表实现，键的唯一性是哈希表的基本要求）。
行为：如果尝试插入已存在的键，新值会覆盖旧值。
示例：
d = {'a': 1, 'b': 2}
d['a'] = 3 # 覆盖旧值
print(d) # 输出: {'a': 3, 'b': 2}
☆无序性：
定义：传统上，字典中的元素没有固定的顺序。
注意：虽然从 Python 3.7 开始，字典保持插入顺序，但这是一个实现细节，在使用时，你不能依赖于元素的顺序来访问数据。
影响：不能像列表那样通过数字索引访问元素。
示例：
d = {'c': 3, 'a': 1, 'b': 2}
print(d) # 输出顺序可能是 {'c': 3, 'a': 1, 'b': 2}，但不应依赖这个顺序
使用建议：如果需要有序存储，考虑使用 OrderedDict。
☆可变性：
字典的内容可以在创建后修改。可以添加新的键值对、修改现有键的值、删除键值对。
示例：
d = {'a': 1}
d['b'] = 2 # 添加新键值对
d['a'] = 10 # 修改现有键的值
del d['b'] # 删除键值对
☆键类型限制：
键必须是不可变（可哈希）的数据类型。
原因：字典使用哈希表实现，键的哈希值用于确定存储位置。
常用键类型：字符串、数字、元组（只包含不可变元素）。
值的类型：没有限制，可以是任何数据类型。
示例：
d = {
'string': 'value',
42: 'answer',
(1, 2): 'tuple key',
# [1, 2]: 'list' # 这会引发错误，因为列表是可变的
}
字典综合示例
源码如下：
# 创建字典
person = {"name": "Alice","age": 30,"city": "Wonderland"
}# 访问字典
print(person["name"]) # 输出: Alice# 修改字典
person["age"] = 31# 添加新键值对
person["hobby"] = "Reading"# 删除键值对
del person["city"]# 使用字典方法
print(person.keys()) # 输出: dict_keys(['name', 'age', 'hobby'])
print(person.values()) # 输出: dict_values(['Alice', 31, 'Reading'])
print(person.items()) # 输出: dict_items([('name', 'Alice'), ('age', 31), ('hobby', 'Reading')])
解包（unpacking）
Python 中，解包（unpacking）是指将一个可迭代对象（如列表、元组、字典等）中的元素提取出来，并分别赋值给多个变量的过程。
示例
1.序列解包：
将元组或列表中的元素解包到多个变量中。
# 使用元组解包
coordinates = (10, 20)
x, y = coordinates
print(x) # 输出: 10
print(y) # 输出: 20
# 使用列表解包
values = [1, 2, 3]
a, b, c = values
print(a) # 输出: 1
print(b) # 输出: 2
print(c) # 输出: 3
2.字典解包：
可以使用 ** 来解包字典，将字典中的键值对传递给函数。
def print_info(name, age):
print(f"Name: {name}, Age: {age}")
person = {'name': 'Alice', 'age': 30}
print_info(**person) # 输出: Name: Alice, Age: 30
3.可变数量的解包：
使用星号 * 可以将剩余的元素捕获到一个列表中。
a, *b = [1, 2, 3, 4, 5]
print(a) # 输出: 1
print(b) # 输出: [2, 3, 4, 5]
c, *d, e = [1, 2, 3, 4, 5]
print(c) # 输出: 1
print(d) # 输出: [2, 3, 4]
print(e) # 输出: 5
解包在处理多个变量时非常方便，特别是在处理函数参数、元组和列表等可迭代对象时。
例、使用元组作为函数的返回值可以一次返回多个值
元组可以作为函数的返回值，并且可以一次返回多个值。在Python中，函数可以返回一个元组，调用方可以通过解包来获取这些值——将返回的元组元素值解包到多个变量中。
下面是一个简单的示例：
def calculate(a, b):sum_value = a + bproduct_value = a * breturn sum_value, product_value # 返回一个元组# 调用函数并解包返回值
result_sum, result_product = calculate(5, 3)print("Sum:", result_sum) # 输出: Sum: 8
print("Product:", result_product) # 输出: Product: 15
这篇关于Python青少年简明教程：列表（List）、元组（tuple）和字典（dict）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
