Python实用技巧--list篇

原文网址

https://github.com/30-seconds/30-seconds-of-python

• all_equal

检查list中的所有元素是否都相同

def all_equal(lst):
  return lst[1:] == lst[:-1]

示例

all_equal([1, 2, 3, 4, 5, 6]) # False
all_equal([1, 1, 1, 1]) # True

• all_unique

检查list中所有元素是否都不同

def all_unique(lst):
  return len(lst) == len(set(lst))

示例

x = [1,2,3,4,5,6]
y = [1,2,2,3,4,5]
all_unique(x) # True
all_unique(y) # False

• bifurcate

将list中元素按照布尔数组filter分为两组

def bifurcate(lst, filter):
  return [
    [x for i,x in enumerate(lst) if filter[i] == True],
    [x for i,x in enumerate(lst) if filter[i] == False]
  ]

示例

bifurcate(['beep', 'boop', 'foo', 'bar'], [True, True, False, True]) # [ ['beep', 'boop', 'bar'], ['foo'] ]

• chunk

将list按指定大小分为多个子列表

from math import ceil

def chunk(lst, size):
  return list(
    map(lambda x: lst[x * size:x * size + size],
      list(range(0, ceil(len(lst) / size)))))

例子

chunk([1,2,3,4,5],2) # [[1,2],[3,4],5]

• compact

去除列表中的空值(False, None, 0, and "").

def compact(lst):
  return list(filter(bool, lst))

示例

compact([0, 1, False, 2, '', 3, 'a', 's', 34]) # [ 1, 2, 3, 'a', 's', 34 ]

• count_by

根据给定的函数对列表中的元素进行分组，并返回每个组中元素的计数

def count_by(arr, fn=lambda x: x):
  key = {}
  for el in map(fn, arr):
    key[el] = 1 if el not in key else key[el] + 1
  return key

示例

from math import floor
count_by([6.1, 4.2, 6.3], floor) # {6: 2, 4: 1}
count_by(['one', 'two', 'three'], len) # {3: 2, 5: 1}

• count_occurences

计算列表中某个值（类型一致）的出现次数

def count_occurrences(lst, val):
  return len([x for x in lst if x == val and type(x) == type(val)])

示例

count_occurrences([1, 1, 2, 1, 2, 3], 1) # 3

• deep_flatten

展开嵌套列表

def spread(arg):
  ret = []
  for i in arg:
    if isinstance(i, list):
      ret.extend(i)
    else:
      ret.append(i)
  return ret

def deep_flatten(lst):
  result = []
  result.extend(
    spread(list(map(lambda x: deep_flatten(x) if type(x) == list else x, lst))))
  return result

示例

deep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]

• difference

求列表a与列表b的差集

def difference(a, b):
  _b = set(b)
  return [item for item in a if item not in _b]

示例

difference([1, 2, 3], [1, 2, 4]) # [3]

• difference_by

在将提供的函数应用于两个列表的每个列表元素之后，返回两个列表之间的差

def difference_by(a, b, fn):
  _b = set(map(fn, b))
  return [item for item in a if fn(item) not in _b]

示例

from math import floor
difference_by([2.1, 1.2], [2.3, 3.4],floor) # [1.2]
difference_by([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], lambda v : v['x']) # [ { x: 2 } ]

• every

如果提供的函数对列表中的每个元素返回True，则返回True，否则返回False

def every(lst, fn=lambda x: x):
  return all(map(fn, lst))

示例

every([4, 2, 3], lambda x: x > 1) # True
every([1, 2, 3]) # True

• every_nth

返回给定列表中每第n个元素

def every_nth(lst, nth):
  return lst[nth-1::nth]

示例

every_nth([1, 2, 3, 4, 5, 6], 2) # [ 2, 4, 6 ]

• filter_non_unique

过滤列表中的非唯一值。

def filter_non_unique(lst):
  return [item for item in lst if lst.count(item) == 1]

示例

filter_non_unique([1, 2, 2, 3, 4, 4, 5]) # [1, 3, 5]

• flatten

展开嵌套列表

def flatten(lst):
  return [x for y in lst for x in y]

示例

flatten([[1,2,3,4],[5,6,7,8]]) # [1, 2, 3, 4, 5, 6, 7, 8]

• group_by

根据给定的函数对列表的元素进行分组。

def group_by(lst, fn):
    return {key : [el for el in lst if fn(el) == key] for key in map(fn,lst)}

示例

import math
group_by([6.1, 4.2, 6.3], math.floor) # {4: [4.2], 6: [6.1, 6.3]}
group_by(['one', 'two', 'three'], len) # {3: ['one', 'two'], 5: ['three']}

• has_duplicates

判断列表中是否有重复元素

def has_duplicates(lst):
  return len(lst) != len(set(lst))

示例

x = [1,2,3,4,5,5]
y = [1,2,3,4,5]
has_duplicates(x) # True
has_duplicates(y) # False

• head

返回列表头元素

def head(lst):
  return lst[0]

示例

head([1, 2, 3]); # 1

• initial

返回列表中除最后一个元素之外的所有元素。

def initial(lst):
  return lst[0:-1]

示例

initial([1, 2, 3]); # [1,2]

• initialize_2d_list

以给定宽度，高度和值初始化2维列表

def initialize_2d_list(w,h, val = None):
  return [[val for x in range(w)] for y in range(h)]

示例

initialize_2d_list(2, 2, 0) # [[0,0], [0,0]]

初始化一个列表，该列表包含指定范围内的数字，包括开始和结束值，并可设置步距。

def initialize_list_with_range(end, start = 0, step = 1):
  return list(range(start, end + 1, step))

示例

initialize_list_with_range(5) # [0, 1, 2, 3, 4, 5]
initialize_list_with_range(7,3) # [3, 4, 5, 6, 7]
initialize_list_with_range(9,0,2) # [0, 2, 4, 6, 8]

• initialize_list_with_values

用指定的值及个数初始化并填充列表。

def initialize_list_with_values(n, val = 0):
  return [val for x in range(n)]

示例

initialize_list_with_values(5, 2) # [2, 2, 2, 2, 2]

• intersection

返回两个列表中都存在的元素的列表。

def intersection(a, b):
  _b = set(b)
  return [item for item in a if item in _b]

示例

intersection([1, 2, 3], [4, 3, 2]) # [2, 3]

• intersection_by

将提供的函数应用于两个列表的每个列表元素后，返回两个列表中都存在的元素的列表。

def intersection_by(a, b, fn):
  _b = set(map(fn, b))
  return [item for item in a if fn(item) in _b]

示例

from math import floor
intersection_by([2.1, 1.2], [2.3, 3.4],floor) # [2.1]

• last

返回列表中的最后一个元素。

def last(lst):
  return lst[-1]

示例

last([1, 2, 3]) # 3

• longest_item

接受任意数量的可迭代对象或具有length属性的对象，并返回最长的对象。如果多个对象的长度相同，则将返回第一个。

def longest_item(*args):
  return max(args, key = len)

示例

longest_item('this', 'is', 'a', 'testcase') # 'testcase'
longest_item([1, 2, 3], [1, 2], [1, 2, 3, 4, 5]) # [1, 2, 3, 4, 5]
longest_item([1, 2, 3], 'foobar') # 'foobar'

• max_n

返回提供的列表中的n个最大元素。如果n大于或等于提供的列表的长度，则返回原始列表（以降序排列）。

def max_n(lst, n=1):
  return sorted(lst, reverse=True)[:n]

示例

max_n([1, 2, 3]) # [3]
max_n([1, 2, 3], 2) # [3,2]

• min_n

从提供的列表中返回n个最小元素。如果n大于或等于提供的列表的长度，则返回原始列表（以升序排列）。

def min_n(lst, n=1):
  return sorted(lst, reverse=False)[:n]

示例

min_n([1, 2, 3]) # [1]
min_n([1, 2, 3], 2) # [1,2]

• none

如果提供的函数对列表中的至少一个元素返回True，则返回False，否则返回True。

def none(lst, fn=lambda x: x):
  return all(not fn(x) for x in lst)

示例

none([0, 1, 2, 0], lambda x: x >= 2 ) # False
none([0, 0, 0]) # True

• offset

将指定数量的元素移到列表的末尾。

def offset(lst, offset):
  return lst[offset:] + lst[:offset]

示例

offset([1, 2, 3, 4, 5], 2) # [3, 4, 5, 1, 2]
offset([1, 2, 3, 4, 5], -2) # [4, 5, 1, 2, 3]

• sample

从列表中随机返回一个元素

from random import randint

def sample(lst):
  return lst[randint(0, len(lst) - 1)]

示例

sample([3, 7, 9, 11]) # 9

• shuffle

随机化列表值的顺序，返回一个新列表

from copy import deepcopy
from random import randint

def shuffle(lst):
  temp_lst = deepcopy(lst)
  m = len(temp_lst)
  while (m):
    m -= 1
    i = randint(0, m)
    temp_lst[m], temp_lst[i] = temp_lst[i], temp_lst[m]
  return temp_lst

示例

foo = [1,2,3]
shuffle(foo) # [2,3,1] , foo = [1,2,3]

• some

def some(lst, fn=lambda x: x):
  return any(map(fn, lst))

示例

some([0, 1, 2, 0], lambda x: x >= 2 ) # True
some([0, 0, 1, 0]) # True

• spread

通过将其元素散布到新列表中来使展开列表

def spread(arg):
  ret = []
  for i in arg:
    if isinstance(i, list):
      ret.extend(i)
    else:
      ret.append(i)
  return ret

示例

spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]

• symmetric_difference_by

将给定的函数应用于两个列表的每个列表元素后，返回两个列表之间的对称差。

def symmetric_difference_by(a, b, fn):
  _a, _b = set(map(fn, a)), set(map(fn, b))
  return [item for item in a if fn(item) not in _b] + [item for item in b if fn(item) not in _a]

示例

from math import floor
symmetric_difference_by([2.1, 1.2], [2.3, 3.4],floor) # [1.2, 3.4]

• tail

返回列表中除第一个元素外的所有元素

def tail(lst):
  return lst[1:] if len(lst) > 1 else lst

示例

tail([1, 2, 3]); # [2,3]
tail([1]); # [1]

• union

一次返回两个列表中任何一个存在的每个元素。

def union(a,b):
  return list(set(a + b))

示例

union([1, 2, 3], [4, 3, 2]) # [1,2,3,4]

• union_by

将给定的函数应用于两个列表中的每个元素之后，一次返回两个列表中任何一个列表中存在的每个元素

def union_by(a,b,fn):
  _a = set(map(fn, a))
  return list(set(a + [item for item in b if fn(item) not in _a]))

示例

from math import floor
union_by([2.1], [1.2, 2.3], floor) # [2.1, 1.2]

• unique_elements

返回给定列表中的唯一元素（可理解为去重）

def unique_elements(li):
  return list(set(li))

示例

unique_elements([1, 2, 2, 3, 4, 3]) # [1, 2, 3, 4]

• zip

创建元素列表，并根据原始列表中的位置进行分组。

def zip(*args, fillvalue=None):
  max_length = max([len(lst) for lst in args])
  result = []
  for i in range(max_length):
    result.append([
      args[k][i] if i < len(args[k]) else fillvalue for k in range(len(args))
    ])
  return result

示例

zip(['a', 'b'], [1, 2], [True, False]) # [['a', 1, True], ['b', 2, False]]
zip(['a'], [1, 2], [True, False]) # [['a', 1, True], [None, 2, False]]
zip(['a'], [1, 2], [True, False], fill_value = '_') # [['a', 1, True], ['_', 2, False]]