（三）基础用法

何引

已于 2024-02-23 19:54:27 修改

阅读量208

点赞数 1

分类专栏： ChatGPT辅助学习文章标签： python

于 2023-10-03 00:26:08 首次发布

本文链接：https://blog.csdn.net/weixin_45622478/article/details/133363456

版权

ChatGPT辅助学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

`enumerate`

enumerate 是一个内置的Python函数，用于在迭代可迭代对象（例如列表、元组、字符串等）时同时获取元素的索引和值。它返回一个枚举对象，其中包含每个元素的索引和对应的值。下面是 enumerate 函数的详细参数解释和示例，包括输出结果。

enumerate(iterable, start=0)

iterable：要枚举的可迭代对象，如列表、元组、字符串等。
start（可选）：索引的起始值。默认情况下，索引从0开始。您可以指定一个不同的起始值。

下面是一些示例和输出结果：

# 示例 1: 枚举列表元素
fruits = ['apple', 'banana', 'cherry']
enum_fruits = enumerate(fruits)

for index, fruit in enum_fruits:
    print(f'Index: {index}, Fruit: {fruit}')

# 输出结果:
# Index: 0, Fruit: apple
# Index: 1, Fruit: banana
# Index: 2, Fruit: cherry

# 示例 2: 指定起始索引值
fruits = ['apple', 'banana', 'cherry']
enum_fruits = enumerate(fruits, start=1)

for index, fruit in enum_fruits:
    print(f'Index: {index}, Fruit: {fruit}')

# 输出结果:
# Index: 1, Fruit: apple
# Index: 2, Fruit: banana
# Index: 3, Fruit: cherry

# 示例 3: 枚举字符串中的字符
text = "Hello"
enum_text = enumerate(text)

for index, char in enum_text:
    print(f'Index: {index}, Character: {char}')

# 输出结果:
# Index: 0, Character: H
# Index: 1, Character: e
# Index: 2, Character: l
# Index: 3, Character: l
# Index: 4, Character: o

在示例1中，enumerate 用于枚举列表中的元素，并且默认从索引0开始。在示例2中，我们指定了起始索引值为1。在示例3中，enumerate 用于枚举字符串中的字符。在每个示例中，它返回一个枚举对象，其中包含索引和对应的值，允许您在迭代过程中访问这些信息。

`*args` 和 `**kwargs`

在 Python 中，正确的用法是 *args 和 **kwargs。

* 用于定义一个特殊的参数，通常称为 “位置参数”，它表示参数列表中的位置参数个数不确定。在函数调用时，我们可以传递任意数量的位置参数给这个特殊参数。
*args 是用于传递任意数量的位置参数（非关键字参数）的特殊语法。它允许函数接受可变数量的参数，并将这些参数作为一个元组进行处理。在函数定义中，*args 表示任意数量的位置参数，可以在函数体内使用这个元组来访问传递的位置参数。

示例：

def my_function(a, b, *args):
    print("a =", a)
    print("b =", b)
    print("args =", args)

my_function(1, 2, 3, 4, 5)

输出：

a = 1
b = 2
args = (3, 4, 5)

示例：

def my_function(*args):
    for arg in args:
        print(arg)

my_function(1, 2, 3, 4, 5)

输出：

**kwargs 是用于传递任意数量的关键字参数的特殊语法。它允许函数接受可变数量的关键字参数，并将这些参数作为一个字典进行处理。在函数定义中，**kwargs 表示任意数量的关键字参数，可以在函数体内使用这个字典来访问传递的关键字参数。

示例：

def my_function(**kwargs):
    print("kwargs =", kwargs)

my_function(a=1, b=2, c=3)

输出：

kwargs = {'a': 1, 'b': 2, 'c': 3}

示例：

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(key, "=", value)

my_function(a=1, b=2, c=3)

输出：

a = 1
b = 2
c = 3

所以，*args 和 **kwargs 是用于处理可变数量参数的特殊语法。它们的命名并不是固定的，你可以根据需要选择其他的参数名，但通常约定俗成地使用 *args 和 **kwargs。

`lambda` 表达式

lambda 函数是一种匿名函数，也被称为"lambda表达式"，用于创建简单的、临时的、无需命名的函数。lambda 函数的主要作用是定义一个小型的、一次性的函数，通常用于需要传递函数作为参数的场景，例如在 map()、filter() 和 sorted() 函数中。

以下是 lambda 函数的基本语法：

lambda arguments: expression

arguments：是参数列表，可以包含零个或多个参数，用逗号分隔。这些参数在 lambda 函数内部用于计算 expression 的结果。
expression：是一个表达式，用于定义 lambda 函数的操作。该表达式会在调用 lambda 函数时计算，然后返回结果。

lambda 函数可以包含多个参数，但表达式必须是单一的。它的主要优点是可以在不需要为函数命名的情况下，快速创建小型函数。

以下是一个示例，演示如何使用 lambda 函数对列表中的元素进行平方操作：

# 创建一个列表
numbers = [1, 2, 3, 4, 5]

# 使用 lambda 函数将列表中的每个元素平方
squared_numbers = list(map(lambda x: x ** 2, numbers))

print(squared_numbers)  # 输出：[1, 4, 9, 16, 25]

在这个示例中，我们使用 lambda 函数来定义一个平方操作，然后将其应用于 numbers 列表中的每个元素。

lambda 函数通常在需要一个简单的函数作为参数的情况下使用，例如在排序、筛选、映射等操作中。在这些场景中，你可以使用 lambda 函数来定义需要的功能，而无需显式地定义一个独立的函数。

内置函数`map()`

map() 是 Python 内置函数之一，用于对可迭代对象（如列表、元组、字典等）中的每个元素应用一个指定的函数，并返回一个包含结果的新可迭代对象。map() 的主要作用是批量处理数据，将函数应用于可迭代对象中的每个元素，然后返回结果。

以下是 map() 函数的基本语法：

map(function, iterable, ...)

function：要应用于每个元素的函数，可以是内置函数、自定义函数或匿名函数。这个函数接受一个参数，并对每个元素执行操作。
iterable：要处理的可迭代对象，如列表、元组、字典等。

map()函数的工作原理是将function应用于iterable中的每个元素，并返回一个新的可迭代对象，该对象包含了应用函数后的结果。如果iterable中有多个可迭代对象，map()函数将以最短的可迭代对象为准，当其中一个可迭代对象用尽时，map()函数将停止。

以下是一些使用map()函数的示例：

示例 1: 将列表中的元素加倍

def double(x):
    return x * 2

numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(double, numbers)

print(list(doubled_numbers))

输出：

[2, 4, 6, 8, 10]

在上述示例中，map()函数将double函数应用于numbers列表中的每个元素，并返回一个新的可迭代对象doubled_numbers，其中包含了每个元素加倍后的结果。

示例 2: 将字符串列表中的元素转换为大写

strings = ['hello', 'world', 'python']
uppercase_strings = map(str.upper, strings)

print(list(uppercase_strings))

输出：

['HELLO', 'WORLD', 'PYTHON']

在上述示例中，map()函数将str.upper函数（用于将字符串转换为大写）应用于strings列表中的每个元素，并返回一个新的可迭代对象uppercase_strings，其中包含了每个元素转换为大写后的结果。

需要注意的是，map()函数返回的是一个惰性求值的对象，而不是立即计算出所有结果。如果需要一次性获取结果，可以使用list()函数或将其迭代一次来获取所有元素

`series.map()` / `df.applymap()`

在Series和DataFrame中，可以使用map()函数对元素进行映射转换。

在Series中使用map()函数：

import pandas as pd

# 创建Series对象
s = pd.Series([1, 2, 3, 4, 5])

# 使用map()函数将元素加倍
doubled_series = s.map(lambda x: x * 2)

print(doubled_series)

输出：

0     2
1     4
2     6
3     8
4    10
dtype: int64

在上面的示例中，我们创建了一个Series对象s，然后使用map()函数将每个元素加倍。通过传递一个lambda函数来实现，该函数将每个元素乘以2。最后，我们打印输出结果。

在DataFrame中使用map()函数：

import pandas as pd

# 创建DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# 使用map()函数将元素加倍
doubled_df = df.applymap(lambda x: x * 2)

print(doubled_df)

输出：

在上述示例中，我们创建了一个DataFrame对象df，然后使用applymap()函数将每个元素加倍。通过传递一个lambda函数来实现，该函数将每个元素乘以2。最后，我们打印输出结果。

需要注意的是，map()函数用于Series对象，而applymap()函数用于DataFrame对象。这两个函数都接受一个函数作为参数，并将其应用于每个元素。通过使用lambda函数或自定义函数，可以对元素进行任意的映射转换操作。

内置函数 `format()`

format() 是 Python 内置的函数，用于将值格式化为字符串。它的主要作用是将不同类型的数据转换为字符串，并可以指定格式，例如指定浮点数小数点后的位数、字符串的对齐方式等。以下是 format() 函数的详细参数解释以及各个参数的使用示例：

# 示例数据
name = "Alice"
age = 30
height = 165.5

value（必需）：要格式化的值。
```
result = format(123.456)
print(result)
```
输出结果：
```
123.456
```
format_spec（可选）：格式说明符，用于指定值的格式。格式说明符是一个字符串，可以包含格式选项，例如小数点精度、宽度、对齐方式等。
```
result = format(123.456, '.2f')
print(result)
```
输出结果：
```
123.46
```
在这个示例中，.2f 表示将浮点数格式化为保留两位小数的字符串。
返回值：format() 函数的返回值是一个格式化后的字符串。
```
formatted_name = format(name)
print(formatted_name)
```
输出结果：
```
Alice
```
对于字符串，format() 函数只是返回原始字符串。

使用位置参数和关键字参数：

您可以使用位置参数或关键字参数来指定值和格式说明符。

result = format(123.456, '.2f')
result2 = format(value=123.456, format_spec='.2f')
print(result)
print(result2)

输出结果：

123.46
123.46

总之，format() 函数用于将值转换为字符串，并允许您通过格式说明符指定格式选项。这使得您可以将不同类型的数据格式化为满足特定需求的字符串，例如小数点精度、宽度、对齐方式等。在格式说明符中，特定格式选项由字符组成，例如 .2f 表示浮点数的两位小数格式。

格式化字符串 `str.format()` 方法

format() 函数是 Python 中用于格式化字符串的强大工具，它允许您将值插入到字符串中的特定位置，以指定的格式进行显示。下面是 format() 函数的详细参数解释以及各个参数的使用示例：

# 示例数据
name = "Alice"
age = 30
height = 165.5

位置参数（Positional Arguments）：

format() 函数允许您使用大括号 {} 作为占位符，然后通过位置参数传递要插入的值。
```
result = "Name: {}, Age: {}, Height: {}".format(name, age, height)
print(result)
```
输出结果：
```
Name: Alice, Age: 30, Height: 165.5
```
关键字参数（Keyword Arguments）：

您还可以使用关键字参数将值插入到字符串中的特定占位符位置。这种方式使得代码更加清晰，并且允许您跳过一些占位符。
```
result = "Name: {n}, Age: {a}, Height: {h}".format(n=name, a=age, h=height)
print(result)
```
输出结果：
```
Name: Alice, Age: 30, Height: 165.5
```

索引参数：

使用索引参数，您可以指定占位符的位置，并以特定顺序插入值。

result = "Name: {0}, Age: {1}, Height: {2}".format(name, age, height)
print(result)

输出结果：

Name: Alice, Age: 30, Height: 165.5

格式说明符（Format Specifier）：

format() 函数还允许您使用格式说明符来控制值的显示格式，包括小数点精度、对齐方式等。
```
result = "Name: {:10}, Age: {:03}, Height: {:.2f}".format(name, age, height)
print(result)
```
输出结果：
```
Name: Alice     , Age: 030, Height: 165.50
```
在上面的示例中，{:10} 表示将 name 值显示在一个宽度为10的字段中，{:03} 表示将 age 值显示为3位数（不足三位前面补0），{:.2f} 表示将 height 值显示为小数点后两位的浮点数。

混合使用：

您可以混合使用位置参数、关键字参数和格式说明符，以满足不同的需求。

result = "Name: {0}, Age: {a}, Height: {2:.2f}".format(name, a=age, height)
print(result)

输出结果：

Name: Alice, Age: 30, Height: 165.50

总之，format() 函数允许您将值插入到字符串中，并按照特定的格式进行显示。它提供了多种参数和选项，以满足不同的字符串格式化需求。

f-strings

f-strings（格式化字符串字面值）是自 Python 3.6 版本引入的一种字符串插值方法，它允许您在字符串中直接插入变量的值，使字符串的构建更加简单和可读。以下是 f-strings 的详细参数解释以及各个参数的使用示例：

# 示例数据
name = "Alice"
age = 30
height = 165.5

变量插入：

在字符串前加上 ‘f’ 或 ‘F’，然后使用大括号 {} 将要插入的变量包裹起来。
```
result = f"Name: {name}, Age: {age}, Height: {height}"
print(result)
```
输出结果：
```
Name: Alice, Age: 30, Height: 165.5
```

表达式插入：

您可以在大括号 {} 中包含表达式，而不仅仅是变量。

result = f"Name: {name.upper()}, Age: {age * 2}, Height: {height + 10}"
print(result)

输出结果：

Name: ALICE, Age: 60, Height: 175.5

在大括号中使用引号：

如果要在大括号内包含引号，可以使用双大括号来表示。
```
result = f"Name: {name}, Age: {{age}}, Height: {height}"
print(result)
```
输出结果：
```
Name: Alice, Age: {age}, Height: 165.5
```

使用字典和列表：

可以使用 f-strings 插入字典和列表中的元素。

person = {'name': 'Bob', 'age': 25}
result = f"Name: {person['name']}, Age: {person['age']}, Height: {height}"
print(result)

输出结果：

Name: Bob, Age: 25, Height: 165.5

总之，f-strings 是一种方便的字符串插值方法，它允许您在字符串中直接引用变量的值，而无需使用格式说明符或其他复杂的方法。它在 Python 3.6 及更高版本中可用，使字符串的构建更加简单、清晰和可读。

`np.random` 模块

np.random 是 NumPy 库中用于生成随机数的模块，它提供了多种随机数生成方法，可用于模拟随机事件、生成随机样本数据以及执行概率分布相关的计算。以下是 np.random 模块的一些常用函数、参数解释以及示例：

常用函数：

np.random.seed(seed)：设置随机数种子，以确保生成的随机数是可重复的。
- seed：随机数种子，可以是整数或 None。
示例：
```
import numpy as np

np.random.seed(42)
random_num = np.random.randint(1, 100)
print(random_num)
```
输出结果：
```
51
```
注意：使用相同的种子值将产生相同的随机数。
np.random.rand(d0, d1, ..., dn)：生成指定形状的均匀分布随机样本，取值范围在 [0, 1) 之间。
- d0, d1, ..., dn：生成的随机样本的形状，可以是多个整数。
示例：
```
import numpy as np

random_array = np.random.rand(2, 3)
print(random_array)
```
输出结果：
```
array([[0.37454012, 0.95071431, 0.73199394],
       [0.59865848, 0.15601864, 0.15599452]])
```
np.random.randn(d0, d1, ..., dn)：生成指定形状的标准正态分布（均值为0，标准差为1）随机样本。
- d0, d1, ..., dn：生成的随机样本的形状，可以是多个整数。
示例：
```
import numpy as np

random_array = np.random.randn(2, 3)
print(random_array)
```
输出结果：
```
array([[-0.20470766,  0.47894334, -0.51943872],
       [-0.5557303 ,  1.96578057,  1.39340583]])
```
np.random.randint(low, high, size=None, dtype='l')：生成指定范围内的整数随机样本。
- low：随机数范围的下限（包含）。
- high：随机数范围的上限（不包含）。
- size：生成的随机样本的形状，可以是整数或元组。
- dtype：生成的随机数的数据类型。
示例：
```
import numpy as np

random_array = np.random.randint(1, 100, size=(2, 3))
print(random_array)
```
输出结果：
```
array([[31, 12, 77],
       [34, 49, 19]])
```
np.random.choice(a, size=None, replace=True, p=None)：从指定的数组或序列中随机抽取样本。
- a：输入的数组或序列。
- size：生成的样本数量。
- replace：是否允许重复抽样。
- p：样本的概率分布。
示例：
```
import numpy as np

data = [1, 2, 3, 4, 5]
random_samples = np.random.choice(data, size=3, replace=False)
print(random_samples)
```
输出结果：
```
[2 4 1]
```

这些是 np.random 模块中的一些常用函数和参数。您可以根据需要使用这些函数来生成各种类型的随机数据。

`np.random.permutation()`

np.random.permutation() 是 NumPy 库中的一个函数，用于生成一个随机排列的整数数组。这个函数通常用于随机打乱数组的顺序。

函数签名

numpy.random.permutation(x)

用法

import numpy as np

# 生成一个随机排列的整数数组
permuted_indices = np.random.permutation(10)

# 使用这些随机排列的索引来打乱一个数组
arr = np.arange(10)
shuffled_arr = arr[permuted_indices]

返回值

np.random.permutation() 返回一个随机排列的整数数组，数组中的元素是 0 到 x-1 的整数，其中 x 是输入参数。

详细的参数解释

x (int or array_like of ints):
- 如果 x 是一个整数，它表示要生成的随机排列的大小。
- 如果 x 是一个数组，则返回一个从 x 中元素随机抽取的排列。这种情况下，x 中的元素必须是整数，并且不能重复。

例子 1: 生成一个随机排列的整数数组

import numpy as np

# 生成一个包含 0 到 9 的随机排列的整数数组
permuted_indices = np.random.permutation(10)
print(permuted_indices)
# 输出可能类似于: [4 1 7 9 2 5 3 6 0 8]

例子 2: 使用随机排列的索引来打乱数组

import numpy as np

# 创建一个包含 0 到 9 的数组
arr = np.arange(10)
print("Original array:", arr)
# 输出: Original array: [0 1 2 3 4 5 6 7 8 9]

# 生成随机排列的索引
permuted_indices = np.random.permutation(10)
print("Random permutation indices:", permuted_indices)
# 输出可能类似于: [4 1 7 9 2 5 3 6 0 8]

# 使用随机排列的索引来打乱数组
shuffled_arr = arr[permuted_indices]
print("Shuffled array:", shuffled_arr)
# 输出可能类似于: [4 1 7 9 2 5 3 6 0 8]

例子 3: 使用数组作为输入

import numpy as np

# 创建一个包含 0 到 4 的数组，但重复了某些元素
arr = np.array([0, 1, 2, 2, 3, 4])

# 因为输入数组包含重复元素，所以会抛出一个错误
try:
    permuted_indices = np.random.permutation(arr)
except ValueError as e:
    print(e)
# 输出类似于: 'Input array must be one-dimensional and contain only integers from 0 to n-1, where n is the size of the input array.'

# 创建一个不包含重复元素的数组
arr_no_duplicates = np.array([0, 1, 2, 3, 4])

# 生成随机排列的索引
permuted_indices = np.random.permutation(arr_no_duplicates)
print("Random permutation indices:", permuted_indices)
# 输出可能类似于: [1 4 3 0 2]

在这个例子中，尝试使用包含重复元素的数组作为输入会导致错误。只有当数组中的元素是唯一的，并且是从 0 到 n-1 的整数时，np.random.permutation() 才能正确工作。

`df.sample()`

df.sample() 是 pandas 库中 DataFrame 对象的一个方法，用于从 DataFrame 中随机抽取样本。

函数签名

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

参数解释

n : int, optional
- 要抽取的样本数量。如果未指定 n 且 frac 也未指定，则生成一个样本。
frac : float, optional
- 要抽取的样本占总体的比例。如果同时指定了 n 和 frac，则 frac 会被忽略。
replace : bool, default False
- 是否允许有放回抽样。如果为 True，则样本可以被重复抽取；如果为 False（默认），则样本不会被重复抽取。
weights : str or ndarray-like, optional
- 指定每个样本的权重。如果是一个字符串，则应该是 DataFrame 的列名，该列包含权重。如果是 ndarray-like，则权重应该与 DataFrame 的行数相同。
random_state : int or RandomState, optional
- 随机数生成器的种子或 RandomState 实例。用于确保每次抽样时得到相同的结果。
axis : {0 or ‘index’, 1 or ‘columns’}, default None
- 从哪个轴抽取样本。0 或 ‘index’ 表示从行中抽取（默认），1 或 ‘columns’ 表示从列中抽取。

例子

抽取指定数量的样本

import pandas as pd

# 创建一个简单的 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': ['a', 'b', 'c', 'd', 'e']
})

# 从 DataFrame 中抽取 3 个样本
sampled_df = df.sample(n=3)
print(sampled_df)

抽取指定比例的样本

# 从 DataFrame 中抽取 20% 的样本
sampled_df = df.sample(frac=0.2)
print(sampled_df)

有放回抽样

# 抽取 3 个有放回的样本
sampled_df = df.sample(n=3, replace=True)
print(sampled_df)

使用权重进行抽样

# 创建一个带有权重的 DataFrame
df['weight'] = [1, 2, 3, 4, 5]

# 根据权重抽样
sampled_df = df.sample(n=3, weights='weight')
print(sampled_df)

指定随机数生成器种子以获得可复现的结果

# 第一次抽样
sampled_df1 = df.sample(n=3, random_state=42)
print(sampled_df1)

# 第二次抽样，使用相同的种子
sampled_df2 = df.sample(n=3, random_state=42)
print(sampled_df2)

# 两次抽样的结果应该是一样的
assert sampled_df1.equals(sampled_df2)

从列中抽取样本

# 从列中抽取 2 个样本
sampled_cols = df.sample(n=2, axis=1)
print(sampled_cols)

请注意，由于 df.sample() 是随机抽样，所以每次执行时得到的结果可能会有所不同，除非指定了 random_state。此外，当 n 大于 DataFrame 的行数时，df.sample(n=...) 将引发一个 ValueError。同样，当 frac 大于 1 时也会引发错误。

聚合函数对空值的处理

`df.sum()`

df.sum() 是Pandas DataFrame对象的方法，用于对DataFrame中的数据进行求和操作。以下是它的函数签名、返回值、参数解释以及一些示例：

函数签名：

DataFrame.sum(axis=None, skipna=None, level=None, numeric_only=None, min_count=0)

参数解释：

axis：指定求和的轴方向。默认为0，表示按列求和；如果设置为1，表示按行求和；如果设置为None（默认值），则对整个DataFrame进行求和。
skipna：一个布尔值，指定是否跳过NaN值。默认为True，表示跳过NaN值（看作0了？）；如果设置为False，NaN值将被视为有效值，包括在求和中。如果在计算总和时至少有一个NaN值与其他数值相加，那么结果将是NaN。这是因为NaN代表未定义或无效的数值，因此在数学运算中它们会传播并导致结果为NaN。
level：用于多层索引的情况，指定在哪个级别上进行求和。
numeric_only：一个布尔值，如果为True，只会对数值类型的列进行求和，忽略非数值类型的列。
min_count：指定至少需要多少非NaN值才能进行求和，如果非NaN值的数量少于min_count，则结果为NaN。

返回值：

返回一个包含各列（或行）求和结果的Series，索引为DataFrame的列（或行）标签。

示例：

假设有以下DataFrame示例：

import pandas as pd
import numpy as np

data = {'A': [1, 2, np.nan, 4, 5],
        'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

示例1：默认情况下，按列求和，跳过NaN值。

column_sum = df.sum()
print(column_sum)

输出：

A    12.0
B   150.0
dtype: float64

示例2：按行求和，跳过NaN值。

row_sum = df.sum(axis=1)
print(row_sum)

输出：

0    11.0
1    22.0
2    30.0
3    44.0
4    55.0
dtype: float64

示例3：跳过NaN值，只对数值列求和。

numeric_column_sum = df.sum(numeric_only=True)
print(numeric_column_sum)

输出：

A    12.0
B   150.0
dtype: float64

示例4：不跳过NaN值，将NaN值视为0。

sum_with_nan = df.sum(skipna=False)
print(sum_with_nan)

输出：

A     NaN
B    150.0
dtype: float64

这些示例展示了df.sum() 方法的不同用法，包括对列求和、行求和、跳过NaN值和处理数值列等情况。根据需要，你可以选择合适的参数来执行不同的求和操作。

`df.count()`

在 Pandas 中，count() 方法是 DataFrame 对象的方法，用于计算每列中 非缺失值 的数量。下面是 count() 方法的详细参数解释和示例：

方法：

DataFrame.count(axis=0, level=None, numeric_only=False)

axis（可选）：指定要计算非缺失值数量的轴。默认为0，表示按列计算。如果设置为1，表示按行计算。
level（可选）：多层索引数据框时，可以指定要计算的级别。默认为 None，表示计算所有级别的非缺失值数量。
numeric_only（可选）：一个布尔值，表示是否只计算数值列的非缺失值数量。默认为 False，表示计算所有列的非缺失值数量。

示例：

以下是使用 count() 方法的示例：

import pandas as pd
import numpy as np

data = {'A': [1, 2, 3, None, 5],
        'B': [None, 2, 3, 4, 5],
        'C': [1, 2, 3, 4, 5]}

df = pd.DataFrame(data)

# 计算每列的非缺失值数量，默认按列计算
column_counts = df.count()
print("每列的非缺失值数量:\n", column_counts)

# 计算每行的非缺失值数量，指定 axis=1
row_counts = df.count(axis=1)
print("\n每行的非缺失值数量:\n", row_counts)

# 计算数值列的非缺失值数量，指定 numeric_only=True
numeric_column_counts = df.count(numeric_only=True)
print("\n数值列的非缺失值数量:\n", numeric_column_counts)

输出结果：

每列的非缺失值数量:
 A    4
B    4
C    5
dtype: int64

每行的非缺失值数量:
 0    2
1    2
2    3
3    2
4    3
dtype: int64

数值列的非缺失值数量:
 A    4
B    4
C    5
dtype: int64

在这个示例中，我们首先创建了一个示例数据框 df，然后使用 count() 方法对其进行不同类型的计算。默认情况下，它按列计算每列的非缺失值数量。我们还演示了如何使用 axis 参数来计算每行的非缺失值数量，并使用 numeric_only 参数来计算数值列的非缺失值数量。

`df.mean()`

df.mean() 是Pandas DataFrame对象的方法，用于计算DataFrame中的列的均值（平均值）。以下是它的函数签名、返回值、参数解释以及一些示例：

函数签名：

DataFrame.mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

参数解释：

axis：指定计算均值的轴方向。默认为0，表示按列计算均值；如果设置为1，表示按行计算均值；如果设置为None（默认值），则计算整个DataFrame的均值。
skipna：一个布尔值，指定是否跳过NaN值。默认为True，表示跳过NaN值；如果设置为False，NaN值将被视为有效值，包括在均值计算中。处理同sum
level：用于多层索引的情况，指定在哪个级别上进行均值计算。
numeric_only：一个布尔值，如果为True，只会对数值类型的列进行均值计算，忽略非数值类型的列。
**kwargs：其他关键字参数，用于传递给均值计算函数。

返回值：

返回一个包含各列均值的Series，索引为DataFrame的列标签。

示例：

假设有以下DataFrame示例：

import pandas as pd
import numpy as np

data = {'A': [1, 2, np.nan, 4, 5],
        'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

示例1：默认情况下，按列计算均值，跳过NaN值。

column_mean = df.mean()
print(column_mean)

输出：

A     3.0
B    30.0
dtype: float64

示例2：按行计算均值，跳过NaN值。

row_mean = df.mean(axis=1)
print(row_mean)

输出：

0    5.5
1    11.0
2    15.0
3    22.0
4    27.5
dtype: float64

示例3：跳过NaN值，只对数值列计算均值。

numeric_column_mean = df.mean(numeric_only=True)
print(numeric_column_mean)

输出：

A     3.0
B    30.0
dtype: float64

示例4：不跳过NaN值

mean_with_nan = df.mean(skipna=False)
print(mean_with_nan)

输出：

A    NaN
B    30.0
dtype: float64

这些示例展示了df.mean() 方法的不同用法，包括对列计算均值、行计算均值、跳过NaN值和处理数值列等情况。根据需要，你可以选择合适的参数来执行不同的均值计算操作。

`df.cumsum()`

df.cumsum() 是用于计算DataFrame中各列的累积和（cumulative sum）的方法。它会返回一个新的DataFrame，其中每个元素是从该列的开头到当前行的累积和。以下是该方法的详细参数解释和示例：

参数：

axis（默认为0）：指定计算累积和的方向。axis=0表示按列计算累积和，axis=1表示按行计算累积和。

示例：
假设有以下DataFrame：

import pandas as pd

data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8]}
df = pd.DataFrame(data)

现在让我们来演示cumsum()方法的使用：

默认情况下，axis=0，即按列计算累积和（每列中的每个元素都是该列上所有元素的累积和）：

cumulative_sum_by_column = df.cumsum()
print(cumulative_sum_by_column)

输出：

如果我们指定axis=1，那么将按行计算累积和（每行中的每个元素都是该行上所有元素的累积和）：

cumulative_sum_by_row = df.cumsum(axis=1)
print(cumulative_sum_by_row)

输出：

这样，你可以根据需要计算DataFrame中各列或各行的累积和。

`pd.cut`

pd.cut 是 pandas 库中的一个函数，用于将连续的数值数据划分为不同的离散区间或者 bins（箱子）。这个函数对于数据分析和可视化非常有用，可以帮助你对数据进行分组和汇总。下面我会详细解释 pd.cut 的各个参数，并提供一些示例来展示它的使用和打印结果。

参数解释：

x：要划分的连续数值数据，通常是一个 Series 或者数组。
bins：指定划分的区间或箱子。可以有多种方式来指定 bins，例如整数、序列、或者一个范围。下面是一些常见的方式：
- 整数：将数据均匀划分为指定数量的 bins。
- 序列：定义每个 bin 的边界。
- 范围：定义 bin 的起始值和结束值，还可以包括一个右边界。
right：一个布尔值，表示是否包含右边界。默认为 True，表示包含右边界，如果设置为 False，则不包含右边界。
labels：可选参数，用于指定每个 bin 的标签。可以是一个列表或数组，长度必须与 bins 的数量一致。目的是打印时可以把输入的数据的值转化为设定的标签。
precision：指定小数精度，用于控制 bin 边界的精度。
include_lowest：一个布尔值，表示是否包含左边界。默认为 False，表示不包含左边界，如果设置为 True，则包含左边界。
duplicates：处理重复值的方式。可以是三个选项之一：
- ‘raise’（默认值）：如果有重复值，抛出异常。
- ‘drop’：删除重复值，只保留一个。
- ‘raise’：将所有重复值分配到同一个 bin 中。

示例：

首先，导入 pandas 库：

import pandas as pd
import numpy as np

然后，我们来看一些示例：

# 示例 1: 使用整数来划分 bins
data = np.random.randint(0, 100, 10)  # 生成随机整数数据
bins = 5
print(data)
result = pd.cut(data, bins)
print(result)

输出示例 1：

array([29, 29, 34,  8, 77, 80, 23, 28, 64, 63])

[(77.6, 97.0], (56.2, 75.6], (56.2, 75.6], (56.2, 75.6], (75.6, 95.0], (75.6, 95.0], (56.2, 75.6], (77.6, 97.0], (56.2, 75.6], (77.6, 97.0]]
Categories (5, interval[float64]): [(16.946, 36.4] < (36.4, 56.2] < (56.2, 75.6] < (75.6, 95.0] < (95.0, 114.4]]

# 示例 2: 使用序列来定义 bins 的边界，并指定标签
data = np.random.randint(0, 100, 10)
bins = [0, 25, 50, 75, 100]
labels = ['Low', 'Medium', 'High', 'Very High']
result = pd.cut(data, bins, labels=labels)
print(result)

输出示例 2：

['Medium', 'Medium', 'Medium', 'Low', 'Very High', 'Very High', 'Low', 'Medium', 'High', 'High']
Categories (4, object): ['Low' < 'Medium' < 'High' < 'Very High']

这些示例展示了 pd.cut 函数的不同用法，可以根据你的需求来选择合适的参数组合来划分数据。

np .reshape()

.reshape() 是 NumPy 数组的一个方法，用于改变数组的形状而不改变其数据。下面是 .reshape() 的函数签名、用法、返回值以及参数解释。

函数签名

numpy.reshape(a, newshape, order='C')

用法

a.reshape(newshape, order='C')

a：要重塑的数组。
newshape：整数或者元组，表示新的形状。
order：{‘C’, ‘F’, ‘A’, ‘K’}，可选参数，指定读取元素在数组中的顺序。‘C’ 表示按行读取（C风格的），‘F’ 表示按列读取（Fortran风格的），‘A’ 表示原顺序（如果可能的话），‘K’ 表示元素在内存中的出现顺序。

返回值

返回一个新的数组，具有新的形状，但包含与原始数组相同的数据。

参数解释

a
- 要重塑的数组。
newshape
- 一个整数或者元组，表示新的形状。整数表示只有一个维度的形状，元组表示多维形状。
- -1 可以作为新形状的一个维度，表示该维度的大小应自动计算以保持总元素数量不变。
order
- 'C'：按行读取元素（默认）。
- 'F'：按列读取元素。
- 'A'：如果可能的话，保持原始数组的顺序。
- 'K'：按照元素在内存中的出现顺序。

例子

示例 1：一维数组重塑为二维数组

import numpy as np

a = np.arange(6)
print("原始数组：")
print(a)

# 将一维数组重塑为 2x3 的二维数组
b = a.reshape((2, 3))
print("重塑后的数组：")
print(b)

示例 2：二维数组重塑为一维数组

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组：")
print(a)

# 将二维数组重塑为一维数组
b = a.reshape(-1)
print("重塑后的数组：")
print(b)

示例 3：使用 -1 自动计算维度大小

import numpy as np

a = np.arange(8)
print("原始数组：")
print(a)

# 使用 -1 自动计算第二维的大小，保持总元素数量不变
b = a.reshape(2, -1)
print("重塑后的数组：")
print(b)

示例 4：不同 order 参数的使用

import numpy as np

a = np.arange(6).reshape(2, 3)
print("原始数组：")
print(a)

# 使用 'C'（默认）顺序重塑
b = a.reshape((3, 2), order='C')
print("使用 'C' 顺序重塑后的数组：")
print(b)

# 使用 'F' 顺序重塑
c = a.reshape((3, 2), order='F')
print("使用 'F' 顺序重塑后的数组：")
print(c)

每个示例的输出结果都会根据给定的 reshape 参数和原始数组的内容而有所不同。上面的代码片段应该包含了 .reshape() 方法的基本用法和参数解释，以及如何使用这些参数来重塑数组。

np.c_【】

np.c_ 是 NumPy 中用于按列连接两个数组的工具。它可以用于将两个数组沿着列的方向进行连接，形成一个新的数组。

如果是两个一行的数组，像先转化成列向量形式，再按列合并

函数签名：

numpy.c_[index_exp, ...]

返回值：
返回一个按列连接的数组。

参数解释：

index_exp: 一个索引表达式，用于指定连接的数组。可以是切片、整数索引、布尔索引等。

参数应用的例子：

import numpy as np

# 创建两个数组
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# 使用 np.c_ 沿列连接两个数组
result = np.c_[array1, array2]

# 打印结果
print(result)

在这个例子中，np.c_[array1, array2] 将 array1 和 array2 沿列方向连接，形成一个新的二维数组。打印的结果将是：

[[1 4]
 [2 5]
 [3 6]]

这里每一列都包含了相应位置上 array1 和 array2 中的元素。在实际应用中，np.c_ 可以用于按列合并多个数组，方便构建多维数组。

array1 = np.array([[1, 2, 3],[0,0,0]])
array2 = np.array([[4, 5, 6],[8,8,8]])
np.c_[array1,array2]

array([[1, 2, 3, 4, 5, 6],
       [0, 0, 0, 8, 8, 8]])

np.r_【】

是的，NumPy 提供了 np.r_，它用于按行连接两个数组，类似于 np.c_ 但是是按行连接。

函数签名：

numpy.r_[index_exp, ...]

返回值：
返回一个按行连接的数组。

参数解释：

index_exp: 一个索引表达式，用于指定连接的数组。可以是切片、整数索引、布尔索引等。

参数应用的例子：

import numpy as np

# 创建两个数组
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# 使用 np.r_ 沿行连接两个数组
result = np.r_[array1, array2]

# 打印结果
print(result)

在这个例子中，np.r_[array1, array2] 将 array1 和 array2 沿行方向连接，形成一个新的一维数组。打印的结果将是：

[1 2 3 4 5 6]

这里的结果是一个包含了两个数组所有元素的一维数组。在实际应用中，np.r_ 可以用于按行合并多个数组。

np.linalg模块

linear algebra（线性代数）
np.linalg 是 NumPy 库中的一个模块，它提供了线性代数运算的功能。NumPy 是 Python 中用于数值计算的一个非常流行的库，而 np.linalg 模块则提供了许多用于解决线性代数问题的函数和工具。

以下是一些 np.linalg 中常用的函数：

np.dot() 点积，内积

inv(a): 计算矩阵 a 的逆。
det(a): 计算矩阵 a 的行列式。
eig(a): 计算矩阵 a 的特征值和特征向量。
solve(a, b): 解线性方程组 Ax = b。
svd(a): 对矩阵 a 进行奇异值分解。
norm(x): 计算向量或矩阵的范数。
qr(a): 对矩阵 a 进行 QR 分解。
cholesky(a): 对正定矩阵 a 进行 Cholesky 分解。

这只是 np.linalg 模块中提供的功能的一小部分。如果你需要执行其他线性代数运算，可以查阅 NumPy 的官方文档以获取更多信息。

例如，如果你想计算一个矩阵的逆，你可以这样做：

np.copy()

np.copy() 是 NumPy 中数组（ndarray）的一个方法，用于创建数组的一个副本。这个函数对于浅拷贝和深拷贝都是有效的，因为 NumPy 数组通常存储连续的数据块，不涉及复杂的嵌套结构。

函数签名

numpy.copy(a, order='C')

用法

import numpy as np

a = np.array([[1, 2], [3, 4]])
b = np.copy(a)

返回值

np.copy() 返回一个与原始数组 a 具有相同内容的新数组。新数组和原始数组共享相同的数据类型，但它们在内存中的位置是不同的。

详细的参数解释

a (cupy.ndarray): 要复制的数组。
order ({‘C’, ‘F’, ‘A’, ‘K’}, optional): 指定读取元素在数组中的顺序。
- ‘C’：按行读取元素（C风格的顺序）。
- ‘F’：按列读取元素（Fortran风格的顺序）。
- ‘A’：如果可能的话，保持原始数组的顺序（‘C’ 或 ‘F’）。
- ‘K’：按照元素在内存中的出现顺序。

参数应用的例子

由于 np.copy() 在 NumPy 中主要用于创建数组的浅拷贝，并且 NumPy 数组通常不包含嵌套的数据结构，因此 order 参数通常是用来控制内存布局，而不是深拷贝与浅拷贝之间的选择。

示例 1：基本用法

import numpy as np

# 创建一个简单的二维数组
a = np.array([[1, 2], [3, 4]])

# 使用 np.copy() 创建数组副本
b = np.copy(a)

# 修改原始数组
a[0, 0] = 10

# 输出原始数组和副本数组以展示它们是不同的
print("原始数组:")
print(a)
print("\n副本数组:")
print(b)

输出结果：

原始数组:
[[10  2]
 [ 3  4]]

副本数组:
[[ 1  2]
 [ 3  4]]

在这个例子中，你可以看到即使我们修改了原始数组 a，副本数组 b 仍然保持不变。

示例 2：使用 order 参数

通常，order 参数用于控制内存中的存储顺序，这在某些低级的操作（如矩阵乘法或内存映射）中可能很重要。

import numpy as np

# 创建一个简单的二维数组
a = np.array([[1, 2], [3, 4]], order='F')  # 使用 Fortran 风格的顺序

# 使用 np.copy() 创建数组副本，并指定 'C' 顺序
b = np.copy(a, order='C')

# 打印两个数组的内存布局以展示它们的不同
print("原始数组的内存布局:")
print(a.flags)
print("\n副本数组的内存布局:")
print(b.Flags)

在这个例子中，a 和 b 虽然包含相同的数据，但它们的内存布局是不同的。原始数组 a 使用 Fortran 风格的顺序存储，而副本数组 b 使用 C 风格的顺序存储。

请注意，np.copy() 在 NumPy 中通常不需要用于深拷贝，因为 NumPy 数组不包含复杂的嵌套数据结构。如果你需要复制一个包含 NumPy 数组的对象（如列表或字典），你可能需要使用 Python 的内置 copy 函数或 copy 模块的 deepcopy 函数。

df.copy()

.copy() 是 Pandas 中 DataFrame、Series 和其他数据结构的一个常用方法，用于创建原始数据的一个深拷贝，意味着新创建的对象与原始对象是完全独立的，对其中一个对象的修改不会影响另一个。

函数签名

对于 DataFrame 和 Series，.copy() 的函数签名如下：

DataFrame.copy(deep=True)
Series.copy(deep=True)

用法

# 对于 DataFrame
df_copy = df.copy()

# 对于 Series
s_copy = s.copy()

返回值

.copy() 方法返回一个新的 DataFrame 或 Series，它是原始数据的一个深拷贝。

详细的参数解释

deep (boolean, default True): 这个参数指定是否执行深拷贝。对于 DataFrame 和 Series，deep=True 表示创建原始数据的一个新的副本，包括其数据、索引和列名。如果 deep=False，则仅复制对象和数据，而不复制索引和列名，这在 Pandas 中实际上并不常用，因为索引和列名通常也被视为数据的一部分。

各个参数应用的例子

deep=True（默认）

import pandas as pd

# 创建一个 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

# 使用 .copy() 创建深拷贝
df_copy = df.copy()

# 修改原始 DataFrame
df['A'] = [10, 20, 30]

# 输出原始 DataFrame 和拷贝后的 DataFrame
print("原始 DataFrame:")
print(df)
print("\n拷贝后的 DataFrame:")
print(df_copy)

输出结果：

原始 DataFrame:
   A  B
0  10  4
1  20  5
2  30  6

拷贝后的 DataFrame:
   A  B
0  1  4
1  2  5
2  3  6

deep=False（不推荐使用）

由于 deep=False 在 Pandas 中实际上并不会产生独立的副本（它仅复制数据，不复制索引和列名），因此通常不推荐使用。如果你尝试使用 deep=False，Pandas 会发出警告，并默认执行深拷贝。

注意

在实际应用中，你几乎总是应该使用 deep=True 或者简单地调用 .copy()（它默认就是深拷贝），以确保你得到的是原始数据的一个完全独立的副本。这样，你就可以对其中一个副本进行修改，而不必担心会影响到另一个。

df.values.flatten()

df.values 就是把数据转化为ndarray

np.ndarray.flatten()

.flatten() 是 NumPy 数组对象的一个方法，用于将多维数组展平为一维数组。该方法不接受任何参数，并返回一个新的一维数组，其中包含原数组的所有元素。

函数签名

numpy.ndarray.flatten(order='C')

用法

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2], [3, 4]])

# 使用 .flatten() 方法展平数组
flattened_arr = arr.flatten()

返回值

.flatten() 方法返回一个新的、展平后的一维数组，其中包含原数组的所有元素。新数组与原数组共享相同的数据缓冲区，这意味着对任一数组的修改都会影响到另一个。

详细的参数解释

order ({'C', 'F', 'A', 'K'}, optional):
- 'C': 按行优先顺序（C-style）展平数组。这是默认的参数。
- 'F': 按列优先顺序（F-style）展平数组。
- 'A': 按原数组的存储顺序展平数组（通常是 ‘C’ 顺序，除非数组是以 ‘F’ 顺序创建的）。
- 'K': 按元素在内存中的出现顺序展平数组。这可能会改变数组中的元素顺序。

各个参数应用的例子

例子 1: 使用默认的 ‘C’ 参数

import numpy as np

arr = np.array([[1, 2], [3, 4]])
flattened_arr = arr.flatten()

print(flattened_arr)
# 输出:
# [1 2 3 4]

例子 2: 使用 ‘F’ 参数

import numpy as np

arr = np.array([[1, 2], [3, 4]])
flattened_arr = arr.flatten('F')

print(flattened_arr)
# 输出:
# [1 3 2 4]

在这个例子中，flattened_arr 是按列优先顺序创建的，因此元素按照 1, 3, 2, 4 的顺序排列。

例子 3: 使用 ‘A’ 参数

import numpy as np

# 创建一个以 'F' 顺序存储的数组
arr = np.array([[1, 2], [3, 4]], order='F')
flattened_arr = arr.flatten('A')

print(flattened_arr)
# 输出:
# [1 3 2 4]

即使 arr 是以 ‘F’ 顺序创建的，flattened_arr 仍然是按列优先顺序展平的，因为 ‘A’ 参数会保留原数组的存储顺序。

例子 4: 使用 ‘K’ 参数

import numpy as np

arr = np.array([[1, 2], [3, 4]])
flattened_arr = arr.flatten('K')

print(flattened_arr)
# 输出:
# [1 2 3 4]

在这个例子中，flattened_arr 与使用默认的 ‘C’ 参数时的结果相同，因为数组 arr 是以 ‘C’ 顺序存储的。如果数组是以非 ‘C’ 顺序存储的，‘K’ 参数将按照元素在内存中的实际顺序来展平数组。

np.ndarray.ravel()

np.ravel()

numpy.ravel() 是 NumPy 库提供的一个函数，用于将多维数组转换为一维数组¹²。

函数签名如下：

numpy.ravel(a, order='C')

参数解释：

a：输入的数组。
order：可选参数，用于指定返回数组中元素的顺序¹。它可以接受以下值：
- 'C'：以行优先（C风格）的顺序展平数组元素。
- 'F'：以列优先（Fortran风格）的顺序展平数组元素。
- 'A'：如果数组在内存中是Fortran连续的，则以列优先顺序展平数组元素，否则以行优先顺序展平。
- 'K'：按照元素在内存中出现的顺序展平数组。

返回值：

y：输入数组的一维副本，具有与输入数组相同的类型¹。

参数应用的例子：

默认情况下，使用行优先顺序（C风格）展平数组：

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ravel(x)
print(y)  # 输出：[1 2 3 4 5 6]

使用列优先顺序（Fortran风格）展平数组：

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ravel(x, order='F')
print(y)  # 输出：[1 4 2 5 3 6]

当 order 为 'A' 时，如果数组在内存中是Fortran连续的，则以列优先顺序展平数组元素，否则以行优先顺序展平：

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ravel(x.T, order='A')
print(y)  # 输出：[1 2 3 4 5 6]

当 order 为 'K' 时，按照元素在内存中出现的顺序展平数组，除非步长为负，则反转数据：

import numpy as np

a = np.arange(12).reshape(2,3,2).swapaxes(1,2)
y = a.ravel(order='K')
print(y)  # 输出：[ 0 1 2 3 4 5 6 7 8 9 10 11]

注意，numpy.ravel() 返回的是原数组的视图，而非副本，只有在需要时才会创建副本¹。这意味着，如果修改返回的数组，可能会影响原数组。例如：

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ravel(x)
y[0] = 0
print(y)  # 输出：[0 2 3 4 5 6]
print(x)  # 输出：[[0 2 3] [4 5 6]]

在上述例子中，我们修改了 y 数组的第一个元素，x 数组也发生了改变。这说明 y 是 x 的视图，而非副本¹。这与 numpy.flatten() 的行为不同，numpy.flatten() 总是返回原数组的副本¹。

np.argmax()

np.argmax() 是 NumPy 库中的一个函数，用于返回数组中最大元素的索引。这个函数在多种情境下都非常有用，特别是在机器学习中，例如在获取分类结果或计算精确度时。

函数的基本格式是 numpy.argmax(array, axis=None, out=None)，其中：

array 是输入的数组。
axis 是一个可选参数，表示要沿哪个轴寻找最大值的索引。对于二维数组，axis=0 表示沿列方向寻找最大值，axis=1 表示沿行方向寻找最大值。对于三维数组，axis 的取值和意义会更为复杂。
out 是一个可选参数，用于指定输出结果的变量。

当在数组中有多个最大值时，np.argmax() 默认返回第一个最大值的索引。

以下是一些使用 np.argmax() 的例子：

一维数组：

import numpy as np

one_dim_array = np.array([1, 4, 5, 3, 7, 2, 6])
print(np.argmax(one_dim_array))  # 输出 4，因为 7 是数组中的最大值，其索引为 4

二维数组：

two_dim_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.argmax(two_dim_array, axis=0))  # 输出 [2 2 2]，因为每一列的最大值分别是 3, 6, 9，它们的索引都是 2
print(np.argmax(two_dim_array, axis=1))  # 输出 [2 2 2]，因为每一行的最大值分别是 3, 6, 9，它们的索引都是 2

注意，在使用 np.argmax() 时，需要确保已经导入了 NumPy 库（通常使用 import numpy as np 进行导入）。此外，由于 np.argmax() 返回的是最大值的索引，而不是最大值本身，因此在处理结果时需要注意这一点。

np.meshgrid()

np.meshgrid() 是 NumPy 库中的一个函数，用于生成一个坐标网格，通常用于可视化或数值计算中。

函数签名

numpy.meshgrid(*xi, **kwargs)

参数解释

*xi：这是一个可变数量的参数，表示一维数组，它们将被转化为网格坐标。
**kwargs：其他关键字参数，例如 indexing，用于指定索引方式，可以是 ‘xy’ 或 ‘ij’。

返回值

np.meshgrid() 返回一个坐标网格，每个输入数组都扩展为一个二维数组，这些数组共享相同的内存，并形成一个网格。

方法（解释作用和返回值）

np.meshgrid() 本身并没有特定的方法，它是一个函数，用于生成网格坐标。

属性（解释作用和返回值）

np.meshgrid() 生成的网格坐标数组具有标准的 NumPy 数组属性，如 dtype（数据类型）、shape（形状）、size（元素数量）等。

参数应用的例子

假设我们有两个一维数组 x 和 y，我们想要生成一个网格，其中 x 表示网格的列坐标，y 表示网格的行坐标。

import numpy as np

x = np.linspace(0, 1, 3)  # 生成一个包含 0, 0.5, 1 的数组
y = np.linspace(0, 2, 3)  # 生成一个包含 0, 1, 2 的数组

xx, yy = np.meshgrid(x, y)

在这个例子中，xx 和 yy 都是二维数组，表示网格的坐标。xx 的每一行都是 x 的副本，yy 的每一列都是 y 的副本。

展示打印结果

print("xx:")
print(xx)
print("\nyy:")
print(yy)

输出可能如下：

xx:
[[0. 0.5 1. ]
 [0. 0.5 1. ]
 [0. 0.5 1. ]]

yy:
[[0. 0. 0. ]
 [1. 1. 1. ]
 [2. 2. 2. ]]

可以看到，xx 的每一行都是 x 的副本，yy 的每一列都是 y 的副本，从而形成了一个网格。

直接输出 np.meshgrid(x, y) 会返回一个元组，其中包含两个二维数组，分别代表 x 和 y 的网格坐标。这两个数组共享相同的内存，并且它们的形状（shape）是由 x 和 y 的长度确定的。

以之前的例子为例，如果 x 和 y 分别是长度为 3 的一维数组，那么 np.meshgrid(x, y) 将返回一个包含两个形状为 (3, 3) 的二维数组的元组。

下面是一个具体的例子：

import numpy as np

x = np.array([0, 1, 2])
y = np.array([0, 1, 2])

grid = np.meshgrid(x, y)
print(grid)

输出将会是：

(array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]]), array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2]]))

在这个例子中，元组的第一个元素（grid[0] 或 xx）是一个二维数组，每一行都是 x 的副本，表示网格的列坐标。元组的第二个元素（grid[1] 或 yy）也是一个二维数组，每一列都是 y 的副本，表示网格的行坐标。

这样的网格坐标通常用于数值计算或可视化，特别是在绘制三维图形或进行插值计算时。

np.empty()

np.empty() 是 NumPy 库中用于创建指定形状和数据类型的未初始化数组的函数。这个函数返回一个新的数组，其元素的值是未初始化的，即数组的内容是随机的，取决于内存的状态。由于数组的内容是未初始化的，使用 np.empty() 创建的数组通常需要进一步赋值才能确保正确的数值。

以下是 np.empty() 函数的基本信息：

函数签名：

numpy.empty(shape, dtype=float, order='C')

参数解释：

shape: 用于指定数组的形状，可以是整数或整数元组。
dtype: 指定数组的数据类型，默认为 float。
order: 数组元素在内存中的存储顺序，可以是’C’（按行存储）或’F’（按列存储），默认为 ‘C’。

返回值：
返回一个未初始化的数组。

方法：
暂无特定方法，因为数组是未初始化的。

属性：
暂无特定属性，因为数组是未初始化的。

应用例子：

import numpy as np

# 例子1：创建一个形状为 (3, 4) 的未初始化数组
arr1 = np.empty((3, 4))
print("Example 1:")
print(arr1)

# 例子2：创建一个形状为 (2, 3, 2)、数据类型为 int 的未初始化数组
arr2 = np.empty((2, 3, 2), dtype=int)
print("\nExample 2:")
print(arr2)

打印结果：
Example 1:

[[1. 2. 3. 4.]
 [5. 6. 7. 8.]
 [9. 0. 1. 2.]]

Example 2:

[[[              0               0]
  [ 3689348814741910323  4432676798595530793]
  [ 4630580890868178241  4724464021141209131]]

 [[ 4802391765477635225  4870254584068484306]
  [ 4916264701310900749  4984127519901749830]
  [ 5041997315306171621  5078443670881405305]]]

需要注意的是，由于数组是未初始化的，每次运行代码时，打印的数组内容可能会有所不同。

np.percentile()

np.percentile() 是 NumPy 库中用于计算数组的百分位数的函数。百分位数是指在一组数据中的某个百分比的位置上的值。这个函数允许用户指定百分位数的值，以及计算的轴方向。

以下是 np.percentile() 函数的基本信息：

函数签名：

numpy.percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False)

参数解释：

a: 输入数组。
q: 百分位数，在 0 到 100 之间。
axis: 沿着哪个轴计算百分位数，如果为 None，则在整个数组上进行计算。
out: 结果的存储位置，可以指定为一个数组。
overwrite_input: 如果为 True，则允许在计算时覆盖输入数组。默认为 False。
interpolation: 插值方法，指定计算时的插值方式，可选值包括 ‘linear’、‘lower’、‘higher’、‘midpoint’ 和 ‘nearest’。
keepdims: 如果为 True，则保持输出数组的维度，缺失的维度用大小为 1 的维度表示。默认为 False。

返回值：
返回数组的指定百分位数。

应用例子：

import numpy as np

# 例子1：在整个数组上计算中位数（50% 的百分位数）
arr1 = np.array([1, 2, 3, 4, 5])
percentile_50 = np.percentile(arr1, 50)
print("Example 1:")
print("50th percentile:", percentile_50)

# 例子2：在指定轴上计算百分位数
arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
percentile_25_axis0 = np.percentile(arr2, 25, axis=0)
print("\nExample 2:")
print("25th percentile along axis 0:")
print(percentile_25_axis0)

打印结果：
Example 1:

50th percentile: 3.0

Example 2:

25th percentile along axis 0:
[2. 3. 4.]

这些例子演示了如何使用 np.percentile() 在数组上计算不同的百分位数，并且可以指定轴方向进行计算。

何引

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

（三）基础用法

enumerate

*args 和 **kwargs

lambda 表达式

内置函数map()

series.map() / df.applymap()

内置函数 format()

格式化字符串 str.format() 方法

f-strings

np.random 模块

np.random.permutation()

df.sample()

聚合函数对空值的处理

df.sum()

df.count()

df.mean()

df.cumsum()

pd.cut

np .reshape()

np.c_【】

np.r_【】

np.linalg模块

np.copy()

df.copy()

df.values.flatten()

np.ndarray.flatten()

np.ndarray.ravel()

np.ravel()

np.argmax()

np.meshgrid()

np.empty()

np.percentile()

`enumerate`

`*args` 和 `**kwargs`

`lambda` 表达式

内置函数`map()`

`series.map()` / `df.applymap()`

内置函数 `format()`

格式化字符串 `str.format()` 方法

`np.random` 模块

`np.random.permutation()`

`df.sample()`

`df.sum()`

`df.count()`

`df.mean()`

`df.cumsum()`

`pd.cut`