f

figo

V1

2022/06/23阅读:15主题:默认主题

pandas笔记

1. Series基础

1.1. 创建Series

  • 从字典创建
prices = {'apple':4.99,
  'banana':1.99,
  'orange':3.99,
  'grapes':0.99}
ser = pd.Series(prices)
  • 从标量创建
ser = pd.Series(2,index = range(0,5))

1.1.1. 使用字母索引

ser = pd.Series(range(1,15,3),index=[x for x in 'abcde'])

1.1.2. 随机数序列

import random
ser = pd.Series(random.sample(range(100),6))

1.1.3. 对Series进行命名

import pandas as pd
a =[1,3,5,7]
a = pd.Series(a,name ='JOE')
a = pd.DataFrame(a)

1.2. 提取元素

1.2.1. 使用比较

import pandas as pd
import random

x = random.sample(range(100),10)
print(x)
y = pd.Series(x)
print(y)
print("==============================")
print(y[y>40])

1.2.2. 使用列表索引

x=random.sample(range(100),10)
print(x)
y = pd.Series(x)
print(y[[2,0,1,2]])

1.2.3. 使用函数

def joe(x):
    return x +10
x = random.sample(range(100),10)
print('Data => ',x,'\n')
y = pd.Series(x)
print('Applying pow => \n' ,pow(y,2),'\n')
print('Applying joe => \n',joe(y))

1.2.4. 元素检查

x = pd.Series(range(1,8),index=[x for x in 'abcdefg'])
print(x,'\n')
print('Is "j" in x? ','j' in x)
print('Is "d" in x? ''d' in x)

2. DataFrame基础

2.1. 选择定位

  • loc方法:通过行索引 "index" 中的具体值来取行数据(如取"Index"为"A"的行)
  • iloc方法:通过行号来取行数据(如取第二行的数据)
    • 选取某几列:df.iloc[:,[0,3,5,1]]
  • 利用loc函数的时候,当index相同时,会将相同的Index全部提取出来,优点是:如果index是人名,数据框为所有人的数据,那么我可以将某个人的多条数据提取出来分析;缺点是:如果index不具有特定意义,而且重复,那么提取的数据需要进一步处理,可用.reset_index()函数重置index
    • 注意,此处设置索引时,直接.set_index('XXX')不行,必须这样:df = df.set_index('XXX')才能生效。
    • 或者,可以这样:.set_index('XXX', inplace = True])
  • 使用点符号。
    • data.Area.head()
  • 如果选取的结果是dataframe,则列或行要表示成列表形式。
    • data[['column_name_1', 'column_name_2']]

2.1.1. 获取DataFrame中分组最大值的索引

  • idxmax()可以获取原df中最大值的索引
  • contb.groupby('cand_nm',as_index=False)[['contb_receipt_amt']].max().index()获取的是生成的新df的索引(即从0开始)
  • contb.groupby('cand_nm')[['contb_receipt_amt']].max().index()获取df是以cand_nm为索引

综上,想要获取每个候选人获取单笔献金最大值的索引,只能用idxmax()方法。

但是这种方法有个缺陷,即只能找出其中一个最大捐赠者。如果一个候选人有多个相同额度的最大捐赠者,则这种方法行不通。

下面的方法,用groupby找出每个候选人最大的捐赠额,然后用候选人和捐赠额作为条件,找出相对应的行。

df_max_donation = pd.DataFrame()
s = contb.groupby('cand_nm')['contb_receipt_amt'].max()
for i in range(s.size):
    ex = 'cand_nm == "%s" & contb_receipt_amt == %f' % (s.index[i], s.values[i])
    # print(ex)
    df_max_donation = pd.concat([df_max_donation,contb.query(ex)],axis=0,)
display(df_max_donation)

应该还有一种方法,将s(Series)转成dataframe,然后和contb进行join操作。 参见[[美国大选献金分析#^805156]]

2.2. 删除列

dt=data.drop("Area",axis=1,inplace=True)
  • axis=1,此操作影响列,即导致列的增加或减少
  • inplace=True,直接在原始 DataFrame 上编辑
  • 有关axis的用法可以参考[[#axis 的理解]]

2.3. 删除行

df.drop([01])
df.drop(index=[01])

注意第一个参数为index,所以在以条件删除行的时候要确认获得条件筛选之后的index值作为参数。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(12).reshape(3,4), columns=['A''B''C''D'])
# df.drop(df[df['A']==4].index,inplace=True)
df.drop(df[df['A']==4].index,inplace=True)

2.4. 增加列或修改列

data.loc[data['id'] > 800"first_name"] = "John"

这段代码可以增加first_name列,如果first_name列已经存在,则会修改满足条件的行的该列值。 增加列也可以用np.wherenp.select

另外,np.select也可以用来修改已经存在的某列的指定行的值,这种情况下,np.select修改的是整列的值,所以如果只想修改特定条件行的值,要注意修改default的值。

con = [abb_pop['state/region'] == 'PR', abb_pop['state/region'] == 'USA']
values = ['Puerto Rico''United States of America']

abb_pop['state'] = np.select(con, values, default=abb_pop['state'])

有关np.wherenp.select的解释可以参考[[#np where 和 np select 再解释]]

2.4.1. 问题

对于数值列,以亿为单位。如果数值较小(小于0.1亿),则转化成以万为单位,并加上万“万元”,否则,加上“亿元”。

如何使用np.select()直接操作?

暂时只想到一个非直达的方法:

x = np.array([0.0001,0.03,0.1,0.9,1,4.3])
df = pd.DataFrame(x, columns = ['r_amt'])
condlist = [df['r_amt']<=0.1, df['r_amt']>0.1]
choicelist = [df['r_amt']*10000, df['r_amt']]
choicelist2 = ['万元''亿元']

# 下面的写法出错。
# choicelist = [str(x) + '万元', x**2]

df['amt'] = np.select(condlist, choicelist, None)
df['unit'] = np.select(condlist, choicelist2, None)
df['amt'] = df['amt'].astype('str')
df['all'] = df['amt'] + df['unit']
df

2.4.2. 某列字段拆分成新列

知识点:

  • apply的重要用法,可以将字符串分割之后的多列组合成pandas,方法就是apply(Series, 1)
  • stack将拆散成的多列打散,变成多行。
  • 合并具有相同index的 DataFrameSeries ,可以用 join 。 具体可参见IMDB - Analysis by Genres
s = dt['genres'].str.split('|').apply(Series, 1).stack()
s.index = s.index.droplevel(-1)
s.name = 'genres'
del dt['genres']
df = dt.join(s)

2.5. 重命名列

两种方式重命名列:

  • 通过使用字典将旧名称映射到新名称进行重命名,格式为 {“old_column_name”: “new_column_name”, …};
    • data.rename(columns={"Area":"place_name"},inplace = False)
  • 通过提供更改列名称的函数重命名。函数应用于每个列名称。
    • data.rename(columns=str.lower)

2.6. 设置索引

df.set_index('country')

设置索引后可以方便地使用loc进行定位,也可以用join连接。

2.7. 设置列名

df.columns=['population','total GDP']

2.8. 对列进行数学操作

df['population'] =df['population']*1000

2.9. 统计列中不同元素出现的次数

df['xxx'].value_counts()

2.10. 自定义排序

from pandas.api.types import CategoricalDtype
cat_size_order = CategoricalDtype(
    ['浦东新区''闵行区''徐汇区''松江区''黄浦区''普陀区''嘉定区''静安区''奉贤区''杨浦区''青浦区''崇明区''虹口区''金山区''宝山区''长宁区''全市'], 
    ordered=True
)
df['行政区'] = df['行政区'].astype(cat_size_order)

2.11. 后续学习stack和unstack

TO BE STUDIED...

参考链接:

https://www.cxyzjd.com/article/S_o_l_o_n/80917211

https://www.jianshu.com/p/8a859643f37e

https://blog.csdn.net/S_o_l_o_n/article/details/80917211

2.12. 数据分段处理

bins = [0,1,10,100,1000,10000,100000,1000000,10000000]
labels = pd.cut(contb_vs['contb_receipt_amt'],bins)
contb_vs['label'] = labels
contb_vs

3. 其他基础

3.1. axis的理解

我的理解:axis = 0 可以理解为结果影响行,axis = 1 可以理解为结果影响列。也就是说,最终作用的结果是行减少了(增加了)还是列减少了(增加了)。

作用范围 作用效果
axis = 0 增加或减少
axis = 1 增加或减少

比如:

data.drop("Area",axis=1),列减少;

df.mean(axis=0),行减少;

df.apply(lambda x:x.max()-x.min()),默认axis = 0,行增加(或减少);

另外可以参考Ambiguity in Pandas Dataframe / Numpy Array "axis" definition

3.2. np.wherenp.select再解释

df['hasimage'] = np.where(df['photos']!= '[]'TrueFalse)
store_patterns = [
    (df['Store Name'].str.contains('Hy-Vee', case=False, regex=False), 'Hy-Vee'),
    (df['Store Name'].str.contains('Central City',
                                case=False,  regex=False), 'Central City'),
    (df['Store Name'].str.contains("Smokin' Joe's",
                                case=False,  regex=False), "Smokin' Joe's"),
    (df['Store Name'].str.contains('Walmart|Wal-Mart',
                                case=False), 'Wal-Mart')
]

store_criteria, store_values = zip(*store_patterns)
df['Store_Group_1'] = np.select(store_criteria, store_values, 'other')

3.3. 时间日期学习

TO BE STUDIED...

3.3.1. 数据重采样

df.resample('M').first() 相关资源:pandas.DataFrame.resample时间重采样的间隔参数

3.3.2. pandas.Series.rolling

可以在求诸如“5日平均”数据时使用。 相关资源:pandas.Series.rolling

3.3.3. pd.to_datetime

doc: pd.to_datetime,注意format等参数。

3.3.4. 获取月份

参考[[消费行为分析#获取月份]] astype('datetime64[M]')可以将datetime格式的数据转成月份,优点是datetime64格式,但是在显示的时候会显示成“1970-01-01”这样的格式。

to_period('M')可以将datetime格式的数据转成月份,而且可以显示成“1970-01”这样的格式。缺点是不是datetime64格式。

如果只想获取单独的月或年,可以这样:

df['year'] = df.order_dt.dt.year
df['month'] = df.order_dt.dt.month

格式为int64

另注意,这里只是要获取月份,暂时并不是要以月份重取样然后求和、技术等操作。如果想做数据重取样,需要对order_dt设置索引。因为resample只能对DatetimeIndex, TimedeltaIndex or PeriodIndex格式的数据进行。

这里有个resample的常见问题**TypeError: Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of 'RangeIndex'**,

Stack Overflow上有个答案:

Convert column date to datetimes and add parameter on to resample:

df['date'] = pd.to_datetime(df['date'])
weekly_summary = df.story_point.resample('W', on='date').sum()

If need new column:

weekly_summary['weekly'] = df.story_point.resample('W', on='date').transform('sum')

Or create DatetimeIndex:

df['date'] = pd.to_datetime(df['date'])
df = df.set_index('date')
weekly_summary = df.story_point.resample('W').sum()

If need new column:

weekly_summary['weekly'] = df.story_point.resample('W').transform('sum')

3.4. mapapplyapplymaptransform用法

  • map: 针对Series
  • apply:   - 针对DataFramed的轴向做运算,也就是说对行或列做运算,不能对单个元素做运算。运算结果返回去重长度的Series。   - 针对Series的元素进行运算。
  • applymap: 针对DataFrame的元素做运算。
  • transform: 运算结果返回原长度的Series

3.4.1. map操作

  • Series的方法 计算每一种水果的平均价格
dic = {
    'item':['apple','banana','orange','banana','orange','apple'],
    'price':[4,3,3,2.5,4,2],
    'color':['red','yellow','yellow','green','green','green'],
    'weight':[12,20,50,30,20,44]
}

df = DataFrame(dic)
mean_price = df.groupby('item')['price'].mean().to_dict()
df['mean_price'] = df['item'].map(mean_price)

3.4.2. apply操作

  • DataFramed的方法,返回去重长度的Series
  • 作用:可以将DataFramed中的行或列数据进行某种形式的运算操作。
def func(s):
    s = s.sum()
    print(s)
df.apply(func)

3.4.3. transform操作

  • 返回原长度的Series
  • 如果要用自定义函数增加新列或对原有列赋值,要用transform
def my_mean(s):
    sum = 0
    for i in s:
        sum += i
    return sum / s.size
df.groupby('item')['price'].apply(my_mean)
## 结果:
# item 
# apple 3.00 
# banana 2.75 
# orange 3.50 
# Name: price, dtype: float64
df.groupby('item')['price'].transform(my_mean)
# 结果:
# 0    3.00
# 1    2.75
# 2    3.50
# 3    2.75
# 4    3.50
# 5    3.00
# Name: price, dtype: float64

3.4.3.1. 问题

是否可以计算出每种水果的平均价格,即: 下面的方法是生成一个新的dataframe,是否有方法可以直接在原dataframe上直接出结果?

df['gross'] = df['price'] * df['weight']
df2 = df.groupby('item').agg({'gross':sum,'weight':sum})
df2['total_mean_price'] = round(df2['gross']/df2['weight'],2)
df2

3.5. 映射索引

修改索引、列名。

df4 = DataFrame({'color':['white','gray','purple','blue','green'], 'value':np.random.randint(10,size=5)})
new_index = {0:'first',1:'two',2:'three',3:'four',4:'five'}
new_col = {'color':'cc','value':'vv'}
df4.rename(index = new_index, columns = new_col)

4. 数据连接

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)

  • objs:Series,DataFrame或Panel对象的序列或映射。如果传递了dict,则排序的键将用作keys参数,除非它被传递,在这种情况下将选择值(见下文)。任何None对象都将以静默方式删除,除非它们都是None,在这种情况下将引发ValueError。
  • axis :{0,1,...},默认为0.要连接的轴。
  • join:{'inner','outer'},默认为'outer'。如何处理其他轴上的索引。结合的外部和交叉的内部。
  • ignore_index:boolean,默认为False。如果为True,请不要在连接轴上使用索引值。生成的轴将标记为0,...,n - 1.如果要连接并置轴没有有意义的索引信息的对象,这将非常有用。请注意,在连接中仍然遵循其他轴上的索引值。
  • join_axes:索引对象列表。用于其他n - 1轴的特定索引,而不是执行内部/外部设置逻辑。
  • keys:序列,默认无。使用传递的键作为最外层来构造层次索引。如果传递了多个级别,则应包含元组。
  • levels:序列列表,默认无。用于构造MultiIndex的特定级别(唯一值)。否则,他们将从键中推断出来。
  • names:list,默认无。生成的分层索引中的级别的名称。
  • verify_integrity:boolean,默认为False。检查新的连锁轴是否包含重复项。相对于实际数据连接,这可能非常昂贵。
  • copy:boolean,默认为True。如果为False,则不要不必要地复制数据。
# First, add the platform and device to the user usage - use a left join this time.
result = pd.merge(user_usage,
                 user_device[['use_id''platform''device']],
                 on='use_id',
                 how='left')
# At this point, the platform and device columns are included
# in the result along with all columns from user_usage
# Now, based on the "device" column in result, match the "Model" column in devices.
devices.rename(columns={"Retail Branding""manufacturer"}, inplace=True)
result = pd.merge(result, 
                  devices[['manufacturer''Model']],
                  left_on='device',
                  right_on='Model',
                  how='left')

merge、join也可以用来合并,比较简单。

5. 数据聚合

5.1. pandas内置计算函数

print(data['item'].count())
print(data['duration'].max())
print(data['duration'][data['item']=='call'].sum())
print(data['month'].value_counts())
print(data['network'].nunique())

另有uniquenunique等函数。

5.2. numpy中的函数

np.ptp(arr,axis=0)

如果不用ptp,下面的写法就比较复杂了:

df_arr = pd.DataFrame(arr)
df_arr.loc[:,[0,1,2,3,4]].max() -df_arr.loc[:,[0,1,2,3,4]].min()

5.3. 聚合

data.groupby('month')['duration'].sum()

data[data['item']=='call'].groupby('network')['duration'].sum().sort_values(ascending=False)

data.groupby(['month','item'])['date'].count()

data.groupby('month',as_index=False).agg({'duration':['sum','count''max','min','mean']})

5.3.1. 输出格式

data.groupby('month')['duration'].sum() # produces Pandas Series

data.groupby('month')[['duration']].sum() # Produces Pandas DataFrame
不同的聚合选项
不同的聚合选项

5.3.2. 从 groupby 操作重命名分组统计信息

聚合字典语法非常灵活,可以在操作之前定义。还可以使用 lambda 函数内联定义函数,以提取内置选项未提供的统计信息。

from datetime import timedelta
aggregations = {
    'duration':'sum',
    'date': [lambda x: max(x).date(), lambda x: (max(x) - timedelta(days=1)).date()]
}
grp = data.groupby('month',as_index=False).agg(aggregations)
grp.columns = grp.columns.droplevel(level=0)
grp.rename(columns={'sum':'duration_sum'r'<lambda_0>':'date'r'<lambda_1>':'date-1'})

6. 数据透视

参考文章

知识点 筛选行不仅可以用loc,还可以用query:

df.query('Product==["CPU","Software"]')

6.1. 设置数据类型为类别

设置数据类型为类别的好处:比如查询单元格中是否有某个字符串,如果是str(object)类型,则需要对每一个单元格进行运算;如果是category类型,则不需要每个单元格运算,只需要对仅有的几个类型进行运算即可。对于较大数据,会明显提升速度。

df["Status"] = df["Status"].astype("category")
# 设置排序的顺序.如果不设置,可能按字母顺序。
df['Status'].cat.set_categories(["won","pending","presented","declined"],inplace=True)

6.2. 一般用法

table = pd.pivot_table(df,index=["Manager","Status"],columns=["Product"],values=["Quantity","Price"],
               aggfunc={"Quantity":len,"Price":[np.sum,np.mean]},fill_value=0)

6.3. 设置双index

pd.pivot_table(df,index=["Name","Account"])

pivot_table 的一个令人困惑的问题是使用列和值。请记住,

6.4. 有无columns参数的区别

pd.pivot_table(df,index=['Manager','Rep'],values=['Price'],aggfunc=['sum'],fill_value=0)

pd.pivot_table(df,index=['Manager','Rep'],values=['Price'],columns=['Product'],aggfunc=[np.sum],fill_value=0)

6.5. 将项目移动到索引获得不同的可视化效果:

pd.pivot_table(df,index=['Manager','Rep','Product'],values=['Price','Quantity'],aggfunc=[np.sum],fill_value=0)

6.6. margins=True可以实现看总数的需求。

pd.pivot_table(df,index=['Manager','Rep','Product'],values=['Price','Quantity'],aggfunc=[np.sum,np.mean],fill_value=0,margins=True)

6.7. set_categories的作用

Status就根据之前定义的顺序排列

pd.pivot_table(df,index=['Manager','Status'],values=['Price'],aggfunc=[np.sum],fill_value=0,margins=True)

6.8. unstack()和stack()可以让groupby(部分?)实现pivot_table的功能

## 以下两句代码效果一样
pd.pivot_table(contb,index=['contbr_occupation'],columns=['party'],aggfunc='sum',values=['contb_receipt_amt'])

contb.groupby(['contbr_occupation','party'])['contb_receipt_amt'].sum().unstack()

6.9. 一张图总结

pivot_table_datasheet
pivot_table_datasheet

7. 读取文件

读取文件比较简单,但是读取csv文件的有个小技巧:有些csv文件的分隔符为一个或多个空格、一个或多个制表符,此时sep参数要设置为sep='\s+'

columns = ['user_id','order_dt''order_products''order_amount']
df = pd.read_csv('CDNOW_master.txt', names=columns, sep='\s+')

8. 写入文件

  • pd.to_excel()对于dataframe数据的写入很方便,缺点是如果工作簿已经存在则会重置工作簿,即原工作簿的内容都会擦掉,而且不能(?)调格式。
    with pd.ExcelWriter(xlsname) as writer:
        df1.to_excel(writer, sheet_name='XXX',index=False)
        df2.to_excel(writer, sheet_name='YYY',index=False)
  • openpyxl。
    • 把dataframe数据用openpyxl写入excel优点是可以定向写入,不影响原内容(不设定其他参数的情况下,也不修改原单元格的格式,如字体字号加粗等),适合在已设定好格式的模板上指定位置填充数据。
    import openpyxl as op
    ontent_1 = '上海' + str(int(month)) + '月' + str(int(day)) + '日日报未直报机构汇总数(' + str(not_direct_report) + '家未直报,另有8280北德意志银行日报无数据)'
    file = 'filename'
    # 加载工作簿
    wb = op.load_workbook(file)
    # 选定工作表
    sh=wb["AAA"]
    # 对单个单元格填充内容,cell的三个参数分别是行号(1开始)、列号(1开始)、内容
    sh.cell(1,1,content_1)
  • 缺点是对于dataframe数据的操作不友好,需要用循环,暂时还没学到别的高效的方法。
    sh=wb["BBB"]
    ## 表头
    headlines = {1:'aa'2:'bb'3:'cc'4:'dd'5:str(int(month)) + '月' + str(int(day)) + '日余额'6:'ee'}
    for col,headline in headlines.items():
        sh.cell(1,col,headline)
    sh.row_dimensions[1].height = 43.2
    ## 数据内容
    for col in mx_not_direct_repo.columns:
        a = mx_not_direct_repo[col].tolist()
        for i in range(len(a)):
            sh.cell(i+2,j,a[i])
        j += 1

9. 数据清洗

9.1. 删除空值所在的行

  • isna只能判断某个元素是否为NaN
df.isna()
  • anyall 方法
df.drop(df.loc[df.isna().any(axis=1)].index,inplace=True,axis=0)
df.reset_index()

any 方法的 axis 参数为 1 ,表名对每一行的多列来说,最终形成一个字段 TrueFalse ,效果就是列减少。参见 [[#axis 的理解]] 。

  • 直接使用pandas封装好的dropna
df.dropna(inplace=True)

9.2. 空值填充

9.2.1. 近邻值进行填充

  • ffill 向前填充
  • bfill 向后填充
df.fillna(method='ffill',axis=0)

9.3. 删除重复行

df.loc[1] = [1,1,1,1,1,1]
df.loc[3] = [1,1,1,1,1,1]
df.loc[5] = [1,1,1,1,1,1]
df.loc[7] = [1,1,1,1,1,1]
df.drop_duplicates(keep='first',inplace=True)

9.4. 删除异常值所在的行

df = pd.DataFrame(np.random.random(size=(1000,3)),columns=['A','B','C'])
## 剔除大于2倍标准差的
df.drop(df.loc[~(df['C'] > (2 *df['C'].std()))].index,inplace=True,axis=0)

9.5. 替换

import pandas as pd
import numpy as np
from pandas import DataFrame,Series
df = DataFrame(np.random.randint(0,100,size=(8,7)))
## df.replace(to_replace=0, value='zero')
df.replace(to_replace={0:'zero',4:'four'})

9.5.1. 指定列替换

## 替换第4列的0
df.replace(to_replace={4:0},value=666)
df.columns = ['zero','one','two','three','four','five','six']
# 下面两种方式效果一样
df.replace(to_replace={'four':0},value=777)
# df.replace(to_replace={'four':{0:777}})

可否对指定行替换?

df.loc[3][df.loc[3] == 18] = 200
df
"""
是否还有别的方法?
"""

9.5.2. map替换

mapSeris的一个方法。 map字典可以进行映射操作。

dic_data = {
    'name':['张三','李四','王老五'],
    'salary':[22222,7777,11111]
}
df = DataFrame(dic_data)
dic_map = {
    '张三':'tom',
    '李四':'jay',
    '王老五':'jerry'
}
df['e_name'] = df['name'].map(dic_map)
df

9.5.3. 几种替换方法比较:mapreplacenp.select

  • map : 将列里面的所有的数据进行替换;如果不存在相关键值,则赋值NaN
  • replace : 替换其中一部分
  • np.select : 可以替换,需设定好default值。

map 也可以用别的方式来达到替换某些索引行的目的,即传入函数,而不是字典。这种方法可以替换 np.select

dic_map = {
    '张三':'tom',
    '李四':'jay',
}
# dict.get(a,b),如果dict中存在键a,则返回其对应的值,否则返回b。
f = lambda x : dic_map.get(x,x)
df['name'] = df['name'].map(f)
df

替换行列名,可以用rename。参考[[#映射索引]]节。

map函数可以做运算工具:

# 超过3000的部分缴纳50%的税,计算税后工资
df['net_pay'] = df['salary'].map(lambda x: (x - 3000) * 0.5 + 3000)
df

运算工具主要有mapapplyapplymap ,用法参考[[#map 、 apply 、 applymap 用法]]。

9.6. 随机抽样

9.6.1. 排序实现随机抽样:将数据打乱之后用切片

  • take
  • permutation
"""
take的第一个参数只能用隐式索引,而不能用显式索引,因为这个列表一般是要自动生成的,而不是让用户自己写列名等操作。
"""

df = DataFrame(data=np.random.randint(0,100,size=(100,3)),columns=['A','B','C'])
## take的用法
df.take([2,0,1,4],axis=0)

## take更一般的用法:自动生成,将行和列均打散
df.take(np.random.permutation(3),axis=1).take(np.random.permutation(100),axis=0)[:10]

分类:

后端

标签:

后端

作者介绍

f
figo
V1