pandas面试基础

阅读路线：

• 准备工作
• 生成对象
• 索引
• 选择需要的数据
• 运算
• 合并（merge）
• 分组（grouping）
• 重塑（reshaping）
• 数据透视表（pivot tables）
• pandas DataFrame里的操作

一、准备工作

import numpy as np
import pandas as pd

在进行下面的题目操作时，一定要先导入上面的两个数据分析包pandas、numpy

二、生成对象

1、如何用Python的列表创建一个series

s = pd.Series([1, 3, 5, np.nan, 6, 8])

输出：

series是一个一维的标记数组，可以容纳任何数据类型（整数、字符串、浮点数、Python对象等）。必须记住，与Python列表不同，一个series总是包含相同类型的数据。

2.如何使用列表创建一个DataFrame

#导入pandas
import pandas as pd

#字符串列表
lst = ["Gamer47", "Shox", "Simple"]

#在列表中调用DataFrame构造函数
df = pd.DataFrame(lst)

输出：

3.如何使用Series字典对象生成DataFrame

df2 = pd.DataFrame({'A': 1.,
                    'B': pd.Timestamp('20130102'),
                    'C': pd.Series(1, index = list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype = 'int32'),
                    'E': pd.Categorical(["test", "train", "test", "train"]),
                    'F': 'foo'})

输出：

4.如何在pandas中创建一个空的DataFrame

要创建一个完全空的pandas dataframe，我们使用以下操作：

import pandas as pd
df = pd.DataFrame()

输出：

三、查看数据：

已知有这样的数据，如何进行查看

dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index = dates, columns = list('ABCD'))

输出：

1.如何查看头部数据

2.如何查看尾部数据

3.如何快速查看数据的统计摘要

4.如何查询索引和列名

四、索引

1.简述Pandas Index

在pandas中建立索引意味着简单地从DataFrame中选择特定地数据行和列。
pandas支持四种类型的多轴索引，它们是：

• DataFrame.[ ]：此函数称为索引运算符
• DataFrame.loc[ ]：此函数用于标签
• DataFrame.iloc[ ]：此函数用于基于位置或整数的
• DataFrame.ix[ ]：此函数用于基于标签和整数的

它们统称为索引器。这些是迄今为止索引数据最常见的方法。这四个函数有助于从DataFrame获取元素、行和列。

2.Pandas定义重新索引（reindexing）

重新索引会更改DataFrame的行标签和列标签。重新索引意味着使数据符合特定轴上给定的一组标签。
多个操作可以通过像这样的索引来完成：

• 重新排列现有数据以匹配一组新的标签。
• 在不存在标签数据的标签位置插入缺失值（NA）标记。

import pandas as pd
import numpy as np
N = 20
df = pd.DataFrame({
    'A': pd.date_range(start='2016-01-01', periods = N, freq = 'D'),
    'x': np.linspace(0, stop=N-1, num=N),
    'y': np.random.rand(N),
    'C': np.random.choice(['Low', 'Medium', 'High']),
    'D': np.random.normal(100, 10, size=(N)).tolist()
})

df_reindexed = df.reindex(index=[0, 2, 5], columns=['A', 'C', 'B'])
print(df_reindexed)

输出：

3.如何设置索引

panda set_index()是一种将列表、序列或dataframe设置为dataframe索引的方法。
语法：
DataFrame.set_index(keys, inplace=False)
参数：

• keys：列标签或列标签/数组列表，需要设置为索引的列
• inplace：默认为False，适当修改DataFrame（不需要创建新对象）

改变索引列
在本例中，名称列被用作DataFrame的索引列

import pandas as pd

#读取csv文本文件到DataFrame变量中
data = pd.read_csv("employees.csv")
data.set_index("first_name", inplace=True)

#观察数据
data.head()

输出：
如输出图像所示，以前索引列是一系列数字

改变索引列后，索引列是给定的索引列

4.如何重置索引

Pandas Series.reset_index()
函数的作用是：生成一个新的DataFrame或带有重置索引的Series。

例1：使用Series.reset_index()函数重置给定Series对象的索引

#导入pandas包
import pandas as pd 

#创建Series
sr = pd.Series([10, 25, 3, 11, 24, 6])
#创建索引
index_ = ['Coca Cola', 'Sprite', 'Coke', 'Fanta', 'Dew', 'ThumbsUp']
#设置索引
sr.index = index_
#打印series
print(sr)

输出：

现在，我们将使用Series.reset_index()函数来重置给定的series对象的索引

#重置索引
result = sr.reset_index()
#打印
print(result)

输出：

从输出中可以看到，该Series.reset_index()函数已将给定Series对象的索引重置为默认值。它保留了索引，并将其转换为列。

五、选择需要的数据

1.获取数据

1.1先创建数据

dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))

1.2选择单列，产生Series

1.3用[ ]切片行：

2.按标签选择

2.1用标签提取一行数据：

2.2用标签选择多列数据：

2.3用标签切片，包含行与列结束点：

2.4返回对象降维：

2.5提取标量值：

2.6快速访问标量，与上述方法等效：

3.按位置选择

3.1用整数位置选择：

3.2 类似NumPy/Python，用整数切片：

3.3 类似NumPy/Python，用整数列表按位置切片：

3.4 显示整行切片：

3.5 显示整列切片：

3.6 显示提取值：

3.7 快速访问标量，与上诉方法等效：

4.布尔索引

4.1用单列的值选择数据：

4.2 选择DataFrame里满足条件的值：

4.3 用isin()筛选：

5.赋值

5.1用索引自动对齐新增列的数据：

5.2 按标签赋值：

5.3 按位置赋值：

5.4 按NumPy数组赋值

5.5 上述赋值结果

5.6 用where条件赋值：

六、运算

1.如何得到一个数列的最小值、第25百分位、中值、第75位和最大值

import pandas as pd
import numpy as np
from numpy import percentile

p = pd.Series(np.random.normal(14, 6, 22))
state = np.random.RandomState(120)
p = pd.Series(state.normal(14, 6, 22))
print(percentile(p, q=[0, 25, 50, 75, 100]))

输出：

2.如何获得panda DataFrame中一个列的平均值

Pandas dataframe.mean(axis=None)函数返回所请求（axis = 0代表对列进行求平均值，axis=1代表对行进行求平均值）的值的平均值。
示例：使用mean()函数查找索引轴上所有观测值的平均值

import pandas as pd
df = pd.DataFrame({
    "A": [12, 4, 5, 44, 1],
    "B": [5, 2, 54, 3, 2],
    "C": [20, 16, 7, 3, 8],
    "D": [14, 3, 17, 2, 6]
})
df

输出：

让我们使用dataframe.mean()函数来查找索引轴上的平均值。

3.如何将函数应用到DataFrame中的每个数据元素

可以使用apply()函数以便将函数应用于给定dataframe中的每一行。让我们来看看我们完成这项任务的方式。
实例：

import pandas as pd

def add(a, b, c):
    return a + b + c

def main():
    
    data = {
        'A': [1, 2, 3],
        'B': [4, 5, 6],
        'C': [7, 8, 9]
    }
    
    df = pd.DataFrame(data)
    print("Original DataFrame:\n", df)
    
    df['add'] = df.apply(lambda row: add(row['A'], row['B'], row['C']), axis = 1)
    print('\nAfter Applying Function:')
    print(df)

if __name__ == '__main__':
    main()

输出：

4.如何在panda中获得一个DataFrame的行数和列数

import numpy as np

raw_data = {'name': ['Willard Morris', 'Al Jennings', 'Omar Mullins', 'Spencer McDaniel'],
            'age': [20, 19, 22, 21],
            'favorite_color': ['blue', 'red', 'yellow', 'green'],
            'grade': [88, 92, 95, 70]}
df = pd.DataFrame(raw_data, columns=['name', 'age', 'favorite_color', 'grade'])

输出：

获取df的行和列计数

df.shape

输出：

5.如何在panda DataFrame中获得列值的总和

Pandas dataframe.sum()函数返回所请求轴的值的和
语法： DataFrame.sum(axis=None,skipna=None)
参数：

• axis：{index(0),columns(1)},axis=0代表对列进行求和，axis=1代表对行进行求和
• skipna：计算结果时排除NA /空值

**示例1：**使用sum()函数查找索引轴上所有值的总和

#导入数据
import pandas as pd
df = pd.read_csv("NBAPlayers.txt", delimiter="\t")

现在求出沿索引轴的所有值的和。我们将跳过计算和时的NaN值。

#查找索引轴的和，默认情况下，轴设置为0
df.sum(axis = 0, skipna = True)

七、合并

1.append合并

如何将新行追加到pandas DataFrame
Pandas dataframe.append() 函数的作用是：将其他dataframe的行追加到给定的dataframe的末尾，返回一个新的dataframe对象。

语法： DataFrame.append(ignore_index=False)
参数：

• ignore_index：如果为真，就不要使用索引标签

示例1: 创建两个数据框，然后将第二个附加到第一个。

import pandas as pd
#使用dictionary创建第一个DataFrame
df1 = pd.DataFrame({
    "a":[1, 2, 3, 4],
    "b":[5, 6, 7, 8]
})
#使用dictionary创建第二个DataFrame
df2 = pd.DataFrame({
    "a": [1, 2, 3],
    "b": [5, 6, 7]
})

现在将df2附加到df1的末尾

df1.append(df2)

输出：

请注意，第二个DataFrame的索引值保留在附加的DataFrame中。如果我们不希望发生这种情况，则可以设置ignore_index = True

df.append(df2, ignore_index = True)

输出：

2.merge合并

2.1数据库风格的DataFrame连接

pandas.merge根据一个键或多个键将行进行连接。对于SQL或其他关系型数据库的用户来说，这种方式是比较熟悉的，它实现的是数据库的连接操作。

df1 = pd.DataFrame({
    'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
    'data1': range(7)
}) 

df2 = pd.DataFrame({
    'key': ['a', 'b', 'd'],
    'data2': range(3)
})

pd.merge(df1, df2)

输出：

请注意，我并没有指定在哪一列上进行连接。如果连接的键信息没有指定，merge会自动将重叠列名作为连接的键。但是，显示地指定连接键才是最好的实现：

如果每个对象的列名是不同的，你可以分别为它们指定列名：

df3 = pd.DataFrame({
    'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
    'data1': range(7)
})

df4 = pd.DataFrame({
    'rkey': ['a', 'b', 'd'],
    'data2': range(3)
})

pd.merge(df3, df4, left_on='lkey', right_on='rkey')

输出：

默认情况下，merge做的是内连接（“inner” join），结果中的键是两张表的交集。
其他可选的选项有’left’、“right”和“outer”。外连接（outer join）是键的并集，联合了左连接和右连接的效果：

尽管不是很直观，但多对多的合并有明确的行为。下面是一个例子：

df1 = pd.DataFrame({
    'key': ['b', 'b', 'a', 'c', 'a', 'b'],
    'data1': range(6)
})

df2 = pd.DataFrame({
    'key': ['a', 'b', 'a', 'b', 'd'],
    'data2': range(5)
})

pd.merge(df1, df2, on='key', how='left')

输出：

多对多连接时行的笛卡尔积。由于左边的DataFrame中有三个‘b’行，而在右边有两行，因此在结果中有六个’b’ 行。连接方法仅影响结果中显示的不同键值：

使用多个键进行合并时，传入一个列名的列表：

left = pd.DataFrame({
    'key1': ['foo', 'foo', 'bar'],
    'key2': ['one', 'two', 'one'],
    'lval': [1, 2, 3]
})

right = pd.DataFrame({
    'key1': ['foo', 'foo', 'bar', 'bar'],
    'key2': ['one', 'one', 'one', 'two'],
    'rval': [4, 5, 6, 7]
})

pd.merge(left, right, on=['key1', 'key2'], how='outer')

输出：

决定哪些键联合出现在结果中，取决于合并方法的选择，把多个键看作一个元组数据来作为单个连接键使用（尽管实际上并不是以这种方法来实现的）。

合并操作中最后一个要考虑的问题时如何处理重叠的列名。虽然你可以手动解决重叠问题，但是merge有一个suffixes后缀选项，用于左右两边DataFrame对象的重叠列名后指定需要添加的字符串：

2.2 根据索引合并

在某些情况下，DataFrame中用于合并的键是它的索引。在这种情况下，你可以传递left_index=True或right_index=True（或者都传）来表示索引需要用来作为合并的键：

left1 = pd.DataFrame({
    'key': ['a', 'b', 'a', 'a', 'b', 'c'],
    'value': range(6)
})

right1 = pd.DataFrame({
    'group_val': [3.5, 7]},
    index=['a', 'b']
)

pd.merge(left1, right1, left_on='key', right_index=True)

输出:

由于默认的合并方法是连接键相交，你可以使用外连接来进行合并：

在多层索引数据的情况下，事情会更复杂，在索引上连接时一个隐式的多键合并：

lefth = pd.DataFrame({
    'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
    'key2': [2000, 2001, 2002, 2001, 2002],
    'data': np.arange(5.)
})

righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
                      index=[['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'],
                             [2001, 2000, 2000, 2000, 2001, 2002]],
                      columns=['event1', 'event2'])

pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)

这种情况下，你必须以列表的方式指明合并所需多个列（请注意使用how = ‘outer’处理重复的索引值）：


使用两边的索引进行合并也是可以的：

left2 = pd.DataFrame([[1., 2.,], [3., 4.,], [5., 6.]],
                     index=['a', 'c', 'e'],
                     columns=['Ohio', 'Nevada'])

right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13., 14.]],
                      index=['b', 'c', 'd', 'e'],
                      columns=['Missouri', 'Alabama'])

pd.merge(left2, right2, how='outer', left_index=True, right_index=True)

DataFrame有一个方便的join示例方法，用于按照索引合并。该方法也可以用于合并多个索引相同或相似但没有重叠列的DataFrame对象。在之前的例子中，我们可以这样写：

由于一些历史原因（例如，一些非常早期版本的pandas），DataFrame的join方法进行连接键上的左连接，完全保留左边DataFrame的行索引。它还支持在调用DataFrame的某一列上连接传递的DataFrame的索引：

最后对于一些简单索引-索引合并，你可以向join方法传入一个DataFrame列表，这个方法可以替代下一节将要介绍的使用更为通用的concat函数的方法：

2.3 沿轴向连接

另一种数据组合操作可互换地称为拼接、绑定或堆叠。NumPy的concatenate函数可以在NumPy数组上实现该功能：

在Series和DataFrame等pandas对象的上下文中，使用标记的轴可以进一步泛化数组连接。尤其是你还有许多需要考虑的事情：

• 如果对象在其他轴上的索引不同，我们是否应该将不同的元素组合在这些轴上，还是只使用共享的值（交集）？
• 连接的数据块是否需要在结果对象中被识别？
• “连接轴”是否包含需要保存的数据？在许多情况下，DataFrame中的默认整数标签在连接期间最好丢弃。

pandas的concat函数提供了一种一致性的方式来解决以上问题。我将给出一些例子来表明它的工作机制。假设我们有三个索引不存在重叠的Series：

用列表中的这些对象调用concat方法会将值和索引粘在一起：

默认情况下，concat方法是沿着axis=0的轴向生效的，生成另一个Series。如果你传递axis=1，返回的结果则是一个DataFrame（axis=1时是列）：

在这个案例中另一个轴向上并没有重叠，你可以看到排序后的索引合集（’outer‘ join 外连接）。你也可以传入join=’inner’：

你甚至可以使用join_axes来指定用于连接其他轴向的轴：

拼接在一起的各部分无法在结果中区分是一个潜在的问题。假设你想在连接轴向上创建一个多层索引，可以使用keys参数来实现：


沿着轴向axis=1连接Series的时候，keys则成为DataFrame的列头：

将相同的逻辑拓展到DataFrame对象：

如果你传递的是对象的字典而不是列表的话，则字典的键会用于keys选项：

还有一些额外的参数负责多层索引生成。例如，我们可以使用names参数命名生成的轴层级：

最后需要考虑的是行索引中不包括任何相关数据的DataFrame：

在这个示例中，我们传入ignore_index=True：

2.4 联合重叠数据

还有另一个数据联合场景，既不是合并操作，也不是连接操作。你可能有两个数据集，这两个数据集的索引全部或部分重叠。作为一个示例，考虑NumPy的where函数，这个函数可以进行面向数组的if-else等价操作：

Series有一个combine_first方法，该方法可以等价于下面这种使用pandas常见数据对齐逻辑的轴向操作：

在DataFrame中，combine_first逐列做相同的操作，因此你可以认为它是根据你传入的对象来“修补"调用对象的缺失值：

八、分组（Grouping）

“group by” 指的是涵盖下列一项或多项步骤的处理流程：

• 分割：按条件把数据分割成多组；
• 应用：为每组单独应用函数；
• 组合：将处理结果组合成一个数据结构。

df = pd.DataFrame({
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': np.random.randn(8),
    'D': np.random.randn(8)
})

输出：

1.先分组，再用sum() 函数计算每组的汇总数据：

df.groupby('A').sum()

输出：

2.多列分组后，生成多层索引，也可以应用sum函数：

df.groupby(['A', 'B']).sum()

输出：

九、重塑（Reshaping）

如何将numpy数组转换为给定形状的DataFrame？

import pandas as pd 
import numpy as np
p = pd.Series(np.random.randint(1, 7, 8))

输出：

将Series p重新组合成一个2行4列的dataframe

info = pd.DataFrame(p.values.reshape(2,4))

输出：

十、数据透视表

透视表是一种可以对数据动态排布并且分类汇总的表格格式，在pandas中它被称作pivot_table。
pivot_table(data, values=None, index=None, columns=None)
参数：

• index：就是层次字段，要通过透视表获取什么信息就按照相应的顺序设置字段
• values：可以对需要的计算数据进行筛选
• columns：类似index可以设置列层次字段，它不是一个必要参数，作为一种分割数据的可选方式。

import pandas as pd 
import numpy as np
df = pd.DataFrame({
    'A': ['one', 'one', 'two', 'three'] * 3,
    'B': ['A', 'B', 'C'] * 4,
    'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] *2,
    'D': np.random.randn(12),
    'E': np.random.randn(12)
})

输出：

用上述数据生成数据透视表非常简单：

pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])

结果：

十一、panda DataFrame里的操作

1.如何将列添加到pandas DataFrame？

源数据：

#导入pandas
import pandas as pd 
#定义一个包含学生数据的字典
data = {'Name': ['Jai', 'Princi', 'Gaurav', 'Anuj'],
        'Height': [5.1, 6.2, 5.1, 5.2],
        'Qualification': ['Msc', 'Ma', 'Msc', 'Msc']}
#将字典转换成DataFrame
df = pd.DataFrame(data)

输出：

添加列：

#声明要转换为列的列表
address = ['Delhi', 'Bangalore', 'Chennai', 'Patna']
#使用”address“作为列名
df['address'] = address
#观察结果
df

输出：

2.如何向panda DataFrame添加索引、行或列？

向DataFrame添加索引
如果您创建了一个DataFrame，pandas允许将输入添加到索引参数中。它将确保您拥有所需的索引。否则，在默认情况下，DataFrame包含一个数值索引，该索引从0开始，在DataFrame的最后一行结束。

向DataFrame添加行、列
我们可以使用.loc、iloc和ix将行、列插入到DataFrame中。

添加具有特定索引名的行：

import pandas as pd 
employees = pd.DataFrame(data={'Name': ['John Doe', 'William Spark'],
                               'Occupation': ['Chemist', 'Statistician'],
                               'Date Of Join': ['2018-01-25', '2018-01-26'],
                               'Age': [23, 24]},
                         index=['Emp001', 'Emp002'],
                         columns=['Name', 'Occupation', 'Date Of Join', 'Age'])
print("\n----------------- BEFORE -------------------\n")
print(employees)
employees.loc['Emp003'] = ['Sunny', 'Programmer', '2018-01-25', 45]
print("\n----------------- AFTER -------------------\n")
print(employees)

输出：

3.如何在panda DataFrame上进行迭代？

您可以通过结合使用for循环和对DataFrame的iterrows()调用来遍历DataFrame的行。

import pandas as pd 
import numpy as np

df = pd.DataFrame([{'c1': 10, 'c2': 100}, {'c1': 11, 'c2': 110}, {'c1': 12, 'c2': 120}])
for index, row in df.iterrows():
    print(row['c1'], row['c2'])
df

输出：

4.我们如何排序DataFrame？

我们可以通过以下几种有效地在DataFrame中执行排序：

• 按标签
• 按实际值

（1）可以使用sort_index()方法对数据dataframe进行排序。可以通过传递axis参数和排序顺序来实现。默认情况下，按升序对行标签进行排序。

import numpy as np
import pandas as pd

unsorted_df = pd.DataFrame(np.random.randn(10, 2), index=[1, 4, 6, 2, 3, 5, 9, 8, 0, 7],
                           columns=['col2', 'col1'])

sorted_df = unsorted_df.sort_index()
print(sorted_df)

输出：

排序顺序
通过将布尔值传递给升序参数，可以控制排序的顺序。让我们考虑下面的例子来理解这个问题

import pandas as pd 
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10, 2), index=[1, 4, 6, 2, 3, 5, 9, 8, 0, 7],
                           columns=['col2', 'col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print(sorted_df)

输出：

对列进行排序
通过传递值1的axis参数，可以对列标签进行排序，让我们考虑下面的例子来理解这个问题。

import pandas as pd 
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10, 2), index=[1, 4, 6, 2, 3, 5, 9, 8, 0, 7],
                           columns=['col2', 'col1'])
sorted_df = unsorted_df.sort_index(axis=1)
print(sorted_df)

输出：

（2）按照实际值
DataFrame.sort_values(by,axis=0,ascending=True,inplace=False)
sort_values提供了一个功能，我们可以在其中指定要排序的值的DataFrame列名。他是通过传递“by”参数来完成的。
参数解析：

• axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照索引排序，即纵向排序，如果为1，则是横向排序。
• by：如果axis=0，那么by=“列名”；如果axis=1，那么by=“行名”；
• ascending：布尔型，True则升序，可以是[True,False]，即第一字段升序，第二个降序。
• inplace：布尔型，是否排序后的数据框替换现有的数据框

import numpy as np
import pandas as pd 
from pandas import DataFrame

data = [['a', 2, 301], ['b', 1, 201], ['c', 2, 201], ['d', 1, 301], ['e', 2, 301]]
df = pd.DataFrame(data, columns=['A', 'B', 'C'])

查看源数据

df.sort_values(by=['C', 'B'], ascending=[False, True], inplace=True)

输出：

按某一行进行排序

data_1 = [[300, 2, 301], [2, 1, 201], [3, 300, 201], [100, 1, 301], [500, 2, 301]]
df_1 = pd.DataFrame(data_1, columns=['A', 'B', 'C'])

输出：

df_1.sort_values(by=0, axis=1, inplace=True)

输出：

7.如何删除panda DataFrame中的行?

import pandas as pd 

data = {'name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
        'year': [2012, 2013, 2013, 2014, 2014],
        'reports': [4, 24, 31, 2, 3]}
df = pd.DataFrame(data, index=['Cochice', 'Pima', 'Santa Cruz', 'Maricopa', 'Yuma'])
df

输出：

删除行

df.drop(['Cochice', 'Pima'])

输出：

8.如何删除panda DataFrame中的列？

创建源数据

test_dict = {'id':[1, 2, 3, 4, 5, 6],
             'name': ['Alice', 'Bob', 'Cindy', 'Eric', 'Helen', 'Grace'],
             'math': [90, 89, 99, 78, 97, 93],
             'english': [89, 94, 80, 94, 94, 90]}
#直接写入参数test_dict
test_dict_df = pd.DataFrame(test_dict)
#字典型赋值
test_dict_df = pd.DataFrame(data=test_dict)

输出：

删除列
删除列，我们使用drop()函数，则要增加参数axis=1

test_dict_df.drop(['id'], axis=1)

输出：