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 False
  for i in range(2, int(num**0.5) + 1):
    if num % i == 0:
      return False
  return True

primes = [num for num in range(2, 100) if is_prime(num)]
print(f"100 以内的所有素数：{primes}")

例2、使用列表的猜数字游戏

import random

def play_guessing_game():
  """猜数字游戏。"""
  secret_number = random.randint(1, 100)
  guesses = []
  attempts = 0

  print("欢迎来到猜数字游戏！")
  print("我已选择一个 1 到 100 之间的数字。")

  while True:
    try:
      guess = int(input("请输入你的猜测："))
      guesses.append(guess)
      attempts += 1

      if guess < secret_number:
        print("太低了！")
      elif guess > secret_number:
        print("太高了！")
      else:
        print(f"恭喜你！你猜对了！你用了 {attempts} 次尝试。")
        print(f"你猜过的数字：{guesses}")
        break
    except 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 + b
    product_value = a * b
    return sum_value, product_value  # 返回一个元组

# 调用函数并解包返回值
result_sum, result_product = calculate(5, 3)

print("Sum:", result_sum)          # 输出: Sum: 8
print("Product:", result_product)   # 输出: Product: 15