Python学习2：列表

 

列表是Pyton的内置数据类型之一。

操作一下：

1，打开Python shell，或者Win+R -> cmd -> python

2，出现控制台提示符>>>

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

>>> type(a)

<class 'list'>

使用type函数，可以查看变量的类型。这里变量a是list类型。

使用id函数可以查看内存地址，来判断两个变量是不是同一个对象，之前在赋值语句的介绍中使用过。

>>> a = 3

>>> type(a)

<class 'int'>

这里a是一个整型的类型。

看到每个类型的描述都有一个class，说明python里的都是对象。

Python是一种面向对象的编程语言。

在Python中几乎所有的东西都是一个对象，有其属性和方法。

一个类就像一个对象构造器，或者说是一个创建对象的 "蓝图"。

列表可以说是Python语言中使用频率最高的一个有序序列（这里的有序指的是先后顺序而不是大小顺序！）。

序列描述了数据类型的一种形态，具体的数据类型有很多，包括列表、元组、字符串，这些都属于序列类型。

从它的特性上来讲可以分为两类，一类是可变序列，一类是不可变序列。

可变序列：指的是序列中的某个元素支持在原位置被改变。

不可变序列：是不允许在原位值改变某个元素或者对象的值。

列表的定义

列表（list）：是可以包含任意对象的有序集合（可以包含类型统一的整数，也可以包含不同类型的如串、元组、字典、自己定义的类的实例等等，并且它是有序的，顺序是可以自定义的）。

Python列表是包含0个或者多个对象引用的有序序列。

列表的申明

列表用一对中括号来申明，中括号里写上多个元素，中间以逗号隔开，逗号是默认的分隔符，这些元素可以是任意类型的数据。

列表基本特征

>>> score = 80

>>> print(score)

80

>>> scores = [77,88,99]

>>> print(scores)

[77, 88, 99]

定义一个变量，赋值一个数值表示一门课成绩；

定义一个列表来表示一个学生多门课程的成绩

使用print函数可以打印对象内容。

列表具有以下特性：

（1）可以包含任意对象的有序集合。如：x = [89, 90.3, ‘tom’]

（2）可以通过下标索引来访问list中的某个元素。下标索引从左边开始总是从0开始，也可以从右边开始，那就是从-1开始。

（3）可变长度，异质，任意嵌套（可任意增减、可包含任意类型的元素，可任意嵌套指的是列表的元素又可以是一个列表）。

（4）支持原位改变，即直接改变列表中某个位置元素的值。

访问列表中的元素和显示列表内容：

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

>>> a

[1, 2, 3, 4, 5]

>>> a[0]

1

>>> a[2]

3

>>> a[-1]

5

>>> a[-2]

4

访问越界会提示错误，所以下标不要越界：

>>> a[5]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

IndexError: list index out of range

>>> a[-6]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

IndexError: list index out of range

嵌套列表，并修改内容：

>>> a = [1, 2, 3, "hello", ["what", "are", 4]]

>>> a[0]

1

>>> a[3]

'hello'

>>> a[4]

['what', 'are', 4]

>>> a[3][0]

'h'

>>> a[4][0]

'what'

>>> a[4][0] = "hello"

>>> a[4][0]

'hello'

>>> a[4]

['hello', 'are', 4]

>>> a[4] = [1, 2 ,3]

>>> a[4]

[1, 2, 3]

>>> a[4] = [1, 2 ,3, 4]

>>> a[4]

[1, 2, 3, 4]

>>> a

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

这个是定义了一个不同类型对象的列表，并且嵌套了另一个列表。

列表的内容可以更改，包括嵌套的列表的内容也可以更改。

列表转换函数list( )

通过列表转换函数list( )可以将某个特定的可迭代序列转换为列表。

注意这里我们说的list、id、type、print等函数，其实都是全局函数，全局函数不依附于任何对象。

将序列转换为列表：

>>> ls = list(range(1,6))

>>> print(ls)

[1, 2, 3, 4, 5]

>>> ls =list("python")

>>> ls

['p', 'y', 't', 'h', 'o', 'n']

列表的初始化

列表用中括号将若干元素括起来，中间用逗号分隔。

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

>>> a

[1, 2, 3]

序列的通用操作

序列的通用操作包括判断元素是否在序列之内、序列连接、重复序列元素等。

函数	描述
x in ls	如果x是ls的元素，则返回True，否则返回False
x not in ls	如果x不是ls的元素，则返回True，否则返回False
ls + lt	连接序列ls和lt，“+”连接操作不会改变两个操作对象ls和lt本身的值
ls * n或 n * ls	将序列ls中的元素重复n次形成一个新的序列，原序列ls并没有改变
ls[i]	通过下标索引的方式来获取序列元素ls[i]
ls[i:j]	获取[i, j-1]范围的元素。ls[:j]获取[0, j-1]范围的元素；ls[i:]获取从i开始的所有元素；ls[:]获取所有的元素。注意：获取列表元素的值时，下标不能越界！
ls[i:j:k]	按一定的步长来访问指定索引范围，其中i、j分别是起始、终止位置，k是步长
len(ls)	获取序列长度，即序列中元素个数
min(ls)	获取序列最小值，但要求序列ls中的元素必须是可以比较大小的
max(ls)	获取序列最大值，但要求序列ls中的元素必须是可以比较大小的
sum(ls)	统计序列元素的总和，如果元素中有非数值类型的数据，则不能求和！
ls.index(x[,i[,j]])	返回元素x在序列ls中[i, j-1]范围内第一次出现的下标索引位置，如果不在序列中则出错
ls.count(x)	统计元素x出现在序列s中的次数

>>> a = [5,6,7]

>>> 5 in a

True

>>> a = [5,6,7]

>>> 8 not in a

True

>>> a = [5,6,7]

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

>>> a+b

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

>>> a*3

[5, 6, 7, 5, 6, 7, 5, 6, 7]

>>> 3*a

[5, 6, 7, 5, 6, 7, 5, 6, 7]

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

>>> a[0:3]

[1, 2, 3]

>>> a[:]

[1, 2, 3, 4, 5]

>>> a[::2]

[1, 3, 5]

>>> len(a)

5

>>> min(a)

1

>>> max(a)

5

>>> sum(a)

15

>>> a.count(1)

1

>>> a = [5,6,7,8,5,3]

>>> a.index(5)

0

使用index时，如果没有这个元素会报错：

>>> a.index(10)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ValueError: 10 is not in list

可以指定index查找元素的范围：

>>> a = [3, 18, 20, 3, 19, 22]

>>> a.index(3)

0

>>> a.index(3,1)

3

>>> a.index(3,0,1)

0

>>> a.index(3,2,5)

3

index函数第一个参数表示要查找的数字，第二个参数表示从哪个位置开始查找，第三个参数表示截止到哪个元素停止查找。

列表的切片操作

还可以使用负数索引或步长：

# 步长为-1则逆序显示列表

>>> a

[3, 18, 20, 3, 19, 22]

>>> a[::-1]

[22, 19, 3, 20, 18, 3]

# 第一个表示起始索引；第二个参数减一表示结束索引，所以写0会缺一个元素，省略为空则会包含第一个元素。

>>> a

[3, 18, 20, 3, 19, 22]

>>> a[5:0:-1]

[22, 19, 3, 20, 18]

>>> a[5::-1]

[22, 19, 3, 20, 18, 3]

#使用负数的索引值

>>> a[-1:-7:-1]

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

>>> a[-1]

22

第三个参数是步长，如果步长为负，则第一个参数要大于第二个参数，即从后面的索引开始遍历。

如果索引为负，而步长为正，也可以遍历列表。注意第二参数省略为空则不会缺少最后一个元素。

省略步长的话就是1。

>>> a

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

>>> a[-6::1]

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

>>> a[-6:-1:1]

[1, 2, 3, 4, 5]

>>> a[-6:-1]

[1, 2, 3, 4, 5]

求和操作

求和操作sum(ls)

>>> x = [1,7,3,0,3,9]

>>> sum(x)

>>> ls = [1,4,9,'Tom', [4,7,5]]  #元素有非数值类型的数据，不能求和！

> sum(ls)   #会出错

可变序列及列表通用操作

前面以list列表为例所介绍的通用操作，既可以使用在列表上，列表是一可变序列，但这些操作它同样适用于不可变序列。

下面将继续以list为例，来介绍可变序列的通用操作。这些操作既可以作用到list列表上，也可以作用到其它可变序列的数据结构上。下表列出了可变序列及列表的通用操作。

函数	描述
ls[i] = x	原位修改。修改ls中指定下标索引对应元素的值为x
ls[i:j] = lt	用可迭代序列lt中的元素替换ls中[i, j-1]范围内的元素。lt中元素个数可以多于也可以少于ls中要被替换掉的元素个数，此时原列表的长度会发生变化
ls[i:j:k] = lt	用可迭代序列lt中的元素替换ls中[i, j-1]范围内的元素。注意：这里要求lt的大小和ls中被置换的元素个数要保持一致。ls[i:j] = lt 和 ls[i:j:k] = lt的操作是有差异的！
del ls[i]	删除列表ls中指定的元素
del ls[i:j]	删除列表ls中[i, j-1]范围的元素，等价于 ls[i:j] = [ ]
del ls[i:j:k]	按步长k来删除列表ls中[i, j-1]范围的元素
ls += lt或 ls.extend(lt)	将可迭代序列lt中的元素逐个追加到列表ls的末尾处
ls *= n	更新列表ls，将列表ls中的元素重复n次
ls.remove(x)	移除列表中指定的元素，当列表中有多个值相同的元素时，remove方法删除的是值相同的第1个元素。必须指明要移除的元素，该方法无返回值
ls.clear( )	清空列表，即删除列表中所有的元素。实施该操作后，列表ls为空，等价于ls = [ ]
ls.append(x)	在列表ls末尾追加一个元素x。说明：x作为一个对象进行追加。一次只能追加一个元素，那怕x是一个列表，也只能作为一个整体进行追加。
ls.insert(i, x)	在指定下标位置处插入元素x

修改元素

>>> s = [1,2,3,4,5,6,7,8]

>>> s[:3] = [11,11,11]

>>> s

[11, 11, 11, 4, 5, 6, 7, 8]

>>> s[2:3] = [22]

>>> s

[11, 11, 22, 4, 5, 6, 7, 8]

>>> a

[22, 20, 19, 18, 3, 3]

>>> a[::2]

[22, 19, 3]

>>> a[::2] = [1,1,1]

>>> a

[1, 20, 1, 18, 1, 3]

其他操作

函数	描述
ls.pop([i])	pop( )操作有返回值。检索并删除特定元素，pop操作会弹出一个值并删除该值。省略i，返回并删除最后一个元素值
ls.reverse( )	反转序列。反转操作只影响序列ls自己，它并不返回新值
ls.copy( )	复制序列。复制序列将产生一个真实的拷贝

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

>>> a.pop()

5

>>> a

[1, 2, 3, 4]

>>> a.pop(0)

1

>>> a

[2, 3, 4]

列表的拷贝

将一个列表赋值给另一个列表不会产生新的列表对象。例如：

> l = [0,1,2,3,4,5,6,7,8,9,10]

> s = l  #将序列l复制给s

> s[0] = -99  #改变序列s中元素的值

> s

[-99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

> l  #发现原序列l中对应元素的值也被修改了

[-99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

以上操作表明s和l它们两个关联的是同一个对象，这其实就是共享引用。

> s is l

说明：全局函数id( )也能检测两个对象是否是共享引用。 

解决产生新的列表的两种方法：

方法一：利用切片操作取出列表的所有元素赋值给新的变量。

> l = [0,1,2,3,4,5,6,7,8,9,10]

> s = l[:]   #把l的所有值取出来赋值给s

> s

[0,1,2,3,4,5,6,7,8,9,10]

> s[0] = -99

> s

[-99,1,2,3,4,5,6,7,8,9,10]

> l

[0,1,2,3,4,5,6,7,8,9,10]

方法二：利用列表的方法“copy( )”拷贝列表的所有元素到新的变量。

> l = [0,1,2,3,4,5,6,7,8,9,10]

> x = l.copy()

> x

[0,1,2,3,4,5,6,7,8,9,10]

> x[-1] = 101

> x

[0,1,2,3,4,5,6,7,8,9,101]

>l

[0,1,2,3,4,5,6,7,8,9,10]

列表所特有的一个操作——“.sort( )”方法

函数	描述
ls.sort(reverse=False )	排序操作。默认按照从小到大进行排序，但设置reverse=True得到降序排列
sorted(ls )	全局排序函数。默认返回升序，但并不改变原序列ls

>>> a

[3, 18, 20, 3, 19, 22]

>>> a.sort()

>>> a

[3, 3, 18, 19, 20, 22]

>>> a.sort(reverse=True)

>>> a

[22, 20, 19, 18, 3, 3]

>>> a

[3, 18, 20, 3, 19, 22]

>>> sorted(a)

[3, 3, 18, 19, 20, 22]

>>> sorted(a,reverse=1)

[22, 20, 19, 18, 3, 3]

>>> sorted(a,reverse=True)

[22, 20, 19, 18, 3, 3]

>>> b = ["hello", "bug", "holiday"]

>>> b.sort()

>>> b

['bug', 'hello', 'holiday']

使用sort方法要注意，必须是同类型的元素，才能比较。否则会出错。