Latest version: 1.2.4

编辑器：PyCharm、Jupyter 官网文档PDF文档

import numpy as np
import pandas as pd

数据结构

Series

Series是一个一维标记数组，能够保存任何数据类型（整数、字符串、浮点数、Python 对象等）。轴标签统称为index。

# 创建系列的基本方法
s = pd.Series(data, index=index)
# 如果data是 ndarray，则index必须与data 的长度相同。如果没有传递索引，将创建一个具有 values 的索引。[0, ..., len(data) - 1]
s = pd.Series(np.random.randn(5), index=["a", "b", "c", "d", "e"])  # numpy创建
# 查看索引
s.index
# 创建索引
pd.Series(np.random.randn(5))
# 列表创建
# Series组成部分：pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
lst = [1,3,5,6,10,23]
# 可以通过index指定索引，如果不指定索引，则会自动从0开始生成索引，我们叫做隐式索引
s = pd.Series(lst) 
# 字典创建
dic = {"A":1,"B":2,"C":3,"D":2}
s2 = pd.Series(dic)

DataFrame

DataFrame是一种二维标记数据结构，具有可能不同类型的列。您可以将其视为电子表格或 SQL 表，或 Series 对象的字典。与 Series 一样，DataFrame 接受多种不同类型的输入：

• 一维数组、列表、字典或系列的字典
• 二维 numpy.ndarray
• 结构化或记录ndarray
• 一种Series
• 其他 DataFrame ```python

  字典

  d = { “one”: pd.Series([1.0, 2.0, 3.0], index=[“a”, “b”, “c”]), “two”: pd.Series([1.0, 2.0, 3.0, 4.0], index=[“a”, “b”, “c”, “d”]), }

  转化为DataFrame

  df = pd.DataFrame(d) pd.DataFrame(d, index=[“d”, “b”, “a”]) pd.DataFrame(d, index=[“d”, “b”, “a”], columns=[“two”, “three”])

  通过索引和列属性分别访问行和列标签

  df.index df.columns

来自 ndarrays / 列表的字典

d = {“one”: [1.0, 2.0, 3.0, 4.0], “two”: [4.0, 3.0, 2.0, 1.0]} pd.DataFrame(d) pd.DataFrame(d, index=[“a”, “b”, “c”, “d”])

来自结构化或记录数组

data = np.zeros((2,), dtype=[(“A”, “i4”), (“B”, “f4”), (“C”, “a10”)]) data[:] = [(1, 2.0, “Hello”), (2, 3.0, “World”)] pd.DataFrame(data) pd.DataFrame(data, index=[“first”, “second”]) pd.DataFrame(data, columns=[“C”, “A”, “B”])

从字典列表

data2 = [{“a”: 1, “b”: 2}, {“a”: 5, “b”: 10, “c”: 20}] pd.DataFrame(data2) pd.DataFrame(data2, index=[“first”, “second”]) pd.DataFrame(data2, columns=[“a”, “b”])

从字典元组

In [56]: pd.DataFrame( { (“a”, “b”): {(“A”, “B”): 1, (“A”, “C”): 2}, (“a”, “a”): {(“A”, “C”): 3, (“A”, “B”): 4}, (“a”, “c”): {(“A”, “B”): 5, (“A”, “C”): 6}, (“b”, “a”): {(“A”, “C”): 7, (“A”, “B”): 8}, (“b”, “b”): {(“A”, “D”): 9, (“A”, “B”): 10}, } )

通过数据框的方式创建数据框

province = pd.DataFrame([‘广东’, ‘广西’, ‘福建’, ‘福建省’], columns=[‘省份’]) print(province) pr1 = province.loc[province[‘省份’].str.contains(‘福’)] print(pr1)

<a name="cVCvo"></a>
### 导入导出
数据导入
```python
# Pandas读取Excel
df=pd.read_excel(r'D:\test.xlsx')  # 直接默认读取到这个Excel的第一个表单
df=pd.read_excel(filepath,sheet_name='Sheet1')  # 可以通过sheet_name来指定读取的表单
# header参数值默认为0，即用第一行作为列索引；usecols表示要导入第几列
data=df.head()  # 默认读取前5行的数据
print("获取到所有的值:\n{0}".format(data))  # 格式化输出
# read_csv()默认文件中的数据都是以逗号分开，也可以用sep=""指定分隔符；nrows指定前几行
pd.read_csv("csv_file")
# Pandas读取txt文件
pd.read_table(r"c:\data\test.txt", sep=" ")  # 须用sep指明分隔符

数据导出

# 输出到Excel格式
df_inner.to_excel('Excel_to_Python.xlsx', sheet_name='bluewhale_cc')
# 输出到CSV格式
df_inner.to_csv('Excel_to_Python.csv')

生成数据

# 创建数据表
df = pd.DataFrame({"id": [1001, 1002, 1003, 1004, 1005, 1006],
                   "date": pd.date_range('20130102', periods=6),
                   "city": ['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
                   "age": [23, 44, 54, 32, 34, 32],
                   "category": ['100-A', '100-B', '110-A', '110-C', '210 - A', '130 - F'],
                   "price": [1200, np.nan, 2133, 5433, np.nan, 4432]},
                  columns=['id', 'date', 'city', 'category', 'age', 'price']
                  )

df1 = pd.DataFrame({"id": [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
                    "gender": ['male', 'female', 'male', 'female', 'male', 'female', 'male', 'female'],
                    "pay": ['Y', 'N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', ],
                    "m-point": [10, 12, 20, 40, 40, 40, 30, 20]}
                   )

df.set_index('name', inplace=True) # 建立索引并生效

数据检查

df.shape # 查看数据表的维度
df.info() # 显示有数据类型、索引情况、行列数、各字段数据类型、内存占用等：
df.describe() # 查看数值型列的汇总统计，会计算出各数字字段的总数（count）、平均数（mean）、标准差（std）、最小值（min）、四分位数和最大值（max）：
df.dtypes # 查看数据表各列格式
df['B'].dtype # 查看单列格式
df.head(3) # 查看前3行数据，默认head()显示前10行数据
df.tail(3) # 查看最后3行
df.sample(5) # 随机查看5条
df.isnull() # 检查数据空值
df['price'].isnull() # 检查特定列空值
df['city'].unique() # 查看city列中的唯一值
df.values # 查看数据表的值
df.columns # 查看列名称
df.axes # 显示数据行和列名
print(len(df)) # 行数
print(df.shape[0])
print(df.shape[1]) # 列数

数据清洗

# 删除数据表中含有空值的行
df.dropna(how='any')
# 使用数字0填充数据表中空值
df.fillna(value=0)
# 使用price均值对NA进行填充
df['price'].fillna(df['price'].mean())
# 清除city字段中的字符空格
df['city'] = df['city'].map(str.strip)
# city列大小写转换
df['city'] = df['city'].str.lower()
# 更改数据格式
df['price'].astype('int')
# 更改列名称
df.rename(columns={'category': 'category-size'})
# 删除后出现的重复值
df['city'].drop_duplicates()
# 删除先出现的重复值
df['city'].drop_duplicates(keep='last')
# 数据替换
df['city'].replace('sh', 'shanghai')

数据处理

# 数据表匹配合并，inner、left，right和outer方式
df_inner = pd.merge(df, df1, how='inner')
df_left = pd.merge(df, df1, how='left')
df_right = pd.merge(df, df1, how='right')
df_outer = pd.merge(df, df1, how='outer')
# 设置索引列
df_inner.set_index('id')
# 按特定列的值排序
df_inner.sort_values(by=['age'])
# 按索引列排序
df_inner.sort_index()
# 如果price列的值>3000，group列显示high，否则显示low
df_inner['group'] = np.where(df_inner['price'] > 3000, 'high', 'low')
# 对复合多个条件的数据进行分组标记
# 对city列等于beijing并且price列大于等于4000的数据标记为1
df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign'] = 1
# 对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size
df_split = pd.DataFrame((x.split('-') for x in df_inner['category']), index=df_inner.index,
                        columns=['category', 'size'])
# 将完成分列后的数据表与原df_inner数据表进行匹配
df_inner = pd.merge(df_inner, df_split, right_index=True, left_index=True)
# 对数据进行翻转
df.groupby('team').sum().T
df.groupby('team').sum().stack()
df.groupby('team').sum().unstack()

df['one'] = 1 # 增加一个固定值的列
df['total'] = df.Q1 + df.Q2 + df.Q3 + df.Q4 # 增加总成绩列

# 将计算得来的结果赋值给新列
df['total'] = df.loc[:,'Q1':'Q4'].apply(lambda x:sum(x), axis=1)
df['total'] = df.sum(axis=1) # 可以把所有为数字的列相加
df['avg'] = df.total/4 # 增加平均成绩列

# Excel多列数据处理
df[["标准地址", "lng", "lat", "时间"]] = df.apply(lambda x: get_url_batch(x['地址']), axis=1, result_type='expand')
df[['lng_', 'lat_']] = df.apply(lambda x: bd09_to_wgs84(x['lng'], x['lat']), axis=1, result_type='expand')

数据提取

# 按索引提取单行的数值
df_inner.loc[3]
# 按索引提取区域行数值
df_inner.loc[0:5]
# 重设索引
df_inner.reset_index()
# 设置日期为索引
df_inner = df_inner.set_index('date')
# 提取4日之前的所有数据
df_inner[:'2013-01-04']
# 使用iloc按位置区域提取数据
df_inner.iloc[:3, :2]
# 使用iloc按位置单独提取数据
df_inner.iloc[[0, 2, 5], [4, 5]]
# 使用ix按索引标签和位置混合提取数据
df_inner.ix[:'2013-01-03', :4]
# 按条件提取（区域和条件值）
# 判断city列的值是否为beijing
df_inner['city'].isin(['beijing'])
# 先判断city列里是否包含beijing和shanghai，然后将复合条件的数据提取出来。
df_inner.loc[df_inner['city'].isin(['beijing', 'shanghai'])]
category = df_inner['category']

数据筛选

# 查看指定列
df['Q1']
df.Q1 # 同上，如果列名符合Python变量名要求，可使用

# 选择多列
df[['team', 'Q1']] # 只看这两列，注意括号
df.loc[:, ['team', 'Q1']] # 和上一行效果一样

# 选择行
# 用指定索引选取
df[df.index == 'Liver'] # 指定姓名
# 用自然索引选择，类似列表的切片
df[0:3] # 取前三行
df[0:10:2] # 在前10个中每两个取一个
df.iloc[:10,:] # 前10个

df.loc['Ben', 'Q1':'Q4'] # 同时给定行和列的显示范围
df.loc['Eorge':'Alexander', 'team':'Q4'] # 指定行区间


# 使用“与”条件进行筛选
df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id', 'city', 'age', 'category', 'gender']]
# 使用“或”条件筛选
df_inner.loc[
    (df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id', 'city', 'age', 'category', 'gender']].sort(['age'])
# 对筛选后的数据按price字段进行求和
df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id', 'city', 'age', 'category', 'gender',
                                                                        'price']].sort(['age']).price.sum()
# 使用“非”条件进行筛选
df_inner.loc[(df_inner['city'] != 'beijing'), ['id', 'city', 'age', 'category', 'gender']].sort(['id'])
# 对筛选后的数据按city列进行计数
df_inner.loc[(df_inner['city'] != 'beijing'), ['id', 'city', 'age', 'category', 'gender']].sort(['id']).city.count()
# 使用query函数进行筛选
df_inner.query('city == ["beijing", "shanghai"]')
# 对筛选后的结果按price进行求和
df_inner.query('city == ["beijing", "shanghai"]').price.sum()
df[df['team'] == 'C'].loc[df.Q1>90] # 多重筛选

数据汇总

# 对所有列进行计数汇总
df_inner.groupby('city').count()
df.groupby('team').sum() # 按团队分组对应列相加
df.groupby('team').mean() # 按团队分组对应列求平均
# 不同列不同的计算方法
df.groupby('team').agg({'Q1': sum,  # 总和
                        'Q2': 'count', # 总数
                        'Q3':'mean', # 平均
                        'Q4': max}) # 最大值
# 按列计数
count = df['提供部门（单位）'].value_counts()
# 对特定的ID列进行计数汇总
df_inner.groupby('city')['id'].count()
# 对两个字段进行汇总计数
df_inner.groupby(['city', 'size'])['id'].count()
# 对city字段进行汇总并计算price的合计和均值。
df_inner.groupby('city')['price'].agg([len, np.sum, np.mean])
# 数据透视表
# 分别计算price的数量和金额并且按行与列进行汇总
pd.pivot_table(df_inner, index=["city"], values=["price"], columns=["size"], aggfunc=[len, np.sum], fill_value=0,margins=True)

# 排序
df.sort_values(by='Q1') # 按Q1列数据升序排列
df.sort_values(by='Q1', ascending=False) # 降序
df.sort_values(['team', 'Q1'], ascending=[True, False]) # team升序，Q1降序

数据统计

df.mean() # 返回所有列的均值
df.mean(1) # 返回所有行的均值，下同
df.corr() # 返回列与列之间的相关系数
df.count() # 返回每一列中的非空值的个数
df.max() # 返回每一列的最大值
df.min() # 返回每一列的最小值
df.median() # 返回每一列的中位数
df.std() # 返回每一列的标准差
df.var() # 方差
s.mode() # 众数

# 简单的数据采样
df_inner.sample(n=3)
# 手动设置采样权重
# Weights参数是采样的权重，通过设置不同的权重可以更改采样的结果，权重高的数据将更有希望被选中。这里手动设置6条数据的权重值。将前面4个设置为0，后面两个分别设置为0.5。
weights = [0, 0, 0, 0, 0.5, 0.5]
df_inner.sample(n=2, weights=weights)
# 采样后不放回
df_inner.sample(n=6, replace=False)
# 采样后放回
df_inner.sample(n=6, replace=True)
# 数据表描述性统计
df_inner.describe().round(2).T
# 标准差
df_inner['price'].std()
# 两个字段间的协方差
df_inner['price'].cov(df_inner['m-point'])
# 数据表中所有字段间的协方差
df_inner.cov()
# 相关性分析
df_inner['price'].corr(df_inner['m-point'])
# 数据表相关性分析
df_inner.corr()