[Python知识库]Python知识点大纲

Pandas

基础

Series/DataFrame创建

# Series 
s1 = pd.Series([1,2,3.0,4],index=list('abcd'),dtype='int32',name='s2')
dict = {'apple':'red','banana':'yellow'} # key==》index，value==》value
s2 = pd.Series(dict)

# Series to DataFrame
s2.to_frame()

# DataFrame
df1 = pd.DataFrame(np.arange(25).reshape(5, 5), 
                  index = ['row1', 'row2','row3','row4','row5'], 
                  columns=['col1', 'col2','col3','col4', 'col5'])

dict = {'id':[1,2,3,5],'comment':['a','b','','d'],'name':list('ABCD')} 
df2 = pd.DataFrame(dict,index=['China','England','Japan','Korea']) # dict's key ==> column name

# df1新增col
df1 = df1.assign(new_col=lambda df1: df1.col1*df1.col2)
df1['new'] = df1.col1**2+df.col2

# multiIndex
indexs = pd.MultiIndex.from_tuples(
[('a', 1), ('b', 2),('c', 3),('c', 2),('e', 5)], names=['index1','index2'])
df1.index=indexs

切片

• data[] ——sad
  缺点：行列没法组合用

data[['col1','col2']] # 取多列
data[0:2] # 取第1、2行

• iloc() 基于位置，整数索引
  loc是location的意思，i可以当作integer加强记忆，因此iloc只能用整数索引「iloc比loc多了I，所以索引的时候可以少打=用整数来表示行列」

data.iloc[:,1] # 取单列
data.iolc[1,:] # 取单行
data.iloc[0:2,[1,3]] # 取连续行「不用[]」，取多列(非联系列)

• loc() 基于标签，用行/列名进行索引

data.loc[['row1','row2'],'col1':'col2'] # 取连续列

• ix()(不推荐：在iloc、loc之前的产物）
• iat、at （不推荐：只能取单个元素——at使用行、列名；iat使用行、列索引）

Boolean切片

# 逻辑关系：& | ～
df1[(df1.col3>=12)&(df1['col4']<=18)]

df1.loc[df1.col2>=11,'col2':'col4']

使用query

df1.query('col1 > 7')
df1.query('col1 > 7 or col2 <= 16')

随机抽样

• df.sample(n=10) / df.sample(frac=0.5)

filter

• df.filter(regex='str') 使用正则匹配

索引

• df.rename() # 重命名行/列索引名字
  • 两种修改方式：
  • (index=index_mapper, columns=columns_mapper, …)
  • (mapper, axis={‘index’, ‘columns’}, …)

df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
df.rename(columns={"A": "a", "B": "c"})
df.rename(index={0: "x", 1: "y", 2: "z"})

• df.set_index('A') # set the index：将A列作为索引
• df.reset_index() # 重置索引。set_index()的反向操作：分层索引的索引层级被还原回列

@Drop：bool，default F。是否删掉回列的索引
@inlace：bool，default F。

• df.reindex() # 重排索引：行/列索引。重排方式：更改顺序；新增加索引没有对应值，默认为nan；减少索引(等价切片，如果传入的list小于df)

DataFrame.reindex(
labels=None,
index=None, # 重排index
columns=None, # 重排col
method=None, # method{None, ‘backfill’/’bfill’, ‘pad’/’ffill’, ‘nearest’}
axis=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)

数据类型

• df.dtypes 查看字段数据类型
• df[‘a’].astype(‘float’) 数据类型转化

summarize data

• 常用属性/方法

# basic
df.head(n) / df.tail(n)
df.shape #  查看df的行/列#
len(df) # 查看df的行

df.index
df1.columns.to_list()

df.info() 			# 查看数据类型、cnt#、非空值
df.describe() 		# 查看cnt、mean、std、四分位数

df[['col1','col2']].unique() 	# 计算每列有几个“不同的值”
df['col1'].value_counts() 		# 计算每个值有几个“记录”

# summary
df.count() 			# cnt非空值
df.sum()
df.cumsum()			# 累加
df.min()/df.max()
df.mean()			# 取平均，如果有空值不会算进平均

# 统计
df.median()			# 取中位数，如果有空值会跳过
df.quantile([0.25,0.75]) 	# 取分位数，比describe灵活可以选择axis
df.var() 					# 计算方差（Variance）
df.std()					# 计算标准差（Standard Deviation）

df.idxmax()/df.idxmin()  # 取最小/最大的index value？

透视表功能

df.groupby

(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=NoDefault.no_default, observed=False, dropna=True)
@level: 当df是多维度索引时，可以用level参数进行第i层索引聚合

## Aggregation
- 常规用法：
df.groupby(['col1','col2']).mean()  # sum(),count()
df.groupby(['col1']).size() 		# size of each group

- 不同字段实现不通聚合-基础 # 结果是二级索引
f = {'ado':['sum'], 'seller':['count']}
df.groupby('country').agg(f) 	 	

- 不同字段实现不通聚合-改名 
df.groupby('country').agg(
						ado_sum=('ado','sum'),
						seller_cnt=('seller','count'),
						ado_range=('ado',lambda x: x.max()-x.min()
)

## Transformation, 
- 常规
df.transform(lambda x:(x+x%2))
- 高阶:求行/列分布
df1.transform(lambda x: x/x.sum(), axis=0) # 列的分布情况
df1.transform(lambda x: x/x.sum(), axis=1) # 行的分布情况

pd.pivot_table 更像透视表

pandas.pivot_table( data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All', observed=False, sort=True)
<==>df.pivot_table(values, index...)

# 基础：
table = pd.pivot_table(df, values='D', index=['A', 'B'],
                    	columns=['C'], aggfunc=np.sum, fill_value=0)

# 进阶：
table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
                    	aggfunc={'D': np.mean,
                             	 'E': [min, max, np.mean]})

pd.pivot: reshape data

pandas.pivot(data, index=None, columns=None, values=None)
没有聚合函数，仅是row转column，不能有重复的行列。pivot其实可以被pivot_table替代

df.stack() 堆积/ df.unstack()

stack列转行，unstack行转列

df.melt()

作用与df.stack类似。均可以通过pivot的方式还原。
区别

• df.stack()? 列转行，列名会成为index，需要从series转为dataframe
• df.melt()? 列转行，列名成为1列的值，默认忽略index；更灵活可以指定

pandas.melt(frame,
id_vars=None, # identifier variables 标识变量
value_vars=None, # Column(s) to unpivot. 如不指定所有剩余字段展开
var_name=None, # use for the ‘variable’ column
value_name=‘value’, # use for the ‘value’ column.
col_level=None, ignore_index=True)

append：https://www.gairuo.com/p/pandas-melt

combining data

• pd.merge(df1, df2, how, on) <==> df1.merge(df2, how, on)

pd.merge(right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=(‘_x’, ‘_y’), copy=True, indicator=False, validate=None)

默认重叠列拼接
@how： {‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’}, default ‘inner’
@on/left_on/right_on：join的key
@suffixes： 相同字段的后缀

• df1.join(other_df2, on=None, how='left', lsuffix='', rsuffix='', sort=False 功能与merge类似

默认行索引拼接，重叠列拼接（没啥区别？）
@how: {‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘left’
@sort: 是否根据连接的键进行排序

• pd.concat()
  用于多个df行方向/列方向的拼接(Vertical/Horizontal)
  pandas.concat(objs, axis=0, join=‘outer’, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)

@objs：[df1,df2,…]
@axis：=1时，会根据索引进行拼接
@join: {‘inner’, ‘outer’}, default ‘outer’
@ignore_index：True, 会重新索引
@key：指定用作“层次化索引”各级别上的索引
@name：行索引的名字
特殊应用：pd.concat([pd.DataFrame([i], columns=['A']) for i in range(5)], ignore_index=True)

• df.append() 数据纵向堆叠的拼接(Vertical)

DataFrame.append(
other, # 待合并的数据。可以是pandas中的DataFrame、series，或者是Python中的字典、列表这样的数据结构
ignore_index=False,
verify_integrity=False, # 默认是False，如果值为True，创建相同的index则会抛出异常的错误
sort=False)

iteration

df.iteritems() # (index-column name, Series)pairs
df.iterrows() # (index-row name, series) pairs

时间函数

date_range()

df1[‘date’] = pd.date_range(‘2022-01-01’, periods=5,freq=‘M’)

to_datetime() 将各种对象转化为datetime

高阶用法

missing data

• df.dropna()

@axis: {0 or ‘index’, 1 or ‘columns’}, default 0
@how: {‘any’, ‘all’}, default ‘any’
@thresh: int, optional（至少几个非空保留）
@subset: index / columns （哪几列/行判断是否NA）
@replace: bool, default False

• df.fillna()
• df.isnull()
• df.notna()
• df.replace("a","b")

(to_replace=None, value=NoDefault.no_default, inplace=False, limit=None, regex=False, method=NoDefault.no_default)
@to_replace: 待替换掉的数据(str, regex, list, dict, Series, int, float, or None都可以；正则也行)
@value: 用value来替换掉to_replace
@method：{‘pad’, ‘ffill’, ‘bfill’, None}，当value为空时，ffill靠前面的填充；bfill靠后面的填充；pad等价ffill？

duplicate data

• s3.unique() #Return unique values，series去重，df不行
• df.duplicated(subset=None, keep='first') # check duplicates

@subset: index / columns （哪几列/行判断是否重复）
@keep: {‘first’, ‘last’, False} （保留前值还是后值）
@return: T/F
first表示第二次出现为重复值(标记为T)；last表示前面出现为重复值(标记为T)；false表示每个都为重复值

• df.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False) # drop duplicates

@ignore_index: 重新索引

Numpy

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖