Python---数据分析(Pandas七:二维数组DataFrame中元素的索引与访问，其他常用方法)

一、DataFrame中元素的索引与访问

1.1、使用列名访问

对于DataFrame来说，可以直接使用列名来访问某一列的数据，返回的是一个Series 对象。

python">import pandas as pddata = {'姓名': ['小明', '小红', '小刚'],'年龄': [20, 18, 22],'成绩': [85, 90, 88]
}df = pd.DataFrame(data, index=['a', 'b', 'c'])
print(df)
print(df['姓名'])
print(df[['姓名', '年龄']])
print(df['成绩']['b'])

1.2、 loc和iloc

可以使用loc与 iloc属性访问单个或多个数据，其语法为：

python">df.loc[row_label, column_label]

python">import pandas as pddata = {'姓名': ['小明', '小红', '小刚'],'年龄': [20, 18, 22],'成绩': [85, 90, 88]
}df = pd.DataFrame(data, index=['a', 'b', 'c'])
print(df)
print(df.loc['a', '姓名'])
print(df.iloc[1, 0])
print(df.loc['a':'b', '姓名':'成绩'])
print(df.iloc[0, 0])
print(df.iloc[0:1, 0:1])

1.3、 at和iat

使用at和 iat属性来访问单个数据。

python">import pandas as pddata = {'姓名': ['小明', '小红', '小刚'],'年龄': [20, 18, 22],'成绩': [85, 90, 88]
}df = pd.DataFrame(data)
print(df)
print(df.at[0, '姓名':'年龄'])
print(df.iat[0, 0])

1.4、 head

该方法用于获取DataFrame的前 n 行。默认情况下，如果不指定 n 的值，它会返回前5行。

python">DataFrame.head(n=None)

描述	说明
n	是可选参数，用于指定要返回的行数。如果不提供该参数，默认值为5。

python">import pandas as pd# 创建一个示例DataFrame
data = {'A': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],'B': [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
}
df = pd.DataFrame(data)# 使用head方法获取前5行
print(df.head(3))

1.5、 tail

该方法用于获取DataFrame的最后n行。与 DataFrame.head 方法类似，如果不指
定 n 的值，它会默认返回最后5行。

python">DataFrame.tail(n=5)

描述	说明
n	是可选参数，用于指定要返回的行数。如果不提供该参数，默认值为5。

python">import pandas as pd# 创建一个示例DataFrame
data = {'A': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],'B': [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
}
df = pd.DataFrame(data)# 使用tail方法获取最后5行
print(df.tail())

1.6、 isin

DataFrame.isin(values) 方法用于检查DataFrame中的元素是否包含在指定的集合 values 中。这个方法会返回一个布尔型DataFrame，其中的每个元素都表示原始DataFrame中对应元素是否在 values 中。

python">DataFrame.isin(values)

描述	说明
values	可以是单个值、列表、元组、集合或另一个DataFrame/Series。如果 values 是一个字典，键是列名，值是列表或元组，表示该列中要检查的值。

python">import pandas as pd# 创建一个示例DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': ['a', 'b', 'c', 'd', 'e']
}
df = pd.DataFrame(data)print(df)# 检查DataFrame中的元素是否包含在指定的值集合中
values_to_check = [2, 4, 'c']
print(df.isin(values_to_check))print(df['C'])

1.7、 get

用于从DataFrame中获取列，它类似于直接使用 df[key] 来访问列，但是当列不存在时，get 方法提供了一个更安全的方式来处理这种情况，你可以指定一个默认值，而不是引发一个错误。

python">DataFrame.get(key, default=None)

描述	说明
key	想获取的列的名称。
default	如果列不存在时返回的默认值。None

python">import pandas as pddata = {'姓名': ['小明', '小红', '小刚'],'年龄': [20, 18, 22],'成绩': [85, 90, 88]
}df = pd.DataFrame(data)# 获取'成绩'列
scores = df.get('成绩')print(scores)# 尝试获取不存在的列，返回指定值
non_existent_column = df.get('体重', default='Not Found')print(non_existent_column)

二、其他常用方法

2.1、nunique

用于计算DataFrame中唯一值的数量。

python">DataFrame.nunique(axis=0, dropna=True)

描述	说明
axis=0	默认值，表示按列进行操作。如果设置为 axis=1，则表示按行进行操作
dropna=True	默认值，表示在计算唯一值之前先排除掉缺失值（NaN）。如果设置为 False，则缺失值也会被计算在内。

python">
import pandas as pd
import numpy as np# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 2, 3, 3, 3],'B': ['a', 'b', 'b', 'c', 'c', 'c'],'C': [np.nan, np.nan, 1, 2, 2, 2]
})print(df)# 使用nunique()方法计算每列的唯一值数量
unique_counts = df.nunique(axis=1, dropna=False)print(unique_counts)

python">   A  B    C
0  1  a  NaN
1  2  b  NaN
2  2  b  1.0
3  3  c  2.0
4  3  c  2.0
5  3  c  2.0
0    3
1    3
2    3
3    3
4    3
5    3
dtype: int64

2.2 、value_counts

用于计算DataFrame中各个值出现的频率的一个方法。

python">DataFrame.value_counts(subset=None, normalize=False, sort=True, ascending=False, dropna=True)

描述	说明
subset=None	可选参数，用于指定要进行计算操作的列名列表。如果未指定，则对整个DataFrame的所有列进行操作。
normalize=False	布尔值，默认为False。如果设置为True，则返回每个值的相对频率，而不是计数。
sort=True	布尔值，默认为True。如果设置为True，则结果将按计数值降序排序。
ascending=False	布尔值，默认为False。当 sort=True时，此参数指定排序顺序。如果设置为True，则结果将按计数值升序排序。
dropna=True	布尔值，默认为True。如果设置为True，则在计数之前排除缺失值。

python">import pandas as pd
import numpy as np# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 2, 3, 3, 3],'B': ['a', 'b', 'b', 'c', 'c', 'c'],'C': [np.nan, np.nan, 1, 2, 2, 2]
})print(df)# 使用value_counts()方法计算值的频率
value_counts = df.value_counts(subset=['C'], normalize=True, sort=True, ascending=True, dropna=False)print(value_counts)

python">   A  B    C
0  1  a  NaN
1  2  b  NaN
2  2  b  1.0
3  3  c  2.0
4  3  c  2.0
5  3  c  2.0
C  
1.0    0.166667
NaN    0.333333
2.0    0.500000
Name: proportion, dtype: float64

2.3、 describe

用于生成DataFrame中数值列的统计摘要，会返回一个DataFrame，其中包含以下统计信息：

count：非NA值的数量

mean：平均值

std：标准差

min：最小值

分位数：可指定

max：最大值

python">DataFrame.describe(percentiles=None, include=None, exclude=None)

描述	说明
percentiles=None	一个列表形式的数值，用于指定要计算的分位数。默认情况下，会计算25%，50%，和75%这三个分位数。如果你想要不同的分位数，可以在这里指定。
include=None	一个列表形式的字符串或字符串序列，用于指定要包含在描述统计中的数据类型。默认情况下，只包括数值类型的数据。
exclude=None	一个列表形式的字符串或字符串序列，用于指定要从描述统计中排除的数据类型。

python">import pandas as pd# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 2, 3, 3, 3],'B': [10, 20, 20.0, 30, 30, 30],'C': ['foo', 'bar', 'bar', 'baz', 'baz', 'baz']
})print(df)# 使用describe()方法生成统计摘要
description = df.describe(percentiles=[0.5, 0.75, 0.9], include=['number'])print(description)

python">   A     B    C
0  1  10.0  foo
1  2  20.0  bar
2  2  20.0  bar
3  3  30.0  baz
4  3  30.0  baz
5  3  30.0  bazA          B
count  6.000000   6.000000
mean   2.333333  23.333333
std    0.816497   8.164966
min    1.000000  10.000000
50%    2.500000  25.000000
75%    3.000000  30.000000
90%    3.000000  30.000000
max    3.000000  30.000000

2.4 、copy

用于创建DataFrame的一个副本。

python">DataFrame.copy(deep=True)

描述	说明
deep=True	默认为True，表示创建一个深拷贝。在深拷贝中，DataFrame中的所有数据都会被复制到新的DataFrame中，因此原始DataFrame中的数据与副本 DataFrame中的数据是完全独立的。如果你对副本进行修改，原始DataFrame不会受到影响，反之亦然。

python">import pandas as pd# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 3],'B': [4, 5, 6]
})# 创建深拷贝
df_deep_copy = df.copy()# 创建浅拷贝
df_shallow_copy = df.copy(deep=False)# 修改深拷贝中的数据
df_deep_copy['A'][0] = 999# 修改浅拷贝中的数据
df_shallow_copy['B'][0] = 888# 打印原始DataFrame和副本
print("Original DataFrame:")
print(df)
print("\nDeep Copy:")
print(df_deep_copy)
print("\nShallow Copy:")
print(df_shallow_copy)

python">Original DataFrame:A    B
0  1  888
1  2    5
2  3    6Deep Copy:A  B
0  999  4
1    2  5
2    3  6Shallow Copy:A    B
0  1  888
1  2    5
2  3    6

2.5 、reset index

用于重置DataFrame的索引。

python">DataFrame.reset_index(level=None, *, drop=False, inplace=False, col_level=0, col_fill='', allow_duplicates=_NoDefault.no_default, names=None)

描述	说明
level=None	整数或索引名称，用于指定要重置的索引级别。对于多级索引的 DataFrame，可以指定一个级别或级别列表。如果为None，则重置所有级别。
drop=False	布尔值，默认为False。如果为True，则重置索引后，原始索引将不会作为列添加到DataFrame中。如果为False，则原始索引将作为新列添加到 DataFrame中。
inplace=False	布尔值，默认为False。如果为True，则直接在原始 DataFrame上进行操作，不返回新的DataFrame。
col_level=0	如果原始索引是多级索引，则指定新列的索引级别。
col_fill=''	如果原始索引是多级索引，并且多，则使用此值填充缺失的级别。
allow_duplicates=_NoDefault.no_default	允许索引列中出现重复值。如果设置为False，则在尝试插入重复列时会引发ValueError。
names=None	列表或元组，用于为新列指定名称。默认情况下，如果drop为Flase，则使用原始索引的名称。

python">import pandas as pd# 创建两个列表，它们将用作多级索引的级别
arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],  # 第一级索引的值['Captive', 'Wild', 'Captive', 'Wild']]   # 第二级索引的值# 使用arrays列表创建一个DataFrame，'Max Speed'列包含对应于多级索引的数据
df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},  # 数据index=arrays)  # 使用arrays列表作为多级索引print(df)
# 重置所有索引级别，并将它们作为列添加到DataFrame中
df_reset = df.reset_index()
print(df_reset)# 只重置第二级索引，并将它作为列添加到DataFrame中
df_reset_level_1 = df.reset_index(level=1)
print(df_reset_level_1)# 重置所有索引级别，但不将它们作为列添加到DataFrame中
df_reset_drop = df.reset_index(drop=True)
print(df_reset_drop)

python">                Max Speed
Falcon Captive      390.0Wild         350.0
Parrot Captive       30.0Wild          20.0level_0  level_1  Max Speed
0  Falcon  Captive      390.0
1  Falcon     Wild      350.0
2  Parrot  Captive       30.0
3  Parrot     Wild       20.0level_1  Max Speed
Falcon  Captive      390.0
Falcon     Wild      350.0
Parrot  Captive       30.0
Parrot     Wild       20.0Max Speed
0      390.0
1      350.0
2       30.0
3       20.0

2.6、 info

用于显示DataFrame的概要信息的一个便捷方法，它提供了关于DataFrame的列、非空值数量、数据类型以及内存使用情况的信息。

python">DataFrame.info(verbose=None, buf=None, max_cols=None, memory_usage=None, show_counts=None)

描述	说明
verbose=None	控制输出信息的详细程度。
buf=None	一个打开的文件对象或类似文件的对象。如果提供，则输出将被写入这个缓冲区而不是标准输出。
max_cols=None	要显示的最大列数。如果DataFrame的列数超过这个值，则只会显示部分列的信息。
memory_usage=None	控制是否显示内存使用情况。可以设置为True或False，或者是一个字符串，'deep’表示深度计算内存使用情况，考虑对象内部数据。
show_counts=None	控制是否显示非空值的数量。如果设置为True，则会在每个列旁边显示非空值的数量。

python">import pandas as pd# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 3, None],'B': ['a', 'b', 'c', 'd'],'C': [1.1, 2.2, 3.3, 4.4]
})print(df)# 显示DataFrame的概要信息
df.info(verbose=False, memory_usage=True, show_counts=True)

python">     A  B    C
0  1.0  a  1.1
1  2.0  b  2.2
2  3.0  c  3.3
3  NaN  d  4.4
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Columns: 3 entries, A to C
dtypes: float64(2), object(1)
memory usage: 228.0+ bytes

2.7、apply

允许你对DataFrame中的每个元素、行或列应用一个函数。

python">DataFrame.apply(func, axis=0, raw=False, result_type=None, args= (), **kwargs)

描述	说明
func	函数，应用于每个元素、行或列。这个函数需要你自定义，或者使用内置的函数。
axis=0	指定应用函数的轴。
raw=False	布尔值，默认为False，则每行或每列将作为Series使用，如果为 True，则将作为Ndarray数组，性能会更好。
result_type=None	控制返回类型。可以是以下之一： ‘reduce’：如果应用函数返回一个列表，这个列表会被转换成一个 Series。 ‘broadcast’：结果会被广播到原始 DataFrame 的形状，保留原始的索引和列。 ‘expand’：如果应用函数返回一个列表（或类似列表的结构），则这个列表会被转换为多个列。这意味着每个列表元素都会变成 DataFrame 的一列。
args=()	元组，包含传递给函数的位置参数。
**kwargs	关键字参数，将被传递给函数。

python">import pandas as pd# 创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 3],'B': [4, 5, 6],'C': [7, 8, 9]
})print(df)# 定义一个函数，计算每行的平均值
def mean_row(row):return row.mean()# 应用函数到每行
result = df.apply(mean_row, axis=0, result_type='expand')print(result)

python">   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9
A    2.0
B    5.0
C    8.0
dtype: float64