import gmpy2
gmpy2.mpz(n)#初始化一个大整数
gmpy2.mpfr(x)# 初始化一个高精度浮点数x
d = gmpy2.invert(e,n) # 求逆元，de = 1 mod n
C = gmpy2.powmod(M,e,n)# 幂取模，结果是 C = (M^e) mod n
gmpy2.is_prime(n) #素性检测
gmpy2.gcd(a,b)  #欧几里得算法，最大公约数
gmpy2.gcdext(a,b)  #扩展欧几里得算法
gmpy2.iroot(x,n) #x开n次根

#数字型（不论是十六进制还是十进制）与字符串之间的转换：
import libnum
s="flag{pcat}"
print libnum.s2n(s)

import libnum
n=0x666c61677b706361747d
print libnum.n2s(n)
#这个转换不用在意十六进制的位数是否为偶数

#二进制与字符串之间的转换：
import libnum
b=‘01110000011000110110000101110100‘
print libnum.b2s(b)
#二进制的位数最好是8的倍数

import libnum
s=‘pcat‘
print libnum.s2b(s)

#libnum.primes(n)：返回不大于n的素数列表
#libnum.factorize(n)：返回n的所有素因子及每个素因子的个数。
#libnum.modular.invmod(e,m)：返回e模m的逆元。

#1 生成pubkey和privkey
import rsa
(pubkey, privkey) = rsa.newkeys(512)  # 512这个数字表示可以加密的字符串长度，可以是1024，4096等等，
(pubkey, privkey) = rsa.newkeys(512, poolsize=8)  # 使用多进程加速生成

#2 从文件中读取公钥或者私钥
with open('private.pem', mode='rb') as privatefile:
	keydata = privatefile.read()
privkey = rsa.PrivateKey.load_pkcs1(keydata)

#3 加密数据
message = 'hello Bob!'.encode('utf8')

# 加密数据
crypto = rsa.encrypt(message, pubkey)

# 解密数据
message = rsa.decrypt(crypto, privkey)

加密大数据文件
import rsa
from rsa.bigfile import *
(pub_key, priv_key) = rsa.newkeys(512)

# 加密数据
with open('inputfile', 'rb') as infile, open('outputfile', 'wb') as outfile:
	encrypt_bigfile(infile, outfile, pub_key)

# 解密数组
with open('inputfile', 'rb') as infile, open('outputfile', 'wb') as outfile:
	decrypt_bigfile(infile, outfile, priv_key)

4 数字签名
签名使用privkey，验证使用pubkey。刚好和加密相反。
对字符串的签名和验证
(pubkey, privkey) = rsa.newkeys(512)
message = 'Go left at the blue tree'
# 签名
signature = rsa.sign(message, privkey, 'SHA-1')
# 验证
rsa.verify(message, signature, pubkey)

# 对文件的签名和验证
# 签名
with open('somefile', 'rb') as msgfile:
	signature = rsa.sign(msgfile, privkey, 'SHA-1')

# 验证
with open('somefile', 'rb') as msgfile:
	rsa.verify(msgfile, signature, pubkey

>>> from PIL import Image
>>> # 生成对应图片的img对象
>>> img = Image.open('C:/Users/Administrator/Desktop/g2.jpg')
>>> # 宽度和高度的像素值
>>> img.size
(320, 180)
>>> # 图像格式
>>> img.format
'JPEG'
>>> # 图片模式，有L，RGB和CMYK等
>>> img.mode
'RGB'
>>> # 获取(1, 2)坐标处的RGB通道值
>>> img.getpixel((1, 2))
(79, 123, 188)
>>> # 将图像转化为灰度图像
>>> img = img.convert('L')
>>> # 将图片的宽度和高度都变为(180, 180)
>>> img = img.resize((180, 180))
>>> # 展示图像
>>> img.show()
>>> # 保存图像
>>> img.save('C:/Users/Administrator/Desktop/g.jpg')


from PIL import Image, ImageFilter
 
img = Image.open('1.jpg')
# 模糊操作
img_blur = img.filter(ImageFilter.BLUR)
img_blur.show()
 
# 将三个通道分离的图像
r, g, b = img.split()
r.show()
g.show()
b.show()
 
# 滤镜操作
img_detail = img.filter(ImageFilter.DETAIL)
img_detail.show()
 
# 逆时针
img_rotate = img.rotate(90)
img_rotate.show()

#sum(a,axis=None):计算和
#mean(a,axis=None):计算平均值#average(a,axis=None,weights=None):加权平均数
#std(a,axis=None):标准差
#var(a,axis=None):方差

import numpy as np
#创建二维数组
A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
#加减
A + B
A - B
#乘法（区别数组与矩阵）
A * B #输出为 array（[[5,12],[21,32]]）
np.dot(A,B) #输出为array([[19,22],[43,50]]) 此处才是矩阵的点乘
也可以直接当做矩阵去乘
np.mat(A) * np.mat(B) #结果同np.dot(A,B)
#矩阵的转置
A.T
#矩阵的求逆
np.linalg.inv(A)
#水平拼合
np.hstack((A, B))
#垂直拼合
np.vstack((A, B))
#沿横轴分割数组（分成输出两列）
np.hsplit(A, 2)
#沿纵轴分割数组（分成两行）
np.vsplit(A, 2)
#返回每列的最大值和最小值
np.max(A, axis=0)
np.min(A, axis=1)
#返回每列的最大值和最小值索引
np.argmax(A, axis=0)
np.argmin(A, axis=1)
#统计格列的中位数
np.median(A, axis=0)
#统计各行的算术平均值
np.mean(A, axis=1)
#统计各列的加权平均值
np.average(A, axis=0)
#统计各行的方差
np.var(A, axis=1)
#统计各行的标准偏差
np.std(A, axis =0)

from __future__ import division 
#如果你用的python2，请加上上面这句话导入python3的除法
#将Python2的除法操作符“/”从整数除法改为普通除法
from sympy import *
x = Symbol('x')
y = Symbol('y')
z = Symbol('z')
a = Symbol('a')
b = Symbol('b')
c = Symbol('c')
# 等同于 x, y, z, a, b, c = symbols('x, y, z, a, b, c')
# 建议用下面这种表达，因为一个一个导入符号实在是太麻烦了。
f = (2/3)*x**2 + (1/3)*x**2 + x + x + 1


#simplify表达式化简
f.simplify()
print(f)
结果：
x**2 + 2*x + 1


#expand表达式展开
>>> f = (x+1)**2
>>> print(expand(f))
x**2 + 2*x + 1


#solve方程自动求解
f1 = 2*x - y + z - 10
f2 = 3*x + 2*y - z - 16
f3 = x + 6*y - z - 28
print(solve([f1, f2, f3]))
结果：
{x: 46/11, z: 74/11, y: 56/11}


#limit求极限
#首先，limit可以作为普通的代入化简求值方法。比如 fx=(x+1)^2+1 用 x=a-1 代入，得到 a^2+1
f = (x+1)**2 + 1
print(limit(f, x, a-1))
结果：a**2 + 1

>>> f = sin(x)/x
>>> print(limit(f, x, 0)) # 输入三个值，函数，自变量，自变量取值
1
从负方向逼近，dir可以取'+' 或者 '-'
>>> print(limit(f, x, 0, dir='-'))
1
f = cos(x)
dx = Symbol('dx')
>>> print(limit(f, x, a)) # 这个的意思是函数f，自变量x用a代入
cos(a)
>>> print(limit(f, x, a-dx))# f的自变量x用a-dx代入
cos(a - dx)
>>> print(limit((limit(f,x,a)-limit(f,x,a-dx))/dx, dx, 0))
-sin(a) #这就是答案

>>> n = Symbol('n')
>>> print(limit(((n+3)/(n+2))**n, n, oo))
E
无穷用oo表示，负无穷用-oo



#diff求导
diff(你的函数，自变量，求导的次数）
 >>> diff(sin(2*x), x) 
2*cos(2*x)
>>> sin(2*x).diff(x) 
2*cos(2*x)
>>> diff(sin(2*x), x, 2) 
-4*sin(2*x)
>>> diff(sin(2*x), x, 3)
-8*cos(2*x)
>>> diff(sin(x*y), x,2,y,3) 
x*(x**2*y**2*cos(x*y) + 6*x*y*sin(x*y) - 6*cos(x*y))
     

dsolve()计算微分方程
>>> x = symbols("x", real=True) # 定义符号x 为实数 
>>>eq1 = dsolve(f(x).diff(x) + f(x)**2 + f(x), f(x)) 
>>>eq1
f(x) == -C1/(C1 - exp(x))
  

#intergrate积分计算
1. 定积分
>>> f = x**2 + 1
>>> integrate(f, (x, -1, 1))
8/3
     
e^x =1|-oo 0
>>> integrate(exp(x), (x, -oo, 0))
1
 
#2. 不定积分
>>> f = 3*x**2 + 1
>>> integrate(f, x)
x**3 + x
     
#3. 双重定积分
>>> f = (4/3)*x + 2*y
>>> integrate(f, (x, 0, 1), (y, -3, 4))
21/2

     
     
#4. 双重不定积分     
>>> f = (4/3)*x + 2*y
>>> integrate(f, (x, 0, 1), (y, -x, x))
x