python数据分析三剑客之: Numpy

数据分析三剑客之: Numpy

一丶Numpy的使用

​ numpy 是Python语言的一个扩展程序库,支持大维度的数组和矩阵运算.也支持针对数组运算提供大量的数学函数库

创建ndarray

# 1.使用np.array() 创建一维或多维数据
import numpy as np
arr = np.array([1,2,3,4,5]) # 一维
arr = np.array([[1,2,3],[4,5,6]])# 二维

### 注意元素类型:
	# 1. numpy默认ndarray的所有元素的类型是相同的
	# 2. 如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int

# 2. 使用 matplotlib.pyplot() 获取一个numpy数组,数据源是一张图片
import matplotlib.pyplot as plt
img_arr = plt.imread('./cat.jpg') # 得到 一个三维数据源

  # 数据源再转换成图片
plt.imshow(img_arr)
  # 可以对数据源进行计算
plt.imshow(img_arr - 100)

使用np的routines函数创建

# 1.创建等差数列  np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
#  参数说明: start-stop是创建数据的范围,num指定个数据,
np.linspace(0,100,num=10) # array([  0.        ,  11.11111111,

# 2. 创建等差数列 np.arange([start, ]stop, [step, ]dtype=None)
np.arange(0,100,2) # array([ 0,  2,  4,  6,  

# 3. 随机数 np.random.randint(low, high=None, size=None, dtype='l')
	# 时间种子(随机因子):无时无刻都在变化的值
    # 固定随机因子就可以固定随机函数的随机性

np.random.seed(90) #固定随机因子
np.random.randint(0,100,size=(3,5))  # 随机数  

# 4. 生成 0-1的随机数,左闭右开  np.random.random(size=None)
np.random.random(size=(3,4))

nadarray的属性

# 四个必须参数: 1.ndim:维度  :   arr.ndim
			  2.shape:形状(各个维度的长度)  :   arr.shape
			  3.size:总长度     :  arr.size
			  4.dypte:元素类型   :   arr.dtype

二丶ndarray的基本操作

索引

​ 维与列表完全一致 多维时同理,索引默认从0开始

# 根据索引修改数据
arr[0] # 获取行元素

arr[[0,1]] # 获取多行元素

arr[1,3] # 获取1行3列的那个元素

arr[1,[2,3,4]]  # 一行多列的值

切片

​ 一维与列表完全一致 多维时同理

### arr[行,列]

# 获取二维数组前两行
arr[0:2]

# 获取二维数组前两列
arr[:,0:2]

# 获取二维数组前两行和前两列数据
arr[0:2,0:2]

# 将数组的 '行' 倒序
arr[::-1,:] 

# 列倒序
arr[:,::-1]

# 全部倒序
arr[::-1,::-1]

# 将图片进行全倒置操作
img_arr.shape # 图片的形状
plt.imshow(img_arr[:,::-1,:]) # 倒序之后的图片

# 对图片进行裁剪
plt.imshow(img_arr[100:360:,150:580,:]) # 行 , 列 进行切片

变形

​ 使用arr.reshape()函数,参数是一个tuple

# 1.将一维数组变形成多维数组
arr_1.reshape((10,4)) # 转换成10行 4列的数组

arr_1.reshape((5,-1)) # -1 , 自动转换

# 2.将多维数组变形车一维数组
arr_1 = arr.reshape((40,))

级联

​ np.concatenate((arr,arr),axis=1)

​ 参数:(数据源1,数据源2) , axis是方向:1是行,0是列

# 1. 一维,二维,多维数组的级联,实际操作中级联多为二维数组
np.concatenate((arr,arr),axis=1) # array([[45, 33, 77, 76

# 2. 合并两张照片
	# 横向合并3张照片
arr_3 = np.concatenate((img_arr,img_arr,img_arr),axis=1)
     #
arr_9 = np.concatenate((arr_3,arr_3,arr_3),axis=0)
plt.imshow(arr_9)

###   注意:
 # 1.级联的参数是列表: 一定要加中括号或小括号
 # 2.维度必须相同
 # 3.性状相符:在维度保持一致的前提下,
    	# 如果进行横向(axis=1)级联,必须保证进行级联的数组行数保持一致
        # 如果进行纵向(axis=0)级联,必须保证进行级联的数组列数保持一致
 # 4. 可通过axis参数改变级联的方向

三丶ndarray聚合操作

求和 np.sum

# arr.sum(axis=1) #  axis 1 行相加 ,0 列
arr.sum(axis=1)

最大值和最小值

# np.max/np.min

平均值

# np.mean() 平均值

其他操作

Function Name    NaN-safe Version    Description
np.sum    np.nansum    Compute sum of elements
np.prod    np.nanprod    Compute product of elements
np.mean    np.nanmean    Compute mean of elements
np.std    np.nanstd    Compute standard deviation
np.var    np.nanvar    Compute variance
np.min    np.nanmin    Find minimum value
np.max    np.nanmax    Find maximum value
np.argmin    np.nanargmin    Find index of minimum value
np.argmax    np.nanargmax    Find index of maximum value
np.median    np.nanmedian    Compute median of elements
np.percentile    np.nanpercentile    Compute rank-based statistics of elements
np.any    N/A    Evaluate whether any elements are true
np.all    N/A    Evaluate whether all elements are true
np.power 幂运算

四丶ndarray的排序

快速排序

# np.sort() 和 ndarray.sort() 都可以,但是有区别:
     # np.sort() 不改变输入
     # ndarray.sort() 本地出里,不占用空间,但改变输入

###
np.sort(arr,axis=0) # 列排序, 不改变源数据
arr.sort(axis=1)  # 行排序 , 改变源数据 

五丶Panda的数据结构

Series

# 概述:
###  Series是一种类似于一维数组的对象
	 # values: 一组数据(ndarray类型)
      # index: 相关的数据索引标签 

# 1. 创建Series
  # 方式一: 由列表或numpy数组创建. 默认索引0到 N-1 整数索引
	  # 使用列表创建Series
		Series(data=[1,2,3])

      # 使用数组生成一个Series
        s2  = pd.Series(np.arange(7))

      # 还可以通过设置index参数指定索引
   		 s = Series(data=[1,2,3],index=['a','b','c'])

      # 使用一个字典生成Series，其中字典的键，就是索引
         s3 = pd.Series({'1':1, '2':2, '3':3})

# 2. Series的索引和切片
   # 可以使用中括号取 单个 索引(此时返回的是元素类型),或者中括号里 '一个列表'取多个索引(此时返回的是一个Series类型)

 # 1.显示索引
 	- 使用index中的元素作为索引值
 	- 使用 s.loc(推荐),获取元素的值.  loc中括号中放置的一定是显示索引
 	- 此时是闭区间 

 # 2.隐式索引
 	- 下标索引 ,使用s.iloc[下标]

# 3. Series的基本概念
   # 可以使用s.head() 和 tail() 分别查看前n个 和后n个值

 		s.head(2) # 查看前2个,默认是5个
		s.tail(2) # 查看后2个

   # 对Series元素进行去重
    	s.unique()

   ### 注意:
	   当索引没有对应的值时,可能出现数据缺失显示NaN(not a number)的清空

    # 使两个Series进行相加
    	s1 = Series([1,2,3],index=['a','b','c'])
        s2 = Series([1,2,3],index=['a','d','c'])
         s = s1 + s2	 # s 中存在空值NaN

    # 使用 pd.isnull()，pd.notnull()，或s.isnull(),notnull()函数检测缺失数据
		# 和 any() 搭配
        s.isnull()   # 找到控制 ,得到布尔类型的数据, 可作为列索引进行过滤

         # 和 all() 搭配
		s.notnull()   # 对空值进行过滤 , 可作为列索引进行过滤

# 3. Series之间的运算
    - 在运算中自动对齐不同索引的数据
    - 如果索引不对应,则补NaN

六丶DateFrame

概述

# DataFrame是一个表格型的数据结构. DataFrame由按照一定顺序排列的多列数据组成.设计初衷是将Series的使用场景从一维拓展到多维.DataFrame既有行索引,也有列索引.
 	# - 行索引:index
	# - 列索引:columns
	# - 值: values

创建DataFrame

# 1. DataFrame的创建
	# - 最常用的方法传递一个字典来创建.DataFrame以字典的键作为每一[列]的名称,以字典的值(一个数组)作为每一列
	# - DataFrame会自动加上每一行的索引
	# - 使用字典创建的DataFrame后,则columns参数将不可被使用
	# - 同Series一行,若传入的列与字典的键不匹配. 则相应的值为NaN

### 使用ndarray 创建DataFrame
	# 参数说明:  # index 是行索引,columns是列索引
df=DataFrame(data=np.random.randint(0,100,size=(3,4)),index=['a','b','c'],columns=['A','B','C','D'])

### DataFrame属性: values,columns,index,shape
    df.values # 获得所有值
    df.columns  # 获取所有列索引
    df.index    # 获取所有行索引
    df.shape    # 获得形状

### 使用ndarray  和 DataFrame: 创建一个表格用于展示张三,李四
dic = {
    'zhangsan':[99,99,99,99],
    'lisi':[0,0,0,0]
}
df = DataFrame(data=dic,index=['语文','数学','英语','理综'])
df

DataFrame的索引

1 . ### 对列 进行索引
	# 通过类似字典的方式 df['q']
	# 通过属性的方式 df.q

# DataFrame的获取列取为一个Series. 返回的Series拥有的DataFrame相同的索引,
        # 且name属性也已经设置好了,就是相应的列明

df['lisi'] # 取出  列索引
df[['zhangsan','lisi']] # 取出多列索引

2. ###  对行进行索引
    - 使用 .loc[] 加 index参数的值,来进行, 行索引
    - 使用.ilock[] 加 索引整数 来进行, 行索引

   # 同样返回一个Series,index为原来的columns

df.loc['语文'] # 行索引
df.iloc[[0,1]] #  行索引
df.iloc[0]   # 行索引    

3. ###  对元素索引的方法
    - 使用列索引
    - 使用行索引(ilock[3,1]  或者 loc['C','q']) 行索引在前,列索引在后

### 行索引在前,列索引在后
    df.iloc[2,1]
    df.loc['英语','zhangsan']
    df.iloc[[1,2],[1]]

切片

【注意】 直接用中括号时：

    - 索引表示的是列索引
    - 切片表示的是行切片

# 行切片
df[0:2]  #行切片

# 在loc和iloc中使用切片(切列)
df.loc['B':'C','丙':'丁']

# 索引和切片总结:
索引
    df['col']:列索引，取出指定的列
    df[[col1,col2]]:取出多列
    df.iloc[1]:取指定的1行 , 下标为1
    df.loc['语文']:取指定的行
    df.iloc[hang,lie]:取元素 , [行,列]
切片：
    df[行切片]：切行
    df.iloc[hang,lie]:切列

DataFrame的运算

# 概述
（1） DataFrame之间的运算 , 同Series一样：
		- 在运算中自动对齐不同索引的数据
		- 如果索引不对应，则补NaN	

#### 练习题:
1 .假设ddd是期中考试成绩，ddd2是期末考试成绩，请自由创建ddd2，并将其与ddd相加，求期中期末平均值。
# 运算, 期中期末,
qz=df  # 期中
qm=df  # 期末
qz+qm  # 列值相加
mean_scroe=(qz+qm)/2 # 求平均值

2. 假设张三期中考试数学被发现作弊，要记为0分，如何实现？
# 找到具体的元素位置,更改值
qz.iloc[1,1]=0

3. 李四因为举报张三作弊立功，期中考试所有科目加100分，如何实现？
# 对 李四的所有科目+100分
qz['lisi']+=100 

4. 后来老师发现有一道题出错了，为了安抚学生情绪，给每位学生每个科目都加10分，如何实现？
# 对所有人的成绩都加10分
qz+=10

七丶处理丢失数据

###  有两种丢失数据:
	None
    np.nan(NaN)

None

# None 是 python 自带的,其类型为python object .因此 None不能参与到任何计算中

np.nan(NaN)

# np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。
#查看np.nan的数据类型
type(np.nan)

pandas中的None与NaN

### 1.  在  pandas中None与np.nan都视作np.nan
	# 做 数据 级联 或者 聚合  都会出现none

### 2. pandas处理空值

# 判断函数
	# - isnull()
	# - notnull()

    #  axis 的值为1,表示横向, 找出为空的行
	df.isnull().any(axis=1)	

    # 找出不含空值的行
	df.notnull().all(axis=1)

	#  ~:取反, 表示取出 不包含空值的行
	df.loc[~df.isnull().any(axis=1)]

		## 固定搭配使用
            isnull()->any
            notnull()->all

	# df.dropna() 可以选择过滤的是行还是列（默认为行）:axis中0表示行，1表示的列
	df.dropna(axis=0)    

# 填充函数  Series/DataFrame, 把数据集中的空值数给填充
	# fillna()  value 和 method参数
    # 参数解释:
    		# axis=1
    		# bfill :  向左填充
             # ffill :  向右填充

             # axis=0
            # bfill : 向上填充
            # ffill :  向下填充
df_test=df.fillna(method='bfill',axis=1).fillna(method='ffill',axis=1)

案例 : 股票分析

# 使用tushare包获取某股票的历史行情数据
	# pip install tushare

import tushare as ts
import pandas as pd

# 导入数据
maotai = ts.get_k_data(code='600519',start='1900-01-01')
maotai.head()

#存储本地
maotai.to_csv('./maotai.csv')

#从本地读取数据
#index_col将哪一列作为原数据的行索引
#将date的类型转成时间类型然后将其作为原数据的行索引
df = pd.read_csv('./maotai.csv',index_col='date',parse_dates=['date'])
df.drop(labels='Unnamed: 0',axis=1,inplace=True)

# 1. 输出该股票所有收盘比开盘上涨3%以上的日期。
	#(收盘-开盘)/开盘 > 0.03
(df['close'] - df['open']) / df['open'] > 0.03
	#将True对应的行数据取出
df.loc[(df['close'] - df['open']) / df['open'] > 0.03]
	#取行索引
df.loc[(df['close'] - df['open']) / df['open'] > 0.03].index

# 2. 假如我从2010年1月1日开始，每月第一个交易日买入1手股票，每年最后一个交易日卖出所有股票，到今天为止，我的收益如何？
df_2010 = df['2010':'2019']

# 3. 基于开盘价进行股票的买卖
	# 买股票的时机：
      #  每月的第一个交易日买入一手（100股）股票
      #   一个完整的年会买入12次股票供给1200股
	# 卖股票的时机：
      #  每年的最后一个交易日卖出所有（1200股）的股票
      #  一共可以卖9次股票
	# 注意：19年只可以买入不可以卖出，最后剩余的不能卖出的1000股股票是需要计算到总收益中

# 数据的重新取样resample()函数

    #买入股票花费的钱数
df_monthly = df_2010.resample('M').first()
cost_money = df_monthly['open'].sum()*100
	#卖出股票收到多少钱
df_yearly = df_2010.resample('A').last()[:-1]
	#昨天的收盘价
last_price = df_2010['close'][-1] 

# 收益
recv_monry = df_yearly['open'].sum()*1200 + last_price*1000
recv_monry - cost_money