Pandas实战-DataFrame对象
本文将主要介绍以下内容：
1. DataFrame概述
2. Series和DataFrame的相似点
3. DataFrame排序
4. 按DataFrame索引排序
5. 设置新索引
6. 从DataFrame读取列
7. 从DataFrame读取行
8. 重命名列或行
9. 重置索引
DataFrame是Pandas的另外一个主要的数据结构，它是由行和列组成的二维数据结构，因此需要两个参考点来从数据集中提取给定值。
1. DataFrame概述
DataFrame可以描述为网格或数据表，类似于Excel之类的电子表格中的网格或数据表。
1.1 从字典创建DataFrame
和往常一样，让我们从导入pandas开始，还将使用NumPy库生成一些随机数据：
In [1]: import pandas as pdimport numpy as np在导入第一个数据集之前，让我们练习从一些Python内置对象实例化一个DataFrame。例如字典，其键将用作列名，而相应的值将用作该列的值。
下例使用三个长度相等的列表来存储城市，国家和人口。也可以使用其它可迭代对象（如元组或Series）代替列表。DataFrame类的第一个参数data代表数据源。
In [2]: city_data = {"City": ["New York City", "Paris", "Barcelona", "Rome"],"Country": ["United States", "France", "Spain", "Italy"],"Population": [8600000, 2141000, 5515000, 2873000]}cities = pd.DataFrame(city_data)cities
Out [2]: City Country Population0 New York City United States 86000001 Paris France 21410002 Barcelona Spain 55150003 Rome Italy 2873000我们创建了第一个DataFrame，它与Series非常相似。再次提醒，当我们没有为构造函数提供一个明确的索引时，pandas会默认生成一个从0开始的顺序索引。
如果我们想翻转数据，以列标头作为索引标签，我们可以调用transpose方法或其T属性：
In [3]: cities.transpose() # 此行代码和下面代码是一样的cities.T
Out [3]: 0 1 2 3City New York City Paris Barcelona RomeCountry United States France Spain ItalyPopulation 8600000 2141000 5515000 2873000另外还可以使用一个更方便的from_dict方法，此方法用于把字典转换为DataFrame。其参数orient用于控制索引标签的创建，如果想把字典的键保存为DataFrame的列，可以使用默认值columns；如果想把字典的键保存为行，则使用值index：
In [4]: pd.DataFrame.from_dict(data = city_data, orient = "index")
Out [4]: 0 1 2 3City New York City Paris Barcelona RomeCountry United States France Spain ItalyPopulation 8600000 2141000 5515000 28730001.2 从NumPy 数组创建DataFrame
DataFrame构造函数还接受NumPy ndarray对象。假设我们要创建一个3x5的DataFrame，其整数在1到100（含）之间，我们可以使用random模块的randint方法：
In [5]: data = np.random.randint(1, 101, [3, 5])data
Out [5]: array([[25, 22, 80, 43, 42],[40, 89, 7, 21, 25],[89, 71, 32, 28, 39]])接下来，我们将ndarray传到DataFrame构造函数中。与行一样，如果未提供自定义的列标头，Pandas将为每列分配一个数字索引：
In [6]: pd.DataFrame(data = data)
Out [6]: 0 1 2 3 40 25 22 80 43 421 40 89 7 21 252 89 71 32 28 39我们可以使用可迭代序列，例如列表，元组或ndarray，以用作行标签。请注意，可迭代项的长度必须等于数据集中的行数。这是一个3x5的表格，因此我们必须为索引提供3个标签。
In [7]: index = ["Morning", "Afternoon", "Evening"]temperatures = pd.DataFrame(data = data, index = index)temperatures
Out [7]: 0 1 2 3 4Morning 25 22 80 43 42Afternoon 40 89 7 21 25Evening 89 71 32 28 39columns参数允许我们设置DataFrame的列名（也称为垂直标签）。因为我们总共有5列，所以我们的可迭代项的长度必须为5。下例通过将标头存储在元组中来设置列名：
In [8]: index = ["Morning", "Afternoon", "Evening"]columns = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")temperatures = pd.DataFrame(data = data,index = index,columns = columns)temperatures
Out [8]: Monday Tuesday Wednesday Thursday FridayMorning 25 22 80 43 42Afternoon 40 89 7 21 25Evening 89 71 32 28 39行索引和列索引都允许包含重复值：
In [9]: index = ["Morning", "Afternoon", " Morning"]columns = ("Monday", "Tuesday", "Wednesday", "Tuesday", "Friday")temperatures = pd.DataFrame(data = data,index = index,columns = columns)temperatures
Out [9]: Monday Tuesday Wednesday Tuesday FridayMorning 25 22 80 43 42Afternoon 40 89 7 21 25Morning 89 71 32 28 392. Series和DataFrame的相似点
在之前介绍的许多Series属性和方法在DataFrame上也适用。
2.1 导入CSV数据集
nba.csv文件是2019-2020 NBA运动员的数据集，包括每个球员的姓名，球队，位置，生日和工资：
In [10]: pd.read_csv("nba.csv")
Out [10]: Name Team Position Birthday Salary0 Shake Milton Philadelphia 76ers SG 9/26/96 14456971 Christian Wood Detroit Pistons PF 9/27/95 16453572 PJ Washington Charlotte Hornets PF 8/23/98 38318403 Derrick Rose Detroit Pistons PG 10/4/88 73170744 Marial Shayok Philadelphia 76ers G 7/26/95 79568… … … … … …445 Austin Rivers Houston Rockets PG 8/1/92 2174310446 Harry Giles Sacramento Kings PF 4/22/98 2578800447 Robin Lopez Milwaukee Bucks C 4/1/88 4767000448 Collin Sexton Cleveland Cavaliers PG 1/4/99 4764960449 Ricky Rubio Phoenix Suns PG 10/21/90 16200000450 rows x 5 columns注意，Birthday列中的值默认是作为字符串而不是datetime对象导入，之前介绍过可以使用parse_dates参数将值强制转换为datetime，一致以YYYY-MM-DD格式显示：
In [11]: pd.read_csv("nba.csv", parse_dates = ["Birthday"])
Out [11]: Name Team Position Birthday Salary0 Shake Milton Philadelphia 76ers SG 1996-09-26 14456971 Christian Wood Detroit Pistons PF 1995-09-27 16453572 PJ Washington Charlotte Hornets PF 1998-08-23 38318403 Derrick Rose Detroit Pistons PG 1988-10-04 73170744 Marial Shayok Philadelphia 76ers G 1995-07-26 79568… … … … … …445 Austin Rivers Houston Rockets PG 1992-08-01 2174310446 Harry Giles Sacramento Kings PF 1998-04-22 2578800447 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000448 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960449 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000450 rows x 5 columns现在我们可以把DataFrame分配给一个变量nba：
In [12]: nba = pd.read_csv("nba.csv", parse_dates = ["Birthday"])2.2 共享和专用属性
Series的值必须是单一同质的数据类型，而DataFrame的列可以保存异构的数据。让我们使用dtypes属性查看各自的数据类型，它返回的是一个Series对象：
In [13]: nba.dtypes
Out [13]: Name objectTeam objectPosition objectBirthday datetime64[ns]Salary int64dtype: object然后调用value_counts方法可以计算每种数据类型的列数：
In [14]: nba.dtypes.value_counts()
Out [14]: object 3datetime64[ns] 1int64 1dtype: int64DataFrame基本上由两个对象组成：一个由行标签组成的索引和一个保存每一行值的数据容器。Pandas自带了几个索引对象，每个索引对象都经过优化以存储特定类型的值（numeric、string、datetime等）。index属性返回DataFrame的Index对象。下面让我们看一下nba数据集使用的索引类型：
In [15]: nba.index
Out [15]: RangeIndex(start=0, stop=450, step=1)RangeIndex是一个优化的索引，用于存储顺序的整数值。与Python的range函数非常相似，RangeIndex包含三个参数：start，stop和step（每两个值之间的间隔）。上例的输出告诉我们索引从0开始，以1为增量（即0、1、2…449）直到450。
DataFrame还具有专用的columns属性，该属性返回包含标头的Index对象：
In [16]: nba.columns
Out [16]: Index(['Name', 'Team', 'Position', 'Birthday', 'Salary'], dtype='object')axes属性同时返回行和列索引：
In [17]: nba.axes
Out [17]: [RangeIndex(start=0, stop=450, step=1),Index(['Name', 'Team', 'Position', 'Birthday', 'Salary'], dtype='object')]shape属性返回DataFrame维度的元组，450行x 5列：
In [18]: nba.shape
Out [18]: (450, 5)ndim属性返回维数：
In [19]: nba.ndim
Out [19]: 2size属性返回数据集中值的总数，包括缺失值，它等于行数和列数的乘积：
In [20]: nba.size
Out [20]: 2250In [21]: len(nba.index) * len(nba.columns)
Out [21]: 2250如果要排除缺失值可以使用count方法，它将返回一个包含每个DataFrame列的非空值数量的Series。然后使用sum方法得出DataFrame中非空值的总数。因为此数据集不包含任何缺失值，所以size属性和count方法的结果将相同。
In [22]: nba.count()
Out [22]: Name 450Team 450Position 450Birthday 450Salary 450dtype: int64In [23]: nba.count().sum()
Out [23]: 22502.3 共享方法
head和tail方法返回数据集的最前或最后的行：
In [24]: nba.head(2)
Out [24]: Name Team Position Birthday Salary0 Shake Milton Philadelphia 76ers SG 1996-09-26 14456971 Christian Wood Detroit Pistons PF 1995-09-27 1645357In [25]: nba.tail(n = 3)
Out [25]: Name Team Position Birthday Salary447 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000448 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960449 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000sample方法返回DataFrame的随机行：
In [26]: nba.sample(3)
Out [26]: Name Team Position Birthday Salary348 Patrick Patterson Los Angeles Clippers PF 1989-03-14 306866014 Alec Burks Golden State Warriors SG 1991-07-20 2320044228 Ignas Brazdeikis New York Knicks SF 1999-01-08 898310nunique方法返回一个包含每一列唯一值的数量的Series：
In [27]: nba.nunique()
Out [27]: Name 450Team 30Position 9Birthday 430Salary 269dtype: int64之前介绍过的max和min方法在DataFrame上也适用，它们返回包含每一列的最大值和最小值的Series。datetime列的最大值是按时间顺序排列的最新日期。
In [28]: nba.max()
Out [28]: Team Washington WizardsPosition SGBirthday 2000-12-23 00:00:00Salary 40231758dtype: objectIn [29]: nba.min()
Out [29]: Team Atlanta HawksPosition CBirthday 1977-01-26 00:00:00Salary 79568dtype: objectnlargest方法返回按照指定列最大值排序的前n行。因为一个DataFrame可以包含多个可排序的列，所以我们必须使用columns参数指定要用作排序的列。参数值可以是单个列名，也可以是多个列名的列表。下例是返回NBA中收入最高的前4名球员：
In [30]: nba.nlargest(n = 4, columns = "Salary")
Out [30]: Name Team Position Birthday Salary205 Stephen Curry Golden State Warriors PG 1988-03-14 4023175838 Chris Paul Oklahoma City Thunder PG 1985-05-06 38506482219 Russell Westbrook Houston Rockets PG 1988-11-12 38506482251 John Wall Washington Wizards PG 1990-09-06 38199000nsmallest方法返回按照指定列最小值排序的前n行。下例是返回NBA中最老的前3名球员：
In [31]: nba.nsmallest(3, columns = ["Birthday"])
Out [31]: is Name Team Position Birthday Salary98 Vince Carter Atlanta Hawks PF 1977-01-26 2564753196 Udonis Haslem Miami Heat C 1980-06-09 2564753262 Kyle Korver Milwaukee Bucks PF 1981-03-17 6004753如果要计算所有NBA工资的总和，可以直接使用sum方法，但必须把numeric_only参数设为True，用于只计算数值类型的列。
In [32]: nba.sum(numeric_only = True)
Out [32]: Salary 3444112694dtype: int64mean方法可以计算平均工资：
In [33]: nba.mean()
Out [33]: Salary 7.653584e+06dtype: float64median方法可以计算工资的中位数，std方法统计偏差：
In [34]: nba.median()
Out [34]: Salary 3303074.5dtype: float64In [35]: nba.std()
Out [35]: Salary 9.288810e+06dtype: float643. 按DataFrame值排序
我们可以使用sort_values方法按一列或多列对DataFrame进行排序。默认情况下，该方法返回一个新的DataFrame。
3.1 按单列排序
首先让我们按名字对球员进行排序，by参数用于指定排序的列：
In [36]: nba.sort_values("Name") # 和下面代码是一样的nba.sort_values(by = "Name")
Out [36]: Name Team Position Birthday Salary52 Aaron Gordon Orlando Magic PF 1995-09-16 19863636101 Aaron Holiday Indiana Pacers PG 1996-09-30 2239200437 Abdel Nader Oklahoma City Thunder SF 1993-09-25 161852081 Adam Mokoka Chicago Bulls G 1998-07-18 79568399 Admiral Schofield Washington Wizards SF 1997-03-30 1000000… … … … … …159 Zach LaVine Chicago Bulls PG 1995-03-10 19500000302 Zach Norvell Los Angeles Lakers SG 1997-12-09 79568312 Zhaire Smith Philadelphia 76ers SG 1999-06-04 3058800137 Zion Williamson New Orleans Pelicans F 2000-07-06 9757440248 Zylan Cheatham New Orleans Pelicans SF 1995-11-17 79568450 rows × 5 columnsascending参数可以指定升序或降序排序，我们可以使用它来找出NBA中最年轻的五个球员，只需对Birthday列进行降序排序，head方法默认返回前5行：
In [37]: nba.sort_values("Birthday", ascending = False).head()
Out [37]: Name Team Position Birthday Salary136 Sekou Doumbouya Detroit Pistons SF 2000-12-23 3285120432 Talen Horton-Tucker Los Angeles Lakers GF 2000-11-25 898310137 Zion Williamson New Orleans Pelicans F 2000-07-06 9757440313 RJ Barrett New York Knicks SG 2000-06-14 7839960392 Jalen Lecque Phoenix Suns G 2000-06-13 8983103.2 按多列排序
sort_values方法的by参数还支持按多个列排序，默认情况下，所有排序将按升序排列，也就是ascending参数默认值为True。下例按字母顺序对球队进行排序，然后再对每个球队中的球员进行排序：
In [38]: nba.sort_values(by = ["Team", "Name"])
Out [38]: Name Team Position Birthday Salary359 Alex Len Atlanta Hawks C 1993-06-16 4160000167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000276 Brandon Goodwin Atlanta Hawks PG 1995-10-02 79568438 Bruno Fernando Atlanta Hawks C 1998-08-15 1400000194 Cam Reddish Atlanta Hawks SF 1999-09-01 4245720… … … … … …418 Jordan McRae Washington Wizards PG 1991-03-28 1645357273 Justin Robinson Washington Wizards PG 1997-10-12 898310428 Moritz Wagner Washington Wizards C 1997-04-26 206352021 Rui Hachimura Washington Wizards PF 1998-02-08 446916036 Thomas Bryant Washington Wizards C 1997-07-31 800000450 rows × 5 columns我们可以使用ascending参数对每个列按相同的顺序排序：
In [39]: nba.sort_values(["Team", "Name"], ascending = False)
Out [39]: Name Team Position Birthday Salary36 Thomas Bryant Washington Wizards C 1997-07-31 800000021 Rui Hachimura Washington Wizards PF 1998-02-08 4469160428 Moritz Wagner Washington Wizards C 1997-04-26 2063520273 Justin Robinson Washington Wizards PG 1997-10-12 898310418 Jordan McRae Washington Wizards PG 1991-03-28 1645357… … … … … …194 Cam Reddish Atlanta Hawks SF 1999-09-01 4245720438 Bruno Fernando Atlanta Hawks C 1998-08-15 1400000276 Brandon Goodwin Atlanta Hawks PG 1995-10-02 79568167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000359 Alex Len Atlanta Hawks C 1993-06-16 4160000450 rows × 5 columns如果我们想对每个列按照不同的排序顺序，例如，对球队按升序进行排序，然后再对工资按降序进行排序。为此，ascending参数也支持列表值，每个布尔值会与by参数的每个值对应，也就是by和ascending参数的列表的长度必须相等。
In [40]: nba.sort_values(by = ["Team", "Salary"],ascending = [True, False])
Out [40]: Name Team Position Birthday Salary111 Chandler Parsons Atlanta Hawks SF 1988-10-25 2510251228 Evan Turner Atlanta Hawks PG 1988-10-27 18606556167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000213 De'Andre Hunter Atlanta Hawks SF 1997-12-02 7068360339 Jabari Parker Atlanta Hawks PF 1995-03-15 6500000… … … … … …80 Isaac Bonga Washington Wizards PG 1999-11-08 1416852399 Admiral Schofield Washington Wizards SF 1997-03-30 1000000273 Justin Robinson Washington Wizards PG 1997-10-12 898310283 Garrison Mathews Washington Wizards SG 1996-10-24 79568353 Chris Chiozza Washington Wizards PG 1995-11-21 79568450 rows × 5 columns与Series一样，inplace参数会修改原始DataFrame而不是返回一个新的DataFrame。Jupyter Notebook中将不会产生任何输出：
In [41]: nba.sort_values(by = ["Team", "Salary"],ascending = [True, False],inplace = True)4. 按DataFrame索引排序
使用inplace参数更改了原始的DataFrame，但我们也有方法将其恢复为原始形式。
4.1 按行索引排序
sort_index方法按索引值对DataFrame进行排序：
In [42]: nba.sort_index().head() # 与下行代码是一样的nba.sort_index(ascending = True).head()
Out [42]: Name Team Position Birthday Salary0 Shake Milton Philadelphia 76ers SG 1996-09-26 14456971 Christian Wood Detroit Pistons PF 1995-09-27 16453572 PJ Washington Charlotte Hornets PF 1998-08-23 38318403 Derrick Rose Detroit Pistons PG 1988-10-04 73170744 Marial Shayok Philadelphia 76ers G 1995-07-26 79568使用inplace参数使更改永久生效：
In [43]: nba.sort_index(inplace = True)4.2 按列索引排序
按列进行排序可以使用axis参数，只需把值设为1或columns：
In [44]: nba.sort_index(axis = 1).head() # 这三行代码是一样的nba.sort_index(axis = "columns").head()nba.sort_index(axis = "columns", ascending = True).head()
Out [44]: Birthday Name Position Salary Team0 1996-09-26 Shake Milton SG 1445697 Philadelphia 76ers1 1995-09-27 Christian Wood PF 1645357 Detroit Pistons2 1998-08-23 PJ Washington PF 3831840 Charlotte Hornets3 1988-10-04 Derrick Rose PG 7317074 Detroit Pistons4 1995-07-26 Marial Shayok G 79568 Philadelphia 76ers5. 设置新索引
设置新索引可以使用set_index方法，它返回一个以给定列作为索引的新DataFrame：
In [45]: nba.set_index(keys = "Name") # is the same asnba.set_index("Name")
Out [45]: Team Position Birthday SalaryNameShake Milton Philadelphia 76ers SG 1996-09-26 1445697Christian Wood Detroit Pistons PF 1995-09-27 1645357PJ Washington Charlotte Hornets PF 1998-08-23 3831840Derrick Rose Detroit Pistons PG 1988-10-04 7317074Marial Shayok Philadelphia 76ers G 1995-07-26 79568… … … … …Austin Rivers Houston Rockets PG 1992-08-01 2174310Harry Giles Sacramento Kings PF 1998-04-22 2578800Robin Lopez Milwaukee Bucks C 1988-04-01 4767000Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960Ricky Rubio Phoenix Suns PG 1990-10-21 16200000450 rows × 4 columns使用inplace参数使更改永久生效：
In [46]: nba.set_index(keys = "Name", inplace = True)如果我们知道要在导入数据集时用作索引的列，我们还可以使用read_csv方法的index_col参数：
In [47]: nba = pd.read_csv("nba.csv",parse_dates = ["Birthday"],index_col = "Name")6. 从DataFrame读取列
DataFrame是共用相同索引的Series对象的集合，我们可以轻松地从DataFrame中读取一个或多个这些列。
6.1 从DataFrame读取单列
每个Series的列都可以使用DataFrame的属性读取。例如，我们可以使用nba.Salary读取Salary列：
In [48]: nba.Salary
Out [48]: NameShake Milton 1445697Christian Wood 1645357PJ Washington 3831840Derrick Rose 7317074Marial Shayo 79568...Austin Rivers 2174310Harry Giles 2578800Robin Lopez 4767000Collin Sexton 4764960Ricky Rubio 16200000Name: Salary, Length: 450, dtype: int64如果您希望始终使用二维数据结构，可以使用to_frame方法将Series转换为DataFrame:
In [49]: nba.Salary.to_frame()
Out [49]: SalaryNameShake Milton 1445697Christian Wood 1645357PJ Washington 3831840Derrick Rose 7317074Marial Shayok 79568… …Austin Rivers 2174310Harry Giles 2578800Robin Lopez 4767000Collin Sexton 4764960Ricky Rubio 16200000450 rows × 1 columns也可以通过名称来读取列，这种方法的优点是它支持名称中带有空格的列。
In [50]: nba["Position"]
Out [50]: NameShake Milton SGChristian Wood PFPJ Washington PFDerrick Rose PGMarial Shayok G..Austin Rivers PGHarry Giles PFRobin Lopez CCollin Sexton PGRicky Rubio PGName: Position, Length: 450, dtype: object6.2 从DataFrame读取多列
要读取多个列，只需要在列表中指定多个列名，返回的是一个新的DataFrame。它的列的排列顺序和列表中的一样，这是重新排列DataFrame列的有效方式：
In [51]: nba[["Salary", "Birthday"]]
Out [51]: Salary BirthdayNameShake Milton 1445697 1996-09-26Christian Wood 1645357 1995-09-27PJ Washington 3831840 1998-08-23Derrick Rose 7317074 1988-10-04Marial Shayok 79568 1995-07-26… … …Austin Rivers 2174310 1992-08-01Harry Giles 2578800 1998-04-22Robin Lopez 4767000 1988-04-01Collin Sexton 4764960 1999-01-04Ricky Rubio 16200000 1990-10-21450 rows × 2 columns如果我们想根据列的数据类型来选择列，可以使用select_dtypes方法，其include和exclude这两个参数可以指定单个数据类型或多个数据类型的列表。提醒一下，您可以使用dtypes属性查看数据集中的数据类型。
In [52]: # 仅选择字符串类型的列` nba.select_dtypes(include = "object")
Out [52]: Team PositionName Shake Milton Philadelphia 76ers SGChristian Wood Detroit Pistons PFPJ Washington Charlotte Hornets PFDerrick Rose Detroit Pistons PGMarial Shayok Philadelphia 76ers G… … …Austin Rivers Houston Rockets PGHarry Giles Sacramento Kings PFRobin Lopez Milwaukee Bucks CCollin Sexton Cleveland Cavaliers PGRicky Rubio Phoenix Suns PG450 rows × 2 columnsIn [53]: # 排除字符串和整数类型的列nba.select_dtypes(exclude = ["object", "int"])
Out [53]: BirthdayName Shake Milton 1996-09-26Christian Wood 1995-09-27PJ Washington 1998-08-23Derrick Rose 1988-10-04Marial Shayok 1995-07-26… …Austin Rivers 1992-08-01Harry Giles 1998-04-22Robin Lopez 1988-04-01Collin Sexton 1999-01-04Ricky Rubio 1990-10-21450 rows × 1 columns
7. 从DataFrame读取行
DataFrame中的行可以通过索引标签或索引位置读取。
7.1 通过索引标签读取行
loc属性返回具有给定索引标签行的Series，注意是区分大小写。下例是返回索引标签是"LeBron James"的行：
In [54]: nba.loc["LeBron James"]
Out [54]: Team Los Angeles LakersPosition PFBirthday 1984-12-30 00:00:00Salary 37436858Name: LeBron James, dtype: object还可以给定一个列表以读取多行，返回结果是一个DataFrame，顺序和给定的列表一样：
In [55]: nba.loc[["Kawhi Leonard", "Paul George"]]
Out [55]: Team Position Birthday SalaryNameKawhi Leonard Los Angeles Clippers SF 1991-06-29 32742000Paul George Los Angeles Clippers SF 1990-05-02 33005556Pandas还支持Python的列表切片语法。例如，我们可以对索引标签进行排序以按字母顺序获得球员的姓名，然后选择Otto Porter和Patrick Beverley之间的所有球员。注意，两个端点的球员也会被包括在内：
In [56]: nba.sort_index().loc["Otto Porter":"Patrick Beverley"]
Out [56]: Team Position Birthday SalaryNameOtto Porter Chicago Bulls SF 1993-06-03 27250576PJ Dozier Denver Nuggets PG 1996-10-25 79568PJ Washington Charlotte Hornets PF 1998-08-23 3831840Pascal Siakam Toronto Raptors PF 1994-04-02 2351838Pat Connaughton Milwaukee Bucks SG 1993-01-06 1723050Patrick Beverley Los Angeles Clippers PG 1988-07-12 12345680我们还可以读取DataFrame从某行开始到最后一行的数据，它与从Python列表中读取分片的语法相同，也就是在初始索引标签后加一个冒号：
In [57]: nba.sort_index().loc["Zach Collins":]
Out [57]: Team Position Birthday SalaryNameZach Collins Portland Trail Blazers C 1997-11-19 4240200Zach LaVine Chicago Bulls PG 1995-03-10 19500000Zach Norvell Los Angeles Lakers SG 1997-12-09 79568Zhaire Smith Philadelphia 76ers SG 1999-06-04 3058800Zion Williamson New Orleans Pelicans F 2000-07-06 9757440Zylan Cheatham New Orleans Pelicans SF 1995-11-17 79568同理可以读取DataFrame从开头到某行的数据，下例返回所从开头到"Al Horford"的行：
In [58]: nba.sort_index().loc[:"Al Horford"]
Out [58]: Team Position Birthday SalaryNameAaron Gordon Orlando Magic PF 1995-09-16 19863636Aaron Holiday Indiana Pacers PG 1996-09-30 2239200Abdel Nader Oklahoma City Thunder SF 1993-09-25 1618520Adam Mokoka Chicago Bulls G 1998-07-1 79568Admiral Schofield Washington Wizards SF 1997-03-30 1000000Al Horford Philadelphia 76ers C 1986-06-03 28000000如果DataFrame中不存在指定的索引标签，则会抛出KeyError异常：
In [59]: nba.loc["Bugs Bunny"]
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
KeyError: 'Bugs Bunny'7.2 通过索引位置读取行
iloc（索引位置index location）属性返回具有给定索引位置的一行或多行，参数可以是单个整数或整数的列表：
In [60]: nba.iloc[300]
Out [60]: Team Denver NuggetsPosition PFBirthday 1999-04-03 00:00:00Salary 1416852Name: Jarred Vanderbilt, dtype: objectIn [61]: nba.iloc[[100, 200, 300, 400]]
Out [61]: Team Position Birthday SalaryNameBrian Bowen Indiana Pacers SG 1998-10-02 79568Marco Belinelli San Antonio Spurs SF 1986-03-25 5846154Jarred Vanderbilt Denver Nuggets PF 1999-04-03 1416852Louis King Detroit Pistons F 1999-04-06 79568列表切片的语法在这里也是使用的，需要注意冒号后面指定端点的行是不包括的。下例返回索引位置400、401、402和403的行：
In [62]: nba.iloc[400:404]
Out [62]: Team Position Birthday SalaryNameLouis King Detroit Pistons F 1999-04-06 79568Kostas Antetokounmpo Los Angeles Lakers PF 1997-11-20 79568Rodions Kurucs Brooklyn Nets PF 1998-02-05 1699236Spencer Dinwiddie Brooklyn Nets PG 1993-04-06 10605600In [63]: nba.iloc[:2] # 读取头两行
Out [63]: Team Position Birthday SalaryNameShake Milton Philadelphia 76ers SG 1996-09-26 1445697Christian Wood Detroit Pistons PF 1995-09-27 1645357In [64]: nba.iloc[447:] # 读取从索引位置447到最后
Out [64]: Team Position Birthday SalaryNameRobin Lopez Milwaukee Bucks C 1988-04-01 4767000Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960Ricky Rubio Phoenix Suns PG 1990-10-21 16200000索引位置也可以使用负数，也就是从倒数开始数。下例是从倒数第10行直到倒数第6行，但不包括倒数第6行：
In [65]: nba.iloc[-10:-6]
Out [65]: Team Position Birthday SalaryNameJared Dudley Los Angeles Lakers PF 1985-07-10 2564753Max Strus ChicagoBulls SG 1996-03-28 79568Kevon Looney Golden State Warriors C 1996-02-06 4464286Willy Hernangomez Charlotte Hornets C 1994-05-27 1557250除此以外还可以指定索引位置的步长序列。在下例中，我们从前十行中选择间隔为2的行。因此，返回结果的索引位置为0、2、4、6和8：
In [66]: nba.iloc[0:10:2]
Out [66]: Team Position Birthday SalaryNameShake Milton Philadelphia 76ers SG 1996-09-26 1445697PJ Washington Charlotte Hornets PF 1998-08-23 3831840Marial Shayok Philadelphia 76ers G 1995-07-26 79568Kendrick Nunn Miami Heat SG 1995-08-03 1416852Brook Lopez Milwaukee Bucks C 1988-04-01 120930247.3 从行的指定列中读取值
loc和iloc属性都支持第二个参数指定要读取的列。在下例中，我们读取索引标签为"Giannis Antetokounmpo" 所在行的Team列的值：
In [67]: nba.loc["Giannis Antetokounmpo", "Team"]
Out [67]: 'Milwaukee Bucks'两个参数都支持传递列表，下例第二个参数使用列表指定要读取Position和Birthday列的值：
In [68]: nba.loc["James Harden", ["Position", "Birthday"]]
Out [68]: Position PGBirthday 1989-08-26 00:00:00Name: James Harden, dtype: object下例第一、二个参数都使用了列表：
In [69]: nba.loc[["Russell Westbrook", "Anthony Davis"],["Team", "Salary"]]
Out [69]: Team SalaryNameRussell Westbrook Houston Rockets 38506482Anthony Davis Los Angeles Lakers 27093019列表切片语法也可以用于读取多个列，注意，这里两个端点都将包括在内：
In [70]: nba.loc["Joel Embiid", "Position":"Salary"]
Out [70]: Position CBirthday 1994-03-16 00:00:00Salary 27504630Name: Joel Embiid, dtype: object参数指定的列名必须和它们在DataFrame中出现的顺序一样。下例会返回空列表，因为Salary列位于Position列之后：
In [71]: nba.loc["Joel Embiid", "Salary":"Position"]
Out [71]: Series([], Name: Joel Embiid, dtype: object)每个DataFrame列都分配有一个索引位置，在我们当前的DataFrame中，Team的索引为0，Position的索引为1，依此类推。
In [72]: nba.columns
Out [72]: Index(['Team', 'Position', 'Birthday', 'Salary'], dtype='object')列的索引位置也可以作为第二个参数传给iloc：
In [73]: nba.iloc[57, 3]
Out [73]: 796806列表切片语法也可以在此处使用。下例返回索引位置100到104（不包括）所在行的从开始到索引位置3（不包括）的列：
In [74]: nba.iloc[100:104, :3]
Out [74]: Team Position BirthdayNameBrian Bowen Indiana Pacers SG 1998-10-02Aaron Holiday Indiana Pacers PG 1996-09-30Troy Daniels Los Angeles Lakers SG 1991-07-15Buddy Hield Sacramento Kings SG 1992-12-17iloc和loc属性非常通用，参数可以是单个值、列表、列表切片等。这种灵活性的缺点是需要额外的开销，pandas必须检查iloc或loc的输入类型。
当我们要从DataFrame中读取单个值时，可以使用at和iat这两个替代属性： at属性的参数是行和列标签，而iat属性的参数是行和列索引位置：
In [75]: nba.at["Austin Rivers", "Birthday"]
Out [75]: Timestamp('1992-08-01 00:00:00')In [76]: nba.iat[263, 1]
Out [76]: 'PF'8. 重命名列或行
我们可以通过使用新名称列表覆盖columns属性来重命名DataFrame中的某些或所有列：
In [77]: nba.columns
Out [77]: Index(['Team', 'Position', 'Birthday', 'Salary'], dtype='object')In [78]: nba.columns = ["Team", "Position", "Date of Birth", "Pay"]nba.head(1)
Out [78]: Team Position Date of Birth PayNameShake Milton Philadelphia 76ers SG 1996-09-26 1445697我们也可以使用rename方法，其参数columns的值类型是一个字典，键是需要修改的原列名，值是新的列名。下例是把原列名"Date of Birth"重命名为"Birthday"：
In [79]: nba.rename(columns = { "Date of Birth": "Birthday" })
Out [79]: Team Position Birthday PayNameShake Milton Philadelphia 76ers SG 1996-09-26 1445697Christian Woo Detroit Pistons PF 1995-09-27 1645357PJ Washington Charlotte Hornets PF 1998-08-23 3831840Derrick Rose Detroit Pistons PG 1988-10-04 7317074Marial Shayok Philadelphia 76ers G 1995-07-26 79568… … … … …Austin Rivers Houston Rockets PG 1992-08-01 2174310Harry Giles Sacramento Kings PF 1998-04-22 2578800Robin Lopez Milwaukee Bucks C 1988-04-01 4767000Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960Ricky Rubio Phoenix Suns PG 1990-10-21 16200000450 rows × 4 columns一如既往地，使用 inplace 参数使修改永久生效：
In [80]: nba.rename(columns = { "Date of Birth": "Birthday" },inplace = True)rename方法也可以重命名索引标签。下例将 "Giannis Antetokounmpo" 重命名为他的昵称 "Greek Freak"：
In [81]: nba.loc["Giannis Antetokounmpo"]
Out [81]: Team Milwaukee BucksPosition PFBirthday 1994-12-06 00:00:00Pay 25842697Name: Giannis Antetokounmpo, dtype: objectIn [82]: nba.rename(index = { "Giannis Antetokounmpo": "Greek Freak" },inplace = True)In [83]: nba.loc["Greek Freak"]
Out [83]: Team Milwaukee BucksPosition PFBirthday 1994-12-06 00:00:00Pay 25842697Name: Greek Freak, dtype: object9. 重置索引
如果我们想把另一列用作DataFrame的索引，可以使用set_index方法，但会造成当前索引Name的丢失：
In [84]: nba.set_index("Team").head()
Out [84]: Position Birthday PayTeamPhiladelphia 76ers SG 1996-09-26 1445697Detroit Pistons PF 1995-09-27 1645357Charlotte Hornets PF 1998-08-23 3831840Detroit Pistons PG 1988-10-04 7317074Philadelphia 76ers G 1995-07-26 79568为了保留原来的索引列Name，我们首先要使用reset_index方法把现有索引重新整合为DataFrame中的常规列，并生成新的顺序索引：
In [85]: nba.reset_index().head()
Out [85]: Name Team Position Birthday Pay0 Shake Milton Philadelphia 76ers SG 1996-09-26 14456971 Christian Wood Detroit Pistons PF 1995-09-27 16453572 PJ Washington Charlotte Hornets PF 1998-08-23 38318403 Derrick Rose Detroit Pistons PG 1988-10-04 73170744 Marial Shayok Philadelphia 76ers G 1995-07-26 79568现在我们可以放心使用set_index方法了：
In [86]: nba.reset_index().set_index("Team").head()
Out [86]: Name Position Birthday PayTeamPhiladelphia 76ers Shake Milton SG 1996-09-26 1445697Detroit Pistons Christian Wood PF 1995-09-27 1645357Charlotte Hornets PJ Washington PF 1998-08-23 3831840Detroit Pistons Derrick Rose PG 1988-10-04 7317074Philadelphia 76ers Marial Shayok G 1995-07-26 79568reset_index方法也支持inplace参数，但是要注意：如果参数设置为True，则该方法将不会返回新的DataFrame，因此不能直接链接调用set_index方法，必须依次分开单独调用：
In [87]: nba.reset_index(inplace = True)nba.set_index("Name", inplace = True)END O(∩_∩)O
Pandas实战-DataFrame对象相关推荐
- 已解决pandas创建DataFrame对象失败
已解决(pandas创建DataFrame对象失败)ValueError: Shape of passed values is (1509, 1), indices imply (1509, 2) 文 ...
- pandas中DataFrame对象to_csv()方法中的encoding参数
当使用pd.read_csv()方法读取csv格式文件的时候,常常会因为csv文件中带有中文字符而产生字符编码错误,造成读取文件错误,在这个时候,我们可以尝试将pd.read_csv()函数的enco ...
- Python Pandas的DataFrame对象中轴的意义，axis=0 或者axis=1代表什么意思？
Python Pandas的DataFrame对象中轴的意义,axis=0 或者axis=1代表什么意义? 通常来说:axis = 0代表行, axis=1代表列. 一.从删除操作来看axis: 举个 ...
- Pandas创建DataFrame对象的几种常用方法
DataFrame是pandas常用的数据类型之一,表示带标签的可变二维表格.本文介绍如何创建DataFrame对象,后面会陆续介绍DataFrame对象的用法. 首先,使用pip.conda或类似工 ...
- [转载] Pandas：DataFrame对象的基础操作
参考链接: 创建一个Pandas DataFrame DataFrame对象的创建,修改,合并 import pandas as pd import numpy as np 创建DataFrame对象 ...
- Python使用pandas扩展库DataFrame对象的pivot方法对数据进行透视转换
Python扩展库pandas的DataFrame对象的pivot()方法可以对数据进行行列互换,或者进行透视转换,在有些场合下分析数据时非常方便. DataFrame对象的pivot()方法可以接收 ...
- 如何创建一个Python Pandas的DataFrame变量，如何给一个DataFrame对象添加新的一行数据？
如何给一个Python Pandas的DataFrame对象添加新一行数据? 1.如何创建一个新的dataframe变量. 1) 创建一个没有列名的dataframe变量:df = pd.DataFr ...
- python中的iloc函数_详解pandas中利用DataFrame对象的.loc[]、.iloc[]方法抽取数据
pandas的DataFrame对象,本质上是二维矩阵,跟常规二维矩阵的差别在于前者额外指定了每一行和每一列的名称.这样内部数据抽取既可以用"行列名称(对应.loc[]方法)",也 ...
- Pandas安装与对象使用（educoder）
第1关:安装并使用Pandas 任务描述 本关任务:输出Pandas的版本号. 相关知识 在安装 Pandas 之前,确保你的操作系统中有 NumPy.如果你是从源代码直接编译,那么还需要相应的工具编 ...
最新文章
- 将数据库改为使用登录名密码登陆
- 数据结构与算法系列 目录
- 阿里云推出免费套餐 30余款云产品半年免费
- android recycleview长按多选_UI设计中Android和IOS设计差异总结
- docker内存阀值_kubernetes调度之资源耗尽处理配置
- JEECG开源说明：JEECG 完全开源，不收任何费用，可以任用于商业！
- 十二. python面向对象主动调用其他类
- 【知识总结】多项式全家桶（一）（NTT、加减乘除和求逆）
- 异或加密的java算法_Java使用异或运算实现简单的加密解密算法实例代码
- Netty工作笔记0001---Netty介绍
- Android之ListView/GridView 优化
- 类文件结构和字节码指令
- Java随机数的使用
- ZooKeeper 的监控
- 腾达u12如何安装linux驱动,解决Centos7 安装腾达U12无线网卡驱动问题
- Unity CityEngine 根据地图中建筑矢量数据批量建模
- Hive 取非 Group by 字段数据的方法
- 我的世界梦世界服务器物品怎么卖,我的世界流浪商人交易表_我的世界流浪商人交易表图物品大全_攻略...
- 栈与队列的相同点和不同点
- python 绘图 实现图中为字体添加下标、上标