快乐学习
前程无忧、中华英才非你莫属!

30个常用的Python代码片段

例子1:检查列表中的所有元素是否相等。

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

例子2:检查列表中所有的值是否唯一

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

例子3:根据元素对应的布尔值,过滤为2组

def bifurcate(lst, filters):  # lst:列表  filter:依据的过滤内容
    return [
        [x for i, x in enumerate(lst) if filters[i] == True],
        [x for i, x in enumerate(lst) if filters[i] == False]
    ]

# 使用案例
bifurcate(['beep', 'boop', 'foo', 'bar'], [True, True, False, True])
# 输出结果: [ ['beep', 'boop', 'bar'], ['foo'] ]

例子4:根据函数将值拆分为两个组,该函数指定输入列表中的元素属于哪个组。


def bifurcate_by(lst, fn):
    return [
        [x for x in lst if fn(x)],
        [x for x in lst if not fn(x)]

bifurcate_by(['beep', 'boop', 'foo', 'bar'], lambda x: x[0] == 'b')
# 输出结果: [ ['beep', 'boop', 'bar'], ['foo'] ]

例子5:将列表分成较小的指定大小的列表。

'''
使用list()和range()创建所需的列表size。
map()在列表上使用并用给定列表的拼接填充它。最后,返回使用创建列表。
'''

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]

例子6:从列表中删除falsey值。

例如 使用filter()过滤掉falsey值(False,None,0和"")。


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

# 使用案例
compact([0, 1, False, 2, '', 3, 'a', 's', 34])
#  输出结果
[ 1, 2, 3, 'a', 's', 34 ]

例子7:根据给定函数对列表元素进行分组,并返回每个组中元素的数量


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

# 使用
from math import floor
count_by([6.1, 4.2, 6.3], floor)
# 输出结果
{4: 1, 6: 2}

count_by(['one', 'two', 'three'], len)
# 输出结果
{3: 2, 5: 1}

例子7:计算列表中值的出现次数


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

例子8:深度压扁列表


'''
使用递归。定义一个函数,spread它使用列表中的每个元素list.extend()或
其中的任何list.append()元素来展平它。
使用list.extend()空列表和spread函数来展平列表。递归地展平作为列表的每个元素。

'''

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]

例子9:返回两个iterables之间的差异。

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]

例子10、将提供的函数应用于两个列表元素后,返回两个列表之间的差异。

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 } ]

例子11、通过函数判断,列表是否满足 lambda表达式,满足的true,不满足的False。

def every(lst, fn=lambda x: not not x):
    for el in lst:
        if not fn(el):
            return False
    return True

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

例子12、返回列表中的每个第n个元素

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

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

例子13、过滤掉列表中的非唯一值。

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]

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

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

import math
group_by([6.1, 4.2, 6.3], math.floor)  
# {4: [4.2], 6: [6.1, 6.3]}

例子15、列表中是否存在重复值,


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

例子16:返回列表的头部。


def head(lst):
    return lst[0]

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

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

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

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

例子18:初始化给定宽度和高度以及值的2D列表。

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]]

例子19: 初始化包含指定范围内的号码,其中的列表start和end已包括其共同差step。

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]

例子20、使用指定的值初始化并填充列表。

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]

例子21、返回两个列表中存在的元素列表。

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]

例子22、 将提供的函数应用于两个列表元素后,返回两个列表中存在的元素列表。


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]

例子23、返回列表中的最后一个元素

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

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

24、获取具有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'

25、返回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]

26、返回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]

27、如果提供的函数返回True列表中的至少一个元素,True否则。

def none(lst, fn=lambda x: not not x):
    for el in lst:
        if fn(el):
            return False
    return True

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

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

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]

29、从数组中返回一个随机元素。

from random import randint

def sample(lst):
    return lst[randint(0, len(lst) - 1)]
sample([3, 7, 9, 11])  # 9

30、随机化列表值的顺序,返回一个新列表。

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]

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


def similarity(a, b):
    return [item for item in a if item in b]

similarity([1, 2, 3], [1, 2, 4])  # [1, 2]
打赏
赞(1) 打赏
未经允许不得转载:同乐学堂 » 30个常用的Python代码片段
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

特别的技术,给特别的你!

联系QQ:1071235258QQ群:367203382

觉得文章有用就打赏一下文章作者

非常感谢你的打赏,我们将继续给力更多优质内容,让我们一起创建更加美好的网络世界!

支付宝扫一扫打赏

微信扫一扫打赏