去重

  1. 使用set的特性

    1. orglist = [1,2,3,3,4,5]
    2. formatlist = list(set(orglist))
    3. print(formatlist)
    4. >>[1, 2, 3, 4, 5]

  2. 使用keys()方法

    1. orgList = [1,0,3,7,7,5]
    2. #list()方法是把字符串str或元组转成数组
    3. formatList = list({}.fromkeys(orgList).keys())
    4. print(formatList)
    5. >>[0, 1, 3, 5, 7]

  3. 安装索引再次排序

    1. orgList = [1,0,3,7,7,5]
    2. formatList = list(set(orgList))
    3. formatList.sort(key=orgList.index)
    4. print(formatList)
    5. >>[1, 0, 3, 7, 5]

    排序和反转

  1. 排序

    1. sorted(iterable, cmp=None, key=None, reverse=False)

  2. 反转

    1. a = [1,2,3,4,6]
    2. a = a[::-1] #切片
    3. a = list(reversed(a)) #利用reversed函数
    4. >>[6, 4, 3, 2, 1]

    删除

列表的删除有3种方法

  1. 根据下标删除元素：

    1. numbers1 = [6,7,8,9,10,11]
    2. numbers1.pop(1)
    3. print(numbers1)
    4. >>[6, 8, 9, 10, 11]
    5. numbers = [6,7,8,9,10,11]
    6. del numbers[0]
    7. >>[7, 8, 9, 10, 11]

  2. 直接删除对应的值：

    1. x = [1,2,3,4,5]
    2. x.remove(1)
    3. print(x)
    4. >>[2,3,4,5]

  3. 切片删除：

    1. str1 = ["a","b","c"]
    2. str1[1:2] = []
    3. print(str1)
    4. >>['a', 'c']

  4. 循环删除

循环一个list的时候，每次循环Index索引+1。如果这个时候动态的改变列表比如第一次循环 索引Index = 0, 下一次循环就是 Index = 1如果这个时候列表list动态的改变了，例如Index=1的元素前进的一位，变为Index = 0位置了，这个时候就会漏掉，循环索引会找Index=1的，但是你的Index变为0了，就漏掉了。

  1. alist = [2,2,3]
  2. for i in alist:
  3.     if i == 2:
  4.         alist.remove(i)
  5. print(alist)
  6. >>[2, 3]

解决：采用倒叙，或者拷贝一个新列表循环

  1. alist = [2,2,3]
  2. for i in alist[:]:
  3.     if i == 2:
  4.         alist.remove(i)
  5. print(alist)
  6. >>[3]
  7. alist = [2,2,3]
  8. for i in alist[::-1]:
  9.     if i == 2:
  10.         alist.remove(i)
  11. print(alist)
  12. >>[3]

交集和并集

  1. 合并

    1. x1 = {1,2,3}
    2. x2 = {3,4,5}
    3. print('x1和x2合并',x1 | x2)
    4. print('x1和x2合并',x1.union(x2))
    5. >>x1和x2合并 {1,2,3,4,5}

  2. 相交

    1. x1 = {1,2,3}
    2. x2 = {3,4,5}
    3. print('x1和x2相交',x1 & x2)
    4. print('x1和x2相交',x1.intersection(x2))
    5. >>x1和x2相交 {3}

  3. 差集

    1. x1 = {1,2,3}
    2. x2 = {3,4,5}
    3. print(x1.difference(x2))
    4. >>{1,2}

  4. 抛出公有元素，返回集合合并的子集

    1. x1 = {1,2,3}
    2. x2 = {3,4,5}
    3. print(x1 ^ x2)
    4. >>{1,2,4,5}

    和*

单星（*）

  1. 在函数定义中使用，收集参数。将参数捕捉到一个元组中 ```python def func1(param1,*param2): #param2是可变参数 print(‘param1:’,param1) print(‘param2:’,param2,type(param2)) func1(1,2,3,4,5)

    param1: 1 param2: (2, 3, 4, 5) 

  2. 2. 向函数传递参数，将变量中可迭代对象的元素拆解出来，作为独立的参数第传给函数
  3. ```python
  4. str_list = ["flower","flight","flight"]
  5. for str in zip(*str_list): #将str_list中的每个元素转化为元组
  6.     print(str)
  7. >>>>
  8. ('f', 'f', 'f')
  9. ('l', 'l', 'l')
  10. ('o', 'i', 'i')
  11. ('w', 'g', 'g')
  12. ('e', 'h', 'h')
  13. ('r', 't', 't')
  14. a = [1,2,3,4,5,6]
  15. print(*a)
  16. >>1 2 3 4 5 6

letcode题目：最长公共前缀

双星（**）

以字典的形式导入

  1. def func2(param1,**param2):
  2.     print('param1:',param1)
  3.     print('param2:',param2,type(param2))
  4. func2(1,a=2,b=3,c=4,d=5)
  5. >>param1: 1
  6. >>param2: {'a': 2, 'b': 3, 'c': 4, 'd': 5} <class 'dict'>

合并列表

  1. a = [1,2,3]
  2. b = [4,5,6]
  3. x =[a,b]
  4. print(x)
  5. x = [*a,*b]
  6. print(x)
  7. >>[[1, 2, 3], [4, 5, 6]]
  8. >>[1, 2, 3, 4, 5, 6]

合并字典

  1. a = {'A':1,'B':2}
  2. b = {'C':3,'D':4}
  3. c = {**a,**b}
  4. print(c)
  5. >>{'A': 1, 'B': 2, 'C': 3, 'D': 4}
  6. c = {}
  7. c.update(a)
  8. c.update(b)
  9. >>{'A': 1, 'B': 2, 'C': 3, 'D': 4}

列表合并成字典

  1. a = ['a','b']
  2. b = [1,2]
  3. c = dict(zip(a,b))
  4. print(c)
  5. >>{'a':1,'b':2}

字典的排序

字典在python3.6x后就已经是有序字典了
相对字典进行排序可以使用lamba表达式结合sorted来完成

  1. key_value = {}
  2. key_value = {1:56,7:32,5:23,3:78,2:78}
  3. print(sorted(key_value.items(), key = lambda kv:(kv[1], kv[0]),reverse=True))  
  4. >>[(3, 78), (2, 78), (1, 56), (7, 32), (5, 23)]

字典删除

pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。