Python基础语法知识4

八、列表（list）

1.访问列表的值

在Python中，访问列表（List）中的值是通过索引（Index）来实现的。索引是列表中每个元素的位置编号，从0开始计数。这意味着列表中的第一个元素的索引是0，第二个元素的索引是1，依此类推。在python中一共有以下几种方式来访问列表的值。

• 索引

索引是从0开始的，即列表中的第一个元素的索引是0，第二个元素的索引是1，依此类推。

• 反向索引

索引可以是正数也可以是负数。正数索引从列表的开头开始计数，而负数索引则从列表的末尾开始计数，其中-1表示最后一个元素，-2表示倒数第二个元素，依此类推。例如：

list = [10, 20, 30, 40, 50]  
  
# 使用正数索引访问元素  
print(list[0])  # 输出: 10  
print(list[4])  # 输出: 50  
  
# 使用负数索引访问元素  
print(list[-1])  # 输出: 50  
print(list[-2])  # 输出: 40

• 切片索引

除了使用单个索引来访问元素外，Python还允许你使用切片来访问列表的一部分。切片操作返回列表的一个子列表，其语法是list[start:stop:step]，其中start是切片开始的索引（包含），stop是切片结束的索引（不包含），step是步长（默认为1）。例如：

list = [10, 20, 30, 40, 50]  
  
# 获取从索引1到索引3（不包含）的元素  
print(list[1:3])  # 输出: [20, 30]  
  
# 获取从索引2开始到列表末尾的元素，步长为2  
print(list[2:])  # 输出: [30, 40, 50]  
print(list[2::2])  # 输出: [30, 50]  
  
# 使用负数索引进行切片  
print(list[-3:])  # 输出: [30, 40, 50]

注意：

• 对于可变类型（如列表），切片操作是浅拷贝
• 对于不可变类型（如整数、浮点数、字符串），切片操作在逻辑上类似于“拷贝”，但由于不可变类型的特性，这种“拷贝”不会引入新的行为变化，因此可以看作是深拷贝的一种特殊情况（但严格来说，这并不算是深拷贝）。例如：

list1 = [[1, 2], 3, 4, 5, 6]  
list2 = list1[:]  # 切片操作  
  
# 修改list1中的子列表和末尾元素的值 
list2[0][0] = 10  
list2[4]=100
  
# 查看list1的变化  
print(list1)  # 输出: [[10, 2], 3, 4, 5, 6]  
print(list1)
# 可以看到，list1中的子列表元素被修改了,但是末尾的元素并未被修改

2.更新列表

在Python中，你可以使用append()方法向列表末尾添加一个元素，或者使用insert()方法在指定位置插入元素。例如：

# 使用append()添加元素  
list = [1, 2, 3]  
list.append(4)  # 结果: [1, 2, 3, 4]  
  
# 使用insert()在指定位置插入元素  
list.insert(1, 1.5)  # 在索引1的位置插入1.5，结果: [1, 1.5, 2, 3, 4]

3.删除列表中的元素

删除列表中的元素，可以使用remove()方法删除第一个匹配的元素，或者使用pop()方法删除指定索引的元素（并可以返回该元素）。还可以使用del语句来删除元素。

# 使用remove()删除元素  
list = [1, 1.5, 2, 3, 4]  
list.remove(1.5)  # 删除第一个匹配的元素1.5，结果: [1, 2, 3, 4]  
  
# 使用pop()删除并返回指定索引的元素  
x1 = my_list.pop(1)  # 删除索引1的元素2，并返回它，结果: [1, 3, 4]，x1的值为2  
  
# 使用del语句删除元素  
del ist[1]  # 删除索引1的元素3，结果: [1, 4]

4.列表操作符

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x)	1 2 3	迭代

5.嵌套列表

嵌套列表是Python中一种非常有用的数据结构，它允许你在一个列表内部包含另一个或多个列表。这种结构可以非常灵活地表示复杂的数据关系，如二维数组、表格数据、树形结构等。例如：

students = [  
    ["Alen", [90, 85, 92]],  
    ["Bob", [88, 95, 78]],  
    ["Click", [75, 82, 88]]  
]

在这个例子中，students是一个列表，它包含了三个元素，每个元素本身也是一个列表。外层的列表代表学生列表，内层的第一个元素是学生的名字，第二个元素是该学生的成绩列表。

要访问嵌套列表中的元素，你需要使用多个索引。例如，要访问Alice的第二门课程的成绩，你可以这样做

alen_second_grade = students[0][1][1]  # 结果: 85

6.Python列表常用API

Python中的列表是一种非常灵活且功能强大的数据结构，它提供了许多内置的方法（API）来执行各种操作，如添加、删除、修改元素，以及查询和遍历列表等。以下是一些Python列表常用的API：

1. 添加元素

• append(x): 将元素x添加到列表的末尾。
• extend(iterable): 将可迭代对象（如另一个列表）中的所有元素添加到列表的末尾。
• insert(i, x): 在指定位置i插入元素x。

2. 删除元素

• remove(x): 移除列表中第一个值为x的元素。如果元素不存在，则抛出ValueError。
• pop([i]): 移除并返回列表中的元素（默认为最后一个元素）。如果指定了索引i，则移除该位置的元素。
• clear(): 移除列表中的所有元素，使其变为空列表。
• del list[i]: 使用del语句删除指定索引i的元素。

3. 修改元素

• 直接通过索引赋值来修改元素：list[i] = x。

4. 查询元素

• index(x): 返回列表中第一个值为x的元素的索引。如果元素不存在，则抛出ValueError。
• count(x): 返回列表中值为x的元素出现的次数。

5. 列表排序

• sort(key=None, reverse=False): 对列表进行原地排序。可选参数key用于指定一个函数，该函数会在每个元素上调用并作为排序的依据；reverse为True时表示降序排序。
• sorted(iterable, key=None, reverse=False): 对可迭代对象进行排序，并返回一个新的列表。参数与sort()方法相同。

6. 列表的切片

• 切片操作允许你获取列表的一个子集。语法为list[start:stop:step]，其中start是起始索引（含），stop是结束索引（不含），step是步长。

7. 列表的拼接和重复

• 使用+操作符可以拼接两个列表。
• 使用*操作符可以重复列表中的元素。

8. 列表的迭代

• 你可以使用for循环来遍历列表中的每个元素。
• 列表还支持enumerate()函数，它可以在迭代时同时获取元素的索引和值。

9. 列表的转换

• 列表可以与其他类型的数据结构（如元组、集合、字典）进行转换，通常使用列表推导式或内置函数（如list(), tuple(), set(), dict()）来实现。

九、Python元组(tuple)

1.创建元组

在Python中，元组是一种有序的数据集合，与列表类似，但元组是不可变的，即一旦创建，就不能更改其元素。创建元组很简单，只需要将元素放在圆括号()中，元素之间用逗号,分隔即可。如果元组中只有一个元素，那么需要在该元素后面加上逗号,，以区分该元素和圆括号本身的含义。

# 创建一个包含多个元素的元组  
tuple1 = (1, 2, 3, 4, 5)  
print(tuple1)  #(1, 2, 3, 4, 5)
  
# 创建一个只包含一个元素的元组，注意元素后面的逗号  
tuple2 = (5,)  
print(tuple2)  #(5,)
  
# 不带括号的单个元素不是元组  
tuple3 = 5  
print(type(tuple3))  # 输出: <class 'int'>  
  
# 但是，如果元素是可迭代对象（如列表），则即使没有括号和逗号，它也不会被解释为元组  
# 下面的例子是一个列表，不是元组  
tuple4 = [5]  
print(type(tuple4))  # 输出: <class 'list'>

注意：

• 元组是不可变的，这意味着你不能修改元组中的元素。但是，如果元组包含可变对象（如列表），则这些可变对象的内容可以被修改，而不会改变元组的结构。
• 创建只包含一个元素的元组时，必须在元素后面加上逗号,，以区分元组和普通的圆括号表达式。

2.访问元组

在Python中，访问元组（Tuple）中的元素非常直接，因为元组是有序的数据集合。你可以通过索引来访问元组中的元素，索引是从0开始的。以下是一些访问元组元素的示例：

my_tuple = (1, 2, 3, 4, 5)  
  
# 访问第一个元素（索引为0）  
first_element = my_tuple[0]  
print(first_element)  # 输出: 1  
  
# 访问最后一个元素（使用-1作为索引）  
last_element = my_tuple[-1]  
print(last_element)  # 输出: 5

  
# 访问第二个到第四个元素（不包括索引为4的元素）  
sub_tuple = my_tuple[1:4]  
print(sub_tuple)  # 输出: (2, 3, 4)  
  

# 访问从第一个元素到倒数第二个元素  
sub_tuple_to_penultimate = my_tuple[:-1]  
print(sub_tuple_to_penultimate)  # 输出: (1, 2, 3, 4)

3.修改

在Python中，元组是不可变的序列类型，这意味着你不能直接修改元组中的元素。但是，你可以通过一些操作来“组合”或“链接”多个元组，以创建一个新的元组。这通常通过使用加号（+）操作符）来实现。下面是一些例子：

tuple1 = (1, 2, 3)  
tuple2 = (4, 5, 6)  
  
# 使用加号操作符链接元组  
tuple3 = tuple1 + tuple2  
  
print(tuple3)  # 输出: (1, 2, 3, 4, 5, 6)

4.删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)#name 'tup' is not defined

5.元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3)+(4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接得到一个新的元组
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x)	1 2 3	迭代

6.元组不可变

元组是不可变的，这意味着你不能直接修改元组中的元素。如果你尝试给元组的一个索引赋值，Python会抛出一个TypeError。元组的不可变性有几个重要的好处：

1. 性能：由于元组是不可变的，Python解释器可以在底层对它们进行优化，以提高访问速度。

2. 线程安全：在多线程环境中，由于元组的内容不会改变，因此不需要担心数据竞争（race condition）或同步问题。

3. 哈希性：由于元组是不可变的，因此它们可以用作字典（dict）的键或集合（set）的元素，因为Python要求字典的键和集合的元素必须是可哈希的（hashable），而不可变类型是可哈希的。

7.元组常用API

元组在Python中是一种不可变的数据结构，用于存储序列化的数据项。由于其不可变性，元组没有像列表那样丰富的API来修改其内容。以下是一些元组常用的API：

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。