Python快速上手（六）

Python3 列表和元组

Python3 列表

列表（List）是一种有序、可变的数据类型，用于存储一组元素。列表可以包含任意类型的元素，甚至可以包含其他列表。列表是 Python 中最常用、最灵活的数据结构之一

1.创建列表

在 Python 中，列表可以包含任意数量的元素，并且这些元素可以是不同类型的数据。你可以使用方括号 [] 或者 list() 函数来创建列表。

my_list = [1, 2, 3, 4, 5]  # 包含整数的列表
mixed_list = [1, "hello", True, 3.14]  # 包含不同类型元素的列表
empty_list = []  # 创建一个空列表

2.访问列表元素

列表中的每个元素都有一个索引，索引从 0 开始，因此第一个元素的索引为 0，第二个元素的索引为 1，以此类推。

first_element = my_list[0]   # 1
second_element = my_list[1]  # 2
last_element = my_list[-1]   # 5，使用负数索引表示倒数第几个元素，-1 表示最后一个元素

3.列表切片

列表切片是获取列表中的一部分的一种方法，它可以返回一个新的列表，包含原列表中指定范围的元素。

sub_list = my_list[1:3]    # [2, 3]，切片范围是 [1, 3)，即包含起始索引但不包含结束索引

4.修改列表元素

列表是可变的数据类型，你可以通过索引来修改列表中的元素。

my_list[0] = 100

5.列表方法

Python 提供了许多内置方法来操作列表，这些方法可以方便地添加、删除、查找和排序列表中的元素。

• append(): 在列表末尾添加一个元素。
• extend(): 将另一个列表中的元素添加到当前列表末尾。
• insert(): 在指定位置插入一个元素。
• remove(): 删除列表中的指定元素。
• pop(): 删除并返回指定位置的元素。
• index(): 返回指定元素在列表中的索引。
• count(): 返回指定元素在列表中的出现次数。
• sort(): 对列表进行排序。
• reverse(): 将列表中的元素倒序排列。

my_list.append(6)
my_list.extend([7, 8, 9])
my_list.insert(0, 0)
my_list.remove(9)
popped_element = my_list.pop(1)
index_of_5 = my_list.index(5)
count_of_5 = my_list.count(5)
my_list.sort()
my_list.reverse()

6.列表操作符

Python 还提供了一些操作符来操作列表，例如 +、*、in 等。

concatenated_list = [1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]
repeated_list = [1, 2, 3] * 3              # [1, 2, 3, 1, 2, 3, 1, 2, 3]
element_exists = 1 in [1, 2, 3]            # True

注意事项

• 列表是可变的，可以动态地添加、删除和修改元素。
• 列表是有序的，可以通过索引来访问列表中的元素。
• 列表是可迭代的，你可以使用循环来遍历列表中的元素。
• 列表是 Python 编程中最常用的数据结构之一，熟练掌握列表的使用和操作将有助于编写更加灵活和高效的代码。

Python3 元组

元组（Tuple）是 Python 中的一种有序、不可变的数据结构。与列表相似，元组可以包含多个元素，但一旦创建后，元组中的元素不可修改，因此元组是不可变的。

1.创建元组

你可以使用圆括号 () 或 tuple() 函数来创建元组。

my_tuple = (1, 2, 3, 4, 5)  # 使用圆括号创建元组
empty_tuple = ()  # 创建一个空元组

2.访问元组元素

元组中的元素也是有序的，你可以使用索引来访问元组中的单个元素。索引从 0 开始，与列表相同。

first_element = my_tuple[0]   # 1
second_element = my_tuple[1]  # 2
last_element = my_tuple[-1]   # 5

3.元组切片

元组切片与列表切片类似，可以获取元组中的子元组。

sub_tuple = my_tuple[1:3]    # (2, 3)，切片范围是 [1, 3)，即包含起始索引但不包含结束索引

4.元组内置函数

• len()
  len() 函数用于返回元组中元素的数量。

  my_tuple = (1, 2, 3, 4, 5)
  length = len(my_tuple)  # 5
  

• max() 和 min()
  max() 和 min() 函数分别用于返回元组中的最大值和最小值。

  my_tuple = (10, 20, 30, 40, 50)
  maximum = max(my_tuple)  # 50
  minimum = min(my_tuple)  # 10
  

• sum()
  sum() 函数用于返回元组中所有元素的总和，要求元组中的元素必须是数值型。

  my_tuple = (1, 2, 3, 4, 5)
  total = sum(my_tuple)  # 15
  

• tuple()
  tuple() 函数用于将可迭代对象（如列表、字符串等）转换为元组。

  my_list = [1, 2, 3, 4, 5]
  converted_tuple = tuple(my_list)  # (1, 2, 3, 4, 5)
  

• sorted()
  sorted() 函数用于返回一个排序后的列表，可以用于对元组进行排序。

  my_tuple = (5, 3, 1, 4, 2)
  sorted_list = sorted(my_tuple)  # [1, 2, 3, 4, 5]
  

• any() 和 all()
  any() 函数用于判断元组中是否存在任何为 True 的元素，如果存在则返回 True，否则返回 False。而 all() 函数用于判断元组中所有元素是否都为 True，如果是则返回 True，否则返回 False。

  my_tuple1 = (True, False, True)
  my_tuple2 = (True, True, True)result1 = any(my_tuple1)  # True
  result2 = all(my_tuple1)  # Falseresult3 = any(my_tuple2)  # True
  result4 = all(my_tuple2)  # True
  

5.元组运算符

在 Python 中，元组支持一些运算符，这些运算符允许你对元组进行连接、重复、比较以及成员检查等操作。让我们逐个解释这些元组运算符：

• 元组连接运算符 +
  +运算符用于连接两个元组，生成一个新的元组。

  tuple1 = (1, 2, 3)
  tuple2 = (4, 5, 6)
  result = tuple1 + tuple2  # 结果为 (1, 2, 3, 4, 5, 6)
  

• 元组重复运算符 *
  *运算符用于重复一个元组多次，生成一个新的元组。

  tuple1 = (1, 2)
  result = tuple1 * 3  # 结果为 (1, 2, 1, 2, 1, 2)
  

• 元组比较运算符
  元组比较运算符用于比较两个元组的大小。元组比较是基于元组中的元素依次比较的，从第一个元素开始比较，直到找到不同的元素为止。
  ==：等于运算符，用于检查两个元组是否相等。
  !=：不等于运算符，用于检查两个元组是否不相等。
  <：小于运算符，用于检查一个元组是否小于另一个元组。
  >：大于运算符，用于检查一个元组是否大于另一个元组。
  <=：小于等于运算符，用于检查一个元组是否小于或等于另一个元组。
  >=：大于等于运算符，用于检查一个元组是否大于或等于另一个元组。

  tuple1 = (1, 2, 3)
  tuple2 = (1, 2, 4)
  equal = tuple1 == tuple2    # False
  not_equal = tuple1 != tuple2 # True
  less_than = tuple1 < tuple2  # True
  greater_than = tuple1 > tuple2 # False
  

• 成员运算符 in 和 not in
  成员运算符用于检查一个元素是否存在于元组中。

  element_exists = 1 in (1, 2, 3)       # True
  element_not_exists = 4 not in (1, 2, 3)  # True
  

注意事项

元组是不可变的，一旦创建后，元组中的元素不可修改。
元组是有序的，可以通过索引来访问元组中的元素。
元组可以包含不同类型的元素，甚至可以包含其他元组。