您的位置：首页 > 编程语言 > Python开发

飞桨学院-Python从小白逆袭大神-Day3-《青春有你2》选手数据分析

2020-05-07 04:24 183 查看

文章目录

引言
Numpy库
数组创建
数组的计算
数组的索引与切片

pandas库

Series
DataFrame

PLE库

相关使用的函数

Matplotlib库

基本使用

作业

引言

第三天的培训主要讲了和数据挖掘和深度学习领域有关的四剑客：Numpy、pandas、Matplotlib、PIL库。由于课程时间有限，人美心善代码6的文姐姐只给我们讲了这些库的常见用法，小编觉得吧，要想深入这个领域还是要靠自己自学这些库，多使用，熟能生巧嘛，哈哈哈。下面的小编将分别介绍这四个库。

Numpy库

numpy是Python科学计算库的基础。包含了强大的N维数组对象和向量运算

中文文档官网：https://www.numpy.org.cn/

数组创建

可以使用array函数从常规Python列表或元组中创建数组。得到的数组的类型是从Python列表中元素的类型推导出来的。

创建数组最简单的办法就是使用array函数。它接受一切序列型的对象（包括其他数组），然后产生一个新的含有传入数据的numpy数组。其中，嵌套序列（比如由一组等长列表组成的列表）将会被转换为一个多维数组

import numpy as np

#将列表转换为数组
array = np.array([[1,2,3],
[4,5,6]])
print(array)

==> [[1 2 3]
[4 5 6]]

import numpy as np

#将列表转换为数组
array = np.array(((1,2,3),
(4,5,6)))
print(array)

==> [[1 2 3]
[4 5 6]]

我们必须从数组和元组中创建矩阵。

此外NumPy提供了几个函数来创建具有初始占位符内容的数组。

```
zeros():
```
可以创建指定长度或者形状的全0数组
```
ones():
```
可以创建指定长度或者形状的全1数组
```
empty():
```
创建一个数组，其初始内容是随机的,取决于内存的状态

emptyarray = np.zeros((2,3))
print(emptyarray)

==> [[0. 0. 0.]
[0. 0. 0.]]

#dtype = 'int64'代表了是整型
emptyarray = np.ones((3,4), dtype='int64')
print(emptyarray)

==>[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]

emptyarray = np.empty((3,4))
print(emptyarray)

==>[[6.23042070e-307 1.42417221e-306 1.37961641e-306 1.27945651e-307]
[1.24610383e-306 1.69118108e-306 8.06632139e-308 1.20160711e-306]
[1.69119330e-306 1.29062229e-306 1.60217812e-306 1.37961370e-306]]

为了创建数字组成的数组，NumPy提供了一个类似于

range()

的函数，该函数返回数组而不是列表。
np.arange([start, ]stop, [step, ]dtype=None)

start:可忽略不写，默认从0开始;起始值
stop:结束值；生成的元素不包括结束值
step:可忽略不写，默认步长为1；步长
dtype:默认为None，设置显示元素的数据类型

array = np.arange( 10, 31, 5 )
print(array)

==> [10,15,20,25,30]

输出数组的一些信息，如维度、形状、元素个数、元素类型等

array = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(array)
#数组维度
print(array.ndim)
#数组形状
print(array.shape)
#数组元素个数
print(array.size)
#数组元素类型
print(array.dtype)

==>[[ 1  2  3]
[ 4  5  6]
[ 7  8  9]
[10 11 12]]  #数组的内容
2 #维度
(4,3) #形状
int32 #类型

重新定义数字的形状

array1 = np.arange(6).reshape([2,3])
print(array1)

==>[[0 1 2]
[3 4 5]]

array2 = np.array([[1,2,3],[4,5,6]],dtype=np.int64).reshape([3,2])
print(array2)

==>[[1 2]
[3 4]
[5 6]]

数组的计算

数组很重要，因为它可以使我们不用编写循环即可对数据执行批量运算。这通常叫做

矢量化（vectorization）

。

大小相等的数组之间的任何算术运算都会将运算应用到元素级。同样，数组与标量的算术运算也会将那个标量值传播到各个元素

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.ones([2,3],dtype=np.int64)

print(arr1 + arr2)
print(arr1 - arr2)
print(arr1 * arr2)
print(arr1 / arr2)
print(arr1 ** 2)

==>[[2 3 4]
[5 6 7]]
[[0 1 2]
[3 4 5]]
[[1 2 3]
[4 5 6]]
[[1. 2. 3.]
[4. 5. 6.]]
[[ 1  4  9]
[16 25 36]]

矩阵乘法：
运用

np.dot()

方法进行矩阵运算

arr3 = np.array([[1,2,3],[4,5,6]])
arr4 = np.ones([3,2],dtype=np.int64)
print(arr3)
print(arr4)
print(np.dot(arr3,arr4))

==>[[1 2 3]
[4 5 6]]
[[1 1]
[1 1]
[1 1]]
[[ 6  6]
[15 15]]

矩阵的其他计算：

print(arr3)
print(np.sum(arr3,axis=1)) #axis=1,每一行求和 axie=0,每一列求和
print(np.max(arr3)) #求元素最大值
print(np.min(arr3)) #求元素最小值
print(np.mean(arr3)) #求所有元素的平均值
print(np.argmax(arr3)) #返回数组中最大值的索引
print(np.argmin(arr3)) #返回数组中最小值的索引

arr3_tran = arr3.transpose()  #矩阵转置
print(arr3_tran)
print(arr3.flatten())  #降维处理

==> [[1 2 3]
[4 5 6]]
[ 6 15]
6
1
3.5
5
0
[[1 4]
[2 5]
[3 6]]
[1 2 3 4 5 6]

这里特别说一下，对于不懂flatten()函数的点这里Python中flatten( )函数及函数用法详解

数组的索引与切片

arr5 = np.arange(0,6).reshape([2,3])
print(arr5)
print(arr5[1]) #输出数组第一行元素
print(arr5[1][2]) #输出第一行第二列的元素
print(arr5[1,2])  #输出第一行第二列的元素
print(arr5[1,:])  #输出数组第一行元素
print(arr5[:,1])  #输出数组第一列元素
print(arr5[1,0:2])  #输出数组第一行第0到1列元素

==>[[0 1 2]
[3 4 5]]
[3 4 5]
5
5
[3 4 5]
[1 4]
[3 4]

pandas库

pandas是python第三方库，提供高性能易用数据类型和分析工具。pandas基于numpy实现，常与numpy和matplotlib一同使用
pandas库。

第三方库安装：pip install pandas
导入库：import pandas as pd
pandas中文网：https://www.pypandas.cn/

Series

Series是一种类似于一维数组的对象，它由

一维数组

（各种numpy数据类型）以及

一组与之相关的数据标签（即索引）

组成。可理解为带标签的一维数组，可存储

整数

、

浮点数

、

字符串

、

Python 对象

等类型的数据。Seris中可以使用index设置索引列表，与字典不同的是，Seris允许索引重复

import pandas as pd
import numpy as np

s = pd.Series(['a','b','c','d','e'])
print(s)
==>0    a
1    b
2    c
3    d
4    e

#与字典不同的是：Series允许索引重复
s = pd.Series(['a','b','c','d','e'],index=[100,200,100,400,500])
print(s)
==> 100    a
200    b
100    c
400    d
500    e
#Series可以用字典实例化
d = {'b': 1, 'a': 0, 'c': 2}
pd.Series(d)
==> b    1
a    0
c    2
print(s.values)
print(s.index)
==> ['a' 'b' 'c' 'd' 'e']
Int64Index([100, 200, 100, 400, 500], dtype='int64')

#与普通numpy数组相比，可以通过索引的方式选取Series中的单个或一组值
print(s[100])
print(s[[400, 500]])
==> 100    a
100    c
dtype: object
400    d
500    e
dtype: object

s = pd.Series(np.array([1,2,3,4,5]), index=['a', 'b', 'c', 'd', 'e'])
print(s)
#对应元素求和
print(s+s)
#对应元素乘
print(s*3)
==> a    1
b    2
c    3
d    4
e    5
dtype: int32

a     2
b     4
c     6
d     8
e    10
dtype: int32

a     3
b     6
c     9
d    12
e    15
dtype: int32

Series中最重要的一个功能是：它会在算术运算中自动对齐不同索引的数据

Series 和多维数组的主要区别在于， Series 之间的操作会自动基于标签对齐数据。因此，不用顾及执行计算操作的 Series 是否有相同的标签

obj1 = pd.Series({"Ohio": 35000, "Oregon": 16000, "Texas": 71000, "Utah": 5000})
obj2 = pd.Series({"California": np.nan, "Ohio": 35000, "Oregon": 16000, "Texas": 71000})

print(obj1 + obj2)
==>	California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

DataFrame

DataFrame是一个表格型的数据结构，类似于Excel或sql表

它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）

DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）

用多维数组字典、列表字典生成 DataFrame

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, 2002], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
print(frame)

==>     state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

#如果指定了列顺序，则DataFrame的列就会按照指定顺序进行排列
frame1 = pd.DataFrame(data, columns=['year', 'state', 'pop'])
print(frame1)

==>	   year   state  pop
0  2000    Ohio  1.5
1  2001    Ohio  1.7
2  2002    Ohio  3.6
3  2001  Nevada  2.4
4  2002  Nevada  2.9

跟原Series一样，如果传入的列在数据中找不到，就会产生NAN值

frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five'])
print(frame2)

==>	   year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN

用 Series 字典或字典生成 DataFrame

d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
print(pd.DataFrame(d))

==>	one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

#通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series,返回的Series拥有原DataFrame相同的索引
print(frame2['state'])
==>	one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object

frame2['debt'] = 16.5
print(frame2)

==>	   year   state  pop  debt
one    2000    Ohio  1.5  16.5
two    2001    Ohio  1.7  16.5
three  2002    Ohio  3.6  16.5
four   2001  Nevada  2.4  16.5
five   2002  Nevada  2.9  16.5

frame2['debt'] = np.arange(5.)
print(frame2)

==>	   year   state  pop  debt
one    2000    Ohio  1.5   0.0
two    2001    Ohio  1.7   1.0
three  2002    Ohio  3.6   2.0
four   2001  Nevada  2.4   3.0
five   2002  Nevada  2.9   4.0

PLE库

PIL库是一个具有强大图像处理能力的第三方库。

图像的组成：由RGB三原色组成,RGB图像中，一种彩色由R、G、B三原色按照比例混合而成。0-255区分不同亮度的颜色。

图像的数组表示：图像是一个由像素组成的矩阵，每个元素是一个RGB值

PIL库一般是被内置的，如果没有，可以在在cmd下用

pip install pillow

进行安装
使用

from PIL import *

Image 是 PIL 库中代表一个图像的类（对象）
导入

from PIL import Image

Matplotlib库

Matplotlib库由各种可视化类构成，内部结构复杂。

matplotlib.pylot是绘制各类可视化图形的命令字库

更多学习，可参考Matplotlib中文网：https://www.matplotlib.org.cn

基本使用

import matplotlib.pyplot as plt
import numpy as np

#显示matplotlib生成的图形
%matplotlib inline

x = np.linspace(-1,1,50) #等差数列
y = 2*x + 1

#传入x,y,通过plot()绘制出折线图
plt.plot(x,y)

#显示图形
plt.show()

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-1,1,50) #等差数列
y1 = 2*x + 1
y2 = x**2

plt.figure()
plt.plot(x,y1)

plt.figure(figsize=(7,5))
plt.plot(x,y2)

plt.show()

import matplotlib.pyplot as plt
import numpy as np

plt.figure(figsize=(7,5))
plt.plot(x,y1,color='red',linewidth=1)
plt.plot(x,y2,color='blue',linewidth=5)
plt.xlabel('x',fontsize=20)
plt.ylabel('y',fontsize=20)
plt.show()

import matplotlib.pyplot as plt
import numpy as np

l1, = plt.plot(x,y1,color='red',linewidth=1)
l2, = plt.plot(x,y2,color='blue',linewidth=5)
plt.legend(handles=[l1,l2],labels=['aa','bb'],loc='best')
plt.xlabel('x')
plt.ylabel('y')
# plt.xlim((0,1))  #x轴只截取一段进行显示
# plt.ylim((0,1))  #y轴只截取一段进行显示
plt.show()

# dots1 = np.array([2,3,4,5,6])
# dots2 = np.array([2,3,4,5,6])
dots1 =np.random.rand(50)
dots2 =np.random.rand(50)
plt.scatter(dots1,dots2,c='red',alpha=0.5) #c表示颜色，alpha表示透明度
plt.show()

x = np.arange(10)
y = 2**x+10
plt.bar(x,y,facecolor='#9999ff',edgecolor='white')
plt.show()

x = np.arange(10)
y = 2**x+10
plt.bar(x,y,facecolor='#9999ff',edgecolor='white')
for ax,ay in zip(x,y):
plt.text(ax,ay,'%.1f' % ay,ha='center',va='bottom')
plt.show()

作业

！！！作业说明！！！
请在下方提示位置，补充代码，对《青春有你2》对选手体重分布进行可视化，绘制饼状图，如下图所示：
不要求跟下图样式一模一样

直接上代码：

import matplotlib.pyplot as plt
import numpy as np
import json
import matplotlib.font_manager as font_manager

#显示matplotlib生成的图形
%matplotlib inline

with open('data/data31557/20200422.json', 'r', encoding='UTF-8') as file:
json_array = json.loads(file.read())

#将参赛选手的体重放入列表
weight = []
for star in json_array:     #遍历每个明星并将她们的体重放在列表里
weig = star['weight']
weight.append(weig)
print(len(weight))          #打印体重和人数
print(weight)

size1 = 0
size2 = 0
size3 = 0
size4 = 0

for num in weight:
if num <= '45kg':
size1 += 1
elif '45kg' < num <= '50kg':
size2 += 1
elif '50kg' < num <= '55kg':
size3 += 1
else:
size4 += 1

labels = ['<=45kg','45~50kg','50~55kg','>55kg']   #标签
sizes = [size1, size2, size3, size4]
explode = (0.1,0.1,0,0)
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode = explode, labels = labels, autopct='%1.1f%%', shadow=True)
ax1.axis('equal')
plt.savefig('/home/aistudio/work/result/pie_result01.jpg')  #将饼图存在目录下
plt.show()                      #显示饼图

得到的饼图为：

好了，今天的分享到这里结束了，继续加油啊！