python列表

Python中没有数组，但是加入了更加强大的列表。

从形式上看，列表会将所有元素都放在一对中括号 [] 中，相邻元素之间用逗号分隔，如下所示：

[element1,element2,element3,...,elementn]

格式中，element1~elementn表示列表中的元素，个数没有限制，只要是Python支持的数据类型就可以。

从内容上看，列表可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且和数组不同的是，在同一个列表中元素的类型也可以不同。比如说：

["c.biancheng.net" , 1 , [2,3,4] , 3.0]

创建列表

在Python中，创建列表的方法可分为 2 种，下面分别进行介绍。

使用=运算符直接创建列表

和其他类型的Python变量一样，创建列表时，也可以使用赋值运算符“=”直接将一个列表赋值给变量，其语法格式如下：

listname = [element1 , element2 , element3 , ... , elementn]

其中，listname表示列表的名称，注意，在命名时既要符合Python命名规范，也要尽量避开与Python的内置函数重名。

下面定义的列表都是合法的：

num = [1,2,3,4,5,6,7]
name = ["C语言中文网","http://c.biancheng.net"]
program = ["C语言","Python","Java"]
emptylist = []   # emptylist 是一个空列表

使用list()函数创建列表

Python还提供了一个内置的list()函数来创建列表，它可用于将元组、区间（range）等对象转换为列表，例如：

a_tuple = ('crazyit', 20, -1.2)
# 将元组转换成列表
a_list = list(a_tuple)
print(a_list)

输出结果为：

['crazyit', 20, -1.2]

查询列表元素

根据索引查找元素

在Python中，如果想将列表的内容输出也比较简单，直接使用print()函数即可。

name = ["C语言中文网","http://c.biancheng.net"]
num = [1,2,3,4,5,6,7]
print(name)
# 通过列表的索引获取指定的元素
print(name[1])
# 通过切片操作实现一次性访问多个元素
print(num[2:4])

运行结果为：

['C语言中文网', 'http://c.biancheng.net']
http://c.biancheng.net
[3, 4]

统计列表元素个数count()

此方法用于统计列表中某个元素出现的次数，其基本语法格式为：

listname.count(obj)

其中，listname代表列表名，obj表示判断是否存在的元素。

下面代码示范了 count() 方法的用法：

a_list = [2, 30, 'a', [5, 30], 30]
# 计算列表中30的出现次数
print(a_list.count(30))
# 计算列表中[5, 30]的出现次数
print(a_list.count([5, 30]))

运行结果为：

2
1

定位元素的索引index()

index()方法用于定位某个元素在列表中出现的位置（也就是索引），如果该元素没有出现，则会引发ValueError错误。

此方法的基本语法格式为：

listname.index(obj,start,end)

同count()方法不同，index()方法还可传入start、end参数，用于在列表的指定范围内搜索元素。

a_list = [2, 30, 'a', 'b', 'crazyit', 30]
# 定位元素30的出现位置
print(a_list.index(30))
# 从索引2处开始、定位元素30的出现位置
print(a_list.index(30, 2))
# 从索引2处到索引4处之间定位元素30的出现位置，因为找不到该元素，会引发 ValueError 错误
print(a_list.index(30, 2, 4))

运行结果为：

1
5
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\1.py", line 7, in <module>
    print(a_list.index(30, 2, 4)) # ValueError
ValueError: 30 is not in list

列表添加元素

append()整体追加列表末尾

append()方法用于在列表的末尾追加元素，该方法的语法格式如下：

listname.append(obj)

其中，listname指的是要添加元素的列表；obj表示要添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

a_list = ['crazyit', 20, -2]
# 追加元素
a_list.append('fkit')
print(a_list)
a_tuple = (3.4, 5.6)
# 追加元组，元组被当成一个元素
a_list.append(a_tuple)
print(a_list)
# 追加列表，列表被当成一个元素
a_list.append(['a', 'b'])
print(a_list)

运行结果为：

['crazyit', 20, -2, 'fkit']
['crazyit', 20, -2, 'fkit', (3.4, 5.6)]
['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

insert()整体指定插入列表

如果希望在列表中间增加元素，则可使用列表的insert()方法，此方法的语法格式为：

listname.insert(index , obj)

其中，index参数指的是将元素插入到列表中指定位置处的索引值。

c_list = list(range(1, 6))
print(c_list)
# 在索引3处插入字符串
c_list.insert(3, 'CRAZY' )
print(c_list)
# 在索引3处插入列表
c_list.insert(3, ["crazy"])
print(c_list)

输出结果为：

[1, 2, 3, 4, 5]
[1, 2, 3, 'CRAZY', 4, 5]
[1, 2, 3, ['crazy'], 'CRAZY', 4, 5]

extend()逐个追加列表末尾

当然，如果希望不将被追加的列表或元组当成一个整体，而是只追加列表中的元素，则可使用列表提供的 extend()方法。

extend()方法的语法格式如下：

listname.extend(obj)

例如：

b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list)
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list)
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list)

运行结果为：

['a', 30, -2, 3.1]
['a', 30, -2, 3.1, 'C', 'R', 'A']
['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

删除列表及元素

删除列表

对于已经创建的列表，如果不再使用，可以使用**del**语句将其删除。

del listname

其中，listname表示要删除列表的名称。

删除前面创建的name列表，可以使用下面的代码 :

name = ["C语言中文网","http://c.biancheng.net"]
print(name)
del name
print(name)

运行结果为：

['C语言中文网', 'http://c.biancheng.net']
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\1.py", line 4, in <module>
    print(name)
NameError: name 'name' is not defined

删除列表元素

在列表中删除元素，主要分为以下 3 种应用场景：

1. 根据目标元素所在位置的索引值进行删除，可使用del语句；
2. 根据元素的值进行删除，可使用列表（list类型）提供的remove()方法；
3. 将列表中所有元素全部删除，可使用列表（list类型）提供的clear()方法。

指定索引值删除元素del

删除列表中指定元素，和删除列表类似，也可以使用del语句。del语句是Python中专门用于执行删除操作的语句，不仅可用于删除列表的元素，也可用于删除变量等。

例如，定义一个保存 3 个元素的列表，若指定删除最后一个元素，可以使用如下的代码：

a_list=[20,2.4,(3,4)]
b_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']

del a_list[-1]
print(a_list)

# 删除第2个到第4个（不包含）元素
del b_list[1: 3]
print(b_list)

输出结果为:

[20, 2.4]
['crazyit', (3, 4), 'fkit']

指定索引删除元素pop()

pop()方法会移除列表中指定索引处的元素，如果不指定，默认会移除列表中最后一个元素。该方法的基本语法格式为：

 listname.pop(index)

例如：

a_list=[1,2,3]
#移除列表的元素 3
print(a_list.pop())
print(a_list)
#移除列表中索引为 0 的元素1
print(a_list.pop(0))
print(a_list)

运行结果为:

3
[1, 2]
1
[2]

指定元素值删除元素remove()

除使用del语句之外，Python还提供了remove()方法 来删除列表元素，该方法并不是根据索引来删除元素的，而是根据元素本身的值来执行删除操作的。

remove()方法会删除第一个和指定值相同的元素，如果找不到该元素，该方法将会引发ValueError错误。

如下代码示范了使用remove()方法删除元素：

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
# 删除第一次找到的30
c_list.remove(30)
print(c_list)
# 删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list)
#再次尝试删除 30，会引发 ValueEroor 错误
c_list.remove(30)

输出结果为:

[20, 'crazyit', -4, 'crazyit', 3.4]
[20, -4, 'crazyit', 3.4]
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\1.py", line 9, in <module>
    c_list.remove(30)
ValueError: list.remove(x): x not in list

删除列表所有元素clear()

list列表还包含一个clear()方法 ，正如它的名字所暗示的，该方法用于清空列表的所有元素。例如如下代码：

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
c_list.clear()
print(c_list)

输出结果为:

[]

列表修改元素

直接赋值修改

可以对列表的元素赋值，这样即可修改列表的元素。

a_list = [2, 4, -3.4, 'crazyit', 23]
# 对第3个元素赋值
a_list[2] = 'fkit'
print(a_list) # [2, 4, 'fkit', 'crazyit', 23]
# 对倒数第2个元素赋值
a_list[-2] = 9527
print(a_list) # [2, 4, 'fkit', 9527, 23]

切片删除修改

对列表中间一段赋值：

b_list = list(range(1, 5))
print(b_list)
# 将第2个到第4个（不包含）元素赋值为新列表的元素
b_list[1: 3] = ['a', 'b']
print(b_list) # [1, 'a', 'b', 4]

对列表中空的slice赋值，就变成了为列表插入元素。

# 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入
b_list[2: 2] = ['x', 'y']
print(b_list) # [1, 'a', 'x', 'y', 'b', 4]

将列表其中一段赋值为空列表，就变成了从列表中删除元素。

# 将第3个到第6个（不包含）元素赋值为空列表，就是删除
b_list[2: 5] = []
print(b_list) # [1, 'a', 4]

list常用方法

反向存放列表元素reverse()

reverse()方法会将列表中所有元素反向存放。该方法的基本语法格式为：

listname.reverse()

例如：

a_list = list(range(1, 8))
# 将a_list列表元素反转
a_list.reverse()
print(a_list)

运行结果为：

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

排序列表元素sort()

sort()方法用于对列表元素进行排序，排序后原列表中的元素顺序会方发生改变。sort()方法的语法格式如下：

listname.sort(key=None, reserse=False)

可以看到，和其他方法不同，此方法中多了 2 个参数，它们的作用分别是：

• **key参数用于指定从每个元素中提取一个用于比较的键。例如，使用此方法时设置key=str.lower**表示在排序时不区分字母大小写。
• **reverse**参数用于设置是否需要反转排序，默认False表示从小到大排序；如果将该参数设为True，将会改为从大到小排序。

例如如下代码：

a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
# 对列表元素排序
a_list.sort()
print(a_list)
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
# 对列表元素排序：默认按字符串包含的字符的编码大小比较
b_list.sort()
print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

运行结果为：

[-30, -2, 3, 3.4, 4, 9.3, 14]
['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

list添加元素的方法及区别

定义两个列表（分别是list1和list3），并分别使用+、extend()、append()对这两个list进行操作，其操作的结果赋值给list2。实例代码如下：

tt = 'hello'
#定义一个包含多个类型的 list
list1 = [1,4,tt,3.4,"yes",[1,2]]
print(list1,id(list1))

print("1.----------------")

#比较 list 中添加元素的几种方法的用法和区别
list3 = [6,7]
list2 = list1 + list3
print(list2,id(list2))

print("2.----------------")

list2 = list1.extend(list3)
print(list2,id(list2))
print(list1,id(list1))

print("3.----------------")

list2 = list1.append(list3)
print(list2,id(list2))
print(list1,id(list1))

输出结果为：

[1, 4, 'hello', 3.4, 'yes', [1, 2]] 2251638471496
1.----------------
[1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7] 2251645237064
2.----------------
None 1792287952
[1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7] 2251638471496
3.----------------
None 1792287952
[1, 4, 'hello', 3.4, 'yes', [1, 2], 6, 7, [6, 7]] 2251638471496

根据输出结果，可以分析出以下几个结论：

1. 使用“+”号连接的列表，是将list3中的元素放在list的后面得到的list2。并且list2的内存地址值与list1并不一样，这表明list2是一个重新生成的列表。
2. 使用extend处理后得到的list2是none。表明extend没有返回值，并不能使用链式表达式。即extend千万不能放在等式的右侧，这是编程时常犯的错误，一定要引起注意。
3. extend处理之后，list1的内容与使用“+”号生成的list2是一样的。但list1的地址在操作前后并没有变化，这表明extend的处理仅仅是改变了list1，而没有重新创建一个list。从这个角度来看，extend的效率要高于“+”号。
4. 从append的结果可以看出，append的作用是将list3整体当成一个元素追加到list1后面，这与extend和“+”号的功能完全不同，这一点也需要注意。

range()快速初始化数字列表

range()函数的用法是：让Python从指定的第一个值开始，一直数到指定的第二个值停止，但不包含第二个值 。

for value in range(1,5):
	print(value)

输出结果为：

1
2
3
4

range()函数的返回值类型为range，而不是list。而如果想要得到range()函数创建的数字列表，还需要借助 list() 函数，比如：

>>> list(range(1,6))
[1, 2, 3, 4, 5]

list列表实现栈和队列

list实现队列

使用list列表模拟队列功能的实现方法是，定义一个list变量，存入数据时使用insert()方法，设置其第一个参数为 0，即表示每次都从最前面插入数据；读取数据时，使用pop()方法，即将队列的最后一个元素弹出。

如此 list 列表中数据的存取顺序就符合“先进先出”的特点。实现代码如下：

#定义一个空列表，当做队列
queue = []
#向列表中插入元素
queue.insert(0,1)
queue.insert(0,2)
queue.insert(0,"hello")
print(queue)
print("取一个元素：",queue.pop())
print("取一个元素：",queue.pop())
print("取一个元素：",queue.pop())

运行结果为：

['hello', 2, 1]
取一个元素： 1
取一个元素： 2
取一个元素： hello

list实现栈

使用list列表模拟栈功能的实现方法是，使用append()方法存入数据；使用pop()方法读取数据。

append()方法向list中存入数据时，每次都在最后面添加数据，这和前面程序中的insert()方法正好相反。

举个例子：

#定义一个空 list 当做栈
stack = []
stack.append(1)
stack.append(2)
stack.append("hello")
print(stack)
print("取一个元素：",stack.pop())
print("取一个元素：",stack.pop())
print("取一个元素：",stack.pop())

输出结果为：

[1, 2, 'hello']
取一个元素： hello
取一个元素： 2
取一个元素： 1