---

前言

本部分主要介绍一些注意事项。另外，series是基础，好多用法都是series扩展一下，很类似的。

1 loc和iloc注意事项。（后面这些都会在笔记中提到）

（1）返回的是Series还是dataframe取决于你有没有加中括号
【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下
（2）loc可以直接布尔索引，iloc布尔索引后还有.values一下转成numpy数组才能布尔索引

2 DataFrame的维度

一、 DataFrame的创建 — pd.DataFrame(data，index=None，columns=None)

— data：可以是字典、列表、NumPy 数组、Pandas Series 或 DataFrame 等。
— index：指定行索引，可以是列表、NumPy 数组或 Pandas Index 对象。
— columns：指定列名，可以是列表、NumPy 数组或 Pandas Index 对象。
没有指定就生成默认的位置索引。

1 字典创建DataFrame(字典转Dataframe很常用)

## 利用字典创建DataFrame
dict = {'数学':[93,89,80,77],'英语':[90,80,70,75],'语文':[87,79,67,92]}
df1 = pd.DataFrame(dict)
print(df1)                          #      数学  英语  语文#   0   93   90    87#   1   89   80    79#   2   80   70    67#   3   77   75    92df2 =pd.DataFrame(dict,index=['张三','李四','王五','赵六'])
print(df2)                          #      数学  英语  语文# 张三   93   90    87# 李四   89   80    79# 王五   80   70    67# 赵六   77   75    92

2 用numpy数组或者嵌套list创建DataFrame

# 从列表创建
data = [['Alice', 25], ['Bob', 30], ['Charlie', 35]]
df1 = pd.DataFrame(data,index=['a','b','c'] ,columns=['Name', 'Age'])
print(df1)                  #       Name  Age# a    Alice   25# b      Bob   30# c  Charlie   35# 从 NumPy 数组创建
data = np.array([[1, 2], [3, 4], [5, 6]])
df2 = pd.DataFrame(data, index=['a','b','c'], columns=['A', 'B'])      
print(df2)                  #    A  B# a  1  2# b  3  4# c  5  6

二、DataFrame的访问、索引、切片、布尔索引、修改等操作

1 行切片访问 df[ : ] ---- 不能用单个数字索引，只能用切片索引（后面会用loc和iloc替代这个很呆的功能）— 默认位置索引和自定义索引都支持

【注1】：这里切片就是真要切片了，不支持 df[0] , df[1]这种
【注2】：所以就很呆，所以我们后面都会用loc和iloc来替代这个垃圾功能
【注3】：切片无论是有没有设置自定义index都可以用默认位置索引（左闭右开），用自定义（符号）index也可以，但是是（左闭右闭）

# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],'Age': [24, 27, 22, 32, 29],'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data)        #      Name  Age  Score
print(df)                      # 0    Alice   24   85.5# 1      Bob   27   88.0# 2  Charlie   22   95.0# 3    David   32   70.5# 4      Eve   29   80.0print(df[0:3])                 #      Name  Age  Score# 0    Alice   24   85.5# 1      Bob   27   88.0# 2  Charlie   22   95.0    df2 = pd.DataFrame(data, index=['a', 'b', 'c', 'd', 'e'])      # 自定义一下索引
print(df2)                     #       Name  Age  Score# a    Alice   24   85.5# b      Bob   27   88.0# c  Charlie   22   95.0# d    David   32   70.5# e      Eve   29   80.0print(df2[0:3])                #       Name  Age  Score# a    Alice   24   85.5# b      Bob   27   88.0# c  Charlie   22   95.0print(df2['a':'c'])            #       Name  Age  Score# a    Alice   24   85.5# b      Bob   27   88.0# c  Charlie   22   95.0print(df2[0])              # KeyError: 0 不能用数字索引，只能用切片索引

2 按列选择

df[‘column_name’]：选择单列，返回 Series。

df[[‘column_name’]] ：选择单列，返回 DataFrame。

【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下

# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],'Age': [24, 27, 22, 32],'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print(df)               #     Name  Age         City# 0    Alice   24     New York# 1      Bob   27  Los Angeles# 2  Charlie   22      Chicago# 3    David   32      Houstonprint(df['Name'])       # 0      Alice# 1        Bob# 2    Charlie# 3      David# Name: Name, dtype: object           Seriesprint(df[['Name']])     #      Name# 0    Alice# 1      Bob# 2  Charlie# 3    David# DataFrame                         两个中括号返回的是 DataFrame

df[[‘col1’, ‘col2’]]：选择多列，返回 DataFrame。

3 按布尔条件选择

df[df[‘column_name’] > value]：选择满足条件的行。

df[(df[‘Age’] > 25) & (df[‘Score’] > 85)] ：and 注意里面布尔条件都要分别用小括号括起来，不然会报错

df[(df[‘Age’] > 25) | (df[‘Score’] > 85)] ： or

# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],'Age': [24, 27, 22, 32, 29],'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data)        #      Name  Age  Score
print(df)                      # 0    Alice   24   85.5# 1      Bob   27   88.0# 2  Charlie   22   95.0# 3    David   32   70.5# 4      Eve   29   80.0print(df[(df['Age'] > 25) & (df['Score'] > 85)])        #    Name  Age  Score# 1   Bob   27   88.0 

4 loc[ ] 与 iloc[ ]进行操作

• [注]：关于你筛选出来的数据是DataFrame还是Series关键在于你整数数组访问单个时有没有加中括号，没有加就有可能是Series，有就是DataFrame，看下面例子就懂了
• [注]：其实这个用法记住各种筛选条件可以混合用就是了

（1）loc[ ]

loc：基于标签（名称）的索引，用于按行和列的标签来访问数据。适合于按行/列标签精确选择数据。
初始要筛选的DataFrame

# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],'Age': [24, 27, 22, 32],'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df)                            #        Age         City# Name                      # Alice     24     New York# Bob       27  Los Angeles# Charlie   22     Chicago# David     32     Houston

基于行标签的选择 — df.loc[‘Alice’] ，df.loc[[‘Alice’]]

df.loc[‘Alice’] — 返回 Series

df.loc[[‘Alice’]] — 返回 DataFrame

df.loc[[‘Bob’, ‘David’]] — 返回 DataFrame ，这种数组的索引方式都可以用

如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有

# 按行标签选择
row = df.loc['Alice']               
print(row)                           # Age            24# City    New York# Name: Alice, dtype: object                # 单行返回 Seriesrow2 = df.loc[['Alice']]                # 加上中括号，返回的是 DataFrame了·
print(row2)                         #        Age      City# Name                   # Alice     24  New Yorkdf2 = df.loc[['Bob', 'David']]
print(df2)                           #        Age         City# Name                      # Bob       27  Los Angeles# David     32     Houston

• 选择标签为 ‘Alice’ 的行。

基于行和列标签的选择 — df.loc[‘Alice’, ‘Age’] , df.loc[‘Alice’, [‘Age’, ‘City’]], df.loc[[‘Alice’], [‘Age’, ‘City’]]

df.loc[‘Alice’, [‘Age’, ‘City’]] — 返回Series

df.loc[[‘Alice’], [‘Age’, ‘City’]] — 返回Dataframe

如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有

• 选择标签为 ‘Alice’ 的行和 ‘Age’ 列对应的单元格数据。

• 选择标签为 ‘Alice’ 的行以及 ‘Age’ 和 ‘City’ 列。

# 选择特定行和列
value = df.loc['Alice', 'Age']       
print(value)                         # 24                                    # 如果只选择一行一列，返回的是标量# 选择特定行的多列  --- 返回 Series
subset = df.loc['Alice', ['Age', 'City']] 
print(subset)                        # Age          24# City    New York# Name: Alice, dtype: object              # 注意：返回的是 Series# 选择特定行的多列  --- 返回 DataFrame
subset2 = df.loc[['Alice'], ['Age', 'City']] 
print(subset2)                       #        Age      City# Name                  # Alice     24  New York                      
# 如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series

基于行和列范围的选择（切片） — df.loc[‘Alice’:‘Charlie’, ‘Age’:‘City’]

# 选择行标签在一定范围内的多行和多列
subset = df.loc['Alice':'Charlie', 'Age':'City']
print(subset)                        #          Age         City# Name                      # Alice     24     New York# Bob       27  Los Angeles# Charlie   22     Chicago

• 选择行标签从 ‘Alice’ 到 ‘Charlie’（包括）的行，以及从 ‘Age’ 到 ‘City’ 的列。

基于布尔条件的选择 ---- df.loc[df[‘Age’] > 25] , df.loc[df[‘Age’] > 25, [‘City’]]

• 选择 ‘Age’ 列大于 25 的所有行。
• 选择 ‘Age’ 列大于 25 的行，并只保留 ‘City’ 列。

subset = df.loc[df['Age'] > 25]
print(subset)                        #        Age         City# Name                      # Bob       27  Los Angeles# David     32     Houstonsubset2 = df.loc[df['Age'] > 25, ['City']]
print(subset2)                      #                City# Name              # Bob   Los Angeles# David     Houston

更新操作

# 更新特定单元格的值
df.loc['Alice', 'Age'] = 30# 更新满足条件的行的特定列
df.loc[df['Age'] > 25, 'City'] = 'San Francisco'

• 更新 ‘Alice’ 行的 ‘Age’ 列值为 30。
• 将 ‘Age’ 列大于 25 的所有行的 ‘City’ 列值更新为 ‘San Francisco’。

（2）iloc[ ] 的使用方法

iloc 用于通过整数位置来选择数据，类似于 NumPy 的数组索引，支持按行、按列或行列组合进行选择。iloc 方法通常有以下几种用法：
创建示例 dataframe

# 创建示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],'Age': [24, 27, 22, 32],'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df)                            #        Age         City# Name                      # Alice     24     New York# Bob       27  Los Angeles# Charlie   22     Chicago# David     32     Houston

基于行位置的选择

df.iloc[0]

df.iloc[[0]]

df.iloc[[0,2]]

# 按行位置选择
print(df.iloc[0])             #  Age          24# City    New York# Name: Alice, dtype: object               # Seriesprint(df.iloc[[0]])           #        Age      City# Name                  # Alice    24  New York                    # DataFrame          print(df.iloc[[0,2]])         #         Age      City# Name                  # Alice    24  New York# Charlie  22   Chicago

基于行和列位置的选择

df.iloc[0,1] ---- 返回一个标量

df.iloc[0,[0,1]] — 返回series

df.iloc[[0],[0,1]] ---- 返回一个dataframe

print(df.iloc[0,1])                # New York
print(df.iloc[0,0])                # 24