- 一、 数据分析环境搭建
- 1. anaconda环境搭建
- 2.pycharm中调用anaconda中的库
- 3.建议的学习顺序
- 二、NumPy学习
- 1.Numpy的数据类型
- a.数据类型
- b.空值
- c.Nan和inf
- 2.Numpy副本和视图
- 3.数组的定义和创建
- a. ndarray数组定义
- b. ndarray数组创建
- 创建一维数组和二维数组
- np.arange(起始值(0),终止值,步长(1))
- np.zeros(数组元素个数, dtype='类型')
- np.ones(数组元素个数, dtype='类型')
- np.random中的函数来创建随机一维数组
- numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
- numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的
- 创建二维数组
- 从已有的数组创建数组
- 4.数组的属性
- 5.数组的维数
- a.什么是轴?
- b.为什么要学习轴?
- c.数组维度有关的属性
- **ndarray.shape**
- **ndarray.size**
- **ndarray.dtype**
- **ndarray.itemsize**
- d.自定义复合类型
- 6.数组索引和切片
- a.索引操作
- b.一维数组切片操作
- c.多维数组的切片操作
- 7.数组的操作
- a.形状操作
- b.数组数值的修改和添加元素
- 删除数组元素
- 7.数组运算
Conda 是一个开源的软件包管理系统和环境管理系统，用于安装多个版本的软件包及其依赖关系，并在它们之间轻松切换。Conda 是为 Python 程序创建的，适用于 Linux，OS X 和Windows，也可以打包和分发其他软件 。最流行的 Python 环境管理工具。
conda官网上下载安装，安装过程不停下一步就行。打开conda,调用里面的jupyter功能。
可以实现在线编写python，并进行可视化分析。
安装好conda之后，之前使用PYcharm 去 pip install matpllotlip的包时候，始终出现错误，方法的根本出发点在于，Pycharm本身缺少numpy和matplotlib这些库，而另一个Python的开发环境Anaconda则自带了300多种常见的库。所以想在pycharm中使用Anaconda自带的库。实现这一“借用”的则是Pycharm中对 “Project Interpreter”的设置，该设置是设定Pychar使用哪一个python编译器。那么只要将该interpreter设置为Anaconda下的python.exe，就可以将Anaconda下众多的库导入到Pycharm中。（这是一种借用conda的方法，但让pycharm自己去调用库的问题始终没有解决）
用pycharm调用conda的库并使用
NumPy是使用Python进行科学计算的基础包，常用于数据分析。NumPy通常与SciPy和Matplotlib一起使用，广泛用于替代matlab，有助于我们学习数据科学或机器学习。
Matplotlib是用于数据可视化的最流行的Python包之一，它是一个跨平台库，用于根据数组中的数据制作2D和简单3D图。
Pandas是一款开放源码的BSD许可的Python库，为Python编程语言提供了高性能，易于使用的数据结构和数据分析工具。Pandas用于广泛的领域，包括金融，经济，统计，分析等学术和商业领域。
Numpy的核心：多维数组
- 代码简洁：减少Python代码中的循环。
- 底层实现：厚内核©+薄接口(Python)，保证性能。
学习numpy，参考视频是numpy学习视频
numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。
| 名称 | 描述 | 字符码 |
|---|---|---|
| np.bool | 用一个字节存储的布尔类型（True或False） | ‘b’ |
| np.int8 | 一个字节大小，-128 至 127 （一个字节） | ‘i’ |
| np.int16 | 整数，-32768 至 32767 （2个字节） | 'i2‘ |
| np.int32 | 整数，（4个字节） | ‘i4’ |
| np.int64 | 整数，（8个字节） | ‘i8’ |
| np.uint8 | 无符号整数，0 至 255 | ‘u’ |
| np.uint16 | 无符号整数，0 至 65535 | ‘u2’ |
| np.uint32 | 无符号整数 | ‘u4’ |
| np.uint64 | 无符号整数 | ‘u8’ |
| np.float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 | ‘f2’ |
| np.float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 | ‘f4’ |
| np.float64 | 双精度浮点数：64位，正负号1位，指数11位，精度52位 | ‘f8’ |
| np.complex64 | 复数，分别用两个32位浮点数表示实部和虚部 | ‘c8’ |
| np.complex128 | 复数，分别用两个64位浮点数表示实部和虚部 | ‘c16’ |
| np.object_ | python对象 | ‘O’ |
| np.string_ | 字符串 | ‘S’ |
| np.unicode_ | unicode类型 | ‘U’ |
## 列表 list01 =[1,2,3,4,5,6] list02 =list01#两个地址是一样的，都是指向同一个内存地址 print(list01,list02) print(id(list01)) print(id(list02)) # copy()函数，浅复制 list02=list01.copy() print(id(list01)) print(id(list02)) ## 深复制 #导入模块 import copy list03 = [1,2,3,[4,5,6]] print(list03) list03 list04=copy.deepcopy(list03) list04 #修改list01第三个元素中的第0个数值 list03[3][0]=100 list03 list043.数组的定义和创建
用np.ndarray类的对象表示n维数组
import numpy as np ary = np.array([1, 2, 3, 4, 5, 6]) print(type(ary),ary) #b. ndarray数组创建[1 2 3 4 5 6]
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
import numpy as np # 用np代替numpy,让代码更简洁 a = [1,2,3,4] # 创建列表a b = np.array([1,2,3,4]) # 从列表a创建数组b，array就是数组的意思 print(a) print(type(a)) # 打印a的类型 print(b) print(type(b)) # 打印b的类型 #观察输出值的区别，列表和数组的区别是什么？ #[1, 2, 3, 4] ##[1 2 3 4] #
创建数组的几种方式：
创建一维数组和二维数组# 创建一维数组 c = np.array([5,6,7,8]) print(c) # 创建二维数组 d = np.array([[1,2],[3,4],[5,6]]) print(d) print(type(d)) #[5 6 7 8] #[[1 2] # [3 4] #[5 6]]np.arange(起始值(0),终止值,步长(1))
numpy.arange(start, stop, step, dtype) # 1个参数:参数值为终止值，起始值取默认值0，步长为1，左闭右开 x = np.arange(5) print(x) # 2个参数:参数值为起始值，终止值，步长默认为1 ，左闭右开 y = np.arange(5,10) print(y) # 3个参数:参数值为起始值，终止值，步长为2 ，左闭右开 z = np.arange(10,20,2) print(z) #[0 1 2 3 4] #[5 6 7 8 9] #[10 12 14 16 18]np.zeros(数组元素个数, dtype=‘类型’)
numpy.zeros(shape, dtype = float, order = 'C') e = np.zeros(10) print(e) #[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]np.ones(数组元素个数, dtype=‘类型’)
numpy.ones(shape, dtype = None, order = 'C') f = np.ones(10) print(f) #[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]np.random中的函数来创建随机一维数组
-
np.random.randn()
创建一个一维数组，其中包含服从标准正态分布（均值为0、标准差为1的分布）的n个随机数
-
np.random.rand()
生成的一维数组中包含的就是0～1之间的n个随机数
# 创建一个包含5个随机数的正态分布一维数组 g = np.random.randn(5) print(g) # 创建一个范围在0~1之间的含有5个随机数的一维数组 h = np.random.rand(5) print(h) #[ 0.68384377 0.278969 0.31402352 -0.19564941 -0.07348227] #[0.59140982 0.77833598 0.33633508 0.46787355 0.34251799]
# 其他函数 zeros_like， ones_like， empty， empty_like， linspace， numpy.random.Generator.rand， numpy.random.Generator.randn， fromfunction， fromfile，set_printoptionsnumpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
numpy.empty(shape, dtype = float, order = 'C') import numpy as np x = np.empty((3,2), dtype = int) print (x) #[[ 869667760 589] # [ 253155624 -618297307] # [ 869667824 589]]numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
import numpy as np a = np.linspace(1,10,10) print(a) # [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]创建二维数组
- 创建一维数组的np.arange()函数和reshape()函数来创建二维数组
# 创建一个3行4列的二维数组
i = np.arange(12).reshape(3,4)
print(i)
#[[ 0 1 2 3]
# [ 4 5 6 7]
#[ 8 9 10 11]]
- np.random.randint()函数用于创建随机整数数组
j = np.random.randint(0,10,(4,4))
print(j)
# 括号里第1个参数0为起始数，第2个参数10为终止数，第3个参数（4,4）则表示创建一个4行4列的二维数组。
#[[6 5 7 2]
#[9 3 8 7]
#[1 1 4 3]
#[5 6 6 7]]
从已有的数组创建数组
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个
numpy.asarray(a, dtype = None, order = None)
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print (a)
#[1 2 3]
4.数组的属性
- ndarray.shape - 维度，数组的尺寸。这是一个整数元组，指示每个维度中数组的大小。对于具有n行和m列的矩阵(n,m)
- ndarray.dtype - 描述数组中元素类型的对象。
- ndarray.size - 数组元素的总数。等于shape的乘积。
- ndarray.ndim - 数组的轴数（尺寸）。len(shape)(长度)。
- ndarray.itemsize - 数组中每个元素的大小（以字节为单位）。
- ndarray.nbytes - 总字节数 = size x itemsize。
- ndarray.real - 复数数组的实部数组。
- ndarray.imag - 复数数组的虚部数组。
- ndarray.T - 数组对象的转置视图。
- ndarray.flat - 扁平迭代器。
数组的轴数（尺寸）
a.什么是轴? 在numpy中可以理解为方向，使用0，1，2数字表示
对于1维数组，只有一个0轴;
对于2维数组（shape（2，2))有0轴和1轴;
对于3维数组（shape（2，2，3））有0，1，2轴;
b.为什么要学习轴? 有了轴的概念后，我们计算会更加方便，比如计算一个2维数组的平均值，必须指定是计算哪个方向上面的数字的平均值。
import numpy as np a = np.array([[1, 2, 3], [4, 5, 6]]) print(np.sum(a, axis=0)) print(np.sum(a, axis=1)) print(np.sum(a)) # 计算所有的值的和 # 三维的数据 a = np.arange(27).reshape((3, 3, 3)) print(a) b = np.sum(a, axis=0) print(b) c = np.sum(a, axis=2) print(c) ’‘’’‘’‘’’‘’‘’‘’’‘编译结果如下: [5 7 9] [ 6 15] 21 [[[ 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 30 33] [36 39 42] [45 48 51]] [[ 3 12 21] [30 39 48] [57 66 75]]
总结： 在计算的时候可以想象成是每一个坐标轴，分别计算这个轴上面的每一个刻度上的值，或者在二维数组中记住0表示行1表示行列。
import numpy as np
ary = np.array([
[1,2,3,4],
[5,6,7,8]
])
print(ary.ndim)
#2
c.数组维度有关的属性
ndarray.shape
数组的维度。这是一个整数元组，指示每个维度中数组的大小。对于具有n行和m列的矩阵，shape将为(n,m)。shape因此，元组的长度 是轴数ndim。
import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary), ary, ary.shape,ary.dtype)
#二维数组
ary = np.array([
[1,2,3,4],
[5,6,7,8]
])
print(type(ary), ary, ary.shape)
# [1 2 3 4 5 6] (6,) int32
# [[1 2 3 4],[5 6 7 8]] (2, 4)
ndarray.size
数组元素的个数。这等于的shape的乘积。
import numpy as np
ary = np.array([
[1,2,3,4],
[5,6,7,8]
])
# 观察shape，size，len的区别
print(ary.shape, ary.size, len(ary))
(2, 4) 8 2
ndarray.dtype
描述数组中元素类型的对象。可以使用标准Python类型创建或指定dtype。另外，NumPy提供了自己的类型。numpy.int32，numpy.int16和numpy.float64是一些示例。
import numpy as np ary = np.array([1, 2, 3, 4, 5, 6]) print(type(ary), ary, ary.dtype) #转换ary元素的类型 b = ary.astype(float) print(type(b), b, b.dtype) #转换ary元素的类型 c = ary.astype(str) print(type(c), c, c.dtype)ndarray.itemsize
数组中每个元素的大小（以字节为单位）。例如，类型为元素的数组float64具有itemsize8（= 64/8），而类型complex32中的一个具有itemsize4（= 32/8）。等同于ndarray.dtype.itemsize。
import numpy as np
a = np.arange(15).reshape(3, 5)
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
a.itemsize
d.自定义复合类型
# 自定义复合类型
import numpy as np
data=[
('zs', [90, 80, 85], 15),
('ls', [92, 81, 83], 16),
('ww', [95, 85, 95], 15)
]
#第一种设置dtype的方式
a = np.array(data, dtype='U3, 3int32, int32')
print(a)
print(a[0]['f0'], ":", a[0]['f1'])
print("=====================================")
#第二种设置dtype的方式
b = np.array(data, dtype=[('name', 'str_', 2),
('scores', 'int32', 3),
('age', 'int32', 1)])
print(b[0]['name'], ":", b[0]['scores'])
print("=====================================")
#第三种设置dtype的方式
c = np.array(data, dtype={'names': ['name', 'scores', 'ages'],
'formats': ['U3', '3int32', 'int32']})
print(c[0]['name'], ":", c[0]['scores'], ":", c.itemsize)
zs : [90 80 85] : 15 28 # 元素字节数
print("=====================================")
#第四种设置dtype的方式
d = np.array(data, dtype={'name': ('U3', 0),
'scores': ('3int32', 16),
'age': ('int32', 28)})
print(d[0]['names'], d[0]['scores'], d.itemsize)
print("=====================================")
#测试日期类型数组
f = np.array(['2011', '2012-01-01', '2013-01-01 01:01:01','2011-02-01'])
['2011' '2012-01-01' '2013-01-01 01:01:01' '2011-01-01']
f = f.astype('M8[D]')
['2011-01-01' '2012-01-01' '2013-01-01' '2011-01-01']
f = f.astype('i4')
[14975 15340 15706 14975]
print(f[3]-f[0])
0
f.astype('bool')
array([ True, True, True, True])
6.数组索引和切片
a.索引操作
一般索引：
import numpy as np array01=np.arange(1,10) array01[5]#索引 list02=[[1,2,3,4,5],[7,8,9,10,11],[12,34,6,6,8]] array03=np.array(list02) array03[0,3]#索引
高级索引：NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。
高级索引-菜鸟笔记
数组对象切片的参数设置与列表切片参数类似
步长+：默认切从首到尾
步长-：默认切从尾到首
数组对象[起始位置:终止位置:步长, …]
默认位置步长：1
import numpy as np a = np.arange(1, 10) print(a) print(a[:3]) print(a[3:6]) print(a[6:]) print(a[::-1]) print(a[:-4:-1]) print(a[-4:-7:-1]) print(a[-7::-1]) print(a[::]) print(a[:]) print(a[::3]) print(a[1::3]) print(a[2::3])c.多维数组的切片操作
数组对象[页号, 行号, 列号]，下标从0开始，到数组len-1结束。
import numpy as np a = np.arange(1, 28).reshape(3,3,3) print(a) #切出1页 print(a[1, :, :]) #切出所有页的1行 print(a[:, 1, :]) #切出0页的1行1列 print(a[0, :, 1])
练习：
import numpy as np
a = np.arange(10)
print(a[2:7:2])
print(a[2],a)
print(a[2:])
t1 = np.arange(24).reshape(4,6)
print(t1)
print('*'*20)
print(t1[1])
print(t1[1,:])
print(t1[1:])
print(t1[1:3,:])
print(t1[[0,2,3]])
print(t1[[0,2,3],:])
print(t1[:,1])
print(t1[:,1:])
print(t1[:,[0,2,3]])
print(t1[2,3])
print(t1[[0,1,1],[0,1,3]])
7.数组的操作
a.形状操作
以下代码是看视频写在jupyter notebook上的代码。 import numpy as np array01=np.arange(32) array01 array01.shape array01.ndim #就地变维:直接改变原数组对象的维度，不返回新数组 array01.shape=(1,32) array01 array01.shape=(2,16) array01 array01.shape=(4,8) array01 array01.shape=(32,1) array01 array01.shape=(2,4,4) array01 #就地变维：等同于上面。 array01.resize(2,4,4) array01 #复制变维:两个内存地址，数据独立 array02=array01.flatten() array02 print(id(array01)) print(id(array02)) #视图变维（表面上看是一个4行8列的，但是本质上来说， #他并没改变，只是视图上的变维，本质是没有任何改变） array02.reshape(4,8) array02 array03=array02.reshape(4,8) array03 print(id(array03)) print(id(array02)) #raval() array03=array02.reshape(4,8) array03 array03.shape array03.ndim np.ravel(array03,order="C") np.ravel(array03,order="F") array03b.数组数值的修改和添加元素
这段代码是参考上述视频编写的学习代码 import numpy as np t=np.arange(24).reshape(4,6) t #整数的索引和切片 t[1,2]=800 t t[0:2,0:2] #整数数组索引 t[[0,1,2],[0,1,3]]=500 t #布尔索引 t[t>15]=1500 t #花式索引 t[t>15]=1500 t #数组数值的修改 t[1,:]=0 t t[:,1]=0 t t[1:3,:]=0 t t[:,1:4]=0 t t[1:4,2:5]=0 t t[[0,1],[0,3]]=0 t #数组添加元素;append()添加 array02=np.arange(24).reshape(4,6) array02 array03=np.append(array02,25) array03 print(id(array02)) print(id(array03)) array04=np.arange(6) array03=np.append(array02,array04)#没有axis就直接拉平 array03 array04=np.arange(6) array04 array04=np.arange(6).reshape(1,6) array04 array03=np.append(array02,array04,axis=0)#以行为标准 array03 array04=np.arange(4).reshape(4,1) array04 array03=np.append(array02,array04,axis=1)#以列为标准 array03 #insert添加 array02 array04=np.arange(4) array04 array05=np.insert(array02,2,array04,axis=1) array05 array02删除数组元素 7.数组运算
