pandas学习

# pandas介绍

pandas 是 Python 的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。

## 基本数据结构
Series 和 DataFrame是pandas的两个核心数据结构，分别代表着一维的序列和二维的表结构。基于这两种数据结构，Pandas 可以对数据进行导入、清洗、处理、统计和输出。

Series类似于字典结构，由索引和值构成`index:values`,默认索引是int类型，从0开始。
```python
# 导入模块
import pandas as pd
# 使用Series构造方法
data = pd.Series([1,2,3,4,5])
print(data)
```

## Series类型数据

创建一个类似字典和列表的数据对象。
```python
s = pd.Series(data,index=index,name=None)
参数：
data:数据
index,索引，默认是int，从0开始
name,别名
```
### 创建
1.通过列表创建
```python
list1 = ['apple','pear','banana','peach']
data = pd.Series(list1)
print(data)
# 输出
0     apple
1      pear
2    banana
3     peach
dtype: object

# 也可以手动指定索引,可以是列表等迭代对象，需要注意与值对应，否则会报错
list1 = ['apple','pear','banana','peach']
data = pd.Series(list1,index=['First','Second','Third','Fourth'])
print(data)
```

2.通过字典创建
字典是key-value形式，会自动将索引录入index作为索引。
```python
info = {'name':'chuck','age':25,'sex':'男','height':'165cm'}
data = pd.Series(info)
print(data)

# 输出
name      chuck
age          25
sex           男
height    165cm
dtype: object
```

3.通过numpy的数组创建
还没学，以后再补上。

### 查看索引或者值

```python
# 直接输出Series对象
print(data)
# 输出
name      chuck
age          25
sex           男
height    165cm
weight     55kg
Name: test, dtype: object

# 查看所有索引
print(data.index)
# 输出
Index(['name', 'age', 'sex', 'height', 'weight'], dtype='object')

# 查看所有的值
print(data.values)
# 输出
['chuck' 25 '男' '165cm' '55kg']

# 通过指定的索引查看对应的值，可以通过下标或者索引名称
print(data['weight'])
print(data[0])
print(data[1:3])
# 输出
55kg
chuck
```

### 添加和修改
```python
# 直接通过键值对赋值添加
data['wage'] = '9500'
print(data['wage'])
# 输出
9500
```

### 常用属性和方法
values属性返回一个数组，可以进行切片截取操作。
```python
info = {'name':'chuck','age':25,'sex':'男','height':'165cm'}
data = pd.Series(info,name='test')
val = data.values
for i in val:
    print(i)

# 输出
chuck
25
男
165cm

# 切片
print(val[0:2])
```

index属性获取索引，返回一个数组系列。
```python
info = {'name':'chuck','age':25,'sex':'男','height':'165cm'}
data = pd.Series(info,name='test')
indexs = data.index
for i in indexs:
    print(i)
# 输出
name
age
sex
height
```

dtype属性，返回基础数据的类型。
```python
print(data.dtype)
```

size属性，返回基础数据元素的数量。
```python
print(data.size)
```

hasnans属性，如果数据有Nan,则返回True,否则返回False
```python
print(data.hasnans)
```

name属性，给Series索引命名。
```python
data = pd.Series(info,name='test')
print(data.name)
```

loc/iloc属性访问指定的值
```python
print(data.loc['height'])
print(data.iloc[3])
```

head()、tail()方法返回前几行和后几行数据
```python
print(data.head(2))
print(data.tail(2))
# 输出
name    chuck
age        25
Name: test, dtype: object
sex
height    165cm
Name: test, dtype: object
```

统计类方法，主要针对数值。
```python
sum,求和
mean,求平均值
max,最大值
min,最小值
count，计数
median,求中位数
describe,返回一个所有描述信息的Series对象
unique,统计去重之后的数量
nunique,所有数量
isnull,是否null,是为true,否为false
sort_index,对索引排序,ascending控制升序或降序，使用True和False,kind选择算法，na_position空值的位置，默认为last
sort_values,对数值排序
```
## DataFrame

DataFrame对象是一种表格型的数据结构，包含行索引、列索引以及一组数据。
```python
# 格式
pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None)
data 表示输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。
index 表示行标签，如果没有传递 index 值，则默认行标签是 RangeIndex(0, 1, 2, …, n)，n 代表 data 的元素个数。
columns 表示列标签，如果没有传递 columns 值，则默认列标签是 RangeIndex(0, 1, 2, …, n)。
dtype 表示要强制的数据类型。只允许使用一种数据类型。如果没有定义强制的数据类型，就会自行推断。
copy 表示从输入复制数据。对于 dict 数据，copy=True，表示重新复制一份。对于 DataFrame 或 ndarray 输入，类似于 copy=False，在原数据中进行操作。
```

### 创建
可以从列表和字典
```python
# 从列表创建
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)
# output
   0
0  1
1  2
2  3
3  4
4  5

```
# 从Series对象创建
```python
s = pd.Series(['apple','pear','peach','strawberry'])
data1 = pd.DataFrame(s,columns=['水果'])
print(data1)
# output
           水果
0       apple
1        pear
2       peach
3  strawberry
```
# 从嵌套列表创建，每个元素作为一列
```python
list1 = [['chuck',25],['joan',26]]
data2 = pd.DataFrame(list1,columns=['姓名','年龄'])
print(data2)

#output
      姓名  年龄
0  chuck  25
1   joan  26
```

# 从字典创建,一个键值对作为一列，值的数量要对应
```python
dict1 = {'姓名':['chuck','joan','ley','cheny'],'性别':['男','女','男','女'],'年龄':[25,26,25,26]}
data3 = pd.DataFrame(dict1)
print(data3)

# output
      姓名 性别  年龄
0  chuck  男  25
1   joan  女  26
2    ley  男  25
3  cheny  女  26
```
### 添加数据
1.通过直接赋值方式添加新列。
```python
dict1 = {'姓名':['chuck','joan','ley','cheny'],'性别':['男','女','男','女'],'年龄':[25,26,25,26]}
data3 = pd.DataFrame(dict1)

data3['工作城市']=pd.Series(['深圳','揭阳','广州','茂名'])
print(data3)
# output
      姓名 性别  年龄 工作城市
0  chuck  男  25   深圳
1   joan  女  26   揭阳
2    ley  男  25   广州
3  cheny  女  26   茂名
```

2.使用insert()添加
```python
df.insert(loc, column, value, allow_duplicates=False)
#loc,列的下标0,表示第一列，1第二列
# column列名
# value值,可以是列表多个值，如果是单个值就是列的值为相同
data2.insert(loc=2,column='性别',value=['男','女'])
data2.insert(loc=3,column='城市',value='深圳')
# 输出
      姓名  年龄 性别  城市
0  chuck  25  男  深圳
1   joan  26  女  深圳
```

### 修改
```python
data2.rename(columns={'姓名':'name','城市':'工作地址'},inplace=True)
# rename()
# columns为修改的列，column= {old:new},inplace=True表示修改原有data2,否则返回一个新的DataFrame对象

# 修改新的data3从原有data2
data3 = data2.rename(columns={'姓名':'name','城市':'工作地址'})

print(data3)
```
### 删除
使用drop删除
```python
DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)
labels：要删除的行或列，用列表给出
axis：默认为0，指要删除的是行，删除列时需指定axis为1
index ：直接指定要删除的行，删除多行可以使用列表作为参数
columns：直接指定要删除的列，删除多列可以使用列表作为参数
inplace: 默认为False，该删除操作不改变原数据；inplace = True时，改变原数据
# 示例
# 删除一行
# data2.drop(index=0,inplace=True)
data2.drop(columns=1,inplace=True)
print(data2)
```

### 常用方法

read_excel()从表格导入数据。
```python
pandas.read_excel(
io,
sheet_name=0,
header=0,
names=None,
index_col=None,
usecols=None,
squeeze=False,
dtype=None,
engine=None,
converters=None,
true_values=None,
false_values=None,
skiprows=None,
nrows=None,
na_values=None,
keep_default_na=True,
verbose=False,
parse_dates=False,
date_parser=None,
thousands=None,
comment=None,
skipfooter=0,
convert_float=True,
mangle_dupe_cols=True,
**kwds)
# 常用属性
id,读取的文件名
sheet_name,读取的sheet表，默认为0
header,表头首行，默认0，如果从第一行开始0行会忽略，None表示不使用源数据的表头
names,自定义表头，传递列表
index_col,指定列为索引，默认为None,就是索引为0的列作为索引，可以设置源数据表中相关字段为索引
usecols,读取指定列，默认为None,读取所有列，可以使用字符串指定列名或者通过'A','B','C'指定列，'A:E'
squeeze，默认为False,读取一列返回Series对象，设置为True不返回dtype
dtype,数据类型，默认None,不改变数据类型
engine，可以指定使用第三方库处理excel文件，如xlrd,openpyxl
converters,对指定列应用方法函数，可以是def或者lambda函数
true_values、alse_values将指定文本转换为True或者False
skiprows,指定跳过的行，int类型
nrows，用于大量数据读取，读取前几行，int类型。
na_values，指定某些列的某些值为NaN。
keep_default_na，表示导入数据时是否导入空值。默认为True，即自动识别空值并导入

# 示例
import pandas as pd
import numpy as np

df = pd.read_excel('通讯录.xlsx',nrows=10,usecols='B:I')
# print(df)

# 删除编号
# print(df.loc[:,['姓名','性别']])

print(df)
```

导出数据方式：
to_csv()
```python
path_or_buf：要写入的文件或文件对象的字符串路径。如果是文件对象，则必须使用newline=''
sep：输出文件的字段分隔符（默认“，”）
na_rep：缺失值的字符串表示形式（默认为“”）
float_format：浮点数的格式字符串
columns：要写入的列（默认为无）
header：是否写出列名（默认为 True）
index：是否写入行（索引）名（默认为 True）
index_label：如果需要，索引列的列标签。如果无 （默认值），且为 True，则索引名称为 使用。（如果使用多索引，则应给出一个序列）。headerindexDataFrame
mode：Python 写入模式，默认为“w”
encoding：一个字符串，表示在内容为 非 ASCII，适用于 3 之前的 Python 版本
lineterminator：表示行尾的字符序列（默认os.linesep)
quoting：设置报价规则，如在 csv 模块中（默认 csv.QUOTE_MINIMAL）。请注意，如果您设置了 那么浮点数将转换为字符串和 csv。QUOTE_NONNUMERIC会将它们视为非数字float_format
quotechar：用于引用字段的字符（默认为“”）
doublequote：控制 in 字段的引用（默认值为 True）quotechar
escapechar：用于转义的角色和转义时间 适当（默认无）sepquotechar
chunksize：一次要写入的行数
date_format：日期时间对象的格式字符串
```

to_excel()
```python
df.to_excel("path_to_file.xlsx", sheet_name="Sheet1")
# 指定文件名和表名

# 将多个df写入一个表中
with pd.ExcelWriter("path_to_file.xlsx") as writer:
    df1.to_excel(writer, sheet_name="Sheet1")
    df2.to_excel(writer, sheet_name="Sheet2")
```
to_dict()
```python
df.to-dict(	orient='dict' into= None)
函数中只需填一个参数：orient即可，但对于写入的orient不同，字典的构造方式也不同，其中有一种是列表形式
orient = 'dict' 函数默认，转换后的字典形式：{column:{index:value}}
orient = 'list'转换后字典形式：{column:[values]}
orient = 'series'转换后字典形式：{column:Series(value)}
orient = 'split'转换后字典形式：{'index':[index],'columns':[columns],'data':[values]}
orient = 'records'转换后list形式：[{column:value}...{column:value}]
orient = 'index'转换后字典形式：{index:{column:value}}
```

loc()方法获取指定行或列。
```python
# pandas 的 .loc() 方法是一个用于选择行和列的函数，它可以帮助你在 pandas 数据帧中定位和选择特定的数据。使用方法是在数据帧名称后面跟上 .loc[]，然后在方括号内输入行和列的标签，标签可以是整数、字符串或布尔值。
# 格式 df.loc[行标签,列标签]

data = pd.DataFrame(np.arange(25).reshape(5,5),index=list('abcde'),columns=list('ABCDE'))

# 提取指定行
print(data.loc['a'])
# output
A    0
B    1
C    2
D    3
E    4
Name: a, dtype: int32

# 提取多行，需要将行标签用列表写明，列标签可以省略或者使用:表示所有列
print(data.loc[['a','d'],:])
# output
    A   B   C   D   E
a   0   1   2   3   4
d  15  16  17  18  19

# 提取指定行的指定列
print(data.loc[['a','d'],['A','B','D']])
# output
    A   B   D
a   0   1   3
d  15  16  18

# 指定行的条件查询获取，查询A列的值大于10，并且B列值大于20的行
print(data.loc[(data['A'] > 10) & (data['B'] > 20)])
# output
    A   B   C   D   E
e  20  21  22  23  24

# 通过loc进行赋值操作
data.loc['a','A'] = 99
```

iloc()通过下标获取指定行和列,iloc索引器用于按位置进行基于整数位置的索引或者选择。
```python
data = pd.DataFrame(np.arange(25).reshape(5,5),index=list('abcde'),columns=list('ABCDE'))
# 格式：df.iloc [row selection, column selection]
# 查询第一行数据，和loc类似，通过下标从0开始可以使用:或者-1等
print(data.iloc[0,:])
# output
A    0
B    1
C    2
D    3
E    4
Name: a, dtype: int32

# 获取多行
print(data.iloc[[0,2],:])
# output
    A   B   C   D   E
a   0   1   2   3   4
c  10  11  12  13  14

```

dropna()删除空值。
```python
pandas.DataFrame.dropna(self, axis=0, how='any', thresh=None, subset=None, inplace=False)
# 参数说明
axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。
thresh：设置需要多少非空值的数据才可以保留下来的。
subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。
```

replace()替换方法。
```python
df.replace(to_replace=None,value=None,inplace=False,limit=None,regex=False,method='pad)
# 参数
to_replace	查找要替换的值
value	替换与查找匹配的值
inplace	修改原数据(True/False)
limit	向前或向后填充的最大尺寸间隙
regex	是否支持正则表达式(True/False)
method	替换方法
# 示例
data.replace(0, '未知', inplace=True)
# output
    A   B   C   D   E
a  未知   1   2   3   4
b   5   6   7   8   9
c  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24
```

rename()重命名行列索引。
```python
DataFrame.rename(self, mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore')
# 参数
mapper,字典或者映射，默认是修改行index索引
index行索引，以字典形式，赋予索引新的值 { 0 : “第一行”}
columns，以字典形式，赋予列名新的值 { A : “第一列”}
axis指定坐标轴 “index” or “columns”
inplace,是否修改源数据对象
errors，针对错误的处理，ignore为忽略，raise为报错。
# 示例
data.rename(columns={'A':'姓名','B':'性别','C':'年龄','D':'身高','E':'体重'},inplace=True)
data.rename(index={'a':0,'b':1,'c':2,'d':3,'e':4},inplace=True)
print(data)
# output
    A   B   C   D   E
a   0   1   2   3   4
b   5   6   7   8   9
c  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24
   姓名  性别  年龄  身高  体重
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
4  20  21  22  23  24
```

drop_duplicates()去除重复项。
```python
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)
# 参数
subset,用来指定特定的列，默认所有列
keep, {'first','last', False}, default 'first'
inplace,是否修改源对象。

# 示例
data = pd.read_excel('test.xlsx')
print('初始数据：\n',data)
data.drop_duplicates(inplace=True)
print('去重后数据：\n',data)
# output
初始数据：
     工号     姓名  年龄       入职日期   性别      部门     岗位
0  1.0     张三  26 2019-10-07    男  信息管理中心  网络工程师
1  NaN   joan  27 2019-07-01    女     业务部    业务员
2  NaN  chuck  26        NaT  NaN     NaN    NaN
3  1.0     张三  26 2019-10-07    男  信息管理中心  网络工程师
4  NaN  chuck  26 2023-05-19    男     信息部    工程师
去重后数据：
     工号     姓名  年龄       入职日期   性别      部门     岗位
0  1.0     张三  26 2019-10-07    男  信息管理中心  网络工程师
1  NaN   joan  27 2019-07-01    女     业务部    业务员
2  NaN  chuck  26        NaT  NaN     NaN    NaN
4  NaN  chuck  26 2023-05-19    男     信息部    工程师

# 指定subset参数，只有姓名和年龄列重复就删除
data.drop_duplicates(inplace=True,subset=['姓名','年龄'])
```

astype()修改数据类型，默认每一列都是一个Series对象，有dtype属性。
```python
(dtype: Any | _str | Type[str] | Type[bytes] | Type[date] | Type[datetime] | Type[timedelta] | Type[bool] | Type[int] | Type[float] | Type[complex] | Type[Timestamp] | Type[Timedelta], copy: _bool = ..., errors: IgnoreRaise = ...) -> Series
data['工号'].astype('str')
print(data.info())
# 输出
<class 'pandas.core.frame.DataFrame'>
Int64Index: 3 entries, 0 to 2
Data columns (total 7 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   工号      1 non-null      object
 1   姓名      3 non-null      object
 2   年龄      3 non-null      int64
 3   入职日期    2 non-null      datetime64[ns]
 4   性别      2 non-null      object
 5   部门      2 non-null      object
 6   岗位      2 non-null      object
dtypes: datetime64[ns](1), int64(1), object(5)
memory usage: 132.0+ bytes
None
```

fillna()填补空值。
```python
print(data.fillna('Miss',inplace=True))
```