devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python酷库之旅-第三方库Pandas(028)

作者：知新_RL | 2024-08-10 05:31:33

赞

踩

Python酷库之旅-第三方库Pandas(028)

目录

一、用法精讲

71、pandas.tseries.api.guess_datetime_format函数

71-1、语法

71-2、参数

71-3、功能

71-4、返回值

71-5、说明

71-6、用法

71-6-1、数据准备

71-6-2、代码示例

71-6-3、结果输出

72、pandas.util.hash_array函数

72-1、语法

72-2、参数

72-3、功能

72-4、返回值

72-5、说明

72-6、用法

72-6-1、数据准备

72-6-2、代码示例

72-6-3、结果输出 

73、pandas.util.hash_pandas_object函数

73-1、语法

73-2、参数

73-3、功能

73-4、返回值

73-5、说明

73-6、用法

73-6-1、数据准备

73-6-2、代码示例

73-6-3、结果输出

二、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、Python魔法之旅

5、博客个人主页

一、用法精讲

71、pandas.tseries.api.guess_datetime_format函数
71-1、语法
  1. # 71、pandas.tseries.api.guess_datetime_format函数
  2. pandas.tseries.api.guess_datetime_format(dt_str, dayfirst=False)
  3. Guess the datetime format of a given datetime string.
  4.  
  5. Parameters:
  6. dt_strstr
  7. Datetime string to guess the format of.
  8.  
  9. dayfirstbool, default False
  10. If True parses dates with the day first, eg 20/01/2005
  11.  
  12. Warning
  13.  
  14. dayfirst=True is not strict, but will prefer to parse with day first (this is a known bug).
  15.  
  16. Returns:
  17. str or None
  18. ret
  19. datetime format string (for strftime or strptime), or None if it can’t be guessed.
71-2、参数

71-2-1、dt_str(必须)：一个或多个日期时间字符串，函数将尝试从这些字符串中猜测出日期时间的格式，如果传入的是列表，函数会尝试从列表中第一个非空字符串进行猜测。

71-2-2、dayfirst(可选，默认值为False)：用于控制日期时间字符串中日和月的顺序，如果设置为True，则假定日期字符串中的第一个数字是日(DD/MM/YYYY)，如果设置为False(默认值)，则假定第一个数字是月(MM/DD/YYYY)，这个参数对于解析一些可能具有不同日/月顺序的日期时间字符串非常有用。

71-3、功能

        用于猜测给定日期时间字符串(dt_str)的格式的一个实用工具。

71-4、返回值

        返回值是一个字符串，表示猜测到的日期时间格式，这个格式字符串遵循Pandas接受的日期时间格式约定，通常与Python的datetime.strptime和datetime.strftime方法兼容。

71-5、说明

        该函数可能在未来的Pandas版本中被弃用或更改。在较新版本的Pandas中，你可能更倾向于使用pandas.to_datetime函数，它也有一个infer_datetime_format参数，虽然它的行为可能与guess_datetime_format略有不同。

71-6、用法
71-6-1、数据准备
无
71-6-2、代码示例
  1. # 71、pandas.tseries.api.guess_datetime_format函数
  2. import pandas as pd
  3. dt_str = '2024-07-17'
  4. format_guess = pd.tseries.api.guess_datetime_format(dt_str)
  5. print(format_guess)
71-6-3、结果输出
  1. # 71、pandas.tseries.api.guess_datetime_format函数
  2. # %Y-%m-%d
72、pandas.util.hash_array函数
72-1、语法
  1. # 72、pandas.util.hash_array函数
  2. pandas.util.hash_array(vals, encoding='utf8', hash_key='0123456789123456', categorize=True)
  3. Given a 1d array, return an array of deterministic integers.
  4.  
  5. Parameters:
  6. vals
  7. ndarray or ExtensionArray
  8. encoding
  9. str, default ‘utf8’
  10. Encoding for data & key when strings.
  11.  
  12. hash_key
  13. str, default _default_hash_key
  14. Hash_key for string key to encode.
  15.  
  16. categorize
  17. bool, default True
  18. Whether to first categorize object arrays before hashing. This is more efficient when the array contains duplicate values.
  19.  
  20. Returns:
  21. ndarray[np.uint64, ndim=1]
  22. Hashed values, same length as the vals.
72-2、参数

72-2-1、vals(必须)：表示需要被哈希处理的输入数组，函数会遍历这个数组中的每个元素，并对其进行哈希处理。

72-2-2、encoding(可选，默认值为'utf8')：指定数组中字符串元素的编码方式，如果数组中包含字符串，则这些字符串会根据此编码方式被转换为字节序列，然后再进行哈希处理。

72-2-3、hash_key(可选，默认值为'0123456789123456')：提供了一个额外的密钥，用于在哈希过程中增加随机性，通过在哈希函数中加入这个密钥，可以增加哈希值的复杂性和安全性，尤其是在需要防止哈希碰撞的场景中。

72-2-4、categorize(可选，默认值为True)：当此参数为True时，函数会首先尝试将输入数组中的元素分类(即，将相同的元素映射到相同的整数标签上)，然后再对这些整数标签进行哈希处理，这可以在一定程度上减少哈希碰撞的可能性，并提高哈希过程的效率。如果输入数组已经是分类类型(Categorical dtype)，则此参数的效果会更加明显。

72-3、功能

        给定一个一维数组(如NumPy数组或Pandas Series)，返回该数组中每个元素的哈希值所组成的数组。

72-4、返回值

        返回一个与输入数组形状相同的一维NumPy数组，但其中的元素已被替换为对应元素的哈希值，这些哈希值是uint64类型的整数，它们代表了输入数组中每个元素的唯一(或尽可能唯一)标识符。

72-5、说明

        无

72-6、用法
72-6-1、数据准备
无
72-6-2、代码示例
  1. # 72、pandas.util.hash_array函数
  2. import pandas as pd
  3. # 创建一个包含字符串的Series
  4. s = pd.Series(['Jimmy', 'Bryce', 'Myelsa'])
  5. # 计算每个字符串的哈希值
  6. hashed_values = pd.util.hash_array(s.values)
  7. # 输出哈希值数组
  8. print(hashed_values)
72-6-3、结果输出 
  1. # 72、pandas.util.hash_array函数
  2. # [1382347394209841164 9798869407607568009 6426393181695770081]
73、pandas.util.hash_pandas_object函数
73-1、语法
  1. # 73、pandas.util.hash_pandas_object函数
  2. pandas.util.hash_pandas_object(obj, index=True, encoding='utf8', hash_key='0123456789123456', categorize=True)
  3. Return a data hash of the Index/Series/DataFrame.
  4.  
  5. Parameters:
  6. obj
  7. Index, Series, or DataFrame
  8. index
  9. bool, default True
  10. Include the index in the hash (if Series/DataFrame).
  11.  
  12. encoding
  13. str, default ‘utf8’
  14. Encoding for data & key when strings.
  15.  
  16. hash_key
  17. str, default _default_hash_key
  18. Hash_key for string key to encode.
  19.  
  20. categorize
  21. bool, default True
  22. Whether to first categorize object arrays before hashing. This is more efficient when the array contains duplicate values.
  23.  
  24. Returns:
  25. Series of uint64, same length as the object.
73-2、参数

73-2-1、obj(必须)：要进行哈希处理的Pandas对象(DataFrame或Series)。

73-2-2、index(可选，默认值为True)：布尔值，指定是否将对象的索引也纳入哈希计算中。如果为True，则对象的索引也会被哈希处理；如果为False，则只考虑对象的数据部分。

73-2-3、encoding(可选，默认值为'utf8')：字符串，用于指定在哈希处理过程中如何编码字符串类型的数据，这在处理包含非ASCII字符的数据时特别有用。

73-2-4、hash_key(可选，默认值为'0123456789123456')：字符串，一个盐值(salt)，用于增加哈希值的唯一性，通过添加这个盐值，即使两个Pandas对象在数据上完全相同，它们的哈希值也可能因为盐值的不同而不同，这有助于防止哈希碰撞，并提高哈希值的安全性。

73-2-5、categorize(可选，默认值为True)：布尔值，如果为True，则在哈希处理之前，函数会尝试将对象中的分类数据(如pandas的Categorical类型)转换为整数编码，这样可以提高哈希处理的效率和一致性；如果为False，则直接使用原始数据进行哈希处理。

73-3、功能

        用于对Pandas对象(如DataFrame或Series)进行哈希处理，该函数对于需要将Pandas对象转换为哈希值以便进行快速比较或作为字典键等场景非常有用。

73-4、返回值

        函数返回一个NumPy数组，其中包含了对象中每一行(或元素，对于Series)的哈希值，这些哈希值可以用于比较、索引或其他需要唯一标识符的场景。

73-5、说明

73-5-1、快速比较：通过比较两个Pandas对象的哈希值，可以快速判断它们是否完全相同(注意，哈希冲突的可能性极低，但理论上存在)。

73-5-2、作为字典键：将Pandas对象哈希处理后，可以使用哈希值作为字典的键，以便快速查找或更新数据。

73-5-3、数据去重：在处理大量数据时，可以使用哈希值来识别并删除重复的行或记录。

73-6、用法
73-6-1、数据准备
无
73-6-2、代码示例
  1. # 73、pandas.util.hash_pandas_object函数
  2. # 73-1、对DataFrame进行哈希处理
  3. import pandas as pd
  4. # 创建一个简单的DataFrame
  5. df = pd.DataFrame({
  6.     'A': [1, 2, 3],
  7.     'B': ['a', 'b', 'c'],
  8.     'C': [True, False, True]
  9. })
  10. # 对DataFrame进行哈希处理，包括索引
  11. hashes = pd.util.hash_pandas_object(df, index=True)
  12. print("Hashes with index included:", hashes)
  13. # 对DataFrame进行哈希处理，不包括索引
  14. hashes_no_index = pd.util.hash_pandas_object(df, index=False)
  15. print("Hashes without index:", hashes_no_index, end='\n\n')
  16.  
  17. # 73-2、对Series进行哈希处理
  18. import pandas as pd
  19. # 创建一个 Series
  20. s = pd.Series([1, 2, 3, 4, 5])
  21. # 对 Series 进行哈希处理
  22. series_hashes = pd.util.hash_pandas_object(s)
  23. print("Hashes for Series:", series_hashes)
  24. # 注意：对于Series，通常没有索引(除非明确指定)，但你可以通过reset_index()将其转换为DataFrame并包含索引
  25. s_df = s.reset_index(drop=False)
  26. s_df_hashes_with_index = pd.util.hash_pandas_object(s_df)
  27. print("Hashes for Series as DataFrame with index:", s_df_hashes_with_index, end='\n\n')
  28.  
  29. # 73-3、处理包含浮点数的DataFrame
  30. import pandas as pd
  31. # 创建一个包含浮点数的DataFrame
  32. df_floats = pd.DataFrame({
  33.     'A': [1.0, 2.0, 3.0000000000001],  # 注意最后一个数有微小的精度差异
  34.     'B': [4.0, 5.0, 6.0]
  35. })
  36. # 对DataFrame进行哈希处理
  37. floats_hashes = pd.util.hash_pandas_object(df_floats)
  38. print("Hashes for DataFrame with floats:", floats_hashes, end='\n\n')
  39. # 注意：由于浮点数的精度问题，即使 '3.0' 和 '3.0000000000001' 在数值上接近，它们的哈希值也可能不同
  40.  
  41. # 73-4、对包含分类数据的DataFrame进行哈希处理
  42. import pandas as pd
  43. # 创建一个包含分类数据的DataFrame
  44. df_categorical = pd.DataFrame({
  45.     'A': pd.Categorical(['a', 'b', 'a', 'c']),
  46.     'B': [1, 2, 3, 4]
  47. })
  48. # 对DataFrame进行哈希处理，包括分类数据的整数编码
  49. categorical_hashes = pd.util.hash_pandas_object(df_categorical, categorize=True)
  50. print("Hashes with categorical data (categorize=True):", categorical_hashes)
  51. # 如果categorize=False，则直接对分类对象的字符串表示进行哈希处理
  52. categorical_hashes_no_categorize = pd.util.hash_pandas_object(df_categorical, categorize=False)
  53. print("Hashes with categorical data (categorize=False):", categorical_hashes_no_categorize, end='\n\n')
  54.  
  55. # 73-5、对包含时间戳的DataFrame进行哈希处理
  56. import pandas as pd
  57. # 创建一个包含时间戳的DataFrame
  58. df_timestamps = pd.DataFrame({
  59.     'Timestamp': pd.to_datetime(['2024-07-01', '2024-07-05', '2024-07-17'])
  60. })
  61. # 对DataFrame进行哈希处理
  62. timestamp_hashes = pd.util.hash_pandas_object(df_timestamps)
  63. print("Hashes for DataFrame with timestamps:", timestamp_hashes, end='\n\n')
  64.  
  65. # 73-6、处理具有NaN值的DataFrame
  66. import pandas as pd
  67. # 创建一个包含NaN值的DataFrame
  68. df_nan = pd.DataFrame({
  69.     'A': [1, 2, None, 4],
  70.     'B': ['a', 'b', 'c', None]
  71. })
  72. # 对DataFrame进行哈希处理
  73. nan_hashes = pd.util.hash_pandas_object(df_nan)
  74. print("Hashes for DataFrame with NaN values:", nan_hashes, end='\n\n')
  75. # 注意：NaN 值会以某种方式影响哈希值，但具体方式取决于Pandas的内部实现
  76.  
  77. # 73-7、对大型DataFrame进行哈希处理
  78. import pandas as pd
  79. import numpy as np
  80. # 创建一个大型DataFrame（这里仅作为示例，实际中可能更大）
  81. np.random.seed(0)
  82. large_df = pd.DataFrame({
  83.     'A': np.random.randint(0, 100, size=100000),
  84.     'B': np.random.choice(['a', 'b', 'c', 'd'], size=100000),
  85.     'C': np.random.rand(100000)
  86. })
  87. # 对大型DataFrame进行哈希处理（注意：这可能需要一些时间）
  88. large_hashes = pd.util.hash_pandas_object(large_df, index=False)
  89. print("Hashes for a large DataFrame (first 10):", large_hashes[:10])
73-6-3、结果输出
  1. # 73、pandas.util.hash_pandas_object函数
  2. # 73-1、对DataFrame进行哈希处理
  3. # Hashes with index included: 0    9483444313420146699
  4. # 1    5719781360446296993
  5. # 2    9877900052590456950
  6. # dtype: uint64
  7. # Hashes without index: 0      485995293390257589
  8. # 1     3005746743269222528
  9. # 2    15997040775864825588
  10. # dtype: uint64
  11.  
  12. # 73-2、对Series进行哈希处理
  13. # Hashes for Series: 0    14639053686158035780
  14. # 1     3869563279212530728
  15. # 2      393322362522515241
  16. # 3     4080319230603510727
  17. # 4    13014484659661894915
  18. # dtype: uint64
  19. # Hashes for Series as DataFrame with index: 0     5967740633143088628
  20. # 1     9280677857880118003
  21. # 2     6253357580284104503
  22. # 3     4295247446495588871
  23. # 4    12355848007932281175
  24. # dtype: uint64
  25.  
  26. # 73-3、处理包含浮点数的DataFrame
  27. # Hashes for DataFrame with floats: 0    12179765616421863049
  28. # 1     4850516111580897109
  29. # 2    13664998175358214438
  30. # dtype: uint64
  31.  
  32. # 73-4、对包含分类数据的DataFrame进行哈希处理
  33. # Hashes with categorical data (categorize=True): 0    10448339489922407492
  34. # 1      328955597323365005
  35. # 2    17337560684877153397
  36. # 3     7837014030697196839
  37. # dtype: uint64
  38. # Hashes with categorical data (categorize=False): 0    10448339489922407492
  39. # 1      328955597323365005
  40. # 2    17337560684877153397
  41. # 3     7837014030697196839
  42. # dtype: uint64
  43.  
  44. # 73-5、对包含时间戳的DataFrame进行哈希处理
  45. # Hashes for DataFrame with timestamps: 0     5029448861734248502
  46. # 1    15824968476515617805
  47. # 2    16154582340151959443
  48. # dtype: uint64
  49.  
  50. # 73-6、处理具有NaN值的DataFrame
  51. # Hashes for DataFrame with NaN values: 0      390400230840112733
  52. # 1     9079939592730820628
  53. # 2    13397986763273461122
  54. # 3    18293157628943714066
  55. # dtype: uint64
  56.  
  57. # 73-7、对大型DataFrame进行哈希处理
  58. # Hashes for a large DataFrame (first 10): 0     3741430234977074334
  59. # 1    13815252830947086855
  60. # 2     5536596816482122074
  61. # 3     7459333729972558407
  62. # 4    10226587178543578329
  63. # 5    16985416363548347045
  64. # 6     5210640794891753453
  65. # 7      334407979408579242
  66. # 8     3392106525313158311
  67. # 9    17317895163462122340
  68. # dtype: uint64

二、推荐阅读

1、Python筑基之旅
2、Python函数之旅
3、Python算法之旅
4、Python魔法之旅
5、博客个人主页
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/957016
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号