列表是Pyton的内置数据类型之一。
操作一下：
1，打开Python shell，或者Win+R -> cmd -> python
2，出现控制台提示符>>>
>>> a = [1, 2, 3]
>>> type(a)
使用type函数，可以查看变量的类型。这里变量a是list类型。
使用id函数可以查看内存地址，来判断两个变量是不是同一个对象，之前在赋值语句的介绍中使用过。
>>> a = 3
>>> type(a)
这里a是一个整型的类型。
看到每个类型的描述都有一个class，说明python里的都是对象。
Python是一种面向对象的编程语言。
在Python中几乎所有的东西都是一个对象，有其属性和方法。
一个类就像一个对象构造器，或者说是一个创建对象的 "蓝图"。
列表可以说是Python语言中使用频率最高的一个有序序列（这里的有序指的是先后顺序而不是大小顺序！）。
序列描述了数据类型的一种形态，具体的数据类型有很多，包括列表、元组、字符串，这些都属于序列类型。
从它的特性上来讲可以分为两类，一类是可变序列，一类是不可变序列。
可变序列：指的是序列中的某个元素支持在原位置被改变。
不可变序列：是不允许在原位值改变某个元素或者对象的值。
列表的定义
列表（list）：是可以包含任意对象的有序集合（可以包含类型统一的整数，也可以包含不同类型的如串、元组、字典、自己定义的类的实例等等，并且它是有序的，顺序是可以自定义的）。
列表的申明
列表用一对中括号来申明，中括号里写上多个元素，中间以逗号隔开，逗号是默认的分隔符，这些元素可以是任意类型的数据。
列表基本特征
>>> 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 "", line 1, in
IndexError: list index out of range
>>> a[-6]
Traceback (most recent call last):
File "", line 1, in
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 "", line 1, in
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方法要注意，必须是同类型的元素，才能比较。否则会出错。
