python 列表的类_Python搬砖之旅(4th day)：列表数据类型专题

列表数据类型专题

Python搬砖之旅(4th day)：列表数据类型专题

第1章 列表的创建

列表是在Python编程过程中最常见的数据类型之一。列表是一组"有序的、可重复的元素集合"，也就是说，从数据结构角度看，Python 的列表是一个"长度可变"的、每一个元素顺序排列的"队列"，列表中的每一

个位置存放的都是数据对象的"指针"。

我们可以将不同数据类型的元素"有序"地存放在列表当中，元素与元素之间使用逗号","隔开。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li

[123, 123.5, 'hello', b'Python', [1, 2, 3]]

>>> id(li)

45716616

>>> id(li[0])

1745059104

>>> id(li[1])

29956880

>>> id(li[2])

45734128

>>> id(li[3])

37271792

>>> id(li[4])

45740552

列表创建之后，为什么其中的数据类型可以不一样呢？

因为列表中的每一个的元素，都是一个指针，指向不同的数据对象。我们使用id()函数分别查看li, li[0], li[1], li[2], li[3], li[4]在内存中的地址，发现其实这些元素在内存空间上都是"不连续"的，而正因为列表中包含了指向这些元素的"指针"，这些元素看起来才是"有序"的。下面使用一幅图来说明这个问题。

创建空列表的两种方法：

第1种，使用一对方括号。

li = [] # 创建一个空列表。

>>>

第2种方法：调用list() 方法

li = list()

这两种方法的效果是一样的。

第2章 访问并修改列表元素

与字符串相似，列表也是通过index索引访问列表中的元素。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li[0]

123

>>> li[1]

123.5

>>> li[2]

'hello'

>>> li[3]

b'Python'

>>> li[4]

[1, 2, 3]

>>> li[-1]

[1, 2, 3]

注意：索引的数值不能超出列表的长度(列表中的元素个数)

与字符串不同的是，字符串是"不可修改"的序列，如果要修改字符串中的某个字符需要重新赋值；

但是，列表中的元素可以直接通过索引访问并修改元素。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li[-1] = [1, 2, 3, 4] # 修改列表中最后一个元素

>>> li

[123, 123.5, 'hello', b'Python', [1, 2, 3, 4]]

>>> li[0], li[1] = li[1], li[0] # 列表中前两个元素互换

>>> li

[123.5, 123, 'hello', b'Python', [1, 2, 3, 4]]

小练习：

li = [‘a’, ‘b’, ‘c’]， 将’a’ 改为 ‘A’。

答案：li[0] = ‘A’

第3章 遍历列表元素

列表的遍历有四种方式：

第1种方式：使用while循环

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

i = 0 # 设置索引从0开始

while i < len(li):

print(li[i], end=" ")

i += 1

第2种方式：使用迭代

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

for i in li:

print(i, end=" ")

第3种方式：使用迭代+索引

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

for i in range(len(li)):

print(li[i], end=" ")

第4种：使用enumerate()函数遍历

enumerate()函数可以将一个可迭代对象，如列表、元组或字符串组合成为一个索引序列，同时列出索引和元素值，一般与for 循环结合使用。

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

for i, value in enumerate(li):

print(f'第{i}个索引对应的值是：{value}', end="\n")

第4章 增加列表元素

增加列表元素的方式有3种：

方法1：使用list.insert (index, obj)的方法，将数据对象obj插入到列表指定的位置上。

>>> li = [1, 2, 3]

>>> li.insert(0, "a") # 把字符串"a"插入到列表的第一个位置

>>> li

['a', 1, 2, 3]

方法2：使用list.append(obj)的方法，将数据对象obj插入到列表的最后。

>>> li = [1, 2, 3]

>>> li.append("a") # append()方法会把元素插入到列表末尾

>>> li

[1, 2, 3, 'a']

方法3： 使用list.extend() 方法，将两个列表的元素合并到一个列表中。

>>> li_1 = ["a", "b", "c"]

>>> li_2 = [1, 2, 3]

>>> li_1.extend(li_2)

>>> li_1

['a', 'b', 'c', 1, 2, 3]

第5章 删除列表元素

删除列表元素有3种方法。

方法1：使用del li[index]的方法

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> del li[0]

>>> li

[123.5, 'hello', b'Python', [1, 2, 3]]

>>> del li

>>> li

Traceback (most recent call last):

File "", line 1, in

li

NameError: name 'li' is not defined

说明：

1，使用del 语句，会对列表造成永久性的改变，会将索引对应的元素从列表中删除‘

2，直接使用del + 列表名的方式，会永久性删除该列表。

方法2：

使用list.remove(value)的方式。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li.remove(123)

>>> li

[123.5, 'hello', b'Python', [1, 2, 3]]

>>> li.remove('China')

Traceback (most recent call last):

File "", line 1, in

li.remove('China')

ValueError: list.remove(x): x not in list

说明：

1，使用remove()方法，会对列表造成永久性的改变，会将值所对应的元素从列表中删除‘；

2，删除不存在于列表中的值会报错。

方法3：

使用list.pop(index)的方式

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li.pop()

[1, 2, 3]

>>> li

[123, 123.5, 'hello', b'Python']

>>> li.pop(0)

123

>>> li

[123.5, 'hello', b'Python']

说明：

1，使用pop()方法，会对列表造成永久性的改变，会将索引所对应的元素从列表中删除‘并返回该值；

2，pop()方法默认删除并返回列表中最后一个元素，使用索引后删除并返回索引对应的值。

第6章 列表的运算符

同字符串一样，列表可以使用"+“实现字符串的拼接，用”*"实现字符串的序列复制。

用in 和 not in 判断元素是否存在于列表当中。

>>> li_1, li_2 = ["a", "b", "c"], [1, 2, 3]

>>> print(li_1 + li_2) # + 运算符实现列表元素的拼接

['a', 'b', 'c', 1, 2, 3]

>>> print(li_1 * 2) # * 运算符实现列表元素的复制

['a', 'b', 'c', 'a', 'b', 'c']

>>> print('a' in li_1) # in 运算符判断元素是否属于列表

True

>>> print(2 not in li_2) # not in 运算符判断元素是否不属于列表

False

注意："+" 运算符的功能等同于list.extend()方法，但是推荐使用"+" 运算符，可以获得更直观的效果和更高的运行效率。

第7章 列表的常用内置函数

len() : 返回列表的长度，即列表中包含的元素个数；

max() : 返回列表中的元素最大值；

min()： 返回列表中的元素最小值。

count() ： 返回元素在列表中出现的次数

index(value)：从列表中找出value第一个匹配项的索引位置

copy() ： 复制列表

clear() ： 清空列表

>>> li = [1, 1, 2, 2, 2, 4, 3, 5]

>>> print(len(li)) # 计算列表长度

8

>>> print(min(li)) # 求列表中的最小值

1

>>> print(max(li)) # 求列表中的最大值

5

>>> print(li.count(2)) # 求列表中元素出现的次数

3

>>> print(li.index(2)) # 求元素在列表中首次出现的位置

2

>>> li_2 = li.copy() # 复制列表

>>> li_2

[1, 1, 2, 2, 2, 4, 3, 5]

>>> li_2.clear() # 清除列表

>>> li_2

[]

注意：列表中元素比较大小，

1，字符串与字符串之间比较转为ASCII码比较；

2，字符串与数字之间不可以比较，否则会报错。

第8章 列表的切片

同字符串一样，我们可以对列表进行切片。

切片的语法格式是：list[start : stop : step]

当start起点位置是列表首位时，start 可以忽略；当end终点位置是len(list)+1时，即取到列表最后一位时，stop 可以省略；当步长为1时，step可以省略。

同字符串一样，列表中元素的位置按从左向右的顺序，从0开始依次向后；

逆向位置排列是从最后一个元素的位置-1开始，向前依次递减；

切片的索引发生错误并不会报错，而是会返回空字符串。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]

>>> li[:] # 该方法相当于li[0:len(li)+1:1]

[123, 123.5, 'hello', b'Python', [1, 2, 3]]

>>> li[::2] # 该方法相当于li[0:len(li)+1:2]

[123, 'hello', [1, 2, 3]]

>>> li[1::2] # 该方法相当于li[1:len(li)+1:2]

[123.5, b'Python']

>>> li[::-1] # 该方法相当于li[-1:-6:-1]

[[1, 2, 3], b'Python', 'hello', 123.5, 123]

>>> li[::-2] # 该方法相当于li[-1:-6:-2]

[[1, 2, 3], 'hello', 123]

>>> li[-2::-2] # 该方法相当于li[-2:-6:-2]

[b'Python', 123.5]

需要注意的是，

1，切片的方向与步长方向应一致，否则会返回空字符串。

2，修改列表的切片会影响列表本身。

第9章 列表的排序

列表的排序：

升序排列：使用list.sort()方法或sorted(list)方法

降序排列：使用list.sort(reverse=True)方法

>>> li = [32, 77, 64, 27, 55, 96, 13]

>>> li.sort() # sort()方法会永久改变列表中元素的顺序

>>> li

[13, 27, 32, 55, 64, 77, 96]

>>> li = [32, 77, 64, 27, 55, 96, 13]

>>> print(sorted(li)) # sorted()方法是一个临时性方法，不会永久改变列表中元素的顺序

[13, 27, 32, 55, 64, 77, 96]

>>> print(li)

[32, 77, 64, 27, 55, 96, 13]

>>> li.sort(reverse = True) # 实现列表的降序排列需要使用参数reverse=True

>>> li

[96, 77, 64, 55, 32, 27, 13]

注意：

1，sort()方法会永久改变列表中元素的顺序。

2，sorted()方法是一个临时性方法，不会永久改变列表中元素的顺序。

3，实现列表的降序排列需要使用参数reverse=True。

第10章 列表的转置

实现列表的转置有3种方法：

方法1：使用切片。注意，切片只是在列表的副本上操作，并不会影响列表本身。

>>> li = [32, 77, 64, 27, 55, 96, 13]

>>> print(li[::-1])

[13, 96, 55, 27, 64, 77, 32]

>>> print(li)

[32, 77, 64, 27, 55, 96, 13]

方法2：使用list.reverse()方法。注意，reverse()方法会永久改变列表中元素的顺序。

>>> li = [32, 77, 64, 27, 55, 96, 13]

>>> li.reverse() # reverse()方法会永久地改变列表中元素的顺序

>>> print(li)

[13, 96, 55, 27, 64, 77, 32]

>>> print(li.reverse()) # reverse()方法不返回值

None

方法3：使用reversed(list)方法。注意，reversed方法是一个临时性的方法，不会改变列表本身。

>>> li = [32, 77, 64, 27, 55, 96, 13]

>>> print(reversed(li)) # reversed()方法不能直接使用，需要转化为列表才可以使用

>>> li_2 = list(reversed(li))

>>> print(li_2) # 强制类型转化为列表

[13, 96, 55, 27, 64, 77, 32]

>>> print(li)

[32, 77, 64, 27, 55, 96, 13]

第11章 列表的嵌套

列表中包含的元素仍然是列表，通常称为列表的嵌套。嵌套的层数也称之为列表的维度。

比如下面这个列表就是一个典型的二维列表，我们可以通过索引的方式来访问子列表中的元素。

观察下列代码，学习使用跌打和索引的方法访问二维列表中的元素。

li = [[1, 2, 3],[1.1, 2.2, 3.3],["a", "b", "c"]]

# 获得第二个子列表中1.1这个元素

print(li[1][0])

# 遍历二维列表

# 方法1：迭代

for list_item in li:

for item in list_item:

print(item, end=" ")

print()

# 方法2：使用索引

for i in range(len(li)):

for j in range(len(li[i])):

print(li[i][j], end=" ")

标签：Python,123.5,元素,数据类型,列表,4th,print,li

来源： https://blog.csdn.net/qq_27381427/article/details/111616446