科学计算中那些眼花缭乱的Python

• 我们将使用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-26

pyarmor obfuscate --licenses license.lic --output main.py

 

---

---

• 谈到科学计算，怎么能够少得了numpy大显神威呢？下面就是一个绝佳的例子。
  • 一个简单的统计案例

我的一篇文章

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")