python numpy pandas 书 全_夯基固本学Python—Numpy与Pandas

数据分析绝对绕不过的三个包是numpy、scipy和pandas。numpy是Python的数值计算扩展，专门用来处理矩阵，它的运算效率比列表更高效。scipy是基于numpy的科学计算包，包括统计、线性代数等工具。pandas是基于numpy的数据分析工具，能更方便的操作大型数据集。

Numpy

numpy的数据结构是n维的数组对象，叫做ndarray。Python的list虽然也能表示，但是不高效，随着列表数据的增加，效率会降低。

载入numpy包，因为它是第三方工具，所以每次使用前必须在代码中载入。as是命名为别名，方便调用，np是numpy约定俗成的简写。

创建素组np.array( )

# 创建数组：array()函数，括号内可以是列表、元祖、数组、生成器等

ar1 = np.array(range(10)) # 整型

ar2 = np.array([1,2,3.14,4,5]) # 浮点型

ar3 = np.array([[1,2,3],('a','b','c')]) # 二维数组：嵌套序列(列表，元祖均可)

ar4 = np.array([[1,2,3],('a','b','c','d')]) # 注意嵌套序列数量不一会怎么样

print(ar1,type(ar1),ar1.dtype)

print(ar2,type(ar2),ar2.dtype)

print(ar3,ar3.shape,ar3.ndim,ar3.size) # 二维数组，共6个元素

print(ar4,ar4.shape,ar4.ndim,ar4.size) # 一维数组，共2个元素

# 结果为：

[0 1 2 3 4 5 6 7 8 9] int32

[ 1. 2. 3.14 4. 5. ] float64

[['1' '2' '3']

['a' 'b' 'c']] (2, 3) 2 6

[[1, 2, 3] ('a', 'b', 'c', 'd')] (2,) 1 2np.arange( )

# 创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。

print(np.arange(10)) # 返回0-9，整型

print(np.arange(10.0)) # 返回0.0-9.0，浮点型

print(np.arange(5,12)) # 返回5-11

print(np.arange(5.0,12,2)) # 返回5.0-12.0，步长为2

print(np.arange(10000)) # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角

# 结果为：

[0 1 2 3 4 5 6 7 8 9]

[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

[ 5 6 7 8 9 10 11]

[ 5. 7. 9. 11.]

[ 0 1 2 ..., 9997 9998 9999]np.linspace( )

# 创建数组：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。

ar1 = np.linspace(2.0, 3.0, num=5)

ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)

ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)

print(ar1,type(ar1))

print(ar2)

print(ar3,type(ar3))

# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

# start：起始值，stop：结束值

# num：生成样本数，默认为50

# endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。

# retstep：如果为真，返回(样本，步骤)，其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

# 结果为：

[ 2. 2.25 2.5 2.75 3. ]

[ 2. 2.2 2.4 2.6 2.8]

(array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)

数组的属性

import numpy as np

ar = np.array([1,2,3,4,5,6,7]) # 使用np.array创建数组

print(ar) # 输出数组，注意数组的格式：中括号，元素之间没有逗号(和列表区分)

print(ar.ndim) # 输出数组维度的个数(轴数)，或者说“秩”，维度的数量也称rank

print(ar.shape) # 数组的维度，对于n行m列的数组，shape为(n，m)

print(ar.size) # 数组的元素总数，对于n行m列的数组，元素总数为n*m

print(ar.dtype) # 数组中元素的类型，类似type()(注意了，type()是函数，.dtype是方法)

print(ar.itemsize) # 数组中每个元素的字节大小，int32l类型字节为4，float64的字节为8

# 结果为：

[1 2 3 4 5 6 7]

1

(7,)

7

int32

4

Numpy通用函数数组形状：.T/.reshape()/.resize()

ar1 = np.arange(10)

ar2 = np.ones((5,2))

print(ar1,'\n',ar1.T)

print(ar2,'\n',ar2.T)

print('------')

# .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变

ar3 = ar1.reshape(2,5) # 用法1：直接将已有数组改变形状

ar4 = np.zeros((4,6)).reshape(3,8) # 用法2：生成数组后直接改变形状

ar5 = np.reshape(np.arange(12),(3,4)) # 用法3：参数内添加数组，目标形状

print(ar1,'\n',ar3)

print(ar4)

print(ar5)

print('------')

# numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！

ar6 = np.resize(np.arange(5),(3,4))

print(ar6)

# numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。

# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！

# 结果为：

[0 1 2 3 4 5 6 7 8 9]

[0 1 2 3 4 5 6 7 8 9]

[[ 1. 1.]

[ 1. 1.]

[ 1. 1.]

[ 1. 1.]

[ 1. 1.]]

[[ 1. 1. 1. 1. 1.]

[ 1. 1. 1. 1. 1.]]

------

[0 1 2 3 4 5 6 7 8 9]

[[0 1 2 3 4]

[5 6 7 8 9]]

[[ 0. 0. 0. 0. 0. 0. 0. 0.]

[ 0. 0. 0. 0. 0. 0. 0. 0.]

[ 0. 0. 0. 0. 0. 0. 0. 0.]]

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

------

[[0 1 2 3]

[4 0 1 2]

[3 4 0 1]]数组类型转换：.astype()

ar1 = np.arange(10,dtype=float)

print(ar1,ar1.dtype)

print('-----')

# 可以在参数位置设置数组类型

ar2 = ar1.astype(np.int32)

print(ar2,ar2.dtype)

print(ar1,ar1.dtype)

# a.astype()：转换数组类型

# 注意：养成好习惯，数组类型用np.int32，而不是直接int32

# 结果为：

[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

-----

[0 1 2 3 4 5 6 7 8 9] int32

[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

Numpy索引及切片索引切片

# 基本索引及切片

ar = np.arange(20)

print(ar)

print(ar[4])

print(ar[3:6])

print('-----')

# 一维数组索引及切片

ar = np.arange(16).reshape(4,4)

print(ar, '数组轴数为%i' %ar.ndim) # 4*4的数组

print(ar[2], '数组轴数为%i' %ar[2].ndim) # 切片为下一维度的一个元素，所以是一维数组

print(ar[2][1]) # 二次索引，得到一维数组中的一个值

print(ar[1:3], '数组轴数为%i' %ar[1:3].ndim) # 切片为两个一维数组组成的二维数组

print(ar[2,2]) # 切片数组中的第三行第三列 → 10

print(ar[:2,1:]) # 切片数组中的1,2行、2,3,4列 → 二维数组

print('-----')

# 二维数组索引及切片

# 结果为：

[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]

4

[3 4 5]

-----

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]

[12 13 14 15]] 数组轴数为2

[ 8 9 10 11] 数组轴数为1

9

[[ 4 5 6 7]

[ 8 9 10 11]] 数组轴数为2

10

[[1 2 3]

[5 6 7]]

-----布尔型索引及切片

# 布尔型索引及切片

ar = np.arange(12).reshape(3,4)

i = np.array([True,False,True])

j = np.array([True,True,False,False])

print(ar)

print(i)

print(j)

print(ar[i,:]) # 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:] = ar[i](简单书写格式)

print(ar[:,j]) # 在第二维度做判断，这里如果ar[:,i]会有警告，因为i是3个元素，而ar在列上有4个

# 布尔型索引：以布尔型的矩阵去做筛选

m = ar > 5

print(m) # 这里m是一个判断矩阵

print(ar[m]) # 用m判断矩阵去筛选ar数组中>5的元素

# 结果为：

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[ True False True]

[ True True False False]

[[ 0 1 2 3]

[ 8 9 10 11]]

[[0 1]

[4 5]

[8 9]]

[[False False False False]

[False False True True]

[ True True True True]]

[ 6 7 8 9 10 11]

Numpy随机数

numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一np.random.normal( ) ：生成一个标准正太分布数组

np.random.rand( ) ：生成一个[0,1)之间的随机浮点数或N维浮点数组 —均匀分布

np.random.randn( )：生成一个浮点数或N维浮点数组 —正态分布

numpy.random.randint( )：生成一个整数或N维整数数组

Pandas

Pandas的数据结构：Series & DataFramePandas数据结构​note.youdao.comPandas的时间模块及操作Pands时间模块​note.youdao.comPandas的基础操作Pandas的基础操作​note.youdao.com