2020-01-09

列表与元组

通用序列操作

索引 、分片、序列相加、乘法、成员资格、长度、最小值和最大值

索引 indexing

索引0指向第一个元素，索引1指向第二个元素……
**（负数索引）**python的序列也可以从右边开始索引，最右边的元素索引是-1

分片 slicing

索引是对单个元素进行访问，**分片访问一定范围内的元素**
分片操作既支持正数索引也支持负数索引
**第一个索引的元素包含在分片内，第二个索引的元素不包含在分片内**

```python
>>> number = [1,2,3,4,5,67,8,9,10]
>>> number[1:3]  # 取索引为第一和第二的元素
[2, 3]
>>> number[-3:-1] # 取倒数第二和倒数第三的元素
[8, 9]
>>> number[-3:] #  取最后三个元素
[8, 9, 10]
>>> number[0:3]  # 取前三个元素
[1, 2, 3]
>>> number[0::2]  # 步长为2
[1, 3, 5, 8, 10]
>>> number[10:0:-2] # 步长可以为负  第二个索引为0 取不到第1个元素
[10, 8, 5, 3]
对于正数步长，python会从序列头部开始向右提取元素，直到最后一个元素(分片中)；对于负数步长，python则是从序列尾部开始向左提取元素，直到第一个元素(分片中)
```

序列相加

使用加号 '+ ' 可以进行序列的连接操作

  >>> [1,2,3] + [4,5,6]  # 数字序列相加
  [1, 2, 3, 4, 5, 6]
  >>> 'hello,' + 'world'  # 字符串序列相加
  'hello,world'
  >>> [1,2,3] + 'hello'  # 字符串序列与数字序列相加 （发生错误）
  Traceback (most recent call last):
    File "<pyshell#11>", line 1, in <module>
      [1,2,3] + 'hello'  # 字符串序列与数字序列相加 （发生错误）
  TypeError: can only concatenate list (not "str") to list 

只有类型相同的序列才能通过加号进行序列连接操作，不同类型的序列不能通过加号连

乘法

序列中的乘法:一个数字n乘以一个序列会生成一个新的序列，新的序列是将原来的序列重复 n次

```python
>>> 'hello'* 5
'hellohellohellohellohello'
>>> [3] * 5
[3, 3, 3, 3, 3]
```

​ python中序列的乘法可以帮助我们快速做一些初始化操作（重复操作，空列表和None）
​ python ​ >>> sq = [None] * 5 # 初始化sq为含有5个None的序列 ​ None是 python 的内建值 表示这里什么都没有 ​ >>> sq ​ [None, None, None, None, None] ​

成员资格

in 运算符用来检查一个值是否在序列中，在返回True、不在返回False

  >>> str = 'hello'
  >>> 'e' in str
  True
  >>> 'a' in str
  False
  >>> users = ['xiaoming','xiaozhang','xiaozhu']
  >>> 'xiaoming' in users  # 检测字符串是否在字符串列表中
  True
  >>>  1 in users  # 数字类型不能在字符串类型中通过in 进行成员检测
  
  SyntaxError: unexpected indent
  >>> 1 in [1,2,3]
  True
  >>> '1' in [1,2,3]  # 字符串类型类可以在数字列表中通过in 进行成员资格检测
  False
  

长度、最小值和最大值

python 提供了长度、最小值和最大值的内建函数，分别为len、min和max

    >>> numbers = [200,300,500]
    >>> len(numbers)  # 长度
    3
    >>> min(numbers)  # 最小值
    200
    >>> max(numbers)  # 最大值
    500

---

列表

列表的内容是可变的

更新列表

序列中的操作，如索引、分片、序列相加和乘法都适用与列表
除此之外列表中还有其他方法用来更新列表（元素赋值、元素删除、分片赋值和列表方法）

• 元素赋值
  赋值语句是最简单改变列表的方法

  >>> a = [1,2,3,4]
  >>> a[1] = 10
  >>> a
  [1, 10, 3, 4]
  >>> a[3] = 100  # 改变了第4个元素的值
  >>> a
  [1, 10, 3, 100]
  >>> a[2] = 'hello'  # 对一个列表中的元素赋不同类型的值
  >>> a
  [1, 10, 'hello', 100]
  >>> a[5] = 5 # 不能为一个不存在元素位置赋值  列表a的长度为4 5超出了列表范围
  Traceback (most recent call last):
    File "<pyshell#35>", line 1, in <module>
      a[5] = 5 # 不能为一个不存在元素位置赋值
  IndexError: list assignment index out of range
  

  对一个列表中的元素赋不同类型的值
  不能为一个不存在元素位置赋值

• 增加元素 append
  在列表末尾添加新对象

  list.append(obj)  直接修改列表在其尾部添加一个元素 
  无返回值
  

  >>> num = [1,2,3]
  >>> num
  [1, 2, 3]
  >>> num.append(4)  # 添加 4
  >>> num
  [1, 2, 3, 4]
  >>> num.append('hello')  # 添加一个字符串
  >>> num
  [1, 2, 3, 4, 'hello']
  

• 删除元素 del
  使用del list[num] num是要删除的列表元素索引

    >>> num = ['a','b','c','d']
    >>> len(num)
    4
    >>> del num[0] # 删除第一个元素 ‘a'
    >>> num
    ['b', 'c', 'd']
    >>> len(num)
    3
    >>> del num[-1]   # 删除最后一个元素
    >>> num
    ['b', 'c']
  

• 分片赋值
  list()函数：将序列直接转换成列表

     >>> show = list('湖人队总冠军')
     >>> show
     ['湖', '人', '队', '总', '冠', '军']
     >>> show[0:2] = list('热火队')  # 分片赋值
     >>> show
     ['热', '火', '队', '队', '总', '冠', '军']
     >>> greeting = list('hi')
     >>> greeting
     ['h', 'i']
     >>> greeting[1:] = list('ello')   #使用与原序列不等长的序列将分片替换
     >>> greeting
     ['h', 'e', 'l', 'l', 'o']
     >>> boil = list('女排夺冠了')
     >>> boil
     ['女', '排', '夺', '冠', '了']
     >>> boil[2:2] = list('2016年奥运会')  #不替换任何元素在任意位置插入新元素
     >>> boil
     ['女', '排', '2', '0', '1', '6', '年', '奥', '运', '会', '夺', '冠', '了']
     >>> boil[2:10] = list()  #对序列中任意位置的元素进行删除
     >>> boil
     ['女', '排', '夺', '冠', '了']
  
  

嵌套列表

列表中可以嵌套列表，嵌套的列表取出来还是列表

   >>> num = [1,2,3]
   >>> num
   [1, 2, 3]
   >>> str = list('abc')
   >>> str
   ['a', 'b', 'c']
   >>> mix = [num,str]
   >>> mix
   [[1, 2, 3], ['a', 'b', 'c']]
   >>> mix[1]
   ['a', 'b', 'c']
   >>> mix[0]
   [1, 2, 3]
   >>> 

列表方法

方法是与对象有紧密联系的函数
调用语法： 对象.方法(参数)
常用方法:

• append 在列表末尾添加新元素
  使用方法： list.append(obj) 无返回值
• count 统计某个元素在在列表中出现的次数
  使用方法： list.count(obj)
• extend 在列表末尾一次性追加另一个序列的多个值
  使用方法： list.extend(seq) seq代表元素列表

>>> a = ['hello','world']
>>> b = ['python','is','funny']
>>> a.extend(b)
>>> a
['hello', 'world', 'python', 'is', 'funny']

• index 从列表中找出某个值第一个匹配项的索引位置
  使用方法: list.index(obj) obj表示要查找的对象
• insert 向列表指定位置插入一个元素
  使用方法：list.insert(index,obj) index插入的位置 obj插入的元素
• pop 移除列表中的一个元素(默认是最后一个元素)，并返回该元素的值
  使用方法：list.pop(num) num是可选参数，代表要移除列表的对象
  **使用pop方法可以实现栈（后进先出）
• remove 移除列表中某一个值的第一个匹配项
  使用方法：list.remove(obj)
• reverse 反向列表元素
  使用方法：list.reverse() 无需参数
  扩展：如果需要反向一个序列可以使用 reversed函数

  >>> num = [11,2,3]
  >>> print('使用reversed函数翻转结果：',list(reversed(num)))
  使用reversed函数翻转结果： [3, 2, 11]

• sort 对原列表进行排序，可以指定参数 ,默认按升序排列
  **sort方法改变了原来的列表而不是返回一个已排序过的列表 **

>>> num = [1,5,3,7]
>>> n = num.sort()
>>> print('变量n的结果是：',n)
变量n的结果是： None
>>> print('列表num排序的结果：',num)
列表num排序的结果： [1, 3, 5, 7]

sort方法修改了列表num,但返回的是空值，所以n的值是None
若不将原列表分片后赋值给另一个变量，两个列表都会被排序

sort有一个对应的函数sorted,可以直接获取列表的副本进行排序

>>> num = [5,8,1,3,6]
>>> n = sorted(num)
>>> print('变量n的结果是：',n)
变量n的结果是： [1, 3, 5, 6, 8]
>>> print('num的结果是：',num)
num的结果是： [5, 8, 1, 3, 6]

sort方法有两个可选参数key和reverse（逆序）

>>> field = ['study','python','is','happy']
>>> field
['study', 'python', 'is', 'happy']
>>> field.sort(key=len,reverse=True)
>>> field.sort(key=len,reverse=True)  #按字符串长度降序排序
>>> field
['python', 'study', 'happy', 'is']

• clear 清空列表
  使用方法：list.clear()

>>> field
['python', 'study', 'happy', 'is']
>>> field.clear()
>>> field
[]

• copy 复制列表
  使用方法：list.copy()

>>> field = ['python','is','study','is']
>>> field_copy = field.copy()
>>> field_copy
['python', 'is', 'study', 'is']
>>> field_copy1=field[:]   # 类似效果
>>> field_copy1
['python', 'is', 'study', 'is']

---

元组

元组与列表类似，不同的是元组的元素不能修改（字符串也是不能修改的）

元组的创建

• 使用逗号分隔
• 圆括号
• tuple函数
  tuple函数将参数(一个序列)转换成元组，与list类似（转换成列表）

>>> 1,2,3,4   # 使用逗号分隔
(1, 2, 3, 4)
>>> (1,2,3,4)  # 是用圆括号
(1, 2, 3, 4)
>>> tuple(['hello','world']) # tuple函数 参数是列表
('hello', 'world')
>>> tuple('hello')           #tuple函数  参数是字符串
('h', 'e', 'l', 'l', 'o')
>>> tuple(('hello','world'))  #tuple函数  参数是元组
('hello', 'world')

注意：创建包含一个值的元组

>>> 1
1
>>> (1)
1
>>> (1,)  # 需要加上逗号
(1,)
>>> 1,    # 需要加上逗号
(1,)
>>> tuple('1')
('1',)
>>> tuple('1',)
('1',)

创建只包含一个值的元组需要加上逗号（利用tulpe函数除外）

元组的基本操作

访问元组、修改元组、删除元组、索引、截取……

• 访问元组
  使用下标索引访问

>>> num = (1,2,3,4)
>>> print('num[1]:',num[1])
num[1]: 2
>>> num = 1,2,3,4,5,6,7
>>> num
(1, 2, 3, 4, 5, 6, 7)
>>> print('num[1:5]:',num[1:5])
num[1:5]: (2, 3, 4, 5)

• 修改元组
  元组中元素的只是不能被修改的，但可以元组进行连接组合

>>> num=1,2,3
>>> field=('hello','world')
>>> num
(1, 2, 3)
>>> field
('hello', 'world')
>>> num+field
(1, 2, 3, 'hello', 'world')

• 删除元组
  元组中的元素值不允许被删除，但可以使用del语句删除整个元组

>>> field
(1, 2, 3, 'hello', 'world')
>>> del field
>>> print('删除后的结果：',field)
Traceback (most recent call last):
 File "<pyshell#14>", line 1, in <module>
   print('删除后的结果：',field)
NameError: name 'field' is not defined

元组field被del后输出会报错（field没有被定义）

• 元组索引、截取
  元组也是序列，所以可以访问元组中指定位置的元素，也可以截取索引中的一段元素

>>> num
(1, 2, 3)
>>> num[2]
3
>>> num[-1]
3
>>> num[:]
(1, 2, 3)

• 元组内置函数
  计算元素个数len、返回最大值max、最小值min、列表转换tuple

元组和列表的区别 区别

列表和元组的区别在于元组不能修改，元组一旦初始化就不能修改
元组不可变所以元组更加安全

>>> t = ('a','b',['A','B'])   #定义一个元组并初始化
>>> t
('a', 'b', ['A', 'B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])   #  发现元组“被修改”
>>> t[2].append('G')
>>> t
('a', 'b', ['X', 'Y', 'G'])

表面上看元组发生了变化，其实变得不是元组的元素、变得是list的列表。元组开始指向list列表没有改变成别的list列表，故元组的不变是指每个元素的指向是不变的，例如上面的程序t[2]是指向一个list列表的，不能指向其他对象，但是指向的list列表是可变的