Skip to main content
 首页 » 编程设计

Numpy和Pandas的使用入门

2022年09月06日108over140

  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)


本文参考链接:https://www.cnblogs.com/djw12333/p/11627591.html