目录
71、pandas.tseries.api.guess_datetime_format函数
73、pandas.util.hash_pandas_object函数
一、用法精讲
71、pandas.tseries.api.guess_datetime_format函数
71-1、语法
# 71、pandas.tseries.api.guess_datetime_format函数
pandas.tseries.api.guess_datetime_format(dt_str, dayfirst=False)
Guess the datetime format of a given datetime string.
Parameters:
dt_strstr
Datetime string to guess the format of.
dayfirstbool, default False
If True parses dates with the day first, eg 20/01/2005
Warning
dayfirst=True is not strict, but will prefer to parse with day first (this is a known bug).
Returns:
str or None
ret
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、代码示例
# 71、pandas.tseries.api.guess_datetime_format函数
import pandas as pd
dt_str = '2024-07-17'
format_guess = pd.tseries.api.guess_datetime_format(dt_str)
print(format_guess)71-6-3、结果输出
# 71、pandas.tseries.api.guess_datetime_format函数
# %Y-%m-%d72、pandas.util.hash_array函数
72-1、语法
# 72、pandas.util.hash_array函数
pandas.util.hash_array(vals, encoding='utf8', hash_key='0123456789123456', categorize=True)
Given a 1d array, return an array of deterministic integers.
Parameters:
vals
ndarray or ExtensionArray
encoding
str, default ‘utf8’
Encoding for data & key when strings.
hash_key
str, default _default_hash_key
Hash_key for string key to encode.
categorize
bool, default True
Whether to first categorize object arrays before hashing. This is more efficient when the array contains duplicate values.
Returns:
ndarray[np.uint64, ndim=1]
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、代码示例
# 72、pandas.util.hash_array函数
import pandas as pd
# 创建一个包含字符串的Series
s = pd.Series(['Jimmy', 'Bryce', 'Myelsa'])
# 计算每个字符串的哈希值
hashed_values = pd.util.hash_array(s.values)
# 输出哈希值数组
print(hashed_values)72-6-3、结果输出
# 72、pandas.util.hash_array函数
# [1382347394209841164 9798869407607568009 6426393181695770081]73、pandas.util.hash_pandas_object函数
73-1、语法
# 73、pandas.util.hash_pandas_object函数
pandas.util.hash_pandas_object(obj, index=True, encoding='utf8', hash_key='0123456789123456', categorize=True)
Return a data hash of the Index/Series/DataFrame.
Parameters:
obj
Index, Series, or DataFrame
index
bool, default True
Include the index in the hash (if Series/DataFrame).
encoding
str, default ‘utf8’
Encoding for data & key when strings.
hash_key
str, default _default_hash_key
Hash_key for string key to encode.
categorize
bool, default True
Whether to first categorize object arrays before hashing. This is more efficient when the array contains duplicate values.
Returns:
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、代码示例
# 73、pandas.util.hash_pandas_object函数
# 73-1、对DataFrame进行哈希处理
import pandas as pd
# 创建一个简单的DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': ['a', 'b', 'c'],
'C': [True, False, True]
})
# 对DataFrame进行哈希处理，包括索引
hashes = pd.util.hash_pandas_object(df, index=True)
print("Hashes with index included:", hashes)
# 对DataFrame进行哈希处理，不包括索引
hashes_no_index = pd.util.hash_pandas_object(df, index=False)
print("Hashes without index:", hashes_no_index, end='\n\n')
# 73-2、对Series进行哈希处理
import pandas as pd
# 创建一个 Series
s = pd.Series([1, 2, 3, 4, 5])
# 对 Series 进行哈希处理
series_hashes = pd.util.hash_pandas_object(s)
print("Hashes for Series:", series_hashes)
# 注意：对于Series，通常没有索引(除非明确指定)，但你可以通过reset_index()将其转换为DataFrame并包含索引
s_df = s.reset_index(drop=False)
s_df_hashes_with_index = pd.util.hash_pandas_object(s_df)
print("Hashes for Series as DataFrame with index:", s_df_hashes_with_index, end='\n\n')
# 73-3、处理包含浮点数的DataFrame
import pandas as pd
# 创建一个包含浮点数的DataFrame
df_floats = pd.DataFrame({
'A': [1.0, 2.0, 3.0000000000001], # 注意最后一个数有微小的精度差异
'B': [4.0, 5.0, 6.0]
})
# 对DataFrame进行哈希处理
floats_hashes = pd.util.hash_pandas_object(df_floats)
print("Hashes for DataFrame with floats:", floats_hashes, end='\n\n')
# 注意：由于浮点数的精度问题，即使 '3.0' 和 '3.0000000000001' 在数值上接近，它们的哈希值也可能不同
# 73-4、对包含分类数据的DataFrame进行哈希处理
import pandas as pd
# 创建一个包含分类数据的DataFrame
df_categorical = pd.DataFrame({
'A': pd.Categorical(['a', 'b', 'a', 'c']),
'B': [1, 2, 3, 4]
})
# 对DataFrame进行哈希处理，包括分类数据的整数编码
categorical_hashes = pd.util.hash_pandas_object(df_categorical, categorize=True)
print("Hashes with categorical data (categorize=True):", categorical_hashes)
# 如果categorize=False，则直接对分类对象的字符串表示进行哈希处理
categorical_hashes_no_categorize = pd.util.hash_pandas_object(df_categorical, categorize=False)
print("Hashes with categorical data (categorize=False):", categorical_hashes_no_categorize, end='\n\n')
# 73-5、对包含时间戳的DataFrame进行哈希处理
import pandas as pd
# 创建一个包含时间戳的DataFrame
df_timestamps = pd.DataFrame({
'Timestamp': pd.to_datetime(['2024-07-01', '2024-07-05', '2024-07-17'])
})
# 对DataFrame进行哈希处理
timestamp_hashes = pd.util.hash_pandas_object(df_timestamps)
print("Hashes for DataFrame with timestamps:", timestamp_hashes, end='\n\n')
# 73-6、处理具有NaN值的DataFrame
import pandas as pd
# 创建一个包含NaN值的DataFrame
df_nan = pd.DataFrame({
'A': [1, 2, None, 4],
'B': ['a', 'b', 'c', None]
})
# 对DataFrame进行哈希处理
nan_hashes = pd.util.hash_pandas_object(df_nan)
print("Hashes for DataFrame with NaN values:", nan_hashes, end='\n\n')
# 注意：NaN 值会以某种方式影响哈希值，但具体方式取决于Pandas的内部实现
# 73-7、对大型DataFrame进行哈希处理
import pandas as pd
import numpy as np
# 创建一个大型DataFrame（这里仅作为示例，实际中可能更大）
np.random.seed(0)
large_df = pd.DataFrame({
'A': np.random.randint(0, 100, size=100000),
'B': np.random.choice(['a', 'b', 'c', 'd'], size=100000),
'C': np.random.rand(100000)
})
# 对大型DataFrame进行哈希处理（注意：这可能需要一些时间）
large_hashes = pd.util.hash_pandas_object(large_df, index=False)
print("Hashes for a large DataFrame (first 10):", large_hashes[:10])73-6-3、结果输出
# 73、pandas.util.hash_pandas_object函数
# 73-1、对DataFrame进行哈希处理
# Hashes with index included: 0 9483444313420146699
# 1 5719781360446296993
# 2 9877900052590456950
# dtype: uint64
# Hashes without index: 0 485995293390257589
# 1 3005746743269222528
# 2 15997040775864825588
# dtype: uint64
# 73-2、对Series进行哈希处理
# Hashes for Series: 0 14639053686158035780
# 1 3869563279212530728
# 2 393322362522515241
# 3 4080319230603510727
# 4 13014484659661894915
# dtype: uint64
# Hashes for Series as DataFrame with index: 0 5967740633143088628
# 1 9280677857880118003
# 2 6253357580284104503
# 3 4295247446495588871
# 4 12355848007932281175
# dtype: uint64
# 73-3、处理包含浮点数的DataFrame
# Hashes for DataFrame with floats: 0 12179765616421863049
# 1 4850516111580897109
# 2 13664998175358214438
# dtype: uint64
# 73-4、对包含分类数据的DataFrame进行哈希处理
# Hashes with categorical data (categorize=True): 0 10448339489922407492
# 1 328955597323365005
# 2 17337560684877153397
# 3 7837014030697196839
# dtype: uint64
# Hashes with categorical data (categorize=False): 0 10448339489922407492
# 1 328955597323365005
# 2 17337560684877153397
# 3 7837014030697196839
# dtype: uint64
# 73-5、对包含时间戳的DataFrame进行哈希处理
# Hashes for DataFrame with timestamps: 0 5029448861734248502
# 1 15824968476515617805
# 2 16154582340151959443
# dtype: uint64
# 73-6、处理具有NaN值的DataFrame
# Hashes for DataFrame with NaN values: 0 390400230840112733
# 1 9079939592730820628
# 2 13397986763273461122
# 3 18293157628943714066
# dtype: uint64
# 73-7、对大型DataFrame进行哈希处理
# Hashes for a large DataFrame (first 10): 0 3741430234977074334
# 1 13815252830947086855
# 2 5536596816482122074
# 3 7459333729972558407
# 4 10226587178543578329
# 5 16985416363548347045
# 6 5210640794891753453
# 7 334407979408579242
# 8 3392106525313158311
# 9 17317895163462122340
# dtype: uint64
1201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
