7802797634

一、什么是贝叶斯推断

贝叶斯推断(Bayesian inference)是一种统计学方法,用来估计统计量的某种性质。

它是贝叶斯定理(Bayes’ theorem)的应用。英国数学家托马斯·贝叶斯(Thomas Bayes)在1763年发表的一篇论文中,首先提出了这个定理。

二、贝叶斯定理

要理解贝叶斯推断,必须先理解贝叶斯定理。后者实际上就是计算”条件概率”的公式。

所谓”条件概率”(Conditional probability),就是指在事件B发生的情况下,事件A发生的概率,用P(A|B)来表示。

根据文氏图,可以很清楚地看到在事件B发生的情况下,事件A发生的概率就是P(A∩B)除以P(B)。

因此,

同理可得,

所以,

即

这就是条件概率的计算公式。

三、全概率公式

由于后面要用到,所以除了条件概率以外,这里还要推导全概率公式。

假定样本空间S,是两个事件A与A’的和。A + A’ = S

上图中,红色部分是事件A,绿色部分是事件A’,它们共同构成了样本空间S。

在这种情况下,事件B可以划分成两个部分。

即

在上一节的推导当中,我们已知

所以,

这就是全概率公式。它的含义是,如果A和A’构成样本空间的一个划分,那么事件B的概率,就等于A和A’的概率分别乘以B对这两个事件的条件概率之和。

将这个公式代入上一节的条件概率公式,就得到了条件概率的另一种写法:

四、贝叶斯推断的含义

对条件概率公式进行变形,可以得到如下形式:

我们把P(A)称为”先验概率”(Prior probability),即在B事件发生之前,我们对A事件概率的一个判断。P(A|B)称为”后验概率”(Posterior probability),即在B事件发生之后,我们对A事件概率的重新评估。P(B|A)/P(B)称为”可能性函数”(Likelyhood),这是一个调整因子,使得预估概率更接近真实概率。

所以,条件概率可以理解成下面的式子:

  后验概率 = 先验概率 x 调整因子

这就是贝叶斯推断的含义。我们先预估一个”先验概率”,然后加入实验结果,看这个实验到底是增强还是削弱了”先验概率”,由此得到更接近事实的”后验概率”。

在这里,如果”可能性函数”P(B|A)/P(B)>1,意味着”先验概率”被增强,事件A的发生的可能性变大;如果”可能性函数”=1,意味着B事件无助于判断事件A的可能性;如果”可能性函数”<1,意味着”先验概率”被削弱,事件A的可能性变小。

五、【例子1】水果糖问题

第一个例子。两个一模一样的碗,一号碗有30颗水果糖和10颗巧克力糖,二号碗有水果糖和巧克力糖各20颗。现在随机选择一个碗,从中摸出一颗糖,发现是水果糖。请问这颗水果糖来自一号碗的概率有多大?

我们假定,H1表示一号碗,H2表示二号碗。由于这两个碗是一样的,也就是说,在取出水果糖之前,这两个碗被选中的概率相同,P(H1)=P(H2)=0.5。我们把P(H1)=0.5这个概率就叫做”先验概率”,即没有做实验之前,来自一号碗的概率是0.5。

再假定,E表示水果糖,所以问题就变成了在已知E的情况下,来自一号碗的概率有多大,即求P(H1|E)。我们把这个概率叫做“后验概率”,即在E事件发生之后,对P(H1)的修正。

根据条件概率公式,得到

已知,P(H1)等于0.5,P(E|H1)为一号碗中取出水果糖的概率,等于0.75,那么求出P(E)就可以得到答案。根据全概率公式,

所以,

将数字代入原方程,得到

这表明,来自一号碗的概率是0.6。也就是说,取出水果糖之后,H1事件的可能性得到了增强。

六、【例子2】假阳性问题

已知某种疾病的发病率是0.001,即1000人中会有1个人得病。现有一种试剂可以检验患者是否得病,它的准确率是0.99,即在患者确实得病的情况下,它有99%的可能呈现阳性。它的误报率是5%,即在患者没有得病的情况下,它有5%的可能呈现阳性。现有一个病人的检验结果为阳性,请问他确实得病的可能性有多大?

假定A事件表示得病,那么P(A)为0.001。这就是“先验概率”,即没有做试验之前,我们预计的发病率。再假定B事件表示阳性,那么要计算的就是P(A|B)。这就是”后验概率”,即做了试验以后,对发病率的估计。

根据条件概率公式,

用全概率公式改写分母,

将数字代入,

我们得到了一个惊人的结果,P(A|B)约等于0.019。也就是说,即使检验呈现阳性,病人得病的概率,也只是从0.1%增加到了2%左右。这就是所谓的”假阳性”,即阳性结果完全不足以说明病人得病。

为什么会这样?为什么这种检验的准确率高达99%,但是可信度却不到2%?答案是与它的误报率太高有关。(【习题】如果误报率从5%降为1%,请问病人得病的概率会变成多少?)

有兴趣的朋友,还可以算一下”假阴性”问题,即检验结果为阴性,但是病人确实得病的概率有多大。然后问自己,”假阳性”和”假阴性”,哪一个才是医学检验的主要风险?

全概率公式、贝叶斯公式推导过程

(1)条件概率公式

设A,B是两个事件,且P(B)>0,则在事件B发生的条件下,事件A发生的条件概率(conditional probability)为:

P(A|B)=P(AB)/P(B)

 

(2)乘法公式

1.由条件概率公式得:

P(AB)=P(A|B)P(B)=P(B|A)P(A)

上式即为乘法公式;

2.乘法公式的推广:对于任何正整数n≥2,当P(A1A2…An-1) > 0 时,有:

P(A1A2…An-1An)=P(A1)P(A2|A1)P(A3|A1A2)…P(An|A1A2…An-1)

 

(3)全概率公式

1. 如果事件组B1,B2,…. 满足

1.B1,B2….两两互斥,即 Bi ∩ Bj = ∅ ,i≠j , i,j=1,2,….,且P(Bi)>0,i=1,2,….;

2.B1∪B2∪….=Ω ,则称事件组 B1,B2,…是样本空间Ω的一个划分

设 B1,B2,…是样本空间Ω的一个划分,A为任一事件,则:

上式即为全概率公式(formula of total probability)

2.全概率公式的意义在于,当直接计算P(A)较为困难,而P(Bi),P(A|Bi)  (i=1,2,…)的计算较为简单时,可以利用全概率公式计算P(A)。思想就是,将事件A分解成几个小事件,通过求小事件的概率,然后相加从而求得事件A的概率,而将事件A进行分割的时候,不是直接对A进行分割,而是先找到样本空间Ω的一个个划分B1,B2,…Bn,这样事件A就被事件AB1,AB2,…ABn分解成了n部分,即A=AB1+AB2+…+ABn, 每一Bi发生都可能导致A发生相应的概率是P(A|Bi),由加法公式得

P(A)=P(AB1)+P(AB2)+….+P(ABn)

=P(A|B1)P(B1)+P(A|B2)P(B2)+…+P(A|Bn)P(PBn)

3.实例:某车间用甲、乙、丙三台机床进行生产,各台机床次品率分别为5%,4%,2%,它们各自的产品分别占总量的25%,35%,40%,将它们的产品混在一起,求任取一个产品是次品的概率。

解:设…..     P(A)=25%*5%+4%*35%+2%*40%=0.0345

 

(4)贝叶斯公式

1.与全概率公式解决的问题相反,贝叶斯公式是建立在条件概率的基础上寻找事件发生的原因(即大事件A已经发生的条件下,分割中的小事件Bi的概率),设B1,B2,…是样本空间Ω的一个划分,则对任一事件A(P(A)>0),有

上式即为贝叶斯公式(Bayes formula),Bi 常被视为导致试验结果A发生的”原因“,P(Bi)(i=1,2,…)表示各种原因发生的可能性大小,故称先验概率;P(Bi|A)(i=1,2…)则反映当试验产生了结果A之后,再对各种原因概率的新认识,故称后验概率。

2.实例:发报台分别以概率0.6和0.4发出信号“∪”和“—”。由于通信系统受到干扰,当发出信号“∪”时,收报台分别以概率0.8和0.2受到信号“∪”和“—”;又当发出信号“—”时,收报台分别以概率0.9和0.1收到信号“—”和“∪”。求当收报台收到信号“∪”时,发报台确系发出“∪”的概率。

解:设…., P(B1|A)= (0.6*0.8)/(0.6*0.8+0.4*0.1)=0.923

sklearn的快速使用

传统的机器学习任务从开始到建模的一般流程是:获取数据 -> 数据预处理 -> 训练建模 -> 模型评估 -> 预测,分类。本文我们将依据传统机器学习的流程,看看在每一步流程中都有哪些常用的函数以及它们的用法是怎么样的。希望你看完这篇文章可以最为快速的开始你的学习任务。

1. 获取数据

1.1 导入sklearn数据集

sklearn中包含了大量的优质的数据集,在你学习机器学习的过程中,你可以通过使用这些数据集实现出不同的模型,从而提高你的动手实践能力,同时这个过程也可以加深你对理论知识的理解和把握。(这一步我也亟需加强,一起加油!^-^)

首先呢,要想使用sklearn中的数据集,必须导入datasets模块:

from sklearn import datasets

下图中包含了大部分sklearn中数据集,调用方式也在图中给出,这里我们拿iris的数据来举个例子:

 

iris = datasets.load_iris() # 导入数据集
X = iris.data # 获得其特征向量
y = iris.target # 获得样本label

1.2 创建数据集

你除了可以使用sklearn自带的数据集,还可以自己去创建训练样本,具体用法参见《Dataset loading utilities》,这里我们简单介绍一些,sklearn中的samples generator包含的大量创建样本数据的方法:

 

下面我们拿分类问题的样本生成器举例子:

from sklearn.datasets.samples_generator import make_classification

X, y = make_classification(n_samples=6, n_features=5, n_informative=2, 
    n_redundant=2, n_classes=2, n_clusters_per_class=2, scale=1.0, 
    random_state=20)

# n_samples:指定样本数
# n_features:指定特征数
# n_classes:指定几分类
# random_state:随机种子,使得随机状可重
>>> for x_,y_ in zip(X,y):
    print(y_,end=': ')
    print(x_)

    
0: [-0.6600737  -0.0558978   0.82286793  1.1003977  -0.93493796]
1: [ 0.4113583   0.06249216 -0.90760075 -1.41296696  2.059838  ]
1: [ 1.52452016 -0.01867812  0.20900899  1.34422289 -1.61299022]
0: [-1.25725859  0.02347952 -0.28764782 -1.32091378 -0.88549315]
0: [-3.28323172  0.03899168 -0.43251277 -2.86249859 -1.10457948]
1: [ 1.68841011  0.06754955 -1.02805579 -0.83132182  0.93286635]

2. 数据预处理

数据预处理阶段是机器学习中不可缺少的一环,它会使得数据更加有效的被模型或者评估器识别。下面我们来看一下sklearn中有哪些平时我们常用的函数:

from sklearn import preprocessing

2.1 数据归一化

为了使得训练数据的标准化规则与测试数据的标准化规则同步,preprocessing中提供了很多Scaler:

data = [[0, 0], [0, 0], [1, 1], [1, 1]]
# 1. 基于mean和std的标准化
scaler = preprocessing.StandardScaler().fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)

# 2. 将每个特征值归一化到一个固定范围
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)
#feature_range: 定义归一化范围,注用()括起来

2.2 正则化(normalize)

当你想要计算两个样本的相似度时必不可少的一个操作,就是正则化。其思想是:首先求出样本的p-范数,然后该样本的所有元素都要除以该范数,这样最终使得每个样本的范数都为1。

>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')

>>> X_normalized                                      
array([[ 0.40..., -0.40...,  0.81...],
       [ 1.  ...,  0.  ...,  0.  ...],
       [ 0.  ...,  0.70..., -0.70...]])

 2.3 one-hot编码

one-hot编码是一种对离散特征值的编码方式,在LR模型中常用到,用于给线性模型增加非线性能力。

data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
encoder = preprocessing.OneHotEncoder().fit(data)
enc.transform(data).toarray()

3. 数据集拆分

在得到训练数据集时,通常我们经常会把训练数据集进一步拆分成训练集和验证集,这样有助于我们模型参数的选取。

# 作用:将数据集划分为 训练集和测试集
# 格式:train_test_split(*arrays, **options)
from sklearn.mode_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
"""
参数
---
arrays:样本数组,包含特征向量和标签

test_size:
  float-获得多大比重的测试样本 (默认:0.25)
  int - 获得多少个测试样本

train_size: 同test_size

random_state:
  int - 随机种子(种子固定,实验可复现)
  
shuffle - 是否在分割之前对数据进行洗牌(默认True)

返回
---
分割后的列表,长度=2*len(arrays), 
  (train-test split)
"""

4. 定义模型

在这一步我们首先要分析自己数据的类型,搞清出你要用什么模型来做,然后我们就可以在sklearn中定义模型了。sklearn为所有模型提供了非常相似的接口,这样使得我们可以更加快速的熟悉所有模型的用法。在这之前我们先来看看模型的常用属性和功能:

# 拟合模型
model.fit(X_train, y_train)
# 模型预测
model.predict(X_test)

# 获得这个模型的参数
model.get_params()
# 为模型进行打分
model.score(data_X, data_y) # 线性回归:R square; 分类问题: acc

 4.1 线性回归

from sklearn.linear_model import LinearRegression
# 定义线性回归模型
model = LinearRegression(fit_intercept=True, normalize=False, 
    copy_X=True, n_jobs=1)
"""
参数
---
    fit_intercept:是否计算截距。False-模型没有截距
    normalize: 当fit_intercept设置为False时,该参数将被忽略。 如果为真,则回归前的回归系数X将通过减去平均值并除以l2-范数而归一化。
     n_jobs:指定线程数
"""
 

 

 4.2 逻辑回归LR

from sklearn.linear_model import LogisticRegression
# 定义逻辑回归模型
model = LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, 
    fit_intercept=True, intercept_scaling=1, class_weight=None, 
    random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, 
    verbose=0, warm_start=False, n_jobs=1)

"""参数
---
    penalty:使用指定正则化项(默认:l2)
    dual: n_samples > n_features取False(默认)
    C:正则化强度的反,值越小正则化强度越大
    n_jobs: 指定线程数
    random_state:随机数生成器
    fit_intercept: 是否需要常量
"""

 4.3 朴素贝叶斯算法NB

from sklearn import naive_bayes
model = naive_bayes.GaussianNB() # 高斯贝叶斯
model = naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
model = naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)
"""
文本分类问题常用MultinomialNB
参数
---
    alpha:平滑参数
    fit_prior:是否要学习类的先验概率;false-使用统一的先验概率
    class_prior: 是否指定类的先验概率;若指定则不能根据参数调整
    binarize: 二值化的阈值,若为None,则假设输入由二进制向量组成
"""

 4.4 决策树DT

from sklearn import tree 
model = tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None, 
    min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, 
    max_features=None, random_state=None, max_leaf_nodes=None, 
    min_impurity_decrease=0.0, min_impurity_split=None,
     class_weight=None, presort=False)
"""参数
---
    criterion :特征选择准则gini/entropy
    max_depth:树的最大深度,None-尽量下分
    min_samples_split:分裂内部节点,所需要的最小样本树
    min_samples_leaf:叶子节点所需要的最小样本数
    max_features: 寻找最优分割点时的最大特征数
    max_leaf_nodes:优先增长到最大叶子节点数
    min_impurity_decrease:如果这种分离导致杂质的减少大于或等于这个值,则节点将被拆分。
"""

4.5 支持向量机SVM

from sklearn.svm import SVC
model = SVC(C=1.0, kernel=’rbf’, gamma=’auto’)
"""参数
---
    C:误差项的惩罚参数C
    gamma: 核相关系数。浮点数,If gamma is ‘auto’ then 1/n_features will be used instead.
"""

 4.6 k近邻算法KNN

from sklearn import neighbors
#定义kNN分类模型
model = neighbors.KNeighborsClassifier(n_neighbors=5, n_jobs=1) # 分类
model = neighbors.KNeighborsRegressor(n_neighbors=5, n_jobs=1) # 回归
"""参数
---
    n_neighbors: 使用邻居的数目
    n_jobs:并行任务数
"""

4.7 多层感知机(神经网络)

from sklearn.neural_network import MLPClassifier
# 定义多层感知机分类算法
model = MLPClassifier(activation='relu', solver='adam', alpha=0.0001)
"""参数
---
    hidden_layer_sizes: 元祖
    activation:激活函数
    solver :优化算法{‘lbfgs’, ‘sgd’, ‘adam’}
    alpha:L2惩罚(正则化项)参数。
"""

5. 模型评估与选择篇

5.1 交叉验证

from sklearn.model_selection import cross_val_score
cross_val_score(model, X, y=None, scoring=None, cv=None, n_jobs=1)
"""参数
---
    model:拟合数据的模型
    cv : k-fold
    scoring: 打分参数-‘accuracy’、‘f1’、‘precision’、‘recall’ 、‘roc_auc’、'neg_log_loss'等等
"""

5.2 检验曲线

使用检验曲线,我们可以更加方便的改变模型参数,获取模型表现。

from sklearn.model_selection import validation_curve
train_score, test_score = validation_curve(model, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=1)
"""参数
---
    model:用于fit和predict的对象
    X, y: 训练集的特征和标签
    param_name:将被改变的参数的名字
    param_range: 参数的改变范围
    cv:k-fold
   
返回值
---
   train_score: 训练集得分(array)
    test_score: 验证集得分(array)
"""

例子

6. 保存模型

最后,我们可以将我们训练好的model保存到本地,或者放到线上供用户使用,那么如何保存训练好的model呢?主要有下面两种方式:

6.1 保存为pickle文件

 
from sklearn.externals import joblib

# 保存模型
joblib.dump(model, 'model.pickle')

#载入模型
model = joblib.load('model.pickle')

hepatorrhea

matplotlib

Matplotlib 是Python 2D绘图领域的基础套件,它让使用者将数据图形化,并提供多样化的输出格式。这里将会以四个小案例探索Matplotlib的常见用法

绘制折线图

import matplotlib.pyplot as plt
import random
# 保证生成的图片在浏览器内显示
%matplotlib inline
# 保证能正常显示中文(Mac)
plt.rcParams['font.family'] = ['Arial Unicode MS']

# 模拟海南一天的温度变化

# 生成x轴的24小时
hainan_x = [h for h in range(0, 24)]

# 生成y轴的温度随机值(15, 25)
hainan_y = [random.randint(15, 25) for t in range(0, 24)]

# 设置画板属性
plt.figure(figsize = (10, 8), dpi = 100)

# 往画板绘图
plt.plot(hainan_x, hainan_y, label="海南")

# 模拟北京一天内温度的变化

# 生成x轴的24小时
beijing_x = [h for h in range(0, 24)]

# 生成y轴的温度随机值(5, 10)
beijing_y = [random.randint(5, 10) for t in range(0, 24)]

# 往画板绘图
plt.plot(beijing_x, beijing_y, label="北京")


# 模拟河北一天内温度的变化
hebei_x = beijing_x
hebei_y = [random.randint(1, 5) for t in range(0, 24)]
# 自定义绘制属性: 颜色color="#0c8ac5", linestyle"-"""--""-.":", 线宽linewidth, 透明度alpha
plt.plot(hebei_x, hebei_y, label="河北",color="#823384", linestyle=":", linewidth=3, alpha=0.3)


# 坐标轴显示设置



# 生成24小时的描述
x_ = [x_ for x_ in range(0, 24)]
x_desc = ["{}时".format(x_desc) for x_desc in x_]

# 设置x轴显示 24小时
plt.xticks(x_, x_desc)

# 生成10至30度的描述
y_ = [y_ for y_ in range(0, 30)][::2]
y_desc = ["{}℃".format(y_desc) for y_desc in y_]


# 设置y轴显示温度描述
plt.yticks(y_, y_desc)

# 指定x y轴的名称
plt.xlabel("时间")
plt.ylabel("温度")

# 指定标题
plt.title("一天内温度的变化")

# 显示图例
plt.legend(loc="best")
 
# 将数据生成图片, 保存到当前目录下
plt.savefig("./t.png")
# 在浏览器内展示图片
plt.show()

绘制条形图

名侦探柯南主要人物年龄
import matplotlib.pyplot as plt
import random
# 保证生成的图片在浏览器内显示
%matplotlib inline
# 保证能正常显示中文(Mac)
plt.rcParams['font.family'] = ['Arial Unicode MS']

# 条形图绘制名侦探柯南主要角色年龄
role_list = ["柯南", "毛利兰", "灰原哀", "琴酒","贝尔摩德", "伏特加", "赤井秀一", "目暮十三"]
role_age = [7, 17, 7, 34, 32, 30, 27, 46]
# 实际年龄
role_ture_age = [18, 17, 18, 34, 45, 30, 27, 46]

x = [i for i in range(1, len(role_list)+1)]

y = role_age
y2 =role_ture_age

# 设置画板属性
plt.figure(figsize = (15, 8), dpi = 100)

# width以x为基准,向右为正,向左为负(如果多了,就需要为基准x加减响应的数值)
plt.bar(x, y, width= -0.3, label="现实年龄", color="#509839")
plt.bar(x, y2, width = 0.3, label="实际年龄", color="#c03035")

x_ = [i for i in range(0, len(role_list)+1)]
x_desc = ["{}".format(x_desc) for x_desc in role_list]
x_desc.insert(0, "")

y_ = range(0, 50)[::5]
y_desc = ["{}岁".format(y_desc) for y_desc in range(0, 50)][::5]

# x轴的数值和描述
plt.xticks(x_, x_desc)
plt.yticks(y_, y_desc)

plt.xlabel("角色姓名")
plt.ylabel("年龄")
plt.title("名侦探柯南主要角色年龄(部分)")
plt.legend(loc="best")
plt.savefig("./mzt.png")
plt.show()

直方图

IMDB
import matplotlib.pyplot as plt
import random

# 保证能正常显示中文
plt.rcParams['font.family'] = ['Arial Unicode MS']

# 时长数据
time = [131,  98, 125, 131, 124, 139, 131, 117, 128, 108, 135, 138, 131, 102, 107, 114, 119, 128, 121, 142, 127, 130, 124, 101, 110, 116, 117, 110, 128, 128, 115,  99, 136, 126, 134,  95, 138, 117, 111,78, 132, 124, 113, 150, 110, 117,  86,  95, 144, 105, 126, 130,126, 130, 126, 116, 123, 106, 112, 138, 123,  86, 101,  99, 136,123, 117, 119, 105, 137, 123, 128, 125, 104, 109, 134, 125, 127,105, 120, 107, 129, 116, 108, 132, 103, 136, 118, 102, 120, 114,105, 115, 132, 145, 119, 121, 112, 139, 125, 138, 109, 132, 134,156, 106, 117, 127, 144, 139, 139, 119, 140,  83, 110, 102,123,107, 143, 115, 136, 118, 139, 123, 112, 118, 125, 109, 119, 133,112, 114, 122, 109, 106, 123, 116, 131, 127, 115, 118, 112, 135,115, 146, 137, 116, 103, 144,  83, 123, 111, 110, 111, 100, 154,136, 100, 118, 119, 133, 134, 106, 129, 126, 110, 111, 109, 141,120, 117, 106, 149, 122, 122, 110, 118, 127, 121, 114, 125, 126,114, 140, 103, 130, 141, 117, 106, 114, 121, 114, 133, 137,  92,121, 112, 146,  97, 137, 105,  98, 117, 112,  81,  97, 139, 113,134, 106, 144, 110, 137, 137, 111, 104, 117, 100, 111, 101, 110,105, 129, 137, 112, 120, 113, 133, 112,  83,  94, 146, 133, 101,131, 116, 111,  84, 137, 115, 122, 106, 144, 109, 123, 116, 111,111, 133, 150]
max_time = max(time)
min_time = min(time)
# 指定分组宽度
width = 5
# 指定分组数量
num_bins = int((max_time - min_time)/2)
# 直方图统计电影时长频数
plt.figure(figsize=(15, 8), dpi=80)

# 绘制直方图
plt.hist(time, num_bins, color="#509839",normed=1)

# 指定显示刻度的个数 
x_ = [i for i in range(min_time, max_time+1)]
plt.xticks(x_[::width])

# 显示网格
plt.grid(True, linestyle="--", alpha=0.5)

# 指定标题
plt.title("Top250的IMDB电影时长统计")
plt.savefig("./IMDB.png")
plt.show()

饼图

pro_learn
import matplotlib.pyplot as plt
import random

# 保证能正常显示中文(Mac)
plt.rcParams['font.family'] = ['Arial Unicode MS']

# 学习时间分配
pro_name = ["C++", "Python", "Java", "Go", "Swift"]
pro_time = [10, 15, 5, 3, 1]

# 画饼
plt.pie(pro_time, labels=pro_name, autopct="%3.2f%%", colors=["#ea6f5a", "#509839", "#0c8ac5", "#d29922", "#fdf6e3"])

# 指定标题
plt.title("学习时间分配")

# 保证为图形为正圆
plt.axis("equal")

# 显示图示
plt.legend(loc="best")
plt.savefig("./pro_learn.png")
plt.show()

 

numpy快速入门

NumPy(Numerical Python)是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。

ndarrayç±»

NumPy中的数组类被称为ndarray,要注意的是numpy.array与Python标准库中的array.array是不同的。ndarray具有如下比较重要的属性:

ndarray.ndim

ndarray.ndim表示数组的维度。

ndarray.shape

ndarray.shape是一个整型tuple,用来表示数组中的每个维度的大小。例如,对于一个n行和m列的矩阵,其shape为(n,m)。

ndarray.size

ndarray.size表示数组中元素的个数,其值等于shape中所有整数的乘积。

ndarray.dtype

ndarray.dtype用来描述数组中元素的类型,ndarray中的所有元素都必须是同一种类型,如果在构造数组时,传入的参数不是同一类型的,不同的类型将进行统一转化。除了标准的Python类型外,NumPy额外提供了一些自有的类型,如numpy.int32、numpy.int16以及numpy.float64等。

ndarray.itemsize

ndarray.itemsize用于表示数组中每个元素的字节大小。

代码示例:
>>> import numpy as np
>>> a = np.arange(15).reshape(3,5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.dtype
dtype('int64')
>>> a.size
15
>>> a.itemsize
8
>>> type(a)
<class 'numpy.ndarray'>
>>> 
>>> b = np.array([1,2,3,4,5,6,7,8,9])
>>> b
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> c = np.array([1,2,3,4,5,6,'7','a','b'])
>>> c
array(['1', '2', '3', '4', '5', '6', '7', 'a', 'b'], dtype='<U21')
>>> type(b)
<class 'numpy.ndarray'>
>>> type(c)
<class 'numpy.ndarray'>
>>> c.dtype
dtype('<U21')
>>> b.dtype
dtype('int64')
>>> c.itemsize
84
>>> b.itemsize
8

数组创建

NumPy中创建数组的方式有若干种。最简单的,可以直接利用Python中常规的list和tuple进行创建。

>>> import numpy as np
>>> a = np.array([1,2,3,4,5,6])
>>> b = np.array((1,2,3,4,5,6))
>>> a
array([1, 2, 3, 4, 5, 6])
>>> b
array([1, 2, 3, 4, 5, 6])

这里需要注意传入的参数,下面的第一种方式是错误的:

>>> a = np.array(1,2,3,4)    # WRONG
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: only 2 non-keyword arguments accepted
>>> a = np.array([1,2,3,4])  # RIGHT

另外,传入的参数必须是同一结构,不是同一结构将发生转换。

>>> import numpy as np
>>> a = np.array([1,2,3.5])
>>> a
array([1. , 2. , 3.5])
>>> b = np.array([1,2,3])
>>> b
array([1, 2, 3])
>>> c = np.array(['1',2,3])
>>> c
array(['1', '2', '3'], dtype='<U1')
>>> 

另外,array还可以将序列的序列转换成二位数组,可以将序列的序列的序列转换成三维数组,以此类推。

>>> import numpy as np
>>> a = np.array([[1,2,3],[2,3,4]])
>>> a
array([[1, 2, 3],
       [2, 3, 4]])
>>> b = np.array([[1,2,3],[2,3,4],[3,4,5]])
>>> b
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])
>>> 

另外,创建数组的时候,可以明确的规定数组的类型。

>>> c = np.array([1,2,3], dtype = complex)
>>> c
array([1.+0.j, 2.+0.j, 3.+0.j])
>>> d = np.array([[1,2,3],[4,5,6]], dtype = '<U1')
>>> d
array([['1', '2', '3'],
       ['4', '5', '6']], dtype='<U1')
>>> 

另外,NumPy还提供了便捷地创建特定数组的方式。

>>> import numpy as np
>>> a = np.zeros((3,4))
>>> a
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
>>> b = np.zeros((2,2,2))
>>> b
array([[[0., 0.],
        [0., 0.]],

       [[0., 0.],
        [0., 0.]]])
>>> c = np.ones((3,3))
>>> c
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])
>>> d = np.ones((3,3), dtype = np.int16)
>>> d
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]], dtype=int16)
>>> e = np.arange(15)
>>> e
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])
>>> f = np.arange(15).reshape(3,5)
>>> f
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> g = np.arange(0,15,3)
>>> g
array([ 0,  3,  6,  9, 12])
>>> h = np.arange(0,3,0.3)
>>> h
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7])

>>> from numpy import pi
>>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
>>> f = np.sin(x)

基本操作

对数组中的算术操作是元素对应(elementwise)的,例如,对两个数组进行加减乘除,其结果是对两个数组对一个位置上的数进行加减乘除,数组算术操作的结果会存放在一个新建的数组中。

>>> import numpy as np
>>> a = np.array([10,20,30,40])
>>> b = np.arange(4)
>>> a
array([10, 20, 30, 40])
>>> b
array([0, 1, 2, 3])
>>> c = a - b
>>> c
array([10, 19, 28, 37])
>>> a
array([10, 20, 30, 40])
>>> b
array([0, 1, 2, 3])
>>> b**2
array([0, 1, 4, 9])
>>> b
array([0, 1, 2, 3])
>>> a<35
array([ True,  True,  True, False])
>>> a
array([10, 20, 30, 40])

在NumPy中,*用于数组间元素对应的乘法,而不是矩阵乘法,矩阵乘法可以用dot()方法来实现。

>>> A = np.array([[1,2],[3,4]])
>>> B = np.array([[0,1],[0,1]])
>>> A
array([[1, 2],
       [3, 4]])
>>> B
array([[0, 1],
       [0, 1]])
>>> A*B                    # elementwise product
array([[0, 2],
       [0, 4]])
>>> A.dot(B)               # matrix product
array([[0, 3],
       [0, 7]])
>>> np.dot(A,B)            # another matrix product
array([[0, 3],
       [0, 7]])

有些操作,如*=,+=,-=,/=等操作,会直接改变需要操作的数组,而不是创建一个新的数组。

>>> a = np.ones((2,3), dtype = int)
>>> a
array([[1, 1, 1],
       [1, 1, 1]])
>>> b = np.random.random((2,3))
>>> b
array([[0.27020018, 0.16904478, 0.29618462],
       [0.45432616, 0.99311013, 0.56769309]])
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> b += 3
>>> b
array([[3.27020018, 3.16904478, 3.29618462],
       [3.45432616, 3.99311013, 3.56769309]])
>>> b += a
>>> b
array([[6.27020018, 6.16904478, 6.29618462],
       [6.45432616, 6.99311013, 6.56769309]])
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> a += b              # b is not automatically converted to integer type
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
>>> 

当操作不同类型的数组时,最终的结果数组的类型取决于精度最宽的数组的类型。(即所谓的向上造型)

>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1.        ,  2.57079633,  4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
       -0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'

ndarray类实现了许多操作数组的一元方法,如求和、求最大值、求最小值等。

>>> a = np.random.random((2,3))
>>> a
array([[0.62181697, 0.26165654, 0.34994938],
       [0.95619296, 0.24614291, 0.42120462]])
>>> a.sum()
2.8569633678947346
>>> a.min()
0.24614290611891454
>>> a.max()
0.9561929625193091
>>> 

除了上述一元方法以外,NumPy还提供了操作数组中特定行和列的一元方法,通过制定不同的axis来实现。

>>> b = np.arange(12).reshape(3,4)
>>> b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> b.sum(axis = 0)                   # sum of each column
array([12, 15, 18, 21])
>>> b.sum(axis = 1)                   # sum of each row
array([ 6, 22, 38])
>>> b.min(axis = 0)                   # min of each column
array([0, 1, 2, 3])
>>> b.min(axis = 1)                   # min of each row
array([0, 4, 8])
>>> b.max(axis = 0)                   # max of each column
array([ 8,  9, 10, 11])
>>> b.max(axis = 1)                   # max of each row
array([ 3,  7, 11])
>>> b.cumsum(axis = 1)                # cumulative sum along each row
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]])
>>> b.cumsum(axis = 0)                # cumulative sum along each column
array([[ 0,  1,  2,  3],
       [ 4,  6,  8, 10],
       [12, 15, 18, 21]])
>>> 

通用方法

NumPy提供了大量的通用数学和算术方法,比如常见的sin、cos、具体可以参考如下:

all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where

>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1.        ,  2.71828183,  7.3890561 ])
>>> np.sqrt(B)
array([ 0.        ,  1.        ,  1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2.,  0.,  6.])

数组索引和迭代

与Python中定义的list一样,NumPy支持一维数组的索引、切片和迭代。

>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[3]
27
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1111
>>> a
array([-1111,     1, -1111,    27, -1111,   125,   216,   343,   512,
         729])
>>> a[::-1]
array([  729,   512,   343,   216,   125, -1111,    27, -1111,     1,
       -1111])

多维数组与一维数组相似,其在每个轴上都有一个对应的索引(index),这些索引是在一个逗号分隔的元组(tuple)中给出的。

>>> b = np.arange(15).reshape(3,5)
>>> b
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> b[2,3]
13
>>> b[3,3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index 3 is out of bounds for axis 0 with size 3
>>> b[0,0]
0
>>> b[0,4]
4
>>> 
>>> 
>>> b[:, 1]
array([ 1,  6, 11])
>>> b[1, :]
array([5, 6, 7, 8, 9])
>>> b[-1]
array([10, 11, 12, 13, 14])
>>> b.shape
(3, 5)

这里需要注意的是,数组的第一个索引是从0开始的。一维数组和多维数组的迭代,可以参考如下示例:

>>> for row in b:
...     print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]

>>> for element in b.flat:
...     print(element)
...
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43

其中flat属性是array中的每个元素的迭代器。

shape操作

1. 改变数组的shape

Numpy中数组shape由每个轴上元素的个数决定的。例如:

>>> import numpy as np
>>> a = np.ones((3,4), dtype = int)
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> a.shape
(3, 4)

NumPy中数组的shape是可以通过多种方式进行改变的,下面展示三种改变数组shape而不改变当前数组的方法,这三种方法返回一个特定shape的数组,但是并不改变原来的数组:

>>> import numpy as np
>>> a = np.ones((3,4), dtype = int)
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> a.ravel()
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> b = a.ravel()
>>> b
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> c = a.reshape(2,-1)
>>> c
array([[1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1]])
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> a.T
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])
>>> a
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> d = a.T
>>> d
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])
>>> a.shape
(3, 4)
>>> b.shape
(12,)
>>> c.shape
(2, 6)
>>> d.shape
(4, 3)

除此之外,NumPy还提供了可以直接修改原始数组shape的方法——resize()。resize()方法和reshape()方法的最主要区别在于,reshape()方法返回一个特定shape的数组,而resize()方法会直接更改原数组。

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a.resize(2,6)
>>> a
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])
2. 数组堆叠和切片

NumPy支持将多个数据按照不同的轴进行堆叠:

>>> a = np.floor(10*np.random.random((2,2)))
>>> a
array([[0., 8.],
       [4., 8.]])
>>> b = np.floor(10*np.random.random((2,2)))
>>> b
array([[1., 4.],
       [4., 1.]])
>>> np.vstack((a,b))
array([[0., 8.],
       [4., 8.],
       [1., 4.],
       [4., 1.]])
>>> np.hstack((a,b))
array([[0., 8., 1., 4.],
       [4., 8., 4., 1.]])

hstack()实现数组横向堆叠,vstack()实现数组纵向堆叠。

>>> from numpy import newaxis
>>> np.column_stack((a,b))
array([[4, 2],
       [2, 8]])
>>> a[:, newaxis]
array([[4],
       [2]])
>>> np.column_stack((a[:,newaxis],b[:,newaxis]))
array([[4, 2],
       [2, 8]])
>>> np.vstack((a[:,newaxis],b[:,newaxis]))
array([[4],
       [2],
       [2],
       [8]])

>>> np.r_[1:4,0,4]
array([1, 2, 3, 0, 4])

除了支持数组的横向和纵向堆叠之外,NumPy还支持数组的横向和纵向分割,示例如下:

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> np.split(a,3)
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
>>> np.h
np.half(         np.hanning(      np.histogram(    np.histogramdd(  np.hstack(       
np.hamming(      np.heaviside(    np.histogram2d(  np.hsplit(       np.hypot(        
>>> np.hsplit(a,4)
[array([[0],
       [4],
       [8]]), array([[1],
       [5],
       [9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]
>>> np.vsplit(a,3)
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
>>> 

其中,split()方法默认为横线分割。

复制和视图

NumPy中,数组的复制有三种方式:

  1. Python通用的地址复制:通过 b = a 复制 a 的值,b 与 a 指向同一地址,改变 b 同时也改变 a。
  2. 通过视图ndarray.view()仅复制值,当对 c 值进行改变会改变 a 的对应的值,而改变 c 的 shape 不改变 a 的 shape。
  3. ndarray.copy() 进行的完整的拷贝,产生一份完全相同的独立的复制。
>>> a = np.arange(12)
>>> a
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> b = a
>>> print(a is b)
True
>>> 
>>> 
>>> c = a.view()
>>> c
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> print(a is c)
False
>>> c.shape = 2,6
>>> c
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])
>>> c[0,0] = 111
>>> c
array([[111,   1,   2,   3,   4,   5],
       [  6,   7,   8,   9,  10,  11]])
>>> a
array([111,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11])
>>> 
>>> 
>>> d = a.copy()
>>> print(a is d)
False
>>> d.shape = 2,6
>>> d
array([[111,   1,   2,   3,   4,   5],
       [  6,   7,   8,   9,  10,  11]])
>>> a
array([111,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11])
>>> d[0,0] = 999
>>> d
array([[ 999,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])
>>> a
array([111,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11])
>>> 

NumPy功能和方法预览

数组创建

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r, zeros, zeros_like

数组转换

ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat

操作

array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

问题

all, any, nonzero, where

排列

argmax, argmin, argsort, max, min, ptp, searchsorted, sort

运算

choose, compress, cumprod, cumsum, inner, ndarray.fill, imag, prod, put, putmask, real, sum

基础统计

cov, mean, std, var

基本线性代数

cross, dot, outer, linalg.svd, vdot

。

317-801-1912

关键缩写和包导入

在这个速查手册中,我们使用如下缩写:

df:任意的Pandas DataFrame对象
s:任意的Pandas Series对象

同时我们需要做如下的引入:

import pandas as pd
import numpy as np

导入数据

  • pd.read_csv(filename):从CSV文件导入数据
  • pd.read_table(filename):从限定分隔符的文本文件导入数据
  • pd.read_excel(filename):从Excel文件导入数据
  • pd.read_sql(query, connection_object):从SQL表/库导入数据
  • pd.read_json(json_string):从JSON格式的字符串导入数据
  • pd.read_html(url):解析URL、字符串或者HTML文件,抽取其中的tables表格
  • pd.read_clipboard():从你的粘贴板获取内容,并传给read_table()
  • pd.DataFrame(dict):从字典对象导入数据,Key是列名,Value是数据

导出数据

  • df.to_csv(filename):导出数据到CSV文件
  • df.to_excel(filename):导出数据到Excel文件
  • df.to_sql(table_name, connection_object):导出数据到SQL表
  • df.to_json(filename):以Json格式导出数据到文本文件

创建测试对象

  • pd.DataFrame(np.random.rand(20,5)):创建20行5列的随机数组成的DataFrame对象
  • pd.Series(my_list):从可迭代对象my_list创建一个Series对象
  • df.index = pd.date_range(‘1900/1/30’, periods=df.shape[0]):增加一个日期索引

查看、检查数据

  • df.head(n):查看DataFrame对象的前n行
  • df.tail(n):查看DataFrame对象的最后n行
  • df.shape():查看行数和列数
  • df.info():查看索引、数据类型和内存信息
  • df.describe():查看数值型列的汇总统计
  • s.value_counts(dropna=False):查看Series对象的唯一值和计数
  • df.apply(pd.Series.value_counts):查看DataFrame对象中每一列的唯一值和计数

数据选取

  • df[col]:根据列名,并以Series的形式返回列
  • df[[col1, col2]]:以DataFrame形式返回多列
  • s.iloc[0]:按位置选取数据
  • s.loc[‘index_one’]:按索引选取数据
  • df.iloc[0,:]:返回第一行
  • df.iloc[0,0]:返回第一列的第一个元素

数据清理

  • df.columns = [‘a’,’b’,’c’]:重命名列名
  • pd.isnull():检查DataFrame对象中的空值,并返回一个Boolean数组
  • pd.notnull():检查DataFrame对象中的非空值,并返回一个Boolean数组
  • df.dropna():删除所有包含空值的行
  • df.dropna(axis=1):删除所有包含空值的列
  • df.dropna(axis=1,thresh=n):删除所有小于n个非空值的行
  • df.fillna(x):用x替换DataFrame对象中所有的空值
  • s.astype(float):将Series中的数据类型更改为float类型
  • s.replace(1,’one’):用‘one’代替所有等于1的值
  • s.replace([1,3],[‘one’,’three’]):用’one’代替1,用’three’代替3
  • df.rename(columns=lambda x: x + 1):批量更改列名
  • df.rename(columns={‘old_name’: ‘new_ name’}):选择性更改列名
  • df.set_index(‘column_one’):更改索引列
  • df.rename(index=lambda x: x + 1):批量重命名索引

数据处理:Filter、Sort和GroupBy

  • df[df[col] > 0.5]:选择col列的值大于0.5的行
  • df.sort_values(col1):按照列col1排序数据,默认升序排列
  • df.sort_values(col2, ascending=False):按照列col1降序排列数据
  • df.sort_values([col1,col2], ascending=[True,False]):先按列col1升序排列,后按col2降序排列数据
  • df.groupby(col):返回一个按列col进行分组的Groupby对象
  • df.groupby([col1,col2]):返回一个按多列进行分组的Groupby对象
  • df.groupby(col1)[col2]:返回按列col1进行分组后,列col2的均值
  • df.pivot_table(index=col1, values=[col2,col3], aggfunc=max):创建一个按列col1进行分组,并计算col2和col3的最大值的数据透视表
  • df.groupby(col1).agg(np.mean):返回按列col1分组的所有列的均值
  • data.apply(np.mean):对DataFrame中的每一列应用函数np.mean
  • data.apply(np.max,axis=1):对DataFrame中的每一行应用函数np.max

数据合并

  • df1.append(df2):将df2中的行添加到df1的尾部
  • df.concat([df1, df2],axis=1):将df2中的列添加到df1的尾部
  • df1.join(df2,on=col1,how=’inner’):对df1的列和df2的列执行SQL形式的join

数据统计

  • df.describe():查看数据值列的汇总统计
  • df.mean():返回所有列的均值
  • df.corr():返回列与列之间的相关系数
  • df.count():返回每一列中的非空值的个数
  • df.max():返回每一列的最大值
  • df.min():返回每一列的最小值
  • df.median():返回每一列的中位数
  • df.std():返回每一列的标准差

(405) 681-1587

1.准备 LAMP 环境
LAMP 是 Linux、Apache、MySQL 和 PHP 的缩写,是 WordPress 系统依赖的基础运行环境。我们先来准备 LAMP 环境:
(由于部分服务安装过程中展示需要,建议您将下方终端部分的高度通过拖拽方式调高一点)
安装 Apache2
在终端输入该命令 ,使用 apt-get 安装 Apache2:
sudo apt-get install apache2 -y

安装 PHP 组件
apt-get 里有 php7.0 ,所以我们可以直接安装 php7.0 :
sudo apt-get install php7.0 -y
安装 php 相关组件:
sudo apt-get install libapache2-mod-php7.0

安装 MySQL 服务
安装 MySQL 过程中,控制台会提示您输入 MySQL 的密码,您需要输入两次密码,并记住您输入的密码,后续步骤需要用到:
sudo apt-get install mysql-server -y
安装 php MySQL相关组件:
sudo apt-get install php7.0-mysql


安装 phpmyadmin
使用 apt-get 安装 phpmyadmin,安装过程中,您需要根据提示选择 apache2 ,再输入root密码 和数据库密码:
sudo apt-get install phpmyadmin -y
建立 /var/www/html 下的软连接:
sudo ln -s /usr/share/phpmyadmin /var/www/html/phpmyadmin
重启 MySQL 服务
sudo service mysql restart
重启 Apache 服务:
sudo systemctl restart apache2.service

 

2.安装并配置 WordPress
安装 WordPress
我们需要下载一个 WordPress 压缩包:
wget /cn.wordpress.org/wordpress-4.8.1-zh_CN.tar.gz
下载完成后,解压这个压缩包
tar zxf wordpress-4.8.1-zh_CN.tar.gz
解压完后,就能在 WordPress 文件夹里看到 WordPress 的源码了

为 wordpress 配置一个数据库
进入 mysql,输入以下代码后,按提示输入您MySQL密码:
mysql -u root -p
为 wordpress 创建一个叫 wordpress 的数据库:
CREATE DATABASE wordpress;
为 这个数据库设置一个用户为 wordpressuser:
CREATE USER wordpressuser;
为这个用户配置一个密码为 password123:  (修改下面password123即可以修改你的密码)
SET PASSWORD FOR wordpressuser= PASSWORD(“password123”);
为这个用户配置数据库的访问权限:
GRANT ALL PRIVILEGES ON wordpress.* TO wordpressuser IDENTIFIED BY”password123″;
生效这些配置
FLUSH PRIVILEGES;
然后退出 mysql
exit;


配置 wordpress
由于PHP默认访问 /var/www/html/ 文件夹,所以我们需要把 wordpress 文件夹里的文件都复制到 /var/www/html/ 文件夹
sudo mv wordpress/* /var/www/html/
修改一下 /var/www/html/ 目录权限:
sudo chmod -R 777 /var/www/html/
将apache指定到index.html
sudo mv /var/www/html/index.html /var/www/html/index~.html
重启 Apache 服务:
sudo systemctl restart apache2.service