- 我们将使用Python实现一个数值计算方面的令你眼花缭乱的炫技案例。
- 这活有意思，但是呢，嗯。。。其实我觉得也不一定有用
- 其次，真搞科学计算，还得看Fortran，Python就是个。。（跑得快哇！！！）
列表生成式和推导式
- Python 中使用一行代码实现一个蒙特卡洛积分计算圆周率
- 前三行代码没有简化的意义
import random
random.seed(0)
num_points = 1000000
print(4 * sum([1 for x,y in [(random.uniform(-1,1),random.uniform(-1,1)) for _ in range(num_points)] if x**2+y**2<=1])/num_points)
- 现在使用Python实现一个蒙特卡洛积分
- 没有分层抽样或者什么高难度操作
- 我知道有一些代码是可以省略的
- 但是这没有太大意义了
- 没有分层抽样或者什么高难度操作
import random,numba
random.seed(0)
f = lambda x:x**2+2*x+1
n = 1000000
a = -1
b = 1
print((b-a) * sum([f(xi) for xi in [random.uniform(a,b) for _ in range(n)]])/n)
- 现在使用Python实现一个高维度的蒙特卡洛积分
- 没有分层抽样或者什么高难度操作
- 我知道有一些代码是可以省略的
- 但是这没有太大意义了
- 没有分层抽样或者什么高难度操作
import random
random.seed(0)
dim = 10
N = 100000
f = lambda x:sum([xi**2 for xi in x])
print(2**dim *sum([f([random.uniform(0,1) for j in range(dim)]) for i in range(N)])/N)
- 上面我们只使用了几行简短的代码便实现了很多非常复杂（不是）的功能
- 但这完全不能显示我们的实力是不是
注意
- 我们简化代码的核心目的是方便操作，而不是单纯得炫技，只会炫技代码，那么肯定是要吃亏的，你去哪里调控你的项目呢。代码越短，读起来越复杂，越难以copy。同样的，IO如果被过度简化了，那就是操作人员的噩梦而不仅仅是pirate的噩梦了。
装饰器
- 装饰器本身就可以简化代码
import random,time
random.seed(0)
def measure_time(func):
def wrapper(*args, **kwargs):
begin_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print("函数 {0} 运行时间为：{1:.6f}秒".format(func.__name__, end_time - begin_time))
return result
return wrapper
@measure_time
def monte_carlo_area(func,min_x,max_x,min_y,max_y,num_samples):
return (max_x - min_x) * (max_y - min_y) * sum([func(random.uniform(min_x,max_x),random.uniform(min_y,max_y))*1 for i in range(num_samples)]) / num_samples
in_circle = lambda x,y:x**2 + y**2 <= 1
in_function = lambda x,y:x**2 + y**2 + x*y <= 1
# 模拟圆的面积
print(monte_carlo_area(in_circle,-1,1,-1,1,1000000))
# 模拟函数的面积
print(monte_carlo_area(in_function,-1,1,-1,1,1000000))
Python标准库
- Python 标准库就是一种最简单的炫技的方式
itertools
- itertools实现排列与组合，下面是案例（与列表生成器做了对比）
import itertools
# 排列
items = ["a","b","c"]
perms = itertools.permutations(items)
for perm in perms:
print(perm)
# 组合
combs = itertools.combinations(items, 2)
for comb in combs:
print(comb)
# 排列
lst = ["a","b","c"]
permutations = [(a, b, c) for a in lst for b in lst if b != a for c in lst if c != a and c != b]
print(permutations)
# 组合
combinations = [(a, b, c) for i, a in enumerate(lst) for j, b in enumerate(lst) for k, c in enumerate(lst) if i < j < k]
print(combinations)
functools
- 案例 ：事实上，我认为这个模块比较鸡肋
import time
from functools import wraps
def calculate_time(func):
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} execution time: {end_time - start_time:.5f}s")
return result
return wrapper
@calculate_time
def scientific_calculation(num1,num2):
return num1 + num2
result = scientific_calculation(10, 20)
print(result)
- 好了，上面那些代码显然还不够眼花缭乱，毕竟只要认真阅读，用手推一推就可以实现的
- 所以我觉得我们应该上一些代码混淆与加密技术
代码混淆与加密技术
- pyarmor
- 创建一个Python文件
- 在终端中，进入test.py所在的目录，然后使用以下命令对test.py进行加密：
pyarmor obfuscate test.py- 会生成一个文件夹，文件夹里的文件就是混淆后的Python文件，可以直接运行
- 设置文件的使用期限
- 利用 lic文件
from datetime import datetime, timedelta
import pyarmor
#使用期限为30天
expire_date = datetime.now() + timedelta(days=30)
lic = pyarmor.get_license()
lic.set_license_attr('expire_date', expire_date)
lic.save('license.lic')- 或者在控制台中完成
pyarmor licenses --expired 2023-05-26pyarmor obfuscate --licenses license.lic --output main.py- 谈到科学计算，怎么能够少得了numpy大显神威呢？下面就是一个绝佳的例子。
- 一个简单的统计案例
我的一篇文章文章来源地址https://www.toymoban.com/news/detail-463327.html
import sys
import numpy as np
import xlrd as xl
import csv
import copy
class SCORE():
def __init__(self,Lmin=85,Lmax=99,address="",Type=".csv"):
self.address = address
self.Type = Type
self.Lmin = Lmin
self.Lmax = Lmax
try:
self.Weight = self.readfile(self.address+"Weight"+self.Type)
self.data = self.readfile(self.address+"data"+self.Type)
except:
print("读取异常")
sys.exit()
#数据转换成float64
self.data = self.data.astype("float64")
self.Weight = self.Weight.astype("float64")
self.DATA = copy.deepcopy(self.data)
def readfile(self,Address):
print(Address)
with open(Address) as f:
f_csv = csv.reader(f)
headers = next(f_csv)
List = []
for row in f_csv:
List.append(row)
if len(List)>1:
return np.array(List)
else:
return np.array(List[0])
def data_check(self):
#检查矩阵是否完整
try:
GROPU_num,Test_num = self.data.shape
except:
print("矩阵维度超标!")
sys.exit()
#检查元素是否非负
if np.min(np.min(self.data))>=0:
return GROPU_num,Test_num
else:
print("含负元素")
sys.exit()
def supplement(self):
GROPU_num,Test_num = self.data_check()
for gn in range(GROPU_num):
self.data[gn][np.where(self.data[gn]==0)]=sum(self.data[gn][np.where(self.data[gn]!=0)])/len(self.data[gn][np.where(self.data[gn]!=0)])
print("缺省元素补充完毕")
def standardization(self):
GROPU_num,Test_num = self.data_check()
for tn in range(Test_num):
ave = sum(self.data[:,tn])/GROPU_num
delta = (sum((self.data[:,tn]-ave)**2)/(GROPU_num-1))**0.5
self.data[:,tn] = (self.data[:,tn]-ave)/delta
print("数据标准化完毕")
def calculate_M(self):
#检查权重矩阵
GROPU_num,Test_num = self.data_check()
assert(len(self.Weight)==Test_num),"权重矩阵长度不符合"
self.supplement()
self.standardization()
self.data *= self.Weight
return np.array([sum(i) for i in self.data])
def calculate_L(self):
GROPU_num,Test_num = self.data_check()
Mscore = self.calculate_M()
Mmax = max(Mscore)
Mmin = min(Mscore)
Mscore = (Mscore*(self.Lmax-self.Lmin)-Mmin*self.Lmax+Mmax*self.Lmin)/(Mmax-Mmin)
return Mscore
s1 = SCORE()
L = s1.calculate_L()
print("Final marks",L)
input("key to exit")文章来源：https://www.toymoban.com/news/detail-463327.html
到了这里，关于科学计算中那些眼花缭乱的Python的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
