Python学习笔记_第二章：列表和元祖

1.序列中每个元素被分配一个序号-元素的位置，也成为索引。第一个索引是0，第二个是1，以此类推。
2.本章介绍的列表的操作同样适用于字符串。

序列概览

Python有6种内建的的序列：列表、元祖、字符串、Unicode字符串、buffer对象和xrange对象，本章重点介绍类表和元祖。
序列可以包含其他序列。
Python中有一种名为容器的数据结构，基本上可以说是包含其他对象的任意对象。序列和映射是两类主要的容器。集合也是一类容器。

通用序列操作

所有序列都可以进行某些特定的操作：索引，分片，加，乘，成员资格，计算序列长度，找出最大元素，找出最小元素，迭代。
迭代：依次对序列中的每个元素重复执行某些操作。

分片

分片操作的实现需要提供两个索引为边界，第一个索引元素是包含在分片内的，而第二个则不包含在分片内。

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[7 : 10]
[8, 9, 10]
>>> 

10指向的是第11个元素，但这个元素是不存在的，确实在最后一个元素之后。

访问最后三个元素的优雅捷径

>>> numbers[-3 : -1]
[8, 9]

尾部计数达不到读取最后一个元素的目的

>>> numbers[-3 : 0]
[]

0作为最后一个位置的下一个位置，也不能达到目的，事实上只要分片中最左边的索引比它右边的晚出现在序列中，结果就是一个空序列。

>>> numbers[-3 :]
[8, 9, 10]

优雅地实现了访问最后三个元素

更大的步长

关于分片：开始点的元素包括在结果之中，而结束点的元素则不再分片之内。当使用一个负数作为步长时，必须让开始点大于结束点。在没有明确指定开始点、结束点时候，正负数的使用可能会带来一些混淆。不过在这种情况下Python会进行正确的操作：对于一个正数步长，Python会从序列偷部开始提取直到尾部，对于负数的步长，则是从序列的尾部开始向左提取元素，直到头部。

序列相加

使用‘+’运算符进行序列的连接操作，两种同类型的序列才能进行连接操作。

乘法

用数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列被重复x次。

>>> num = 3 * numbers[0 : 3]
>>> num
[1, 2, 3, 1, 2, 3, 1, 2, 3]

如果想创建一个占用十个元素空间，却不包含任何内容的列表，最好的方法是：

>>> num = [None] * 10
>>> num
[None, None, None, None, None, None, None, None, None, None]

None是Python中的内建值，它的确切含义是：“这里什么都没有”

成员资格

in 预算符即成员资格运算符

>>> '$$$' in subject
>>> '$$$' in seq
True

早期的Python版本中，in只能用来检查某个(不是某几个)字符是否存在于一个字符串中，如果尝试检验多个字符组成的子串则会报错。

长度、最小值、最大值

len、min、max

列表：Python中的“苦力”

list函数

list函数试用于所有的序列，而不仅仅是字符串。
join方法是split方法的逆方法，' '.join(somelist)用于将somelist用' '分割。

基本的列表操作

1.改变列表：列表元素赋值
2.删除元素：使用del 语句实现

>>> names = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'liqi']
>>> del names[1]
>>> names
['zhangsan', 'wangwu', 'zhaoliu', 'liqi']

3.分片赋值
分片赋值时，可使用与原序列不等长的序列将分片替换。可以利用“替换空白”来向序列中插入元素，通过“用空白替换”来删除序列中的元素。

列表方法

Python中函数和方法的区别

这里引用Magic_chao不负青春博客
1、函数要手动传self，方法不用传self
2、如果是一个函数，用类名去调用，如果是一个方法，用对象去调用
举例说明如下

class Foo(object):
    def __init__(self):
        self.name="haiyan"
    def func(self):
        print(self.name)

obj = Foo()
obj.func()
Foo.func(obj)

判断函数和方法的方式

from types import FunctionType,MethodType
obj = Foo()
print(isinstance(obj.func,FunctionType))  #False
print(isinstance(obj.func,MethodType))   #True   #说明这是一个方法
print(isinstance(Foo.func,FunctionType))  #True   #说明这是一个函数。
print(isinstance(Foo.func,MethodType))  #False

列表中提供的方法如下:
1.append
2.count
3.extend
append和extend的区别,举例说明:

>>> lst1 = 3 * ['1st1']
>>> lst2 = 2 * ['lst2']
>>> lst3 = lst1.append(lst2)
>>> lst3
>>> lst1
['1st1', '1st1', '1st1', ['lst2', 'lst2']]
>>> lst1.extend(lst2)
>>> lst1
['1st1', '1st1', '1st1', ['lst2', 'lst2'], 'lst2', 'lst2']

extend和连接操作的区别:extend方法修改了被扩展的序列,而原始的连接操作会返回一个空列表
4.index
5.insert
6.pop
pop默认移除列表中的最后一个元素,pop(0)会移除列表中的第一个元素，pop是唯一一个既能修改列表又返回元素值的列表方法。
用列表实现栈：pop()和append()分别可以实现出栈和入栈操作。
用列表实现队列：
1.用insert(0,...)来代替append方法表示入队，用pop()表示出队
2.用append()表示入队，用pop(0)表示出队
更好的实现方案是：使用collection模块中的deque对象。
7.remove
8.reverse
如果需要对列表进行反向迭代，可以使用reversed函数，这个函数返回一个迭代器对象，可以用list函数将其返回值转换为list
9.sort

>>> x = [1, 2, 4, 3, 6, 5]
>>> y = x[:]
>>> x
[1, 2, 4, 3, 6, 5]
>>> y.sort()
>>> y
[1, 2, 3, 4, 5, 6]

这里调用x[:],可以复制整个列表给y，如果只是简单地赋值是没用的，因为这样做就让x和y指向同一个列表了
另一种获得列表排序后副本的方法是sorted函数，这个函数实际上可以用于任意序列，确总是返回一个列表
如果想把一些元素按相反的顺序排列，可以先使用sort（sorted），然后调用reverse方法，或者也可以使用reverse参数。
10.高级排序
内建函数cmp提供了比较函数的默认实现方式：

>>> cmp(1, 3)
-1
>>> cmp(3, 1)
1
>>> cmp(1, 1)
0
>>> x.sort(cmp)
>>> x
[1, 2, 3, 4, 5, 6]

sort方法还有另外两个可选参数——key和reverse（关键字参数），使用示例如下：

>>> x = ['abc', 'abcd', 'abcdegh', 'abcde', 'ab']
>>> x.sort(key = len)
>>> x
['ab', 'abc', 'abcd', 'abcde', 'abcdegh']
>>> x = [1, 2, 4, 3, 6, 5]
>>> x.sort(reverse = True)
>>> x
[6, 5, 4, 3, 2, 1]

元祖：不可变序列

元祖和列表的唯一区别是元祖不可以修改，然而字符串也是如此
定义方法：用逗号分割一些值
实现只有一个值的元祖的方法：即使只有一个值也加一个逗号。

>>> 40
40
>>> (40)
40
>>> 40,
(40,)
>>> (40,)
(40,)
>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2, )
(42, 42, 42)

tuple函数

功能：以一个序列作为参数，把它转化为元祖，如果参数是元祖，则原样返回
它和list一样，并不是一个函数，而是一种类型，但目前可以忽略掉区别

基本元祖操作

除了创建元祖和访问元祖元素外没有太多其他操作，元祖分片还是元祖

>>> x = 1, 2, 3
>>> x
(1, 2, 3)
>>> x[1]
2
>>> x[0 : 2]
(1, 2)

那么，意义何在

一下两个情况，元祖不能被列表替代
1.元祖可以在映射（集合的成员）中当做键使用，列表不行
2.元祖作为很多内建函数、方法的返回值存在