1.Numpy基础
1.创建数组
创建一维数组
import numpy as np
a = np.arange(5)
注：将0 ，1， 2， 3， 4赋值给a这个变量
创建m*n的多维数组
import numpy as np
def cnmda(m,n):
'''创建numpy数组
参数：
m：第一维的长度
n：第二维的长度
'''
ret = 0
n = [y for y in range(n)]
ret = np.array([n]*m)
return ret
2.数组的基本运算
二维数组
a = np.array( [ [1, 2 , 3],[4 ,5 , 6] ] )
b = np.array( [ [ 4, 5, 6], [1, 2, 3] ] )
二维数组矩阵转置
In： a.T
Out: array([[1,4],
[2,5]
[3, 6])
二维数组的加和乘
import numpy as np
#定义函数
def opeadd(m, b, n):
'''
m:是一个数组
b： 是一个列表
n： 是列表的索引
返回 m+b[n]
'''
ret = 0
#创建多维数组， 并赋值给ret
ret = m + b[n]
return ret
def opemul（m,b ,n）:
'''
m:是一个数组
b： 是一个列表
n： 是列表的索引
返回 m*b[n]
'''
ret = 0
#创建多维数组，并赋值给ret
ret = m* b[n]
return ret
3.numpy数组的切片和索引
import numpy as np
def ce(a, m, n):
'''
a:是一个numpy数组
m:是第m维数组的索引
n:第m维数组的前n个元素的索引
你需要做的是 m+b[n]
返回值：
ret：一个Numpy数组
'''
ret = 0
#实现找出多维数组a中第m个数组的前n个元素 并赋值给ret
ret = a[m, :n]
return ret
4.numpy数组的堆叠
改变数组的形状
b = np.arange(24).reshape(2, 3, 4)
reshape()
import numpy as np
In： b = np.arange(24).reshape(2, 3, 4)
Out: b
Out: array([ [ [0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]],
[
[12, 13,14, 15],
[15, 16, 17, 18],
[19, 20, 21, 22,23] ]
] )
ravel():拆解，将多维数组变成一维数组
In： b.ravel()
Out: array(
[0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13,14, 15,
16, 17, 18,
19, 20, 21, 22,23 ])
flatten()：拉直，其功能与ravel（）相同，但是flatten（）返回的是真实的数组，需要分配新的内存空间，而ravel（）仅仅是改变视图。
shape（）：使用元组改变数组形状
In: b.shape = (6,4)
In: b
out: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
transpose（）：转置
In: b.transpose()
Out: array([[ 0, 4, 8, 12, 16, 20],
[ 1, 5, 9, 13, 17, 21],
[ 2, 6, 10, 14, 18, 22],
[ 3, 7, 11, 15, 19, 23]])
数组的堆叠
创建两个数组
In： a = np.arange(9).reshape(3,3)
In: a
Out: array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
In: b = a*2
In: b
Out: array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
hstack（）：水平叠加
In： np.hstack((a, b))# 注意这是两个括号
Out: array([[ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8, 10],
[ 6, 7, 8, 12, 14, 16]])
vstack（）：垂直叠加
In： np.vstack((a, b))
Out:array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
dstack():深度叠加
In ： np.dstack((a, b))
Out: array([[[ 0, 0],
[ 1, 2],
[ 2, 4]],
[[ 3, 6],
[ 4, 8],
[ 5, 10]],
[[ 6, 12],
[ 7, 14],
[ 8, 16]]])
实例：
import numpy as np
def varray(m,n):
'''
m:是第一个数组
n:是第二个数组
ret:一个numpy数组
'''
ret = 0
# 实现数组的垂直叠加并赋值给ret
ret = np.vstack((m, n))
return ret
def darray（m, n）:
ret = 0
#实现数组的深度叠加并赋值给ret
ret = np.dstack((m,n))
return ret
def harray(m, n):
ret = 0
#实现数组的水平叠加并赋值给ret
ret = np.hstack((m, n))
return ret
5.Numpy的拆分
拆分数组
新建数组
import numpy as np
In: a= np.arange(9).reshape(3,3)
In: a
Out: array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
hsplit():横向拆分
In： np.hsplit(a,3)
Out: [ array([[0],[3], [6]]),
array([[1], [4],[7]]),
array([[2],[5], [8]]) ]
vsplit():纵向拆分
In： np.vsplit(a,3)
Out: [ array([[0, 1, 2]]),
array([[3, 4, 5]]),
array([[6, 7, 8]]) ]
dsplit():深度拆分
深度拆分要求数组的的秩大于等于3
c= np.arange(27).reshape(3,3,3)
In: np.dsplit(c,3)
Out:[
array([
[[ 0], [ 3], [ 6]],
[[ 9], [12],[15]],
[[18], [21], [24]]
]),
array([
[[ 1], [ 4],[ 7]],
[[10],[13],[16]],
[[19], [22],[25]]
]),
array([
[[ 2], [ 5],[ 8]],
[[11],[14],[17]],
[[20], [23],[26]]
])
]
实例
import numpy as np
def vsarray(m, n):
'''
m: 第一个数组
n: 是需要拆分到的维度
返回值
ret： 一个Numpy数组
'''
ret = 0
#实现数组的纵向拆分并赋值给ret
ret = np.vsplit(m,n)
return ret
def hsarray(m,n):
ret = 0
#实现数组的水平拆分并赋值给ret
ret = np.hsplit(m,n)
return ret
def dsarray(m, n):
ret =0
#实现数组的深度拆分并赋值给ret
ret = np.dsplit(m, n)
return ret
2.pandas基础
1.了解数据的处理对象--series
数据结构：
Series：一维数组，类似于Python中的基本数据结构list，区别是Series只允许存储相同的数据类型，这样可以更有效的使用内存，提高运行效率。
DataFrame：二维的表格型数据结构，可以理解为Series容器。
Panel：三维的数组，可以理解为DataFrame容器。
Series是一个类似数组的对象，包含一个数组的数据（任何的Numpy的数据累心）和一个与数组关联的数据标签，被叫做索引。最简单的Series是由一个数组的数据构成。
In： obj = Series（[4, 7, -5, 3]）
In :obj
Out :
0 4
1 7
2 -5
3 3
创建一个带有索引来确定每个数据点的Series
In :obj2=Series([4,7,-5,3],index=['d','b','a','c'])
In :obj2
Out:
d 4
b 7
a -5
c 3
通过传递字典来创建一个Series
In :sdata={'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
In :obj3=Series(sdata)
In :obj3
Out:
Ohio 35000
Texas 71000
Oregon 16000
Utah 5000
实例
创建一个名为series_a的series数组，当中值为[1,2,5,7],对应的索引为['nu', 'li', 'xue', 'xi']创建一个名为dict_a的字典，字典中包含如下内容{'ting':1, 'shuo':2, 'du':32, 'xie':44}将dict_a字典转化成名为series_b的series数组。
# -*- coding: utf-8 -*-
from pandas import Series,DataFrame\
import pandas as pd
def create_series():
'''
返回值：
series_a:一个Series类型的数据
series_b: 一个Series类型的数据
dict_a: 一个字典类型的数据
series_a = Series([1,2,5,7], index= ['nu', 'li', 'xue','xi'])
dict_a = {'ting':1, 'shuo':2, 'du':32, 'xie':44}
series_b = Series(dict_a)
return series_a, dict_a, series_b
DataFrame是一个表格型数据结构，是以一个或多个二维块存放的数据表格（层次化索引），DataFrame即有行索引还有列索引，他有一组有序的列，每个列既可以是不同的类型（数值、字符串、布尔型）的数据，也可以看做由Series组成的字典。
DataFrame创建：
dictionary = { 'state'['0hio','0hio','0hio','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9] }
frame = DataFrame（dictionary）
修改行名：
frame = DataFrame（dictionary， index =['one','two','three','four','five']）
添加修改：
frame[add] = [[0,0,0,0,0]
添加Series类型：
value =Series（[1,3,1,4,6,8],index = [0,1,2,3,4,5]）
frame['add1'] = value
实例：、
创建一个五行三列的名为 df1 的DataFrame数组,列名为 [states,years,pops],行名['one','two','three','four','five']给df1添加新列，列名为 new_add，值为[7,4,5,8,2]
from pandas import Series，DataFrame
import pandas as pd
def create_dataFrame():
'''
返回值：
df1: 一个DataFrame数据
'''
#**********************************#
dictionary = {
'states':['0hio','0hio','0hio','Nevada','Nevada'],
'years':[2000,2001,2002,2001,2002],
'pops':[1.5,1.7,3.6,2.4,2.9] }
df1 = DataFrame(dictionary)
df1 = DataFrame(dictionary, index=['one','two','three','four','five'])
df1['new_add'] =[7,4,5,8,2]
return df1
2.读取csv格式数据
读取csv,并储存在 DataFrame 中。header 关键字告诉 Pandas 哪些是数据的列名。如果没有列名的话就将它设定为 None 。
# Reading a csv into Pandas.
# 如果数据集中有中文的话，最好在里面加上 encoding = 'gbk' ，以避免乱码问题。后面的导出数据的时候也一样。
df = pd.read_csv('uk_rain_2014.csv', header = 0)
查看前n行：df.head(5)
查看后n行：df.tail(5)
查看总行数：len（df）
修改列名：
df.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']
实例：
将test3/uk_rain_2014.csv中的数据导入到df1中；将列名修改为['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']；计算df1的总行数并存储在length1中。
from pandas import Series，DataFrame
import pandas as pd
def read_csv_data():
'''
返回值:
df1: 一个DataFrame类型数据
length1: 一个int类型数据
'''
#********************
df1 = pd.read_csv('test3/uk_rain_2014.csv', header =0)
df1.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']
length1 = len(df1)
return df1 , length1
3.数据的基本操作-排序
对索引进行排序
series用sort_index()按索引排序，sort（）按值排序
1.
In: obj = Series(range(4), index=['d','a','b','c'])
In obj.sort_index()
Out :
a 1
b 2
c 3
d 0
2.
In :frame = DataFrame(np.arange(8).reshape((2,4)),index=['three', 'one'],columns=['d','a','b','c'])
In: frame
Out:
d a b c
three 0 1 2 3
one 4 5 6 7
In: frame.sort_index()
Out:
d a b c
one 4 5 6 7
three 0 1 2 3
In:frame.sort()
Out:
d a b c
one 4 5 6 7
three 0 1 2 3
按行排序
In ： frame.sort_index(axis=1, ascending = False)
Out:
d c b a
three 0 3 2 1
one 4 7 6 5
按列排序（只针对Series）
In： obj.sort()
In : obj
Out:
d 0
a 1
b 2
c 3
按值排序
series
In ： obj =Series（[4, 7, -3, 2]）
In: obj.order()
out:
2 -3
3 2
0 4
1 7
DataFrame:
In: frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0, 1]})
In: frame.sort_values(by='b')
Out:
a b
2 0 -3
3 1 2
0 0 4
1 1 7
实例：
对代码中s1进行按索引排序,并将结果存储到s2；对代码中d1进行按值排序（index为f），并将结果存储到d2。
from pandas import Series,DataFrame
import pandas as pd
def sort_gate():
'''
返回值:
s2: 一个Series类型数据
d2: 一个DataFrame类型数据
'''
# s1是Series类型数据，d1是DataFrame类型数据
s1 = Series([4, 3, 7, 2, 8], index=['z', 'y', 'j', 'i', 'e'])
d1 = DataFrame({'e': [4, 2, 6, 1], 'f': [0, 5, 4, 2]})
#*******************************************************************
s2 = s1.sort_index()
d2 = d1.sort_values(by='f')
return s2,d2
4.数据的基本操作删除
删除指定轴上的项：即删除Series的元素或DataFrame的某一行（列）。我们可以通过对象drop（labels， axis=0）方法实现此功能。
删除Series的一个元素：
In: ser = Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In: ser.drop('c')
Out:
d 4.5
b 7.2
a -5.3
删除DataFrame的行和列
In: df = DataFrame(np.arange(9).reshape(3,3), index=['a','c','d'], columns=['oh','te','ca'])
In: df
Out:
oh te ca
a 0 1 2
c 3 4 5
d 6 7 8
In: df.drop('a')
Out[19]:
oh te ca
c 3 4 5
d 6 7 8
In: df.drop(['oh','te'],axis=1)
Out[20]:
ca
a 2
c 5
d 8
注意：drop（）返回的是一个新对象，元素对象不会被改变。
实例：
在s1中删除'z'行，并赋值到s2；在d1中删除'yy'列，并赋值到d2。
from pandas import Series, DataFrame
import pandas as pd
import numpy as np
def delete_data():
'''
返回值:
s2: 一个Series类型数据
d2: 一个DataFrame类型数据
'''
# s1是Series类型数据，d1是DataFrame类型数据
s1 = Series([5, 2, 4, 1], index=['v', 'x', 'y', 'z'])
d1=DataFrame(np.arange(9).reshape(3,3), columns=['xx','yy','zz'])
# ********** Begin *********#
s2 = s1.drop('z')
d2 = d1.drop('yy')
return s2,d2
5.数据的基本操作-算数运算
DataFrame中的算数运算是df中对应位置的元素的算术运算。如果没有共同的元素，则用NaN代替。
In: df1 = DataFrame(np.arange(12.).reshape((3,4)),columns=list('abcd'))
In: df2 = DataFrame(np.arange(20.).reshape((4,5)),columns=list('abcde'))
In: df1+df2
Out:
a b c d e
0 0 2 4 6 NaN
1 9 11 13 15 NaN
2 18 20 22 24 NaN
3 NaN NaN NaN NaN NaN
此外，如果我们想设置默认的其他填充值吗，而非NaN的话，可以传入填充值。
In: df1.add(df2, fill_value=0)
Out:
a b c d e
0 0 2 4 6 4
1 9 11 13 15 9
2 18 20 22 24 14
3 15 16 17 18 19
实例：
让df1与df2相加得到df3，并设置默认填充值为4。
from pandas import Series，DataFrame
import numpy as np
import pandas aspd
def add_way():
'''
返回值:
df3: 一个DataFrame类型数据
'''
# df1,df2是DataFrame类型数据
df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
# ********** Begin *********#
df3 = df1.add(df2,fill_value =4)
return df3
6.数据的基本操作-去重
duplicated()
DataFrame的duplicated方法返回一个布尔类型Series，表示各行是否是重复行。
创建DataFrame
In: df = DataFrame({'k1':['one']*3 + ['two']*4, 'k2':[1,1,2,3,3,4,4]})
In: df
Out:
k1 k2
0 one 1
1 one 1
2 one 2
3 two 3
4 two 3
5 two 4
6 two 4
检测：
In: df.duplicated()
Out:
0 False
1 True
2 False
3 False
4 True
5 False
6 True
drop_duplicates()用于去除重复的行数，具体用法：
In: df.drop_duplicates()
Out:
k1 k2
0 one 1
2 one 2
3 two 3
5 two 4
实例：
去除df1中重复的行，并把结果保存到df2中。
from pandas import Series, DataFrame
import pandas as pd
def delete_duplicated():
'''
返回值:
df2: 一个DataFrame类型数据
'''
# df1是DataFrame类型数据
df1 = DataFrame({'k1': ['one'] * 3 + ['two'] * 4, 'k2': [1, 1, 2, 3, 3, 4, 4]})
# ********** Begin *********#
df2 = df1.drop_duplicates()
return df2
7.层次化索引
层次化索引使我们能在一个轴上拥有多个（两个以上）索引级别。
如：
In:data = Series(np.random.randn(10), index = [['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd' ],[1,2,3,1,2,3,1,2,2,3]])
In:data
Out:
a 1 0.169239
2 0.689271
3 0.879309
b 1 -0.699176
2 0.260446
3 -0.321751
c 1 0.893105
2 0.757505
d 2 -1.223344
3 -0.802812
索引方式
In:data['b':'d']
Out:
b 1 -0.699176
2 0.260446
3 -0.321751
c 1 0.893105
2 0.757505
d 2 -1.223344
3 -0.802812
内层选取
In:data[:, 2]
Out:
a 0.689271
b 0.260446
c 0.757505
d -1.223344
数据重塑
将Series转化为DataFrame:
In:data.unstack()
Out:
1 2 3
a 0.169239 0.689271 0.879309
b -0.699176 0.260446 -0.321751
c 0.893105 0.757505 NaN
d NaN -1.223344 -0.802812
实例：
对s1进行数据重塑，转化成DataFrame类型，并复制到d1。
from pandas import Series， DataFrame
import pandas as pd
import numpy as np
def suosaying():
'''
返回值:
d1: 一个DataFrame类型数据
'''
#s1是Series类型数据
s1=Series(np.random.randn(10),
index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'], [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
# ********** Begin *********#
d1 = s1.unstack()
return d1
suoying()
