1. 基本操作(构造,增,删,查,切片)

A. 构造

list1=[]                                
list1=["12s",1,25.3,[2,4]]              list中的数据类型多种多样
L=list(range(2,10,2))                   构造连续元素的list
L=L1  或者 L=L1[:]                      列表的赋值
[k + '=' + v for k, v in d.items()]     列表生成式进行构造 一个函数一个序列，函数作用于序列，生成一个序列
[m + n for m in 'ABC' for n in 'XYZ']   列表生成式进行构造（从左往右）

List的第一个元素的下标为0 或 -len(list)
List的最后一个元素的下标为len(list)-1 或 -1

B. 增加

list.append(obj)：      在列表末尾添加新的元素
list.insert(index,obj)：将元素插入某一位置之前，如果index大于list的长度，最后加。如果index小于0，最开始加
list1.extend(list2)：   在列表末尾一次性追加另一个序列
list1=list1+list2       在列表末尾一次性追加另一个序列
list1=list1*n           在列表末尾一次性追加n-1个当前序列

C. 删除

list.pop()：            移除列表中的最后一个元素，并且返回该元素的值
list.pop(index)：       移除列表中下表为index的元素，并且返回该元素的值
list.remove(obj)：      移除列表中某个值的第一个匹配项
del L[0]或del L[2:3]    删除指定下标范围的元素

D. 查找

len(list)：             统计列表中元素个数 
list.count(obj)：       统计某个元素在列表中出现的次数
max(list)：             返回列表元素最大值 
min(list)：             返回列表元素最小值 
list.index(obj)：       从列表中找出某个值第一个匹配项的索引位置
obj in list1            判断对象是否在列表中，是一个bool类型

E. 切片与强制转化

list(seq)：                  将元组转换为列表 
L=L[n:]  L=L[:m]  L=L[n:m:3]  L=L[::2] 列表的切片（同样适用于字符串）

2. 高级操作(排序,比较,拆分合并,过滤,循环,转置)

A. 排序

list.reverse()==list[::-1]： 逆序，反向列表中元素
list.sort([func])：          对原列表进行排序    reverse==True时，按降序排列

B. 比较

cmp(list1,list2)：           比较两个列表的元素，返回一个true/false的列表

C. 字符串的拆分与合并

list=s.split(";",1)          字符串的split()将其按“;”分割成list，split 接受一个可选的第二个参数, 它是要分割的次数
s = ";".join(list) join()    方法将list合成一个字符串，以“;”划分，返回一个字符串

D. 过滤

[elem for elem in list1 if len(elem) > 1]      过滤长度大于0的元素
[elem for elem in list1 if elem != "b"]        过滤长度不等于“b”的元素
[elem for elem in list1 if list1.count(elem) == 1] 过滤不重复的元素

E. 循环

<span style="color:#000000">for x,y in [(1,3),(2,4)]:               获取列表的元素
for i ,v in enumerate(L):               获取列表的元素和下标</span>

F. 矩阵转置

zip(*matrix)                 矩阵转置

3. 高阶函数（map(),reduce(),filter(),sorted()）

A. map()
接收一个函数和一个序列。map()把传入的函数依次作用于每个元素，然后在返回整个序列

list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

B. reduce()
接收一个函数和一个序列，reduce()把传入的函数依次作用于每2个元素，做累积，最后返回一个值

reduce(x+y, [1, 3, 5, 7, 9])
reduce(lambda x, y: x * 10 + y, map(char2num, s)）

C. filter()
接收一个函数和一个序列。filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定留还是丢弃该元素。返回的是一个迭代器

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

D. Sorted()
接收一个序列和一个key，将key作用于这个序列，然后对这个序列排序

sorted([‘bob’, ‘about’, ‘Zoo’, ‘Credit’], key=str.lower,reverse=True)
print(sorted([(‘Bob’, 75),( ‘Adam’,92),( ‘Bart’,66),( ‘Lisa’,88)],key=lambda x:x[0]))

4. 应用(队列,堆栈,链表)

A. 队列
list用做队列 要用collections.deque—先进先出

from collections import deque
queue=deque([“Eric”,”John”,”Michael”])
queue.append(“Terry”) # Terry arrives
queue.append(“Graham”) # Graham arrives
queue.popleft() # The first to arrive now leaves’Eric’
queue.popleft() # The second to arrive now leaves’John’
queue # Remaining queue in order of arrival
deque([‘Michael’, ‘Terry’, ‘Graham’])

B. 堆栈
list用成栈—-先进后出

L.append
L.pop

C. 链表
List作为链表使用的代码如下：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
		#定义只有头节点的空链表，l3为头指针，p为遍历指针，carry为进值
        l3=p=ListNode(0)        
        carry=0
        while l1 or l2 or carry:
            if l1:
                carry+=l1.val
                l1=l1.next
            if l2:
                carry+=l2.val
                l2=l2.next
            p.next=ListNode(carry%10)
            p=p.next;
            carry=carry//10
        return l3.next