01数据分析之jupyter使用与numpy使用

数据分析

一.工具安装，两种方式

注意：版本一定要匹配（64位，32位），计算机多少位操作提供要匹配

方式一：python + 自己安装包-------->相当于自己搭建集成的开发环境
第一步，安装python.exe,通过官网获取
第二步，配置环境变量（系统可以找到我们安装软件），方便程序的启动
D:\Python36
D:\Python36\Scripts
第三步，数据分析和机器学习，需要一些库，numpy，jupyter，pandas，matplotlib等等
第四步，启动开发环境：jupyter notebook
第五步，后续需要安装其他库，pip install xxx

方式二：Anaconda集成好的开发环境，进行安装
第一步，执行Anaconda.exe （个版本下载地址：https://repo.anaconda.com/archive/）
第二步，配置环境变量
D:\Anaconda3
D:\Anaconda3\Scripts
第三步，依然可以通过pip install xxx拓展Anaconda
基本上不需要安装其他一些库，直接使用，集成开发环境

随便在哪个目录cmd: jupyter notebook

二.jupyter使用（cmd: jupyter notebook）:

  1.代码块操作：

    a 在一个代码单元上面插入一行(above)
    b 在一个代码单元下面插入一行(blow)
    双击d  删除代码块

	Tab 代码提示功能
	Shift + Tab 代码方法API提示

  2.运行代码块：

      Ctrl+Enter:  选中本代码块运行
      Alt+Enter:  运行代码块，插入新的一行
      Shift+Enter: 运行代码块，选中下一个单元

  3.魔法指令

    一行代码运行计时:  %time  一行代码
    多行代码运行计时:  %%time  多行代码
    多行代码平均运行计时:  %%timeit  多行代码
    
    指定计算轮数，每论多少次  timeit -r 6 -n 100 bar(8, 8)
	
	
	查看当前会话的所有变量与函数名称  %who
	查看当前会话的所有变量与函数名称的详细信息：%whos
	返回一个字符串列表，里面元素是当前会话的所有变量与函数名称：%who_ls
	
    列出常用魔法指令：%lsmagic  （linux指令）

    %ls、 %mkdir、 %cd、...

  mardown格式：

     将选择单元转换为md: m  =>  按y转换为code模式
     插入图片：![](图片地址)
     
 4.执行windows的dos命令 与 linux命令
 
 dos命令：   !dir
 
 列出常用魔法指令：%lsmagic 
 %ls、 %mkdir、 %cd、...
 

三.数据分析人工智能最基础一个库：numpy（numeric（数字化） python）

数据: 一切皆数据,一切皆矩阵.
中文官网：https://www.numpy.org.cn/
查看API，如何使用了

使用某个库，导包，import numpy as np

ModuleNotFoundError: No module named 'numpy',集成环境下，没有numpy这个模块
没有该模块，咱们安装 pip install numpy

NumPy包的核心是ndarray对象
n dimension array n维数组

1.创建ndarray

导入：import numpy as np
1.查看库的版本：np.__version__


2.查看存储大小：
l = [i for i in range(100000)]
l.__sizeof__()		

n = np.array(l)
n.__sizeof__()  # ndarray存储空间优化

3.将列表转换为ndarray对象：
  nd = np.array([[1,2,3], [2,3,4]])  # array([[1, 2, 3],[2, 3, 4]])
   n = np.array([[1,2,3], [2,3]])  # array([list([1, 2, 3]), list([2, 3])], dtype=object)

4.
注意：
- numpy默认ndarray的所有元素的类型是相同的
- 如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int
l = [1,2,3,'4',5.0]
n = np.array(l)   # array(['1', '2', '3', '4', '5.0'], dtype='

5.使用np的routines函数创建(routines常规方法)
    #shape:维度  dtype:数据类型  order：存储方式（列先/行先）
    1) np.ones(shape, dtype=None, order='C')   # 生成全是1的ndarray.
        np.ones(shape=(4,5,3), dtype=np.int8)

    2) np.zeros(shape, dtype=float, order='C') # 生成全是0的ndarray
        np.zeros(shape=[3,5], dtype=np.int)

    3) np.full(shape, fill_value, dtype=None, order='C') 
        # shape: 维度
        # fill_value 使用指定的值填充ndarray  
        np.full(shape=(4,5), fill_value=8, dtype=np.float)
        
	4) np.eye(N, M=None, k=0, dtype=float)  # 对角线为1其他的位置为0
        np.eye(5)
        '''        
        array([[1., 0., 0., 0., 0.],
               [0., 1., 0., 0., 0.],
               [0., 0., 1., 0., 0.],
               [0., 0., 0., 1., 0.],
               [0., 0., 0., 0., 1.]])'''
         # 行列数相同的矩阵,叫做方阵, 
	    # 主对角线上全是1, 其他位置全是0的方阵,我们叫做单位矩阵/满秩矩阵. 有解
        
	5) np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None
 	   # 等差数列， 从start到stop分割成num份， num默认为50份
       # start开始数字，stop结束数值，  num: 分割成几份
       # endpoint是否包含结束的数值（即左闭右闭）  retstep: 是否返回步长，公差   
		np.linspace(1, 10,num=10,  retstep=True) 
         # (array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
                   
	6) np.arange([start, ]stop, [step, ]dtype=None)   
        # 和python原生的range是一样.
        # 左闭右开.        
        # 当步长step是小数的时候,推荐使用np.linspace()
        np.arange(0, 10, step=2) # array([0, 2, 4, 6, 8])
     
    np.random下面的东西都是用来生成随机数.
	7) np.random.randint(low, high=None, size=None, dtype='l') 
        # size：维度
        # 左闭右开
        # 伪随机数： 加入种子，通过种子与算法生成的数列，默认以时间戳为种子
        np.random.seed(2)
        np.random.randint(0,10, size=(4,5))   # array([[8, 8, 6],[2, 8, 7]])
    
    8) np.random.randn(d0, d1, ..., dn)
    　#　d0.. 每个维度的个数
      # 标准正太分布： 平均值是0, 方差是1的正态分布叫做标准正态分布.
        np.random.randn(3,4,5)
        
	9)np.random.normal(loc=0.0, scale=1.0, size=None)  # 正态分布.
     # loc指正态分布的平均值
	 # scale指标准偏差
     # size 维度
      n = np.random.normal(loc=10, scale=3, size=(10000, 300))
      n.mean()  # 获取平均值
      n.std()   # 获取方差
    
    10) np.random.random(size=None)  # 生成0到1的随机数，左闭右开 size为维度
       np.random.random(size=(3,4,4))
      
    11) #  # 生成0到1之间的随机数, 左闭右开,不包括1
		np.random.rand(2,3,4)    #　random.random()的方便方法
	   		               

2.ndarray的属性

n = np.zeros(shape=(2,3), dtype=int)
n
'''
array([[0, 0, 0],
       [0, 0, 0]])
'''


n.ndim  # 2 数组维度
n.shape  # (2, 3)  各维度的长度
n.size  # 6 总长度/元素的个数
n.dtype  # dtype('int32') 元素类型

3.ndarray的基本操作

axis = 1   对列进行操作
axis = 0   对行进行操作

1.索引操作：一维与列表完全一致 多维时同理
    n = np.array([[1,2,3], [2,3,4], [4,5,6]])
    通过索引获取值：n[2][2]、n[2,2] 、n[2] 
    根据索引修改数据： n[1,2] = 88
    
2.ndarray类方法操作ndarray对象（增删改）    
	n = np.array([[1,2,3], [2,3,4]]
    
    1) 增加： np.append(arr, values, axis=None) 
    # 添加值到一个数组的末尾，
    # 水平添加， axis=1, 要求行数一致
	np.append(n, [[9], [8]], axis=1)
                 
    '''
    array([[1, 2, 3, 9],
       	  [2, 3, 4, 8]])
    '''               
                 
    # 垂直添加， axis=0, 要求列数一致
     np.append(n, [[9,8,7]], axis=0) 
      '''
      array([[1, 2, 3],
       		[2, 3, 4],
       		[9, 8, 7]])
      '''                 
	 1) 增加：numpy.append(arr, values, axis=None) 
     2) 插入：numpy.insert(arr,obj,value,axis=None) 
     3）删除：numpy.delete(arr,obj,axis=None)
    
3. 切片（一维与列表完全一致 多维时同理）  
	n =np.random.randint(0,100, size=(3,4,5))
    n[1:, 1:3, 1:4]
    
    将数据反转：
    n = np.array([[1,2,3], [2,3,4]])
	n[::, ::-1]
    '''
    array([[3, 2, 1],
       [4, 3, 2]])
    '''
    
4. 变形(使用reshape函数，注意参数是一个tuple！)
	# reshape的关键就在于,总元素个数不能发生变化.
    n = np.array([[1,2,3], [2,3,4]])
    n.shape  # (2, 3)
    n.reshape(6)  # array([1, 2, 3, 2, 3, 4])
    
5. 级联
	np.concatenate((a1, a2, ...), axis=0, out=None)
    np.concatenate() 级联需要注意的点：
    级联的参数是列表：一定要加中括号或小括号
    维度必须相同
    形状相符
    【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
    可通过axis参数改变级联的方向    
    
    n1 = np.random.randint(0,100, size=(3,4))
	n2 = np.random.randint(0,100, size=(3,4))
    '''
    array([[91,  5, 96, 73],
           [ 8, 14, 76, 91],
           [41, 93, 47, 73]])
    array([[40, 76, 97, 81],
           [66, 98, 60, 86],
           [94, 11, 88, 15]])
    '''
    
    # 水平级联 axis=1,水平级联要求行数一致
	np.concatenate((n1,n2), axis=1)
    '''
    array([[91,  5, 96, 73, 40, 76, 97, 81],
           [ 8, 14, 76, 91, 66, 98, 60, 86],
           [41, 93, 47, 73, 94, 11, 88, 15]])
    '''
    
    # 垂直级联 , axis=0, 要求列数一致
	np.concatenate((n1,n2), axis=0)
    '''
    array([[53, 30, 62, 62],
           [61, 28, 90,  4],
           [14, 67, 67, 25],
           [58, 76, 97, 81],
           [70, 89, 38, 58]])
    '''
    
    
    np.hstack与np.vstack
	水平级联与垂直级联,处理自己，进行维度的变更
    np.hstack((n1, n2))
    np.vstack((n1, n2))
    
 6.切分
	与级联类似，三个函数完成切分工作：
    np.split(ary, indices_or_sections, axis=0)
    indices_or_sections： 切分位置， 第几行或第几列

    np.split
    np.vsplit
    np.hsplit 
    
    n = np.random.randint(0,  100, size=(6,6))   
	np.split(n, [1,3], axis=0)  # 切的是行 ,axis=0
    np.split(n, [1,3], axis=1)   # 切的是列 ,axis=0
    
7.副本：所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。  
	n = np.random.randint(0,  100, size=(6,6))
	n2 = n  # 浅拷贝
    n3 = n.copy()  # 深拷贝

4.ndarray的聚合操作

np.nan  # 对标python中的None

1. 求和np.sum(a, axis=None, dtype=None)
   除去nan 求和：  np.nansum(n)  # 除去nan 求和

   n = np.random.randint(0,  100, size=(6,6)) 
   np.sum(n) 或者 n.sum()  # 对所有元素求和
     
   n.sum(axis=1)  # axis=1表示对每一列进行聚合操作.  array([352, 258, 341, 294, 327, 231])
   n.sum(axis=0)  # 对行 进行聚合求和操作
    
   n = np.array([1,2,3,np.nan])
   n.sum()  # nan
  
    
   最大值： n.max() 、n.max(axis=0)、n.max(axis=1)
   最小值： n.min() 、n.min(axis=0)、n.min(axis=1)
   计算所有元素的乘积：np.prod()、np.prod(axis=0)、np.prod(axis=1)
   求平均值： np.mean()、np.mean(axis=0)、np.mean(axis=1)
   求标准差： np.std()、np.std(axis=0)、np.std(axis=1)
   求方差：np.var()、np.var(axis=0)、np.var(axis=1)
   最大值、最小值索引： np.argmin() 、np.argmax()

平均值： x = a1+a2+...+an/n
方差: 每个样本值与全体样本值的平均数之差的平方值的平均数  d = (a1-x)2 + (a2 -x)2 /n
	 用来度量随机变量和其数学期望（即均值）之间的偏离程度
标准值：s = sqrt((a1-x)2 + (a2 -x)2 /n)  

5.ndarray的矩阵操作

1. 基本矩阵操作(加减乘除)
n = np.array([[1,2,3],[4,5,6]])
  
    n+1  # array([[2, 3, 4],[5, 6, 7]])  全体元素加1
    n-1  # array([[0, 1, 2],[3, 4, 5]])  全体元素减1
    n*2  # 全体元素乘2   
    n/2  # 全体元素除2   

    
    n1 = np.random.randint(0,10, size=(3,4))
    n2 = np.random.randint(0,10, size=(3,4))
    display(n1,n2)
    '''
    array([[9, 4, 0, 9],
           [8, 2, 1, 6],
           [1, 9, 3, 9]])
    array([[2, 2, 8, 2],
           [5, 2, 9, 6],
           [6, 5, 0, 5]])
    '''       

    n1 +  n2  # 相同位置的元素进行运算.
    array([[11,  6,  8, 11],
           [13,  4, 10, 12],
           [ 7, 14,  3, 14]])

   
 矩阵乘积： 只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义
    公式： n1矩阵的每一行分别乘以n2矩阵的每一列
    n1 = np.array([[1,2,3],[1,2,3]])
    n2 = np.array([[1,2,3],[1,2,3],[1,2,3]])
    np.dot(n1, n2)
    
 逆矩阵：n_inv = np.linalg.inv(n)

   例如：求解方程
    x + y + z = 8
    2x - y + z = 8
    3x + y - z = 2

	转换为矩阵：
    I = np.array([[1,1,1], [2, -1, 1],[3,1,-1]])
    J = np.array(['x', 'y', 'z'])
    K = np.array([8, 8, 2])
    
    I J = K  # 两边乘以I的逆矩阵
    
    I_ IJ = I_ K
    J = I_ K
    
    即：
    I_inv = np.linalg.inv(I)
    np.dot(I_inv, K)  # 2，1，5

2. 广播机制
【重要】ndarray广播机制的两条规则
  	1, 缺失维度给你补维度.
    2, 缺失数据给你补数据,用已有的数据进行补充.
    
    m = np.ones((2,3)) #  array([[1., 1., 1.],[1., 1., 1.]])
    a = np.arange(3)  # array([0, 1, 2])
    
    m + a    # array([[1., 2., 3.],[1., 2., 3.]])
    a缺了一个维度, 广播机制会补一个维度 [[0,1,2]]
    补完之后,a缺了数据, 广播机制会使用已有的数据进行填充：[[0,1,2],[0,1,2]]

6.ndarray的排序

排序只对一维数据有意义.

1. 快速排序

    np.sort()与ndarray.sort()都可以，但有区别：

    np.sort()不改变输入
    ndarray.sort()本地处理，不占用空间，但改变输入
    
 arr = np.array([6,2,3,1,5,4])
 np.sort(arr)  #  array([1, 2, 3, 4, 5, 6])  不改变原数组
    
 arr.sort()  # array([1, 2, 3, 4, 5, 6])  改变原数组


2.部分排序
np.partition()

7.ndarray的简单io操作

import numpy as np
n = np.random.randint(1,50, size=(3,4))
np.savetxt('./arr.txt', n, fmt='%.2e')

np.loadtxt('arr.txt')