数据分析总结:
导入import numpy as np
np.version #version查看numpy的版本
type()查看数据的类型
xx.dtype 查看数据中元素的类型
xx.shape #shape数据的形状
导入
import matplotlib.pyplot as plt
例如：
cat =plt.imread("./cat.jpg")#imread是读取照片的位置
plt.imshow(cat)#展现cat数据
plt.show()
重要：
nd6 = np.array([[[1,2,3,5],[4,5,6,5]],[[1,2,3,5],[4,5,6,5]]])
nd6.shape
#这个一定要看懂
坑：
rgb jpg格式的图片0-255
np.ones(shape, dtype=None, order='C')
例：
ones = np.ones((456,730,3),dtype = "float")
ones
numpy.zeros(shape, dtype=float, order=’C’)
参数：
shape：int或int类型序列，表示矩阵形状
dtype：输出的数据类型
order：‘C’ 或者 ‘F’，表示数组在内存的存放次序是以行(C)为主还是以列(F)为主
np.zeros((456,730,3),dtype="float")
zeros的使用方法】
B=zeros(n)：生成n×n全零阵。
B=zeros(m,n)：生成m×n全零阵。
B=zeros([m n])：生成m×n全零阵。
B=zeros(d1,d2,d3……)：生成d1×d2×d3×……全零阵或数组。
B=zeros([d1 d2 d3……])：生成d1×d2×d3×……全零阵或数组。
B=zeros(size(A))：生成与矩阵A相同大小的全零阵。
numpy.full(shape, fill_value, dtype=None, order=’C’)
参数：
shape：int或int类型序列，表示矩阵形状
fill_value：填充值
dtype：输出的数据类型
order：‘C’ 或者 ‘F’，表示数组在内存的存放次序是以行(C)为主还是以列(F)为主
nd4 = np.full(12,fill_value=1024)
numpy.eye(N, M=None, k=0, dtype=float)
参数：
N：行数
M：列数
k：对角线偏移
dtype：输出的数据类型
对角矩阵（主对角线上元素都为1，其他元素都为0）——对角线向右上方偏移k（k>0向右上方偏移，k<0向左下方偏移）
例:
np.eye(2, dtype=int)
np.eye(3, k=1)
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
np.random.randint(low, high=None, size=None, dtype='l')#生成一个整数或N维整数数组，取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。
例:
nd1=np.random.randint(0,255,size=(3,4,2))
numpy.random.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组
例:
numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组，取数范围：正态分布的随机样本数。
例:
np.random.randn(10,2,1)
np.arange([start, ]stop, [step, ]dtype=None)
例:
np.arange(start = 5,stop = 10,dtype= float)
np.random.random(size=(12,2))
numpy.random.choice(a, size=None, replace=True, p=None)：从序列中获取元素，若a为整数，元素取值为np.range(a)中随机数；若a为数组，取值为a数组元素中随机元素。
例:
ndarray的属性:
4个必记参数： ndim：维度 shape：形状（各维度的长度） size：总长度
索引总结:
l[4] 4代表的下坐标
可以根据索引修改数据：
nd[1,1,1]=0
切片:
同理
数据反转：
例子：
nd1=[27, 86, 82, 15, 4, 1, 1, 84, 23, 55, 61]
反转：
nd[::-1]
结果:
nd1=[61, 55, 23, 84, 1, 1, 4, 15, 82, 86, 27]
np.hstack与np.vstack 水平级联与垂直级联,处理自己，进行维度的变更
np.hstack如果是水平的 就变成垂直的 就是列变成行
np.vstack如果是垂直的 就变成水平的 就是行变成列
切分：
np.split
np.vsplit
np.hsplit
np.hsplit:一行为基准 进行切分 np.hsplit(nd, [1,3,5])就是1单独一份 3单独一份，5单独一份 其他一份
np.vsplit；一列为基准 进行切分
np.split(nd, [2], axis = 1)
#axis = 0 和vsplit一样的效果 axis = 1 和 hspilt一样的效果
np.sum 和 np.nansum 的区别 nan not a number
nan与数相加还是nan
矩阵积np.dot()
np.dot(nd1,nd2)#两个ndarray 在进行相乘的时候，一个数据的行和一个数据 的列必须相同
必记:
astype数据类型转化的函数
例子：
a=dtype('uint8')
b=a.astype('uint32')
cat.flags.writeable = True #改成可写
np.concatenate()
运算：sum 和 max最大 min最小 mean平均数 argmin最小数的下坐标 argmin、argsum同理
nd.sum(axis = 0) 列为准 上下数相加
nd.sum(axis = 1) 行为准 一行相加
ndarray的矩阵操作: + - / * 系统函数：add subtract
np.sort()不改变输入 含义:这个函数不改变原始的数据 排序后 再次打印原始的数据 还是以前的数据
ndarray.sort()本地处理，不占用空间，但改变输入 含义:这个函数改变了原始的数据 再次打印 打印的排序后的数据
np.partition(a,k)
当k为正时，我们想要得到最小的k个数
当k为负时，我们想要得到最大的k个数
luban.shape#就是降维操作
#cv2在读图片的时候，是以BGR格式 RGB
sanpang = cv2.imread("./cv2_change_head/j.jpg")
plt.imshow(sanpang[::,::,::-1])
#作用，加载各种算法的类
cascade = cv2.CascadeClassifier()
#加载算法
cascade.load("./cv2_change_head/haarcascade_frontalface_default.xml")
#识别人脸
face = cascade.detectMultiScale(sanpang)
face
Pandas的数据结构
import pandas as pd
from pandas import Series,DataFrame
import numpy as np
Series是一种类似与一维数组的对象，由下面两个部分组成：
values：一组数据（ndarray类型）
index：相关的数据索引标签
Series 就是对ndarray的包装
索引：
s[["pi","a"]] 里面还要套一个括号
方法二：loc操作
s.loc["pi"] 左闭右闭
总结：两个中括号出来的数据，就是当前数据类型， 一个中括号是元素的类型
(2) 隐式索引：
s.iloc[0:2]
loc 进行切片的时候， 左闭右闭 iloc进行切片的时候左闭右开
Series的基本概念:
shape，类型
size，几维数据
index,行数据
values列数据
head(),tail()快速查看Series对象的样式
xxx.head(3)查看前3行数据
xxx.tail(3)查看后3行数据
#===============================================
重点：
导入
csv文件或者 excel表格， 或者txt
例：data = pd.read_csv("./president_heights.csv")
pd.read_excel
还可以是json数据 html数据
可以使用pd.isnull()，pd.notnull()，或自带isnull(),notnull()函数检测缺失数据
pd.isnull(s)
#返回的结果 Series 每个元素是boolean
如果有空的数据则是返回True
pd.notnull()
如果不是空的数据则是返回True
#================================================
创建Series
例：
s = Series(data = np.random.randint(0,150,size = 5), index = ["张三","李四","Sara","Lisa","Michale"],
name = "Python")
Series之间的运算，在运算中自动对齐不同索引的数据，如果索引不对应，则补NaN。
DataFrame
是一个【表格型】的数据结构，可以看做是【由Series组成的字典】（共用同一个索引）。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
行索引：index
列索引：columns
值：values（numpy的二维数组）
DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。
创建：
例：
df1 = DataFrame(data = {"Python":[99,101,120,78],
"数学":[120,136,141,149],
"汉语":[123,114,130,117]},
index = list("abcd"))
df1
Python 数学 汉语 英语
a 99 120 123 NaN
b 101 136 114 NaN
c 120 141 130 NaN
d 78 149 117 NaN
DataFrame的索引
可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。
对行进行索引
- 使用.ix[]来进行行索引
- 使用.loc[]加index来进行行索引 左闭右闭
- 使用.iloc[]加整数来进行行索引 左闭右开
对行进行索引的额时候使用loc或者iloc 对列进行索引的时候，直接使用中括号
#但是一定要注意 一个中括号和两个中括号的区别， 列不能切片的
Series与DataFrame之间的运算
使用Python操作符：以行为单位操作（参数必须是行），对所有行都有效。（类似于numpy中二维数组与一维数组的运算，但可能出现NaN）
使用pandas操作函数：
axis=0：以列为单位操作（参数必须是列），对所有列都有效。
axis=1：以行为单位操作（参数必须是行），对所有行都有效。
Series与DataFrame之间的区别
Series 可以简单地被认为是一维的数组。
Series 和一维数组最主要的区别在于 Series 类型具有索引（ index ）。
可以调用as_matrix()将其转换为ndarray类型的对象
DataFrame对象
将数个 Series 按列合并而成的二维数据结构，每一列单独取出来是一个 Series
=========================================================================
Series也可以创建多层索引
例:
s = Series(data = [1,2,3,“a”],
index = [[“a”,“a”,“b”,“b”], [“期中”,“期末”,“期中”,“期末”]])
s
#三层索引
df = DataFrame(data = np.random.randint(0,150,size = 8),
index = [["a","a","a","a","b","b","b","b"],
["期中","期中","期末","期末","期中","期中","期末","期末"],
["一单元","二单元","一单元","二单元","一单元","二单元","一单元","二单元"]],
columns = ["Python"])
df
#隐式创建
造pd.MultiIndex
方式1：
df1 = DataFrame(data = np.random.randint(0,100,size = 8),
index = pd.MultiIndex.from_arrays([["a","a","a","a","b","b","b","b"],
["期中","期中","期末","期末","期中","期中","期末","期末"],
["一单元","二单元","一单元","二单元","一单元","二单元","一单元","二单元"]]),
columns = ["Python"])
df1
方式2：
df3 = DataFrame(np.random.randint(0,150,size = 4),
index = pd.MultiIndex.from_tuples([("a",1),("a",2),("b",1),("b",2)]),
columns = ["Python"])
df3
方式3：
df4 = DataFrame(np.random.randint(0,150,size = (8,2)),
index = pd.MultiIndex.from_product([list("abcd"), ["期中","期末"]]),
columns = ["Python","数学"])
df4
索引的堆（stack）
df4.unstack() #把第二层行索引变成了列索引
df4.unstack(level = 0) #把行索引变成列索引
#stack 是把列变成行索引
总结：使用stack()的时候，level等于哪一个，哪一个就消失，出现在行里。
使用stack()的时候，level等于哪一个，哪一个就消失，出现在行里。
聚合操作：
需要指定axis
和unstack()相反，聚合的时候，axis等于哪一个，哪一个就保留
例：
div()平均数
df4.sum(axis =0) 列为主
df4.sum(axis = 1) 行为主
df4.std()标准差
=====================================================================
pandas的拼接操作
注意：在进行pandas 级联的时候， 一定要注意轴的变化
参数ignore_index 含义：重新索引
pd.concat()默认axis=0
例：
pd.concat([df1, df3], axis = 1)
a b c d e f
1 a1 b1 c1 d1 e1 f1
2 a2 b2 c2 d2 e2 f2
3 a3 b3 c3 d3 e3 f3
pd.concat([df1, df2])默认axis=0
a b c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3
4 a4 b4 c4
5 a5 b5 c5
6 a6 b6 c6
使用多层索引 keys
concat([x,y],keys=['x','y'])
不匹配级联
外连接：补NaN（默认模式）
df1
a b c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3
df5 = make_df(list("abcd"), [3,4,5,6])
df5
a b c d
3 a3 b3 c3 d3
4 a4 b4 c4 d4
5 a5 b5 c5 d5
6 a6 b6 c6 d6
pd.concat([df1, df5], join = "outer")
a b c d
1 a1 b1 c1 NaN
2 a2 b2 c2 NaN
3 a3 b3 c3 NaN
3 a3 b3 c3 d3
4 a4 b4 c4 d4
5 a5 b5 c5 d5
6 a6 b6 c6 d6
内连接：只连接匹配的项
pd.concat([df1,df5], join = "inner")
a b c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3
3 a3 b3 c3
4 a4 b4 c4
5 a5 b5 c5
6 a6 b6 c6
df6 = make_df(list("abcz"), [3,4,7,8])
df6
df6.columns
pd.concat([df1,df2,df5,df6], join_axes=[df6.columns])
#连接指定的轴
a b c z
1 a1 b1 c1 NaN
2 a2 b2 c2 NaN
3 a3 b3 c3 NaN
4 a4 b4 c4 NaN
5 a5 b5 c5 NaN
6 a6 b6 c6 NaN
3 a3 b3 c3 NaN
4 a4 b4 c4 NaN
5 a5 b5 c5 NaN
6 a6 b6 c6 NaN
3 a3 b3 c3 z3
4 a4 b4 c4 z4
7 a7 b7 c7 z7
8 a8 b8 c8 z
使用append()函数添加
s1 = ["123"]
s1.append("456")
使用pd.merge()合并
===========================
merge与concat的区别在于，merge需要依据某一共同的行或列来进行合并
使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
注意每一列元素的顺序不要求一致
---==================================
一对一合并：
df1 = DataFrame({"age":[30,22,36],
"work":["tech","accounting","sell"],
"sex":["男","女","女"]},
index = list("abc"))
df1
age sex work
a 30 男 tech
b 22 女 accounting
c 36 女 sell
df2 = DataFrame({"home":["上海","安徽","山东"],
"work":["tech","accounting","sell"],
"weight":[60,50,40]}, index = list("abc"))
df2
home weight work
a 上海 60 tech
b 安徽 50 accounting
c 山东 40 sell
df1.merge(df2)
age sex work home weight
0 30 男 tech 上海 60
1 22 女 accounting 安徽 50
2 36 女 sell 山东 40
多对一合并
df3 = DataFrame({"home":["深圳","北京","上海","安徽","山东"],
'work':["tech","tech","tech","accounting","sell"],
"weight":[60,75,50,80,40]}, index = list("abcde"))
df3
home weight work
a 深圳 60 tech
b 北京 75 tech
c 上海 50 tech
d 安徽 80 accounting
e 山东 40 sell
多对多合并
df5 = DataFrame({"age":[28,30,22,36],
"work":['tech',"tech","accounting","sell"],
"sex":["女","男","女","男"]}, index = list("abce"))
df5
age sex work
a 28 女 tech
b 30 男 tech
c 22 女 accounting
e 36 男 sell
df3.merge(df5)
home weight work age sex
0 深圳 60 tech 28 女
1 深圳 60 tech 30 男
2 北京 75 tech 28 女
3 北京 75 tech 30 男
4 上海 50 tech 28 女
5 上海 50 tech 30 男
6 安徽 80 accounting 22 女
7 山东 40 sell 36 男
key的规范化
df6 = DataFrame({"age":[30,22,37],
"work":["tech","leader","sell"],
"hobby":["sixdog","playcat","diaofish"]}, index = list("abc"))
f6
age hobby work
a 30 sixdog tech
b 22 playcat leader
c 37 diaofish sell
df5.merge(df6)
age sex work hobby
0 30 男 tech sixdog
df5.merge(df6,on = "work", suffixes=["_总部","_分部"])
age_总部 sex work age_分部 hobby
0 28 女 tech 30 sixdog
1 30 男 tech 30 sixdog
2 36 男 sell 37 diaofish
使用left_on和right_on指定左右两边的列作为key，当左右两边的key都不想等时使用
df3
df3
home weight work
a 深圳 60 tech
b 北京 75 tech
c 上海 50 tech
d 安徽 80 accounting
e 山东 40 sell
df6
age hobby work
a 30 sixdog tech
b 22 playcat leader
c 37 diaofish sell
外合并 how='outer'：补NaN
df3.merge(df6, how = "outer")
home weight work age hobby
0 深圳 60.0 tech 30.0 sixdog
1 北京 75.0 tech 30.0 sixdog
2 上海 50.0 tech 30.0 sixdog
3 安徽 80.0 accounting NaN NaN
4 山东 40.0 sell 37.0 diaofish
5 NaN NaN leader 22.0 playcat
左合并、右合并：how='left'，how='right'，
df3.merge(df6, how = "left")
#左合并很重要的， 因为会给你个主表， 主表数据不能丢， 宁愿有空值也不能丢掉
df3.merge(df6, how = "left")
#左合并很重要的， 因为会给你个主表， 主表数据不能丢， 宁愿有空值也不能丢掉
home weight work age hobby
0 深圳 60 tech 30.0 sixdog
1 北京 75 tech 30.0 sixdog
2 上海 50 tech 30.0 sixdog
3 安徽 80 accounting NaN NaN
4 山东 40 sell 37.0 diaofish
df3.merge(df6, how = "right")
home weight work age hobby
0 深圳 60.0 tech 30 sixdog
1 北京 75.0 tech 30 sixdog
2 上海 50.0 tech 30 sixdog
3 山东 40.0 sell 37 diaofish
4 NaN NaN leader 22 playcat
=========================================
处理丢失数据
None和np.nan( NaN)
np.nan的类型是float类型
None的类型是None
np.nan输出nan
None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。
object类型的运算要比int类型的运算慢得多
计算不同数据类型求和时间
%timeit np.arange(1e5,dtype=xxx).sum()
%timeit np.arange(1e6, dtype = int).sum()
%timeit np.arange(1e6, dtype = float).sum()
%timeit np.arange(1e6, dtype = object).sum()
isnull()
notnull()
dropna(): 过滤丢失数据
fillna(): 填充丢失数据
is_null = df.isnull()
is_null 这个函数返回的结构和原来的结构一样， 所有的数据都是boolean， 如果为空 True 不为空的 返回false
is_null1 = is_null.any() 验证那一列有空值
is_null1
is_null1 = is_null.any(axis = 1) 检测哪一行有空值
is_null1
df3 = df.add(df2, fill_value=0) 非空值增加 fill_value增加的值就是 下面数据增加的几
df3
Python Java 数学 物理 H5
a 10.0 20.0 57.0 NaN NaN
b 22.0 33.0 44.0 12.0 NaN
c NaN 1.0 2.0 3.0 4.0
e 10.0 20.0 57.0 90.0 20.0
f 22.0 33.0 44.0 12.0 80.0
g 100.0 1.0 2.0 3.0 4.0
df3_isnull = df3.isnull().any(axis = 1)判断哪一行有空值 如果那一行有空值就显示True
df3_isnull
df3[df3_isnull] 把带有空值的数据显示出来
过滤函数 dropna()是一个删除空值的函数
df3.dropna(axis = 1)那一列没有空值 可以选择过滤的是行还是列（默认为行）
Java 数学
a 20.0 57.0
b 33.0 44.0
c 1.0 2.0
e 20.0 57.0
f 33.0 44.0
g 1.0 2.0
也可以选择过滤的方式 how = 'all' 滤除全为NaN的行
axis=1滤除列
df1.dropna(axis=1,how="all")
thresh=n滤除n行
填充函数 Series/DataFrame 函数:fillna()
df3.fillna(value=1) 将空值全部填充为1
可以选择前向填充还是后向填充
df3.fillna(method="bfill") method参数 :bfill向前填充 back 向后填充 ffill向上填充 forward向下填充
object时间大于float大于int
np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。
但可以使用np.nan*()函数来计算nan，此时视nan为0
isnull 和notnull 是用来判断数据是否为空的
isnull 和any notnull和all来连用
过条件的判断来检索 cond = (df3>=10).all(axis=1) 判断哪一行有大于10的数据 展现出来
pandas中None与np.nan都视作np.nan