第一周 Python环境配置与数据处理
文章目录
1 矩阵运算
1.1 NumPy简介
NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。
NumPy(Numerical Python) 是科学计算基础库，提供大量科学计算相关功能，比如数据 统计，随机数生成等。其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组 与矩阵运算，Numpy 支持向量处理 ndarray 对象，提高程序运算速度。
1.2 NumPy操作
使用NumPy，开发人员可以执行以下操作：
-
数组的算数和逻辑运算。
-
傅立叶变换和用于图形操作的例程。
-
与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。
1.3 NumPy练习
导入相关库
# ! pip install numpy
# ! pip install pandas
# ! pip install matplotlib
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
%matplotlib inline
查看版本
np.__version__
'1.24.2'
- 创建一个长度为10的一维全为0的ndarray对象，然后让第5个元素等于1
s1 = np.zeros(shape=10)
s1
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
- 创建一个元素为从10到49的ndarray对象
np.random.randint(10, 50, size=10)
array([12, 30, 41, 26, 46, 20, 30, 23, 31, 26])
np.linspace(10, 49, 10)
array([10. , 14.33333333, 18.66666667, 23. , 27.33333333,
31.66666667, 36. , 40.33333333, 44.66666667, 49. ])
a = np.arange(10, 50)
a
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49])
- 将第2题的所有元素位置反转
a[::-1]
array([49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
15, 14, 13, 12, 11, 10])
- 使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素
a4 = np.random.random(size=(10,10))
a4
array([[0.01526119, 0.69212902, 0.35879764, 0.8239509 , 0.31220377,
0.54510431, 0.36689184, 0.94074923, 0.2475156 , 0.3076519 ],
[0.60810075, 0.99662242, 0.0254494 , 0.03305689, 0.53328887,
0.01880315, 0.25911847, 0.34594219, 0.54366849, 0.51715659],
[0.57794582, 0.3647596 , 0.87800382, 0.32973267, 0.81217461,
0.23678119, 0.34331877, 0.53793056, 0.77735558, 0.9918691 ],
[0.35326427, 0.93030897, 0.85058753, 0.82652364, 0.20476774,
0.21307409, 0.87638441, 0.68164326, 0.44943155, 0.11775033],
[0.8772758 , 0.17764787, 0.8301284 , 0.70338716, 0.84614739,
0.74073933, 0.56463795, 0.4565219 , 0.16274116, 0.44795188],
[0.8776156 , 0.87691803, 0.19911984, 0.49571451, 0.80946595,
0.75036879, 0.92157137, 0.14450135, 0.9873476 , 0.86180973],
[0.90041318, 0.60206028, 0.00647357, 0.92229729, 0.63743449,
0.51149359, 0.53360766, 0.50223843, 0.45014074, 0.52722903],
[0.80473606, 0.90439616, 0.50962543, 0.07326534, 0.32992097,
0.53373273, 0.54502907, 0.88935823, 0.88672426, 0.87128563],
[0.15113523, 0.21433752, 0.49552134, 0.00468275, 0.03367613,
0.15089374, 0.09762623, 0.99802318, 0.43707507, 0.60874524],
[0.47442501, 0.43180401, 0.01051482, 0.11242477, 0.67646364,
0.31486135, 0.56175425, 0.44720385, 0.32572487, 0.32067582]])
zmin, zmax = a4.min(), a4.max()
zmin, zmax
(0.004682749712346501, 0.9980231768845362)
- 创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0
nd = np.zeros(shape = (10,10), dtype=np.int8)
nd[[0,9]] = 1
nd[:, [0,9]] = 1
nd
array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], dtype=int8)
a5 = np.ones((10,10))
a5
array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
a5[1:-1, 1:-1] = 0
a5
array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
- 创建一个每一行都是从0到4的5*5矩阵
l = [0,1,2,3,4]
nd = np.array(l*5)
nd.reshape(5,5)
array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
nd6_1 = np.arange(0,5,1)
nd6_1
array([0, 1, 2, 3, 4])
nd6 = np.arange(0,25).reshape(5,5)
nd6
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
- 创建一个范围在(0,1)之间的长度为12的等差数列
np.linspace(0,1,12)
array([0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
0.90909091, 1. ])
- 创建一个长度为10的随机数组并排序
a8 = np.random.random(10)
a8
array([0.25583254, 0.10454712, 0.68691678, 0.0367394 , 0.26233731,
0.875376 , 0.93943219, 0.40984092, 0.50752613, 0.94099902])
np.sort(a8)
array([0.0367394 , 0.10454712, 0.25583254, 0.26233731, 0.40984092,
0.50752613, 0.68691678, 0.875376 , 0.93943219, 0.94099902])
a8.argsort()
array([3, 1, 0, 4, 7, 8, 2, 5, 6, 9], dtype=int64)
a8[a8.argsort()]
array([0.0367394 , 0.10454712, 0.25583254, 0.26233731, 0.40984092,
0.50752613, 0.68691678, 0.875376 , 0.93943219, 0.94099902])
- 创建一个长度为10的随机数组并将最大值替换为0
nd = np.random.randint(0,10,size=10)
display(nd)
index_max = nd.argmax()
array([8, 3, 4, 7, 5, 6, 4, 2, 0, 7])
nd[index_max]
8
all_index_max = np.argwhere(nd == nd[index_max]).reshape(-1)
all_index_max
array([0], dtype=int64)
nd[all_index_max] = -100
nd
array([-100, 3, 4, 7, 5, 6, 4, 2, 0, 7])
- 如何根据第3列来对一个5*5矩阵排序？
n10 = np.random.randint(0,100,size=(5,5))
n10
array([[51, 66, 96, 11, 87],
[96, 67, 56, 5, 32],
[10, 39, 9, 48, 62],
[37, 62, 92, 52, 66],
[76, 24, 80, 81, 58]])
n10 = np.random.randint(0,100,size=(5,5))
n10
array([[36, 96, 8, 18, 95],
[74, 42, 35, 67, 38],
[45, 72, 97, 17, 36],
[91, 40, 44, 56, 88],
[ 3, 36, 20, 43, 41]])
n10[:,2]
array([ 8, 35, 97, 44, 20])
np.argsort(n10[:,2])
array([0, 4, 1, 3, 2], dtype=int64)
n10[np.argsort(n10[:,2])]
array([[36, 96, 8, 18, 95],
[ 3, 36, 20, 43, 41],
[74, 42, 35, 67, 38],
[91, 40, 44, 56, 88],
[45, 72, 97, 17, 36]])
- 给定一个4维矩阵，如何得到最后两维的和？
n11 = np.random.randint(0,100,size=(2,3,3,3))
n11
array([[[[94, 56, 77],
[82, 57, 66],
[14, 33, 56]],
[[64, 50, 41],
[23, 32, 48],
[17, 28, 39]],
[[78, 12, 8],
[45, 43, 35],
[24, 95, 20]]],
[[[50, 7, 61],
[41, 60, 71],
[97, 39, 66]],
[[11, 57, 34],
[62, 69, 8],
[34, 81, 0]],
[[97, 94, 72],
[85, 12, 5],
[76, 9, 63]]]])
n11.sum(axis=(2,3))
array([[535, 342, 360],
[492, 356, 513]])
n11.sum(axis=(-1,-2))
array([[535, 342, 360],
[492, 356, 513]])
- 给定数组[1, 2, 3, 4, 5]，如何得到在这个数组的每个元素之间插入3个0后的新数组？
nd1 = np.arange(1,6)
nd2 = np.zeros(shape=17, dtype=int)
nd2[::4] = nd1
nd2
array([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5])
n12 = np.array([1,2,3,4,5]).reshape(5,1)
n12
array([[1],
[2],
[3],
[4],
[5]])
n12_1 = np.zeros((5,3))
n12_1
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
n12 = np.concatenate([n12,n12_1],axis=1)
n12
array([[1., 0., 0., 0.],
[2., 0., 0., 0.],
[3., 0., 0., 0.],
[4., 0., 0., 0.],
[5., 0., 0., 0.]])
n12.reshape(-1)
array([1., 0., 0., 0., 2., 0., 0., 0., 3., 0., 0., 0., 4., 0., 0., 0., 5.,
0., 0., 0.])
- 给定一个二维矩阵，如何交换其中两行的元素？
n13 = np.random.randint(0,100,size=(3,3))
n13
array([[14, 78, 24],
[ 4, 9, 80],
[97, 47, 82]])
n13[[1,0,2]]
array([[ 4, 9, 80],
[14, 78, 24],
[97, 47, 82]])
- 创建一个100000长度的随机数组，使用两种方法对其求三次方，并比较所用时间
n14 = np.random.random(size=1000000)
n14
array([0.02418255, 0.40608648, 0.51057477, ..., 0.54587694, 0.84541225,
0.9119286 ])
n14 = np.random.randint(0,1000000,(5))
n14
array([292518, 189051, 514431, 575466, 548272])
%timeit np.power(n14,3)
1.42 µs ± 100 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
%timeit n14**3
1.38 µs ± 36.2 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
n14_2 = np.dot(n14,n14)
%timeit np.dot(n14_2, n14)
2.64 µs ± 124 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
观察得知最后一种方式所用时间最短
扫描二维码关注公众号，回复： 15421912 查看本文章
- 创建一个53随机矩阵和一个32随机矩阵，求矩阵积
n15_53 = np.random.randint(0,100,size=(5,3))
n15_53
array([[10, 14, 67],
[92, 85, 64],
[82, 96, 72],
[66, 85, 88],
[27, 35, 53]])
n15_32 = np.random.randint(0,100,(3,2))
n15_32
array([[15, 6],
[72, 25],
[83, 79]])
np.dot(n15_53, n15_32)
array([[ 6719, 5703],
[12812, 7733],
[14118, 8580],
[14414, 9473],
[ 7324, 5224]])
2 Pandas库
Pandas，python+data+analysis的组合缩写，是python中基于numpy和matplotlib的第三方数据分析库，与后两者共同构成了python数据分析的基础工具包，享有数分三剑客之名。
正因为pandas是在numpy基础上实现，其核心数据结构与numpy的ndarray十分相似，但pandas与numpy的关系不是替代，而是互为补充。pandas就数据处理上比numpy更加强大和智能，而numpy比pandas更加基础和强大。
Pandas的导入也很简单，语法如下：
import pandas as pd
2.1 数据结构
Pandas核心数据结构有两种，即一维的series和二维的dataframe，就像excel中的列和表的关系。下面就这两种数据结构展开更加详细的介绍。
2.1.1 Series
Series，一维数组。可以取任意行的数据、可以取指定行的数据、还可以修改相应的数据，这在Series中也可以实现，对应的分别是Series的切片、索引和修改。
- 创建
# 导入Pandas库
import pandas as pd
# 构建Series，其中index和name是可选项
series = pd.Series([1,2,"da"],index=["a","b","c"],name="ss")
series
a 1
b 2
c da
Name: ss, dtype: object
- 切片、修改
# 切片
series[:2]
# 索引
series["a"]
# 修改值
series["a"] = 6
series[1] = 88
series
a 6
b 88
c da
Name: ss, dtype: object
- 其他属性
# Series的属性：dtype, index, values, name
series.dtype
series.index
series.values
series.name
'ss'
2.1.2 DataFrame
DataFrame，二维数组，也可以说是表。
- 创建
# 导入Pandas库
import pandas as pd
# 构建DataFrame，其中index、dtype和columns是可选项,
dataFrame = pd.DataFrame([[1,2,3],[4,5,6]],index=["a","b"],columns=["第一列","第二列","第三列"])
dataFrame
| 第一列 | 第二列 | 第三列 | |
|---|---|---|---|
| a | 1 | 2 | 3 |
| b | 4 | 5 | 6 |
- 切片
dataFrame[0:1]
| 第一列 | 第二列 | 第三列 | |
|---|---|---|---|
| a | 1 | 2 | 3 |
dataFrame.loc['a']
第一列 1
第二列 2
第三列 3
Name: a, dtype: int64
dataFrame.loc[::,"第一列"]
a 1
b 4
Name: 第一列, dtype: int64
dataFrame.loc["a","第一列"]
1
dataFrame.iloc[:1]
| 第一列 | 第二列 | 第三列 | |
|---|---|---|---|
| a | 1 | 2 | 3 |
dataFrame.iloc[::,1]
a 2
b 5
Name: 第二列, dtype: int64
dataFrame.iloc[1,1]
5
- 增加、修改
# 新增列
dataFrame["新增列"] = 6
# 新增行
dataFrame.loc["c"] = [55,88,99,66]
dataFrame
| 第一列 | 第二列 | 第三列 | 新增列 | |
|---|---|---|---|---|
| a | 1 | 2 | 3 | 6 |
| b | 4 | 5 | 6 | 6 |
| c | 55 | 88 | 99 | 66 |
# 另外，append也可以增加，但是它增加的索引是默认值，而且之前的index会变列
dataFrame.append([55])
D:\TempFIles\ipykernel_16568\130454973.py:2: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.
dataFrame.append([55])
| 第一列 | 第二列 | 第三列 | 新增列 | 0 | |
|---|---|---|---|---|---|
| a | 1.0 | 2.0 | 3.0 | 6.0 | NaN |
| b | 4.0 | 5.0 | 6.0 | 6.0 | NaN |
| c | 55.0 | 88.0 | 99.0 | 66.0 | NaN |
| 0 | NaN | NaN | NaN | NaN | 55.0 |
- 删除
# 删除可以分好几种，下面一一介绍
# 删除行
dataFrame.drop(index="c",inplace=True)
# 删除列,注意这里的0是列名哦
dataFrame.drop(columns=0,inplace=True)
# 删除nan值,参数axis指定删除行还是列，0代表行，1代表列
# how指定是有一个旧删除，还是所有都为nan值菜删除，可选值'any', 'all'
# thresh阈值，指定行或者列超过指定的个数旧删除
# inplace是否在源数据删除，True代表是，False代表否
dataFrame.dropna(inplace=True)
# 删除重复值
# 参数subset: 指定去重依据，多条件用[]括起来
# keep: 保留第一个还是最后一个，默认第一个，可选值first、last
# inplace:是否在源数据删除
dataFrame.drop_duplicates()
- 查看
# 查看数据可以对数据有个大体的认知
# 前N行,不写参数N，则是前五行
dataFrame.head(N)
# 后N行,不写参数N，则是后五行
dataFrame.tail(N)
# 总体信息,包括索引，各列类型，整体数据类型，内存大小等信息
dataFrame.info()
2.2 读写数据
Pandas支持了非常丰富的文件类型，也就是说，它可以读取和保存多种类型的数据，比如：excel文件、csv文件、或者json文件、sql文件，甚至html文件等，这对我们获取数据很方便，这里挑常用的几个讲解，其他基本大同小异，注意特殊参数就行，读者自行查阅。
2.2.1 读数据
- excel文件
pd.read_excel()
参数详解：
io:文件路劲，可以是相对路径，可以是绝对路径
sheet_name：excel存在多个sheet的情况，所以可以指定sheet名（列1，列2…）或者指定第几个（0，1，2…），默认第一个。
usecols：提取特定的列，可以是列名，也可以是列号，[]括起来
header:以数据的第几行做标题行，和后面的参数skiprows 很像，都能是跳过几行
dtype:指定读取到的数据格式
skiprows :跳过几行，和header类似
- csv文件
excel虽然是使用做多的数据格式，但是由于excel存在诸多问题，如：数据加载慢、多sheet问题，没法保存大数据（excel单个表只能100w多一点），所以csv就显得优秀很多，上述问题都不存在。
pd.read_csv()
读取时的参数很多都是一样的，所以不再赘述，只讲解不一样的参数。
和Excel不同参数详解：
sep：csv文件并不是表格格式，所以要指定分隔符，默认是逗号，有事还可能是”\t“
encoding：csv文件不像excel只有一种编码，所以使用时有时候需要指定编码格式。utf8或者gb2312等
- sql文件
pd.read_sql(sql, con)
参数详解：
sql:sql语句，比如"select * from test"
con:链接数据库的信息，包括ip、user、密码、数据库等
2.2.2 写数据
对于写文件，重要参数几乎一样，这里只使用excel做演示：
dataFrame.to_excel("输出.xlsx",index=False,sheet_name="1")
参数说明：
excel_writer:保存文件路径，不写绝对路径则保存在当前目录下。注意文件后缀（必须）
sheet_name：保存excel文件中sheet的名字（excel特有）
index：是否输出索引列，一般不输出（通用）
encoding：指定输出文件编码（通用）
startrow/startcol：输出文件在excel文件第几行几列开始(excel特有）
sep：输出的csv文件以什么分割，默认逗号（csv特有）
2.3 数据处理、分析
2.3.1 基础操作
利用Pandas进行数据分析，基础操作就是Data Frame的各种操作，这里不再赘述。
2.3.2 分组聚合
- 分组聚合(groupby函数)
常用参数：
by：指定的分组依据，多个的时候用[]括起来
axis：聚合方向，默认对列聚合，可选值0（纵向，默认）和1（横向）
level：当聚合依据是索引时使用，默认None
- 透视和透视提取
上面讲到的分组聚合和Excel中的透视表很像，但是又不能对列和行一起做透视，那有没有和Excel中的透视表功能一样的功能呢，当然是有的，那就是pandas中的pivot_table。
2.3.3 数据拼接、合并
- concat
concat函数参数：
objs：需要合并的数据
axis：合并方向，可以横向拼接，也可以纵向拼接
join：合并方式，类似内联外联，默认外联，不一样的nan补充
- merge
merge函数和sql中的内外联一致，可以实现左联、右联、内联和外联。
merge函数详解
left:数据1right：数据2
how: 连接方式，可选inner（默认），outer，left，right
on：用来连接的列，使用on时，数据1和数据2用来连接的列名要相同，不相同时用下面参数
left_on：单独指定左边表的连接列,
right_on：单独指定右边表的连接列,
left_index: 是否使用左边表的索引连接，默认False
right_index: 是否使用右边表的索引连接，默认False
3 数据可视化
Matplotlib 是Python中类似 MATLAB 的绘图工具
3.1 线
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(224)
x = np.linspace(0, np.pi)
y_sin = np.sin(x)
y_cos = np.cos(x)
ax1.plot(x, y_sin)
ax2.plot(x, y_sin, 'go--', linewidth=2, markersize=12)
ax3.plot(x, y_cos, color='red', marker='+', linestyle='dashed')
[<matplotlib.lines.Line2D at 0x2eae8013760>]
在上面的三个Axes上作画。plot，前面两个参数为x轴、y轴数据。ax2的第三个参数是 MATLAB风格的绘图，对应ax3上的颜色，marker，线型。
另外，我们可以通过关键字参数的方式绘图，如下例：
x = np.linspace(0, 10, 200)
data_obj = {
'x': x,
'y1': 2 * x + 1,
'y2': 3 * x + 1.2,
'mean': 0.5 * x * np.cos(2*x) + 2.5 * x + 1.1}
fig, ax = plt.subplots()
#填充两条线之间的颜色
ax.fill_between('x', 'y1', 'y2', color='yellow', data=data_obj)
# Plot the "centerline" with `plot`
ax.plot('x', 'mean', color='black', data=data_obj)
plt.show()
发现上面的作图，在数据部分只传入了字符串，这些字符串对一个这 data_obj 中的关键字，当以这种方式作画时，将会在传入给 data 中寻找对应关键字的数据来绘图。
3.2 散点图
x = np.arange(10)
y = np.random.randn(10)
plt.scatter(x, y, color='red', marker='+')
plt.show()
3.3 条形图
条形图分两种，一种是水平的，一种是垂直的，见下例子：
np.random.seed(1)
x = np.arange(5)
y = np.random.randn(5)
fig, axes = plt.subplots(ncols=2, figsize=plt.figaspect(1./2))
vert_bars = axes[0].bar(x, y, color='lightblue', align='center')
horiz_bars = axes[1].barh(x, y, color='lightblue', align='center')
#在水平或者垂直方向上画线
axes[0].axhline(0, color='gray', linewidth=2)
axes[1].axvline(0, color='gray', linewidth=2)
plt.show()
条形图还返回了一个Artists 数组，对应着每个条形，例如上图 Artists 数组的大小为5，我们可以通过这些 Artists 对条形图的样式进行更改，如下例：
fig, ax = plt.subplots()
vert_bars = ax.bar(x, y, color='lightblue', align='center')
# We could have also done this with two separate calls to `ax.bar` and numpy boolean indexing.
for bar, height in zip(vert_bars, y):
if height < 0:
bar.set(edgecolor='darkred', color='salmon', linewidth=3)
plt.show()
3.4 直方图
直方图用于统计数据出现的次数或者频率，有多种参数可以调整，见下例：
np.random.seed(19680801)
n_bins = 10
x = np.random.randn(1000, 3)
fig, axes = plt.subplots(nrows=2, ncols=2)
ax0, ax1, ax2, ax3 = axes.flatten()
colors = ['red', 'tan', 'lime']
ax0.hist(x, n_bins, density=True, histtype='bar', color=colors, label=colors)
ax0.legend(prop={
'size': 10})
ax0.set_title('bars with legend')
ax1.hist(x, n_bins, density=True, histtype='barstacked')
ax1.set_title('stacked bar')
ax2.hist(x, histtype='barstacked', rwidth=0.9)
ax3.hist(x[:, 0], rwidth=0.9)
ax3.set_title('different sample sizes')
fig.tight_layout()
plt.show()
参数中density控制Y轴是概率还是数量，与返回的第一个的变量对应。histtype控制着直方图的样式，默认是 ‘bar’，对于多个条形时就相邻的方式呈现如子图1， ‘barstacked’ 就是叠在一起，如子图2、3。 rwidth 控制着宽度，这样可以空出一些间隙，比较图2、3. 图4是只有一条数据时。
3.5 饼图
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
fig1, (ax1, ax2) = plt.subplots(2)
ax1.pie(sizes, labels=labels, autopct='%1.1f%%', shadow=True)
ax1.axis('equal')
ax2.pie(sizes, autopct='%1.2f%%', shadow=True, startangle=90, explode=explode,
pctdistance=1.12)
ax2.axis('equal')
ax2.legend(labels=labels, loc='upper right')
plt.show()
饼图自动根据数据的百分比画饼.。labels是各个块的标签，如子图一。autopct=%1.1f%%表示格式化百分比精确输出，explode，突出某些块，不同的值突出的效果不一样。pctdistance=1.12百分比距离圆心的距离，默认是0.6.
3.6 泡泡图
散点图的一种，加入了第三个值 s 可以理解成普通散点，画的是二维，泡泡图体现了Z的大小，如下例：
np.random.seed(19680801)
N = 50
x = np.random.rand(N)
y = np.random.rand(N)
colors = np.random.rand(N)
area = (30 * np.random.rand(N))**2 # 0 to 15 point radii
plt.scatter(x, y, s=area, c=colors, alpha=0.5)
plt.show()
4 图灵测试
图灵测试一词来源于计算机科学和密码学的先驱阿兰·麦席森·图灵写于1950年的一篇论文《计算机器与智能》。阿兰·麦席森·图灵1950年设计出这个测试，其内容是，如果电脑能在5分钟内回答由人类测试者提出的一系列问题，且其超过30%的回答让测试者误认为是人类所答，则电脑通过测试。
4.1 简要介绍
图灵测试是测试人在与被测试者(一个人和一台机器)隔开的情况下，通过一些装置（如键盘）向被测试者随意提问。问过一些问题后，如果被测试者超过30%的答复不能使测试人确认出哪个是人、哪个是机器的回答，那么这台机器就通过了测试，并被认为具有人类智能。图灵测试 2014 的举办方英国雷丁大学发布新闻稿，宣称俄罗斯人弗拉基米尔·维西罗夫（Vladimir Veselov）创立的人工智能软件尤金·古斯特曼（Eugene Goostman）通过了图灵测试。如果这一结论获得确认，那么这将是人工智能乃至于计算机史上的一个里程碑事件。
4.2 产生背景
1950年，图灵来到曼彻斯特大学任教，同时还担任该大学自动计算机项目的负责人。就在这一年的十月，他又发表了另一篇题为《机器能思考吗？》的论文，成为划时代之作。也正是这篇文章，为图灵赢得了一顶桂冠——“人工智能之父”。在这篇论文里，图灵第一次提出“机器思维”的概念。他逐条反驳了机器不能思维的论调，做出了肯定的回答。他还对智能问题从行为主义的角度给出了定义，由此提出一假想：即一个人在不接触对方的情况下，通过一种特殊的方式，和对方进行一系列的问答，如果在相当长时间内，他无法根据这些问题判断对方是人还是计算机，那么，就可以认为这个计算机具有同人相当的智力，即这台计算机是能思维的。这就是著名的“图灵测试”(Turing Testing)。当时全世界只有几台电脑，其他几乎所有计算机根本无法通过这一测试。但图灵预言，在20世纪末，一定会有电脑通过“图灵测试”。目前为止还没有电脑通过图灵测试。美国科学家兼慈善家休·勒布纳20世纪90年代初设立人工智能年度比赛,把图灵的设想付诸实践.比赛分为金、银、铜三等奖。
要分辨一个想法是“自创”的思想还是精心设计的“模仿”是非常难的，任何自创思想的证据都可以被否决。图灵试图解决长久以来关于如何定义思考的哲学争论，他提出一个虽然主观但可操作的标准：如果一台电脑表现（act）、反应（react）和互相作用（interact）都和有意识的个体一样，那么它就应该被认为是有意识的。消除人类心中的偏见，图灵设计了一种“模仿游戏”即图灵测试：远处的人类测试者在一段规定的时间内，根据两个实体对他提出的各种问题的反应来判断是人类还是电脑。通过一系列这样的测试，从电脑被误判断为人的几率就可以测出电脑智能的成功程度。
图灵预言，到2000年将会出现足够好的电脑，能够在不超过7成人的长达5分钟的提问中全部回答正确。成功通过图灵测试的电脑还没有，但已有电脑在测试中“骗”过了测试者。最终将会出现能够骗过大多数人的电脑吗？前几年IBM公司研制的计算机“深蓝”与国际象棋世界冠军卡斯帕罗夫进行的那场人机大战，最终以“深蓝”战胜卡斯帕罗夫而宣告结束，让我们不得不佩服图灵的天才预言。
现代计算机之父冯·诺依曼[iv]生前曾多次谦虚地说：如果不考虑查尔斯·巴贝奇[v]等人早先提出的有关思想，现代计算机的概念当属于阿兰·图灵。冯·诺依曼能把“计算机之父”的桂冠戴在比自己小10岁的图灵头上，足见图灵对计算机科学影响之巨大。
5 总结
通过本次作业，复习了python的相关知识点，同时学习了解了numpy、pandas、matplotlib三个库。
使用了新的代码练习工具——Jupyter Notebook，Jupyter Notebook是以网页的形式打开，可以在网页页面中直接编写代码和运行代码，代码的运行结果也会直接在代码块下显示。如在编程过程中需要编写说明文档，可在同一个页面中直接编写，便于作及时的说明和解释。