Pandas 2.2 中文官方教程和指南（九·一）（2）https://developer.aliyun.com/article/1509696
最后，rename()还接受标量或类似列表的值来修改Series.name属性。
In [248]: s.rename("scalar-name") Out[248]: a -0.186646 b -1.692424 c -0.303893 d -1.425662 e 1.114285 Name: scalar-name, dtype: float64
方法DataFrame.rename_axis()和Series.rename_axis()允许更改MultiIndex的特定名称（而不是标签）。
In [249]: df = pd.DataFrame( .....: {"x": [1, 2, 3, 4, 5, 6], "y": [10, 20, 30, 40, 50, 60]}, .....: index=pd.MultiIndex.from_product( .....: [["a", "b", "c"], [1, 2]], names=["let", "num"] .....: ), .....: ) .....: In [250]: df Out[250]: x y let num a 1 1 10 2 2 20 b 1 3 30 2 4 40 c 1 5 50 2 6 60 In [251]: df.rename_axis(index={"let": "abc"}) Out[251]: x y abc num a 1 1 10 2 2 20 b 1 3 30 2 4 40 c 1 5 50 2 6 60 In [252]: df.rename_axis(index=str.upper) Out[252]: x y LET NUM a 1 1 10 2 2 20 b 1 3 30 2 4 40 c 1 5 50 2 6 60 ```## 迭代 pandas 对象的基本迭代行为取决于类型。在 Series 上进行迭代时，它被视为类似数组，基本迭代产生值。DataFrame 遵循字典样式的约定，迭代对象的“键”。 简而言之，基本迭代（`for i in object`）产生： + **Series**: 值 + **DataFrame**: 列标签 因此，例如，迭代 DataFrame 会给出列名： ```py In [253]: df = pd.DataFrame( .....: {"col1": np.random.randn(3), "col2": np.random.randn(3)}, index=["a", "b", "c"] .....: ) .....: In [254]: for col in df: .....: print(col) .....: col1 col2
pandas 对象还具有类似字典的items()方法，用于迭代(key, value)对。
要迭代 DataFrame 的行，您可以使用以下方法：
iterrows()：以(index, Series)对的形式迭代 DataFrame 的行。这将行转换为 Series 对象，可以更改数据类型并具有一些性能影响。itertuples()：以值的 namedtuples 形式迭代 DataFrame 的行。这比iterrows()快得多，并且在大多数情况下更适合用于迭代 DataFrame 的值。
警告
通过 pandas 对象进行迭代通常较慢。在许多情况下，手动迭代行是不必要的，并且可以通过以下方法之一避免：
- 寻找矢量化解决方案：许多操作可以使用内置方法或 NumPy 函数（布尔）索引等进行，…
- 当您有一个无法一次处理完整 DataFrame/Series 的函数时，最好使用
apply()而不是迭代值。请参阅函数应用部分的文档。 - 如果需要对值进行迭代操作但性能很重要，请考虑使用 cython 或 numba 编写内部循环。请参阅提高性能部分，了解一些此方法的示例。
警告
您绝对不应该修改正在迭代的内容。这并不保证在所有情况下都有效。根据数据类型，迭代器返回的是副本而不是视图，对其进行写入将不起作用！
例如，在以下情况中设置值没有效果：
In [255]: df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]}) In [256]: for index, row in df.iterrows(): .....: row["a"] = 10 .....: In [257]: df Out[257]: a b 0 1 a 1 2 b 2 3 c
items
与类似字典的接口一致，items()迭代键值对：
- Series：(索引, 标量值)对
- DataFrame：(列, Series)对
例如：
In [258]: for label, ser in df.items(): .....: print(label) .....: print(ser) .....: a 0 1 1 2 2 3 Name: a, dtype: int64 b 0 a 1 b 2 c Name: b, dtype: object
iterrows
iterrows()允许您以 Series 对象的形式迭代 DataFrame 的行。它返回一个迭代器，产生每个索引值以及包含每行数据的 Series：
In [259]: for row_index, row in df.iterrows(): .....: print(row_index, row, sep="\n") .....: 0 a 1 b a Name: 0, dtype: object 1 a 2 b b Name: 1, dtype: object 2 a 3 b c Name: 2, dtype: object
注意
因为iterrows()为每行返回一个 Series，它不会在行之间保留数据类型（对于数据框的列，数据类型是保留的）。例如，
In [260]: df_orig = pd.DataFrame([[1, 1.5]], columns=["int", "float"]) In [261]: df_orig.dtypes Out[261]: int int64 float float64 dtype: object In [262]: row = next(df_orig.iterrows())[1] In [263]: row Out[263]: int 1.0 float 1.5 Name: 0, dtype: float64
row中的所有值，作为一个 Series 返回，现在都被转换为浮点数，包括列x中的原始整数值：
In [264]: row["int"].dtype Out[264]: dtype('float64') In [265]: df_orig["int"].dtype Out[265]: dtype('int64')
在迭代行时保留数据类型，最好使用itertuples()，它返回值的命名元组，通常比iterrows()快得多。
例如，转置数据框的一种构造性方法可能是：
In [266]: df2 = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]}) In [267]: print(df2) x y 0 1 4 1 2 5 2 3 6 In [268]: print(df2.T) 0 1 2 x 1 2 3 y 4 5 6 In [269]: df2_t = pd.DataFrame({idx: values for idx, values in df2.iterrows()}) In [270]: print(df2_t) 0 1 2 x 1 2 3 y 4 5 6
itertuples
itertuples() 方法将返回一个迭代器，为数据框中的每一行产生一个命名元组。元组的第一个元素将是行对应的索引值，而其余值是行的数值。
例如：
In [271]: for row in df.itertuples(): .....: print(row) .....: Pandas(Index=0, a=1, b='a') Pandas(Index=1, a=2, b='b') Pandas(Index=2, a=3, b='c')
此方法不会将行转换为 Series 对象；它只是返回命名元组中的值。因此，itertuples() 保留值的数据类型，并且通常比iterrows()更快。
注意
如果列名无效的 Python 标识符、重复或以下划线开头，则列名将重命名为位置名称。如果列数较多（>255），则返回常规元组。## .dt 访问器
Series有一个访问器，可以简洁地返回类似日期时间的属性，如果它是一个日期时间/周期类似的 Series。这将返回一个 Series，索引类似于现有的 Series。
# datetime In [272]: s = pd.Series(pd.date_range("20130101 09:10:12", periods=4)) In [273]: s Out[273]: 0 2013-01-01 09:10:12 1 2013-01-02 09:10:12 2 2013-01-03 09:10:12 3 2013-01-04 09:10:12 dtype: datetime64[ns] In [274]: s.dt.hour Out[274]: 0 9 1 9 2 9 3 9 dtype: int32 In [275]: s.dt.second Out[275]: 0 12 1 12 2 12 3 12 dtype: int32 In [276]: s.dt.day Out[276]: 0 1 1 2 2 3 3 4 dtype: int32
这使得可以使用如下的表达式：
In [277]: s[s.dt.day == 2] Out[277]: 1 2013-01-02 09:10:12 dtype: datetime64[ns]
您可以轻松地生成带有时区信息的转换：
In [278]: stz = s.dt.tz_localize("US/Eastern") In [279]: stz Out[279]: 0 2013-01-01 09:10:12-05:00 1 2013-01-02 09:10:12-05:00 2 2013-01-03 09:10:12-05:00 3 2013-01-04 09:10:12-05:00 dtype: datetime64[ns, US/Eastern] In [280]: stz.dt.tz Out[280]: <DstTzInfo 'US/Eastern' LMT-1 day, 19:04:00 STD>
您还可以链接这些类型的操作：
In [281]: s.dt.tz_localize("UTC").dt.tz_convert("US/Eastern") Out[281]: 0 2013-01-01 04:10:12-05:00 1 2013-01-02 04:10:12-05:00 2 2013-01-03 04:10:12-05:00 3 2013-01-04 04:10:12-05:00 dtype: datetime64[ns, US/Eastern]
您还可以使用Series.dt.strftime()将日期时间值格式化为字符串，支持与标准strftime()相同的格式。
# DatetimeIndex In [282]: s = pd.Series(pd.date_range("20130101", periods=4)) In [283]: s Out[283]: 0 2013-01-01 1 2013-01-02 2 2013-01-03 3 2013-01-04 dtype: datetime64[ns] In [284]: s.dt.strftime("%Y/%m/%d") Out[284]: 0 2013/01/01 1 2013/01/02 2 2013/01/03 3 2013/01/04 dtype: object
# PeriodIndex In [285]: s = pd.Series(pd.period_range("20130101", periods=4)) In [286]: s Out[286]: 0 2013-01-01 1 2013-01-02 2 2013-01-03 3 2013-01-04 dtype: period[D] In [287]: s.dt.strftime("%Y/%m/%d") Out[287]: 0 2013/01/01 1 2013/01/02 2 2013/01/03 3 2013/01/04 dtype: object
.dt 访问器适用于周期和时间增量数据类型。
# period In [288]: s = pd.Series(pd.period_range("20130101", periods=4, freq="D")) In [289]: s Out[289]: 0 2013-01-01 1 2013-01-02 2 2013-01-03 3 2013-01-04 dtype: period[D] In [290]: s.dt.year Out[290]: 0 2013 1 2013 2 2013 3 2013 dtype: int64 In [291]: s.dt.day Out[291]: 0 1 1 2 2 3 3 4 dtype: int64
# timedelta In [292]: s = pd.Series(pd.timedelta_range("1 day 00:00:05", periods=4, freq="s")) In [293]: s Out[293]: 0 1 days 00:00:05 1 1 days 00:00:06 2 1 days 00:00:07 3 1 days 00:00:08 dtype: timedelta64[ns] In [294]: s.dt.days Out[294]: 0 1 1 1 2 1 3 1 dtype: int64 In [295]: s.dt.seconds Out[295]: 0 5 1 6 2 7 3 8 dtype: int32 In [296]: s.dt.components Out[296]: days hours minutes seconds milliseconds microseconds nanoseconds 0 1 0 0 5 0 0 0 1 1 0 0 6 0 0 0 2 1 0 0 7 0 0 0 3 1 0 0 8 0 0 0
注意
如果使用非日期时间类似的值访问，Series.dt将引发TypeError。
向量化字符串方法
Series 配备了一组字符串处理方法，使得在数组的每个元素上操作变得容易。最重要的是，这些方法会自动排除缺失/NA 值。这些方法通过 Series 的str属性访问，通常与等效的（标量）内置字符串方法名称匹配。例如：
In [297]: s = pd.Series( .....: ["A", "B", "C", "Aaba", "Baca", np.nan, "CABA", "dog", "cat"], dtype="string" .....: ) .....: In [298]: s.str.lower() Out[298]: 0 a 1 b 2 c 3 aaba 4 baca 5 <NA> 6 caba 7 dog 8 cat dtype: string
还提供了强大的模式匹配方法，但请注意，模式匹配通常默认使用正则表达式（在某些情况下总是使用）。
注意
在 pandas 1.0 之前，字符串方法仅适用于object类型的Series。pandas 1.0 添加了StringDtype，专门用于字符串。更多信息请参见文本数据类型。
请参见矢量化字符串方法获取完整描述。
排序
pandas 支持三种排序方式：按索引标签排序、按列值排序以及按两者的组合排序。
按索引排序
Series.sort_index()和DataFrame.sort_index()方法用于按其索引级别对 pandas 对象进行排序。
In [299]: df = pd.DataFrame( .....: { .....: "one": pd.Series(np.random.randn(3), index=["a", "b", "c"]), .....: "two": pd.Series(np.random.randn(4), index=["a", "b", "c", "d"]), .....: "three": pd.Series(np.random.randn(3), index=["b", "c", "d"]), .....: } .....: ) .....: In [300]: unsorted_df = df.reindex( .....: index=["a", "d", "c", "b"], columns=["three", "two", "one"] .....: ) .....: In [301]: unsorted_df Out[301]: three two one a NaN -1.152244 0.562973 d -0.252916 -0.109597 NaN c 1.273388 -0.167123 0.640382 b -0.098217 0.009797 -1.299504 # DataFrame In [302]: unsorted_df.sort_index() Out[302]: three two one a NaN -1.152244 0.562973 b -0.098217 0.009797 -1.299504 c 1.273388 -0.167123 0.640382 d -0.252916 -0.109597 NaN In [303]: unsorted_df.sort_index(ascending=False) Out[303]: three two one d -0.252916 -0.109597 NaN c 1.273388 -0.167123 0.640382 b -0.098217 0.009797 -1.299504 a NaN -1.152244 0.562973 In [304]: unsorted_df.sort_index(axis=1) Out[304]: one three two a 0.562973 NaN -1.152244 d NaN -0.252916 -0.109597 c 0.640382 1.273388 -0.167123 b -1.299504 -0.098217 0.009797 # Series In [305]: unsorted_df["three"].sort_index() Out[305]: a NaN b -0.098217 c 1.273388 d -0.252916 Name: three, dtype: float64
按索引排序还支持一个key参数，该参数接受一个可调用函数，用于对要排序的索引应用。对于MultiIndex对象，该键会按照指定的level逐级应用到各级别。
In [306]: s1 = pd.DataFrame({"a": ["B", "a", "C"], "b": [1, 2, 3], "c": [2, 3, 4]}).set_index( .....: list("ab") .....: ) .....: In [307]: s1 Out[307]: c a b B 1 2 a 2 3 C 3 4
In [308]: s1.sort_index(level="a") Out[308]: c a b B 1 2 C 3 4 a 2 3 In [309]: s1.sort_index(level="a", key=lambda idx: idx.str.lower()) Out[309]: c a b a 2 3 B 1 2 C 3 4
有关按值排序的键排序信息，请参见值排序。### 按值排序
Series.sort_values()方法用于按值对Series进行排序。DataFrame.sort_values()方法用于按其列或行值对DataFrame进行排序。可选的by参数可用于指定一个或多个列以确定排序顺序。
In [310]: df1 = pd.DataFrame( .....: {"one": [2, 1, 1, 1], "two": [1, 3, 2, 4], "three": [5, 4, 3, 2]} .....: ) .....: In [311]: df1.sort_values(by="two") Out[311]: one two three 0 2 1 5 2 1 2 3 1 1 3 4 3 1 4 2
by参数可以接受一个列名列表，例如：
In [312]: df1[["one", "two", "three"]].sort_values(by=["one", "two"]) Out[312]: one two three 2 1 2 3 1 1 3 4 3 1 4 2 0 2 1 5
这些方法通过na_position参数对 NA 值进行特殊处理：
In [313]: s[2] = np.nan In [314]: s.sort_values() Out[314]: 0 A 3 Aaba 1 B 4 Baca 6 CABA 8 cat 7 dog 2 <NA> 5 <NA> dtype: string In [315]: s.sort_values(na_position="first") Out[315]: 2 <NA> 5 <NA> 0 A 3 Aaba 1 B 4 Baca 6 CABA 8 cat 7 dog dtype: string
排序还支持一个key参数，该参数接受一个可调用函数，用于对要排序的值应用。
In [316]: s1 = pd.Series(["B", "a", "C"]) • 1
In [317]: s1.sort_values() Out[317]: 0 B 2 C 1 a dtype: object In [318]: s1.sort_values(key=lambda x: x.str.lower()) Out[318]: 1 a 0 B 2 C dtype: object
key将获得值的Series，并应返回具有相同形状的转换值的Series或数组。对于DataFrame对象，键会按列应用，因此键仍应期望一个 Series 并返回一个 Series，例如：
In [319]: df = pd.DataFrame({"a": ["B", "a", "C"], "b": [1, 2, 3]}) • 1
In [320]: df.sort_values(by="a") Out[320]: a b 0 B 1 2 C 3 1 a 2 In [321]: df.sort_values(by="a", key=lambda col: col.str.lower()) Out[321]: a b 1 a 2 0 B 1 2 C 3
每列的名称或类型可用于对不同列应用不同的函数。 ### 通过索引和值
传递给DataFrame.sort_values()的by参数可能是列名或索引级别名称。
# Build MultiIndex In [322]: idx = pd.MultiIndex.from_tuples( .....: [("a", 1), ("a", 2), ("a", 2), ("b", 2), ("b", 1), ("b", 1)] .....: ) .....: In [323]: idx.names = ["first", "second"] # Build DataFrame In [324]: df_multi = pd.DataFrame({"A": np.arange(6, 0, -1)}, index=idx) In [325]: df_multi Out[325]: A first second a 1 6 2 5 2 4 b 2 3 1 2 1 1
按‘second’（索引）和‘A’（列）排序
In [326]: df_multi.sort_values(by=["second", "A"]) Out[326]: A first second b 1 1 1 2 a 1 6 b 2 3 a 2 4 2 5
注意
如果一个字符串既匹配列名又匹配索引级别名称，则会发出警告，并且列优先。这将导致在将来版本中出现歧义错误。 ### searchsorted
Series 具有searchsorted()方法，其工作方式类似于numpy.ndarray.searchsorted()。
In [327]: ser = pd.Series([1, 2, 3]) In [328]: ser.searchsorted([0, 3]) Out[328]: array([0, 2]) In [329]: ser.searchsorted([0, 4]) Out[329]: array([0, 3]) In [330]: ser.searchsorted([1, 3], side="right") Out[330]: array([1, 3]) In [331]: ser.searchsorted([1, 3], side="left") Out[331]: array([0, 2]) In [332]: ser = pd.Series([3, 1, 2]) In [333]: ser.searchsorted([0, 3], sorter=np.argsort(ser)) Out[333]: array([0, 2]) ```### 最小/最大值 `Series`具有`nsmallest()`和`nlargest()`方法，它们返回最小或最大的\(n\)值。对于大型`Series`，这比对整个 Series 进行排序并在结果上调用`head(n)`要快得多。 ```py In [334]: s = pd.Series(np.random.permutation(10)) In [335]: s Out[335]: 0 2 1 0 2 3 3 7 4 1 5 5 6 9 7 6 8 8 9 4 dtype: int64 In [336]: s.sort_values() Out[336]: 1 0 4 1 0 2 2 3 9 4 5 5 7 6 3 7 8 8 6 9 dtype: int64 In [337]: s.nsmallest(3) Out[337]: 1 0 4 1 0 2 dtype: int64 In [338]: s.nlargest(3) Out[338]: 6 9 8 8 3 7 dtype: int64
DataFrame还具有nlargest和nsmallest方法。
In [339]: df = pd.DataFrame( .....: { .....: "a": [-2, -1, 1, 10, 8, 11, -1], .....: "b": list("abdceff"), .....: "c": [1.0, 2.0, 4.0, 3.2, np.nan, 3.0, 4.0], .....: } .....: ) .....: In [340]: df.nlargest(3, "a") Out[340]: a b c 5 11 f 3.0 3 10 c 3.2 4 8 e NaN In [341]: df.nlargest(5, ["a", "c"]) Out[341]: a b c 5 11 f 3.0 3 10 c 3.2 4 8 e NaN 2 1 d 4.0 6 -1 f 4.0 In [342]: df.nsmallest(3, "a") Out[342]: a b c 0 -2 a 1.0 1 -1 b 2.0 6 -1 f 4.0 In [343]: df.nsmallest(5, ["a", "c"]) Out[343]: a b c 0 -2 a 1.0 1 -1 b 2.0 6 -1 f 4.0 2 1 d 4.0 4 8 e NaN ```### 按 MultiIndex 列排序 当列是 MultiIndex 时，必须明确排序，并完全指定所有级别为`by`。 ```py In [344]: df1.columns = pd.MultiIndex.from_tuples( .....: [("a", "one"), ("a", "two"), ("b", "three")] .....: ) .....: In [345]: df1.sort_values(by=("a", "two")) Out[345]: a b one two three 0 2 1 5 2 1 2 3 1 1 3 4 3 1 4 2
复制
pandas 对象上的copy()方法会复制底层数据（尽管不会复制轴索引，因为它们是不可变的）并返回一个新对象。请注意几乎不需要复制对象。例如，只有少数几种方法可以原地更改 DataFrame：
- 插入、删除或修改列。
- 分配给
index或columns属性。 - 对于同质数据，可以通过
values属性或高级索引直接修改值。
明确指出，没有 pandas 方法会具有修改数据的副作用；几乎每个方法都会返回一个新对象，保持原始对象不变。如果数据被修改，那是因为您明确这样做了。
dtypes
在大多数情况下，pandas 使用 NumPy 数组和 dtype 来处理 Series 或 DataFrame 的单个列。NumPy 支持float、int、bool、timedelta64[ns]和datetime64[ns]（请注意，NumPy 不支持时区感知的日期时间）。
pandas 和第三方库在一些地方扩展了 NumPy 的类型系统。本节描述了 pandas 内部所做的扩展。查看 扩展类型 了解如何编写适用于 pandas 的自定义扩展。查看 生态系统页面 查看已实现扩展的第三方库列表。
以下表格列出了所有 pandas 的扩展类型。对于需要 dtype 参数的方法，可以按照指示指定字符串。查看各自的文档部分了解更多关于每种类型的信息。
| 数据类型 | 数据类型 | 标量 | 数组 | 字符串别名 |
| 时区感知日期时间 | DatetimeTZDtype |
Timestamp |
arrays.DatetimeArray |
'datetime64[ns, <tz>]' |
| 分类 | CategoricalDtype |
(无) | Categorical |
'category' |
| 周期（时间跨度） | PeriodDtype |
Period |
arrays.PeriodArray 'Period[<freq>]' |
'period[<freq>]', |
| 稀疏 | SparseDtype |
(无) | arrays.SparseArray |
'Sparse', 'Sparse[int]', 'Sparse[float]' |
| 区间 | IntervalDtype |
Interval |
arrays.IntervalArray |
'interval', 'Interval', 'Interval[<numpy_dtype>]', 'Interval[datetime64[ns, <tz>]]', 'Interval[timedelta64[<freq>]]' |
| 可空整数 | Int64Dtype, … |
(无) | arrays.IntegerArray |
'Int8', 'Int16', 'Int32', 'Int64', 'UInt8', 'UInt16', 'UInt32', 'UInt64' |
| 可空浮点数 | Float64Dtype, … |
(无) | arrays.FloatingArray |
'Float32', 'Float64' |
| 字符串 | StringDtype |
str |
arrays.StringArray |
'string' |
| 布尔值（带 NA） | BooleanDtype |
bool |
arrays.BooleanArray |
'boolean' |
pandas 有两种存储字符串的方式。
object数据类型，可以保存任何 Python 对象，包括字符串。StringDtype，专门用于字符串。
通常，我们建议使用StringDtype。更多信息请参见文本数据类型。
最后，任意对象可以使用object数据类型存储，但应尽可能避免（出于性能和与其他库和方法的互操作性考虑。请参见对象转换）。
一个方便的dtypes属性用于返回 DataFrame 的每列的数据类型的 Series。
In [346]: dft = pd.DataFrame( .....: { .....: "A": np.random.rand(3), .....: "B": 1, .....: "C": "foo", .....: "D": pd.Timestamp("20010102"), .....: "E": pd.Series([1.0] * 3).astype("float32"), .....: "F": False, .....: "G": pd.Series([1] * 3, dtype="int8"), .....: } .....: ) .....: In [347]: dft Out[347]: A B C D E F G 0 0.035962 1 foo 2001-01-02 1.0 False 1 1 0.701379 1 foo 2001-01-02 1.0 False 1 2 0.281885 1 foo 2001-01-02 1.0 False 1 In [348]: dft.dtypes Out[348]: A float64 B int64 C object D datetime64[s] E float32 F bool G int8 dtype: object
在Series对象上，使用dtype属性。
In [349]: dft["A"].dtype Out[349]: dtype('float64')
如果 pandas 对象包含具有多种数据类型在单个列中的数据，则列的数据类型将被选择以容纳所有数据类型（object是最通用的）。
# these ints are coerced to floats In [350]: pd.Series([1, 2, 3, 4, 5, 6.0]) Out[350]: 0 1.0 1 2.0 2 3.0 3 4.0 4 5.0 5 6.0 dtype: float64 # string data forces an ``object`` dtype In [351]: pd.Series([1, 2, 3, 6.0, "foo"]) Out[351]: 0 1 1 2 2 3 3 6.0 4 foo dtype: object
每种类型的DataFrame的列数可以通过调用DataFrame.dtypes.value_counts()来找到。
In [352]: dft.dtypes.value_counts() Out[352]: float64 1 int64 1 object 1 datetime64[s] 1 float32 1 bool 1 int8 1 Name: count, dtype: int64
数值数据类型将传播并可以共存于数据框中。如果传递了数据类型（可以直接通过dtype关键字、传递的ndarray或传递的Series），那么它将在数据框操作中保留。此外，不同的数值数据类型将不会被合并。以下示例将让你一窥其中。
In [353]: df1 = pd.DataFrame(np.random.randn(8, 1), columns=["A"], dtype="float32") In [354]: df1 Out[354]: A 0 0.224364 1 1.890546 2 0.182879 3 0.787847 4 -0.188449 5 0.667715 6 -0.011736 7 -0.399073 In [355]: df1.dtypes Out[355]: A float32 dtype: object In [356]: df2 = pd.DataFrame( .....: { .....: "A": pd.Series(np.random.randn(8), dtype="float16"), .....: "B": pd.Series(np.random.randn(8)), .....: "C": pd.Series(np.random.randint(0, 255, size=8), dtype="uint8"), # [0,255] (range of uint8) .....: } .....: ) .....: In [357]: df2 Out[357]: A B C 0 0.823242 0.256090 26 1 1.607422 1.426469 86 2 -0.333740 -0.416203 46 3 -0.063477 1.139976 212 4 -1.014648 -1.193477 26 5 0.678711 0.096706 7 6 -0.040863 -1.956850 184 7 -0.357422 -0.714337 206 In [358]: df2.dtypes Out[358]: A float16 B float64 C uint8 dtype: object
Pandas 2.2 中文官方教程和指南（九·一）（4）https://developer.aliyun.com/article/1509698
