python3基础：列表

python中列表是一种有序的数据结构，可以根据坐标取值，用[]表示。内部元素用逗号隔开，里面可以放大多数的数据结构，比如：字符、数字、列表、元祖、字典等等
列表的增删改查，以及列表的常用方法必须熟记于心

1. 创建列表

空列表：

非空列表：

2.遍历列表

两种方式：基于值遍历和基于坐标遍历
遍历值：

基于坐标遍历：

3.访问列表

通过下标：

代码示例：倒序输出列表元素

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(len(a)-1,-1,-1):
...     print(a[i])
...

代码示例：正序输出奇数坐标的值

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(1,len(a),2):
...     print(a[i])
...
2
-3
-5

代码示例：正序输出偶数坐标的值

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(0,len(a),2):
...     print(a[i])
...
-1
3
0
5

通过切片：正序、倒序、间隔

4.更新列表

索引直接修改

>>> a = [100, 2, 3, -3, 0, -5, 5]
>>> a[0]=1
>>> a
[1, 2, 3, -3, 0, -5, 5]
>>> a[-1]=-1
>>> a
[1, 2, 3, -3, 0, -5, -1]

append()：在列表的最后追加元素

>>> a = [1,2,3,4]
>>> a.append(2222)
>>> a
[1, 2, 3, 4, 2222]

insert(index,element):在index指定的位置插入元素element

>>> a = [1,2,3,4]
>>> a.insert(0,0)
>>> a
[0, 1, 2, 3, 4]
>>> a.insert(-1,222)
>>> a
[0, 1, 2, 3, 222, 4]

如果insert第一个参数指定的下标越界的话会将第二个元素放在最后

切片赋值：可多可少可正好

a = [[-1, -2], 2, 3, -3, 0, -5, 5]
>>> a
[[-1, -2], 2, 3, -3, 0, -5, 5]
>>> a[0:2]=[1,2,3]
>>> a
[1, 2, 3, 3, -3, 0, -5, 5]
>>> a[0:2]=[-1]
>>> a
[-1, 3, 3, -3, 0, -5, 5] 

5.删除列表

两种方法：
1.del删除列表中元素或者整个列表
2.remove()删除指定元素

del删除列表中某个元素

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

del删除整个列表

>>> a=[1,2,3,4]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

remove(element)删除指定元素

代码示例：根据出现次数删除

>>> a= [1,1,1,1,1,2,3]
>>> for i in range(a.count(1)):
...     a.remove(1)
...
>>> a
[2, 3]

代码示例：死循环删除

>>> a= [1,1,1,1,1,2,3]
>>> while 1:
...     try:
...         a.remove(1)
...     except:
...         break
...

6.列表操作函数(仅对列表有用)：

方法	作用
append(obj)	在列表的末尾添加对象obj
insert(index,obj)	在index处插入对象obj,如果index指定的下标越界的话会将obj放在列表的最后
remove(obj)	移除列表中第一次出现的obj，一次只能删除一个
pop(index)	移除列表中的一个元素并返回该元素的值(默认是最后一个)
index(obj)	从列表中找出obj出现的第一个位置，未找到抛异常
count(obj)	统计元素obj在列表中出现的次数
extend(seq)	在列表的末尾一次性追加另一个序列中的多个值
（用新列表扩展原来的列表）
reverse()	对列表元素反转，是原地操作
sort()	对列表进行原地排序，根据ASCII码从大到小进行

7.列表复制

引用（变量a=变量b）指的是操作的同一个对象，复制（[:]模式）指完全复
制一个新的对象

引用复制：a和b指向同一内存空间

变量a = 变量b

列表的*也是引用复制

>>> a = [[]*3]*3
>>> a
[[], [], []]
>>> a[0].append(1)
>>> a
[[1], [1], [1]]

非引用复制[:]：a和b内存空间不一致

8.推导列表

[]中只能是for循环，if和表达式

>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x for x in range(1,11,2)]
[1, 3, 5, 7, 9]
>>> [x for x in range(0,11,2)]
[0, 2, 4, 6, 8, 10]
>>> [x**2 for x in range(9)]
[0, 1, 4, 9, 16, 25, 36, 49, 64]

代码示例：将字典转换为列表

d = {'x': 'A', 'y': 'B', 'z': 'C' }
print ([k + '=' + v for k, v in d.items()])

代码示例：大写字母转小写生成新的列表

L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])

代码示例：二维矩阵的转置

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print([[j[i] for j in a] for i in range(3)])

代码示例：删除二维矩阵的某一列

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print ([[i[j] for j in [1,2]] for i in a])

for i in a：遍历列表的每一行
for j in [1,2]：遍历列表的第二列和第三列
j分别取1,2代表列表的第二列和第三列
[i[j] for j in [1,2]]：
表示每一行的第二列和第三列元素，存到子列表中

9.sort()函数

定义：

>>> help([1].sort)
Help on built-in function sort:

sort(...) method of builtins.list instance
    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

作用：对原序列进行排序，也就是直接在原序列上操作，没有返回值
参数说明：
key：也是一个函数，这个函数会从每个元素中提取一个用于比较的关键字。默认值为None。
reverse：接受False或者True，表示是否逆序。如设置为True，表示逆序。

代码示例：按序列的个数长度降序排列

list9=[(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]
def L(tup):
    return len(tup)

list9.sort(key=L,reverse=True)
print (list9)

代码示例：使用元组最后一个元素的大小比较实现list排序

list9=[(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]
def L(tup):
    return tup[-1]

list9.sort(key=L,reverse=True)
print (list9)

10.sorted()函数

对列表进行排序，返回一个新的列表，原列表的值不变
定义：sorted(iterable[, cmp[, key[, reverse]]]）
函数参数：
1）iterable：是可迭代类型类型;
2）cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的
一项;
3）key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代
集合中的一项;
4）reverse：排序规则. reverse = True 或者 reverse = False，有默认值，
默认为升序排列（False）。
代码示例：

>>> a = [3,8,0,6,1,9]
>>> sorted(a)#升序
[0, 1, 3, 6, 8, 9]
>>> a
[3, 8, 0, 6, 1, 9]
>>> sorted(a,reverse = True)#降序
[9, 8, 6, 3, 1, 0]
>>> a
[3, 8, 0, 6, 1, 9]

>>> sorted(a,key=lambda x:len(x))
[(1, 9), (1, 5, 3), (1, 3, 6, 3), (1, 1, 2, 4, 5, 6)]
>>> sorted(a,key=lambda x:x[-1])
[(1, 5, 3), (1, 3, 6, 3), (1, 1, 2, 4, 5, 6), (1, 9)]
>>>

11.迭代器

优点：节省空间，不需要一下取出所有的数据时可以用迭代器。
迭代器最基本的方法：iter()和__next__()方法
➢ 一个用来获得迭代器对象
➢ 一个用来获取容器中的下一个元素

使用迭代器的两种方法：
1.it.next()
2.next(it)

代码示例1：d.next()

#encoding=utf-8
a = iter([1,2,3,4])
print(next(a))
print(next(a))

代码示例2：next(it)

#encoding=utf-8
li=[5,6,7]
#li=(5,6,7)
it=iter(li)
print (it)
print (it.__next__())#对象的内置方法
print (it.__next__())
print (it.__next__())
print (it.__next__()) 

以上的代码也不省空间，因为列表已经生成了

字典的迭代，默认的是迭代的字典的key：
print(type(iter({1:‘1’,2:‘2’,3:‘3’})))
#<dict_keyiterator object at 0x00000235CAC22F98>
print(type(iter({1:‘1’,2:‘2’,3:‘3’}.values())))<class ‘dict_valueiterator’>

自定义的迭代器：

#encoding=utf-8
class MyRange(object):
    def __init__(self, n):
        self.idx = 0
        self.n = n

    def __iter__(self):
        return self#返回自己

    def __next__(self):
        if self.idx < self.n:
            val = self.idx
            self.idx += 1
            return val
        else:
            raise StopIteration()

myRange = MyRange(3)
print (next(myRange))
print (next(myRange))
print (next(myRange))

12.生成器

在Python中，这种一边循环一边计算的机制，称为生成器（Generator）
优点：节省空间
两种方式：（）或yield

代码示例1：（）

L= [x*x for x in range(10)]
print(L)
g = (x*x for x in range(10))
print (g)

print (next(g))
print (next(g))
print (next(g))
print (next(g))

for i in g:
      print (i)

代码示例：yield

def odd():
    print ('step 1')
    yield 1
    print ('step 2')
    yield 3
    print ('step 3')
    yield 5
o = odd()
print (next(o))
print (next(o))
print (next(o))
print (next(o))

#for i in o:
#    print i 

迭代器和生成器的区别：
1.迭代器需要实现对应的__iter__()和__next__()方法。对于可迭代对象，for语句可以通过iter()方法获取迭代器，并且通过next方法获得容器的下一个元素。
2.生成器是一种特殊的迭代器，不需要明确定义__iter__()和__next__()方法
3.生成器通过生成器函数产生，生成器函数可以通过常规的def语句来定义，但是不用return返回，而是用yield一次返回一个结果

13.枚举

同时获得标号和元素

#encoding=utf-8
for i ,value in enumerate(['A','B','C']):
      print(i,value)

14.深浅拷贝

Python中的对象之间赋值时是按引用传递的，如果需要拷贝对象，需要使用标准库中的copy模块。
浅拷贝（copy.copy()):生成了新的列表，每个元素指向原列表中的地址
深拷贝（copy.deepcopy()):生成了新的列表，每个元素都是新的
代码示例：

#encoding = utf-8
import copy
a = [1, 2, 3, 4, 5, ['a', 'b']]  # 原始对象
b = a  # 赋值，传对象的引用
c = copy.copy(a)  # 对象拷贝，浅拷贝
d = copy.deepcopy(a)  # 对象拷贝，深拷贝
a.append(6)  # 修改对象a
a[5].append('c')  # 修改对象a中的['a', 'b']数组对象
print ('a = ', a)
print ('b = ', b)
print ('c = ', c)
print ('d = ', d)

15.通过list实现堆栈（后进先出）

通过List实现一个堆栈，堆栈就是存储数据的一种数据结构，后存入的数
据，会被先取出
代码示例：’’‘list实现堆栈：pop()’’’

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print (stack)
print (stack.pop())
print (stack)
print (stack.pop())
print (stack.pop())
print (stack)

16.通过list实现队列（先进先出）

代码示例：’’‘list实现队列：pop(0)’’’

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print (stack.pop(0))
print (stack.pop(0))
print (stack.pop(0))

代码示例：deque

#encoding=utf-8
from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")           # Terry arrives
queue.append("Graham")          # Graham arrives
print (queue.popleft())                # The first to arrive now leaves
print (queue.popleft())                # The second to arrive now leaves
print (queue)                    # Remaining queue in order of arrival