一、废话不多说，直接开讲

1、DataFrame的索引和切片

1.1 选择列

        当想要获取 df 中某列数据时，只需要在 df 后面的方括号中指明要选择的列即可。如果是 一列，则只需要传入一个列名;如果是同时选择多列，则传入多个列名即可（注意：多个列名 用一个 list 存放）

#获取一列
df[col]
#获取多列
df[[col1 , col2]]

df.iloc[,[0,2]]

1.2 按行列索引选择

        DataFrame对象按照行列检索获取，可以使用loc和iloc函数，方括号中逗号之前的部分表示要获取的行的索引，如果输入一个冒号，或不输入任何数值表示获取所有的行或列，逗号之后方括号表示要获取的列的索引。

df.loc[普通行索引,普通列索引]
df.iloc[位置行索引,位置列索引]

1.3 loc与iloc获取

看实例：

import numpy as np
import pandas as pd
data=pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'),columns=list('ABCD'))
#获取行为'b'的行
data.loc['b']
#使用iloc获取，行为'b'的行，行号为1
data.iloc[1]

其中首先用np生成一个一维数组，用reshape将其转变成3行4列的二维数组，在通过DsteFrame将其装换成类似于二维数组的列表，并更改行索引名为a、b、c，列索引为A、B、C、D，再将这段数组用date来接收，用loc来索引名为b的行，用iloc来索引数值为1的索引行，其打印结果相同，如下 ：

• 获取'A'列所有行

data.loc[:,'A']
data.iloc[:,0]

逗号左右分别表示行和列，两行代码运行结果都一样

• 获取部分行部分列：

#获取a bc行，A B列
data.loc[['a','b','c'],['A','B']]
data.iloc[[0,1,2],[0,1]]

        上部分为获取行号为a，b，c，列号为A,B的结果，以及行索引值为0，1，2，列索引值为0,1的所对应的值 ，其所对应结果都一样

• 获取满足条件的行：

df[df[“支出”]>10]
df[(df[“支出”]>10) & (df[“性别”]=='女')]

df[“支出”]>10为列‘支出’这一列中所对应的数值大于10的行，其返回的是布尔值，再用df将这个布尔值括起来即表示将布尔值为True的行打印出来

(df[“支出”]>10) & (df[“性别”]=='女') 这段则表示同时满足支出大于10，性别等于女的行。

2、isin()选择

        • df.isin(values) 返回结果为相应的位置是否匹配给出的 values

        • values 为序列时：对应每个具体值

        •​​​​​​​ values 为字典时：对应各个变量名称

df.col.isin([1,3,5])
df[ df.col.isin([1,3,5])]
df[ df.col.isin(['val1','val2'])]
df[ df.index.isin(['val1','val2'])]

df 是一个DataFrame对象。

col 是DataFrame中的一列（Series）。

.isin([1,3,5]) 是一个方法，用于判断col 中的元素是否包含在 [1,3,5] 这个列表中。

3、query()的使用

 使用boolean值表达式进行筛选

df.query( expr：语句表达式 inplace=False;是否直接替换原数据框 )

可以使用前缀“@”引用环境变量等号为==，而不是=  

expr是一个字符串，表示查询条件。查询条件可以使用DataFrame中的列名，并使用关系运算符和逻辑运算符进行比较和组合。

import pandas as pd# 创建一个示例DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [6, 7, 8, 9, 10],'C': [11, 12, 13, 14, 15]}
df = pd.DataFrame(data)# 使用query函数进行查询
result = df.query('A > 2')  # 查询A列大于2的行
print(result)result = df.query('A > 2 and B < 9')  # 查询A列大于2且B列小于9的行
print(result)

4、排序

4.1 按照索引进行排序

具体用法如下：

df.sort_index(level :（多重索引时）指定用于排序的级别顺序号/名称18ascending = True :是否为升序排列，多列时以表形式提供inplace = False :na_position = 'last‘ :缺失值的排列顺序，first/last
)df.sort_index(axis=0, ascending=True, inplace=False)

axis 参数表示排序的轴方向，可以是 0 或 1，默认值是 0，表示按行索引进行排序。

ascending 参数表示排序的顺序，可以是 True 或 False，默认值是 True，表示升序排序。

inplace 参数表示是否在原地进行排序，可以是 True 或 False，默认值是 False，表示返回一个排序后的副本，原数据不变。

import pandas as pd# 创建一个示例 DataFrame
data = {'A': [2, 1, 3],'B': [5, 3, 1]}
df = pd.DataFrame(data, index=[2, 1, 3])# 按行索引进行升序排序
result = df.sort_index()
print(result)# 按列索引进行降序排序
result = df.sort_index(axis=1, ascending=False)
print(result)

在示例中，创建了一个 DataFrame，并使用 sort_index() 方法按行索引进行升序排序和按列索引进行降序排序。其打印结果为

        ​​​​​​​        ​​​​​​​        ​​​​​​​        

4.2按照变量值排序

用于按照指定列的值进行排序，语法如下：

df.sort_values（by :指定用于排序的变量名，多列时以列表形式提供ascending = True :是否为升序排列inplace = False :na_position = 'last‘ :缺失值的排列顺序，first/last
）
df.sort_values(by, axis=0, ascending=True, inplace=False)

其中by参数表示排序的依据列，可以是列标签（字符串）或列标签列表（字符串列表）

import pandas as pd# 创建一个示例 DataFrame
data = {'A': [2, 1, 3],'B': [5, 3, 1]}
df = pd.DataFrame(data)# 按照列 'A' 的值进行升序排序
result = df.sort_values(by='A')
print(result)# 按照列 'B' 和 'A' 的值进行降序排序
result = df.sort_values(by=['B', 'A'], ascending=[False, False])
print(result)

5、计算新变量

5.1 新变量为常数

df['vamame'] = value#用于向DataFrame中添加新列或修改现有列的操作。

import pandas as pd# 创建一个示例 DataFrame
data = {'A': [1, 2, 3],'B': [4, 5, 6]}
df = pd.DataFrame(data)# 添加新列 'C'，并赋予新的值
df['C'] = [7, 8, 9]
print(df)# 修改列 'A' 的值
df['A'] = [10, 11, 12]
print(df)

5.2 基于原变量做简单四则运算

df['var'] = df['oldvar'] *100
df['var'] = df.oldvar * 100

        这两个语句都是用来创建一个新的列 'var'，并将 'oldvar' 列中的值乘以100赋给 'var' 列。

        第一个语句 df['var'] = df['oldvar'] * 100 使用了方括号将列名 'var' 和 'oldvar' 包裹起来，表示访问和操作 DataFrame 中的列。

        第二个语句 df['var'] = df.oldvar * 100 使用了点运算符，将 DataFrame 中的 'oldvar' 列作为一个属性进行访问。

        两个语句效果相同，都是将 'oldvar' 列中的每个值乘以100，然后赋给 'var' 列。

 df ['new_val'] = df .总分 + df .名次 + 1

# 使用内部函数计算
import math
df['n3'] = math.sqrt(9)
df['n4'] = math.sqrt(df.体重)  #报错
import numpy
df['n4'] = numpy.sqrt(df.体重)

• df['n3'] = math.sqrt(9)，这行代码将 math.sqrt(9) 的结果（即3）赋给了新的列 'n3'。因为求根号9的结果是3。

• df['n4'] = math.sqrt(df.体重)，这行代码试图计算 DataFrame 列 '体重' 中每个值的平方根，并将结果赋给新的列 'n4'。但是这行代码会报错，因为 math.sqrt() 函数不支持作用于整个 DataFrame 列，只能逐个计算单个值的平方根。

• df['n4'] = numpy.sqrt(df.体重)，这行代码使用了 numpy.sqrt() 函数。numpy.sqrt() 函数支持对整个 DataFrame 列进行计算，所以可以成功求出 '体重' 列每个值的平方根，并将结果赋给新的列 'n4'。

5.3 基于一个原变量做函数运算

df.apply(
func : 希望对行/列执行的函数表达式
axis = 0 : 针对行还是列逬行计算
'index': 针对每列进行计算
'columns': 针对每行逬行计算
)

简化的用法:

df [' varname ' ] = df. oldvar. apply （函数表达式）

df['n5'] = df.体重.apply(math.sqrt)
df['n7'] = df.体重.apply(numpy.sqrt)

# 使用自定义函数
def get_first(tmp):return tmp[:1]
df['n6'] = df.开设.apply(get_first)

5.4 不修改原df,而是生成新的df

用法如下：

df.assign(varname = expression)

# 返回新的dataframe
df2 = df.assign(n8 = df.课程.apply(get_first))

5.5 在指定位置插入新变量列

df.insert(loc :插入位置的索引值，0 <= loc <= len (columns)column :插入的新列名称value : Series 或者类数组结构的变量值allow_duplicates = False :是否允许新列重名
)#该方法会直接修改原 df

# 指定位置增加新列
df.insert(1,'new_col',100)#插入位置索引值为1，插入名称为new_col,插入变量值为100
df.insert(1,'new_col2',df.课程.apply(get_first))

其中

• df.insert(1,'new_col',100)：这行代码在索引位置1之前插入了一个名为 'new_col' 的新列，并将所有的值初始化为 100。这意味着新列将位于原始 DataFrame 的第二列位置。

• df.insert(1,'new_col2',df.课程.apply(get_first))：这行代码在索引位置1之前插入了一个名为 'new_col2' 的新列，并使用 df.课程.apply(get_first) 来为新列赋值。df.课程 是一个 Series 或 DataFrame 列，apply() 函数将 get_first 函数应用于每个元素，并返回一个新的 Series 或 DataFrame 列。因此，新列 'new_col2' 的值将根据 get_first 函数的结果进行赋值。请注意，get_first 是一个自定义的函数，它的具体实现需要根据具体的需求来编写。