import random
 
 
def coin_trial():
    """
    模拟抛掷 10 次硬币
    """
    heads = 0  # 正面朝上的次数
    for i in range(10):
        if random.random() <= 0.5:
            heads += 1
    return heads
 
 
def simulate(n):
    """
    模拟抛掷 10 * n 次硬币
    """
    trials = []
    for i in range(n):
        trials.append(coin_trial())
    return(sum(trials) / n)

simulate(1)

simulate(10)

simulate(100)

simulate(1000)

simulate(10000)

simulate(100000)

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from collections import Counter
 
# rcParams 配置
plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
# 为 True 时, 减号使用 unicode 编码而不是连字符号，请查看 http://en.wikipedia.org/wiki/Plus_and_minus_signs#Character_codes
plt.rcParams['axes.unicode_minus'] = False
 
def Discrete_pmf():
    xk = np.arange(5)  # X 所有可能的取值[0 1 2 3 4 5]
    pk = (1 / 16, 1 / 4, 3 / 8, 1 / 4, 1 / 16)  # 概率函数
    # name: 实例名称 custm, values: 两个数组的元组_LIKE，可选
    # (xk, pk) 哪里 xk 是整数，并且 pk 是介于 0 和 1 之间的非零概率吗？sum(pk) = 1。xk 和 pk 必须有相同的形状。
    dist = stats.rv_discrete(name='custm', values=(xk, pk))  
    rv = dist.rvs(size=100)  # rvs: 产生服从指定分布的 100 个随机数, 通过 size 给定随机数的大小
    fig, (ax0, ax1) = plt.subplots(ncols=2, figsize=(10, 5))  # 将窗口划分为 ax0, ax1
    
    ax0.set_title("概率函数")
    ax0.plot(xk, pk, 'ro', ms=8, mec='r')  # 画点, X 轴为 xk, Y 轴为 pk, 红色点图, 红点大小为 8, 红点颜色为 red
    ax0.vlines(xk, 0, pk, colors='r', linestyles='-', lw=2)  # 画线, 0 为 Y 轴最下方, 红色, 实线, 宽度为 2
    for i in xk:  # 标注数字
        ax0.text(i, pk[i], '%.3f' % pk[i], ha='center', va='bottom')
    
    ax1.set_title("分布函数")
    pk1 = dist.cdf(xk)  # cdf 累积分布函数
    """
    rv 数据序列(绘制的直方图高度服从这个数据序列, 标注的数据并不准确?)
    5 组(0 1 2 3 4),
    density=ture 的意思是保证该面积的积分为 1
    histtype: 直方图类型，‘bar’, ‘barstacked’, ‘step’, ‘stepfilled’
    蓝色
    透明度 0.75
    cumulative=True 频率累加
    """
    ax1.hist(rv, 5, density=True, histtype='step', facecolor='blue',
             alpha=0.75, cumulative=True)  # .hist 用于绘制直方图
    for i in xk:  # 标注数字
        ax1.text(i, pk1[i], '%.3f' % pk1[i], ha='center', va='bottom')
    print(Counter(rv))
        
    
if __name__ == "__main__":
    Discrete_pmf()

import numpy as np
from numpy import pi
import matplotlib.pyplot as plt
import scipy.stats as stats
 
 
def test_norm_pmf():
    mu = 0  # 均值为 0
    sigma = 1  # 方差为 1
    x = np.arange(-5, 5, 0.1)  # 分布随机变量 x
    fig, (ax0, ax1) = plt.subplots(ncols=2, figsize=(10, 5))
    
    # 概率密度函数
    y0 = (1 / ((np.sqrt(2 * pi) * sigma))) * np.exp(-(((x - mu) ** 2)) / (2 * sigma * sigma))  # f(x)
    ax0.plot(x, y0)
    ax0.set_title('Normal: $\mu$ = %.1f, $\sigma^2$ = %.1f' % (mu, sigma))
    ax0.set_xlabel('x')
    ax0.set_ylabel('概率密度函数 Probability density', fontsize=15)
    
    # 概率分布函数
    y1 = stats.norm.cdf(x, 0, 1)  # F(x)
    ax1.plot(x, y1)
    ax1.set_title('Normal: $\mu$ = %.1f, $\sigma^2$ = %.1f' % (mu, sigma))
    ax1.set_xlabel('x')
    ax1.set_ylabel('概率分布函数 Cumulative density', fontsize=15)
    
    fig.subplots_adjust(wspace=0.4)
    plt.show()
    
    
if __name__ == "__main__":
    test_norm_pmf()

from scipy import stats
from scipy.stats import norm
 
print(norm.__doc__)

from scipy import stats
from scipy.stats import norm
import numpy as np
import pylab as plt
 
X = norm()
Y = norm(loc = 1.0, scale = 2.0)  # 正态分布期望 1.0, 标准差 2.0
t = np.arange(-10, 10, 0.01)
plt.plot(t, X.pdf(t), label='$X$', color="red")
plt.plot(t, Y.pdf(t), "b--", label="$Y$")
plt.legend()
plt.show()

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
 
#解决中文显示问题
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
 
# 定义随机变量
mu4 = 2  # 平均值：每天发生 2 次事故
# 发生事故次数，包含 0 次，1 次，2 次，3 次，4 次事故
X4 = np.arange(0,5,1)
pList4 = stats.poisson.pmf(X4,mu4)  # poisson 泊松, pmf 离散型随机变量分布律
print(pList4)
# 绘图
plt.plot(X4, pList4, marker='o', linestyle='None', alpha=0.75)
plt.vlines(X4, 0, pList4, alpha=0.75)
plt.xlabel('某路口发生 k 次事故')
plt.ylabel('概率')
for i in X4:  # 标注数字
    plt.text(i, pList4[i], '%.3f' % pList4[i], ha='center', va='bottom')
plt.title('泊松分布：平均值 mu=%i' % mu4)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
from scipy import stats
 
# 解决汉字显示
mpl.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
mpl.rcParams["axes.unicode_minus"] = False
 
f = plt.figure(figsize=(16, 8))
mean, var = 0.5, 1.0/12  # [0, 1]范围内的均匀分布的均值和方差
 
 
def p_norm(nvr):
    """
    绘制正态分布曲线
    """
    mu = mean
    sigma = np.sqrt(var/nvr)
    norm_dis = stats.norm(mu, sigma)  # 定义正态分布对象
    norm_x = np.linspace(0, 1, 128)  # 定义域
    pdf = norm_dis.pdf(norm_x)  # f(X)
    plt.plot(norm_x, pdf, 'r', alpha=0.6, label='N(${0:.1f}, {1:.2f}^2$)'.format(mu, sigma))
    plt.legend(loc='upper left', prop={'size': 8})
    
    
def sample(rv_num):
    """
    对随机变量(X1+X2+...)进行一次采样
    :return: 这些样本的平均值
    """
    single_sample_dist = stats.uniform(loc=0, scale=1)  # 定义[0, 1]上的均匀分布对象
    x = 0
    for j in range(rv_num):
        x += single_sample_dist.rvs()
    x *= 1 / rv_num
    return x
 
 
def plotHist(Sample_num, rv_num, n_):
    """
    画出 n 个随机变量和样本的直方图
    :param Sample_num: 样本数目
    :param rv_num: 随机变量的个数
    :param n_: 图例序号
    """
    x = np.zeros((Sample_num))
    sp = f.add_subplot(2, 2, n_)
    for i in range(Sample_num):  # 采样 Sample_num 次
        x[i] = sample(rv_num)
    # 画出直方图
    plt.hist(x, 500, density=True, color='#348ABD', label='{}个随机变量'.format(rv_num))
    plt.setp(sp.get_yticklabels(), visible=False)
    # 画出正态分布曲线
    p_norm(rv_num)
    
    
if __name__ == "__main__":
    Sample_num = 1000
    nvr = ([1, 2, 32, 64])
    for i in range(np.size(nvr)):
        plotHist(Sample_num, nvr[i], i + 1)
    plt.suptitle("服从均匀分布 U[0, 1]的多个随机变量和的均值逼近于正态分布")
    plt.show()

import numpy as np
from math import sqrt
 
# 生成样本数据
nlist = range(0, 9_000_000)
nlist = [float(i) / 1_000_000 for i in nlist]
N = len(nlist)

sum1 = 0.0  # 样本数据之和
sum2 = 0.0  # 样本数据平方和
for i in range(N):
    sum1 += nlist[i]
    sum2 += nlist[i] ** 2
mean = sum1 / N  # 平均值
var = sum2 / N - mean ** 2  # 方差 D(X) = E(X ^ 2) - [E(X)] ^ 2
std = sqrt(var)  # 标准差 ^ 2 = 方差
 
mean, var, std

narray = np.array(nlist)
sum1 = narray.sum()
narray2 = narray * narray  # 就这?
sum2 = narray2.sum()
mean = sum1 / N
var = sum2 / N - mean ** 2
std = sqrt(var)
 
mean, var, std

mean = np.mean(nlist)
var = np.var(nlist)
std = np.std(nlist)
 
mean, var, std

import numpy as np
import random
import pandas as pd
 
# 列名 = [买入价, 维护费, 车门数, 可容纳人数, 后备箱大小, 安全性, 汽车类别]
columnsName=['buying', 'maint', 'doors', 'persons','lug-boot','safety','label']
 
 
def getDataSet(file):
    """
    从数据集中获得数据
    """
    fr = open(file)
    rdata = []
    for line in fr.readlines():
        tmp = line.strip().split(',')  # 这个文件以逗号分割数据
        rdata.append(tmp)
    df = pd.DataFrame(rdata)  # 读入数据到 DATAFrame 变量 df，类似二维表
    df.columns = columnsName  # 设置 df 的列名
    return df
 
 
def getTrainTest(data, trainNum):
    """
    随机抽取数据,将数据集分成训练集和测试集
    :return: 训练集, 测试集
    """
    # 从 0 到 len（data）整数列表中随机截取 trainNum 个整数片段
    """
    语法：random.sample(sequence, k)
    参数：
    sequence: 可以是一个列表，元组，字符串，或集合
    k: 一个整数值，它指定一个样本的长度
    返回：从序列中选择元素的 k 长度的新列表。
    """
    choose = random.sample(range(len(data)), trainNum)
    choose.sort()
    j = 1
    dftrain = pd.DataFrame(columns=columnsName)
    dftest = pd.DataFrame(columns=columnsName)
    for i in range(1,len(data)):
        # 如果被随机选中，加入训练集，否则测试集
        if (j < trainNum and i == choose[j]):
            dftrain.loc[dftrain.shape[0]]=data.iloc[i]
            j += 1
        else:
            dftest.loc[dftrain.shape[0]]=data.iloc[i]
    return dftrain, dftest

class NBClassify(object):
    """
    定义朴素贝叶斯模型
    """
    def __init__(self):
        # tabProbablity 核心字典，记录各类别的先验概率，格式：{'unacc':概率值, 'acc': 概率值, 'vgood': 概率值, 'good': 概率值}
        _tagProbablity = None
        # featuresProbablity 核心字典，记录各类别下各特征取值的条件概率。三级字典，
        # 格式：类别 1: {'特征 1': {'值 1': 概率值, ...'值 n': 概率值}, '特征 2':{}...},类别 2：{'特征 1': {'值 1': 概率值, ...'值 n': 概率值},
        _featuresProbablity = None
 
    def train(self,df):
        """
        4.定义训练函数
        利用训练数据分别计算类先验概率和似然概率
        """
        # value_counts: 查看 label 这一列的计数结果
        self._tagProbablity = df['label'].value_counts(value for value in df['label'])
        print("各类别的先验概率(各类别占比)：\n", self._tagProbablity)
 
        # 计算各特征及对应取值的出现次数 dictFeaturesBase
        # 格式：{特征 1:{值 1:出现 5 次, 值 2:出现 1 次}, 特征 2:{值 1:出现 1 次, 值 2:出现 5 次}}
        dictFeaturesBase = {}.fromkeys(df.columns)  # 创建一个字典
        for column in df.columns:  # 遍历数据各列
             seriesFeature = df[column].value_counts()
             dictFeaturesBase[column] = seriesFeature
        # 从特征值字典删去类别信息
        del dictFeaturesBase['label']
 
        # 初始化字典 dictFeatures
        # 格式：{类别 1:{'特征 1':{'值 1':None,...'值 n':None},'特征 2':{...}},类别 2：{'特征 1':{'值 1':None, ...},...}
        dictFeatures = {}.fromkeys(df['label'])
        for key in dictFeatures.keys():
            dictFeatures[key] = {}.fromkeys([key for key in dictFeaturesBase])
        for key, value in dictFeatures.items():
            for subkey in value.keys():
                value[subkey] = {}.fromkeys([x for x in dictFeaturesBase[subkey].keys()])
        # 计算各类别、对应特征及对应取值的出现次数，存入字典 dictFeatures
        for i in range(0, len(df)):
            label = df.iloc[i]['label']  # df.iloc: 官方文档定义为“基于整数位置的索引，用于按位置进行选择。类别
            for feature in columnsName[0:6]:  # 对应的特征
                fvalue = df.iloc[i][feature]  # 对应的特征取值
                if dictFeatures[label][feature][fvalue] == None:
                    dictFeatures[label][feature][fvalue] = 1  # 该类别下该特征值第一个出现的样本
                else:
                    dictFeatures[label][feature][fvalue] += 1  # 如果已有，次数加一
 
        # 该类数据集若未涵盖此特征值时，加入 Laplace 平滑项
        # 拉普拉斯平滑（Laplace Smoothing）又被称为加 1 平滑，是比较常用的平滑方法。
        # 平滑方法的存在时为了解决零概率问题。比较多地出现在文本分类问题的概率处理上
        # https://blog.csdn.net/weixin_43868020/article/details/106602799
        for tag, featuresDict in dictFeatures.items():
            for featureName, featureValueDict in featuresDict.items():
                for featureKey, featureValues in featureValueDict.items():
                    if featureValues == None:
                        featureValueDict[featureKey] = 1
 
        # 由字典 dictFeatures 计算每个类别下每种特征对应值的概率，即特征的似然概率 P(feature|tag)
        for tag, featuresDict in dictFeatures.items():
            for featureName, featureValueDict in featuresDict.items():
                totalCount = sum([x for x in featureValueDict.values() if x != None])
                for featureKey, featureValues in featureValueDict.items():
                    featureValueDict[featureKey] = featureValues / totalCount
        self._featuresProbablity = dictFeatures
        print("每个类别下每种特征对应值的似然概率:\n", dictFeatures)
 
    def classify(self, featureTuple):
        """
        对测试集进行预测
        :return: 最大后验概率的类别
        """
        resultDict = {}
        # 计算样本属于每个类别的后验概率
        for tag, featuresDict in self._featuresProbablity.items():
            iNumList = []
            i=0
            # 将各特征值对应的似然概率添加到列表 iNumList
            for feature,featureValueDict in featuresDict.items():
                featureValue = str(featureTuple[i])
                iNumList.append(self._featuresProbablity[tag][feature][featureValue])
                i=i+1
            # 列表 iNumList 中的概率相乘，得到似然概率
            conditionProbability = 1
            for iNum in iNumList:
                conditionProbability *= iNum
            # 将先验概率乘以似然概率得到后验概率 resultDict
            resultDict[tag] = self._tagProbablity[tag] * conditionProbability
        # 对比每个类别的后验概率 resultDict 的大小
        resultList = sorted(resultDict.items(), key=lambda x: x[1], reverse=True)
        # 返回最大后验概率的类别
        return resultList[0][0]

if __name__ == '__main__':
    dfData = getDataSet('car.txt')
    # 避免过拟合，采用交叉验证，随机选取 1500 个数据作为测试集，剩余为训练集
    # 交叉验证: 在给定的建模样本中，拿出大部分样本进行建模型，留小部分样本用刚建立的模型进行预报，
    # 并求这小部分样本的预报误差，记录它们的平方加和。
    trainData, testData = getTrainTest(dfData, 1500)
    # 定义朴素贝叶斯模型
    model = NBClassify()
    # 代入训练数据集，进行模型训练
    model.train(trainData)
    # 对测试数据集进行预测，并计算错误率
    errorCount = 0
    for i in range(0, len(testData)):
        result = model.classify(testData.iloc[i][0:6])
        # 将预测的类别和实际值比较
        if testData.iloc[i][6] != result: 
            errorCount += 1
    print("精度为 %f" % ((float(len(testData)) - float(errorCount)) / len(testData)))

import pandas as pd
import numpy as np
import random
from sklearn.naive_bayes import BernoulliNB
 
columnsName=['buying', 'maint', 'doors', 'persons','lug-boot','safety','label']
 
 
def getDataSet(file):
    """
    从数据集中获得数据，并进行整理
    """
    fr = open(file)
    rdata = []
    for line in fr.readlines():
        tmp = line.strip().split(',')
        rdata.append(tmp)
    df = pd.DataFrame(rdata)
    df.columns = columnsName
    # feature_codes 记录特征及数据标签的编码表，如：'buying'特征的取值及对应的编码：'vhigh': 0, 'high': 1, 'med': 2, 'low': 3
    feature_codes = [{'vhigh': 0, 'high': 1, 'med': 2, 'low': 3},
            {'vhigh': 0, 'high': 1, 'med': 2, 'low': 3},
            {'2': 0, '3': 1, '4': 2, '5more': 3},
            {'2': 0, '4': 1, 'more': 2},
            {'small': 0, 'med': 1, 'big': 2},
            {'high': 0, 'med': 1, 'low': 2},
            {'unacc':0,'acc': 1,'good': 2,'vgood':3} ]
    for i in range(0,7):
        df.iloc[:, i] = df.iloc[:,i].map(feature_codes[i])
    # Xtrain, Xtest, Ytrain, Ytest = train_test_split(df.iloc[:, 1:6], df.iloc[:, 7], test_size=0.17, random_state=420)
    return df
 
 
def getTrainTest(data, trainNum):
    """
    随机抽取数据,将数据集分成训练集和测试集
    """
    # 从 0 到 len（data）整数列表中随机截取 trainNum 个片段
    choose = random.sample(range(len(data)), trainNum)
    choose.sort()
    j = 1
    dftrain = pd.DataFrame(columns=columnsName)
    dftest = pd.DataFrame(columns=columnsName)
    for i in range(1,len(data)):
        # 如果被随机选中，加入训练集，否则测试集
        if (j < trainNum and i == choose[j]):
            dftrain.loc[dftrain.shape[0]]=data.iloc[i]
            j += 1
        else:
            dftest.loc[dftrain.shape[0]]=data.iloc[i]
    return dftrain, dftest

dfData = getDataSet('car.txt')
dfData

# 设置训练集和测试集
trainData, testData = getTrainTest(dfData, 1500)
train_X = trainData.iloc[:, :-1]
train_Y = np.asarray(trainData.iloc[:, -1], dtype="|S6")
test_X = testData.iloc[:, :-1]
test_Y = np.asarray(testData.iloc[:, -1], dtype="|S6")
 
train_X

train_Y  # 训练集的测评结果

test_X # 训练集输入

"""
alpha : 浮点数, 可不填 (默认为 1.0)
拉普拉斯或利德斯通平滑的参数λ，如果设置为 0 则表示完全没有平滑选项。
但是需要注意的是，平滑相当于人为给概率加上一些噪音，
因此λ设置得越大，伯努利朴素贝叶斯的精确性会越低（虽然影响不是非常大），布里尔分数也会逐渐升高。
binarize : 浮点数或 None，可不填，默认为 0
将特征二值化的阈值，如果设定为 None，则假定为特征已经被二值化完毕
fit_prior : 布尔值, 可不填 (默认为 True)
是否学习先验概率 P(Y=c)。如果设置为 false，则不使用先验概率，而使用统一先验概率（uniform prior），
即认为每个标签类出现的概率是 1/n_classes
class_prior：形似数组的结构，结构为(n_classes, )，可不不填（默认为 None）
"""
clf = BernoulliNB()
clf.fit(train_X, train_Y)  # 训练
predicted = clf.predict(test_X)
predicted

print('精度为：%f ' % np.mean(predicted == test_Y))

import pandas as pd
import matplotlib.pyplot as plt
 
messages = pd.read_csv('QQ_data.csv')  #读取数据
fig = plt.figure(figsize=(12,5))
plt.title('Frequency of QQmessages')
plt.xlabel('Number of QQmessages')
plt.ylabel('Frequency')
plt.hist(messages['numbers'].values,range=[0, 60], bins=60, histtype='stepfilled')  # 以列名为"numbers"的数据绘制直方图
plt.show()

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import scipy
import scipy.stats as stats
import scipy.optimize as opt
import statsmodels.api as sm
 
messages = pd.read_csv('QQ_data.csv')  #读取数据
y_obs = messages['numbers'].values
np.seterr(invalid='ignore')
 
 
def poisson_logprob(mu, sign=-1):
    """
    :params mu: 泊松模型的参数值
    :params sign: 系数
    :return: 观测数据的总似然值
    """
    print(" 参数 mu: ", mu)
    """
    方法 stats.poisson.logpmf(y_obs, mu=mu) 计算在给定点 y_obs 值上服从泊松分布(参数值为 mu)的概率对数值,
    然后使用 np.sum 求和得到似然函数值
    """
    return np.sum(sign * stats.poisson.logpmf(y_obs, mu=mu))
 
 
"""
方法 opt.minimize_scalar 通过不断迭代参数(mu), 求出(似然)函数的最小值,
因此在(似然)函数前加上负号(就可以求出(似然)函数的最大值)
https://vimsky.com/examples/usage/python-scipy.optimize.minimize_scalar.html
"""
freq_results = opt.minimize_scalar(poisson_logprob)
print("参数 mu 的估计值: %s" % freq_results['x'])
 

x = np.linspace(1, 60)
y_min = np.min([poisson_logprob(i, sign=1) for i in x])
y_max = np.max([poisson_logprob(i, sign=1) for i in x])
# 根据不同的 mu 值[1,60]，画出数据集的似然函数变化曲线
fig = plt.figure(figsize=(6,4))
plt.plot(x, [poisson_logprob(mu, sign=1) for mu in x])
plt.fill_between(x, [poisson_logprob(mu, sign=1) for mu in x], \
                 y_min,color='#348ABD',alpha=0.3)
# 画出似然函数值最大的红色竖线
plt.vlines(freq_results['x'], y_max, y_min, colors='red', linestyles='dashed')
plt.scatter(freq_results['x'], y_max, s=110, c='red', zorder=3)
plt.ylim(ymin=y_min, ymax=0)
plt.title('Optimization of $\mu$')
plt.xlabel('$\mu$')
plt.ylabel('Log probability of $\mu$ given data')
plt.show()

x_lim = 60
mu = int(freq_results['x'])
for i in np.arange(x_lim):
    plt.bar(i, stats.poisson.pmf(mu, i), color='#348ABD')  # 柱状图
plt.xlim(0, x_lim)
plt.ylim(0, 0.1)
plt.title('Estimated Poisson distribution for QQmessages')  # QQ 消息数量的泊松分布估计
plt.xlabel('Number of QQmessages')  # QQ 消息数量
plt.ylabel('Probability mass')
plt.legend(['$\mu$ = %s' % mu])
plt.show()
 

import numpy as np
import pandas as pd
from sklearn.naive_bayes import BernoulliNB
 
data = np.array([["护士", "打喷嚏", "感冒"], ["农夫", "打喷嚏", "过敏"], ["建筑工人", "头痛", "脑震荡"],
                ["建筑工人", "头痛", "感冒"], ["教师", "打喷嚏", "感冒"], ["教师", "头痛", "脑震荡"]])
df = pd.DataFrame(data, columns=["职业", "症状", "类别"])
df

feature_codes = [{'护士': 0, '农夫': 1, '建筑工人': 2, '教师': 3},
        {'打喷嚏': 0, '头痛': 1},
        {'感冒': 0, '过敏': 1, '脑震荡': 2}]
for i in range(0, len(df.columns)):
    df.iloc[:, i] = df.iloc[:,i].map(feature_codes[i])
df

train_X = df[['职业', '症状']]
train_Y = df['类别']
train_X

test_X = pd.DataFrame(np.array([["2", "0"]]), columns=["职业", "症状"]) # 打喷嚏的建筑工人
test_X

clf = BernoulliNB()
clf.fit(train_X, train_Y)
clf.predict(test_X)

from scipy.stats import norm
 
print(norm.rvs(), end="\n\n")  # 产生一个标准正态分布(均值为 0, 标准差为 1)的随机值
 
print(norm.rvs(size=10), end="\n\n")  # 产生 10 个标准正态分布的随机值
 
print(norm.rvs(loc=10, scale=0.1), end="\n\n")  # 产生一个均值为 10, 标准差为 0.1 的正态分布随机值

from scipy.stats import norm
 
print("P(X < 0.3) = {}".format(norm.cdf(0.3)))
 
print("P(-0.2 < X < 0.2) = {}".format(norm.cdf(0.2) - norm.cdf(-0.2)))

import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt
import matplotlib.style as style
import matplotlib as mpl
from IPython.core.display import HTML
 
# PLOTTING CONFIG 绘图配置
"""
其实%matplotlib inline 这一句是 IPython 的魔法函数，可以在 IPython 编译器里直接使用，作用是内嵌画图，省略掉 plt.show()这一步，直接显示图像。
如果不加这一句的话，我们在画图结束之后需要加上 plt.show()才可以显示图像。
"""
%matplotlib inline
mpl.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
mpl.rcParams['axes.unicode_minus'] = False
style.use('fivethirtyeight')
plt.rcParams["figure.figsize"] = (14, 7)
plt.figure(dpi=100)  # 把分辨率调到 100
 
# PDF 概率密度函数
plt.plot(np.linspace(-4, 4, 100), 
         stats.norm.pdf(np.linspace(-4, 4, 100)) 
         / np.max(stats.norm.pdf(np.linspace(-3, 3, 100))),
        )
plt.fill_between(np.linspace(-4, 4, 100),
                 stats.norm.pdf(np.linspace(-4, 4, 100)) 
                 / np.max(stats.norm.pdf(np.linspace(-3, 3, 100))),
                 alpha=.15,
                )
# CDF 累积分布函数
plt.plot(np.linspace(-4, 4, 100), 
         stats.norm.cdf(np.linspace(-4, 4, 100)),
        )
 
# LEGEND 图例
plt.text(x=-1.5, y=.7, s="pdf (normed)", rotation=65, 
         alpha=.75, weight="bold", color="#008fd5")
plt.text(x=-.4, y=.5, s="cdf", rotation=55, alpha=.75, 
         weight="bold", color="#fc4f30")
 
# TICKS 坐标轴
plt.tick_params(axis = 'both', which = 'major', labelsize = 18)
plt.axhline(y = 0, color = 'black', linewidth = 1.3, alpha = .7)
 
# TITLE 标题
plt.text(x = -5, y = 1.25, s = "正态分布 - 概述",
               fontsize = 26, weight = 'bold', alpha = .75)
plt.text(x = -5, y = 1.1, 
         s = ('下图是归一化的概率密度函数 (pdf)以及正态分布随机变量 $ y \sim \mathcal{N}(\mu,\sigma) $的累计密度函数(cdf),'
              '其中 $ \mu = 0 $ , $ \sigma = 1$.'),
         fontsize = 19, alpha = .85)

# IMPORTS
import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt
import matplotlib.style as style
from IPython.core.display import HTML
 
# PLOTTING CONFIG
%matplotlib inline
style.use('fivethirtyeight')
plt.rcParams["figure.figsize"] = (14, 7)
 
plt.figure(dpi=100)
 
# PDF
# 中 82, 不中 220
plt.plot(np.linspace(0, 1, 500), 
         stats.beta.pdf(np.linspace(0, 1, 500),a=82,b=220),label='a=82,b=220', \
         linewidth=1 
        )
 
# 中 84, 不中 220
plt.plot(np.linspace(0, 1, 500), 
         stats.beta.pdf(np.linspace(0, 1, 500),a=84,b=220),label='a=84,b=220', \
         linewidth=2, linestyle='dashed' 
        )
 
# 中 182, 不中 420
plt.plot(np.linspace(0, 1, 500), 
         stats.beta.pdf(np.linspace(0, 1, 500),a=182,b=420),label='a=182,b=420', \
         linewidth=3 
        )
 
#AXISES LABEL
plt.xlabel('X',size=20)
plt.ylabel('Density of Beta',size=20)
 
# TICKS
plt.tick_params(axis = 'both', which = 'major', labelsize = 18)
plt.xticks(np.linspace(0,1,11))
 
#SHOWING TEXT IN CANVAS
plt.legend()
 
plt.show()

from scipy.stats import norm
 
x1 = norm.ppf(0.1)  # 累计密度函数的反函数
x2 = norm.ppf(0.05)
x1, x2