基础题
拆分input输入的值用split
map()函数是内置函数之一，它用于对可迭代对象（如列表、元组等）中的每个元素应用指定的函数，
#输入A、B，输出A+B。
x,y=map(int,input().split()) #map将输入的数值均转为Int型，input输入默认为字符
print(x+y)进制转换
其他进制转二进制----bin(var)
其他进制转八进制----oct(var)
其他进制转十进制----int(var，base)，其实不管赋值时用什么进制默认输出都是十进制，所以可以不需要转换。base是var的进制数（2，8，10，16），默认为10
其他进制转十六进制----hex(var)
#十六进制数是在程序设计时经常要使用到的一种整数的表示方式。
#它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。
#十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
#给出一个非负整数，将它表示成十六进制的形式。
x=int(input())
if 0<=x<=2147483647:
print(hex(x)[2:].upper())
输入：30
输出：1E字符串大小写转换
x.upper() 转为大写
x.lower() 转为小写
自定义输入矩阵
C=[]
D=[[0]*m for i in range(n)]
for i in range(n):
C.append(list(map(int,input().split())))
#n是行，m是列数
输出：D=[[0,0,0],[0,0,0]]
#用列表表示矩阵的方法enumerate函数
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
example = 'abcd'
for i,j in enumerate(example):
print(i,j)
打印结果为：
0 a
1 b
2 c
3 d枚举
例如：153是一个水仙花数，因为153=1^3+5^3+3^3。
count = 0
for i in range(100,1000):
count += 1
a = int(i / 100)
b = int(i / 10 % 10)
c = int((i % 10))
if pow(a,3)+pow(b,3)+pow(c,3)==i:
print('水仙花数:',i)
print('枚举次数:',count)运算
11/5=2.2
11//5=2（向下取整）
11%5=1（取余）
幂运算pow(x,y)=x^y
分数用fractions模块
from fractions import Fraction
f=Fraction(1,2)
print(f)求阶乘可用math.factorial（）运算
import math
a=math.factorial(5)
print(a)
输出：120取整
向上取整 math.ceil（x）
向下取整 math.floor(x)
四舍五入 round(x)
int()函数是“向0取整”，取整方向总是让结果比小数的绝对值更小
combination(a,x)函数
全排列函数
from itertools import combinations
a = 'abc' #对字符串进行combinations排列组合
for i in combinations(a,2):
x = ''.join(i)
print (x,end=' ')
输出：ab ac bc字符串空格与替换
rstrip()方法，去掉字符串结尾空格
lstrip()方法，去掉字符串开头空格
strip()方法，去掉字符串左右空格
replace()方法，用其他字符替换空格
join()方法，将字符串连接起来
>>> name = "Sheep Core "
>>> name.rstrip()
'Sheep Core'
>>> name = " Sheep Core"
>>> name.lstrip()
'Sheep Core'
>>> name = " Sheep Core "
>>> name.strip()
'Sheep Core'
>>> stars = " I love you "
>>> stars.replace(" ", "*")
'**I*love*you**'
# 可修改替换个数，比如只替换开头两个空格
>>> stars.replace(" ", "*", 2)
'**I love you '
>>> a = "I love python"
>>> b = a.split()
>>> b
['I', 'love', 'python']
>>> " ".join(b)
'I love python'time函数
time.gmtime() #转换为time.struct_time类型的时间对象的秒数
time.asctime() #返回一个可读形式的字符串 Tue Feb 17 09:42:58 2009
import time
n=int(input())
print(time.asctime(time.gmtime(n//1000))[11:19])
#测试案例 n=46800999
#n//1000 ms->s 毫秒格式转化为秒位运算
&与 |或 ~非 ^异或
A^0=A，B^B=0
落单数
找出一组数中出现次数为单数的数字，其他均为成双出现
a=[i for i in range(1,22)]
for i in range(1,20,2):
a[i]=a[i-1]
print(a)
b=0
for i in a:
b=b^i
print(b)
#a=[1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15, 17, 17, 19, 19, 21]
b=21找双数
找出一组数中出现次数为双数的数字，其余为单数
a=[i for i in range(1,22)]
a[20]=9
print(a)
b=0
for i in range(1,21):
b=b^i
print(b)
for e in a:
b=b^e
print(b)
#bug需要把重复的数放在最后一位
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 9]
9判断二进制中1的个数
让n与1做与运算，如果最后一位为0则为0，否则为1
再让n向右取反，比如001001向右取反是向左加0，000100
n=int(input())
b=0
while n:
b+=n&1
n>>=1
print(b)
是否为2的整数次方
2的整数次方时二进制只有一个1，则减去1后与原来数与为0
n=int(input())
m=n-1
if n&m==0:
print('yes')
else:
print('no')
整数的奇偶位互换
二进制从右往左数，最右边是第一位
0x55555555是16进制的奇数位，01010101010101010101010101010101（32位）
0xAAAAAAAA是16进制的偶数位，10101010101010101010101010101010
把原数n与010101与运算，保留奇数位，再左移一位（右边+0）
原数与101010...运算，保留偶数位，再右移一位（左边+0）
将上诉两个数异或运算
n=int(input())
print(bin(n))
a=n&0x55555555
b=n&0xAAAAAAAA
c=(a<<1)^(b>>1)
print(bin(c))
print(c)浮点数二进制
浮点数*2，如果大于等于1，则为1，留下小数位；小于1则为0，继续运算直到为1
例：0.625
0.625*2=1.25>1, 则0.1
0.25*2=0.5<1, 则0.10
0.5*2=1=1, 则0.101结束
n=float(input())
ans="0."
while n!=0:
n*=2
print(n)
if n>=1:
ans+="1"
n=n-1
else:
ans+="0"
print(ans)
lowbit运算
对于一个非负整数，取最低位为1及其后的零构成的数的值。
例如
lowbit(100100) = 4
lowbit(n) = n & (~n+1) = n&(-n)
求一个数的个位数
def get_last_digit(n):
return n % 10
# 测试函数
num = 12345
print(get_last_digit(num)) # 输出: 5
求一个数的十位数
def get_tenth_digit(n):
# 去掉个位数
n_without_last_digit = n // 10
# 获取十位数
tenth_digit = n_without_last_digit % 10
return tenth_digit
# 测试函数
num = 12345
print(get_tenth_digit(num)) # 输出: 3堆
python有一个自动排序的函数
import heapq
>>> dqueue=[]
>>> heapq.heappush(dqueue,(1,'F'))
>>> heapq.heappush(dqueue,(5,'R'))
>>> heapq.heappush(dqueue,(8,'U'))
>>> heapq.heappush(dqueue,(4,'P'))
>>> heapq.heappop(dqueue)
(1, 'F')
>>> heapq.heappop(dqueue)
(4, 'P')
>>> heapq.heappop(dqueue)
(5, 'R')
>>> heapq.heappush(dqueue,(1,'F'))
>>> heapq.heappush(dqueue,(5,'R'))
>>> heapq.heappush(dqueue,(4,'P'))
>>> dqueue
[(1, 'F'), (4, 'P'), (5, 'R'), (8, 'U')]
#有时输出来的并不是排序好的结果
[(1, 'F'), (4, 'P'), (8, 'U')，(5, 'R')]元组
graph={"A":{"B":4,"C":5},
"B":{"A":4,"C":5,"D":3},
"C":["A","B","E"],
"D":["B","C","E"],
"E":["C","D","F"],
"F":["D","E"]}
>>> graph["A"]
{'B': 4, 'C': 5}
>>> graph["A"]["B"] #查找元组的值
4
>>> graph["A"].keys() #查找元组的键
dict_keys(['B', 'C'])
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
