原文链接

1.链式比较

i=3
print(1<i<3)
print(1<i<=3)

2.不用else和if实现计算器

from operator import *

def calculator(a,b,k):
    return{
        "+":add,
        "-":sub,
        "*":mul,
        "/":truediv,
        "**":pow
    }[k](a,b)

calculator(1,2,"+")
calculator(3,4,"**")

3.函数链

from operator import (add,sub)

def add_or_sub(a,b,oper):
    return (add if oper=="+" else sub)(a,b)

add_or_sub(1,2,"+")

4.求字符串的字节长度

def str_byte_len(mystr):
    return(len(mystr.encode("utf-8")))

str_byte_len("i love python")
str_byte_len("字符")

5.寻找n次出现的位置

def search_n(s,c,n):
    size=0
    for i, x in enumerate(s):
        if x==c:
            size+=1
        if size==n:
            return i
    return -1

print(search_n("fdasadfadf","a",3))
print(search_n("fdasadfadf","a",30))

6.去掉最高最低求平均

def score_mean(lst):
    lst.sort()
    lst2=lst[1:len(lst)-1]
    return round(sum(lst)/len(lst2),2)

score_mean([9.1,9.0,8.1,9.7,19,8.2,8.6,9.8])

7.交换元素

def swap(a,b):
    return b,a

swap(1,0)

8.二分查找

def binarySearch(arr,x):
    left=0
    right=len(arr)-1
    while left<=right:
        # (left+right)/2容易溢出,但python会强转long,不会溢出
        mid=int(left+(right-left)/2)
        if arr[mid]==x:
            print("found %d 在索引位置%d" %(x,mid))
            return mid

        elif arr[mid]<x:
            left=mid+1
            print("区间缩小为[%d,%d]" %(mid+1,right))
        
        elif arr[mid]>x:
            right=mid-1
            print("区间缩小为[%d,%d]" %(left,mid-1))
    return -1

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

9.距离矩阵

import numpy as np
x,y=np.mgrid[0:5,0:5]
list(map(lambda xe,ye:[(ex,ey) for ex,ey in zip(xe,ye)],x,y))

10.打印乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print('{0}*{1}={2}'.format(j,i,j*i),end="\t")
    print()

11.嵌套数组完全展开

from collections.abc import *

def flatten(input_arr,output_arr=None):
    if output_arr is None:
        output_arr=[]
    for ele in input_arr:
        # isinstance判断类型,Iterable可迭代类型
        if isinstance(ele,Iterable):
            flatten(ele,output_arr)
        else:
            output_arr.append(ele)
    return output_arr

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

12.list分组

from math import ceil

def divide(lst,size):
    if size<=0:
        return [lst]
    # ceil向下取整
    return [lst[i * size : (i+1)*size] for i in range(0,ceil(len(lst)/size))]

divide([1,3,5,7,9],2)

13.单列分割为多列

import pandas as pd
import os

# file_folder="此处输入待处理的文件夹位置"
# files=os.listdir(file_folder)

# for file in files:
#     file_loc=file_folder+"/"+file
#     raw_data=pd.read_csv(file_loc,header=None)
#     data_after_process=raw_data.iloc[:,0].str.split(";",expand=True)
#     data_after_process_loc="处理完毕后的数据存储位置"+"/"+file
#     data_after_process.to_csv(data_after_process_loc,index=None,header=None)

14.生成fibonacci序列前n项(普通版)

def fibonacci(n):
    if n<=1:
        return [1]
    fib=[1,1]
    
    while len(fib)<n:
        fib.append(fib[len(fib)-1]+fib[len(fib)-2])
    return fib

fibonacci(5)

15.生成fibonacci序列前n项(生成器版)

def fibnoacci(n):
    a,b=1,1
    for _ in range(n):
        yield a
        a, b = b, a+b

list(fibonacci(5))

16.过滤false值

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

filter_false([None,0,False,"",[],"ok",[1,2]])

17.对象转换为可迭代类型

from collections.abc import Iterable

def cast_iterable(val):
    return val if isinstance(val,Iterable) else [val]

print(cast_iterable('foo'))
print(cast_iterable(12))
print(cast_iterable({"foo":12}))

18.求更长列表

def max_length(*lst):
    return max(*lst,key=lambda v:len(v))

print(f"更长的列表是{max_length([1,2,3],[4,5,6,7],[8])}")

19.出现次数最多的元素

def max_frequency(lst):
    return max(lst,default="列表为空",key=lambda v: lst.count(v))

lst=[1,3,3,2,1,1,2]
r=max_frequency(lst)
print(f"{lst}中出现次数最多的元素为:{r}")

20.求多个列表的最大值

def max_lists(*lst):
    return max(max(*lst,key=lambda v:max(v)))

print(max_lists([1,2,3],[6,7,8],[4,5]))

21.列表重复元素检查

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

x=[1,1,2,2,3,2,3,4,5,6]
has_duplicates(x)

22.求列表中的重复元素

from collections import Counter

def find_all_duplicates(lst):
    c=Counter(lst)
    return list(filter(lambda k: c[k]>1,c))

find_all_duplicates([1,2,2,3,3,4])

23.浮点数等差数列

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)

24.列表按条件分组

def bif_by(lst,Fn):
    return [[x for x in lst if Fn(x)],[x for x in lst if not Fn(x)]]

records=[25,89,31,34]
bif_by(records,lambda x:x<80)

25.求重复的元素及次数

from collections import Counter

lst=[2,"b",2,3,"d","m","n","n"]
a=Counter(lst)
[x for x in a.items() if x[1]>1]

26.多序列运算函数

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

27.字典最大对

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]

max_pairs({"a":-10,"b":5,"c":3,"d":5})

28.合并字典

def merge_dict2(dic1,dic2):
    return {**dic1,**dic2}

merge_dict2({"a":1,"b":2},{"c":3})

29.求字典前n个最大值

from heapq import nlargest

def topn_dict(d,n):
    return nlargest(n,d,key=lambda k: d[k])

topn_dict({"a":10,"b":8,"c":9,"d":10},3)

30.字母同顺序不同

from collections import Counter

def anagram(str1,str2):
    return Counter(str1)==Counter(str2)

# 神奇的变位词
anagram("eleven+two","twelve+one")