02、Python 教程 - 列表和元组

在Python中，最基本的数据结构为序列（包括列表、元组、字符串等）（sequence）
列表是可以修改的，而元组不可以
Python支持一种数据结构的基本概念，名为容器（container）
容器基本上就是可包含其他对象的对象
两种主要的容器是序列（如列表和元组）和映射（如字典）
在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。
有一种既不是序列也不是映射的容器，它就是集合（set）

通用的序列操作

通用的序列操作包括索引、切片、相加、相乘和成员资格检查

1，索引

索引中，下标从0开始访问单个元素，0时第一个元素的位置
用负数索引时，Python将从右（即从最后一个元素）开始往左数，-1是最后一个元素的位置

beyond = "I love the band"
beyond[0]#结果为：I
beyond[2]#结果为：l
beyond[-1]#结果为：d
beyond[-2]#结果为：n
"beyond"[2]#结果为：y

fourth = input('Year: ')[3] 
输入结果：Year: 1999 
输出结果：'9'

2，切片:

除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素
简而言之，左闭右开
切片索引方向只能从左向右，不能反过来操作，即左小右大，左闭右开
若要反过来操作需要指定步长即可

number = [0,1,2,3,4,5,6,7,8,9]
number[1:3]#结果为：[1，2]
number[4:5]#结果为：[4]
number[8:10]#结果为：[8,9]   索引10，该元素压根不存在，但是没有报错，压根用不到，左闭右开

number[-3:-1]#结果为：[7,8]
number[-1:-3]#结果为：[]
'''
如果第一个索引指定的元素位于第二个索引指定的元素后面
（在这里，倒数第3个元素位于第1个元素后面），结果就为空序列
'''

#切片结束于序列末尾，可省略第二个索引
number[-3:]#结果为：[7,8,9]
#如果切片始于序列开头，可省略第一个索引
number[:3]#结果为：[0,1,2]
#要复制整个序列，可将两个索引都省略
number[:]#结果为：[0,1,2,3,4,5,6,7,8,9]

设置步长的切片
通常情况不写步长的时候，步长默认为1

number=[0,1,2,3,4,5,6,7,8,9]
number[0:5]#结果为：[0,1,2,3,4]
number[0:5:1]#结果为：[0,1,2,3,4]
#不写第三个参数步长的话默认为1

number[0:10:2]#结果为：[0,2,4,6,8]  步长为2时，将从起点和终点之间每隔一个元素提取一个元素

#要从序列中每隔3个元素提取1个，只需提供步长4即可
number[::4]#结果为：[0,4,8]

#当然，步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素
number[8:3:-1]#结果为：[8,7,6,5,4]
number[3:8:-1]#结果为：[]

#步长为正数时，它从起点移到终点
#步长为负数时，它从终点移到起点
number[5::-2]#结果为：[5,3,1]
number[:5:-2]#结果为：[9,7]

3，序列相加+

[1,2,3] + [3,2,1]#结果为：[1,2,3,3,2,1]
'hello,' + "beyond"#结果为：'hello,beyond'

[1,2,2] + "yanyu"#结果为：报错！！！
#一般而言，不能拼接不同类型的序列

4，乘法*

“beyond” * 5#结果为：'beyondbeyondbeyondbeyondbeyond'
[521] * 3#结果为：[521,521,521]

'''
Python中None表示什么都没有，为空
将列表长度初始化为5如下：
'''
beyond = [None] * 5
beyond#结果为：[None,None,None,None,None]

5，成员资格in

要检查特定的值（可以是单个字符也可以是字符串）是否包含在序列中，可使用运算符in
它检查是否满足指定的条件，并返回相应的值，满足时返回True，不满足时返回False
这样的运算符称为布尔运算符，而前述真值称为布尔值

beyond = "yanyu like beyond"
'y' in beyond#结果为：True
'q' in beyond#结果为：False

users = ['yanyu','huangjiaju','yeshirong']
input('Enter your user name:') in users
Enter your user name:yanyu
#结果为：True

长度、最小值、最大值
函数len返回序列包含的元素个数，min和max分别返回序列中最小和最大的元素

beyond = [19,5,22]
len(beyond)#结果为：3
max(beyond)#结果为：22
min(beyond)#结果为：5

max(1999,2005)#结果为：2005
min(98,55)#结果为：55

列表

函数list，使用字符串来创建列表
可将任何序列（而不仅仅是字符串）作为list的参数

list("beyond")#结果为：['b', 'e', 'y', 'o', 'n', 'd']

基本的列表操作包括索引、切片、拼接和相乘，但列表的有趣之处在于它
是可以修改的

1，修改列表：给元素赋值

beyond = [1,2,3,4,5]
beyond[1] = 99
beyond#结果为：[1,99,3,4,5]
#不能给不存在的元素赋值，因此如果列表的长度为2，就不能给索引为100的元素赋值

2，删除元素del

yanyu = ["yanyu",1999,'huangjiaju']
del yanyu[1]
yanyu#结果为：['yanyu','huangjiaju']

3，给切片赋值

yanyu = list("beyond")
yanyu#结果为：['b', 'e', 'y', 'o', 'n', 'd']

yanyu[2:] = list('SQ')
yanyu#结果为：['b','e','S','Q']
yanyu[3:] = list("jiaju")
yanyu#结果为：['b', 'e', 'S', 'j', 'i', 'a', 'j', 'u']

＃在不替换原有元素的情况下插入新元素
yanyu[1:1] = [6,7,8]
yanyu#结果为：['b', 6, 7, 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u']
yanyu[1:3] = []
yanyu#结果为：['b', 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u']
'''
这很显然与del yanyu[1:3]等效
类推，也可以对执行步长不为1的切片进行赋值
'''

4，列表方法

方法是与对象（列表、数、字符串等）联系紧密的函数
object.method(arguments)
方法调用与函数调用很像，只是在方法名前加上了对象和句点
列表包含多个可用来查看或修改其内容的方法

1，append，将一个对象附加到列表末尾

yanyu = [1,2,4,5,6]
yanyu.append(7)
yanyu#结果为：[1,2,4,5,6,7]

2，clear，就地清空列表的内容

yanyu = [1,2,3]
yanyu.clear()
yanyu#结果为：[]
#这类似于切片赋值语句yanyu[:] = []

3，copy，复制列表（将另一个名称关联到列表）

a = [1,2,3]
b = a
b[1] = 4
a#结果为：[1,4,3]
#将另一个名称关联到列表

a = [1,2,3]
b = a.copy()
b[1] = 4
a#结果为：[1, 2, 3]
#这类似于使用a[:]或list(a)，它们也都复制a

4，count，计算指定的元素在列表中出现了多少次

['to', 'be', 'or', 'not', 'to', 'be'].count('to')结果为：2 

x = [[1, 2], 1, 1, [2, 1, [1, 2]]] 
x.count(1)结果为：2 
x.count([1, 2])结果为：1

5，extend，同时将多个值附加到列表末尾，可使用一个列表来扩展另一个列表

a = [1, 2, 3] 
b = [4, 5, 6] 
a.extend(b) 
a结果为：[1, 2, 3, 4, 5, 6]
#很明显a这个列表已经发生了修改
'''
extend是将b扩展到a，a会发生变化会被扩展
而常规拼接+，只是返回一个新的序列，原本的不会被修改
'''
a = [1, 2, 3] 
b = [4, 5, 6] 
a + b结果为：[1, 2, 3, 4, 5, 6] 
a结果为：[1, 2, 3]
#很明显a这个列表并没有改变
a = a+b#结果为：[1, 2, 3, 4, 5, 6] 效果实现了 但是拼接的效率将比extend低

a = [1, 2, 3] 
b = [4, 5, 6] 
a[len(a):] = b 
a结果为：[1, 2, 3, 4, 5, 6] 
#这虽然可行，但可读性不是很高

6，index，查找指定值第一次出现的索引

yanyu= ['We', 'are', 'the', 'knights', 'who', 'say', 'huangjiaju'] 
yanyu.index('who')结果为：4 who处于索引第4处
yanyu.index('xixihaha')#结果为：报错 其不存在

7，insert，用于将一个对象插入列表

numbers = [1, 2, 3, 5, 6, 7] 
numbers.insert(3, 'four') 
numbers结果为：[1, 2, 3, 'four', 5, 6, 7]

'''
与extend一样，也可使用切片赋值来获得与insert一样的效果
这虽巧妙，但可读性根本无法与使用insert媲美
'''
numbers = [1, 2, 3, 5, 6, 7] 
numbers[3:3] = ['four'] 
numbers结果为：[1, 2, 3, 'four', 5, 6, 7]

8，pop，从列表中删除一个元素（末尾为最后一个元素），并返回这一元素

pop是唯一既修改列表又返回一个非None值的列表方法

x = [1,2,3，9，8，7]
x.pop()#结果为：7
x#结果为：[1,2,3,9,8]
x.pop(2)#结果为：3
x#结果为：[1,2,9,8]

'''
使用pop可实现一种常见的数据结构——栈（stack）后进先出
push和pop是大家普遍接受的两种栈操作（加入和取走）的名称
Python没有提供push，但可使用append来替代
方法pop和append的效果相反，因此将刚弹出的值压入（或附加）后，得到的栈将与原来相同

要创建先进先出（FIFO）的队列，可使用insert(0, ...)代替append
另外，也可继续使用append，但用pop(0)替代pop()。
'''
x = [1,4,7]
x.append(x.pop())
x#结果为：[1,4,7]

9，remove，用于删除第一个为指定值的元素

remove是就地修改且不返回值的方法
不同于pop的是，它修改列表，但不返回任何值

x = ['I','love',"beyond",'and',"I",'hahaha']
x.remove("I")
x#结果为：
x.remove("SQ")#结果为：报错 原因为列表里面没有该元素

10，reverse，按相反的顺序排列列表中的元素

修改列表，但不返回任何值（与remove和sort等方法一样）

x = [1, 2, 3] 
x.reverse() 
x结果为：[3, 2, 1]

'''
如果要按相反的顺序迭代序列，可使用函数reversed
这个函数不返回列表，而是返回一个迭代器，不改变原来的列表
'''
x = [1, 2, 3] 
list(reversed(x))结果为：[3, 2, 1]
x#结果为：[1,2,3]

11，sort，用于对列表就地排序

sort方法：对原来的列表进行修改，使其元素按顺序排列，且不返回任何值！！！
sorted函数：可用于任何序列，但总是返回一个列表

x = [7,4,1,8,9,6,5,2,3]
x.sort()
x#结果为：[1,2,3,4,5,6,7,8,9]

y = [9,5,1,7,8,6]
z = y.sort()
print(z)#结果为：None 其原因在于，sort不返回任何值！！！
y#结果为：[1,5,6,7,8,9]  y列表排序了，但是sort不返回任何值导致z为None

#先将z关联到y的副本，再对z进行排序
y = [9,5,1,7,8,6]
z = y.copy()
z.sort()
z#结果为：[1, 5, 6, 7, 8, 9]  z进行排序
y#结果为：[9, 5, 1, 7, 8, 6]  y并未修改

#另一种方式是使用函数sorted
x = [4, 6, 2, 1, 7, 9] 
y = sorted(x) 
y结果为：[1, 2, 4, 6, 7, 9]
x结果为：[4, 6, 2, 1, 7, 9] 

#如果要将元素按相反的顺序排列，可先使用sort（或sorted），再调用方法reverse，也可使用参数reverse

sorted('Python')结果为：['P', 'h', 'n', 'o', 't', 'y']   大写字母<小写字母，相同类型字母a或A最小

12，高级排序

方法sort接受两个可选参数（关键字参数）：key和reverse
参数key类似于参数cmp：你将其设置为一个用于排序的函数
参数reverse：只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序
要根据长度对元素进行排序，可将参数key设置为函数len

x = ["qwert","asf",'zx',"vxcb",'sdfsd']
x.sort(key=len)
x#结果为：['zx', 'asf', 'vxcb', 'qwert', 'sdfsd']

y = [4,6,8,2,1,9,7]
y.sort(reverse=True)
y#结果为：[9, 8, 7, 6, 4, 2, 1]

元组：不可修改的序列()

元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组

1,2,3#结果为：(1, 2, 3)    元组
(1,2,3)#结果为：(1, 2, 3)  元组

#逗号很关键，若只有一个数时，不加逗号就代表数，加上逗号代表元组
1999#结果为：1999        数
1999,#结果为：(1999,)    元组
(1999,)#结果为：(1999,)  元组

函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组
如果参数已经是元组，就原封不动地返回它

tuple([1, 2, 3])#结果为：(1, 2, 3) 
tuple('abc')#结果为：('a', 'b', 'c') 
tuple((1, 2, 3))#结果为：(1, 2, 3)

元组的创建及其元素的访问方式与其他序列相同

x = 1, 2, 3 
x#结果为：(1,2,3)
x[1]#结果为：2 
x[0:2]结果为：(1, 2)

本章节介绍的新函数