Python离散事件模拟代码

⑴ 求用python代码实现下列问题：

$python3.6he.pyA1=1A4=7B3=1
已知参数为:
A1=1,A4=7,B3=1
所有可能的{A1，A2，A3，A4}组合:
(1,2,6,7)
(1,3,6,7)
(1,4,6,7)
(1,5,6,7)
$python3.6he.pyA1=1A4=7B3=1C1=3
已知参数为:
A1=1,A4=7,B3=1,C1=3
所有可能的{A1，A2，A3，A4}组合:
(1,2,6,7)
(1,5,6,7)
$python3.6he.py
已知参数为:
A1=1,A4=7,B3=1,D1=2
所有可能的{A1，A2，A3，A4}组合:
无
$cathe.py
...

#!/usr/bin/envpython3.6
importsys


names=('A1','A2','A3','A4','B1','B2','B3','C1','C2','D1')


defgetzuhe(**kwargs):
results=[]
fora1,a2,a3,a4incombinations(range(1,10),4):
ifnota1<a2<a3<a4:
continue
b1=a2-a1
b2=a3-a2
b3=a4-a3
c1=abs(b2-b1)
c2=abs(b3-b2)
d1=abs(c2-c1)
values=(a1,a2,a3,a4,b1,b2,b3,c1,c2,d1)
kws=dict(zip(names,values))
ifall(kws.get(k.upper())==int(v)fork,vinkwargs.items()):
results.append((a1,a2,a3,a4))
returnresultsifresultselse['无']


if__name__=='__main__':
iflen(sys.argv)>1:
kwargs=eval(f'dict({",".join(sys.argv[1:])})')
else:
kwargs=dict(A1=1,A4=7,B3=1,D1=2)
ifany(k.upper()notinnamesforkinkwargs):
print(f'参数有误.参数范围如下:
{names}')
print('已知参数为:')
print(','.join([f'{k}={v}'fork,vinkwargs.items()]))
print('所有可能的{A1，A2，A3，A4}组合:')
foriingetzuhe(**kwargs):
print(i)

⑵ 《外星人入侵》的python完整代码

项目名如标题，在《python编程：从入门到实践》里有完整详细的说明，网上也能查到源码，这里只是在重复这种程序

不过学编程，借鉴模仿很重要，即使抄轮子也得抄个像模像样才行，抄到即是学到。

进入正题：

游戏很简单，就是一个打飞机类型的游戏，以下代码将实现游戏的主程序，飞船的基本操作等。

注：这里提醒新上手的萌新，python的代码不要随便复制粘贴！

不要随便复制粘贴！

不要随便复制粘贴！

python的缩进很严格，复制粘贴后一定要注意格式是否正确，否则会报出异常：

IndentationError: unexpected indent

未知的缩进错误

当出现此提示时，要检查一下哪里的缩进出现了问题，小段的代码还好，大段的代码就呵呵了

注意下载好的文件后缀名为.whl

然后新建一个文件夹，名字叫alien_invasion，将下载好的模块放在此文件夹下，

然后你要新建以下文件：

1.alien_invasion.py 游戏主程序

2.game_functions.py 存放游戏函数

3.bullet.py 子弹模块

4.settings.py 游戏设置模块

5.ship.py 飞船模块

然后新建images文件夹存放飞船素材。

这些会让我们实现启动游戏，飞船的显示与移动，以及开火功能。

为避免文章冗~长，这里贴一段主程序代码，其它代码下周见（偷懒）。

alien_invasion.py

#!usr/bin/env python3
#_*_ coding:utf-8 _*_
#此模块是游戏的主程序
import sys
import game_functions as gf #导入game_functions文件，并指定了别名gf
import pygame
from settings import Settings
from ship import Ship
from pygame.sprite import Group
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init() #pygame的init函数，用于创建一个游戏对象
#把Setting类实例化
ai_settings = Settings()
#显示游戏窗口并设置其大小
screen = pygame.display.set_mode(
(ai_settings.screen_width,ai_settings.screen_height))
#设置窗口标题
pygame.display.set_caption("Alien Invasion")
# 把Ship类实例化，用于创建飞船
ship = Ship(ai_settings,screen)
#存储子弹的编组
bullets = Group()
#开始游戏的主循环
while True:
#用于响应鼠标，键盘事件
gf.check_events(ai_settings,screen,ship,bullets)
#更新飞船在屏幕的位置
ship.update()
#更新子弹位置并删除消失的子弹
gf.update_bullets(bullets)
#用于更新屏幕背景色，更新飞船,子弹等
gf.update_screen(ai_settings,screen,ship,bullets)
run_game() #运行游戏

⑶ 求python 熵值法实现代码

一、基本原理

在信息论中，熵是对不确定性的一种度量。信息量越大，不确定性就越小，熵也就越小；信息量越小，不确定性越大，熵也越大。
根据熵的特性，可以通过计算熵值来判断一个事件的随机性及无序程度，也可以用熵值来判断某个指标的离散程度，指标的离散程度越大，该指标对综合评价的影响（权重）越大，其熵值越小。

二、熵值法步骤

1. 选取n个国家，m个指标，则为第i个国家的第j个指标的数值（i=1, 2…, n; j=1,2,…, m）；

2. 指标的归一化处理：异质指标同质化

由于各项指标的计量单位并不统一，因此在用它们计算综合指标前，先要对它们进行标准化处理，即把指标的绝对值转化为相对值，并令，从而解决各项不同质指标值的同质化问题。而且，由于正向指标和负向指标数值代表的含义不同（正向指标数值越高越好，负向指标数值越低越好），因此，对于高低指标我们用不同的算法进行数据标准化处理。其具体方法如下:
正向指标:

负向指标:

则为第i个国家的第j个指标的数值（i=1, 2…, n; j=1, 2,…, m）。为了方便起见，归一化后的数据仍记为;

3. 计算第j项指标下第i个国家占该指标的比重：

4. 计算第j项指标的熵值：

其中. 满足;

5. 计算信息熵冗余度：

6. 计算各项指标的权值：

7. 计算各国家的综合得分：

[code]function [s,w]=shang(x)
% 函数shang.m, 实现用熵值法求各指标(列）的权重及各数据行的得分
% x为原始数据矩阵, 一行代表一个国家, 每列对应一个指标
% s返回各行得分, w返回各列权重
[n,m]=size(x); % n=23个国家, m=5个指标
%% 数据的归一化处理
% Matlab2010b,2011a,b版本都有bug,需如下处理. 其它版本直接用[X,ps]=mapminmax(x',0,1);即可
[X,ps]=mapminmax(x');
ps.ymin=0.002; % 归一化后的最小值
ps.ymax=0.996; % 归一化后的最大值
ps.yrange=ps.ymax-ps.ymin; % 归一化后的极差,若不调整该值, 则逆运算会出错
X=mapminmax(x',ps);
% mapminmax('reverse',xx,ps); % 反归一化, 回到原数据
X=X'; % X为归一化后的数据, 23行(国家), 5列(指标)
%% 计算第j个指标下，第i个记录占该指标的比重p(i,j)
for i=1:n
for j=1:m
p(i,j)=X(i,j)/sum(X(:,j));
end
end
%% 计算第j个指标的熵值e(j)
k=1/log(n);
for j=1:m
e(j)=-k*sum(p(:,j).*log(p(:,j)));
end
d=ones(1,m)-e; % 计算信息熵冗余度
w=d./sum(d); % 求权值w
s=w*p'; % 求综合得分[\code]

测试程序：

data.txt 数据如下：
114.6 1.1 0.71 85.0 346
55.3 0.96 0.4 69.0 300
132.4 0.97 0.54 73.0 410
152.1 1.04 0.49 77.0 433
103.5 0.96 0.66 67.0 385
81.0 1.08 0.54 96.0 336
179.3 0.88 0.59 89.0 446
29.8 0.83 0.49 120.0 289
92.7 1.15 0.44 154.0 300
248.6 0.79 0.5 147.0 483
115.0 0.74 0.65 252.0 453
64.9 0.59 0.5 167.0 402
163.6 0.85 0.58 220.0 495
95.7 1.02 0.48 160.0 384
139.5 0.70 0.59 217.0 478
89.9 0.96 0.39 105.0 314
76.7 0.95 0.51 162.0 341
121.8 0.83 0.60 140.0 401
42.1 1.08 0.47 110.0 326
78.5 0.89 0.44 94.0 280
77.8 1.19 0.57 91.0 364
90.0 0.95 0.43 89.0 301
100.6 0.82 0.59 83.0 456

执行代码：
[code]x=load('data.txt'); % 读入数据
[s,w]=shang(x)[\code]

运行结果：
s =

Columns 1 through 9

0.0431 0.0103 0.0371 0.0404 0.0369 0.0322 0.0507 0.0229 0.0397

Columns 10 through 18

0.0693 0.0878 0.0466 0.0860 0.0503 0.0800 0.0234 0.0456 0.0536

Columns 19 through 23

0.0272 0.0181 0.0364 0.0202 0.0420

w =

0.1660 0.0981 0.1757 0.3348 0.2254

⑷ python scikit-learn 有什么算法

1，前言

很久不发文章，主要是Copy别人的总感觉有些不爽，所以整理些干货，希望相互学习吧。不啰嗦，进入主题吧，本文主要时说的为朴素贝叶斯分类算法。与逻辑回归，决策树一样，是较为广泛使用的有监督分类算法，简单且易于理解（号称十大数据挖掘算法中最简单的算法）。但其在处理文本分类，邮件分类，拼写纠错，中文分词，统计机器翻译等自然语言处理范畴较为广泛使用，或许主要得益于基于概率理论，本文主要为小编从理论理解到实践的过程记录。

2，公式推断

一些贝叶斯定理预习知识：我们知道当事件A和事件B独立时，P（AB）=P（A）（B），但如果事件不独立，则P（AB）=P（A）P（B|A）。为两件事件同时发生时的一般公式，即无论事件A和B是否独立。当然也可以写成P（AB）=P（B）P（A|B），表示若要两件事同事发生，则需要事件B发生后，事件A也要发生。

由上可知，P（A）P（B|A）= P（B）P（A|B）

推出P（B|A）=

其中P（B）为先验概率，P（B|A）为B的后验概率，P（A|B）为A的后验概率（在这里也为似然值），P（A）为A的先验概率（在这也为归一化常量）。

由上推导可知，其实朴素贝叶斯法就是在贝叶斯定理基础上，加上特征条件独立假设，对特定输入的X（样本，包含N个特征），求出后验概率最大值时的类标签Y（如是否为垃圾邮件），理解起来比逻辑回归要简单多，有木有，这也是本算法优点之一，当然运行起来由于得益于特征独立假设，运行速度也更快。

8. Python代码

# -*-coding: utf-8 -*-

importtime

fromsklearn import metrics

fromsklearn.naive_bayes import GaussianNB

fromsklearn.naive_bayes import MultinomialNB

fromsklearn.naive_bayes import BernoulliNB

fromsklearn.neighbors import KNeighborsClassifier

fromsklearn.linear_model import LogisticRegression

fromsklearn.ensemble import RandomForestClassifier

fromsklearn import tree

fromsklearn.ensemble import GradientBoostingClassifier

fromsklearn.svm import SVC

importnumpy as np

importurllib

# urlwith dataset

url ="-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"

#download the file

raw_data= urllib.request.urlopen(url)

#load the CSV file as a numpy matrix

dataset= np.loadtxt(raw_data, delimiter=",")

#separate the data from the target attributes

X =dataset[:,0:7]

#X=preprocessing.MinMaxScaler().fit_transform(x)

#print(X)

y =dataset[:,8]

print(" 调用scikit的朴素贝叶斯算法包GaussianNB ")

model= GaussianNB()

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的朴素贝叶斯算法包MultinomialNB ")

model= MultinomialNB(alpha=1)

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的朴素贝叶斯算法包BernoulliNB ")

model= BernoulliNB(alpha=1,binarize=0.0)

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的KNeighborsClassifier ")

model= KNeighborsClassifier()

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的LogisticRegression(penalty='l2')")

model= LogisticRegression(penalty='l2')

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的RandomForestClassifier(n_estimators=8) ")

model= RandomForestClassifier(n_estimators=8)

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的tree.DecisionTreeClassifier()")

model= tree.DecisionTreeClassifier()

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的GradientBoostingClassifier(n_estimators=200) ")

model= GradientBoostingClassifier(n_estimators=200)

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

print(" 调用scikit的SVC(kernel='rbf', probability=True) ")

model= SVC(kernel='rbf', probability=True)

start_time= time.time()

model.fit(X,y)

print('training took %fs!' % (time.time() - start_time))

print(model)

expected= y

predicted= model.predict(X)

print(metrics.classification_report(expected,predicted))

print(metrics.confusion_matrix(expected,predicted))

"""

# 预处理代码集锦

importpandas as pd

df=pd.DataFrame(dataset)

print(df.head(3))

print(df.describe())##描述性分析

print(df.corr())##各特征相关性分析

##计算每行每列数据的缺失值个数

defnum_missing(x):

return sum(x.isnull())

print("Missing values per column:")

print(df.apply(num_missing, axis=0)) #axis=0代表函数应用于每一列

print(" Missing values per row:")

print(df.apply(num_missing, axis=1).head()) #axis=1代表函数应用于每一行"""

⑸ 在套用网上的matlab代码时显示未定义变量，要怎么定义呢

Key Features
用于科学和工程计算的高级语言
桌面环境变得适合于迭代式的探查、设计及问题求解
用于数据可视化的图像系统以及用于创建自定义绘图的工具
用于曲线拟合、数据分类、信号分析和许多其他领域特定任务的应用程序
用于各种工程和科学应用的附加工具箱
用于构建自定义用户界面的应用程序的工具
C/C++、java?、.NET、Python?、SQL、Hadoop? 和 Microsoft? Excel? 的接口
与最终用户共享 MATLAB 程序的免费部署选项
为什么选择 MATLAB？
MATLAB? 是面向工程师和科学家的最简单和最具生产力的软件。无论您要分析数据、开发算法还是创建模型，MATLAB 都提供了鼓励探索和发现的环境。它将高级语言与针对迭代式工程和科学工作流进行调整的桌面环境相结合。

在针对您的工作方式所设计的桌面环境中分析数据和开发算法。
MATLAB 精通数学
基于矩阵的 MATLAB 语言是世界上最自然的计算数学表示方法。MATLAB 中的线性代数就像教科书中的线性代数一样。这样可以简单直接地捕获您想 法背后的数学概念，意味着您的代码更容易编写、阅读和理解，而且更容易维护。
您可以信任您的计算结果。MATLAB 深根于数值分析研究社区，因其无可挑剔的数值运算而广为人知。由 350 名工程师组成的 MathWorks 团队每天都对 MATLAB 代码库运行数百万次的测试，不断验证其质量。
MATLAB 执行艰苦工作，确保您的代码快速运行。数学运算分布到您的计算机上的多个内核中，库调用经过高度优化，所有代码均即时编译。您可以通过将 for 循环更改为并行 for 循环或将标准数组更改为 GPU 或分布式数组来以并行方式运行您的算法。无需更改代码，即可在可无限扩展的公共云或私有云上运行并行算法。
MATLAB 语言还提供了传统编程语言的功能，包括流控制、错误处理、面向对象编程、单元测试和源代码管理集成。

探索图片库 (4 图片 )
MATLAB 面向工程师和科学家设计
MATLAB 调整后的界面环境更适合迭代式工程和科学工作流程。集成的工具支持同时探索数据和程序，让您以更少的时间评估更多的想法。
您可以采用交互方式预览、选择和预处理您要导入的数据。
丰富的内置数学函数集为您的工程和科学分析提供支持。
2D 和 3D 绘图函数使您可以实现数据可视化，理解数据，并交流结果。
使用 MATLAB 应用程序可以执行常见的工程任务，无需编程。将不同算法处理数据的方式可视化，并在您获得所需结果之前反复迭代。
利用集成的编辑和调试工具可以快速试探多个选项，优化分析，并通过反复迭代找出最佳解决方案。
您可以将工作捕获为可共享的交互式描述。
由工程师和科学家编写的全面、专业的文档始终触手可及，确保您保持工作效率。可靠的实时技术支持人员能迅速回答您的问题。您还可以在 MATLAB Central（一个面向 MATLAB 和 Simulink? 用户的开放式交流平台）学习超过 100,000 名社区成员和 MathWorks 工程师的知识与经验。
MATLAB 和附加工具箱相互集成，并设计为协同工作。它们专门针对科学和工程应用提供了经过专业开发、严格测试、现场强化和完全归档的功能。

实时编辑器包括结果以及生成这些结果的代码，用于加速探索性编程和分析。添加方程式、图像、超链接以及格式化文本以增强描述效果。
MATLAB 集成工作流
重大的工程和科学挑战需要广泛合作才能使想法付诸实施。沿途的每次交接都会增加错误和延迟。
MATLAB 会使从研究到生产的整个路径自动化。您可以：
构建和打包自定义 MATLAB 应用程序和工具箱，以便与其他 MATLAB 用户共享。
创建独立可执行文件，以便与其他没有 MATLAB 的人共享。
与 C/C++、Java、.NET 和 Python 集成。直接从 MATLAB 调用这些语言，或者打包 MATLAB 算法和应用程序以便在 Web、企业和生成系统内部署。
将 MATLAB 算法转换为 C、HDL 和 PLC 代码以在嵌入式设备上运行。
部署 MATLAB 代码以在生产 Hadoop 系统上运行。
MATLAB 还是基于模型的设计的关键部分，该设计用于多域仿真、物理和离散事件仿真以及验证和代码生成。探索 Simulink、Simscape? 和 Stateflow? 以了解更多关于基于模型的设计的信息。

⑹ python没有直接生成服从泊松分布随机数的函数吗

首先是泊松分布，这是一个离散型的随机变量分布，比较好弄，此外例如考察一些到达事件的概率时，通常服从泊松分布，因此该分布相当实用。在开始编写之前，先感谢知乎一位大神的科普知识，假设有一个服从均匀分布的随机变量，u~U[0,1]，F(x)为随机变量x的累计分布函数，那么F-1（u）的变量服从F分布，即F的逆函数是服从F的随机变量。代码如下：

[java] view plain print?
<span style="white-space:pre"> </span>private static int getPossionVariable(double lamda) {
int x = 0;
double y = Math.random(), cdf = getPossionProbability(x, lamda);
while (cdf < y) {
x++;
cdf += getPossionProbability(x, lamda);
}
return x;
}

private static double getPossionProbability(int k, double lamda) {
double c = Math.exp(-lamda), sum = 1;
for (int i = 1; i <= k; i++) {

⑺ 以下代码怎么用python 去模拟

pbCompleted = 0
def eventCallback(eventType, pEventData, pContext):
if eventType==fft_file_downloader_event_completed:
pbCompleted = pContext
print "Completion callback!\n"
pbCompleted = 1;
elif eventType==fft_file_downloader_event_progress:
print "Current progress: %d\n" % pEventData
python是没有指针的，所以需要传递指针的操作，直接传递数值，将有些变量作为类变量或者全局的变量。比如pbCompleted可以作为全局的。

⑻ 创建类和对象的问题

1.var $book_ID表示book类中的一个成员变量；
2.$this->book_ID=$ID表示book类的实例化时的this指针（表示当前类的对象）指向的book_ID成员变量赋给$ID变量的值；
3.类和对象是面向对象编程的核心，其简介如下：
面向对象语言(Object-Oriented Language)是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。语言中提供了类、继承等成分。

面向对象语言借鉴了20世纪50年代的人工智能语言LISP，引入了动态绑定和交互式开发环境的思耄皇加?0年代的离散事件模拟语言SIMULA67，引入了类的要领和继承，成形于70年代的Smalltalk。面向对象语言的发展有两个方向：一种是纯面向对象语言，如Smalltalk、EIFFEL等；另一种是混合型面向对象语言，即在过程式语言及其它语言中加入类、继承等成分，如C++、Objective-C等。

面向对象语言刻画客观系统较为自然，便于软件扩充与复用。有4个主要特点：

(1)识认性，系统中的基本构件可识认为一组可识别的离散对象;
(2)类别性，系统具有相同数据结构与行为的所有对象可组成一类；
(3)多态性，对象具有惟一的静态类型和多个可能的动态类型；
(4)继承性，在基本层次关系的不同类中共享数据和操作。

其中，前三者为基础，继承是特色。四者(有时再加上动态绑定)结合使用，体现出面向对象语言的表达能力。

一般认为，较典型的面向对象语言有：

SIMULA67，支持单继承和一定含义的多态和部分动态绑定；
Smalltalk支持单继承、多态和动态绑定；
EIFFEL，支持多继承、多态和动态绑定；
C++，支持多继承、多态和部分动态绑定。

四种语言涉及概念的含义虽基本相同，但所用术语有别。

基于类的面向对象语言

基于类的面向对象语言是面向对象世界里的主流。它包括：

Simula, 第一个面向对象语言
Smalltalk, 第一个支持动态类型的语言
C++, 它的大部分基于类的特性继承自Simula.等等等等。

与基于类的语言相对应的是基于对象的面向对象语言。这里“基于对象”的概念和把Visual Basic叫做基于对象的概念是不同的。这里的“基于对象”是指一个只以对象为中心，没有类的概念的语言，类似Python之类的语言。

一个生动的比喻：人类原始语言--面向对象语言

不知道这样的比喻是不是恰当:人生就象是一段程序, 只不过这段程序是由上帝用特殊的代码编写而成,里面的算法极其复杂.这世界上谁也不会看懂,谁能看懂谁就是上帝.除非就象拖动播放器一样去拖动时间,你才会猛然发现后面的事情.但是时间是不能拖动的.至少现在是这样.于是对将来的无知就使我们有了恐惧 .

我想也许上帝编写他的庞大的程序应该综合了很多语言,而在编写“human”这个类的时候我想也许他主要用的应该是面向对象这种语言吧.他赋予了我们每个人类对象一些属性 ,一些行为,并且使之归类.物以类聚，人以群分，体现的正是这一点.所以我们每个人最起码应该知道自己本身属于什么类.能做什么?不能做什么?而我就属于那种再平凡不过的替其他代码服务的方法, 别人只需要调用就可 .

有的代码有局限性,写出来只能在一定的环境才能运行.我们周围的大自然就是 ,比如高山,大树,房屋,大海，甚至地球等星球。而有的代码写出来以后,可以在任何地方运行.比如面向对象语（JAVA）.而我偏偏就属于前一种代码,顶多生活在自己的世界就已经是非常幸福了.其实到现在我都没有达到.而大多数人就属于后者,走到哪儿都能生存, 都能适应.所以说我们人类的适应力其实是最强的. 还有一种代码就是乱码 ,让人看不懂. 谁也不理解他, 他也不理解这个世界. 由于现代社会的冷漠和沟通的减少,以及人们表达方式所产生的误会，这种代码也有很多 .他们孤单寂寞 ,感情得不到宣泄 ,压抑得不到释放 ,似被忽略, 不值得提.

有的代码写出来以后什么用处也没有, 他的存在只是浪费时间和空间 ,浪费资源而已 .什么都不做 ,或者说尽做一些毫无用处的事 .其实也不能这么说 .正如你在大街上看到乞丐一样 ,也许你会害怕那种情形 ,所以你使自己努力， 奋进 ，最后成为一位杰出的人才. 这都归于乞丐在你心中留下的阴影 ，只不过我们看不见这种实际存在的作用.而有的代码功能十分的庞大,服务很多，可以做许多有意义 ，有用的事. 我们当中的掌管技术或艺术的人就属于这一类. 他们是推动社会的核心力量 ,他们的存在就是让世界前进 ，发展 ，让这个世界充满勃勃生机.然而还有一种代码, 自己没有多少的服务和动作, 而是靠调用别的代码来达到目的. 不要说这种代码可恶, 这种代码其实最有用. 通过他的调用 别的代码才能发挥自己的作用 ,才能体现出价值来. 我们当中也有很多这种类型的人 .比如公司的经理，总裁，地区的市长，国家的主席等，他们通常是上流社会的主导，控制着世界发展的方向. 没有他们的控制和管理， 恐怕社会将体现不出应有的价值.

我们每个人都无法看透别人 ,正如类的封装一样. 如果要想了解一点的话 ,可以通过消息与其他事物互动 .所以这样也只是对事物了解了一点点 ,因此不要说你看透了谁 ,你了解透了谁 ，至少你不能了解他的真真的本身属性.其实很多人所说的掌握了真理只不过是一些事物所表现出来的类似真理的表象而已. 所以我们为人处事应该谦虚, 因为我们知道的只有一丁点 .实际上我们经常只是实列连接 ,就如同父辈和我们这代之间的鸿沟一样 .彼此都不通过消息去了解 .但有一点就是 我们至少必须了解自己 .给自己定位. 这就是所谓的自知.

同样 ,人必须要发展 ,要进步, 如同类的继承一样, 子类继承了父类. 而且他本身还增加了许多功能. 这样才能提高内涵, 提高自身的价值.而上帝实际上就是用“遗传”和“变异”来体现这一设计的. 而且类还具有多态性 ,可以继承他上面的许多的父类. 所以我们要多多向那些比我们优秀的人学习, 继承他们的优点, 学习他们的智慧. 如果你觉的继承过来的东西满足不了你或不适合你, 怎么办呢? 不要紧, 上帝编写程序的时候早就考虑到了. 他允许每个“person”这个实列重写父类中的方法, 以适应自己本身. 也就是方法覆盖. 东方曾经就是向西方学习 ,继承了他们的先进之处, 再结合自己的特点, 走自己的特色道路, 这就是一个很好的列子.

另外就是接口要多, 这样才活跃. 很多东西都可以通过接口来了解你的很多特点. 这便是开放 .让别人来了解自己 ,也让自己在别人面前表现出自己的价值, 存在的意义. 而有的代码则相反 ，没有什么接口，甚至根本就没有接口 .把自己孤立起来, 让人不能理解 .任何一方面都无法与他沟通. 这就会导致自闭 ,而自闭又会导致落后, 挨打 .中国曾经就是由于闭关锁国，闭门造车而导致发展缓慢，十分落后，而现在就不一样了，加入了世贸，融入了世界，成为了强国，甚至成为了带动世界经济的火车头，这就是一个很大的转变.

程序有重复和选择结构, 我相信我们人类这道程序也应该是. 比如可以发明时间机器, 直接跳到后面去执行语句, 而我们就走向了未来. 或是再返回去重复执行以前的语句, 就如同我们回到从前, 再去经历一遍. 当然 ,这是要有条件的, 要根据条件选择. 而我们要具备的条件就是技术, 这样才能发明时间机器. 但这就要看上帝要在什么时候实现这一小目标"时间机器的诞生"

程序设计总是强调弱耦合，强内聚.而上帝在面向人类对象的设计中也是这样的. 他是希望我们每个人不要太依赖别人,而是要靠自己的实力去实现愿望 . 中国就是这样, 走自己的特色道路, 坚持自力更生 ,艰苦奋斗，最终实现了社会主义社会 .

还有就是包, 里面的内容十分丰富. 每个类或实列都可以直接或间接享用或吸收里面的东西. 比如LANG包. 而事实上中国共产党就属于这个包, 起到SUPER的作用. 我们每个人都是在党的怀抱下成长的, 我们每个人都直接或间接的继承他的优良传统和作风,才使我们中华民族的每个子女这么优秀 .因此我们每个人都要爱戴党，拥护党，加入党。

上帝好象有意偏袒生命这种不同寻常的东西, 在面向对象的时候, 他还赋予每段代码不同寻常的功能. 那就是代码本身在适当的时候可以改变自己, 调整自己 ,以适应需要. 这是个了不起的设计. 敢这样说: 就因为这个设计, 世界才能发展到现在. 这个类的类名叫"life" 是高贵的 ,功能最强的 ,尤其是在"person"这一方面体现的更强烈. 正如我们在失败的时候可以及时的调整自己的心态, 重新开始. 或者在了解自己很落后的时候 ,可以让自己去学习, 去工作. 或者说在受到伤害的时候努力让自己坚持. 也就是说, 在做任何事情的时候可以根据需要随时改变自己的动作或心态去迎合目标. 这有点象函数 ,能根据不同的参数计算出不同的结果. 而我们的性格和行为就相当于自变量 ,改变自变量, 将改变结果 .或者说就正如方法重载 ,虽然类名是一样的, 但可以根据参数个数或类型而自己就判定应该调用那一个方法 ,应该做那些动作. 所不同的是, 我们不但可以赋予自己不同的参数 ,我们还能改变自己的算法方式 .而函数就不行, 算法方式已经定下了 ，只能由此算法改变结果而已.因此说这种代码是高度智慧的, 也就是说 ,上帝在编写他的时候赋予了他特殊的方法:允许对象调用自己本身去创造方法. 也就是说他把我们设计成了主动对象, 而把其他事物设计成了被动对象 .上帝是希望通过我们人类的主动性去发现事物 ,发现真理, 探索世界. 缺了他 ,世界将是一片荒凉, 如同机械一般 ,没有激情 ,没有生机, 就象风穿梭在黑夜.

所有的程序都是“固定”的, 也就是说编写好了以后他总是按照程序“本身”去执行 ,不会有任何意外. 对与普通程序, 死机可能是一种意外. 其实不是 ,死机无非就是程序中断，这也是符合程序本身的. 因为你的程序只能做到这样：死机的时候中断. 上帝在设计我们人类的时候也是这样的. 如果我们有意外, 比如地球毁灭, 太阳寿尽, 那也没办法, 因为上帝在编写程序的时候没有编写处理异常的代码. 也许他编写了, 只不过这段代码到后期才能执行, 但谁知道呢. 普通代码通常是这段代码执行完以后再去执行那段代码.也就是所谓的顺序执行. 同样 ,上帝编写的程序也不列外 .有因必有果, 所有事情的发生一点也不偶然,正如东京的蝴蝶振动一下翅膀，纽约就会倾盆大雨，而其间的一系列连环反应谁也不清楚, 但这一切其实都是已“注定”的.任何人都无法改变自己的“FORTUNE” 你可能会说, 我就可以改变自己的命运, 我要靠自己的努力去改变自己的人生. 恭喜你 !你就是那段具有高度智慧的代码, 能根据需要随时改变自己的状态和行为. 但是, 这个改变本身实际上仍然是上帝赋予你的. 是他老人家安排我们能做什么 ,不能做什么。

⑼ 关于python的问题 在python里如何在不用eval（）的情况下将字符串转化成代码计算 

这涉及到非常复杂的字符串处理问题

随着输入表达式的复杂度增加，程序会变得越发臃肿

以简单的二元加法为例，处理二元加法比较简单：

string=input()
num=[float(i)foriinstring.split('+')]
print(sum(num))

而Python内置函数是以C写成，在运行速度上，占据绝对优势

在编程时只需将传入表达式执行检查，并且转化为Python表达式，传递给eval()即可，这比手动进行字符串处理方便快捷，也带来了更好的代码可读性和复用能力

用Python的哲学说就是：EIBIT——明了胜于晦涩

⑽ 如何在Python中实现这五类强大的概率分布

要使用Python实现一些离散和连续的概率分布。虽然我不会讨论这些分布的数学细节，但我会以链接的方式给你一些学习这些统计学概念的好资料。在讨论这些概率分布之前，我想简单说说什么是随机变量（randomvariable）。随机变量是对一次试验结果的量化。举个例子，一个表示抛硬币结果的随机变量可以表示成PythonX={1如果正面朝上,2如果反面朝上}12X={1如果正面朝上,2如果反面朝上}随机变量是一个变量，它取值于一组可能的值（离散或连续的），并服从某种随机性。随机变量的每个可能取值的都与一个概率相关联。随机变量的所有可能取值和与之相关联的概率就被称为概率分布（probabilitydistributrion）。我鼓励大家仔细研究一下scipy.stats模块。概率分布有两种类型：离散（discrete）概率分布和连续（continuous）概率分布。离散概率分布也称为概率质量函数（probabilitymassfunction）。离散概率分布的例子有伯努利分布（Bernoullidistribution）、二项分布（binomialdistribution）、泊松分布（Poissondistribution）和几何分布（geometricdistribution）等。连续概率分布也称为概率密度函数（probabilitydensityfunction），它们是具有连续取值（例如一条实线上的值）的函数。正态分布（normaldistribution）、指数分布（exponentialdistribution）和β分布（betadistribution）等都属于连续概率分布。若想了解关于离散和连续随机变量的知识，你可以观看可汗学院关于概率分布的视频。二项分布（BinomialDistribution）服从二项分布的随机变量X表示在n个独立的是/非试验中成功的次数，其中每次试验的成功概率为p。E(X)=np,Var(X)=np(1−p)如果你想知道每个函数的原理，你可以在IPython笔记本中使用helpfile命令。E(X)表示分布的期望或平均值。键入stats.binom?了解二项分布函数binom的信息。二项分布的例子：抛掷10次硬币，恰好两次正面朝上的概率是多少？假设在该试验中正面朝上的概率为0.3，这意味着平均来说，我们可以期待有3次是硬币正面朝上的。我定义掷硬币的所有可能结果为k=np.arange(0,11)：你可能观测到0次正面朝上、1次正面朝上，一直到10次正面朝上。我使用stats.binom.pmf计算每次观测的概率质量函数。它返回一个含有11个元素的列表（list），这些元素表示与每个观测相关联的概率值。您可以使用.rvs函数模拟一个二项随机变量，其中参数size指定你要进行模拟的次数。我让Python返回10000个参数为n和p的二项式随机变量。我将输出这些随机变量的平均值和标准差，然后画出所有的随机变量的直方图。泊松分布（PoissonDistribution）一个服从泊松分布的随机变量X，表示在具有比率参数（rateparameter）λ的一段固定时间间隔内，事件发生的次数。参数λ告诉你该事件发生的比率。随机变量X的平均值和方差都是λ。E(X)=λ,Var(X)=λ泊松分布的例子：已知某路口发生事故的比率是每天2次，那么在此处一天内发生4次事故的概率是多少？让我们考虑这个平均每天发生2起事故的例子。泊松分布的实现和二项分布有些类似，在泊松分布中我们需要指定比率参数。泊松分布的输出是一个数列，包含了发生0次、1次、2次，直到10次事故的概率。我用结果生成了以下图片。你可以看到，事故次数的峰值在均值附近。平均来说，你可以预计事件发生的次数为λ。尝试不同的λ和n的值，然后看看分布的形状是怎么变化的。现在我来模拟1000个服从泊松分布的随机变量。正态分布（NormalDistribution）正态分布是一种连续分布，其函数可以在实线上的任何地方取值。正态分布由两个参数描述：分布的平均值μ和方差σ2。E(X)=μ,Var(X)=σ2正态分布的取值可以从负无穷到正无穷。你可以注意到，我用stats.norm.pdf得到正态分布的概率密度函数。β分布（BetaDistribution）β分布是一个取值在[0,1]之间的连续分布，它由两个形态参数α和β的取值所刻画。β分布的形状取决于α和β的值。贝叶斯分析中大量使用了β分布。当你将参数α和β都设置为1时，该分布又被称为均匀分布（uniformdistribution）。尝试不同的α和β取值，看看分布的形状是如何变化的。指数分布（ExponentialDistribution）指数分布是一种连续概率分布，用于表示独立随机事件发生的时间间隔。比如旅客进入机场的时间间隔、打进客服中心电话的时间间隔、中文维基网络新条目出现的时间间隔等等。我将参数λ设置为0.5，并将x的取值范围设置为$[0,15]$。接着，我在指数分布下模拟1000个随机变量。scale参数表示λ的倒数。函数np.std中，参数ddof等于标准偏差除以$n-1$的值。/81321/