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([0, 1])
df.drop(index=[0, 1])

注意第一个参数为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.where或np.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.where和np.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的 DataFrame 和 Series ，可以用 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.where和np.select再解释

df['hasimage'] = np.where(df['photos']!= '[]', True, False)

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. map、apply、applymap、transform用法

• 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())

另有unique、nunique等函数。

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. 一张图总结

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()

• any 和 all 方法

df.drop(df.loc[df.isna().any(axis=1)].index,inplace=True,axis=0)
df.reset_index()

any 方法的 axis 参数为 1 ，表名对每一行的多列来说，最终形成一个字段 True 或 False ，效果就是列减少。参见 [[#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替换

map是Seris的一个方法。 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. 几种替换方法比较：map、replace、np.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

运算工具主要有map、apply、applymap ，用法参考[[#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]