python 刷题时遇到的基础知识

刷题时常用函数：
素数：除了1和它本身之外的数都不能整除的数。
sorted():排序不改变原字符串中字母，只是按照设定的key排序，输出新的列表，可以用list(input())作输入，输出用print(’’.join(res()))
round() ：四舍五入
count()
list(reversed()):reversed 返回是个迭代器，要用List输出
replace()
fillter()
str.upper()
set():去重，针对可迭代对象，会乱序,不是按照原来的字符串或列表中字母顺序输出
‘’.join()：链接字符串数组
enumerate():枚举，添加一列索引
findall(pattern,string)
eval()：执行字符串表达式，并返回里面的值，不识别{}，[]，可将其替换为（），对于{}，[]，eval将其作为 字典，列表
list(map(int,input().split()))
str.isupper（）是否为大写字母
str.islower()：是否为小写字母
一：
hex(x)❌10进制整数
返回16进制数，以字符串形式表示
hex(-42)
‘-0x2a’
oct(x)❌10进制整数
返回8进制数，以字符串形式表示
bin(x):x – int 或者 long int 数字
返回二进制字符串

int(‘10’) # 字符串转换成10进制整数
int(‘10’,16) # 字符串转换成16进制整数
int(‘0x10’,16) # 字符串转换成16进制整数
int(‘10’,8) # 字符串转换成8进制整数
int(‘010’,8) # 字符串转换成8进制整数
int(‘10’,2) # 字符串转换成2进制整数

二：
质因数：
除了1以外，两个没有其他共同质因子的正整数称为互质。因为1没有质因子，1与任何正整数（包括1本身）都是互质。正整数的因数分解可将正整数表示为一连串的质因子相乘，质因子如重复可以用指数表示。

n=int(input())
res=[]
while n>1:
    for i in range(2,n+1):
        if n%i==0:
            n=n//i
            res.append(i)
            break
            #当获得质因数时跳出for循环，从新的n开始判断
for i in res:
    print(i,end=' ')

三：
向上取整 ceil(x)
向下取整 floor(x)

五舍六入取整
https://www.runoob.com/w3cnote/python-round-func-note.html
round(x):返回浮点数x的四舍五入值。其实不是四舍五入，python2和python3有区别
python3:如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2。
字符串格式化可以做截断使用，例如 “%.2f” % value（保留两位小数并变成字符串……如果还想用浮点数请披上float()的外衣）



四舍五入

n=[x for x in input().split('.')]
if int(n[-1])<=4:
    print(int(n[0]))
else:
    print(int(n[0])+1)

四：
字典：
字典相当于索引是任意不可变类型的列表：而列表则相当于 key 只能是整数的字典。因此，如果程序中要使用的字典的 key 都是整数类型，则可考虑能否换成列表。
列表的索引总是从 0 开始、连续增大的；但字典的索引即使是整数类型，也不需要从 0 开始，而且不需要连续。因列表不允许对不存在的索引赋值：但字典则允许直接对不存在的 key 赋值，这样就会为字典增加一个 key-value 对。
字典中的 key 不允许重复。

既可使用花括号语法来创建字典，也可使用 dict() 函数来创建字典。实际上，dict 是一种类型，它就是 Python 中的字典类型。

在使用花括号语法创建字典时，花括号中应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。

在使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。

如果要判断字典是否包含指定的 key，则可以使用 in 或 not in 运算符。需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，可通过 list() 函数把它们转换成列表。



dict.setdefault(key, default=None)
key – 查找的键值。
default – 键不存在时，设置的默认键值。
返回值：如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。
即当要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。新增一个key-value对

**dict.contains(key)😗*判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。

dict.fromkeys(seq[, value])
seq – 字典键值列表。
value – 可选参数, 设置键序列（seq）的值
返回一个新字典
使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），通常会使用 dict 类直接调用。

join:
join：将序列中的元素以指定的字符连接生成一个新的字符串。
join不能直接连接数字，否则会报错

应该将元素遍历成字符串形式输出

匈牙利算法：

编辑距离：
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。

动态规划解法：
当其中一个字符串为空串时，那么编辑距离为另一个非空字符串的长度；
当两个字符串均为非空时(长度分别为 i 和 j )，取以下三种情况最小值即可：
1、长度分别为 i-1 和 j 的字符串的编辑距离已知，那么加1即可；
2、长度分别为 i 和 j-1 的字符串的编辑距离已知，那么加1即可；
3、长度分别为 i-1 和 j-1 的字符串的编辑距离已知，此时考虑两种情况，若第i个字符和第j个字符不同，那么加1即可；如果相同，那么不需要加1。

dp[i][j]表示：字符串A前i个字符与字符串B前j个字符的最短编辑距离。求最小编辑距离就是把这个列表填写完，dp[-1][-1]的值即为所求的最小编辑距离。
特殊情况：
if(A == null)
dp[0][j] = j
if(B == null)
dp[i][0] = i

while True:
    try:
        a,b=input(),input()
        dp=[[0 for j in range(len(b)+1)] for i in range(len(a)+1)]
        for i in range(len(a)+1):
            dp[i][0] = i
        for j in range(len(b)+1):
            dp[0][j] = j
        for i in range(1,len(a)+1):
            for j in range(1,len(b)+1):
                if a[i-1]==b[j-1]:
                    temp=0
                else:
                    temp=1
                dp[i][j]=min((dp[i-1][j-1]+temp,dp[i-1][j]+1,dp[i][j-1]+1))
        if dp[-1][-1]<0:
            print(-1)
        else:
            print(dp[len(a)][len(b)])
    except:
        break

引入python-Levenshtein包计算：

大数相加：
因为python中整数大小取决于内存，所以直接输入相加就行，但是出题肯定不是为了考察这个，所以写了一个考虑进位的
仅限正数版（负数更费事了，先不考虑）

class solution:
    def lens(self,arr1,arr2):
        if len(arr1)<=len(arr2):
            for i in range(abs(len(arr1)-len(arr2))):
                arr1.append(0)
            return[arr2,arr1]
        else:
            for i in range(abs(len(arr1)-len(arr2))):
                arr2.append(0)
            return[arr1,arr2]
    def sums(self,arr1,arr2):
        arr1=list(reversed(arr1))
        arr2=list(reversed(arr2))
        arr1,arr2=self.lens(arr1,arr2)
        add_nums=[]
        sum_list=[0]*(len(arr1)+1)
        for i,v in enumerate(arr1):
            # sum_list[i] 为进位，所以每次加上进位
            v_add=int(v)+int(arr2[i])+sum_list[i]
            if v_add>=10:
                add_nums.append(v_add%10)
                sum_list[i+1]=1
            else:
                add_nums.append(v_add)
        if sum_list[-1]==1:
            add_nums.append(1)
        return list(reversed(add_nums))
while True:
    try:
        s=solution()
        a1=[int(x) for x in input()]
        a2=[int(x) for x in input()]
        res=s.sums(a1,a2)
        print(''.join(str(i) for i in res))
    except:
        break

如何set()后按照原字符串顺序输出：
set()是无序的！！！

arr=input()
b=list(set(arr))
b=sorted(b,key=arr.index)

十进制负数转为二进制：
0xff:是十六进制表示
-3的二进制11111100
3的二进制11

b = bin(-3 & 0xff)

十进制转二进制表示，防止N为负数

bin(n&0xffffffff)

凯撒密码加密；
将字符串中的字符平移n位，就是凯撒密码.比如此处的后移两位，a变为c，z变为b，以此类推，只换字母其它字符不变.
ord()将字符转为ascii码，chr()将ascii码转为字符
小写字母是ord(‘a’),大写字母是ord(‘A’)

arr=list(input())
for i in range(len(arr)):
    if arr[i].islower():
        arr[i]=chr((ord(arr[i])+1-ord('a')%26+ord('a')
arr