Python学习小记（四）Python数据类型③列表和元组

一、列表（list)

Python的常见序列类型包括字符串、列表(list)和元组。上一篇的字符串，其实就是一种常见的序列，通过索引访问字符串内的字符程序就是序列的示范程序。序列类型支持双向索引，即若第一个元素下标为0，第二个下标为1，以此类推；或者最后一个元素下标为-1，倒数第二个元素下标为-2，以此类推。

        与字符串不同的是，列表是可变的，即可在原处修改其中的内容。列表是有序可变序列，而字符串是有序不可变序列。当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙。

1、列表的创建

Python中用“[]”来创建列表(list)，用“,”分割列表内的每个元素。一个列表中的数据类型可以各不相同，可以同时分别为整数、字符串、甚至是列表、元组等。

①.直接使用“=”将一个列表赋值给变量即可创建列表对象。

>>>list1=[]
>>>list1
[]
>>>type(list1)
<class 'list'>
>>>list1=['good',222,['file1',200]]
>>>list1
['good', 222, ['file1', 200]]

②.也可以使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型转化为列表。

>>>a_list=list((3,4,5,6,7))
>>>a_list
[3, 4, 5, 6, 7]
>>>type(a_list)
<class 'list'>
>>>list(range(1,10,2))
[1, 3, 5, 7, 9]
>>>list('hello python')
['h', 'e', 'l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n']

（注：range(start,stop,step)为python的内置函数）

2、列表的增删改查（尽量从列表尾部进行元素的增加与删除操作）

①.增

a.使用列表对象的append()方法在当前列表尾部追加元素，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快。

（注：列表中包含的是元素值的引用，而不是直接包含元素值。

            原地操作：通过下标来修改序列中元素的值或通过可变序列对象自身提供的方法来增加和删除元素时，序列对象在内存中的起始地址是不变的，仅仅是改变值的元素地址发生变化。）

>>>l=[]
>>>for i in range(5):
...    l.append(i)
...    
>>>l
[0, 1, 2, 3, 4]
>>>l.append('a')
>>>l
[0, 1, 2, 3, 4, 'a']

b.使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来添加列表元素也不改变其内存首地址，属于原地操作。

>>>a=[1,2,3]
>>>id(a)
2186773724224
>>>a.extend([4,5,6])
>>>a
[1, 2, 3, 4, 5, 6]
>>>id(a)
2186773724224
>>>a.extend((7,8))
>>>a
[1, 2, 3, 4, 5, 6, 7, 8]

#extend()和append()区别：
>>>l=[]
>>>l.append([2,3,4])
>>>l
[[2, 3, 4]]
>>>l.extend([5,6,7])
>>>l
[[2, 3, 4], 5, 6, 7]

c.使用列表对象的insert(index,obj)方法将元素添加至列表的指定位置。(insert方法在使用时必须指定位置，添加元素到指定索引位置时，该位置及其后面的元素自动往后退一位。）

>>>a=[1,2,3]
>>>id(a)
2186773769216
>>>a.insert(3,6)
>>>a
[1, 2, 3, 6]
>>>id(a)
2186773769216
>>>a.insert(7)
Traceback (most recent call last):
  File "D:\python3102\lib\code.py", line 90, in runcode
    exec(code, self.locals)
  File "<input>", line 1, in <module>
TypeError: insert expected 2 arguments, got 1
>>>a.insert(5,7)
>>>a
[1, 2, 3, 6, 7]
>>>a.insert(2,9)
>>>a
[1, 2, 9, 3, 6, 7]

②.删

a.使用del命令删除列表中指定位置上的元素。

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

b.使用列表的pop()方法删除并返回指定位置（默认为最后一个）上的元素，如果给定的索引超出了列表的范围则抛出异常。(pop()的参数只能时索引值，或者为空）

>>>list1=['a',1,2,3,'b']
>>>list1.pop()
'b'
>>>list1
['a', 1, 2, 3]
>>>list1.pop(1)
1
>>>list1
['a', 2, 3]
>>>list1.pop('a')
Traceback (most recent call last):
  File "D:\python3102\lib\code.py", line 90, in runcode
    exec(code, self.locals)
  File "<input>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer

c.使用列表对象的remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素则抛出异常。

>>>list1=[1,2,3,4,3,4,5]
>>>list1.remove(3)
>>>list1
[1, 2, 4, 3, 4, 5]
>>>list1.remove(7)
Traceback (most recent call last):
  File "D:\python3102\lib\code.py", line 90, in runcode
    exec(code, self.locals)
  File "<input>", line 1, in <module>
ValueError: list.remove(x): x not in list

特别注意，list的遍历是基于下标的，当删除其中的一个元素的时候，列表实际上已经发生了变化，该元素后面的所有元素都往前移动了一个位置，所以下次遍历的时候就会跳过该元素后面的一个元素，例2中的倒数第二个1就被跳过了，这个1去填了倒数第三个1的位置，所以这个1不会被移除。

例1>>>x=[1,2,1,2,1,2,1,2,1]
>>>for i in x:
...    if i==1:
...        x.remove(i)
        
>>>x
[2, 2, 2, 2]
例2>>>x=[1,2,1,2,1,1,1]
>>>for i in x:
...    if i==1:
...        x.remove(i)
        
x
[2, 2, 1]

③.改,当列表内的元素被改变后，列表的内存地址不改变。

>>>ll=['a','b']
>>>ll,id(ll)
(['a', 'b'], 2186773860608)
>>>ll[1]=2
>>>ll,id(11)
(['a', 2], 2186727785008)

④.查，列表的查找方法一般有两种，可以通过索引取值或者通过循环取值。

>>>list1=['a','b','c']
>>>list1[2]
'c'
>>>for i in list1:
...    print(i)
...    
a
b
c

3、列表的其他操作

①列表的切片操作，和字符串的切片操作大体上一致，具体见上篇。

②列表排序

a.使用列表对象的sort()方法进行原地排序 ，无返回值       list.sort(key=None,reverse=False)

参数：key用来指定一个参数，此函数在每次比较时被调用，reverse表示排序方式，默认值为False(升序），当为True时为降序。

>>>list1=[3,4,5,1,2,6,7,9]
>>>list1.sort()
>>>list1
[1, 2, 3, 4, 5, 6, 7, 9]

b.使用内置函数sorted()对列表进行排序并返回新列表

>>>list2=[3,4,5,1,2,6,7,9]
>>>sorted(list2)
[1, 2, 3, 4, 5, 6, 7, 9]

c.使用列表对象的reverse()方法将元素原地逆序。

>>>list3=[3,4,5,1,2,6,7,9]
>>>list3.reverse()
>>>list3
[9, 7, 6, 2, 1, 5, 4, 3]

d.使用内置函数reversed()对列表元素进行逆序排序并返回迭代对象。

>>>list4=[3,4,5,1,2,6,7,9]
>>>list5=reversed(list4)    #返回reversed对象
>>>list(list5)              #把reversed对象转化为列表
[9, 7, 6, 2, 1, 5, 4, 3]
>>>for i in list5:
...    print(i,end=' ')
...                            #没有输出内容，因为迭代对象已经遍历结束
>>>list5=reversed(list4)
>>>for i in list5:
...   print(i,end='')
    
97621543

③列表的访问与计数

可以使用列表对象的count()方法统计指定元素在列表对象中出现的次数。

>>> list6=[1,2,3,4,2,1,1,2]
>>> list6.count(1)
3
>>> list6.count(3)
1
>>> list6.count(8)
0

 ④列表的成员判断，和字符串一致，用in 和 not in ，返回结果为bool值。

4、列表的操作符和方法汇总

二、元组(tuple)

        元组和列表、字符串都是序列数据类型的基本组成，所以它们有很多共同属性，但是特殊的是，元组是一种有序不可变序列。

1、元组的创建

        Python中，元组用一对小括号“（）”表示，元组内的各元素用“,”分隔。

>>>a_tupe=('a','b','mpilgrim')
>>>a_tupe
('a', 'b', 'mpilgrim')
>>>type(a_tupe)
<class 'tuple'>
>>>a=(3)        #特别注意逗号的应用，没有逗号会变成int而不是tuple
>>>a
3
>>>type(a)
<class 'int'>
>>>a=(3,)
>>>type(a)
<class 'tuple'>
>>>a=3,           #通过这种方式也可以创建tuple
>>>a
(3,)
>>>type(a)
<class 'tuple'>

        或者可以使用tuple函数将其他序列转换成元组

>>>tuple('abcdefg')        #把字符串转化成元组
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>>alist=['a','b',1,2,3]
>>>tuple(alist)            #把列表转换成元组
('a', 'b', 1, 2, 3)

2、元组的操作方法

因为元组是一种有序不可变序列，所以列表的append()、extend()、insert()、remove()、pop()等方法，元组都没有，特殊的是，元组的del方法只能删除元组对象，不能删除元组中的元素。除此之外，其他操作方法大体上一致。

>>>t=(1,2,3)
>>>del t[1]
Traceback (most recent call last):
  File "D:\python3102\lib\code.py", line 90, in runcode
    exec(code, self.locals)
  File "<input>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>>del t
>>>t
Traceback (most recent call last):
  File "D:\python3102\lib\code.py", line 90, in runcode
    exec(code, self.locals)
  File "<input>", line 1, in <module>
NameError: name 't' is not defined

3、元组（序列）的打包和解包

>>>t=1,2,3            #将1、2、3打包赋值给t
>>>x,y,z=t            #将t解包赋值给x,y,z,需要注意的是，解包的时候，元组中有几个元素，就必须有几个对应的变量接收                  
>>>x
1
>>>y
2
>>>z
3
>>>t
(1, 2, 3)

 三、列表和元组的比较

1、相同点

①二者都为有序序列

②都支持双向索引

③有很多通用的方法，count()方法统计指定元素的出现次数和index()方法获取指定元素的索引，len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。

2、不同点

①元组属于不可变序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。也没有append等可以修改序列的方法。

②元组的速度比列表更快，如果定义了一系列常量值，而所需要做的只是进行遍历，那么一般使用元组而不用列表。

③元组对不需要改变的数据进行“写保护”将使得代码更加安全。

④元组可以用做字典的“键”，也可以作为集合的元素。而列表则都不能（因为列表是可变的）。