Numpy
Numpy基本数据结构
np.array()函数接受一个多维list,返回对应纬度的矩阵
vector = np.array([1, 2, 3, 4])
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
特殊矩阵:
np.zeros((第一维size, 第二维size, ...)) 初始化全零矩阵,要求传入的是一个元组,存储各个维度上的尺寸.
np.ones((第一维size, 第二维size, ...)) 初始化全一矩阵,要求传入的是一个元组,存储各个维度上的尺寸.
np.arange(起点, 终点, 步长) 创建一个序列
np.eye(size) 创建一个size*size的单位矩阵
np.linspace(起点, 终点, 数列长度) 返回一个从起点到终点线性插值的长度为数列长度序列
np.logspace(起点指数, 终点指数, 数列长度, base=底数) 返回从 底数起点指数 到底数终点指数的长度为数列长度的等比序列
Numpy基本操作和属性
一个矩阵中存储的数据类型应该相同,其dtype属性返回矩阵中元素的数据类型
使用astype(类型)方法安全地改变元素的数据类型.
vector = numpy.array(["1", "2", "3", "4"]) # ['1' '2' '3' '4']
vector = vector.astype(float) # [1. 2. 3. 4.]
矩阵对象的shape属性返回其各维度上的尺寸.
使用reshape((第一维size, 第二维size, ...)) 方法更改重整数组的形状,若传入某维度上的size为-1,则根据其他维度的尺寸反推此维度的尺寸
matrix = np.arange(6).reshape(-1, 3) # 得到 [[0 1 2] [3 4 5]]
使用ravel()方法将高维矩阵拉伸成一维向量
matrix = np.arange(6).reshape(-1, 3)
matrix = matrix.ravel() # 得到 [0 1 2 3 4 5]
Numpy矩阵支持下标索引与切片,与python的list类似
matrix = numpy.array([[5,10,15], [20,25,30], [35,40,45]])
matrix[:,1] # 得到[10 25 40]
matrix[:,0:2] # 得到[[5 10] [20 25] [35 40]]
matrix[1:3,:2] # 得到 [[20 25] [35 40]]
Numpy矩阵的reshape()和切片并不返回新矩阵,只是更改了原矩阵的一个视图(view),对新视图进行的修改也会作用在原视图上
Numpy矩阵支持比较运算符, 返回一个与原矩阵尺寸相同的bool矩阵,存储对对应为进行判断的结果
print(matrix == 10) # 得到 [[False True False] [False False False] [False False False]]
print(matrix > 10) # 得到 [[False False True] [ True True True] [ True True True]]
与MATLAB类似,可以用矩阵比较运算的结果来索引矩阵
matrix[matrix>10]=10 # 得到 [[ 5 10 10] [10 10 10] [10 10 10]]
使用min(axis=维度), max(axis=维度), sum(axis=维度) 分别返回数组在某维度上的最小值,最大值和求和
matrix = np.arange(9).reshape((3, 3))
matrix.min(axis=1) # array([0, 3, 6])
matrix.max(axis=1) # array([2, 5, 8])
matrix.sum(axis=1) # array([3, 12, 21])
排序
numpy.sort(矩阵, axis=维度)返回对矩阵对应维度进行排序后的矩阵,注意返回的是一个新矩阵,而原矩阵不改变
numpy.argsort(矩阵, axis=维度)返回排序后矩阵每个位置的元素在原矩阵中的对应索引.
Numpy矩阵运算
加减法:
相同维度矩阵加减,对应位置元素相加减
a1 = np.array([20,30,40,50]) # 得到 [20 30 40 50]
a2 = np.arange(4) # 得到 [0 1 2 3]
a3 = a1 - a2 # 得到 [20 29 38 47]
矩阵加减某个标量,则对每个元素都加减这个标量
a1 = np.array([20,30,40,50]) # 得到 [20 30 40 50]
a2 = a1-1 # 得到 [19 29 39 49]
矩阵乘法:
相同维度矩阵使用*运算符,返回尺寸相同的新矩阵,其存储的是对应位置元素相乘结果
使用矩阵1.dot(矩阵1)或np.dot(矩阵1,矩阵2)计算矩阵点乘
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
# 矩阵对应位置相乘
print(A*B) # 得到 [[2 0] [0 4]]
# 矩阵点乘两种写法
print(A.dot(B)) # 得到 [[5 4] [3 4]]
print(np.dot(A,B)) # 得到 [[5 4] [3 4]]
乘方操作: 对矩阵每个元素进行乘方操作
A = np.range(5)
A = A ** 2 # 得到 [0 1 4 9 25]
矩阵拼接:
使用tile(矩阵,(第一维倍数, 第二维倍数, ...))方法将矩阵对应尺寸上延展对应倍数
matrix = np.arange(2)
matrix = np.tile(matrix,(1,3)) # 得到 [[0 1 0 1 0 1]]
matrix = np.tile(matrix,(3,1)) # 得到 [[0 1] [0 1] [0 1]]
矩阵的转置,行列式,求逆
使用.T属性求矩阵的转置
使用np.linalg.inv(矩阵)求矩阵的逆
使用np.linalg.det(矩阵)求矩阵的行列式
matrix = np.arange(1,5).reshape(2,2)
# 求矩阵转置
print(matrix.T) # 得到 [[1 3] [2 4]]
# 求矩阵的逆
print(np.linalg.inv(matrix)) # 得到 [[-2. 1. ] [ 1.5 -0.5]]
# 求矩阵的行列式
print(np.linalg.det(matrix)) # 得到 -2.0000000000000004
Pandas
pandas数据读取
使用pandas的read_csv()方法读取csv数据,读取到的数据将会被包装成一个DataFrame对象.
food_info = pd.read_csv("food_info.csv")
type(food_info) # pandas.core.frame.DataFrame
food_info.dtypes # DataFrame中包含的每个对象都被看成Numpy对象
food_info.columns.tolist() # 得到所有列名
food_info.values.tolist() # 以np.array形式返回其内容
pandas数据展示
调用DataFrame对象的head(行数)方法显示前行数行,tail(行数)方法显示前head行.
food_info.head() # 显示前5行
food_info.head(3) # 显示前3行
food_info.tail() # 显示后5行
调用DataFrame对象的shape()方法返回其矩阵形状
food_info.shape # (8618, 36)
调用DataFrame对象的loc[行数]属性取第行数行,行数可以是一个int数或一个列表
若行数为一个int数字,则返回一个Series对象
若行数为一个列表,则返回一个DataFrame对象
type(food_info.loc[[0]]) # pandas.core.frame.DataFrame
type(food_info.loc[0]) # pandas.core.series.Series
food_info.loc[3:5]
food_info.loc[[2,5,10]]
对DataFrame对象使用下标索引可以返回某几列
若传入一个索引值,则返回一个Series对象
若传入一个索引列表,则返回一个DataFrame对象
ndb_col = food_info["NDB_No"]
zinc_copper_col = food_info[["Zinc_(mg)", "Copper_(mg)"]]
type(ndb_col) # pandas.core.series.Series
type(zinc_copper_col) # pandas.core.frame.DataFrame
Pandas数据处理
对DataFrame对象进行加减乘除,等价于对其每一个元素进行加减乘除
div_100 = food_info["Iron_(mg)"] / 100
add_100 = food_info["Iron_(mg)"] + 100
sub_100 = food_info["Iron_(mg)"] - 100
mult_100 = food_info["Iron_(mg)"] * 100
例子: 计算加权指标
# Score = 2*(protein_(g))-0.75*(Lipid_Tot_(g))
weighted_protein = food_info["Protein_(g)"] * 2
weighted_fat = -0.75 * food_info["Lipid_Tot_(g)"]
initial_rating = weighted_protein + weighted_fat
取最值,平均值: max(),min(),mean(),Pandas会自动剔除不存在的坏值
# 使用max()取最大值
max_calories = food_info["Energ_Kcal"].max()
mean_calories = food_info["Energ_Kcal"].mean()
例子: 归一化数据并将其作为新行
normalized_protein = food_info["Protein_(g)"] / food_info["Protein_(g)"].max()
normalized_fat = food_info["Lipid_Tot_(g)"] / food_info["Lipid_Tot_(g)"].max()
food_info["Normalized_Protein"] = normalized_protein
food_info["Normalized_Fat"] = normalized_fat
排序
sort_value()方法将所有行按值排序
sort_index()方法将所有行按索引排序
# 第一个参数: 排序的键
# inplace: 是否直接替换原对象
# ascending: 升序与否
food_info.sort_values("Sodium_(mg)", inplace=True)
food_info.sort_values("Sodium_(mg)", inplace=True, ascending=False)
数据透视表
titanic_surival = pd.read_csv("titanic_train.csv")
使用pivot_table()函数生成数据透视表,其参数如下
index:指定以哪个指标为基准进行统计
values:统计的字段,可以为索引,也可以为索引列表
aggfunc:对统计字段的值应用的方法,默认取平均值,即np.mean()
# 统计不同船舱的获救概率
passenger_survival = titanic_surival.pivot_table(index="Pclass", values="Survived", aggfunc=np.mean)
# 统计不同船舱的年龄
passenger_age = titanic_surival.pivot_table(index="Pclass", values="Survived")
# 统计每个港口的 总票价 和 总获救人数
port_stats = titanic_surival.pivot_table(index="Embarked", values=["Fare", "Survived"], aggfunc=np.sum)
删除空值无锡妇科哪家医院好 http://www.87554006.com/
使用dropna()来删除带有空值的行或列,其参数列表如下
axis:维度,取0删除有空值的列,取1删除有空值的行
subset:删除掉subset字段有空值的行
# 删除掉所有有空值的列, axis=1
drop_na_columns = titanic_surival.dropna(axis=1)
# 删除掉所有["Age"或"Sex"字段]有空值的行
new_titanic_survival = titanic_surival.dropna(axis=0, subset=["Age", "Sex"])
重新建立索引
使用reset_index方法来重新建立索引
new_titanic_survival = titanic_surival.sort_values("Age", ascending=False)
# 将数据集按照当前顺序重新建立索引,drop代表放弃原来索引
titanic_reindexed = new_titanic_survival.reset_index(drop=True)
DataFrame对象的apply(函数)方法可以对数据每一列都执行自定义函数,并将结果汇总到一个Series对象中.
# 返回每一列的第100名
def hundredth_row(column):
# Extract the hundredth item
hundredth_item = column.loc[99]
return hundredth_item
# 对每个字段返回其第100位,下一行等价于 titanic_surival.loc[99]
hundredth_row = titanic_surival.apply(hundredth_row)
# 统计每一列的空值个数
def not_null_count(column):
column_null = pd.isnull(column)
null = column[column_null]
return len(null)
# 对每个字段返回其空值个数
column_null_count = titanic_surival.apply(not_null_count)
# 对每一行的Pclass字段编码
def which_class(row):
pclass = row["Pclass"]
if pd.isnull(pclass):
return "Unknown"
elif pclass == 1:
return "First Class"
elif pclass == 2:
return "Second Class"
elif pclass == 3:
return "Third Class"
# 返回每一行的Pclass字段的编码
classes = titanic_surival.apply(which_class, axis=1)
Pandas的基本数据结构:DataFrame和Series
DataFrame和Series为Pandas最重要的两种结构,其中Series类似于一维向量,而DataFrame类似于二维矩阵.
Series可以看作是Numpy对象的集合,DataFrame可以看作是Series的集合
fandango = pd.read_csv('fandango_score_comparison.csv')
# 对DataFrame进行索引取值得到Series
series_film = fandango['FILM']
type(series_film) # pandas.core.series.Series
可以使用Series()构造函数生成Series对象,index参数指定索引
from pandas import Series
film_names = fandango['FILM'].values # 得到所有电影名字
rt_scores = series_rt.values # 得到所有评分值
# 以电影名字为索引,将电影评分构成一个Series
series_custom = Series(rt_scores, index=film_names)
# 这样可以以电影名为索引找到电影
series_custom[['Minions (2015)', 'Leviathan (2014)']]
series的底层实现用的是np.ndarray,因此series对象可以替代ndarray作为函数参数
np.add(series_custom, series_custom)
np.sin(series_custom)
np.max(series_custom)