目录

列表(元组)基本操作符回顾len()函数在列表与元组上的使用列表(元组)之间的累加与乘法in和notin在列表(元组)中的用法列表常用方法append()函数insert()函数count()函数remove()函数Python内置函数delreverse()函数sort()函数clear()函数copy()函数extend()函数小练习：完成列表合并功能

列表(元组)基本操作符回顾

len()函数在列表与元组上的使用

示例如下：

names = ["Neo", "Lily", "Jack"]
length = len(names)
print(length)

# 执行结果如下
# >>> 3

注意：len()函数可以计算除了数字类型之外的其他所有数据类型的长度

列表(元组)之间的累加与乘法

示例如下：

names = ["Neo", "Lily", "Jack"]
new_names_01 = names + names
print(new_names_01)

names = ["Neo", "Lily", "Jack"]
new_names_01 = names * 2
print(new_names_01)

# 输出结果如下：
# >>> ["Neo", "Lily", "Jack", "Neo", "Lily", "Jack"]
# >>> ["Neo", "Lily", "Jack", "Neo", "Lily", "Jack"]

in 和 not in 在列表(元组)中的用法

in ：判断某个成员（元素）是否在该数据结构中，返回结果为布尔值。

not in ：判断某个成员（元素）是否不在该数据结构中，返回结果为布尔值。

示例如下：

names = ["Neo", "Lily", "Jack"]
print(bool("Adam" in names))
print(bool("Adam" not in names))

# 执行结果如下：
# >>> False
# >>> True

列表常用方法

append() 函数

append()函数的功能：将一个元素添加当当前列表中

append()函数的用法：list_append(new_item) ，new_item为添加进列表的新的元素(成员)

append()函数的注意事项：

被添加的元素止水被添加到末尾append() 函数是在原有列表的基础上进行添加，不需要额外的添加新的变量

示例如下：

names = ["Neo"]
names.append("Jack")

print(names)

# 执行结果如下：
# >>> ["Neo", "Jack"]

a = [1, 2, 3]
b = [4, 5, 6]

print(a.append(1))
print(a)

a.append(b)
print(a)

# 执行结果如下：
# >>> [1, 2, 3, 1]
# >>> Node
# >>> [1, 2, 3, 1, [4, 5, 6]]		a.append(b) 会将整个列表当做一个元素添加进去

这里我们注意到 print(a.append(1)) 返回的是 Node ，这是为什么呢？

原因是append方法只是在恰当的位置修改原来的列表！也就是说，不是返回一个列表，而只是修改原来的列表，所以如果用 等式 输出的话，返回是None 。去掉返回值即可得到新的列表！

看下面两个示例：

# 原代码：

list= [1,2,3,4]
list= list.append(5)
print(list)

# 输出：
# >>> None


# 修改后代码

list= [1,2,3,4]
list.append(5)
print(list)

# 输出：
# >>> 1,2,3,4,5

insert() 函数

insert() 函数的功能：讲一个元素添加到列表的指定位置中

insert() 函数的用法：list.insert(index, new_item) , index为新的元素放在的新的位置(数字，下标位)，new_item为填的新成员(元素)

insert() 函数与append()函数的区别：

insert() 函数可以将元素添加至任意的位置，而append()函数只能将元素添加之末尾。如果insert() 函数传入的位置不存在，则将新的元素添加至列表结尾

示例如下：

friuts = ["橘子", "香蕉", "火龙果"]
friuts.insert(1, "苹果")

print(friuts)

# 执行结果如下：
# >>> ["橘子", "苹果", "香蕉", "火龙果"]


friuts.insert(10, "鸭梨")

print(friuts)

# 执行结果如下：
# >>> "橘子", "苹果", "香蕉", "火龙果", "鸭梨"]

count() 函数

count() 函数的功能：返回列表(元组)中某个成员(元素)的个数

count() 函数的用法：inttype = list.count(item) , item为想要查询的个数

count() 函数的注意事项：如果查询的成员(元素)不存在，则返回 0；列表只会检查完整元素是否存在需要计算的内容。

示例如下：

friuts = ["橘子", "香蕉", "火龙果", "香蕉", "苹果"]
count = friuts.count("香蕉")
print("friuts 列表中香蕉出现的次数为 " + str(count) + " 次")

# 执行结果如下：
# >>> friuts 列表中香蕉出现的次数为 2 次


# 注意事项：如果查询的成员(元素)不存在，则返回 0；列表只会检查完整元素是否存在需要计算的内容。
friuts = ["橘子", "香蕉", "火龙果", "香蕉", "苹果"]
count = friuts.count("香")
print("friuts 列表中\"香\"出现的次数为 " + str(count) + " 次")

# 执行结果如下：
# >>> friuts 列表中"香"出现的次数为 0 次

remove() 函数

remove() 函数的功能：删除列表中的某个元素

remove() 函数的用法：list_remove = list.remove(item) , item为想要删除的元素

remove() 函数的注意事项：

如果删除的成员(元素)不存在，则会直接报错如果被删除的元素有多个，只会删除第一个remove() 函数不会返回一个新的列表，而是在原有的列表中对成员(元素)执行删除动作

示例如下：

books = ["Python", "Java", "PHP"]
books.remove("PHP")
print(books)

# 执行结果如下：
# >>> ["Python", "Java"]

Python内置函数 del

del 函数的功能：将变量完全删除(即踢打内存管家将变量从内存中删除)

示例如下：

books = ["Python", "Java", "PHP"]
books.del()
print(books)

# 执行结果如下：
# >>> NameError: name "books" is not defined. Did you mean: "bool"?

reverse() 函数

reverse() 函数的功能：对当前列表顺序的反转

reverse() 函数的用法： list = list.reverse() , 无参数传递

示例如下：

books = ["Python", "Java", "PHP"]
books.reverse()
print(books)

# 执行结果如下：
# >>> ["PHP", "Java", "Python"]

sort() 函数

sort() 函数的功能：对当前列表按照一定的规律进行排序

sort() 函数的用法： list = list.sort(cmp=Node, key=Node, reverse=False)

cmp —> 可选参数，制定排序方案的函数key —> 参数比较reverse —> 排序规则，reverse = True (降序)；reverse = False (升序)，升序是默认状态这里的 cmp 和 key涉及到函数的知识点，后续的函数相关章节会详细介绍

sort() 函数的注意事项：列表中的元素类型必须相同，否则会报错，无法排序

示例如下：

books = ["Python", "C", "PHP", "Go", "C++", "Java"]
books.sort()
print(books)

# 执行结果如下：
# >>> ["C", "C++", "Go", "Java", "PHP", "Python"]

int_lists = [79, 6, 99, 46, 30]
int_lists.sort(reverse=True)
print(int_lists)

# 执行结果如下：
# >>> [99, 79, 46, 30, 6]

test_list = ["Hello", 666, 3.14, True]
test_list.sort()
print(test_list)

# 执行结果如下：
# >>> TypeError: "<" not supported between instances of "int" and "str"

clear() 函数

clear() 函数的功能：将当前列表的数据清空

clear() 函数的用法： list = list.clear() ， 该函数无参数，无返回值

示例如下：

int_list = [79, 6, 99, 46, 30]
int_list.clear()
print(int_list)
print(len(int_list))

# 执行结果如下：
# >>> []
# >>> 0

思考一个问题：当我们使用 clear() 函数 清空一个列表时，和重新命名一个空的列表，哪个更节省资源？

其实相对来说使用 clear() 函数更节省资源；当我们创造一个变量的时候，会占用一个内存地址，使用该变量之后该变量地址则会被内存管家清空。再次使用时，又会生成新的内存地址，这个过程也是需要消耗资源的，只是因为速度处理的比较快我们无法感知罢了。

copy() 函数

copy() 函数的功能：将当前列表复制一份新的列表，虽然新的列表虽与旧的列表的内容相同，但是内存地址不同

copy() 函数的用法：list = list.copy() ，该函数无参数，返回一个与旧列表一模一样的列表

copy() 函数与 2次赋值 的区别：

二次赋值的变量与原始变量共享相同的内存地址空间copy() 函数创建的新列表与原始列表不是一个内存空间，新列表的变量值不因原列表变量的值的变更而变更copy() 函数属于浅拷贝

示例如下：

old_list = [1, 2, 3, 4, 5]
new_list = old_list.copy()

print(new_list)
print("\"old_list\"内存地址为：" + str(id(old_list)), "\"new_list\"内存地址为：" + str(id(new_list)))

# 执行结果如下：
# >>> [1, 2, 3, 4, 5]
# >>> "old_list"内存地址为：2175764462080 "new_list"内存地址为：2175767330496

copy() 函数与 2次赋值 的区别示例如下：

old_list = [1, 2, 3, 4, 5]
new_list_01 = old_list
new_list_02 = old_list.copy()

old_list.append(6)

print(new_list_01)
print(new_list_02)

# 执行结果如下：
# >>> [1, 2, 3, 4, 5, 6]
# >>> [1, 2, 3, 4, 5]

浅拷贝

什么是浅拷贝？

通俗的说，我们有一个列表 a，列表里的元素还是列表。当我们拷贝出新列表 b 后，无论是 a 还是 b 的内部的列表中的数据发生了变化后，相互之间都会受到影响。这就是浅拷贝。

浅拷贝示例如下：

old_list = [[1, 2, 3], [4, 5]]
new_list = old_list.copy()

old_list[1].append(6)
print(str(old_list), "--------," + str(new_list))

# 执行结果如下：
# >>> [[1, 2, 3], [4, 5, 6]] --------,[[1, 2, 3], [4, 5, 6]]


new_list[0].append(0)
print(str(old_list), "--------," + str(new_list))

# 执行结果如下：
# >>> [[1, 2, 3, 0], [4, 5, 6]] --------,[[1, 2, 3, 0], [4, 5, 6]]

深拷贝

什么是深拷贝？

深拷贝不仅对列表第一层进行了 copy ，对深层的数据也进行了 copy， 原始变量与新变量之间完全不共享数据，这就是深拷贝。

深拷贝示例如下：

old_list_deepcopy = [[1, 2, 4], [4, 5]]
new_list_deepcopy = copy.deepcopy(old_list_deepcopy)

old_list_deepcopy[1].append(6)
print(str(old_list_deepcopy), "--------," + str(new_list_deepcopy))

# 执行结果如下：
# >>> [[1, 2, 4], [4, 5, 6]] --------,[[1, 2, 4], [4, 5]]


new_list_deepcopy[0].append(0)
print(str(old_list_deepcopy), "--------," + str(new_list_deepcopy))

# 执行结果如下：
# >>> [[1, 2, 4], [4, 5, 6]] --------,[[1, 2, 4, 0], [4, 5]]

关于浅拷贝与深拷贝，我们再来看看对 数字类型 和 字符串类型又是怎样的，示例如下：

str_1 = "python"
print("str_1: ", str_1, id(str_1))

str_2 = str_1
print("str_2: ", str_2, id(str_2))

str_3 = copy.copy(str_2)
print("str_3: ", str_3, id(str_3))

str_4 = copy.deepcopy(str_1)
print("str_4: ", str_4, id(str_4))

# 执行结果如下：
# >>> str_1:  python 140222883317104
# >>> str_2:  python 140222883317104
# >>> str_3:  python 140222883317104
# >>> str_4:  python 140222883317104

可以看出，数字类型与字符串类型的浅拷贝与深拷贝是没有区别的，都是指向的同意内存地址，所以深拷贝与浅拷贝是没有意义的

extend() 函数

extend() 函数的功能：将其他列表或元组中的元素一次性的导入到当前列表中

extend() 函数的用法：list = list.extend(iterable) ，iterable 代表列表或元组，该函数无返回值。

示例如下：

students = ["Neo", "Jack", "Lily"]
new_students = ("Lilei", "Lily")
print(id(students))

# 执行结果如下：
# >>> 2032966498816

students.extend(new_students)

print(students)
print(id(students))

# 执行结果如下：
# >>> ["Neo", "Jack", "Lily", "Lilei", "Lily"]        相同的成员(元素)并不会覆盖掉
# >>> 2032966498816

小练习：完成列表合并功能

例如给出两个列表[1, 3, 5, 7, 9]和[2, 4, 6, 8, 10]，最终合并为[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list_1 = [1, 3, 5, 7, 9]
list_2 = [2, 4, 6, 8, 10]
list_1.extend(list_2)
print(list_1)

# 执行结果如下：
# >>> [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]


list_1.sort()
print(list_1)

# 执行结果如下：
# >>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

以上就是Python学习之列表常用方法总结的详细内容，更多关于Python列表的资料请关注脚本之家其它相关文章！

关键词： 注意事项 常用方法 是否存在