python-day18(正式学习)

最新推荐文章于 2024-07-12 16:42:46 发布
最新推荐文章于 2024-07-12 16:42:46 发布
阅读量502 收藏 2
点赞数 1
文章标签： json 数据结构与算法 数据库
原文链接：http://www.cnblogs.com/leaf-wind/p/11377980.html
版权

目录

numpy模块

numpy简介

numpy官方文档：https://docs.scipy.org/doc/numpy/reference/?v=20190307135750

numpy是Python的一种开源的数值计算扩展库。这种库可用来存储和处理大型numpy数组，比Python自身的嵌套列表结构要高效的多（该结构也可以用来表示numpy数组）。

numpy库有两个作用：

  1. 区别于list列表，提供了数组操作、数组运算、以及统计分布和简单的数学模型
  2. 计算速度快，甚至要由于python内置的简单运算，使得其成为pandas、sklearn等模块的依赖包。高级的框架如TensorFlow、PyTorch等，其数组操作也和numpy非常相似。

为什么要用numpy

lis1=[1,2,3]
lis2=[4,5,6]

当我们想让两个列表内的元素相乘时，如果不用numpy模块，就需要用一个for循环来进行元素的相乘并重新建一个列表来赋值。而使用了numpy则完全不一样了，接下来就让我们欣赏一下numpy模块的功能。

创建numpy数组

numpy数组即numpy的ndarray对象，创建numpy数组就是把一个列表传入np.array()方法

arr=np.array([1,2,3])
print(arr)
arr1=np.array([[1,2,3],[4,5,6]])
print(arr1)
arr2=np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
print(arr2)

创建一维二维和三维的numpy数组，在numpy中一般用二位比较多，三维及以上用其他模块

numpy数组的基本属性

属性解释
dtype数组元素的数据类型
size数组元素的个数
ndim数组的维度
shape数组的维度大小（以元组形式）
astype类型转换

dtype种类：bool_,int(8,16,32,64),float(16,32,64)

arr=np.array([[1,2,3],[4,5,6]])
print(arr,arr.dtype)
print(arr.T)
print(arr.size)
print(arr.ndim)
print(arr.shape)

[[1 2 3]
[4 5 6]] int32
[[1 4]
[2 5]
[3 6]]
6
2
(2, 3)

获取numpy数组的行列数

由于numpy数组是多维的，对于维的数组而言，numpy数组就是既有行又有列

arr=np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.shape)
print(arr.shape[0])
print(arr.shape[1])

[[1 2 3]
[4 5 6]]
(2, 3)
2
3

切割numpy数组

切分numpy数组类似于列表的切割，但与列表的切割不同的是，numpy数组的切割涉及到行和列的切割，但是两者的切割方式都是从索引0开始，并且取头不取尾

arr=np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr[:,:])
print(arr[:1,1:])
print(arr[0,:])
print(arr[:,0])
print(arr[arr>5])

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

numpy数组元素替换

numpy数组元素的替换，类似于列表元素的替换，并且numpy数组也是一个可变类型的数据，即如果对numpy数组进行替换操作，会修改原numpy数组的元素，所以下面我们用.copy()方法举例numpy数组元素的替换。

arr=np.array([[1,2,3],[4,5,6]])
arr1=arr.copy()
arr1[:1,:]=0
print(arr1)
arr2=arr.copy()
arr2[arr2>5]=0
print(arr2)
arr[:,:]=0
print(arr)

[[0 0 0]
[4 5 6]]
[[1 2 3]
[4 5 0]]
[[0 0 0]
[0 0 0]]

numpy数组的合并

arr1 = np.array([[1, 2], [3, 4], [5, 6]])
print(arr1)
[[1 2]
 [3 4]
 [5 6]]
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2)
[[ 7  8]
 [ 9 10]
 [11 12]]
# 合并两个numpy数组的行，注意使用hstack()方法合并numpy数组，numpy数组应该有相同的行，其中hstack的h表示horizontal水平的
print(np.hstack((arr1, arr2)))
[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]
# 合并两个numpy数组，其中axis=1表示合并两个numpy数组的行
print(np.concatenate((arr1, arr2), axis=1))
[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]
# 合并两个numpy数组的列，注意使用vstack()方法合并numpy数组，numpy数组应该有相同的列，其中vstack的v表示vertical垂直的
print(np.vstack((arr1, arr2)))
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]
# 合并两个numpy数组，其中axis=0表示合并两个numpy数组的列
print(np.concatenate((arr1, arr2), axis=0))
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]
方法详解
array()将列表转换为数组，可选择显式指定dtype
arange()range的numpy版，支持浮点数
linspace()类似arange()，第三个参数为数组长度
zeros()根据指定形状和dtype创建全0数组
ones()根据指定形状和dtype创建全1数组
eye()创建单位矩阵
empty()创建一个元素全随机的数组
reshape()重塑形状

array

arr = np.array([1, 2, 3])
print(arr)
[1 2 3]

arange

# 构造0-9的ndarray数组
print(np.arange(10))
[0 1 2 3 4 5 6 7 8 9]
# 构造1-4的ndarray数组
print(np.arange(1, 5))
[1 2 3 4]
# 构造1-19且步长为2的ndarray数组
print(np.arange(1, 20, 2))
[ 1  3  5  7  9 11 13 15 17 19]

linspace/logspace

# 构造一个等差数列，取头也取尾，从0取到20，取5个数
print(np.linspace(0, 20, 5))
[ 0.  5. 10. 15. 20.]
# 构造一个等比数列，从10**0取到10**20，取5个数
print(np.logspace(0, 20, 5))
[1.e+00 1.e+05 1.e+10 1.e+15 1.e+20]

zeros/ones/eye/empty

# 构造3*4的全0numpy数组
print(np.zeros((3, 4)))
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
# 构造3*4的全1numpy数组
print(np.ones((3, 4)))
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
# 构造3个主元的单位numpy数组
print(np.eye(3))
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
# 构造一个4*4的随机numpy数组，里面的元素是随机生成的
print(np.empty((4, 4)))
[[ 2.31584178e+077 -1.49457545e-154  3.95252517e-323  0.00000000e+000]
 [ 0.00000000e+000  0.00000000e+000  0.00000000e+000  0.00000000e+000]
 [ 0.00000000e+000  0.00000000e+000  0.00000000e+000  0.00000000e+000]
 [ 0.00000000e+000  0.00000000e+000  1.29074055e-231  1.11687366e-308]]

reshape

arr = np.ones([2, 2], dtype=int)
print(arr.reshape(4, 1))
[[1]
 [1]
 [1]
 [1]]

fromstring/fromfunction(了解)

# fromstring通过对字符串的字符编码所对应ASCII编码的位置，生成一个ndarray对象
s = 'abcdef'
# np.int8表示一个字符的字节数为8
print(np.fromstring(s, dtype=np.int8))
[ 97  98  99 100 101 102]


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:4: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead
  after removing the cwd from sys.path.
def func(i, j):
    """其中i为numpy数组的行，j为numpy数组的列"""
    return i * j


# 使用函数对numpy数组元素的行和列的索引做处理，得到当前元素的值，索引从0开始，并构造一个3*4的numpy数组
print(np.fromfunction(func, (3, 4)))
[[0. 0. 0. 0.]
 [0. 1. 2. 3.]
 [0. 2. 4. 6.]]

numpy数组的运算

运算符说明
+两个numpy数组对应元素相加
-两个numpy数组对应元素相减
*两个numpy数组对应元素相乘
/两个numpy数组对应元素相除，如果都是整数则取商
%两个numpy数组对应元素相除后取余数
**n单个numpy数组每个元素都取n次方，如**2：每个元素都取平方
arrarr1 = np.array([[1, 2], [3, 4], [5, 6]])
print(arr1)
[[1 2]
 [3 4]
 [5 6]]
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2)
[[ 7  8]
 [ 9 10]
 [11 12]]
print(arr1 + arr2)
[[ 8 10]
 [12 14]
 [16 18]]
print(arr1**2)
[[ 1  4]
 [ 9 16]
 [25 36]]

numpy数组运算函数

numpy数组函数详解
np.sin(arr)对numpy数组arr中每个元素取正弦，sin(x)sin(x)
np.cos(arr)对numpy数组arr中每个元素取余弦，cos(x)cos(x)
np.tan(arr)对numpy数组arr中每个元素取正切，tan(x)tan(x)
np.arcsin(arr)对numpy数组arr中每个元素取反正弦，*arcsi**n(x*)arcsin(x)
np.arccos(arr)对numpy数组arr中每个元素取反余弦，*arcco**s(x*)arccos(x)
np.arctan(arr)对numpy数组arr中每个元素取反正切，*arcta**n(x*)arctan(x)
np.exp(arr)对numpy数组arr中每个元素取指数函数，*e**x*ex
np.sqrt(arr)对numpy数组arr中每个元素开根号x

一元函数：abs, sqrt, exp, log, ceil, floor, rint, trunc, modf, isnan, isinf, cos, sin, tan

二元函数：add, substract, multiply, divide, power, mod, maximum, mininum

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
# 对numpy数组的所有元素取正弦
print(np.sin(arr))
[[ 0.84147098  0.90929743  0.14112001 -0.7568025 ]
 [-0.95892427 -0.2794155   0.6569866   0.98935825]
 [ 0.41211849 -0.54402111 -0.99999021 -0.53657292]]
# 对numpy数组的所有元素开根号
print(np.sqrt(arr))
[[1.         1.41421356 1.73205081 2.        ]
 [2.23606798 2.44948974 2.64575131 2.82842712]
 [3.         3.16227766 3.31662479 3.46410162]]
# 对numpy数组的所有元素取反正弦，如果元素不在定义域内，则会取nan值
print(np.arcsin(arr * 0.1))
[[0.10016742 0.20135792 0.30469265 0.41151685]
 [0.52359878 0.64350111 0.7753975  0.92729522]
 [1.11976951 1.57079633        nan        nan]]


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in arcsin
  
# 判断矩阵元素中是否含有np.nan值
print(np.isnan(arr))
[[False False False]
 [False False False]]

numpy数组矩阵化

numpy数组点乘

numpy数组的点乘必须满足第一个numpy数组的列数等于第二个numpy数组的行数，即m∗n⋅n∗m=m∗mm∗n·n∗m=m∗m 。

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr1.shape)
(2, 3)
arr2 = np.array([[7, 8], [9, 10], [11, 12]])
print(arr2.shape)
(3, 2)
assert arr1.shape[0] == arr2.shape[1]
# 2*3·3*2 = 2*2
print(arr2.shape)
(3, 2)

numpy数组转置

numpy数组的转置，相当于numpy数组的行和列互换。

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)
[[1 2 3]
 [4 5 6]]
print(arr.transpose())
[[1 4]
 [2 5]
 [3 6]]
print(arr.T)
[[1 4]
 [2 5]
 [3 6]]

nummpy数组的逆

numpy数组行和列相同时，numpy数组才可逆。

arr = np.array([[1, 2, 3], [4, 5, 6], [9, 8, 9]])
print(arr)
[[1 2 3]
 [4 5 6]
 [9 8 9]]
print(np.linalg.inv(arr))
[[ 0.5        -1.          0.5       ]
 [-3.          3.         -1.        ]
 [ 2.16666667 -1.66666667  0.5       ]]
# 单位numpy数组的逆是单位numpy数组本身
arr = np.eye(3)
print(arr)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
print(np.linalg.inv(arr))
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

numpy数组数学和统计方法

方法详解
sum求和
cumsum累加求和
mean求平均数
std求标准差
var求方差
min求最小值
max求最大值
argmin求最小值索引
argmax求最大值索引
sort排序
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
# 获取numpy数组所有元素中的最大值
print(arr.max())
9
# 获取numpy数组所有元素中的最小值
print(arr.min())
1
# 获取举着每一行的最大值
print(arr.max(axis=0))
[7 8 9]
# 获取numpy数组每一列的最大值
print(arr.max(axis=1))
[3 6 9]
# 获取numpy数组最大元素的索引位置
print(arr.argmax(axis=1))
[2 2 2]

numpy.random生成随机数

函数名称函数功能参数说明
rand(d0,d1,⋯,*d**n*d0,d1,⋯,dn )产生均匀分布的随机数*d**n*dn 为第n维数据的维度
randn(d0,d1,⋯,*d**n*d0,d1,⋯,dn )产生标准正态分布随机数*d**n*dn 为第n维数据的维度
randint(low[, high, size, dtype])产生随机整数low:最小值；high:最大值；size:数据个数
random_sample([size])在[0,1)[0,1) 内产生随机数size为随机数的shape，可以为元祖或者列表
choice(a[, size])从arr中随机选择指定数据arr为1维数组；size为数组形状
uniform(low,high [,size])给定形状产生随机数组low为最小值；high为最大值，size为数组形状
shuffle(a)与random.shuffle相同a为指定数组

点击查看源网页

pandas模块

pandas官方文档：https://pandas.pydata.org/pandas-docs/stable/?v=20190307135750

pandas基于Numpy，可以看成是处理文本或者表格数据。pandas中有两个主要的数据结构，其中Series数据结构类似于Numpy中的一维数组，DataFrame类似于多维表格数据结构。

pandas是python数据分析的核心模块。它主要提供了五大功能:

  1. 支持文件存取操作，支持数据库(sql)、html、json、pickle、csv(txt、excel)、sas、stata、hdf等。
  2. 支持增删改查、切片、高阶函数、分组聚合等单表操作，以及和dict、list的互相转换。
  3. 支持多表拼接合并操作。
  4. 支持简单的绘图操作。
  5. 支持简单的统计分析操作。

一、Series数据结构

Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。

Series比较像列表（数组）和字典的结合体

import numpy as np
import pandas as pd
df = pd.Series(0, index=['a', 'b', 'c', 'd'])
print(df)
a    0
b    0
c    0
d    0
dtype: int64
print(df.values)
[0 0 0 0]
print(df.index)
Index(['a', 'b', 'c', 'd'], dtype='object')

1.1 Series支持NumPy模块的特性（下标）

详解方法
从ndarray创建SeriesSeries(arr)
与标量运算df*2
两个Series运算df1+df2
索引df[0], df[[1,2,4]]
切片df[0:2]
通用函数np.abs(df)
布尔值过滤df[df>0]
arr = np.array([1, 2, 3, 4, np.nan])
print(arr)
[ 1.  2.  3.  4. nan]
df = pd.Series(arr, index=['a', 'b', 'c', 'd', 'e'])
print(df)
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64
print(df**2)
a     1.0
b     4.0
c     9.0
d    16.0
e     NaN
dtype: float64
print(df[0])
1.0
print(df['a'])
1.0
print(df[[0, 1, 2]])
a    1.0
b    2.0
c    3.0
dtype: float64
print(df[0:2])
a    1.0
b    2.0
dtype: float64
np.sin(df)
a    0.841471
b    0.909297
c    0.141120
d   -0.756802
e         NaN
dtype: float64
df[df > 1]
b    2.0
c    3.0
d    4.0
dtype: float64

1.2 Series支持字典的特性（标签）

详解方法
从字典创建SeriesSeries(dic),
in运算’a’ in sr
键索引sr['a'], sr[['a', 'b', 'd']]
df = pd.Series({'a': 1, 'b': 2})
print(df)
a    1
b    2
dtype: int64
print('a' in df)
True
print(df['a'])
1

1.3 Series缺失数据处理

方法详解
dropna()过滤掉值为NaN的行
fillna()填充缺失数据
isnull()返回布尔数组，缺失值对应为True
notnull()返回布尔数组，缺失值对应为False
df = pd.Series([1, 2, 3, 4, np.nan], index=['a', 'b', 'c', 'd', 'e'])
print(df)
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64
print(df.dropna())
a    1.0
b    2.0
c    3.0
d    4.0
dtype: float64
print(df.fillna(5))
a    1.0
b    2.0
c    3.0
d    4.0
e    5.0
dtype: float64
print(df.isnull())
a    False
b    False
c    False
d    False
e     True
dtype: bool
print(df.notnull())
a     True
b     True
c     True
d     True
e    False
dtype: bool

二、DataFrame数据结构

DataFrame是一个表格型的数据结构，含有一组有序的列。

DataFrame可以被看做是由Series组成的字典，并且共用一个索引。

2.1 产生时间对象数组：date_range

date_range参数详解：

参数详解
start开始时间
end结束时间
periods时间长度
freq时间频率，默认为'D'，可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…
dates = pd.date_range('20190101', periods=6, freq='M')
print(dates)
DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
               '2019-05-31', '2019-06-30'],
              dtype='datetime64[ns]', freq='M')
np.random.seed(1)
arr = 10 * np.random.randn(6, 4)
print(arr)
[[ 16.24345364  -6.11756414  -5.28171752 -10.72968622]
 [  8.65407629 -23.01538697  17.44811764  -7.61206901]
 [  3.19039096  -2.49370375  14.62107937 -20.60140709]
 [ -3.22417204  -3.84054355  11.33769442 -10.99891267]
 [ -1.72428208  -8.77858418   0.42213747   5.82815214]
 [-11.00619177  11.4472371    9.01590721   5.02494339]]
df = pd.DataFrame(arr, index=dates, columns=['c1', 'c2', 'c3', 'c4'])
df
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943

三、DataFrame属性

属性详解
dtype是查看数据类型
index查看行序列或者索引
columns查看各列的标签
values查看数据框内的数据，也即不含表头索引的数据
describe查看数据每一列的极值，均值，中位数，只可用于数值型数据
transpose转置，也可用Ｔ来操作
sort_index排序，可按行或列index排序输出
sort_values按数据值来排序
# 查看数据类型
print(df2.dtypes)
0    float64
1    float64
2    float64
3    float64
dtype: object
df
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
print(df.index)
DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
               '2019-05-31', '2019-06-30'],
              dtype='datetime64[ns]', freq='M')
print(df.columns)
Index(['c1', 'c2', 'c3', 'c4'], dtype='object')
print(df.values)
[[ 16.24345364  -6.11756414  -5.28171752 -10.72968622]
 [  8.65407629 -23.01538697  17.44811764  -7.61206901]
 [  3.19039096  -2.49370375  14.62107937 -20.60140709]
 [ -3.22417204  -3.84054355  11.33769442 -10.99891267]
 [ -1.72428208  -8.77858418   0.42213747   5.82815214]
 [-11.00619177  11.4472371    9.01590721   5.02494339]]
df.describe()
c1c2c3c4
count6.0000006.0000006.0000006.000000
mean2.022213-5.4664247.927203-6.514830
std9.58008411.1077728.70717110.227641
min-11.006192-23.015387-5.281718-20.601407
25%-2.849200-8.1133292.570580-10.931606
50%0.733054-4.97905410.176801-9.170878
75%7.288155-2.83041413.8002331.865690
max16.24345411.44723717.4481185.828152
df.T
2019-01-31 00:00:002019-02-28 00:00:002019-03-31 00:00:002019-04-30 00:00:002019-05-31 00:00:002019-06-30 00:00:00
c116.2434548.6540763.190391-3.224172-1.724282-11.006192
c2-6.117564-23.015387-2.493704-3.840544-8.77858411.447237
c3-5.28171817.44811814.62107911.3376940.4221379.015907
c4-10.729686-7.612069-20.601407-10.9989135.8281525.024943
# 按行标签[c1, c2, c3, c4]从大到小排序
df.sort_index(axis=0)
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
# 按列标签[2019-01-01, 2019-01-02...]从大到小排序
df.sort_index(axis=1)
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
# 按c2列的值从大到小排序
df.sort_values(by='c2')
c1c2c3c4
2019-02-288.654076-23.01538717.448118-7.612069
2019-05-31-1.724282-8.7785840.4221375.828152
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-03-313.190391-2.49370414.621079-20.601407
2019-06-30-11.00619211.4472379.0159075.024943

四、DataFrame取值

df
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943

4.1 通过columns取值

df['c2']
2019-01-31    -6.117564
2019-02-28   -23.015387
2019-03-31    -2.493704
2019-04-30    -3.840544
2019-05-31    -8.778584
2019-06-30    11.447237
Freq: M, Name: c2, dtype: float64
df[['c2', 'c3']]
c2c3
2019-01-31-6.117564-5.281718
2019-02-28-23.01538717.448118
2019-03-31-2.49370414.621079
2019-04-30-3.84054411.337694
2019-05-31-8.7785840.422137
2019-06-3011.4472379.015907

4.2 loc（通过行标签取值）

# 通过自定义的行标签选择数据
df.loc['2019-01-01':'2019-01-03']
c1c2c3c4
df[0:3]
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407

4.3 iloc（类似于numpy数组取值）

df.values
array([[ 16.24345364,  -6.11756414,  -5.28171752, -10.72968622],
       [  8.65407629, -23.01538697,  17.44811764,  -7.61206901],
       [  3.19039096,  -2.49370375,  14.62107937, -20.60140709],
       [ -3.22417204,  -3.84054355,  11.33769442, -10.99891267],
       [ -1.72428208,  -8.77858418,   0.42213747,   5.82815214],
       [-11.00619177,  11.4472371 ,   9.01590721,   5.02494339]])
# 通过行索引选择数据
print(df.iloc[2, 1])
-2.493703754774101
df.iloc[1:4, 1:4]
c2c3c4
2019-02-28-23.01538717.448118-7.612069
2019-03-31-2.49370414.621079-20.601407
2019-04-30-3.84054411.337694-10.998913

4.4 使用逻辑判断取值

df[df['c1'] > 0]
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
df[(df['c1'] > 0) & (df['c2'] > -8)]
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-03-313.190391-2.49370414.621079-20.601407

五、DataFrame值替换

df
c1c2c3c4
2019-01-3116.243454-6.117564-5.281718-10.729686
2019-02-288.654076-23.01538717.448118-7.612069
2019-03-313.190391-2.49370414.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
df.iloc[0:3, 0:2] = 0
df
c1c2c3c4
2019-01-310.0000000.000000-5.281718-10.729686
2019-02-280.0000000.00000017.448118-7.612069
2019-03-310.0000000.00000014.621079-20.601407
2019-04-30-3.224172-3.84054411.337694-10.998913
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
df['c3'] > 10
2019-01-31    False
2019-02-28     True
2019-03-31     True
2019-04-30     True
2019-05-31    False
2019-06-30    False
Freq: M, Name: c3, dtype: bool
# 针对行做处理
df[df['c3'] > 10] = 100
df
c1c2c3c4
2019-01-310.0000000.000000-5.281718-10.729686
2019-02-28100.000000100.000000100.000000100.000000
2019-03-31100.000000100.000000100.000000100.000000
2019-04-30100.000000100.000000100.000000100.000000
2019-05-31-1.724282-8.7785840.4221375.828152
2019-06-30-11.00619211.4472379.0159075.024943
# 针对行做处理
df = df.astype(np.int32)
df[df['c3'].isin([100])] = 1000
df
c1c2c3c4
2019-01-3100-5-10
2019-02-281000100010001000
2019-03-311000100010001000
2019-04-301000100010001000
2019-05-31-1-805
2019-06-30-111195

六、读取CSV文件

import pandas as pd
from io import StringIO
test_data = '''
5.1,,1.4,0.2
4.9,3.0,1.4,0.2
4.7,3.2,,0.2
7.0,3.2,4.7,1.4
6.4,3.2,4.5,1.5
6.9,3.1,4.9,
,,,
'''

test_data = StringIO(test_data)
df = pd.read_csv(test_data, header=None)
df.columns = ['c1', 'c2', 'c3', 'c4']
df
c1c2c3c4
05.1NaN1.40.2
14.93.01.40.2
24.73.2NaN0.2
37.03.24.71.4
46.43.24.51.5
56.93.14.9NaN
6NaNNaNNaNNaN

七、处理丢失数据

df.isnull()
c1c2c3c4
0FalseTrueFalseFalse
1FalseFalseFalseFalse
2FalseFalseTrueFalse
3FalseFalseFalseFalse
4FalseFalseFalseFalse
5FalseFalseFalseTrue
6TrueTrueTrueTrue
# 通过在isnull()方法后使用sum()方法即可获得该数据集某个特征含有多少个缺失值
print(df.isnull().sum())
c1    1
c2    2
c3    2
c4    2
dtype: int64
# axis=0删除有NaN值的行
df.dropna(axis=0)
c1c2c3c4
14.93.01.40.2
37.03.24.71.4
46.43.24.51.5
# axis=1删除有NaN值的列
df.dropna(axis=1)
0
1
2
3
4
5
6
# 删除全为NaN值得行或列
df.dropna(how='all')
c1c2c3c4
05.1NaN1.40.2
14.93.01.40.2
24.73.2NaN0.2
37.03.24.71.4
46.43.24.51.5
56.93.14.9NaN
# 删除行不为4个值的
df.dropna(thresh=4)
c1c2c3c4
14.93.01.40.2
37.03.24.71.4
46.43.24.51.5
# 删除c2中有NaN值的行
df.dropna(subset=['c2'])
c1c2c3c4
14.93.01.40.2
24.73.2NaN0.2
37.03.24.71.4
46.43.24.51.5
56.93.14.9NaN
# 填充nan值
df.fillna(value=10)
c1c2c3c4
05.110.01.40.2
14.93.01.40.2
24.73.210.00.2
37.03.24.71.4
46.43.24.51.5
56.93.14.910.0
610.010.010.010.0

八、合并数据

df1 = pd.DataFrame(np.zeros((3, 4)))
df1
0123
00.00.00.00.0
10.00.00.00.0
20.00.00.00.0
df2 = pd.DataFrame(np.ones((3, 4)))
df2
0123
01.01.01.01.0
11.01.01.01.0
21.01.01.01.0
# axis=0合并列
pd.concat((df1, df2), axis=0)
0123
00.00.00.00.0
10.00.00.00.0
20.00.00.00.0
01.01.01.01.0
11.01.01.01.0
21.01.01.01.0
# axis=1合并行
pd.concat((df1, df2), axis=1)
01230123
00.00.00.00.01.01.01.01.0
10.00.00.00.01.01.01.01.0
20.00.00.00.01.01.01.01.0
# append只能合并列
df1.append(df2)
0123
00.00.00.00.0
10.00.00.00.0
20.00.00.00.0
01.01.01.01.0
11.01.01.01.0
21.01.01.01.0

九、导入导出数据

使用df = pd.read_excel(filename)读取文件，使用df.to_excel(filename)保存文件。

9.1 读取文件导入数据

读取文件导入数据函数主要参数：

参数详解
sep指定分隔符，可用正则表达式如'\s+'
header=None指定文件无行名
name指定列名
index_col指定某列作为索引
skip_row指定跳过某些行
na_values指定某些字符串表示缺失值
parse_dates指定某些列是否被解析为日期，布尔值或列表
df = pd.read_excel(filename)
df = pd.read_csv(filename)

9.2 写入文件导出数据

写入文件函数的主要参数：

参数详解
sep分隔符
na_rep指定缺失值转换的字符串，默认为空字符串
header=False不保存列名
index=False不保存行索引
cols指定输出的列，传入列表
df.to_excel(filename)

十、pandas读取json文件

strtext = '[{"ttery":"min","issue":"20130801-3391","code":"8,4,5,2,9","code1":"297734529","code2":null,"time":1013395466000},\
{"ttery":"min","issue":"20130801-3390","code":"7,8,2,1,2","code1":"298058212","code2":null,"time":1013395406000},\
{"ttery":"min","issue":"20130801-3389","code":"5,9,1,2,9","code1":"298329129","code2":null,"time":1013395346000},\
{"ttery":"min","issue":"20130801-3388","code":"3,8,7,3,3","code1":"298588733","code2":null,"time":1013395286000},\
{"ttery":"min","issue":"20130801-3387","code":"0,8,5,2,7","code1":"298818527","code2":null,"time":1013395226000}]'

df = pd.read_json(strtext, orient='records')
df
codecode1code2issuetimettery
08,4,5,2,9297734529NaN20130801-33911013395466000min
17,8,2,1,2298058212NaN20130801-33901013395406000min
25,9,1,2,9298329129NaN20130801-33891013395346000min
33,8,7,3,3298588733NaN20130801-33881013395286000min
40,8,5,2,7298818527NaN20130801-33871013395226000min
df.to_excel('pandas处理json.xlsx',
            index=False,
            columns=["ttery", "issue", "code", "code1", "code2", "time"])

10.1 orient参数的五种形式

orient是表明预期的json字符串格式。orient的设置有以下五个值：

1.'split' : dict like {index -> [index], columns -> [columns], data -> [values]}

这种就是有索引，有列字段,和数据矩阵构成的json格式。key名称只能是index,columns和data。

s = '{"index":[1,2,3],"columns":["a","b"],"data":[[1,3],[2,8],[3,9]]}'
df = pd.read_json(s, orient='split')
df
ab
113
228
339

2.'records' : list like [{column -> value}, ... , {column -> value}]

这种就是成员为字典的列表。如我今天要处理的json数据示例所见。构成是列字段为键,值为键值,每一个字典成员就构成了dataframe的一行数据。

strtext = '[{"ttery":"min","issue":"20130801-3391","code":"8,4,5,2,9","code1":"297734529","code2":null,"time":1013395466000},\
{"ttery":"min","issue":"20130801-3390","code":"7,8,2,1,2","code1":"298058212","code2":null,"time":1013395406000}]'

df = pd.read_json(strtext, orient='records')
df
codecode1code2issuetimettery
08,4,5,2,9297734529NaN20130801-33911013395466000min
17,8,2,1,2298058212NaN20130801-33901013395406000min

3.'index' : dict like {index -> {column -> value}}

以索引为key,以列字段构成的字典为键值。如：

s = '{"0":{"a":1,"b":2},"1":{"a":9,"b":11}}'
df = pd.read_json(s, orient='index')
df
ab
012
1911

4.'columns' : dict like {column -> {index -> value}}

这种处理的就是以列为键，对应一个值字典的对象。这个字典对象以索引为键,以值为键值构成的json字符串。如下图所示:

s = '{"a":{"0":1,"1":9},"b":{"0":2,"1":11}}'
df = pd.read_json(s, orient='columns')
df
ab
012
1911

5.'values' : just the values array。

values这种我们就很常见了。就是一个嵌套的列表。里面的成员也是列表，2层的。

s = '[["a",1],["b",2]]'
df = pd.read_json(s, orient='values')
df
01
0a1
1b2

十一、pandas读取sql语句

import numpy as np
import pandas as pd
import pymysql


def conn(sql):
    # 连接到mysql数据库
    conn = pymysql.connect(
        host="localhost",
        port=3306,
        user="root",
        passwd="123",
        db="db1",
    )
    try:
        data = pd.read_sql(sql, con=conn)
        return data
    except Exception as e:
        print("SQL is not correct!")
    finally:
        conn.close()


sql = "select * from test1 limit 0, 10"  # sql语句
data = conn(sql)
print(data.columns.tolist())  # 查看字段
print(data)  # 查看数据

点击查看源网页

matplotlib模块

matplotlib官方文档：https://matplotlib.org/contents.html?v=20190307135750

matplotlib是一个绘图库，它可以创建常用的统计图，包括条形图、箱型图、折线图、散点图、饼图和直方图。

一、条形图

import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

classes = ['3班', '4班', '5班', '6班']

classes_index = range(len(classes))
print(list(classes_index))
[0, 1, 2, 3]
student_amounts = [66, 55, 45, 70]

# 画布设置
fig = plt.figure()
# 1,1,1表示一张画布切割成1行1列共一张图的第1个；2,2,1表示一张画布切割成2行2列共4张图的第一个（左上角）
ax1 = fig.add_subplot(1, 1, 1)
ax1.bar(classes_index, student_amounts, align='center', color='darkblue')
ax1.xaxis.set_ticks_position('bottom')
ax1.yaxis.set_ticks_position('left')

plt.xticks(classes_index,
           classes,
           rotation=0,
           fontsize=13,
           fontproperties=font)
plt.xlabel('班级', fontproperties=font, fontsize=15)
plt.ylabel('学生人数', fontproperties=font, fontsize=15)
plt.title('班级-学生人数', fontproperties=font, fontsize=20)
# 保存图片，bbox_inches='tight'去掉图形四周的空白
# plt.savefig('classes_students.png?x-oss-process=style/watermark', dpi=400, bbox_inches='tight')
plt.show()

img

二、直方图

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

mu1, mu2, sigma = 50, 100, 10
# 构造均值为50的符合正态分布的数据
x1 = mu1 + sigma * np.random.randn(10000)
print(x1)
[59.00855949 43.16272141 48.77109774 ... 57.94645859 54.70312714
 58.94125528]
# 构造均值为100的符合正态分布的数据
x2 = mu2 + sigma * np.random.randn(10000)
print(x2)
[115.19915511  82.09208214 110.88092454 ...  95.0872103  104.21549068
 133.36025251]
fig = plt.figure()
ax1 = fig.add_subplot(121)
# bins=50表示每个变量的值分成50份，即会有50根柱子
ax1.hist(x1, bins=50, color='darkgreen')

ax2 = fig.add_subplot(122)
ax2.hist(x2, bins=50, color='orange')

fig.suptitle('两个正态分布', fontproperties=font, fontweight='bold', fontsize=15)
ax1.set_title('绿色的正态分布', fontproperties=font)
ax2.set_title('橙色的正态分布', fontproperties=font)
plt.show()

img

三、折线图

import numpy as np
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

np.random.seed(1)

# 使用numpy的累加和，保证数据取值范围不会在（0，1）内波动
plot_data1 = randn(40).cumsum()
print(plot_data1)
[ 1.62434536  1.01258895  0.4844172  -0.58855142  0.2768562  -2.02468249
 -0.27987073 -1.04107763 -0.72203853 -0.97140891  0.49069903 -1.56944168
 -1.89185888 -2.27591324 -1.1421438  -2.24203506 -2.41446327 -3.29232169
 -3.25010794 -2.66729273 -3.76791191 -2.6231882  -1.72159748 -1.21910314
 -0.31824719 -1.00197505 -1.12486527 -2.06063471 -2.32852279 -1.79816732
 -2.48982807 -2.8865816  -3.5737543  -4.41895994 -5.09020607 -5.10287067
 -6.22018102 -5.98576532 -4.32596314 -3.58391898]
plot_data2 = randn(40).cumsum()
plot_data3 = randn(40).cumsum()
plot_data4 = randn(40).cumsum()

plt.plot(plot_data1, marker='o', color='red', linestyle='-', label='红实线')
plt.plot(plot_data2, marker='x', color='orange', linestyle='--', label='橙虚线')
plt.plot(plot_data3, marker='*', color='yellow', linestyle='-.', label='黄点线')
plt.plot(plot_data4, marker='s', color='green', linestyle=':', label='绿点图')

# loc='best'给label自动选择最好的位置
plt.legend(loc='best', prop=font)
plt.show()

img

四、散点图+直线图

import numpy as np
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

# 修改背景为条纹
plt.style.use('ggplot')

x = np.arange(1, 20, 1)
print(x)
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
# 拟合一条水平散点线
np.random.seed(1)
y_linear = x + 10 * np.random.randn(19)
print(y_linear)
[ 17.24345364  -4.11756414  -2.28171752  -6.72968622  13.65407629
 -17.01538697  24.44811764   0.38793099  12.19039096   7.50629625
  25.62107937  -8.60140709   9.77582796  10.15945645  26.33769442
   5.00108733  15.27571792   9.22141582  19.42213747]
# 拟合一条x²的散点线
y_quad = x**2 + 10 * np.random.randn(19)
print(y_quad)
[  6.82815214  -7.00619177  20.4472371   25.01590721  30.02494339
  45.00855949  42.16272141  62.77109774  71.64230566  97.3211192
 126.30355467 137.08339248 165.03246473 189.128273   216.54794359
 249.28753869 288.87335401 312.82689651 363.34415698]
# s是散点大小
fig = plt.figure()
ax1 = fig.add_subplot(121)
plt.scatter(x, y_linear, s=30, color='r', label='蓝点')
plt.scatter(x, y_quad, s=100, color='b', label='红点')

ax2 = fig.add_subplot(122)
plt.plot(x, y_linear, color='r')
plt.plot(x, y_quad, color='b')

# 限制x轴和y轴的范围取值
plt.xlim(min(x) - 1, max(x) + 1)
plt.ylim(min(y_quad) - 10, max(y_quad) + 10)
fig.suptitle('散点图+直线图', fontproperties=font, fontsize=20)
ax1.set_title('散点图', fontproperties=font)
ax1.legend(prop=font)
ax2.set_title('直线图', fontproperties=font)
plt.show()

img

五、饼图

import numpy as np
import matplotlib.pyplot as plt
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['SimHei']

fig, ax = plt.subplots(subplot_kw=dict(aspect="equal"))

recipe = ['优', '良', '轻度污染', '中度污染', '重度污染', '严重污染', '缺']

data = [2, 49, 21, 9, 11, 6, 2]
colors = ['lime', 'yellow', 'darkorange', 'red', 'purple', 'maroon', 'grey']
wedges, texts, texts2 = ax.pie(data,
                               wedgeprops=dict(width=0.5),
                               startangle=40,
                               colors=colors,
                               autopct='%1.0f%%',
                               pctdistance=0.8)
plt.setp(texts2, size=14, weight="bold")

bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
kw = dict(xycoords='data',
          textcoords='data',
          arrowprops=dict(arrowstyle="->"),
          bbox=None,
          zorder=0,
          va="center")

for i, p in enumerate(wedges):
    ang = (p.theta2 - p.theta1) / 2. + p.theta1
    y = np.sin(np.deg2rad(ang))
    x = np.cos(np.deg2rad(ang))
    horizontalalignment = {-1: "right", 1: "left"}[int(np.sign(x))]
    connectionstyle = "angle,angleA=0,angleB={}".format(ang)
    kw["arrowprops"].update({"connectionstyle": connectionstyle})
    ax.annotate(recipe[i],
                xy=(x, y),
                xytext=(1.25 * np.sign(x), 1.3 * y),
                size=16,
                horizontalalignment=horizontalalignment,
                fontproperties=font,
                **kw)

ax.set_title("饼图示例",fontproperties=font)

plt.show()
# plt.savefig('jiaopie2.png?x-oss-process=style/watermark')

img

六、箱型图

箱型图：又称为盒须图、盒式图、盒状图或箱线图，是一种用作显示一组数据分散情况资料的统计图（在数据分析中常用在异常值检测）

包含一组数据的：最大值、最小值、中位数、上四分位数（Q3）、下四分位数（Q1）、异常值

  1. 中位数 → 一组数据平均分成两份，中间的数
  2. 上四分位数Q1 → 是将序列平均分成四份，计算(n+1)/4与(n-1)/4两种，一般使用(n+1)/4
  3. 下四分位数Q3 → 是将序列平均分成四份，计算(1+n)/4*3=6.75
  4. 内限 → T形的盒须就是内限，最大值区间Q3+1.5IQR,最小值区间Q1-1.5IQR （IQR=Q3-Q1）
  5. 外限 → T形的盒须就是内限，最大值区间Q3+3IQR,最小值区间Q1-3IQR （IQR=Q3-Q1）
  6. 异常值 → 内限之外 - 中度异常，外限之外 - 极度异常
import numpy as np
import pandas as pd
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
plt.figure(figsize=(10, 4))
# 创建图表、数据

f = df.boxplot(
    sym='o',  # 异常点形状，参考marker
    vert=True,  # 是否垂直
    whis=1.5,  # IQR，默认1.5，也可以设置区间比如[5,95]，代表强制上下边缘为数据95%和5%位置
    patch_artist=True,  # 上下四分位框内是否填充，True为填充
    meanline=False,
    showmeans=True,  # 是否有均值线及其形状
    showbox=True,  # 是否显示箱线
    showcaps=True,  # 是否显示边缘线
    showfliers=True,  # 是否显示异常值
    notch=False,  # 中间箱体是否缺口
    return_type='dict'  # 返回类型为字典
)
plt.title('boxplot')

for box in f['boxes']:
    box.set(color='b', linewidth=1)  # 箱体边框颜色
    box.set(facecolor='b', alpha=0.5)  # 箱体内部填充颜色
for whisker in f['whiskers']:
    whisker.set(color='k', linewidth=0.5, linestyle='-')
for cap in f['caps']:
    cap.set(color='gray', linewidth=2)
for median in f['medians']:
    median.set(color='DarkBlue', linewidth=2)
for flier in f['fliers']:
    flier.set(marker='o', color='y', alpha=0.5)
# boxes, 箱线
# medians, 中位值的横线,
# whiskers, 从box到error bar之间的竖线.
# fliers, 异常值
# caps, error bar横线
# means, 均值的横线

img

七、plot函数参数

  • 线型linestyle（-,-.,--,..）
  • 点型marker（v,^,s,*,H,+,x,D,o,…）
  • 颜色color（b,g,r,y,k,w,…）

八、图像标注参数

  • 设置图像标题：plt.title()
  • 设置x轴名称：plt.xlabel()
  • 设置y轴名称：plt.ylabel()
  • 设置X轴范围：plt.xlim()
  • 设置Y轴范围：plt.ylim()
  • 设置X轴刻度：plt.xticks()
  • 设置Y轴刻度：plt.yticks()
  • 设置曲线图例：plt.legend()

九、Matplolib应用

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
%matplotlib inline

# 找到自己电脑的字体路径，然后修改字体路径
font = FontProperties(fname='/Library/Fonts/Heiti.ttc')

header_list = ['方程组', '函数', '导数', '微积分', '线性代数', '概率论', '统计学']
py3_df = pd.read_excel('py3.xlsx', header=None,
                       skiprows=[0, 1], names=header_list)
# 处理带有NaN的行
py3_df = py3_df.dropna(axis=0)
print(py3_df)

# 自定义映射
map_dict = {
    '不会': 0,
    '了解': 1,
    '熟悉': 2,
    '使用过': 3,
}

for header in header_list:
    py3_df[header] = py3_df[header].map(map_dict)

unable_series = (py3_df == 0).sum(axis=0)
know_series = (py3_df == 1).sum(axis=0)
familiar_series = (py3_df == 2).sum(axis=0)
use_series = (py3_df == 3).sum(axis=0)

unable_label = '不会'
know_label = '了解'
familiar_label = '熟悉'
use_label = '使用过'
for i in range(len(header_list)):
    bottom = 0

    # 描绘不会的条形图
    plt.bar(x=header_list[i], height=unable_series[i],
            width=0.60, color='r', label=unable_label)
    if unable_series[i] != 0:
        plt.text(header_list[i], bottom, s=unable_series[i],
                 ha='center', va='bottom', fontsize=15, color='white')
    bottom += unable_series[i]

    # 描绘了解的条形图
    plt.bar(x=header_list[i], height=know_series[i],
            width=0.60, color='y', bottom=bottom, label=know_label)
    if know_series[i] != 0:
        plt.text(header_list[i], bottom, s=know_series[i],
                 ha='center', va='bottom', fontsize=15, color='white')
    bottom += know_series[i]

    # 描绘熟悉的条形图
    plt.bar(x=header_list[i], height=familiar_series[i],
            width=0.60, color='g', bottom=bottom, label=familiar_label)
    if familiar_series[i] != 0:
        plt.text(header_list[i], bottom, s=familiar_series[i],
                 ha='center', va='bottom', fontsize=15, color='white')
    bottom += familiar_series[i]

    # 描绘使用过的条形图
    plt.bar(x=header_list[i], height=use_series[i],
            width=0.60, color='b', bottom=bottom, label=use_label)
    if use_series[i] != 0:
        plt.text(header_list[i], bottom, s=use_series[i],
                 ha='center', va='bottom', fontsize=15, color='white')

    unable_label = know_label = familiar_label = use_label = ''

plt.xticks(header_list, fontproperties=font)
plt.ylabel('人数', fontproperties=font)
plt.title('Python3期数学摸底可视化', fontproperties=font)
plt.legend(prop=font, loc='upper left')
plt.show()
    方程组   函数   导数        微积分       线性代数  概率论  统计学
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   熟悉   熟悉   熟悉        使用过         不会   不会   不会
25  使用过  使用过  使用过        使用过        使用过  使用过  使用过
26  使用过  使用过  使用过        使用过        使用过   不会   不会
27  使用过  使用过   不会         不会         不会   不会   不会
28  使用过  使用过  使用过        使用过        使用过  使用过   了解
29  使用过  使用过  使用过        使用过        使用过   了解   不会
30  使用过  使用过  使用过        使用过        使用过   不会   不会
31  使用过  使用过  使用过        使用过         不会  使用过  使用过
32   熟悉   熟悉  使用过        使用过        使用过   不会   不会
33  使用过  使用过  使用过        使用过         熟悉  使用过   熟悉
34   熟悉   熟悉   熟悉        使用过        使用过   熟悉   不会
35  使用过  使用过  使用过        使用过        使用过  使用过  使用过
36  使用过  使用过  使用过        使用过        使用过  使用过   了解
37  使用过  使用过  使用过        使用过        使用过   不会   不会
38  使用过  使用过  使用过         不会         不会   不会   不会
39  使用过  使用过   不会         不会         不会   不会   不会
40  使用过  使用过  使用过        使用过        使用过   不会   不会
41  使用过  使用过   熟悉         了解         了解   了解   不会
42  使用过  使用过  使用过         不会         不会   不会   不会
43   熟悉  使用过   了解         了解         不会   不会   不会

img

点击查看源网页

...

点击查看源网页

...

点击查看源网页

hhhhhhhhhge...

转载于:https://www.cnblogs.com/leaf-wind/p/11377980.html

Wjx510010104
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python学习day18
qq_44981522的博客
12-22 95
python学习day18 class 类名: 类的说明文档 类的内容(对象方法、类方法、静态方法 + 对象属性、类属性) “”" # 1. 对象方法 “”" 方法指的就是定义在类中的函数。 1）怎么定义: 直接定义(不需要添加任何装饰器)在类中函数就是对象方法 2）怎么调用: 通过 '对象.xx()'的形式来调用 3）特点: 每个对象方法都有一个默认参数self，在通过对象调用对象方法的时候self不需要传参, ​ 系统会自动将当前对象传给self（self谁调用就指向谁） “”" # 定义类 cl
Python学习 Day18
weixin_43902376的博客
11-19 89
na
Python 变量类型
bloodsuckerm的博客
01-30 233
Python 变量类型 变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。 基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。 因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。 变量赋值 Python 中的变量赋值不需要类型声明。 每个变量在内存中创建，都包括变量的标识，名称和数据这
在jupyter上显示深度学习模型的各层
hhh0209的博客
06-28 3071
最近跟着网上的教程在学习深度学习，目前是用caffe框架。        参考网友的博客（http://www.cnblogs.com/denny402/p/5103425.html），成功在jupyter上显示出了训练出的模型的各卷基层，但其实代码不太懂，先记录到这里，以后再分析代码。     基本和参考的博客一致。过程中遇到一些问题，解释如下：     问
【Python Cookbook】第三章 数字、日期和时间
weixin_47691066的博客
10-01 295
查漏补缺~
第五章Python数据处理工具 ——Pandas
SunnyRivers
07-18 2433
前言 上一章向读者介绍了有关数值计算的numpy模块，通过numpy模块可以非常方便地调用各种常用的数学和统计函数。本章将介绍强大的数据处理模块Pandas，该模块可以帮助数据分析师轻松地解决数据的预处理问题，如数据类型的转换、缺失值的处理、描述性统计分析、数据的汇总等。 通过本章内容的学习，读者将会掌握如下知识点，进而在数据处理过程中做到游刃有余，为后续的数据分析或机器学习做准备： 两种重要的...
numpy模块
weixin_30896511的博客
05-04 363
目录 一、numpy简介 二、为什么用numpy 三、创建numpy数组 四、numpy数组的常用属性 五、获取numpy数组的行列数 六、切割numpy数组 七、numpy数组元素替换 八、numpy数组的合并 九、...
python-day15-day19
03-18
在Python编程语言的学习过程中，"python-day15-day19"这部分内容涵盖了从第15天到第19天的学习笔记。尽管没有提供具体的笔记内容，但我们可以根据通常的Python学习路径来推测涵盖的一些关键知识点。 1. **面向对象...
python-Day10.rar
04-08
"python-Day10.rar"这个压缩包文件很可能是这一天学习材料的集合，包含了一些练习、代码示例或者讲义文档。虽然没有具体的文件内容描述，但我们可以根据一般Python学习路径推测出可能涉及的主题。 首先，Python中的...
python-Day19.rar
04-11
以上内容仅为"python-Day19.rar"可能涉及的知识点，具体的学习内容可能会根据课程设计或个人兴趣有所不同。通过深入理解和实践这些概念，开发者可以进一步提升Python编程技能，为解决更复杂的编程问题打下坚实基础。
python-Day17.rar
04-11
"python-Day17.rar"这个压缩包很可能是某个Python学习课程或者教程的一部分，涵盖了第17天的教学内容。在Python的学习过程中，每一天可能都会涉及新的概念、语法和实用技巧。在这里，我们将会探讨一些可能涵盖在...
python-Day05.rar
04-02
"python-Day05.rar"这个压缩包文件可能包含了这天学习的所有资料，包括讲义、代码示例、练习题等。下面我们将详细探讨一些可能涉及的Python知识点。 1. **函数（Functions）**：函数是Python编程的基础元素之一，...
跑 Faster-RCNN 出现：RuntimeWarning: invalid value encountered in greater_equal 等这样的warning
tunhuzhuang1836的博客
08-02 2万+
在跑 Faster-RCNN 的代码的时候，可能手残想更改官方的Pascal VOC数据集，改成跑自己的数据集。 但是可能会出现这样或者类似的warning： RuntimeWarning: invalid value encountered in true_divide RuntimeWarning: invalid value encountered in greater_equal ...
解决 RuntimeWarning: invalid value encountered in double_scalars
热门推荐
蕾姆的博客
12-26 12万+
在计算余弦相似度函数时候，出现这个错误 # 计算余弦相似度函数 def cos_like(self,array1, array2): num = float(np.matmul(array1, array2)) s = np.linalg.norm(array1) * np.linalg.norm(array2) return num ...
python ：invalid value encountered in true_divide。（除法遇到无效值）
南戈的博客
05-06 4万+
假设有这样一个需求（不是假设，是真的）： 给出历年的预算费用，求增长率。 为方便后续计算，用matrix矩阵实现。 # 历史数据 his=matrix([[30000., 20000., 10000., 1000.], [ 0., 0., 0., 9000.], [ 0., 0., 10000., 0.], ...
深度学习-1
weixin_43139613的博客
08-28 227
跃迁函数 简单说就是大于0返回1，否则返回0 import numpy as np 0 def setp_function(x): y = x > 0 return y.astype(np.int) x = np.array([-1,1,2]) p setp_function(x) array([0, 1, 1]) import matplotlib.pylab as plt...
【Python】使用numpy时警告：RuntimeWarning溢出报错的屏蔽方法
小白兔的窝
10-11 4万+
写sigmoid函数时候遇到溢出，屏幕打印一长串的RuntimeWarning，很难受。 尝试了try...except RuntimeWarning: pass。没用。 尝试了longfloat()函数包住变量，没用。 最后使用 python -W ignore::RuntimeWarning my_script.py 世界干净了！值得拥有！...
Python应用爬虫下载QQ音乐歌曲！
最新发布
Python_trys的博客
07-12 828
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970。
python学习笔记-day8-2-【python 异常处理 try except】
05-17
在Python中，异常处理是非常重要的一部分。当程序运行时如果出现错误，如果没有异常处理，程序就会崩溃。为了避免这种情况，Python提供了异常处理机制。 在Python中，异常处理语句使用 `try` 和 `except` 关键字来实现。`try` 语句块中包含可能会发生异常的代码，如果这段代码出现了异常，则会跳转到 `except` 语句块中执行异常处理代码。 下面是一个简单的例子： ```python try: num = int(input("请输入一个整数：")) print(10/num) except ZeroDivisionError: print("除数不能为0") except ValueError: print("输入的不是整数") ``` 在上面的代码中，我们尝试将用户输入的字符串转换为整数，并将其用作除数计算 10/num。如果用户输入的是 0，则会触发 ZeroDivisionError 异常。如果用户输入的不是整数，则会触发 ValueError 异常。如果发生异常，则会跳转到对应的 except 语句块中执行处理代码。 除了可以指定具体的异常类型，也可以使用 `except Exception` 来捕获所有异常。例如： ```python try: num = int(input("请输入一个整数：")) print(10/num) except Exception as e: print("发生异常：", e) ``` 在上面的代码中，如果发生任何异常，都会跳转到 `except` 语句块中执行处理代码，并将异常信息打印出来。 除了 `try` 和 `except`，还有 `finally` 关键字，它指定的代码块无论是否发生异常都会执行。例如： ```python try: num = int(input("请输入一个整数：")) print(10/num) except Exception as e: print("发生异常：", e) finally: print("程序执行完毕") ``` 在上面的代码中，无论是否发生异常，都会执行 `finally` 中的代码，即输出“程序执行完毕”。 总之，在Python中，异常处理是非常重要的一部分，它可以有效避免程序崩溃，提高程序的健壮性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值