[学习笔记] Numpy基础

上专业选修《数据分析程序设计》课程，老师串讲了Numpy基础，边听边用jupyter敲了下——理解+笔记。

老师讲的很全很系统，有些点没有记录，在PPT里就不搬了。

环境：python3.6 vscode+jupyter扩展

#%%

#------------------------------2019.9.23 NumPy-----------------------------

import numpy as np

# 1.NumPy在一个连续的内存块中存储数据

# 2.性能差异

my_arr = np.arange(100000)

my_list = list(range(10000))

print(my_arr)

#%%

# 1.ndarry:一种多维数组对象

data = np.random.randn(2,3)

print(data,'\n')

print(data*10,'\n')

print(data+data,'\n')

# 1.1.ndarry通用的同构数据多为容器——所有元素必须是相同类型的

# .shape 返回表示各维度大小的元组

# .dtype 返回类型

print(data.shape)

print(data.dtype)

#%%

# 1.2.创建ndarry

# 1.2.1.用array函数直接创建，dtype自动判定

data_list = [1,1.5,2]

arr1 = np.array(data_list)

print(arr1)

data2 = [[1,2,3,4],[5,6,7,8]]

arr2 = np.array(data2)

print(arr2.dtype)

# 可以用属性ndim和shape验证

arr2.ndim   #只返回维数

# eg:arr_empty = np.empty((2,3,4,2))

# arr_empty为4

#%%

#一般numpy创建的数组类型为浮点数

# 1.2.2特定函数创建数组，传入表示形状的元组即可。

# zeros

# ones

# empty 创建一个没有任何具体值的数组

arr_zero = np.zeros(10)

arr_one = np.ones((2,3))

arr_empty = np.empty((2,3,4,2))

print(arr_zero)

print(arr_one)

print(arr_empty)

print(arr_empty.ndim)

# arange

np.arange(15)

# 位矩阵

#%%

# 1.3类型

# 创建时指定

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

arr4 = np.array([1,2,3],dtype='float64')

print(arr3.dtype)

print(arr4.dtype)

# 转换类型

arr3 = arr3.astype(np.float64)

print(arr3.dtype)

# 浮点型转整数——舍弃小数点后

arr_float = np.random.rand(1,10)*10

print(arr_float)

arr_float = arr_float.astype(np.int32)

print(arr_float)

# 某字符串数组表示的全是数字，可以直接用astype转为数值形式

arr_string = np.array(['1.0','2.0','3.0'])

print(arr_string.dtype)

arr_string = arr_string.astype(np.float64)

print(arr_string.dtype)

print(arr_string)

#adtype总会创建一个数据备份，即使现类型和目标类型相同

#%%

# 1.4运算

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

print(arr)

print(arr-arr)

print(arr*arr)

print(1/arr)

print(arr**0.5)     #和标量运算，数组每个元素都和此标量运算

arr_compare = np.array([ [0,4,1], [7,2,12] ])

print(arr_compare > arr)

#%%

# 1.5切片、索引

# 对数字切片的修改，是直接对数组本身修改（python的list列表不是,是对副本操作）

# 对ndarray切片的副本操作：arr[5:8].cpoy()。这样不更改原数组

arr_sl = np.arange(10)

print(arr_sl)

arr_sl[3:6] = 999   #广播

print(arr_sl)

arr_slice = arr_sl[3:6]

arr_slice[:] = 888

print(arr_sl)

li = list(range(10))

list_slice = li[2:8]

list_slice[0] = 666

print(list_slice)

print(li)

arr2d = np.array([[1.,2.,3.], [4.,5.,6.]])

#索引

print(arr2d[0][1])

#同

print(arr2d[0,1])

#多维数组中，若省略了后面的索引，则返回对象是一个维度低一点的ndarray

arr3d = np.array([ [ [1,2,3],[4,5,6] ], [ [7,8,9],[10,11,12] ] ])

print(arr3d.shape)

print(arr3d)

print(arr3d[0,1])   # 访问索引已(0,1)开头的那些值

arr3d[0] = 999

print(arr3d)

#%%

#1.6布尔

# 布尔型索引选取数组中的数据，总是创建副本，即使返回一模一样的数组也是

names = np.array(['Bob','Peter','Bob','Jenny'])

data_arr = np.random.randn(4,7)

print(data_arr)

arr_bool = names=='Bob'

print(arr_bool)     #[ True False  True False]

print(data_arr[arr_bool])

print('------------------------')

print(data_arr[names=='Bob',5:])    #选取Bob,并索引列

#%%

# 1.6.2 布尔取反

# way1:

names!='Bob'

# way2:

data_arr[~(names=='Bob')]

#%%

# 1.6.3 布尔组合

mask = (names=='Bob')|(names=='Peter')

data_arr[mask]

data_arr[data_arr>1]

#%%

# 1.7花式索引

# 为了按特定顺序选中数据，那么传入表示顺序的[]即可

data = np.arange(80).reshape((8,10))

data[[3,1,4]]

data[[1,5,3],[0,3,2]]   #返回(1,0),(5,3),(3,2)位置的数据

data[[1,5,7,2]][:,[0,3,1,2]]    #列所有元素都输出，但按0 3 1 2的顺序

#       行          列

#%%

# 1.7.1花式索引的转置

# 花式索引和切片不一样，它总是副本

# 转置不是副本，是本身

arr = np.arange(15).reshape((3,5))

arr.T

# transpose 高维数组转置

#%%

# 2.通用数组

arr = np.arange(10)

print(np.sqrt(arr))

print(arr)

# 每个位置上，最大的那个

# np.maximum(x,y)

# 分别返回小数部分、整数部分

remainder, whole_part = np.modf(arr)

print(remainder)

print(whole_part)

# abs

# square

# exp

# log log10 log2 log1p

# ...

#%%

# 3利用数组进行数据处理

# 3.1

points = np.arange(-5,5,0.01)

xs,ys = np.meshgrid(points,points)  # 生成网格点坐标矩阵

ys

# 3.2 np.where

arr = np.random.randn(3,4)

print(arr)

print(np.where(arr>0,2,-2))

# 3.3数学和统计方法

# 既可以当实例方法，也可以当*numpy函数用

print(arr.mean())

# 对特定轴向

arr.mean(axis=0)    #对列求

# 或

arr.mean(0)

arr.sort(1)     #对行排序就地排序

np.unique(arr)  #删除重复的元素

# cumsum对特定轴

arr = np.arange(9).reshape(3,3)

print(arr)

print(arr.cumsum(1))

# 同理 cumprod 累乘

# 对布尔型

arr = np.random.randn(100)

print( (arr>0).sum() )

# any() 检查数组中是否存在>=1个True

# all() 检查数组中是否全为True

#%%

# 4.线性代数

# x.dot(y) 同 np.dot(x,y)

# diag    返回对角线矩阵

# trace

# det

# eig

# inv

# pinv

# qr

# svd

#%%

# 5.伪随机数生成

# 正态分布

samples = np.random.normal(size=(3,3))

# 标准整体分布

ss = np.random.randn(3)

# 给定上下限随机整数

sss = np.random.randint(10,size=(4))    # [4 6 4 1]