numpy、pandas使用

swai1688

已于 2022-04-06 23:36:37 修改

阅读量464

点赞数

分类专栏： Python开发文章标签： python

于 2022-02-23 20:28:38 首次发布

本文链接：https://blog.csdn.net/swai1688/article/details/123098624

版权

Python开发专栏收录该内容

8 篇文章 0 订阅

订阅专栏

numpy和pandas axis=0/axis=1的含义

numpy

增、删、改、查、基本属性

pandas

numpy和pandas axis=0/axis=1的含义

参考链接

axis=0指的行，numpy和pandas指代的是处理所有的行，返回的是一行的数据

axis=1,处理所有的列，所以axis=1,返回的是一列的数据

numpy

增、删、改、查、基本属性

参考教程：numpy使用

np.hstack\np.vstack\np.delete

import numpy as np
# narray数据类型,ndmin指定数组的维度
# 定义array类型,必须为相同数据类型，list dataframe没有这个要求
test_arr = np.array([[1,2,3],[4,5,6]],ndmin=1)
test_arr_2 = np.array([[7,8,9],[10,11,12]])
#查看属性 ndim shape dtype
test_arr.ndim
test_arr.shape
test_arr.dtype
#访问元素
#常规的for循环，通过下标来访问数据
for one_arr in test_arr:
    print(type(one_arr),one_arr)
#展平访问所有的
for one_ele in test_arr.ravel():
    print(one_ele) 
#迭代器访问 np.nditer order='C'按行访问 order='F'按列访问,通过迭代器是可以修改数据的 op_flags=['readwrite']
for one_arr in np.nditer(test_arr, order = 'C'):
    print(one_arr)
#增，不能直接在原arr增加，通过合并两个arr即可，np.vstack(垂直) np.hstack(水平)
np.vstack((test_arr,test_arr_2))
np.hstack((test_arr,test_arr_2))
#删
delete_arr = np.delete(test_arr,0,axis=0)
#np.hsplit np.vsplit切割

#reshape 变维
#这里需要区别 resize() 和 reshape() 的使用方法，它们看起来相似，实则不同。resize 仅对原数组进行修改，没有返回值，而 reshape 不仅对原数组进行修改，同时返回修改后的结果。

reshape_arr = test_arr.reshape((2,3))
#reval 展平 成为一维
ravel_arr = test_arr.ravel()

# 空值
np.nan

import numpy as np
test_arr = np.arange(10)
test_arr[2:9:2]
test_arr[2:]
#还可以使用 省略号“...”,返回所有的值
test_arr[...]
#整数数组、布尔值索引
test_arr[[1,2,3]]
test_arr[test_arr <5]

#广播机制，两个数组之间的算术运算问题
import numpy as np
a = np.array([0.1,0.2,0.3,0.4])
b = np.array([10,20,30,40])
c = a * b
print(c)

import numpy as np
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
#b数组与a数组形状不同
b = np.array([1,2,3])
print(a + b)

print(a*2)

# np.argwhere() 返回符合条件的索引值
x = np.arange(6).reshape(2,3)
y = np.argwhere(x>1)
print(y)

#np.unique return_counts = True
zero_arr = np.zeros(6)
unique_zero_arr = np.unique(zero_arr,return_counts=True)
print(unique_zero_arr)

import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 

#数学运算
np.sin/np.cos/np.tan
np.around
np.floor
np.ceil
#算术运算
np.add
np.subtract
np.multiply
np.divide
np.power
np.mod
np.sum

#统计函数
#amin()函数
print (np.amin(a))
#调用 amin() 函数，axis=1
print(np.amin(a,1))
#调用amax()函数
print(np.amax(a))
#再次调用amax()函数
print(np.amax(a,axis=0))

#argmax argmin 返回索引

#最值之差
np.ptp(a,0)
#np.percentile中位数

#np.median() 中值
np.median(a,0)
#np.mean()


#排序函数与搜索，sort 返回排好序的副本，argsort返回排好序的索引
np.sort(a,axis=1)
#np.argwhere,返回索引列表 [[],[]]
np.argwhere(x>1)
#如果a\b没有，则返回索引列表[index_a,index_b]
np.where(x>1,a,b)
#np.argmax np.argmin最大最小值的索引

#副本和视图
x.copy()

numpy random模块使用

import numpy as np
#随机数：
#传参都是n0,n1,n2..,如果为int，则需要最大最小值
#np.random.rand()/np.random.randn()(返回正态分布）/np.random.randint()
# np.random.random/np.random.random_sample()等为了兼容而保留的函数
np.random.rand()#返回一个随机值
# np.random.rand(n0,n1,n2...)
np.random.randn()#返回一个随机值
# np.random.randn(n0,n1,n2...)

#
np.random.randint(6)
np.random.randint(3,8,(4,5))

#正态分布
np.random.normal(10)
#均匀分布
np.random.uniform(0,10,10)

#设置随机种子
np.random.seed()

#随机选择
test_list = [1,2,3,4,5,6,6]
choice_size = 3
np.random.choice(test_list,choice_size)

pandas

参考教程

删除数据的操作与自带的数据类型一致，访问数据：df.iterrows() 或df.iteritems()

记住for index,row in df.iterrows():row["column_a"]即可

import pandas as pd 
# 基本数据类型 DataFrame 和 Series
df = pd.DataFrame({"test_a":["a","b"],"value":[1,2]})
#series的属性
sr = pd.Series([1,2,3])
sr.values/sr.index/sr.ndim
# 读入数据
# pd.read_csv()
# pd.read_excel()
# 增、删、改、查
#直接下标访问数据，[][]行访问必须为切片，列必须为名字访问，系统通过这两个方式区分行和列,行列位置可以调换
df[:1][["test_a","value"]]
df[["test_a"]][:1]

#通过 loc访问，loc主要通过位置访问,可以有一个[],或者两个[][],可以索引，可以标签
df.loc[[0,1]]["value"]
#添加行和列
index_name = 3
df.loc[index_name] = ["c",3]
#添加列或者通过insert
df["test_c"] = [4,5,6]
df.insert(1,column="test_c",value=[4,5,6])

#删除 行或者列
df.drop(columns=["test_c"],index=1,inplace=True)
df.pop("test_c")
del df["test_c"]

#遍历
for row in df.iterrows():
#以键值对 (key,value) 的形式遍历；
    print(row)
for item in df.iteritems():
    print(item)

#常用属性
df.head(5)
df.tail(6)
df.values
df.index
df.ndim
df.size
df.dtypes

#转置
df.T

#
df.shift

pd.concat合并两个dataframe，一般是相同列

pd.merge合并dataframe,以同名列作为join的key进行合并

误区：列跟列相加，一般是按照索引将两列加起来，并不是合并，df["a"]+df["b"]

# 合并不同的dataframe，concat（行操作）merge（列操作）
df_a = pd.DataFrame({"test_a":["a","b"],"value":[1,2],"value_2":[3,4]})
df_b = pd.DataFrame({"test_a":["a","b","c","d","d"],"value":[3,4,4,5,6],"value_2":[5,5,5,5,5]})

# ignore_index
df_concat = pd.concat((df_a, df_b),ignore_index=True)

#默认是用相同的列作为key，on
df_merge = pd.merge(df_a,df_b,left_index=True,right_index=True,how='outer')
#sort_values()排序
df_concat.sort_values(by=['test_a','value'],ascending=[True,False])

# groupby函数
df_concat_group = df_concat.groupby(["test_a"])
list(df_concat_group)

#groupby 之后的各种函数
#agg汇总函数
#transform:不同列，使用不同 {"value":"mean","value_2":"max"}
df_concat_group["value","value_2"].agg("mean")
df_concat_group["value","value_2"].transform("mean")

#first / last
df_concat_group.first()
df_concat_group.last()

#窗口函数,min_period=1可以不满足窗口数的值也显示
df.rolling(window=3).mean()
#groupby和rolling结合

#移动 shift,可实现 hive的窗口函数，lead、leg函数
df_concat_group.shift(-1) 
# rank method='average' first min max dense
pd.merge(df_concat,df_concat_group.rank(),left_index=True,right_index=True)

# 过滤 多个条件过滤
df_concat[(df_concat["test_a"]>'a') & (df_concat["value_2"]>1)] 
# map 输入为单个元素,只有series有map
def test_func(x):
#     print(x)
    return "test"

df_concat['value_2'].map(test_func)
# apply 输入为一个series
df_concat.apply(test_func,axis=0)

#applymap对于dataframe每个元素
df_concat.applymap(test_func)

#pipe操作整个dataframe
def adder(df_a,df_b):
    return df_a + df_b
df_a.pipe(adder,df_b)

#常用属性
df_a = pd.DataFrame([[1,2],[3,4]])
#设置columns
df_a.columns=["column_a","column_b"]
#添加行
df_a.loc[2]=[3,4]
df_a.loc[4]=[5,6]
#添加列
df_a["column_c"] = [1,1,1,1]
df_a.insert(3,column="column_d",value=[2,2,2,2])
print("final df_a",df_a)
#去掉重复行,也可以指定列标签去重
df_unique = df_a.drop_duplicates()
print(df_a.drop_duplicates(["column_a"],keep='last'))
#重置索引
df_unique.reset_index(drop=True,inplace=True)

#排序
df_a.sort_values("column_a")



#字符串处理函数，处理series
df_b = pd.DataFrame([["a","b"],["c","d"]],columns=["column_a","column_b"])
df_b["column_a"]=df_b["column_a"].str.upper()

#设置数据显示格式
# pd.set_option()
# pd.get_option()
#窗口函数
df_a.rolling(window=2).mean()

category类型

#创建
import pandas as pd
sr = pd.Series(["a","b","c","b"],dtype='category') 
sr_2 = pd.Categorical(["a","b","c","b"],["a","b","c","d"])

#获取类别信息categories和codes
# 通过series访问则使用.cat
sr.cat.categories
sr = sr.cat.add_categories(["e","f"])
sr = sr.cat.remove_categories(["e"]) 
print(sr.cat.categories)
sr_2.categories

sr.cat.codes
sr_2.codes
#
sr.cat.categories=["format.{}".format(x) for x in sr.cat.categories]

Dataframe,只有Series才有str 字符串操作，封装在df[xx].str.xxx()中

Dataframe空值判断和丢弃空值操作

import pandas as pd
import numpy as np

test_a = pd.DataFrame([["a","b"],["c",None],["d",np.nan],[None,None]],columns=["column_a","column_b"])
#isna和isnull功能一致
test_a.isna()
test_a.isnull()
#how="any" 和 "all",subset,inplace
test_a.dropna(axis=0,how="any",subset=["column_a","column_b"],inplace=True)
test_a

#去重操作
#how="first","last",None
test_a.drop_duplicates(subset=["column_a"],inplace=True,how="first")

scipy使用：参考教程

#常量模块
from scipy import constants
constants.acre

#向量量化
from scipy import cluster

#线性代数
from scipy imort linalg

#io模块
from scipy import io

#优化算法
from scipy import optimize

#快速傅里叶变换
from scipy import fft