python实战打卡---day4-CSDN博客

本文链接：https://blog.csdn.net/liang0502/article/details/125601471

全展开

对于如下数组[[[1,2,3],[4,5]]]

如何完全展开成⼀维的。这个⼩例⼦实现的 flatten是递归版，两个参数分别表⽰带展开的数组，输出
数组。

from collections.abc import *
def flatten(lst,out_lst=None):
    if out_lst is None:
        out_lst=[]
    for i in lst:
        if isinstance(i,Iterable):# 判断i是否可以迭代
            flatten(i,out_lst) # 尾数递归
        else:
            out_lst.append(i) # 产生结果
    return out_lst
print(flatten([[1,2,3],[4,5]]))
print(flatten([[1,2,3],[4,5]],[6,7]))
print(flatten([[[1,2,3],[4,5,6]]]))
'''
[1, 2, 3, 4, 5]
[6, 7, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
'''

numpy⾥的 flatten与上⾯的函数实现有些微妙的不同：

import numpy
b=numpy.array([[1,2,3],[4,5]])
b.flatten()
'''
array([list([1, 2, 3]), list([4, 5])], dtype=object)
'''

列表等分

from math import ceil
def divide(lst,size):
    if size<=0:
        return [lst]
    return [lst[i * size:(i+1)*size]for i in range(0,ceil(len(lst)/size))]
r=divide([1,3,5,7,9],2) # [[1, 3], [5, 7], [9]]

列表压缩

def filter_false(lst):
    return list(filter(bool,lst))
r=filter_false([None,0,False,' ',[],'ok',[1,2]])
print(r) # [' ', 'ok', [1, 2]]

更长的列表

def max_length(*lst):
    return max(*lst,key=lambda v:len(v))
r=max_length([1,2,3],[4,5,6,7],[8])
r # [4, 5, 6, 7]

求众数

def top1(lst):
    return max(lst,default='列表为空',key=lambda v:lst.count(v))
lst=[1,3,3,2,1,1,2]
r=top1(lst)
r # 1

多表之最

def max_lst(*lst):
    return max(max(*lst,key=lambda v:max(v)))
r=max_lst([1,2,3],[6,7,8],[4,5])
r # 8

列表查重

def has_duplicates(lst):
    return len(lst)==len(set(lst))
x=[1,1,2,2,3,2,3,4,5,6]
y=[1,2,3,4,5]
has_duplicates(x) # False
has_duplicates(y) # True

列表反转

def reverse(lst):
    return lst[::-1]
r=reverse([1,-2,3,4,1,2])
print(r) # [2, 1, 4, 3, -2, 1]

浮点数等差数列

def rang(start,stop,n):
    start,stop,n=float('%.2f'%start),float('%.2f'%stop),int('%.d'%n)
    step=(stop-start)/n
    lst=[start]
    while n>0:
        start,n=start+step,n-1
        lst.append(round((start),2))
    return lst
rang(1,8,10) # [1.0, 1.7, 2.4, 3.1, 3.8, 4.5, 5.2, 5.9, 6.6, 7.3, 8.0]

按条件分组

def bif_by(lst,f):
    return [[x for x in lst if f(x)],[x for x in lst if not f(x)]]
records=[25,89,31,34]
bif_by(records,lambda x: x<80) # [[25, 31, 34], [89]]

map实现向量运算

lst1=[1,2,3,4,5,6]
lst2=[3,4,5,6,3,2]
list(map(lambda x,y:x*y+1,lst1,lst2)) # [4, 9, 16, 25, 16, 13]

值最大的字典

def max_pairs(dic):
    if len(dic)==0:
        return dic
    max_val=max(map(lambda v:v[1],dic.items()))
    return [item for item in dic.items()if item[1]==max_val]
r=max_pairs({'a':-10,'b':5,'c':3,'d':5})
print(r) # [('b', 5), ('d', 5)]

合并两个字典

def merge_dict(dic1,dic2):
    return {**dic1,**dic2} # python3.5后⽀持的⼀⾏代码实现合并字典
merge_dict({'a':1,'b':2},{'c':3}) # {'a': 1, 'b': 2, 'c': 3}

topn字典

from heapq import nlargest
# 返回字典d前n个最⼤值对应的键
def topn_dic(d,n):
    return nlargest(n,d,key=lambda k:d[k])
topn_dic({'a':10,'b':8,'c':9,'d':10},3) # ['a', 'd', 'c']

异位词

from collections import Counter
# 检查两个字符串是否 相同字母异序词，简称：互为变位词
def anagram(str1, str2):
    return Counter(str1) == Counter(str2)

anagram('eleven', 'twelve') # False
anagram('eleven+two', 'twelve+one') # True 这是⼀对神器的变位词

逻辑上合并字典
```
dic1 = {'x': 1, 'y': 2 }
dic2 = {'y': 3, 'z': 4 }
merged1 = {**dic1, **dic2} # {'x': 1, 'y': 3, 'z': 4}
```
修改merged[‘x’]=10，dic1中的x值不变， merged是重新⽣成的⼀个新字典。但是， ChainMap却不同，它在内部创建了⼀个容纳这些字典的列表。因此使⽤ChainMap合并字典，修改merged[‘x’]=10后，dic1中的x值改变，如下所⽰：
```
from collections import ChainMap
merged2 = ChainMap(dic1,dic2)
print(merged2) # ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})
```

命名元组提高可持续性

使⽤命名元组写出来的代码可读性更好，尤其处理上百上千个属性时作⽤更加凸显。

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y', 'z']) # 定义名字为Point的元祖，字段属性有x,y,z
lst = [Point(1.5, 2, 3.0), Point(-0.3, -1.0, 2.1), Point(1.3, 2.8, -2.5)]
print(lst[0].y - lst[1].y) # 2-(-1.0)=3.0

样本抽样

使⽤ sample抽样，如下例⼦从100个样本中随机抽样10个。

from random import randint,sample
lst = [randint(0,50) for _ in range(100)]
print(lst[:5])
lst_sample = sample(lst,10)
print(lst_sample) 
'''
[45, 32, 38, 35, 39]
[13, 27, 47, 7, 21, 7, 41, 7, 25, 16]
'''

重洗数据集

使⽤ shuffle⽤来重洗数据集，值得注意的是shuffle是对lst就地(in place)洗牌，节省存储空间

from random import shuffle
lst = [randint(0,50) for _ in range(100)]
shuffle(lst)
print(lst[:5]) # [17, 3, 25, 16, 6]

10个均匀分布的坐标点

random模块中的 uniform(a,b)⽣成[a,b)内的⼀个随机数，如下⽣成10个均匀分布的⼆维坐标点

from random import uniform
[(uniform(0,10),uniform(0,10)) for _ in range(10)]
'''
[(0.2665807600279879, 5.383511432442373),
 (1.5011019829743688, 2.0019173174172322),
 (7.895402475082539, 7.993310691595755),
 (5.580681202712464, 1.1822304529034222),
 (4.2766601036812615, 9.37591748760102),
 (8.192889244729486, 5.579512714276839),
 (7.751755541777804, 2.5924639030348184),
 (1.3365837183662788, 1.5694256418294983),
 (3.3888833600812385, 1.393886311289294),
 (4.691993668789238, 6.975086973487919)]
'''