第二章_列表和元组

新概念：数据结构：数据结构是通过某种方式组织在一起的数据元素的集合

2.1序列概览

1、Python有六种内建**序列**：列表，元组，字符串，Unicode字符串，buffer对象，xrange对象
2、序列的作用：用来操作一组数值
3、序列的特性：：同时序列也可以包含其他序列
4、列表和元组的区别：列表可以修改，元组不能修改
5、列表的各个元素通过逗号分隔，写在“[]”中
    >>> endword=["hehe",42]
    >>> endword
    ['hehe', 42]
    >>> join=["haha",23]
    >>> datebase=[endword,join]
    >>> datebase
    [['hehe', 42], ['haha', 23]]
    >>>

2.2通用序列操作

索引、分片、加、乘、检查、迭代
（以下通过列表演示序列的基本操作）

2.2.1索引

1、理论依据：序列中的所有元素都是有编号的，从0开始；
    >>> greeting="hello"
    >>> greeting[0]
    'h'
   补充：如同C语言中的数组一样，可以通过[索引]的形式来引用数组中的值
2、负索引：使用负索引时，python会从最右边，也就是最后一个元素开始记起，最后一个元素的位置编号是-1，
    >>> greeting[-1]
    'o'
3、字符串字面值也可以使用索引：
    >>> "hello"[0]
    'h'
    >>> 
4、如果一个函数调用返回一个序列那么可以直接对返回的结构进行操作
    >>> fourth=raw_input("years:")[3]
    years:2005
    >>> fourth
    '5'

2.2.2分片

1、分片的作用：用来访问一定范围的元素，在方括号里通过冒号隔开两个索引来实现
    >>> tag="0123456789"
    >>> tag[4:6]
    '45'
    >>> tag[0:9]
    '012345678'
    >>>     
2、分片的规则：
    （1）可以使用负索引
    （2）第一个索引包含在分片内，第二个索引不包含在分片内
    （3）只要分片内左边的索引比它右边的索引晚出现在序列中，结果就是一个空的序列
    例：
        >>> tag=[0,1,2,3,4,5,6,7]
        >>> tag[-3:-1]
        [5, 6]
        >>> tag[-3:0]
        []
    分析： tag=[0 , 1 , 2 , 3 , 4 , 5 , 6 , 7]
         正索引：0 , 1 , 2 , 3 , 4 , 5 , 6 , 7
         负索引：-8, -7, -6, -5, -4, -3, -2,-1



3、问题：如何使得到的分片包括序列结尾元素？
    >>> numbers=[1,2,3,4,5,6,7,8,9,10]
    >>> numbers[3:6]
    [4, 5, 6]

    >>> numbers[7:10]            #numbers序列的索引是从0到9，没有10和11
    [8, 9, 10]
    >>> number[7:11]
    [8, 9, 10]  
    >>> number[7:]
    [8, 9, 10]

    >>> numbers[-3:-1]           #此方法不行
    [8, 9]

    >>> numbers[-3:]             #这种方法也适用于截取开头部分
    [8, 9, 10]
    >>> 
    number[:-3]
    [1, 2, 3, 4, 5, 6, 7]
由以上示例可以得出结论：分片操作中只要 ：号的某一侧没有写索引，代表取该侧的所有元素
3、如何复制整个序列：
    >>> numbers[:]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> 
4、分片可以设置步长：
    1、步长默认值是1，
    2、注意步长不能为0
        >>> numbers[0:10:2]
        [1, 3, 5, 7, 9]
        >>> numbers[0:10:-2]
        []
        >>> numbers[-10:-1:-2]
        []
        >>> numbers[:-1:-2]
        []
        >>> numbers[8:3:-1]
        [9, 8, 7, 6, 5]
        >>> numbers[10:0:-2]
        [10, 8, 6, 4, 2]
        >>> 
        >>> number[::-1]
        [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

    3、步长的使用规则：
        （1）当使用一个负数作为步长时必须让开始索引大于结束索引
        （2）对于一个正数步长，python会从序列头部开始向右提取元素，直到最后一个元素。而对于负数步长，则是从序列的尾部开始向左提取元素，直到第一个元素
    经验：使用负数步长，可很方便得到一个序列的反序序列

2.2.3序列相加：通过使用+运算符

1、两种同类型的序列才能相加（注意有六种内建序列）
>>> [1,2,3]+[1,2,3]
[1, 2, 3, 1, 2, 3]                 #列表中的元素可以重复
>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> [1,2,3]+“Hello World”
  File "<stdin>", line 1
[1,2,3]+“Hello World”
        ^
SyntaxError: invalid syntax
>>> 

2.2.4乘法

1、用数字x乘以序列会生成新的序列，在新的序列中，原来的序列会被重复x次；
    >>> 3*[1,2,3]
    [1, 2, 3, 1, 2, 3, 1, 2, 3]
2、None：（注意首字母大写）代表空值，意味着在里面没有放置任何元素，这里什么也没有
3、空列表：用两个中括号表示“[]”
4、初始化：
    创建空列表
    >>> squence=[]
    >>> squence
    []
    创建一个占用十个元素空间，却不包含任何内容的列表
    >>> squence=[None]*10
    >>> squence
    [None, None, None, None, None, None, None, None, None, None]
    >>>     
    创建一个包含10个1的列表
    >>> squence=[1]*10
    >>> squence
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

2.2.5成员资格

1、in运算符：检查一个值是否在一个序列中
    >>> String="haha"
    >>> 'h'in String
    True
    >>> 'ha' in String
    True

    >>> database=[["albert","123"],["smitn","456"]]
    >>> ["smith","456"] in database
    False
    >>> ["smitn","456"] in database
    True
    >>> 


    长子串也可以

2.2.6长度，最小值和最大值

1、len函数：返回序列中元素的数量
2、min函数
3、max函数 
特殊：max和min函数的参数，并不一定是序列，也可以是多个数字参数
>>> number=[12,199,100]
>>> len(number)
3
>>> max(number)
199
>>> min(number)
12
>>> max(12,199,100)       #多个数字参数
199
>>> min(12,199,100)
12
>>> len(12,199,100)      #len 函数没有多参数的形式 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: len() takes exactly one argument (3 given)

2.3列表：Python的苦力

列表是可变的，可以改变列表的内容

2.3.1 list函数：以一个序列作为参数并把它转换成列表

1、用于根据字符串创建列表   
    >>> list("hello")
    ['h', 'e', 'l', 'l', 'o']
    >>> 
    将字符串转化成列表，列表转化成字符串
    >>> squence=list("Hello")
    >>> squence
    ['H', 'e', 'l', 'l', 'o']
    >>> string=''.join(squence)
    >>> string
    'Hello'
    >>> 

2、list函数适用于所有类型的序列

2.3.2基本的列表操作

请注意并不是所有的列表方法都真正的改变列表
（1）改变列表：元素赋值
    1、使用索引为某个特定，位置明确的元素赋值：
        >>> x=[1,1,1]
        >>> x[1]=2
        >>> x
        [1, 2, 1]
        >>> 

（2）删除元素del
    >>> name=["zhangsan","lisi","wangwu","zhangshi"]
    >>> del name[1]
    >>> name
    ['zhangsan', 'wangwu', 'zhangshi']
    >>>
（3）分片赋值
    >>> name=list("Strang")
    >>> name[3:4]="i"
    >>> name
    ['S', 't', 'r', 'i', 'n', 'g']
    >>>
    1、分片赋值时可以使用与原序列不等长的序列替换
        >>> name=list("perl")
        >>> name[1:]=list("ython")
        >>> name
        ['p', 'y', 't', 'h', 'o', 'n']
        >>>
    2、分片赋值可以用于在序列中插入新元素
        >>> numbers=[1,3,4,5]
        >>> numbers[1:1]=2
        Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        TypeError: can only assign an iterable

        >>> numbers=[1,3,4,5]
        >>> numbers[1:1]=[2]
        >>> numbers
        [1, 2, 3, 4, 5]
    3、也可以用来删除元素
        >>> numbers=[1,2,3,4,5]
        >>> numbers[1:4]=[]
        >>> numbers
        [1, 5]
        >>>

2.3.3列表方法

1、方法：是与某些对象有紧密联系的函数，方法可以这样调用：
        对象.方法(参数)
（1）append：用于在列表末尾追加新的对象
        >>> lst=[1,2,3]
        >>> lst.append(4)
        >>> lst
        [1, 2, 3, 4]
        >>>
（2）count：统计某个元素在列表中出现的次数
        >>> x=[[1,2],2,1,[2,1],[1,2]]
        >>> x.count(1)
        1
        >>> x.count([1,2])
        2
        >>> 
（3）extend：在列表末尾一次性追加另一个序列的多个值，换句话说可以用新列表扩展原有列表
        >>> a=[1,2,3]
        >>> b=[4,5,6]
        >>> a.extend(b)
        >>> a
        [1, 2, 3, 4, 5, 6]
    区别：extend方法是修改原来的列表，原来的列表发生改变。而“+”操作符是生成了新的列表，而原来的列表没有发生改变，效率低于extend
        >>> a=[1,2,3]
        >>> b=[4,5,6]
        >>> a+b
        [1, 2, 3, 4, 5, 6]
        >>> a
        [1, 2, 3]
        >>> b
        [4, 5, 6]
        >>>

（4）index方法：从列表中找出某个值的第一个匹配项的索引，如果列表中没有该元素就会引发异常
        >>> knight=["haha","hehe","hoho","huhu"]
        >>> knight.index("hehe")
        1
        >>> knight.index("haha")
        0
        >>> 
（5）insert：将对象插入列表中
        >>> number=[1,2,3,4,5]
        >>> number.insert(3,"four")
        >>> number
        [1, 2, 3, 'four', 4, 5]
        >>>
（6）pop：移除列表中的一个元素（默认是最后一个）并返回该元素的值，也可以指定索引
        唯一一个既能修改列表又返回元素值（出None外）的列表方法
        >>> x=[1,2,3,4]
        >>> x.pop()
        4
        >>> x
        [1, 2, 3]
        >>> x.pop(0)
        1
        >>> x
        [2, 3]
        >>>
（7）remove：用于移除列表中某个值的第一个匹配项，注意不同于pop，remove没有返回值；
        >>> x=["to","be","or","to","not"]
        >>> x.remove("to")
        >>> x
        ['be', 'or', 'to', 'not']
        >>> 
（8）reverse：将列表中的元素反向存放
        >>> x=[1,2,3]
        >>> x.reverse()
        >>> x
        [3, 2, 1]
        >>> 
（9）sort：在原位置对列表进行排序返回空值（默认是升序）
        >>> x=[4,3,5,7,8,2,9]
        >>> x.sort()
        >>> x
        [2, 3, 4, 5, 7, 8, 9]
        >>> 
    如果只想排序而不想改变原来的序列sorted方法返回新的已排序的列表副本
        >>> x=[4,3,5,7,8,2,9]
        >>> y=x
        >>> y.sort()
        >>> x
        [2, 3, 4, 5, 7, 8, 9]
        >>> y
        [2, 3, 4, 5, 7, 8, 9]
        >>> 

        >>> x=[4,3,5,7,8,2,9]
        >>> y=x[:]
        >>> y.sort()
        >>> y
        [2, 3, 4, 5, 7, 8, 9]
        >>> x
        [4, 3, 5, 7, 8, 2, 9]
        >>>

        >>> x=[4,3,5,7,8,2,9]
        >>> y=x.sorted（x）
        >>> y
        [2, 3, 4, 5, 7, 8, 9]
        >>> x
        [4, 3, 5, 7, 8, 2, 9]
        >>>
（10）高级排序
    1、关键字参数：sort方法有两个可选参数key和reverse，如果要使用他们，可以通过名字来指定，参数key必须提供的在排序中使用的函数，然而该函数并不是直接用来确定对象的大小，而是为每个元素创建一个键，然后所有元素根据键值来排序。参数reverse是简单的布尔值，用来指明列表是否要进行反向排序
                >>> x=["fdsa","sdafdsf","yt","oiuytrte","safhn"]
                >>> x.sort(key=len)
                >> x
                ['yt', 'fdsa', 'safhn', 'sdafdsf', 'oiuytrte']

                >>> x=[4,6,2,1,7,9]
                >>> x.sort(reverse=True)
                >>> x
                [9, 7, 6, 4, 2, 1]
                >>>

2.4元组：不可变的序列

创建元组：用逗号分隔一些值
    >>> 1,2,3
    (1, 2, 3)
    >>> 1,2,3
    (1, 2, 3)
    >>> 1,
    (1,)
    >>> (1,2,3)
    (1, 2, 3)
1、元组不能修改
2、元组通过圆括号括起来
3、空元组可以用没有包含内容两个圆括号表示
4、如何实现包括一个值的元组——加一个逗号
    >>> 42
    42
    >>> .42
    0.42
    >>> 42.
    42.0
    >>> ,42
      File "<stdin>", line 1
       ,42
^
    SyntaxError: invalid syntax
    >>> 42,
    (42,)
    >>> (42,)
    (42,)
    >>> (42)
    42
    >>> 3*(40+2)
    126
    >>> 3*(40+2,)
    (42, 42, 42)
    >>> 

2.4.1：tuple函数

1、与list函数类似：以一个序列作为参数并把他转换为元组
    >>> tuple([1,2,3])
    (1, 2, 3)
    >>> tuple("abc")
    ('a', 'b', 'c')
    >>> 

---

全文引用于：作者: Magnus Lie Hetland

出版社: 人民邮电出版社

原作名: Beginning Python: From Novice to Professional, Second Edition

译者: 司维 / 曾军崴 / 谭颖华

出版年: 2010-7

页数: 471

定价: 69.00元

装帧: 平装

丛书: 图灵程序设计丛书

ISBN: 9787115230270