python通识相关

将日期对象格式化为字符串

date_string = date.strftime('%Y-%m-%d')

通配符匹配某段 并定点替换

pattern = r's-[^>]*.ii'
replacement = r's-' + mu_str_lower + '.ii'
new_cell_value = re.sub(pattern, replacement, url_str)

pandas read

df = pd.read_sql_query(sql, oracle_conn)

python大小写转换

('AF').lower()

requirements.txt自动生成

pip install pipreqs
ipreqs ./ --encoding=utf-8

Dataframe专区

apply

# 根据某列赋值
apply(lambda x: if)
# 选取行
.str[-2]  .str.endswith('')
# 

移动几列到最后

import pandas as pd

# 创建示例DataFrame
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9], 'D': [10, 11, 12]})

# 要移动的列索引
columns_to_move = ['B', 'C']

# 重新索引列顺序
for col in columns_to_move:
                total_df[col] = total_df.pop(col)

# 输出结果
print(df)

dataframe某列找出含某字段的行

filtered_df = df[df['A'].str.contains('ap')]

查看dataframe a的每行是否在dataframe b里

import pandas as pd

# 创建示例DataFrame A
df_a = pd.DataFrame({'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']})

# 创建示例DataFrame B
df_b = pd.DataFrame({'col1': [3, 4, 5], 'col2': ['c', 'd', 'e']})

# 检查df_a的每一行是否存在于df_b中
df_a['is_in_df_b'] = df_a.apply(lambda row: any(row.equals(row_b) for _, row_b in df_b.iterrows()), axis=1)

# 打印结果
print(df_a)

# .any()方法检查每一行中是否有任何一个值在DataFrame B中存在，如果存在，则返回True，否则返回False

import pandas as pd

# 创建示例DataFrame A
df_a = pd.DataFrame({'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']})

# 创建示例DataFrame B
df_b = pd.DataFrame({'col1': [3, 4, 5], 'col2': ['c', 'd', 'e']})

# 逐行检查df_a的每一行是否存在于df_b中
for index, row in df_a.iterrows():
    is_in_df_b = row.isin(df_b).all()  # 检查每一行是否存在于df_b中
    print(f"Row {index+1} is in df_b: {is_in_df_b}")
# .all()方法检查所有列是否匹配

dataframe a b, 有共同列 1，2，将a中2缺失的部分用b中的2填充 on 1列

import pandas as pd

# 创建示例DataFrame "a"
data_a = {'1': ['A', 'B', 'C', 'D'],
          '2': [1, None, 3, None]}
df_a = pd.DataFrame(data_a)

# 创建示例DataFrame "b"
data_b = {'1': ['A', 'B', 'C', 'D'],
          '2': [10, 20, 30, 40]}
df_b = pd.DataFrame(data_b)

# 使用merge和fillna合并DataFrame "a" 和 "b"，并进行填充
merged_df = df_a.merge(df_b, on='1', suffixes=('_a', '_b'))
merged_df['2_a'] = merged_df['2_a'].fillna(merged_df['2_b'])

# 最终的DataFrame，将2填充后的结果赋值给 a
final_df = merged_df[['1', '2_a']]
final_df.columns = ['1', '2']
df_a = final_df

print(df_a)

dataframe重命名

import pandas as pd

# 创建示例DataFrame
data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8],
        'C': [9, 10, 11, 12]}
df = pd.DataFrame(data)

# 重命名列
df = df.rename(columns={'A': 'new_A', 'B': 'new_B', 'C': 'new_C'})

print(df)

dataframe有三列，a列为名字，b列为科目，c为分数，现需将a列作为主列，b作为列名，列名重复的加先后的后缀，c作为b列名对应的分数

import pandas as pd

# 创建示例DataFrame
data = {'name': ['Alice', 'Bob', 'Alice', 'Bob', 'Charlie'],
        'subject': ['Math', 'Math', 'Science', 'Science', 'Math'],
        'score': [90, 80, 85, 95, 70]}
df = pd.DataFrame(data)

# 使用pivot_table进行转换
df_pivot = pd.pivot_table(data=df, values='score', index='name', columns='subject', aggfunc='first')

# 处理重复的列名
cols = pd.Series(df_pivot.columns)

# 使用duplicated函数检查是否有重复列名
dup_cols = cols[cols.duplicated()].unique()

# 在重复的列名后加上后缀
for dup_col in dup_cols:
    cols[cols[cols == dup_col].index.values.tolist()] = [dup_col + str(i) for i in range(sum(cols == dup_col))]

# 更新DataFrame的列名
df_pivot.columns = cols

print(df_pivot)

两个表jA B进行left join, 目的是在获取B表的value列，优先on5个字段，对于没有获得值的A表的行 on4个字段再此匹配B表，还没有值的join3个，依次类推

import pandas as pd

# 创建示例DataFrame1
data1 = {'A': [1, 2, 3, 4],
         'B': [5, 6, 7, 8],
         'C': [9, 10, 11, 12]}
df1 = pd.DataFrame(data1)

# 创建示例DataFrame2
data2 = {'A': [1, 2, 3, 4],
         'B': [5, 6, 7, 9],
         'C': [9, 10, 12, 15],
         'E': [17, 18, 19, 20]}
df2 = pd.DataFrame(data2)

# 根据5个字段进行左连接
merged_df = df1.merge(df2, on=['A', 'B', 'C'], how='left')

# 对于没有获得值的A表的行，再次根据4个字段进行左连接
merged_df = merged_df.merge(df2, on=['A', 'B'], how='left', suffixes=('', '_missing1'))

# 对于还没有值的A表的行，再次根据3个字段进行左连接
merged_df = merged_df.merge(df2, on=['A'], how='left', suffixes=('', '_missing2'))

# 以此类推，根据需要多次进行左连接

# 获取B表的value列
merged_df['value_from_B'] = merged_df['E'].fillna(merged_df['E_missing1']).fillna(merged_df['E_missing2'])

print(merged_df[['A', 'B', 'C', 'E', 'value_from_B']])

dataframe删去某列等于某些值的行

import pandas as pd

# 假设您的DataFrame为df，需要删除的列为'列1'，特定值列表为['value1', 'value2', 'value3']
new_df = df[~df['列1'].isin(['value1', 'value2', 'value3'])]

dataframe groupby多列

import pandas as pd

# 假设您的DataFrame为df，需要进行groupby的列为'列1'、'列2'和'列3'
for (a, b, c), group in df.groupby(['列1', '列2', '列3']):
    # 在循环中，a、b、c分别代表每个组的键值
    # group为该组对应的数据

    # 进行您需要的操作
    # 例如：
    print(f"组的键值: {a}, {b}, {c}")
 

dataframe某行某些列同时赋值

import pandas as pd

# 假设您的DataFrame为df，需要赋值的行索引为row_index，需要赋值的列为['列1', '列2']

# 使用.loc方法对指定行的多个列进行赋值
df.loc[row_index, ['列1', '列2']] = [value1, value2]

dataframe某列空值替换

import pandas as pd

# 假设您的DataFrame为df，需要替换的列为'列1'，替换的值为newValue
df['列1'].fillna(newValue, inplace=True)
import pandas as pd

# 假设您的DataFrame为df，需要替换的列为'列1'，NULL字符为'NULL'
df['列1'].replace('NULL', '', inplace=True)

dataframe某列大于10时记录index，若没有大于10的记录最大的index

import pandas as pd

# 假设您的DataFrame为df，列名为'column_name'
# 获取列大于10的记录的索引
greater_than_10 = df[df['column_name'] > 10].index

# 如果没有大于10的记录，获取最大的索引
if len(greater_than_10) == 0:
    max_index = df.index.max()
else:
    max_index = greater_than_10.max()

print(max_index)

dict to Dataframe

import pandas as pd

# 假设有一个字典 data
data = {'列名1': [值1, 值2, 值3],
        '列名2': [值4, 值5, 值6],
        '列名3': [值7, 值8, 值9]}

# 将字典转换为 DataFrame
df = pd.DataFrame.from_dict(data)

dataframe列名大小写转换

cols = df.columns
cols_lower = [x.lower() for x in cols]
df.columns = cols_lower

dataframe某列抽取最后一个字符

df['a'] = df['a'].astype(str)
df['a_simple'] = df['a'].apply(lambda x: x[:-1])

dataframe某列求分位数

df['A'].quantile(0.25)

dataframe query

df.query('A > 2 & B < 8')
df.query('age > 40 & gender == "M"')
df.query('age > @settingage')

# 使用query()函数进行模糊匹配
result = df.query("Name like 'J%'")

dataframe列处理 判断 函数 字典

# map支持字典 函数
gender_dict = {'女':0, '男':1}
df['性别'] = df['性别'].map(gender_dict)
# apply支持函数

dataframe某列的唯一值

df["A"].unique()

dataframe排序

df.sort_values(by=['order1'], ascending=True, ignore_index=True, inplace=True)

dataframe以某列分区 另一列按大小排序 选取小的保留

import pandas as pd

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

# 自定义函数，对每个分区进行排序和选择
def select_smallest_partition(group):
    sorted_group = group.sort_values('sort_column')
    smallest_value_row = sorted_group.head(1)
    return smallest_value_row

# 使用 groupby 和 apply 进行分区、排序和选择
result = df.groupby('partition_column').apply(select_smallest_partition)

# 重置索引并删除分区列
result = result.reset_index(drop=True).drop('partition_column', axis=1)

Numpy专区

import numpy as np
# 创建一个形状为(2, 3)的全零数组
x = np.zeros((2, 3))
print(x)