pandas处理excel

START

 

import pandas as pd
url = "input.xls"
data = pd.read_excel(io=url,index_col="age",sheet_name=0)

"""
参数：
io 代表文件路径
index_col 代表索引列
sheet_name 为第几张工作表  默认为第一个，可以用索引，也可以用名字
"""

 

输出所有信息

print(data,type(data))
"""
  id name  个性签名
age               
23    1   a1  哥的地盘
24    2   a2  哥的传说
25    3   a3  心花怒放
26    4   a4  倚天屠龙
27    5   a5  逍遥剑先 
<class 'pandas.core.frame.DataFrame'>
"""

按照索引，输出一行数据

 

print(data.loc["a2"])

-----------------------
id         2
age       24
个性签名    哥的传说
Name: a2, dtype: object

 

后面获取单个字段

 

print(data.loc["a2"].get("个性签名"))
-----------------------------------
哥的传说

 

获取所有的列的字段名

print(data.columns)
-------------------
Index(['id', 'age', '个性签名'], dtype='object')



print(data.columns.values)
------------------------------
['id' 'age' '个性签名']

获取一列：

print(data["age"]) #单个字段
---------------------
name
a1    23
a2    24
a3    25
a4    26
a5    27




print(data[["age","id","个性签名"]])  #也支持多个字段 以数组传参
-----------------------------
      age  id  个性签名
name               
a1     23   1  哥的地盘
a2     24   2  哥的传说
a3     25   3  心花怒放
a4     26   4  倚天屠龙
a5     27   5  逍遥剑先

如何遍历呢？

 

for idx,row in data.iterrows():  #idx=索引的值，row=一行数据
    print(f"{idx}的数据为：")
    for key in data.columns.values:
        s = f"{key}:{row.get(key)}"
        print(s)
    print("----------")
---------------------------------------------------------------
a4的数据为：
id:4
age:26
个性签名:倚天屠龙
----------
a5的数据为：
id:5
age:27
个性签名:逍遥剑先
----------

 

做数据的条件判断。

 

print(data.loc[data["id"] > 3,["个性签名","id"]])
print(data["id"] == 2)
------------------------------------------------------------
 个性签名  id
name          
a4    倚天屠龙   4
a5    逍遥剑先   5

 

将数据保存为excel

 

data_frame1 = data.loc[data["id"] > 3,["个性签名","id"]]
data_frame1.to_excel("output.xlsx")

 

剩下的我该去补一补基础喽，numpy 和 pandas

-----------------------------numpy---------------------------------------

pip install numpy

如何创建对象

 

#第一种创建方式
arr = np.array([11,22,33])
print(arr,type(arr))
-------------
[11 22 33] <class 'numpy.ndarray'>


#第二种创建方式： 通过读取文件

#第三种创建方式
arr = np.ones(shape=(3,3)) # 全部为1
arr = np.zeros(shape=(3,3)) #全部为0
arr = np.arange(1,26).reshape(5,5) #range效果一样
arr = np.random.randint(0,100,size=(3,5))#取值伪随机数，需要指定size
arr = np.linspace(0,10,num=5) #从a到b分为n份

 

属性：

 

print(arr.shape) #形状
print(arr.ndim)# 几维
print(arr.size)#一共有多少个数据
print(arr.dtype)#数据类型

 

方法：

 

arr.reshape(1,25)

 

索引和切片

#print(arr[0][3]) = print(arr[0,3]) #索引取值

print(arr[1:,:2]) #切片  

print(arr[1:][:3]) #代表先切出来一个结果 再继续切！！！！！！！！！！！！！！！注意

#注意 一定要在一个括号里面切

将数组转化为一维数组：这里说一下，不止是用于pandas也适用于numpy

 

arr.flatten()

 

聚合函数：

 

arr1.sum(axis=1)

 

级联：

data = np.concatenate((arr0,arr1),axis=1)
------------------------------------------
[[0. 0. 1. 1.]
 [0. 0. 1. 1.]]
 
np.hstack((arr0,arr1)) #== (axis = 1)
np.vstack((arr0,arr1)) #== (axis = 0)

-----------------------------------------pandas---------------------

分为两种数据类型

"""series : 为一维数据dataframe: 二维数据"""

创建series数据方式

 

s = pd.Series(data=[1,2,"abc"],index=["a","b","c"]) #基本创建
dic = {
    "name":"wusen"
}
s = pd.Series(data=dic)#通过字典创建

print(s,type(s))
----------------------------------------------------
a      1
b      2
c    abc
dtype: object <class 'pandas.core.series.Series'>

 

索引切片：

 

pass：跟别的一样，不试了，不重要

 

属性：

 

print(s.shape) #太懒了，不写了
print(s.size)
print(s.index)
print(s.values)
print(s.dtype)

 

方法：

 

print(s.head(1)) #前一个数据
print(s.tail(1)) #后一个数据
print(s.unique()) #去重
print(s.isnull) #这个方法没搞明白是啥

#series运算的时候索引必须一样

 

二维数组dataframe

创建：

 

df = pd.DataFrame(data=np.arange(1,10).reshape(3,3),index=["a","b","c"],columns=["A","B","C"])
print(df,type(df))
-------------------------------------------
   A  B  C
a  1  2  3
b  4  5  6
c  7  8  9 <class 'pandas.core.frame.DataFrame'>

#默认索引和列 都是0123456 只有手动指定以后才会变

 

属性：

 

print(df.index)
print(df.columns)
print(df.values)
print(df.shape)

 

索引切片

 

# print(df["A"]) #取一列
# print(df[["A","B"]]) #取多列
# print(df[["A","B"]]["A"]) #在多列基础上继续取列
# print(df.iloc[0]) #隐士取一行
# print(df.iloc[0:]) #隐士取多行
# print(df.loc["a"]) #显式取一行
# print(df.loc[["a","b"]]) #显式取多行

# print(df.iloc[1,1]) #隐式取值
# print(df.iloc[[1,2],[1,2]]) #隐式取值  
# print(df.iloc[:,:]) #隐式切片取值

 

其他知识点：

 

# 如何给某一列转换为时间格式
# df["time"] = pd.to_datetime(df["time"])
# 将某一列数据作为行索引,inplace=True  将新数据赋值给原来的变量
df.set_index("A",inplace=True)
print(df)

 

数据清洗：

缺失值：None 不可以参与运算

np.nan(NAN) 可以参与运算

重复值

异常值

处理缺失值：

 

# df = pd.DataFrame(data=np.arange(1,10).reshape(3,3))
# df.iloc[1,1] = None #会默认转化为NAN
# print(df)
# 方式一：对空值过滤，删除行数据
# 太麻烦了
# print(df.isnull().any(axis=1)) #any是检测 行或者列中是否有True
# print(df.isnull().any(axis=1).index)
# df = df.drop(labels=df.isnull().any(axis=1).index,axis=1)
# 方式二：
# print(df.dropna(axis=0))
# 方式三：
# print(df.fillna(value=0)) #默认指定一个数值
# print(df.fillna(method="ffill",axis=1)) #同一行，前一个数据
# print(df.fillna(method="bfill",axis=1)) #同一行，取后一个数据

 

处理重复值：

 

df = pd.DataFrame(np.arange(1,26).reshape(5,5))
df.iloc[1] = [0,0,0,0,0]
df.iloc[2] = [0,0,0,0,0]
df = df.drop_duplicates(keep="first") #keep : {'first', 'last', False}, default 'first'

 

处理异常数据：

 

# 处理异常数据
# df = pd.DataFrame(data=np.random.random(size=(1000,3)),columns=["A","B","C"])
# print(df)
# twice_std = df["C"].std()*2 # 条件
# -(df["C"] > twice_std)
# df.loc[-(df["C"] > twice_std)]
# 异常值练习
# df = pd.DataFrame(data=np.arange(9).reshape(3,3),columns=["A","B","C"])
# print(df)
# print(df["A"]>3)
# print(df.loc[df["A"]>3])

 

级联操作：

 

# df1 = pd.DataFrame(data=np.ones(shape=(2,2)),columns=["A","C"])
# df2 = pd.DataFrame(data=np.zeros(shape=(2,2)),columns=["A","B"])
# print(pd.concat((df1,df2)))# 默认为0
# print(pd.concat((df1,df2),axis=1))
# print(pd.concat((df1,df2),axis=0,join="inner"))#参数为内连接

 

合并数组：

 

# data1 = {
#     "name":["a","b","c"],
#     "age":[11,22,33]
# }
# df1 = pd.DataFrame(data=data1)
# data2 = {
#     "name":["a","b","c"],
#     "num":[1111,2222,3333]
# }
# df2 = pd.DataFrame(data=data2)
# print(pd.merge(df1,df2,on="name"))
# # 参数on = left——on  +  right_on
# #参数how = "inner"

 

高级操作--------------------------

按照一维数组 指定替换某个值：

 

df = pd.DataFrame(data=np.arange(1,10).reshape(3,3),index=["a","b","e"],columns=["A","B","C"])
print(df.replace(to_replace=5,value="HHHH"))#变成一维数组，第一个数字改变
print(df.replace(to_replace=[1,3],value="HHHH"))#变成一维数组，列表里面的位置都会变
print(df.replace(to_replace={1, 3,6},value="HHHH"))#变成一维数组，列表里面的位置都会变

 

映射 map

 

dic = {
    "name":["张三","李四"],
    "num":[5000,8000]
}
df = pd.DataFrame(data=dic)
# 定义映射关系
mapper = {
    "张三":"是个傻子",
    "李四":"不是傻子"
}
df["sign_name"] = df["name"].map(mapper)
print(df)

 

映射例子一：

 

# def after_num(s):#计算税后薪资
#     return s - (s-3000)*0.5
# df["after_num"] = df["num"].map(after_num)
# print(df)

 

随机抽样：

 

# df = pd.DataFrame(data=np.arange(12).reshape(4,3),columns=["A","B","C"])
# print(df)
# # np.random.permutation(3) = [2,1,0]  打乱
# # df = df.take([2,1,0],axis=1)
# df = df.take(np.random.permutation(3),axis=1).take(np.random.permutation(4),axis=0)
# print(df)

 

----数据分类处理

 

dic = {
    "name":["A","A","B","C"],
    "num":[10,20,33,44]
}
df = pd.DataFrame(data=dic)

自定义高级聚合函数:.transform(fun1)    ==   apply(fun1)
def fun1(s):
    return s+100
print(df.groupby(by="name")["num"].transform(fun1))
"""
# print(df.groupby(by="name")["num"].mean())
# mapper = df.groupby(by="name")["num"].mean().to_dict()
# df["mean_num"] = df["name"].map(mapper)
# print(df)

 

透视表 && 交叉表

 

#这个怎么说呢，就相当于group by

dic = {
    "name":["A","A","B","C"],
    "num":[10,20,33,44]
}
df = pd.DataFrame(data=dic)
print(df)
# pandas高级操作-透视表&交叉表
print(df.pivot_table(index="name",values=["num"],aggfunc="sum"))
"""
index:分类条件
values:计算的列
aggfunc：聚合函数
columns:再一次分类
fill_value:NaN的替换值
"""
# 交叉表：
# pd.crosstab(df.age,df.smoke)
"""
参数跟pivot_table的差不错
"""

 

工作中遇到的新问题：

 

#1.将所有的NAN换成空字符串，用replace
df = df.replace([np.NAN,-np.NAN],"")
print(df)

2.新加一行数据：
dic = {
    "name":["A","B","C"],
    "age":[1,2,3]
}
df = pd.DataFrame(dic)
new = pd.DataFrame({"name":"hhhh"},index=["0"])
df = df.append(new,ignore_index=True)#如果加上这个参数，

笔记：如果其他值不写的话，那么它默认为NAN

3.给选中的元素赋值用at  (用loc好像不可以赋值)
df.at[index,colunm] = new_value

4.筛选条件  &并且   |或者     ~取反
df_new = df[(df["Line"] == line) & (df["Shift"] == shift)]