- 1、numpy、pandas之间的关系：
- scipy——数值计算库：理解是一个集成库，包括基础库numpy、数据分析清洗库pandas、可视化库matplotlib等
- numpy——基础：他是一个基础库，用于简单的数学计算和纯数学存储
- pandas——数据分析：数据分析和清洗
- matplotlib——绘图：可视化绘图
- 2、本节英文词汇：axis 数轴、ndim 空间维度、
目录
2、通过内部函数：zeros()、ones()、empty()
3、内部函数 arange()、linspace、logspace()：
4、numpy.random中的random()、randn()、randint()函数：
（1）numpy.random.random()、numpy.random.rand()：
（2）numpy.random.randn()： 生成高斯分布
（5）打乱顺序 np.random.permutation( m )
3、ndarray创建后数据类型更改：对象.astype("")
1、np.hstack np.vstack np.concatenate
（2） 数组 支持 长列表索引，取出索引列表 每个位置对应的值
NLP Numpy、Pandas、Scikit-learn资料：
NLP Numpy、Pandas、Scikit-learn资料下载
一、numpy库的基本知识：
- 1、NumPy的数据类型：ndarray，通常被称作n维数组 , ndarray 可以与 list tuple相互转换
- 2、ndarray只能有一种由相同类型的元素，数组的size一旦定义完成无法改变，但可以改变数组形状。
- 3、元素的数据类型由dtype(data-type)对象来指定，每个ndarray只有一种dtype类型.
- 4、numpy 默认的数据类型 dtype = 'int32'、dtype = 'float64'
- 5、多维数组的0轴、1轴、2轴的理解方法：从最外层向里层递进：
- 5、数组的值是可以修改的（类似列表），例： arr1[arr1 == ' tom'] = 'jerry' ------ bool 索引改值
二、ndarray创建：
1、通过内部array函数：numpy.array()
- 特点：①接收一个普通的python序列，并将其转换为ndarray，可以是多维tuple和list,也可以是一个 dict。
- ② ndarray是一个规则的数据结构，传入的多维数组上下要对齐
import numpy as np
list1 = [[1,2,3],[4,5,6],[7,8,9]]
tuple1 = ((1,2,3),(4,5,6),(7,8,'a'))
print(np.array([1,2,3,4,5]),type(np.array([1,2,3,4,5])))
print(np.array(list1))
print(np.array(tuple1),np.array(tuple1).dtype) ------- 多维数组只有 一种dtype。
# [1 2 3 4 5] <class 'numpy.ndarray'>
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# [['1' '2' '3']
# ['4' '5' '6']
# ['7' '8' 'a']] <U11
----------------------------------------- 传入字典 --------------------------------------
dict1 = {'name':'aa','1':20}
arr = np.array(dict1)
print(arr,type(arr),arr.dtype)
------- 结果 --------
{'name': 'aa', '1': 20} <class 'numpy.ndarray'> object2、通过内部函数：zeros()、ones()、empty()
- 特点：该函数可以创建一维和多维数组。
import numpy as np
print(np.zeros(8)) 一个数字 相当于 1*8的数组
print(np.zeros((4,2))) 创建一个 4*2 的数组
[ 0. 0. 0. 0. 0. 0. 0. 0.]
[[ 0. 0.]
[ 0. 0.]
[ 0. 0.]
[ 0. 0.]]
import numpy as np
print(np.ones(8))
print(np.ones((4,2)))
[ 1. 1. 1. 1. 1. 1. 1. 1.]
[[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]
import numpy as np
print(np.empty(8)) # 创建未初始化的数组
print(np.empty((4,2)))
[ 1. 1. 1. 1. 1. 1. 1. 1.]
[[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]import numpy as np
help(np.dtype) # 查看方法的用法3、内部函数 arange()、linspace、logspace()：
- 特点：此三个函数只能创建一维数组，如果想要多维数组可以通过 reshape（）函数更改维度。
（1）创建等差数列：一维数组
import numpy as np
print(np.arange(1,20,2)) # 只能创建一维数组 ，前闭后开 区间 ，等差数组
import numpy as np
print(np.linspace(1,20,11,endpoint=False)) # 11值得是元素个数，等差数列，可以通过endpoint来控制是否包含终值，默认是闭区间。（2）等比数组：一维数组
import numpy as np
print(np.logspace(1, 2, 5)) # 5是元素个数，等比数列，默认base = 10.0 为底， 闭区间
# [ 10. 17.7827941 31.6227766 56.23413252 100. ]
help(np.logspace)
4、numpy.random中的random()、randn()、randint()函数：
- 特点：此三个函数可以创建多维数组。
（1）numpy.random.random()、numpy.random.rand()：
- 特点：可以创建多维数组，元素用0-1的float填充。
import numpy as np # 填充数字 为 0-1 的浮点型
print(np.random.random(4))
print(np.random.random((3,4,5))) 三维数组，维度用（）括起来。print(np.random.rand(3,4)) ------------- 特点：内部不需要小 （），填充值 0 - 1 的 float：
array([[0.69570197, 0.83366018, 0.4209347 , 0.61494205],
[0.10000352, 0.06254728, 0.52734986, 0.35841483],
[0.71014369, 0.20743027, 0.53953882, 0.13875083]])
（2）numpy.random.randn()： 生成高斯分布
- 第一种：
import numpy as np
arr1 = np.random.randn(3,2) 返回一个样本的标准正态分布 ,这里的多维不能加 小（）。
arr2 = np.random.randn(3,2,4)
print(arr1)
print(arr2)- 第二种：
（3）numpy.random.randint()：
- 特点：区间前闭后开，python中random模块中randint 是区间。
print(np.random.randint(1,9,(3,4))) 随机 整数 多维数组 ，整数可以自定义
print(np.random.randint(1,9,size=(3,4))) 关键字参数传送，结果相同（4）np.random.uniform()：生成均与分布
（5）打乱顺序 np.random.permutation( m )
（7）choice
choice(seq) 从序列seq中随机选择一个元素
>>>random.choice([1,2,3,4,5,6,7,8,9])
8（8）getrandbits(k)
生成一个K比特长的随机整数（转换为十进制的数值范围就是2的K次方）
>>>random.getrandombits(8)
250#范围：0-255，即2的8次方5、创建特殊数组 对角矩阵、单位矩阵
arr7 = np.zeros((2, 3))
print(arr7)
arr8 = np.eye(4)
print(arr8)
arr9 = np.diag((2, 3, 4, 6))
print(arr9)
arr10 = np.ones((3, 4))
print(arr10)[[0. 0. 0.]
[0. 0. 0.]]
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
[[2 0 0 0]
[0 3 0 0]
[0 0 4 0]
[0 0 0 6]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]三、ndarray的属性查看：
1、ndarray 属性查看：ndarray.属性名
arr = np.array([1,2,3,4,5])
print(arr.ndim,arr.shape,arr.size,arr.itemsize) ----------- 1 (5,) 5 4 （本质：取对象的属性）
================= 下面的放式也可以计算非数组类型的属性 =============================
print(np.ndim(arr),np.shape(arr),np.size(arr),np.itemsize(arr) （本质：调用 类方法计算）2、创建ndarray时，可以通过dtype指定数据类型：
- 内容：int 默认为 32位 ，float默认为64位，即int32、float64。
- 特点：① 知道要数组中有一个字符串,数组的dtype类型就会变成 字符串类型
import numpy as np
arr1 = np.random.randint(1,9,(3,4),dtype= "int64")
arr2 = np.random.random((3,4,5,)).dtype
print(arr1.dtype,arr2)
========================================================================
ndarray1 = np.array(
[
['liu','zhang','li','huang','xu',],
['kang',1,'lei','yin','hao',],
])
ndarray1.dtype ---------- 结果:dtype('<U5') 知道要数组中有一个字符串,数组的dtype类型就会变成 字符串类型3、ndarray创建后数据类型更改：对象.astype("")
arr1 = np.array([1,2,3,4],dtype='int32')
print(arr1.dtype)
arr2 = arr1.astype("float") 注意:需要用新的数组接收，原数组类型不变。
print(arr2.dtype，arr1.dtype) 结果: dtype=('int32') dtype('float64')
======================== 也可写成 =======================================
arr1 = np.array([1,2,3,4],dtype=np.int)
arr2 = arr1.astype(np.float) ------ "float" 与 np.float 等价
arr2.dtype 4、常用的numpy的数据类型：
（1）整数类型与bool型数组：
- 特点：① int 默认为 32位
- ② 无符号的 u1等 的u 是小写。
arr1 = np.array([1,2,3,4,0],dtype='bool_') ----- 创建 bool 数组
print(arr1) # [ True True True True False]
arr1 = np.array([1,2,3,4,0],dtype=np.bool_) ----- "数据类型" 可以写成 np.数据类型
print(arr1) # [ True True True True False]
==============================================================================
import numpy as np # 设定字符串类型
ndarray1 = np.array(['kang','san','lei','yin','hao'],dtype = "|U8") --- 结果： , dtype='<U8')
ndarray1 = np.array(['kang','san','lei','yin','hao'],dtype = "|S3") ----- 固定长,会截取字符串
==============================================================================
ndarray1 = np.array(['1','2','3'],dtype = "int32") ---可以转化数据类型,结果:array([1, 2, 3])
ndarray1 = np.array(['1','2','3'],dtype = "float") ---可以转化数据类型,结果:array([1., 2., 3.])（2）浮点数与字符串类型：
- 特点：① 知道要数组中有一个字符串,数组的dtype类型就会变成 字符串类型
- ② |S 与 |U 都是固定长度，定义时如果小于字符串的长度会截取字符串，float默认为64位
- ③
array([[b'liu', b'zhang', b'li', b'huang', b'xu'],
[b'kang', b'san', b'lei', b'yin', b'hao']], dtype='|S8') ----- |S 前面有 b
array([['liu', 'zhang', 'li', 'huang', 'xu'],
['kang', 'san', 'lei', 'yin', 'hao']], dtype='<U8') ----- |U 是默认的实例：
四、ndarray数组改变形状：
① 注意ndarray修改shape与 数组 转置的区别。
②修改数组形状时一定要保持数组元素个数（即size）不变。
1、利用shape属性赋值来改变：
- 特点：① 接受的参数是一个元组
import numpy as np
arr1 = np.random.randint(1,9,(3,4))
arr1.shape = (2,3,2) -------- 修改了原数组的shape，接收的是元组， 小（）不要忘记
print(arr1)
=================================================================================
arr1.shape = (2,3,-1) -------- -1 自动计算轴
print(arr1)2、利用内部函数reshape（）：
- 特点：① 接受的参数是一个元组
- ② 但是新旧数共用一个内存空间，改变一个数字元素，另一个数组也会改变，类似于list 的 引用 。
import numpy as np
arr1 = np.random.randint(1,9,(3,4))
arr2 = arr1.reshape((2,3,2)) ----1、接受的参数是一个元祖(这里面小（）可以不加) 2、生成了新的数组，原数组不变
print(arr2)
print(arr1) -------- 旧数组的shape不变
arr2[0,2,0] = 1000
print(arr1)
print(arr2) -------- 但是新旧数共用一个内存空间，改变一个数字元素，另一个数组也会改变，类似于list浅拷贝。
=======================================================================================
若果想要独立两个空间，可以用 ndarray对象.copy()方法
arr3 = arr2.copy() ---------- arr3 与 arr2、arr1 独立
3、拉平
print(a3.ravel()) # 不改变源数据
print(a3.flatten("C"))
print(a3.flatten("F"))
answer：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[ 0 4 8 1 5 9 2 6 10 3 7 11]五、数组的合并
1、np.hstack np.vstack np.concatenate
arr1 = np.arange(1, 7).reshape((3, 2))
arr2 = np.arange(11, 17).reshape((3, 2))
print(arr1)
print(arr2)
print(np.hstack((arr1, arr2)))
print(np.vstack((arr1, arr2)))
print(np.concatenate((arr1, arr2), axis=1))
print(np.concatenate((arr1, arr2), axis=0))[[1 2]
[3 4]
[5 6]]
[[11 12]
[13 14]
[15 16]]
[[ 1 2 11 12]
[ 3 4 13 14]
[ 5 6 15 16]]
[[ 1 2]
[ 3 4]
[ 5 6]
[11 12]
[13 14]
[15 16]]
[[ 1 2 11 12]
[ 3 4 13 14]
[ 5 6 15 16]]
[[ 1 2]
[ 3 4]
[ 5 6]
[11 12]
[13 14]
[15 16]]六、numpy的基本操作：
1、数组与标量、数组之间的算数运算：
（1）数组间算数运算（非矩阵积）的优点：
① 数组不用循环即可对每个元素执行批量的算术运算操作，这个过程叫做矢量化，即用数组表达式代替循环
的做法。矢量化数组运算性能比纯Python方式快上一两个数据级。
② 大小相等的两个数组之间的任何算术运算都会将其运算应用到元素级上的操作。
（2）数组间算数运算的理解：
① 元素级操作：在NumPy中，大小相等的数组之间的运算，为元素级运算，即只用于位置相同的元素之间，
所得的运算结果组成一个新的数组，运算结果的位置跟操作数位置相同。
② 注意 数组 * 数组 与 数组 矩阵积的区别
（3）数组算数运算实例：
①数组与标量：
import numpy as np
arr1 = np.array([1,2,3,4,5,6,7,8])
print(arr1/2.0)
print(1.0/arr1)
print(arr1**2)
print(2**arr1)②数组与数组之间：
- 大小相等的数组之间的算数运算
（4）数组的广播：
- ① 数组中需要有一个 单行/单列数组，且列数/行数与另一个数组相同。
- ② 通用可以广播规律：两个数组的 shape值 对应位置数字相同 或者 为1，例：shape(2,3,4) 与 shape(2,1,4)
- 可以广播
import numpy as np
arr1 = np.array([1,1,1,1])
arr2 = np.array([[1,2,3,4],
[4,5,6,7],
[7,8,9,10]])
print(arr1+arr2)
[[ 2 3 4 5]
[ 5 6 7 8]
[ 8 9 10 11]]2、ndarray数组的矩阵积：
矩阵积(matrix product)：两个二维矩阵(行和列的矩阵)满足第一个矩阵的列数与第二个矩阵的行数相同，那么可以进行矩阵的乘法，即矩阵积，矩阵积不是元素级的运算。也称为点积、数量积。 Arr1.dot(arr2)
得到的新矩阵：行数由第一个矩阵行数决定，列数由第二个矩阵列数决定。
实例：
七、多维数组的索引与切片：
- ① 先从行开始索引，即[ np.ix_([行],[列]) ],首先索引 0 轴 .....
1、索引：
（1）
import numpy as np
arr1 = np.random.randint(1,9,(3,4,5))
print(arr1)
print(arr1[1,1,3]) 索引 也可以用 arr1[1][1][3]
（2） 数组 支持 长列表索引，取出索引列表 每个位置对应的值
index = np.array([0,1,1,0,1])
a = np.array(['一','二','三'])
print(a[index])
# 结果
['一' '二' '二' '一' '二']
index = [0,1,1,0,1]
a = np.array([['一','二','三'],['四','五','六']])
print(a[index])
# 结果
[['一' '二' '三']
['四' '五' '六']
['四' '五' '六']
['一' '二' '三']
['四' '五' '六']]2、ndarray切片：
https://blog.csdn.net/qq_16555103/article/details/84287384 ------------ numpy库 二
1647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
