python实用小技巧

max & min

获取最大值或最小值，两种用法
max(arg1, arg2, *args[, key])
max(iterable, *[, key, default])
参数: key，其为一个函数，用来指定取最大/小值的方法
参数: default用来指定最大/小值不存在时返回的默认值

"""
max(arg1, arg2, *args[, key]) 示例
"""
>>> print(max(1,2,3,4))
4
>>> print(min(1,2,3,4))
1
>>> s = '12345'
>>> print(max(s))
5
>>> print(max((),default=1))
1
>>> max(1,2,'3',key = int) # 指定key为转换函数后，可以取最大值
'3'
>>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
-1

"""
max(iterable, *[, key, default])示例
"""
>>> lst = [{'name': 'sumcet', 'age': 18}, {'name': 'bbu', 'age': 11}]
>>> max(lst, key=lambda x: x['age'])
{'name': 'sumcet', 'age': 18} # 获取年龄最大的

>>> min(lst, key=lambda x: x['age'])
{'name': 'bbu', 'age': 11} # 获取年龄最小的

map

根据提供的函数对指定序列做映射
语法：map(function, iterable, ...)
参数：function -- 函数，iterable -- 一个或多个序列

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) # 提供了两个列表，对相同位置的列表数据进行相加
[3, 7, 11, 15, 19]

lambda

lambda用来创建匿名函数。传入一个或多个参数
语法：lambda [arg1 [,arg2,.....argn]]:expression

>>> sum = lambda x,y:x+y
>>> sum(100,200)
300

>>> c = {'apple': 6899, 'htc': 3999}
>>> d = {'huawei': 4888, 'mi': 1999, 'oppo': 2799}
>>> e = {**c, **d}
>>> e
{'apple': 6899, 'htc': 3999, 'huawei': 4888, 'mi': 1999, 'oppo': 2799}
>>> name = list(map(lambda x:x, e)) # 字典默认打印的是key
>>> name
['apple', 'htc', 'huawei', 'mi', 'oppo']

>>> name = list(map(lambda x:x, e.keys()))
>>> name
['apple', 'htc', 'huawei', 'mi', 'oppo']

>>> price = list(map(lambda x:x, e.values()))
>>> price
[6899, 3999, 4888, 1999, 2799]

zip

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
注意：如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [6,7,8,9]
>>> zipped = zip(a,b)
>>> print(zipped)  # 返回的是一个对象
<zip object at 0x10726fc88>
>>> L = list(zipped) # 转换为list
>>> print(L)
[(1, 4), (2, 5), (3, 6)]

>>> list(zip(a,c)) # 元素个数与最短的列表一致
[(1, 6), (2, 7), (3, 8)]

>>> a2,b2 = zip(*list(L))  # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a2)
[1, 2, 3]
>>> list(b2)
[4, 5, 6]

join

将序列中的元素以指定的字符连接生成一个新的字符串。

>>> seq = ("a", "b", "c")
>>> print('-'.join(seq)) #参数：连接的元素序列
a-b-c
>>> print(''.join(seq))
abc

anagram

所谓anagram，就是两个词所用的字母及其个数都是一样的，但是它们字母的位置不一样

"""字符串"""
>>> from collections import Counter
>>> a = 'abc'
>>> b = 'cba'
>>> Counter(a) == Counter(b)
True
>>> Counter(a)
Counter({'a': 1, 'b': 1, 'c': 1})
>>> Counter(b)
Counter({'c': 1, 'b': 1, 'a': 1})

"""列表"""
>>> a = [1,2,3]
>>> b = [1,3,2]
>>> a == b
False
>>> from collections import Counter
>>> Counter(a) == Counter(b)
True

"""字典原生支持"""
>>> c = {'a':1, 'b':2}
>>> d = {'b':2, 'a':1}
>>> c == d
True

倒转

"""字符串倒转"""
>>> L1 = 'abcdefg'
>>> L2 = L1[::-1] # 切片法，a[::-1]就相当于a[尾:头:-1]
>>> print(L1,L2)
abcdefg gfedcba

"""整数字倒转"""
>>> N1 = 123456789
>>> N2 = int(str(N1)[::-1])
>>> print(N2)
987654321

"""列表倒转"""
>>> L1 = ['a','b','c','d','e']
>>> L2 = [L for L in reversed(L1)] # 内置函数reversed(),用于list倒转
>>> print(L2)
['e', 'd', 'c', 'b', 'a']

排序

sort： 是应用在 list 上的方法
sorted 可以对所有可迭代的对象进行排序操作

"""
sort() 方法只为 list 定义
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
"""
>>> L = [2,3,1,5,2,6]
>>> L.sort() # 正序
>>> L
[1, 2, 2, 3, 5, 6]
>>> L.sort(reverse=True) # 倒序
>>> L
[6, 5, 3, 2, 2, 1]

"""
sorted() 函数可以接收任何的 iterable。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
"""
>>> _list = [5, 0, 6, 1, 2, 7, 3, 4] #处理列表
>>> sorted(_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]

>>> d = {1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'} # 处理字典
>>> sorted(d, reverse=True)
[5, 4, 3, 2, 1]

>>> D = sorted(d.items(), key=lambda x: x[1]) # 以字典的value升序
>>> print(D)
[(5, 'A'), (2, 'B'), (3, 'B'), (1, 'D'), (4, 'E')]

>>> E = sorted(d.items(), key=lambda x: x[1], reverse=True) # 以字典的value倒序
>>> print(E)
[(4, 'E'), (1, 'D'), (2, 'B'), (3, 'B'), (5, 'A')]

列表去重

方法一：把list转成set，去除重复项，再转回list。
方法二：调用collections里的OrderedDict，和set差不多。

items = ['foo', 'bar', 'bar', 'foo']
>>> list(set(items))
['bar', 'foo']

>>> from collections import OrderedDict
>>> print(list(OrderedDict.fromkeys(items).keys()))
['foo', 'bar']

list中最大索引

获取列表中值最大/最小的元素的索引值

>>> lst = [3, 8, 24, 11, 34, 23]
>>> max(range(len(lst)), key=lst.__getitem__)
4
>>> min(range(len(lst)), key=lst.__getitem__)
0
>>>

list重复最多的元素

第一种是利用max()函数的key参数
第二种则是使用Counter

"""第一种"""
>>> lst
[1, 2, 3, 1, 2, 5, 6, 1, 3, 2, 4, 1]
>>> max(set(lst), key = lst.count)
1

"""第二种"""
>>> from collections import Counter
>>> cnt = Counter(lst)
>>> cnt
Counter({1: 4, 2: 3, 3: 2, 5: 1, 6: 1, 4: 1})
>>> cnt.most_common()
[(1, 4), (2, 3), (3, 2), (5, 1), (6, 1), (4, 1)]
>>> cnt.most_common(1) # 获取排名第一的元祖
[(1, 4)]

合并字典

"""方式一"""
>>> c
{'apple': 6899, 'htc': 3999}
>>> d
{'huawei': 4888, 'mi': 1999, 'oppo': 2799}
>>> d.update(c)
>>> d
{'huawei': 4888, 'mi': 1999, 'oppo': 2799, 'apple': 6899, 'htc': 3999}

"""方式二"""
>>> d1 = {'a':1, 'b':2}
>>> d2 = {'c':3, 'd':4}
>>> d3 = {**d1, **d2}
>>> print(d3)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}