当前位置:   article > 正文

【终篇】Pandas中文官方文档:基础用法6

pandas文档中文


本文授权转载自Python大咖谈

禁止二次转载

大家好,我是老表

阅读文本大概需要 16 分钟

建议从头开始学习,本系列前四篇
  1. Pandas中文官方文档:基础用法1

  2. Pandas中文官方文档:基础用法2

  3. Pandas中文官方文档:基础用法3

  4. Pandas中文官方文档:基础用法4

  5. Pandas中文官方文档:基础用法5

数据类型

大多数情况下,pandas 使用 Numpy 数组、Series 或 DataFrame 里某列的数据类型。Numpy 支持 floatintbooltimedelta[ns]datetime64[ns],注意,Numpy 不支持带时区信息的 datetime

Pandas 与第三方支持库对 Numpy 类型系统进行了扩充,本节只介绍 pandas 的内部扩展。如需了解自行编写与 pandas 配合的扩展类型,请参阅扩展类型,参阅扩展数据类型了解第三方支持库提供的扩展类型。

下表列出了 pandas 扩展类型,参阅列出的文档内容,查看每种类型的详情。

数据种类数据类型标量数组文档
带时区的
日期时间
DatetimeTZ
Timestamparrays.
DatetimeArray
Time zone handling
类别型Categorical
(无)CategoricalCategorical data
时间段PeriodPeriodarrays.
PeriodArray
Time span representation
稀疏数据Sparse(无)arrays.
SparseArray
Sparse data structures
时间间隔IntervalIntervalarrays.
IntervalArray
IntervalIndex
空整型Int64...(无)arrays.
IntegerArray
Nullable integer data type

此表要横屏看

Pandas 用 object 存储字符串。

虽然, object 数据类型能够存储任何对象,但应尽量避免这种操作,要了解与其它支持库与方法的性能与交互操作,参阅 对象转换。

DataFrame 的 dtypes 属性用起来很方便,以 Series 形式返回每列的数据类型。

  1. In [328]: dft = pd.DataFrame({'A': np.random.rand(3),
  2.    .....:                     'B'1,
  3.    .....:                     'C''foo',
  4.    .....:                     'D': pd.Timestamp('20010102'),
  5.    .....:                     'E': pd.Series([1.0] * 3).astype('float32'),
  6.    .....:                     'F': False,
  7.    .....:                     'G': pd.Series([1] * 3, dtype='int8')})
  8.    .....: 
  9. In [329]: dft
  10. Out[329]: 
  11.           A  B    C          D    E      F  G
  12. 0  0.035962  1  foo 2001-01-02  1.0  False  1
  13. 1  0.701379  1  foo 2001-01-02  1.0  False  1
  14. 2  0.281885  1  foo 2001-01-02  1.0  False  1
  15. In [330]: dft.dtypes
  16. Out[330]: 
  17. A           float64
  18. B             int64
  19. C            object
  20. D    datetime64[ns]
  21. E           float32
  22. F              bool
  23. G              int8
  24. dtype: object

要查看 Series 的数据类型,用 dtype 属性。

  1. In [331]: dft['A'].dtype
  2. Out[331]: dtype('float64')

Pandas 对象单列中含多种类型的数据时,该列的数据类型为可适配于各类数据的数据类型,通常为 object

  1. # 整数被强制转换为浮点数
  2. In [332]: pd.Series([123456.])
  3. Out[332]: 
  4. 0    1.0
  5. 1    2.0
  6. 2    3.0
  7. 3    4.0
  8. 4    5.0
  9. 5    6.0
  10. dtype: float64
  11. # 字符串数据决定了该 Series 的数据类型为 ``object``
  12. In [333]: pd.Series([1236.'foo'])
  13. Out[333]: 
  14. 0      1
  15. 1      2
  16. 2      3
  17. 3      6
  18. 4    foo
  19. dtype: object

DataFrame.dtypes.value_counts() 用于统计 DataFrame 里各列数据类型的数量。

  1. In [334]: dft.dtypes.value_counts()
  2. Out[334]: 
  3. float32           1
  4. object            1
  5. bool              1
  6. int8              1
  7. float64           1
  8. datetime64[ns]    1
  9. int64             1
  10. dtype: int64

多种数值型数据类型可以在 DataFrame 里共存。如果只传递一种数据类型,不论是通过 dtype 关键字直接传递,还是通过 ndarraySeries 传递,都会保存至 DataFrame 操作。此外,不同数值型数据类型不会合并。示例如下:

  1. In [335]: df1 = pd.DataFrame(np.random.randn(81), columns=['A'], dtype='float32')
  2. In [336]: df1
  3. Out[336]: 
  4.           A
  5. 0  0.224364
  6. 1  1.890546
  7. 2  0.182879
  8. 3  0.787847
  9. 4 -0.188449
  10. 5  0.667715
  11. 6 -0.011736
  12. 7 -0.399073
  13. In [337]: df1.dtypes
  14. Out[337]: 
  15. A    float32
  16. dtype: object
  17. In [338]: df2 = pd.DataFrame({'A': pd.Series(np.random.randn(8), dtype='float16'),
  18.    .....:                     'B': pd.Series(np.random.randn(8)),
  19.    .....:                     'C': pd.Series(np.array(np.random.randn(8),
  20.    .....:                                             dtype='uint8'))})
  21.    .....: 
  22. In [339]: df2
  23. Out[339]: 
  24.           A         B    C
  25. 0  0.823242  0.256090    0
  26. 1  1.607422  1.426469    0
  27. 2 -0.333740 -0.416203  255
  28. 3 -0.063477  1.139976    0
  29. 4 -1.014648 -1.193477    0
  30. 5  0.678711  0.096706    0
  31. 6 -0.040863 -1.956850    1
  32. 7 -0.357422 -0.714337    0
  33. In [340]: df2.dtypes
  34. Out[340]: 
  35. A    float16
  36. B    float64
  37. C      uint8
  38. dtype: object

默认值

整数的默认类型为 int64,浮点数的默认类型为 float64,这里的默认值与系统平台无关,不管是 32 位系统,还是 64 位系统都是一样的。下列代码返回的结果都是 int64

  1. In [341]: pd.DataFrame([12], columns=['a']).dtypes
  2. Out[341]: 
  3. a    int64
  4. dtype: object
  5. In [342]: pd.DataFrame({'a': [12]}).dtypes
  6. Out[342]: 
  7. a    int64
  8. dtype: object
  9. In [343]: pd.DataFrame({'a'1}, index=list(range(2))).dtypes
  10. Out[343]: 
  11. a    int64
  12. dtype: object

注意,Numpy 创建数组时,会根据系统选择类型。下列代码在 32 位系统上返回 int32

In [344]: frame = pd.DataFrame(np.array([12]))

向上转型

与其它类型合并时,要用到向上转型,这里指的是从现有类型转换为另一种类型,如int 变为 float

  1. In [345]: df3 = df1.reindex_like(df2).fillna(value=0.0) + df2
  2. In [346]: df3
  3. Out[346]: 
  4.           A         B      C
  5. 0  1.047606  0.256090    0.0
  6. 1  3.497968  1.426469    0.0
  7. 2 -0.150862 -0.416203  255.0
  8. 3  0.724370  1.139976    0.0
  9. 4 -1.203098 -1.193477    0.0
  10. 5  1.346426  0.096706    0.0
  11. 6 -0.052599 -1.956850    1.0
  12. 7 -0.756495 -0.714337    0.0
  13. In [347]: df3.dtypes
  14. Out[347]: 
  15. A    float32
  16. B    float64
  17. C    float64
  18. dtype: object

DataFrame.to_numpy() 返回多个数据类型里用的最多的数据类型,这里指的是输出结果的数据类型是适用于所有同质 Numpy 数组的数据类型。这里会强制执行向上转型

  1. In [348]: df3.to_numpy().dtype
  2. Out[348]: dtype('float64')

astype

astype() 方法显式地把一种数据类型转换为另一种,默认返回的是复制数据,就算数据类型没有改变也会执行复制操作,copy=False 可以改变默认操作模式。此外,如果 astype 无效会触发异常。

向上转型一般都会遵循 numpy 的规则。如果操作中涉及两种不同类型的数据,返回的将是更通用的那种数据类型。

  1. In [349]: df3
  2. Out[349]: 
  3.           A         B      C
  4. 0  1.047606  0.256090    0.0
  5. 1  3.497968  1.426469    0.0
  6. 2 -0.150862 -0.416203  255.0
  7. 3  0.724370  1.139976    0.0
  8. 4 -1.203098 -1.193477    0.0
  9. 5  1.346426  0.096706    0.0
  10. 6 -0.052599 -1.956850    1.0
  11. 7 -0.756495 -0.714337    0.0
  12. In [350]: df3.dtypes
  13. Out[350]: 
  14. A    float32
  15. B    float64
  16. C    float64
  17. dtype: object
  18. # 转换数据类型
  19. In [351]: df3.astype('float32').dtypes
  20. Out[351]: 
  21. A    float32
  22. B    float32
  23. C    float32
  24. dtype: object

astype() 把一列或多列转换为指定类型 。

  1. In [352]: dft = pd.DataFrame({'a': [123], 'b': [456], 'c': [789]})
  2. In [353]: dft[['a''b']] = dft[['a''b']].astype(np.uint8)
  3. In [354]: dft
  4. Out[354]: 
  5.    a  b  c
  6. 0  1  4  7
  7. 1  2  5  8
  8. 2  3  6  9
  9. In [355]: dft.dtypes
  10. Out[355]: 
  11. a    uint8
  12. b    uint8
  13. c    int64
  14. dtype: object

0.19.0 版新增。

astype() 通过字典指定哪些列转换为哪些类型。

  1. In [356]: dft1 = pd.DataFrame({'a': [101], 'b': [456], 'c': [789]})
  2. In [357]: dft1 = dft1.astype({'a': np.bool'c': np.float64})
  3. In [358]: dft1
  4. Out[358]: 
  5.        a  b    c
  6. 0   True  4  7.0
  7. 1  False  5  8.0
  8. 2   True  6  9.0
  9. In [359]: dft1.dtypes
  10. Out[359]: 
  11. a       bool
  12. b      int64
  13. c    float64
  14. dtype: object

astype()loc() 为部分列转换指定类型时,会发生向上转型。

loc() 尝试分配当前的数据类型,而 [] 则会从右方获取数据类型并进行覆盖。因此,下列代码会产出意料之外的结果:

  1. In [360]: dft = pd.DataFrame({'a': [123], 'b': [456], 'c': [789]})
  2. In [361]: dft.loc[:, ['a''b']].astype(np.uint8).dtypes
  3. Out[361]: 
  4. a    uint8
  5. b    uint8
  6. dtype: object
  7. In [362]: dft.loc[:, ['a''b']] = dft.loc[:, ['a''b']].astype(np.uint8)
  8. In [363]: dft.dtypes
  9. Out[363]: 
  10. a    int64
  11. b    int64
  12. c    int64
  13. dtype: object

对象转换

Pandas 提供了多种函数可以把 object 从一种类型强制转为另一种类型。这是因为,数据有时存储的是正确类型,但在保存时却存成了 object 类型,此时,用 DataFrame.infer_objects()Series.infer_objects() 方法即可把数据转换为正确的类型。

  1. In [364]: import datetime
  2. In [365]: df = pd.DataFrame([[12],
  3.    .....:                    ['a''b'],
  4.    .....:                    [datetime.datetime(201632),
  5.    .....:                     datetime.datetime(201632)]])
  6.    .....: 
  7. In [366]: df = df.T
  8. In [367]: df
  9. Out[367]: 
  10.    0  1          2
  11. 0  1  a 2016-03-02
  12. 1  2  b 2016-03-02
  13. In [368]: df.dtypes
  14. Out[368]: 
  15. 0            object
  16. 1            object
  17. 2    datetime64[ns]
  18. dtype: object

因为数据被转置,所以把原始列的数据类型改成了 object,但使用 infer_objects 后就变正确了。

  1. In [369]: df.infer_objects().dtypes
  2. Out[369]: 
  3. 0             int64
  4. 1            object
  5. 2    datetime64[ns]
  6. dtype: object

下列函数可以应用于一维数组与标量,执行硬转换,把对象转换为指定类型。

  • `to_numeric()`,转换为数值型

  1. In [370]: m = ['1.1'23]
  2. In [371]: pd.to_numeric(m)
  3. Out[371]: array([1.12. , 3. ])
  • `to_datetime()`,转换为 datetime 对象

  1. In [372]: import datetime
  2. In [373]: m = ['2016-07-09', datetime.datetime(201632)]
  3. In [374]: pd.to_datetime(m)
  4. Out[374]: DatetimeIndex(['2016-07-09''2016-03-02'], dtype='datetime64[ns]', freq=None)
  • `to_timedelta()`,转换为 timedelta 对象。

  1. In [375]: m = ['5us', pd.Timedelta('1day')]
  2. In [376]: pd.to_timedelta(m)
  3. Out[376]: TimedeltaIndex(['0 days 00:00:00.000005''1 days 00:00:00'], dtype='timedelta64[ns]', freq=None)

如需强制转换,则要加入 error 参数,指定 pandas 怎样处理不能转换为成预期类型或对象的数据。errors 参数的默认值为 False,指的是在转换过程中,遇到任何问题都触发错误。设置为 errors='coerce' 时,pandas 会忽略错误,强制把问题数据转换为 pd.NaTdatetimetimedelta),或 np.nan(数值型)。读取数据时,如果大部分要转换的数据是数值型或 datetime,这种操作非常有用,但偶尔也会有非制式数据混合在一起,可能会导致展示数据缺失:

  1. In [377]: import datetime
  2. In [378]: m = ['apple', datetime.datetime(201632)]
  3. In [379]: pd.to_datetime(m, errors='coerce')
  4. Out[379]: DatetimeIndex(['NaT''2016-03-02'], dtype='datetime64[ns]', freq=None)
  5. In [380]: m = ['apple'23]
  6. In [381]: pd.to_numeric(m, errors='coerce')
  7. Out[381]: array([nan,  2.,  3.])
  8. In [382]: m = ['apple', pd.Timedelta('1day')]
  9. In [383]: pd.to_timedelta(m, errors='coerce')
  10. Out[383]: TimedeltaIndex([NaT, '1 days'], dtype='timedelta64[ns]', freq=None)

error 参数还有第三个选项,error='ignore'。转换数据时会忽略错误,直接输出问题数据:

  1. In [384]: import datetime
  2. In [385]: m = ['apple', datetime.datetime(201632)]
  3. In [386]: pd.to_datetime(m, errors='ignore')
  4. Out[386]: Index(['apple'2016-03-02 00:00:00], dtype='object')
  5. In [387]: m = ['apple'23]
  6. In [388]: pd.to_numeric(m, errors='ignore')
  7. Out[388]: array(['apple'23], dtype=object)
  8. In [389]: m = ['apple', pd.Timedelta('1day')]
  9. In [390]: pd.to_timedelta(m, errors='ignore')
  10. Out[390]: array(['apple', Timedelta('1 days 00:00:00')], dtype=object)

执行转换操作时,to_numeric() 还有一个参数,downcast,即向下转型,可以把数值型转换为减少内存占用的数据类型:

  1. In [391]: m = ['1'23]
  2. In [392]: pd.to_numeric(m, downcast='integer')   # smallest signed int dtype
  3. Out[392]: array([123], dtype=int8)
  4. In [393]: pd.to_numeric(m, downcast='signed')    # same as 'integer'
  5. Out[393]: array([123], dtype=int8)
  6. In [394]: pd.to_numeric(m, downcast='unsigned')  # smallest unsigned int dtype
  7. Out[394]: array([123], dtype=uint8)
  8. In [395]: pd.to_numeric(m, downcast='float')     # smallest float dtype
  9. Out[395]: array([1.2.3.], dtype=float32)

上述方法仅能应用于一维数组、列表或标量;不能直接用于 DataFrame 等多维对象。不过,用 apply(),可以快速为每列应用函数:

  1. In [396]: import datetime
  2. In [397]: df = pd.DataFrame([
  3.    .....:     ['2016-07-09', datetime.datetime(201632)]] * 2, dtype='O')
  4.    .....: 
  5. In [398]: df
  6. Out[398]: 
  7.             0                    1
  8. 0  2016-07-09  2016-03-02 00:00:00
  9. 1  2016-07-09  2016-03-02 00:00:00
  10. In [399]: df.apply(pd.to_datetime)
  11. Out[399]: 
  12.            0          1
  13. 0 2016-07-09 2016-03-02
  14. 1 2016-07-09 2016-03-02
  15. In [400]: df = pd.DataFrame([['1.1'23]] * 2, dtype='O')
  16. In [401]: df
  17. Out[401]: 
  18.      0  1  2
  19. 0  1.1  2  3
  20. 1  1.1  2  3
  21. In [402]: df.apply(pd.to_numeric)
  22. Out[402]: 
  23.      0  1  2
  24. 0  1.1  2  3
  25. 1  1.1  2  3
  26. In [403]: df = pd.DataFrame([['5us', pd.Timedelta('1day')]] * 2, dtype='O')
  27. In [404]: df
  28. Out[404]: 
  29.      0                1
  30. 0  5us  1 days 00:00:00
  31. 1  5us  1 days 00:00:00
  32. In [405]: df.apply(pd.to_timedelta)
  33. Out[405]: 
  34.                 0      1
  35. 0 00:00:00.000005 1 days
  36. 1 00:00:00.000005 1 days

各种坑

integer 数据执行选择操作时,可以很轻而易举地把数据转换为 floating 。pandas 会保存输入数据的数据类型,以防未引入 nans 的情况。参阅 对整数 NA 空值的支持。

  1. In [406]: dfi = df3.astype('int32')
  2. In [407]: dfi['E'] = 1
  3. In [408]: dfi
  4. Out[408]: 
  5.    A  B    C  E
  6. 0  1  0    0  1
  7. 1  3  1    0  1
  8. 2  0  0  255  1
  9. 3  0  1    0  1
  10. 4 -1 -1    0  1
  11. 5  1  0    0  1
  12. 6  0 -1    1  1
  13. 7  0  0    0  1
  14. In [409]: dfi.dtypes
  15. Out[409]: 
  16. A    int32
  17. B    int32
  18. C    int32
  19. E    int64
  20. dtype: object
  21. In [410]: casted = dfi[dfi > 0]
  22. In [411]: casted
  23. Out[411]: 
  24.      A    B      C  E
  25. 0  1.0  NaN    NaN  1
  26. 1  3.0  1.0    NaN  1
  27. 2  NaN  NaN  255.0  1
  28. 3  NaN  1.0    NaN  1
  29. 4  NaN  NaN    NaN  1
  30. 5  1.0  NaN    NaN  1
  31. 6  NaN  NaN    1.0  1
  32. 7  NaN  NaN    NaN  1
  33. In [412]: casted.dtypes
  34. Out[412]: 
  35. A    float64
  36. B    float64
  37. C    float64
  38. E      int64
  39. dtype: object

浮点数类型未改变。

  1. In [413]: dfa = df3.copy()
  2. In [414]: dfa['A'] = dfa['A'].astype('float32')
  3. In [415]: dfa.dtypes
  4. Out[415]: 
  5. A    float32
  6. B    float64
  7. C    float64
  8. dtype: object
  9. In [416]: casted = dfa[df2 > 0]
  10. In [417]: casted
  11. Out[417]: 
  12.           A         B      C
  13. 0  1.047606  0.256090    NaN
  14. 1  3.497968  1.426469    NaN
  15. 2       NaN       NaN  255.0
  16. 3       NaN  1.139976    NaN
  17. 4       NaN       NaN    NaN
  18. 5  1.346426  0.096706    NaN
  19. 6       NaN       NaN    1.0
  20. 7       NaN       NaN    NaN
  21. In [418]: casted.dtypes
  22. Out[418]: 
  23. A    float32
  24. B    float64
  25. C    float64
  26. dtype: object

基于 `dtype` 选择列

select_dtypes() 方法基于 dtype 选择列。

首先,创建一个由多种数据类型组成的 DataFrame:

  1. In [419]: df = pd.DataFrame({'string': list('abc'),
  2.    .....:                    'int64': list(range(14)),
  3.    .....:                    'uint8': np.arange(36).astype('u1'),
  4.    .....:                    'float64': np.arange(4.07.0),
  5.    .....:                    'bool1': [True, False, True],
  6.    .....:                    'bool2': [False, True, False],
  7.    .....:                    'dates': pd.date_range('now', periods=3),
  8.    .....:                    'category': pd.Series(list("ABC")).astype('category')})
  9.    .....: 
  10. In [420]: df['tdeltas'] = df.dates.diff()
  11. In [421]: df['uint64'] = np.arange(36).astype('u8')
  12. In [422]: df['other_dates'] = pd.date_range('20130101', periods=3)
  13. In [423]: df['tz_aware_dates'] = pd.date_range('20130101', periods=3, tz='US/Eastern')
  14. In [424]: df
  15. Out[424]: 
  16.   string  int64  uint8  float64  bool1  bool2                      dates category tdeltas  uint64 other_dates            tz_aware_dates
  17. 0      a      1      3      4.0   True  False 2019-08-22 15:49:01.870038        A     NaT       3  2013-01-01 2013-01-01 00:00:00-05:00
  18. 1      b      2      4      5.0  False   True 2019-08-23 15:49:01.870038        B  1 days       4  2013-01-02 2013-01-02 00:00:00-05:00
  19. 2      c      3      5      6.0   True  False 2019-08-24 15:49:01.870038        C  1 days       5  2013-01-03 2013-01-03 00:00:00-05:00

该 DataFrame 的数据类型:

  1. In [425]: df.dtypes
  2. Out[425]: 
  3. string                                object
  4. int64                                  int64
  5. uint8                                  uint8
  6. float64                              float64
  7. bool1                                   bool
  8. bool2                                   bool
  9. dates                         datetime64[ns]
  10. category                            category
  11. tdeltas                      timedelta64[ns]
  12. uint64                                uint64
  13. other_dates                   datetime64[ns]
  14. tz_aware_dates    datetime64[ns, US/Eastern]
  15. dtype: object

select_dtypes() 有两个参数,includeexclude,用于实现“提取这些数据类型的列” (include)或 “提取不是这些数据类型的列”(exclude)。

选择 bool 型的列,示例如下:

  1. In [426]: df.select_dtypes(include=[bool])
  2. Out[426]: 
  3.    bool1  bool2
  4. 0   True  False
  5. 1  False   True
  6. 2   True  False

该方法还支持输入 NumPy 数据类型的名称:

  1. In [427]: df.select_dtypes(include=['bool'])
  2. Out[427]: 
  3.    bool1  bool2
  4. 0   True  False
  5. 1  False   True
  6. 2   True  False

select_dtypes() 还支持通用数据类型。

比如,选择所有数值型与布尔型的列,同时,排除无符号整数:

  1. In [428]: df.select_dtypes(include=['number''bool'], exclude=['unsignedinteger'])
  2. Out[428]: 
  3.    int64  float64  bool1  bool2 tdeltas
  4. 0      1      4.0   True  False     NaT
  5. 1      2      5.0  False   True  1 days
  6. 2      3      6.0   True  False  1 days

选择字符串型的列必须要用 object

  1. In [429]: df.select_dtypes(include=['object'])
  2. Out[429]: 
  3.   string
  4. 0      a
  5. 1      b
  6. 2      c

要查看 numpy.number 等通用 dtype 的所有子类型,可以定义一个函数,返回子类型树:

  1. In [430]: def subdtypes(dtype):
  2.    .....:     subs = dtype.__subclasses__()
  3.    .....:     if not subs:
  4.    .....:         return dtype
  5.    .....:     return [dtype, [subdtypes(dt) for dt in subs]]
  6.    .....: 

所有 Numpy 数据类型都是 numpy.generic 的子类:

  1. In [431]: subdtypes(np.generic)
  2. Out[431]: 
  3. [numpy.generic,
  4.  [[numpy.number,
  5.    [[numpy.integer,
  6.      [[numpy.signedinteger,
  7.        [numpy.int8,
  8.         numpy.int16,
  9.         numpy.int32,
  10.         numpy.int64,
  11.         numpy.int64,
  12.         numpy.timedelta64]],
  13.       [numpy.unsignedinteger,
  14.        [numpy.uint8,
  15.         numpy.uint16,
  16.         numpy.uint32,
  17.         numpy.uint64,
  18.         numpy.uint64]]]],
  19.     [numpy.inexact,
  20.      [[numpy.floating,
  21.        [numpy.float16, numpy.float32, numpy.float64, numpy.float128]],
  22.       [numpy.complexfloating,
  23.        [numpy.complex64, numpy.complex128, numpy.complex256]]]]]],
  24.   [numpy.flexible,
  25.    [[numpy.character, [numpy.bytes_, numpy.str_]],
  26.     [numpy.void, [numpy.record]]]],
  27.   numpy.bool_,
  28.   numpy.datetime64,
  29.   numpy.object_]]

注意:Pandas 支持 categorydatetime64[ns, tz] 类型,但这两种类型未整合到 Numpy 的架构里,因此,上面的函数没有显示。

大家好,我是老表
觉得本文不错的话,转发、留言、点赞,是对我最大的支持。

每日留言

说说你读完本文感受?

或者一句激励自己的话?

(字数不少于15字)

怎么加入刻意学习队伍

点我,看文末彩蛋

留言有啥福利

点我就知道了

想进学习交流群

加微信:jjxksa888

:简说Python

2小时快速掌握Python基础知识要点

完整Python基础知识要点

Python小知识 | 这些技能你不会?(一)

Python小知识 | 这些技能你不会?(二)

Python小知识 | 这些技能你不会?(三)

Python小知识 | 这些技能你不会?(四)

近期推荐阅读: 整理了我开始分享学习笔记到现在超过250篇优质文章,涵盖数据分析、爬虫、机器学习等方面,别再说不知道该从哪开始,实战哪里找了
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/很楠不爱3/article/detail/193636
推荐阅读
相关标签
  

闽ICP备14008679号