了解numpy
Numpy是Numerical Python的简称，是高性能计算和数据法分析的基础包，是Python的一个重要扩充库。Numpy支持高纬度数组和矩阵运算，也针对数组运算提供了大量的数学函数库。Numpy运算效率极好，是大量机器学习框架的基础库。
Numpy中主要包括一个强大的N维数组对象ndarray。ndarray对象是一系列同类型数据的集合。下标索引从0开始，是一个用于存储同类型元素的多维数组。ndarray中的每个元素在内存都拥有相同大小的存储区域。
关于ndarray
属性：
数组形状shape:是一个表示数组各维大小的整数元组
数据类型dtype:是一个描述数组的类型对象。对象类型为Numpy中的24中数组标量类型中的一种
数组数据data:是一个指向内存中数据的指针
跨度strides:一个元组，是当前纬度的宽，表示当前纬度移动到下一个位置需要跨越的字节数。跨度可以是负数，这样会使得数组在内存中向后移动。
数组顺序order:访问数组元素的主序列，如“C”为行主序，“F”代表列主序等
构建ndarray数组：
在Numpy模块中，提供了ndarray()和array()两个方法来创建ndarray。因为ndarray()是底层的方法，所以一般情况下，建立数组都是用的是array()方法。
函数格式：
numpy.array(object, dtype= None, copy=Tye, order=None, subok=False, ndmin=0)
object: 数组或嵌套的数组
dtype: 数组元素的数据类型，从numpy中的24中数据类型中选择
order: 创建数组的样式，和前面的数组顺序order的含义一样
ndmin: 指定所生成数组应具有的最小纬度
实例：
# 创建一个一维数组
# 创建一个二维数组同理
import numpy as np
array = np.array([1,2,3])
print(a)
import numpy as np
array = np.array([1,2,3], dtype=np.float16, ndmin=1)
print(array)
Numpy的数据类型
bool_: 布尔类型，True或者False
int8: 有符号字节类型，范围为-128 ~ 127
int16:有符号16位整数，范围为-32768 ~ 32767
int32:有符号32位整数，范围为-2^31 ~ 2^31-1
int64:有符号64位整数，范围为-2^63 ~ 2^63-1
uint8:无符号字节类型，范围为0 ~ 255
uint16:无符号16位整数，范围为0 ~ 65535
uint32:无符号32位整数，范围为0 ~ 2^32-1
uint64:无符号64位整数，范围为0 ~ 2^64-1
float_:64位浮点数，同float64
float16:16位浮点数
float32:32位浮点数
float64:64位（双精度浮点数），同float_
complex_:128位复数，同complex128
complex64:64位复数
complex128:128位复数，同complex_
数据类型对象（dtype）
Numpy中的dtype是由nupy.dtype类产生的数据类型对象，其作用是描述数组元素对应的内存区域的各部分的使用。
其内部结构包括数据类型、数据的字节数、各组成部分的顺序、各字段的名称等。
构造dtype对象的函数：
numpy.dtype(object, align, copy)
参数说明：
object: 要转换为dtype对象的数据对象
align：如果为True，则填充字段使其类似C的结构体
copy：指明是否赋值dtype对象。如果为False，则是对内置数据类型对象的引用
实例：
import numpy as np
# 使用dtype设置数据类型
x = np.float64(5)
print(x)
y = np.array(x, dtype=np.int64) # 转化为int类型的数据
print(y)
dt = np.dtype('int64')
print(dt)
5.0
5
int64
使用astype()修改数据类型
在数组建立之后，也可以使用Numpy中数组附带的astype()方法修改其数据类型。
函数使用：
array.astype(dtype, order, casting, subok, copy)
dtype: 要修改的数据类型
order: 前面的数组顺序order的含义一样
copy: 指明是否赋值dtype对象。
实例：
import numpy as np
arr = np.array([1, 2, 3])
print(arr.dtype)
arr = arr.astype(dtype=np.float32) # 这里要记得赋值回去
print(arr.dtype)
print(arr)
int32
float32
[1. 2. 3.]
Numpy数组属性
1、常用术语：
axis（轴）：每个线性数组成为一个轴，轴即数组的维度。例如，将二维数组看做以为数组，此一维数组中的每个元素又是一个一维数组，
则每个一维数组是Numpy中的轴。第一个轴相当于底层数组，第二个轴是底层数组中的数组。
rank（秩）：秩描述Numpy数组的维度，即州的数量，一维数组的值为1，二维数组的值为2，以此类推。
在使用的时候可以声明axis。如果axis=0，则表示按第0周方向操作，即对每一列进行操作；如果axis=1，则是对每一行进行操作。
案例：
import numpy as np
arr = np.array([[1,2,3], [6,7,8]])
print(arr)
print(arr.sum(axis=0))
print(arr.sum(axis=1))
[[1 2 3]
[6 7 8]]
[ 7 9 11]
[ 6 21]
基本属性:
ndarray.ndim: 秩，轴的数量
ndarray.shape: 数组的维度
ndarray.size: 数组元素的总个数
ndarray.dtype: 数组元素类型
ndarray.itemsize: 每个元素的大小(B)
ndarray.data: 实际数组元素
在ndarray.ndim返回这个数组的维度，等于秩。reshape()函数可以将数组变形重构，调整数组各维度的大小
reshape()函数的格式：
numpy.reshape(a, newshape, order=‘C’)
案例：
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7])
print(arr.ndim)
arr3D = arr.reshape((2,4))
print(arr3D)
1
[[0 1 2 3]
[4 5 6 7]]
import numpy as np
# 使用arr.shape调整数组的维度
arr = np.array([0,1,2,3,4,5,6,7])
arr.shape = (4, 2)
print(arr)
[[0 1]
[2 3]
[4 5]
[6 7]]
其他创建数组的方法
1、empty：
numpy.empty(shape, dtype=np.float64, order=‘C’)
该函数能创建一个指定形状、数据类型的空数组。这个数组没有经过初始化。
参数含义：
shape: 数组形状
dtype: 数据类型，可选
order: 有‘C’和‘F’两种选项，两种选项的意义与前面的意义相同
实例：
import numpy as np
arr = np.empty([4,3], dtype=np.int64) # 需要注意，由于所用的空间没有进行初始化，所以运行之后得到的值是不确定的
print(arr)
[[ 2875735890248 64 0]
[ 0 223338299392 7364060715054281785]
[3703194961231557170 3631089009351275570 3775813319067448885]
[3487527970877289785 4049972162539381298 7221632169245028665]]
2、zeros:
numpy.zeros(shape, dtype=float, order='C)
这个函数能创建一个全0填充的数组。
参数含义：与上面相同
import numpy as np
x = np.zeros(5) # 默认为浮点数
print(x)
y = np.zeros((5,), dtype=np.int64) # 设置类型为整数
print(y)
arr = np.zeros((5,5), dtype=np.int64) # 这里生成了一个5*5的数组
print(arr)
arr = np.zeros((2,3), dtype = [('float64', 'int64'), ('i1', 'float64'), ('i8','float32')]) # 自定义数据类型
print(arr)
[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]
[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.) (0, 0., 0.)]]
3、ones
numpy.ones(shape, dtype=float, order=‘C’)
填充一个全1的数组
产生数列的函数
在进行科学运算是，经常使用到基本的简单数列，如1-50等，。python中提供了range()函数。而在Numpy中则提供了类似的函数，如arange(), linspace()等函数
1、range() 函数
range函数通常在for循环中见到，range函数通过指定起始值，终值和步长可以传一个一维数组。生成的一维数组不包含终值。
格式：
range(start, stop, [,step])
所生成的数组从start开始，到stop-1结束，步长为step，默认情况下start=0，step=1，而且step必须要是整数
2、arange()函数
Numpy的arange()函数功能与range()相似，在start开始到stop的范围内，生成一个ndarray数组。
格式：
arange([start,] stop [, step,] dtype=None)
实例：
import numpy as np
arr = np.arange(0, 10, 0.2)
print(arr)
[0. 0.2 0.4 0.6 0.8 1. 1.2 1.4 1.6 1.8 2. 2.2 2.4 2.6 2.8 3. 3.2 3.4
3.6 3.8 4. 4.2 4.4 4.6 4.8 5. 5.2 5.4 5.6 5.8 6. 6.2 6.4 6.6 6.8 7.
7.2 7.4 7.6 7.8 8. 8.2 8.4 8.6 8.8 9. 9.2 9.4 9.6 9.8]
3、linspace()函数
Numpy的linspace函数根据起始值，终值生成指定个数的样本数
格式：
numpy.linspace(start, stop, num, endpoint=True, retstep=False, dtype=None)
实例：
import numpy as np
arr = np.linspace(start=0, stop=10, num=50, endpoint=False, retstep=True, dtype=np.float32)
print(arr)
(array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. , 2.2, 2.4,
2.6, 2.8, 3. , 3.2, 3.4, 3.6, 3.8, 4. , 4.2, 4.4, 4.6, 4.8, 5. ,
5.2, 5.4, 5.6, 5.8, 6. , 6.2, 6.4, 6.6, 6.8, 7. , 7.2, 7.4, 7.6,
7.8, 8. , 8.2, 8.4, 8.6, 8.8, 9. , 9.2, 9.4, 9.6, 9.8],
dtype=float32), 0.2)
使用随机函数创建数组
在Numpy中的random子模块中还提供了随机函数，常见函数如下图：
rand(d0, d1,…,dn): 随机生成指定纬度的浮点数组
randint(low, hight, size, dtype): 随机生成[low, high]的整数
random([size]): 随机产生[0.0, 1.0]的浮点数
uniform(start, end, size): 从[start, end]均匀分布的数据中随机抽取一组浮点数
normal(loc, scale, size): 基于给定的均值和方差，随机产生一组正态分布的浮点数
实例：
import numpy as np
arr = np.random.rand(2,3) # 生成两行三列的随机浮点数数组
print(arr)
arr = np.random.randint(0, 10, (2, 3)) # 生成两行三列的10以内随机整数数组
print(arr)
arr = np.random.random((2, 3)) # 生成2行3列的0-1之间浮点数的数组
print(arr)
arr = np.random.uniform(1, 2, (2, 3)) # 生成两行三列的[1,2)的随机浮点数组
print(arr)
[[0.30614812 0.93304496 0.94005095]
[0.53064454 0.50410921 0.14695257]]
[[0 0 6]
[0 3 2]]
[[0.16012226 0.44020527 0.32024027]
[0.66336213 0.72225233 0.14854609]]
[[1.2322809 1.44797148 1.2532598 ]
[1.08514408 1.55828985 1.06121751]]
其他数据类型转换成ndarray
Numpy中可以通过array()函数，将Python中常见的数值序列，如List等转换为ndarray数组
实例：
import numpy as np
myList = [1,2,2]
print(type(myList))
myNdarray = np.array(myList)
print(type(myNdarray))
<class 'list'>
<class 'numpy.ndarray'>
切片、迭代和索引
切片是指去数据序列对象的一部分的操作。ndarray数组与其他数据类型类似，也可以进行索引、切片和迭代
1、切片
对ndarray进行切片操作与一维数组相同，用索引标记切片的起始和终止位置即可。因为ndarray可以是多维数组，在进行切片时，
通常需要设定每个维度上的切片位置。
同时Numpy还提供了一个copy方法，可以根据现有的ndarray数组创建新的ndarray数组。使用copy方法与切片，可以使用元素组的一部分生成新数组。
切片实例：
import numpy as np
arr = np.arange(0, 24, 0.5).reshape(8, 6)
print(arr)
arr = arr[3:, 1:4] ## 从第3+1行开始到最后一行，从第2列到第4列的数组
print(arr)
[[ 0. 0.5 1. 1.5 2. 2.5]
[ 3. 3.5 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5 8. 8.5]
[ 9. 9.5 10. 10.5 11. 11.5]
[12. 12.5 13. 13.5 14. 14.5]
[15. 15.5 16. 16.5 17. 17.5]
[18. 18.5 19. 19.5 20. 20.5]
[21. 21.5 22. 22.5 23. 23.5]]
[[ 9.5 10. 10.5]
[12.5 13. 13.5]
[15.5 16. 16.5]
[18.5 19. 19.5]
[21.5 22. 22.5]]
import numpy as np
# 使用copy函数对数组进行切片复制
arr = np.arange(0, 24, 1).reshape(4, 6)
print(arr)
arr2 = np.copy(arr[1:4, :3])
print(arr2)
arr3 = np.copy(arr2)
print(arr2)
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[[ 6 7 8]
[12 13 14]
[18 19 20]]
[[ 6 7 8]
[12 13 14]
[18 19 20]]
迭代
与其他数据序列类似，ndarray也可以通过for循环进行迭代。当维数多余1维时，迭代操作使用嵌套的for循环。
迭代时，通常按照第一条轴对二维数组进行扫描。如果需要按照掐他方法进行迭代，可以使用apply_along_axis(func, axis, arr)函数函数指定当前处理的轴。
此外，Numpy还包含一个循环迭代器类Numpy.nditer，所生成的迭代器对象是一个根据位置进行遍历的对象。这是一个有效的多维迭代器对象，与Python的iter()函数类似，每个数组元素可使用迭代器对象来访问，从而很方便的对数组进行遍历。
迭代实例：
1、使用嵌套for循环对ndarray数组进行迭代遍历：
import numpy as np
a = np.arange(0, 20, 1).reshape(4, 5)
for arr in a:
for num in arr:
print(num, end=' ')
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
2、使用迭代器对ndarray数组进行迭代
import numpy as np
a = np.arange(0, 20, 1).reshape(4, 5)
for num in np.nditer(a):
print(num, end=' ')
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
3、使用迭代器并指定数组的访问顺序
import numpy as np
a = np.arange(0, 20, 1).reshape(4, 5)
print(a)
for num in np.nditer(a, order='C'):
print(num, end=" ")
print()
for num in np.nditer(a, order='F'):
print(num, end=" ")
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
0 5 10 15 1 6 11 16 2 7 12 17 3 8 13 18 4 9 14 19
Numpy计算
Numpy中的ndarray可以直接进行基本运算，包括条件运算、统计运算，以及基本数组运算
条件运算
Numpy中的条件运算出了常见的比较大小运算还可以使用where函数事项查找操作。
格式：
where(condition, x if true, y if false)
案例：
简单条件运算：
import numpy as np
scores = np.random.randint(70, 90, 10) # .reshape(2, 5)
print(scores)
result = [scores > 80]
print(result)
[[73 77 89 72 74]
[77 84 81 88 78]]
[array([[False, False, True, False, False],
[False, True, True, True, False]])]
使用where函数实现数据筛选：
import numpy as np
arr = np.random.randint(70, 90, 20).reshape(4, 5)
print(arr)
arr[arr < 80] = 0
print(arr)
print(np.where(arr > 80, 1, 0))
[[89 89 74 71 81]
[81 72 84 82 88]
[74 81 80 83 86]
[79 88 85 84 89]]
[[89 89 0 0 81]
[81 0 84 82 88]
[ 0 81 80 83 86]
[ 0 88 85 84 89]]
[[1 1 0 0 1]
[1 0 1 1 1]
[0 1 0 1 1]
[0 1 1 1 1]]
统计运算
Numpy提供了丰富的统计函数，常用的统计函数：
argmax():最大值下标
argmin():最小值下标
cumsum():从第一个元素开始累加各元素
max():最大值
min():最小值
mean():算术平均值
std():标准差
sum():求和
了解Pandas
Pandas是python的一个数据分析包，是基于Numpy的一种工具，是为了解决数据分析任务而创建的。
Pandas主要处理一下三种数据类型：
Series: 一维数组，与Numpy中的ndarray类似
DataFrame:二维数组，可以看做是Series的容器
Panel: 三维数组。
Series数据结构
创建Series对象：
创建对象可以使用pd.Series(data, index)。data表示数据值，index是索引。通常情况下会创建一个0-N-1的整数索引
import pandas as pd
import numpy as np
s1 = pd.Series([1,2,3,4,5])
print(s1)
s2 = pd.Series({"a": 1, "b": 2}) # 字典创建Series，索引值为字典的key值
print(s2['a'])
s3 = pd.Series(data=[1,2,3,4,5], index=np.arange(0,1,0.2)) # 索引值不一定是整数，还可以是其他的一些类型
print(s3[0.2])
0 1
1 2
2 3
3 4
4 5
dtype: int64
1
2
访问Series对象
访问的方法和普通的数组是相同的，这里就不再赘述，这里主要了解增加对象成员和删除对象成员的方法
增加数据成员：(两个Series对象进行拼接)
import pandas as pd
arr = pd.Series(range(0, 5, 1))
print(arr)
arr = arr.append(arr)
print(arr)
0 0
1 1
2 2
3 3
4 4
dtype: int64
0 0
1 1
2 2
3 3
4 4
0 0
1 1
2 2
3 3
4 4
dtype: int64
C:\Users\molongqishi\AppData\Local\Temp\ipykernel_24628\135238922.py:6: FutureWarning: The series.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.
arr = arr.append(arr)
删除数据成员:
import pandas as pd
arr = pd.Series(range(0, 5, 1), range(1, 6, 1))
print(arr)
arr = arr.drop(2) ## 根据索引进行删除
print(arr)
1 0
2 1
3 2
4 3
5 4
dtype: int64
1 0
3 2
4 3
5 4
dtype: int64
DataFrame对象
该对象是一个表格性的数据结构，包含一组有序数列。列索引对应表格的字段名，航索引对应表格的行号，值是一个二维数组。
创建DataFrame：
创建的方法有很多，但是主要是通过DataFrame()进行创建。
格式：
DataFrame([data, index, columns, dtype, copy])
创建实例：
总的来说都要构建成字典再创建。
从字典数据创建DataFrame
import pandas as pd
dict = {'col1': [1,2,None], 'col2': ['a','b', None]} # 注意：All arrays must be of the same length，也就是说数组的长度应该要相同，不相同的话可以使用None进行占位
df = pd.DataFrame(dict)
print(df)
col1 col2
0 1.0 a
1 2.0 b
2 NaN None
用列表组成的字典创建
import pandas as pd
list1 = [1,2,3]
list2 = [2,3,4]
df = pd.DataFrame({'col1': list1, 'col2': list2})
print(df)
col1 col2
0 1 2
1 2 3
2 3 4
数据访问：
import numpy as np
import pandas as pd
pd = pd.DataFrame(np.arange(0,20,1).reshape(4,5), index=['a','b','c','d'], columns=['1','2','3','4','5'])
print(pd)
print()
print(pd['1'])
print()
print(pd['1']['a'])
1 2 3 4 5
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
a 0
b 5
c 10
d 15
Name: 1, dtype: int32
0
切片：
可以使用loc()和iloc()函数按索引名或者按照下标进行切片
import numpy as np
import pandas as pd
fd = pd.DataFrame(np.arange(0,20,1).reshape(4,5), index=['a','b','c','d'], columns=['1','2','3','4','5'])
print(fd.loc[['a', 'b'], ['1', '3']])
print()
print(fd.iloc[0:1, 2:3])
1 3
a 0 2
b 5 7
3
a 2
添加数据：
import numpy as np
import pandas as pd
fd = pd.DataFrame(np.arange(0,20,1).reshape(4,5), index=['a','b','c','d'], columns=['1','2','3','4','5'])
fd['f']=9 # 增加列，
print(fd)
1 2 3 4 5 f
a 0 1 2 3 4 9
b 5 6 7 8 9 9
c 10 11 12 13 14 9
d 15 16 17 18 19 9
删除数据：
删除数据使用drop()
import numpy as np
import pandas as pd
fd = pd.DataFrame(np.arange(0,20,1).reshape(4,5), index=['a','b','c','d'], columns=['1','2','3','4','5'])
print(fd)
print(fd.drop(columns='1')) # 删除‘1’列, column代表待删除的列名
print(fd.drop(index='a')) # 删除‘a’行，index代表待删除的行名
fd.drop(index='a', axis=1, inplace=True) # 从原数据中删除数据，axis表示是删除一行还是删除一列
print(fd)
1 2 3 4 5
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
2 3 4 5
a 1 2 3 4
b 6 7 8 9
c 11 12 13 14
d 16 17 18 19
1 2 3 4 5
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
1 2 3 4 5
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
数据对齐
算术数据对齐：
可以进行加减乘数的操作，也有对应的函数
import pandas as pd
s1 = pd.Series({'color':1, 'size':2, 'weight':3})
s2 = pd.Series({'color':5, 'size':7, 'weight':4.5, 'priec': 1})
print(s1 * s2)
color 5.0
priec NaN
size 14.0
weight 13.5
dtype: float64
import pandas as pd
s1 = pd.Series({'color':1, 'size':2, 'weight':3})
s2 = pd.Series({'color':5, 'size':7, 'weight':4.5, 'priec': 1})
print(s1.add(s2, fill_value=0)) # 其他的函数也是同理
color 6.0
priec 1.0
size 9.0
weight 7.5
dtype: float64
缺失数据的处理：dropna()
import pandas as pd
data = pd.Series([1,2,None,4])
print(data.dropna(axis=0)) # 这里的axis是判断对行还是列进行过滤，这里是过滤列，如果想过滤行就将axis=1
dfHow = pd.DataFrame([[1,2,None], [None, None, None], [1,1,1]])
print(dfHow.dropna(axis=0, how='any')) # how参数：any只要有None值就删除，all必须要一整行或者整列是None才删除
print()
print(dfHow.dropna(axis=0, how='all'))
0 1.0
1 2.0
3 4.0
dtype: float64
0 1 2
2 1.0 1.0 1.0
0 1 2
0 1.0 2.0 NaN
2 1.0 1.0 1.0
Matplotlib
Matplotlib是python的一个基本2D绘图库，它提供了很多参数，可以通过参数控制样式、属性等
matplotlib.pyplot:
pyplot中常用的函数
figure():创建一个空白画布，可以指定画布的大小和像素
add_subplot():创建子图，可以指定子图的行数、列数和标号
subplots():建立一些子图
title():设置图标标题
xlabel():设置x轴名称
ylabel();设置y轴名称
xlim():指定x轴刻度范围
ylim():指定y轴刻度范围
legend():指定图例
savefig():保存图形
show():显示图形
add_subplot(nrows, ncols, index)
参数：
nrows：子图划分成的行数
ncols：子图划分成的列数
index：子图的序号，从一开始
实例
import matplotlib.pyplot as plt
fig = plt.figure()
# 创建三个子图
# ax1=fig.add_subplot(2,2,1)
# ax2=fig.add_subplot(2,2,2)
# ax3=fig.add_subplot(2,2,3)
# 创建6个子图
fig,axes=fig.subplots(2,3)
绘制图形
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
rect = plt.Rectangle((0.2,0.75), 0.4, 0.15, color='r',alpha=0.3) # 创建一个长方形对象
ax.add_patch(rect) # 将图形添加到画布中，同理，其他的图形也是这样操作的，只是一些参数不同而已
plot函数
需要绘制曲线时就是使用到plot函数，绘制需要在画布上进行，如果没有创建画布的话，那么会先隐式的创建一个画布
plot(x, y, format_string, ** kwargs)
参数：
x: x轴数据，列表或者数组，可选
y: y轴数据，列表或数组。
format_string:控制曲线的格式字符串，可选
** kwars:第二组或者更多组参数（x, y, format_string）
实例
import matplotlib.pyplot as plt
import numpy as np
a = np.arange(0,10,1)
plt.xlabel('x')
plt.ylabel('y')
plt.plot(a, a * 1.5, a, a * 2, a, a * a) # 里面的参数一共分为三组，(（a, a * 1.5）, （a, a * 2）, （a, a * a)）
plt.legend(['1.5x', '2.0x', 'x*x'])
plt.show()
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10, 10, 100)
y = np.sin(x)
plt.plot(x, y, marker='o')
plt.show()
绘制3D图
mpl_toolkits.mplot3d包提供了一些基本的3D绘图功能，其支持的图标类型包括散点图、曲面图、线图和网格图。坐标轴是Axes3D，绘制时腰围三个坐标轴提供数据。
函数mpl_Axes3D.plot()可以绘制三维曲线图，其基本格式如下：
plot(xs, ys, * zs, * zdir, * args, ** kwargs)
参数说明：xs,ys,* zs: 分别代表x,y,z坐标轴，如果没有zs参数则绘制2D图。
zdir: 使用哪个方向作为z(取值’x’,‘y’,‘z’)
实例：
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def randrange(n, randFloor, randCeil):
rnd = np.random.rand(n) # 生成n个随机数
return (randCeil - randFloor) * rnd + randFloor
plt.rcParams['font.sans-serif']=['SimHei'] # 设置中文
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d') # 添加子3D坐标轴
n = 100
for zmin, zmax, c, m, l in [(4,15,'r','o', '低值'), (13,40,'g','*', '高值')]:
x = randrange(n, 0, 20)
y = randrange(n, 0, 20)
z = randrange(n, zmin, zmax)
ax.scatter(x, y, z, c=c, marker=m, label=l, s=z*6)
ax.set_xlabel('X-value')
ax.set_ylabel('Y-value')
ax.set_zlabel('Z-value')
ax.set_title('高/低值3D散点图', alpha=0.6, size=15, weight='bold')
plt.show()
总结
在程序的编写和验证的过程中倒是很轻松。但是在下载文件的过程中出现了一些问题，当将界面下载成Markdown文件的过程中会有报错，导致卡了好几个小时。正常的应该是点击左上角的
File->Download as，然后选择想要转换的格式就可以下载了，但是总是会报错。于是我先下载了Pandoc，命令：
pip install pandoc
下载好之后通过：
pip list
查看是否成功下载了jupyter，我的是这样的，最主要看下有没有圈起来的东西
接着使用命令行:
jupyter nbconvert Untitled.ipynb --to markdown
其中的Untitled.ipynb是下载下来的notebook文件，最后的markdown是想要转换成的格式，除了‘markdown’还可以选择’asciidoc’, ‘custom’, ‘html’, ‘latex’, ‘notebook’, ‘pdf’, ‘python’, ‘rst’, ‘script’, ‘slides’, ‘webpdf’。
如果文章中出现了错误还请大家指正！
3231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
