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

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

1.1、 使用列名访问

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

import pandas as pd

data = {
    '姓名': ['小明', '小红', '小刚'],
    '年龄': [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属性访问单个或多个数据，其语法为：

df.loc[row_label, column_label]

import pandas as pd

data = {
    '姓名': ['小明', '小红', '小刚'],
    '年龄': [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属性来访问单个数据。

import pandas as pd

data = {
    '姓名': ['小明', '小红', '小刚'],
    '年龄': [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行。

DataFrame.head(n=None)

| 描述 | 说明 |

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

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行。

DataFrame.tail(n=5)

| 描述 | 说明 |

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

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 中。

DataFrame.isin(values)

| 描述 | 说明 |

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

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 方法提供了一个更安全的方式来处理这种情况，你可以指定一个默认值， 而不是引发一个错误。

DataFrame.get(key, default=None)

| 描述 | 说明 |
| key | 想获取的列的名称。 |

default	如果列不存在时返回的默认值。None

import pandas as pd
 
data = {
    '姓名': ['小明', '小红', '小刚'],
    '年龄': [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中唯一值的数量。

DataFrame.nunique(axis=0, dropna=True)

| 描述 | 说明 |
| axis=0 | 默认值，表示按列进行操作。如果设置为 axis=1，则表示按行进行操作 |

dropna=True	默认值，表示在计算唯一值之前先排除掉缺失值（NaN）。如果 设置为 False，则缺失值也会被计算在内。

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)

   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中各个值出现的频率的一个方法。

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，则在计数之前排除缺失 值。

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)

   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：最大值

DataFrame.describe(percentiles=None, include=None, exclude=None)

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

exclude=None	一个列表形式的字符串或字符串序列，用于指定要从描述统计 中排除的数据类型。

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)

   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  baz
              A          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的一个副本。

DataFrame.copy(deep=True)

| 描述 | 说明 |

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

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)

Original DataFrame:
   A    B
0  1  888
1  2    5
2  3    6

Deep Copy:
     A  B
0  999  4
1    2  5
2    3  6

Shallow Copy:
   A    B
0  1  888
1  2    5
2  3    6

2.5 、reset index

用于重置DataFrame的索引。

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，则使用原始索引的名称。

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)

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

2.6、 info

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

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，则会在每 个列旁边显示非空值的数量。

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)

     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中的每个元素、行或列应用一个函数。

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	关键字参数，将被传递给函数。

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)

   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