这里收集一些短小精悍的py代码
这里收集一些短小精悍的py代码
# 利用快速幂计算分数取模
def fraction_mod_inverse(a,b,mod):
# a*(b**(mod-2))%mod
return pow(b,mod-2,mod)*a%mod
# 考察Python中List的insert和del操作
class Solution:
def duplicateZeros(self, arr: List[int]) -> None:
"""
Do not return anything, modify arr in-place instead.
"""
n=len(arr)
pre_n=n
idx=-1
while True:
if idx==n-1:
break
idx+=1
if arr[idx]==0:
arr.insert(idx,0)
idx+=1
n+=1
del arr[pre_n:n]
# 装饰器例子
import time
def printarg(fn):
def wrapper(*args):
print(*args)
return wrapper
def timer(fn):
def wrapper(*args):
t1=time.time()
fn()
t2=time.time()
t=t2-t1
print("%s cost %.1f"%(fn.__name__,t))
return wrapper
@printarg
@timer
def func_a(*args):
time.sleep(1.0)
func_a(3,4,5)
# 指定4个位宽，右对齐
print('{:4}'.format(cur),end="")
# 从头到尾遍历
a=[2,3,5,6,88]
for i,_ in enumerate(a):
print(i,',',a[i])
#encoding:UTF-8
msg = 'www.BAIDU.com.123'
print(msg.upper()) #upper()函数，将所有字母都转换成大写
print(msg.lower()) #lower()函数，将所有字母都转换成小写
print(msg.capitalize()) #capitalize()函数，将首字母都转换成大写，其余小写
print(msg.title()) #title()函数，将每个单词的首字母都转换成大写，其余小写
char.isalpha()
char.isdigit()
# 字典按key排序
cnt4num=sorted(cnt4num.items(),key=lambda x:x[0])
# 判断两个list内容相同
import operator
a=[1,2,3]
b=[1,2,3]
if operator.eq(a,b):
print("same")
# 线性筛，对EulerPhi函数打表
# O(n)复杂度
phi=[0 for i in range(10005)]
prime=[0 for i in range(10005)]
vis=[False for i in range(100005)]
def phi_init(n):
phi[1]=1
cnt=0
for i in range(2,n+1):
if not vis[i]:
cnt=cnt+1
prime[cnt]=i
phi[i]=i-1
for j in range(1,cnt+1):
if i*prime[j]>n:
break
vis[i*prime[j]]=True
if i%prime[j]==0:
phi[i*prime[j]]=phi[i]*prime[j]
break
else:
phi[i*prime[j]]=phi[i]*phi[prime[j]]
# python生成幂集
# 参考https://www.cnblogs.com/Alan-LJP/p/11831228.html
from itertools import combinations
L = [1, 2, 3, 1]
result_list = sum([list(map(list, combinations(L, i))) for i in range(len(L) + 1)], [])
print('result_list =', result_list)
# 整数转二进制表示
print(bin(1)) # 0b1
print(bin(-1)) # -0b1
print(bin(10)) # 0b1010
print(bin(-10)) # -0b1010
print("{0:b}".format(10)) # 1010
print("{0:#b}".format(10)) # 0b1010 , with 0b prefix
print("{0:b}".format(10).zfill(8)) # 00001010 , pad zero, show 8 bits
print(format(10, "b")) # 1010
print(format(10, "#b")) # 0b1010, with 0b prefix
print(format(10, "b").zfill(16)) # 0000000000001010, pad zero, show 16 bits
# with hex, oct bin
# int: 10; hex: a; oct: 12; bin: 1010
result = "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(10)
print(result)
# with 0x, 0o, or 0b as prefix:
# int: 10; hex: 0xa; oct: 0o12; bin: 0b1010
result = "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(10)
print(result)
def generate_random_str(randomlength=16):
"""
生成一个指定长度的随机字符串
"""
str_list = [random.choice(string.digits + string.ascii_letters) for i in range(randomlength)]
random_str = ''.join(str_list)
return random_str
def common_request(method, url, config={}):
response = session.request(method, url, json=config, headers=header)
print("\nstart################################################################################################start")
print("\n******************************[url]******************************\n", response.request.url)
print("\n*****************************[header]****************************\n", header)
if config:
print("\n*****************************[config]****************************\n", config)
print("\n*************************[response.header]***********************\n", response.headers)
print("\n***************************[status_code]**************************\n", response.status_code)
print("\n****************************[response]***************************\n", response.text)
print("\nend##################################################################################################end")
return response
如果 type(obj) 是<class NoneType>
if语句可以这么写：
if obj is None:
十进制转任意进制
def trans_map(cint):
# cint: int
# return: str
# 把数字转化为相应字符，比如10-a, 11-b
if cint < 0:
return None
elif cint < 10: # 数字转为字母
return str(cint)
elif cint >= 10: # ASCII码转为字母A-Z
return chr(cint - 10 + 65)
def tenToAny(n, origin):
# n进制: int
# origin: int
# return: str
res = ''
while origin:
res = trans_map(origin % n) + res # 需要逆序
origin = origin // n # 一定要整除，不然除3会进入死循环
return res
# 统计模式字符串出现了多少次(可重叠)
# 方案1，缺点是regex是第三方的模块
import regex as re
s=input()
t=input()
t_pattern=re.compile(t)
print(len(re.findall(t_pattern, s,overlapped=True)))
# 方案2，最朴素的做法，时间却是最省的，但是依然可能超时
def count_substrings(string, substring):
string_size = len(string)
substring_size = len(substring)
count = 0
for i in range(0,string_size-substring_size+1):
if string[i:i+substring_size] == substring:
count+=1
return count
s=input()
t=input()
print(count_substrings(s, t))
# 方案3，使用re模块把匹配位置也找到
import re
s=input()
t=input()
print([match.start() for match in re.finditer('(?=%s)' % t, s)])
######################################
# 统计模式字符串出现了多少次(不可重叠)
s=input()
t=input()
print(s.count(t))
```python3
# 建议熟背 最长公共子串和最长公共子序列的代码
# 最长公共子串
# 参考https://zhuanlan.zhihu.com/p/268342434
class Solution:
def findLength(self, nums1: List[int], nums2: List[int]) -> int:
n1=len(nums1)
n2=len(nums2)
dp=[[0 for i in range(1005)]for j in range(1005)]
ret=0
for i in range(1,n1+1):
for j in range(1,n2+1):
if i==0 or j==0:
dp[i][j]=0
else:
if nums1[i-1]==nums2[j-1]:
dp[i][j]=dp[i-1][j-1]+1
ret=max(ret,dp[i][j])
else:
pass
return ret
# 最长公共子序列
class Solution:
def longestCommonSubsequence(self, text1: str, text2: str) -> int:
# 这不是dp题目吗
n1=len(text1)
n2=len(text2)
dp=[[0 for i in range(n2+1)]for j in range(n1+1)]
for i in range(0,n1):
for j in range(0,n2):
if text1[i]==text2[j]:
dp[i+1][j+1]=dp[i][j]+1
else:
dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j])
return (dp[-1][-1])
from queue import PriorityQueue
class DualPriorityQueue(PriorityQueue):
def __init__(self, maxPQ=False):
PriorityQueue.__init__(self)
self.reverse = -1 if maxPQ else 1
def put(self, priority, data):
PriorityQueue.put(self, (self.reverse * priority, data))
def get(self, *args, **kwargs):
priority, data = PriorityQueue.get(self, *args, **kwargs)
return self.reverse * priority, data
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param a int整型一维数组
# @param k int整型
# @param x int整型
# @return int整型
#
class Solution:
def minMax(self , a: List[int], k: int, x: int) -> int:
# write code here
pq=DualPriorityQueue(maxPQ=True)
for i in a:
pq.put(i,i)
for t in range(k):
if not pq.empty():
ele=pq.get()[1]
pq.put(ele-x,ele-x)
return pq.get()[1]
# pq.get()方法默认是取最小元素，
# 如果需要取最大元素，一种曲线救国方法是-1*元素插入队列
# 掌握PriorityQueue用法
# 贪心法，解决哈夫曼编码问题(合并果子问题)
from queue import PriorityQueue as PQ
pq = PQ()
cost=0
n=int(input())
a=list(map(int,input().split()))
for i in range(0,n):
pq.put(a[i])
while not pq.empty():
if pq.qsize()==1:
break
else :
a=pq.get()
b=pq.get()
cost=cost+a+b
pq.put(a+b)
print(cost)
from Queue import PriorityQueue
class DualPriorityQueue(PriorityQueue):
def __init__(self, maxPQ=False):
PriorityQueue.__init__(self)
self.reverse = -1 if maxPQ else 1
def put(self, priority, data):
PriorityQueue.put(self, (self.reverse * priority, data))
def get(self, *args, **kwargs):
priority, data = PriorityQueue.get(self, *args, **kwargs)
return self.reverse * priority, data
minQ = DualPriorityQueue()
maxQ = DualPriorityQueue(maxPQ=True)
minQ.put(10, 'A')
minQ.put(100, 'A')
maxQ.put(10, 'A')
maxQ.put(100,'A')
print "Min DQ: {}".format(minQ.get())
print "Max DQ: {}".format(maxQ.get())
# 统计1到2048出现多少次“1”
sum1=0;
for i in range(1,2048):
k=str(i)
sum1=sum1+k.count('1')
print(sum1)
# 统计n的二进制表示中有多少个1
n=int(input())
if n<0 :
n=n&0xffffffff
cnt = 0
while n:
cnt+=1
n=(n-1)&n
print(cnt)
# 句子反转 Hello World -> World Hello
s_input = input()
l_input = s_input.split(' ')
print(' '.join(l_input[::-1]))
# 高精度斐波那契数
def fib_yield_for(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
# 求整数的阶乘(高精度)
n=int(input())
ans=1;
for i in range(1,n+1,1):
ans*=i
print(ans)
# 求整数的阶乘
import math
print(math.factorial(30))
# 计算两个string类型的01串表示的二进制数相加的结果
return bin(int(a,2)+int(b,2))[2:]
# 拼接数字串得到最小的数
# 这份py代码思路是暴力，但是也能过。。。
# -*- coding:utf-8 -*-
import itertools
class Solution:
def PrintMinNumber(self, numbers):
# write code here
ret=[]
numbers=list(map(str,numbers))
mm=itertools.permutations(numbers)
for i in mm:
ret.append(''.join(i))
ret.sort()
return ret[0]
# 得到前k个单词的截断
class Solution(object):
def truncateSentence(self, s, k):
"""
:type s: str
:type k: int
:rtype: str
"""
a=list(s.split(" "))
b=a[0:k]
c=' '.join(b)
return c
# 读入一行不定个数整数
num=list(map(int,input().split()))
# Input a hexadecimal IPV6 address, store it into 4 integers and output them.
def trans(v):
if v&0x80000000 :
return v-4294967296
else :
return v
a=list(input().strip().split(':'))
for i in range(8):
a[i]=a[i].zfill(4)
print(trans( int((a[0]+a[1]),16) ),end=" ")
print(trans( int((a[2]+a[3]),16) ),end=" ")
print(trans( int((a[4]+a[5]),16) ),end=" ")
print(trans( int((a[6]+a[7]),16) ),end="\n")
# 给定n个字符串，请对n个字符串按照字典序排列
a=[]
n=int(input())
for i in range(0,n):
a.insert(-1,input())
a.sort()
for i in a:
print(i)
from decimal import Decimal
# 保留两位小数，并做四舍五入处理
def TwoDigits(a):
return Decimal(a).quantize(Decimal("0.00"))
# 判断一个全部由小写字母构成的字符串是否正好用了26个英文字母
# 练习python里的set用法
class Solution:
def checkIfPangram(self, sentence: str) -> bool:
s=set()
for i in sentence:
if not i in s:
s.add(i)
if len(s)==26:
return True
else :
return False
# 二分查找
import bisect
idx=bisect_left(a,x)
# 直接查找
idx=str_a.find(x)
看 https://www.php.cn/python-tutorials-424214.html
print("%.2f" % a) #四舍五入保留2位小数
# 四舍五入保留小数点后2位
print("{:.2f}".format(3.1495926))
# 四舍五入保留小数点后2位，带符号
print("{:+.2f}".format(3.1495926))
# python读文件，建议熟背
file_object = open('test.txt','r')
try:
# line可接收换行符
for line in file_object:
do_somthing_with(line)
finally: #做清尾工作
file_object.close()
# python和java都有垃圾回收机制，不需要程序员写资源释放代码
# 但是
# Python 垃圾回收机制，只能帮我们回收变量、类对象占用的内存，而无法自动完成类似关闭文件、数据库连接等这些的工作。
# finally代码块做清尾工作，一般来说总是执行
#当 try 块中代码发生异常，导致程序崩溃时，在崩溃前 Python 解释器也会执行 finally 块中的代码。
Pthon切片语法 https://zhuanlan.zhihu.com/p/79541418
简述python的垃圾回收机制
python的内存管理是通过引用计数+清理来完成的。因此python的垃圾回收机制，很大一部分主要是处理引用计数无法解决的循环引用。
1、标记清除算法：算法分为“标记”和“清除”两个阶段，首先标记所有需要回收的对象，在标记完成后统一回收所有被标记的对象。有两个不足：一是效率问题，标记和清除两个过程的效率都不高；另一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发一次垃圾收集动作
2、复制算法：将内存分为两块，每次只使用其中的一块。当这一块内存用完了，就将还存活的对象复制到另一块上，然后再把已使用过的内存空间一次清理掉。这样使得每次都是对一整块内存回收，内存分配时候也不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配即可，实现简单，运行高效。缺点是一次只能使用一部分内存，会有一些浪费。一般新生代会选择这种算法。
3、标记-整理算法：复制算法存在两个问题，1）会浪费50%的空间 2）如果被使用的内存中所有对象都100%存活的极端情况，就需要有额外的空间进行分配担保，因此老年代一般不能直接选用复制算法。有人提出了另外一种“标记-整理”（Mark-Compact）算法，标记过程仍然与“标记-清除”一样，后续步骤让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
4、分代回收算法：分代回收算法并没有什么新的思想，只是根据对象存活周期的不同将内存划分为几块。比如新生代和老年代，不同代使用不同的回收算法。比如新生代使用复制算法，而老年代使用标记-清除或标记-整理算法
python装饰器了解过吗？
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
概括的讲，装饰器的作用就是为已经存在的函数或对象添加额外的功能。
