# 忽略 FutureWarning
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)

with open("/tmp/foo.txt") as file:
    data = file.read()
    line = file.readline()
    lines = file.readlines()

with open('example.txt', 'w/w+') as file:
    file.write('Hello, World!\n')

with open('example.txt', 'a/a+') as file: #追加模式
    file.write('Hello, World!\n')

try:
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
except FileNotFoundError:
    print('文件不存在！')
except PermissionError:
    print('无权限访问文件！')
except Exception as e:
    print(f'发生未知错误：{e}')

print("I\'m ok.") # output: I'm ok.
print(r'D:\Users') # output: D:\Users
print("I\'m learning\nPython.") # output：I'm learning 换行 python.
print('\\\n\\') #output:\ 换行 \
print('%%') #output:%

# str-unicode；bytes EN-ascii CN-utf-8
ord('A') # output: 65
chr(65) # output: 'A'
ord('中') # output: 20013
# 该函数可用于字母、数字排序校对

print('A'.encode('ascii'))# output: b'A'
print(b'A'.decode(ascii)) # output: 'A'
print("你好".encode('utf-8')) # output: b'\xe4\xbd\xa0\xe5\xa5\xbd'
len('你好') # output: 2
len(b'\xe4\xbd\xa0\xe5\xa5\xbd') # output: 6
# 1个中文字符经过UTF-8编码后通常会占用3个字节，
#而1个英文字符只占用1个字节。

## 添加前后缀
x=['600050','600976','002024','000063']
l=[i+'.XSHG' for i in x if i[0]=='6'] + [i+'.XSHE' for i in x if i[0]!='6']

## 补齐前位
x=[1,2,7,600001]
def trans_code(code):
    new_code=str(code)
    while len(new_code)<6:
        new_code='0'+new_code
    return new_code
l=[trans_code(i) for i in x]

## 自定义填充
original_string = "example"
width = 10
fill_char = '*'
left_aligned = original_string.ljust(width, fill_char) # 输出: example***
right_aligned = original_string.rjust(width, fill_char)# 输出: ***example
centered = original_string.center(width, fill_char)# 输出: *example**
number = 42
left_pad = "{:05d}".format(number) # 输出: 00042
right_pad = "{:<08.3f}".format(number)# 输出: 42.123000

## 格式化
name = "Alice"
age = 30
formatted_string1 = f"My name is {name} and I am {age} years old."
f_number1 = f"{number:.2f}"
formatted_string2 = "My name is {} and I am {} years old.".format(name, age)
f_number2 = "{:.2f}".format(number)
formatted_string3 = "My name is %s and I am %d years old." % (name, age)
f_number3 = "%.2f" % number

## 替换.replace
ori = "hello world, hello universe"
rep = ori.replace("hello", "hi", 1)# 输出: hi world, hello universe

## 分割.split
ori = "apple,banana,cherry"
split_list = ori.split(',')

## 连接.join
words = ["apple", "banana", "cherry"]
jo = ", ".join(words)# 输出: apple, banana, cherry

## 去重
df['a'].drop_duplicates()

import re
s='''董明珠女士'''
re.findall('[0-9]+', s)#匹配数字

s1=re.findall('[\u4e00-\u9fa5]',s) #剔除非汉字字符
s2=''.join(s1)

pattern='<td><div align="center">([0-9]+)<' #数字
x=re.findall(pattern, string)
relink='<a href="([^\"]+)">' #链接
cinfo=re.findall(relink,string)
pattern2='align=\"center\">([^<]+)</div' #同类信息

#提取所有连接
url_pattern = r'href=[\'"]?([^\'" >]+)'
#提取日期
date_pattern = r'\b(?:\d{4}[-/]\d{2}[-/]\d{2} | \d{2}[-/]\d{2}[-/]\d{4})\b'
#提取文本
html_tag_pattern = r'<[^>]+>(.*?)<\/[^>]+>'
#提取图片url
img_url_pattern = r'src=[\'"]?([^\'" >]+)'
#提取标签
header_pattern = r'<h[1-6]>(.*?)<\/h[1-6]>'

#三个捕获组对应后面的cols
re.findall("jishu\\([0-9]+,([0-9]+),'\n
                ([^']+)','[0-9]+'\\)\" title=\"([^\"]+)"

def count_chinese_word(filepath, encoding='gbk'):
    _dict = {}    
    with open (filepath, 'r', encoding= encoding ,errors="ignore") as txt_file:
            for uchar in txt_file.read():
                 _dict[uchar]=_dict.get(uchar,0)+1 
    return _dict

def is_chinese(uchar):
    if uchar >= u'\u4E00' and uchar <= u'\u9FA5':
        return True
    else:
        return False

#精确模式
import jieba 
seg1 = jieba.cut("迅雷不及掩耳盗铃儿响叮当仁不让我们荡起双桨之势") # 默认精确模式
",".join(seg1)
#output'迅雷不及,掩耳盗铃,儿响,叮,当仁不让,我们,荡起,双桨,之势'

#全模式
seg2 = jieba.cut("迅雷不及掩耳盗铃儿响叮当仁不让我们荡起双桨之势",cut_all=True) 
",".join(seg2)
#output'迅雷,迅雷不及,迅雷不及掩耳,不及,掩耳,掩耳盗铃,儿,响叮当,叮当,当仁不让,不让,我们,荡起,双桨,之,势'

#搜索引擎模式
seg3 = jieba.cut_for_search("迅雷不及掩耳盗铃儿响叮当仁不让我们荡起双桨之势") #搜索引擎模式
",".join(seg3)
#output'迅雷,不及,迅雷不及,掩耳,掩耳盗铃,儿响,叮,不让,当仁不让,我们,荡起,双桨,之势'

#paddel深度学习模式
#精确模式和paddle模式效果差异并不大，仅在一些名称词表现出色一些，但paddle模式非常耗时，多50倍以上
seg4 = jieba.cut("迅雷不及掩耳盗铃儿响叮当仁不让我们荡起双桨之势",use_paddle=True) 
",".join(seg4)
#output'迅雷不及,掩耳盗铃,儿响,叮,当仁不让,我们,荡起,双桨,之势'

#分标签
import jieba.posseg as pseg
seg5 = pseg.cut("迅雷不及掩耳盗铃儿响叮当仁不让我们荡起双桨之势",use_paddle=True) #paddle模式分析出词性
list(seg5)
'''output：[pair('迅雷不及', 'i'),pair('掩耳盗铃', 'i'),pair('儿响', 'n'),pair('叮', 'v'),pair('当仁不让', 'i'),
pair('我们', 'r'),pair('荡起', 'v'),pair('双桨', 'n'),pair('之', 'u'),pair('势', 'ng')]'''

import time

time.time()
time.localtime(secs) # 参数为时间戳秒数，为空则取当前时间
# output: time.struct_time(tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)

time.mktime(t) # 结构化时间转时间戳
# 定制函数字符串转时间戳
def s2timestamp(day):
    st=time.strptime(day, "%Y-%m-%d")
    return time.mktime(st)


time.strptime(string,'%Y-%m-%d %H:%M:%S') # 字符串转结构化
time.strftime('%Y-%m-%d %H:%M:%S', t) # 结构化转字符串
# 定制函数时间戳转字符串
def t2str(t):
    st=time.localtime(t)
    return time.strftime("%Y-%m-%d",st) 
# 时间加法
s = 某date
t2s(s2t(s)+需加的天数*24*3600)
def add_day(day,num):
    smp1=time.mktime(time.strptime(day,"%Y-%m-%d"))
    smp2=smp1+24*3600*num
    day2s=time.localtime(smp2)
    return time.strftime("%Y-%m-%d",day2s)

# 时间减法
t1=s2t('2025-10-01')
t2=s2t('2022-01-01')
(t1-t2)/3600/24

def get_daysdiff(day1,day2):
    smp1=time.mktime(time.strptime(day1,"%Y-%m-%d"))
    smp2=time.mktime(time.strptime(day2,"%Y-%m-%d"))
    return int((smp2-smp1)/3600/24)

# 提取年份
def to_yearmonth(x):
    t=time.strptime(x,'%b-%y') #原本不合规的时间字符串长什么样
    y=time.strftime("%Y",t)
    m=time.strftime("%m",t)
    s = y+m
    return s # 只要年份和月份就单独输出
df['Y']=df['month'].apply(to_y) 

# 提取week
def get_week(day): # time struct 中的 tm_day中的0表示星期一
    return time.strptime(day,"%Y-%m-%d").tm_wday+1

%z  Time zone offset from UTC.
%a  Sun
%A  Sunday
%b  Oct
%B  October
%c  Locale's appropriate date and time representation.
%I  12小时制搭配%p
%p  Locale's equivalent of either AM or PM.
%W  周数，星期一为始 %Y_%W
%j  一年中的第几天

# datetime
def add_day(day, num):
    """
    添加指定天数到给定日期
    :param day: str, 日期字符串，格式为 "%Y-%m-%d"
    :param num: int, 需要添加的天数
    :return: str, 新的日期字符串
    """
    date_obj = datetime.strptime(day, "%Y-%m-%d")
    new_date = date_obj + timedelta(days=num)
    return new_date.strftime("%Y-%m-%d")


def get_week(day):
    """
    获取给定日期的星期几
    :param day: str, 日期字符串，格式为 "%Y-%m-%d"
    :return: int, 星期几（1-7）
    """
    date_obj = datetime.strptime(day, "%Y-%m-%d")
    return date_obj.weekday() + 1

def get_week_start_end(day):
    """
    获取给定日期所在周的开始日和结束日
    :param day: str, 日期字符串，格式为 "%Y-%m-%d"
    :return: tuple, (开始日, 结束日)
    """
    date_obj = datetime.strptime(day, "%Y-%m-%d")
    start_of_week = date_obj - timedelta(days=date_obj.weekday())
    end_of_week = start_of_week + timedelta(days=6)
    return start_of_week.strftime("%Y-%m-%d"), end_of_week.strftime("%Y-%m-%d")

# pandas 
df['date'] = pd.to_datetime(df['date'],format='') #字符串转换为日期格式
df['days_interval'] = df['date'].diff().dt.days  # 计算相邻日期的天数差

# 缺失值查询
df.isnull()
df['col1'].isnull()
df.isnull.sum() #axis=0/1,0列1行

# 筛选有缺失值的行
df.loc[df.isnull().any(1)]
df.loc[~(df.isnull().any(1))] #取反

# 筛选有缺失值的列
df.loc[:,df.isnull().any()]

# 补
df.fillna(0)
df.fillna(method = 'ffill')#行数据向下填充
df.fillna(method = 'ffill',axis=1)#列数据向右填充
DataFrame.interpolate(method='linear'/'pad'/'time'/'nearest'/'cubic'/, axis=0, limit=None, inplace=False, limit_direction=None, limit_area=None, downcast=None, **kwargs)

import random

## 基本随机数生成
random.random() #生成一个 [0.0, 1.0) 范围内的随机浮点数。
random.uniform(a, b)#生成一个 [a, b] 或 (a, b) 范围内的随机浮点数，包括边界。
random.randint(a, b)#生成一个 [a, b] 范围内的随机整数，包括边界。
random.randrange(start, stop[, step])#生成一个从 start 开始，到 stop 结束（不包括 stop），步长为 step 的随机整数。
random.choice(seq)# 从非空序列 seq 中随机选择一个元素。
random.choices(population, weights=None/cum_weights=None, k=1) #从 population 序列中随机选择 k 个元素，指定权重。
random.sample(population, k)#从 population 序列中随机选择 k 个不重复的元素。

## 序列操作
random.shuffle(x[, random])#就地打乱可变序列 x 的顺序。
random.permutation(x)#返回一个新的序列，包含 x 中所有元素的随机排列。

## 分布相关的随机数
random.paretovariate(alpha)#alpha=1.5 二八分布帕累托
random.gauss(mu, sigma)#生成一个符合均值为 mu，标准差为 sigma 的高斯分布（正态分布）的随机浮点数。
random.expovariate(lambd)#生成一个符合指数分布的随机浮点数，lambd 是速率参数。
random.lognormvariate(mu, sigma)#生成一个符合对数正态分布的随机浮点数。
random.poissonvariate(mu)#生成一个符合泊松分布的随机整数。
random.triangular(low, high=None, mode=None)#生成一个符合三角形分布的随机浮点数，范围在 [low, high] 之间，mode 指定峰值位置。

## 种子设置
random.seed()
random.getstate()#返回当前随机数生成器的状态。
random.setstate(state)#设置随机数生成器的状态为之前保存的状态。

## 其他实用工具
random.getrandbits(k) #生成一个 k 位的随机整数。
random.randbytes(n) #生成一个长度为 n 的随机字节串

# 1.公式法
def gini(L):
    s1=0
    s2=0
    for i in L:
        s2 += 2*len(L)*i #分母
        for j in L:
            s1 += abs(i-j) #分子 绝对值
    return s1/s2
L=[]
for i in df.index:
    L=L+[ df.loc[i,'income'] for j in range(int(df.loc[i,'people']/10000))]
gini(L)

#2.洛伦兹曲线（见画图）

s=0 #面积B（洛伦兹曲线内）
for i in df.index[1:]:
    people1=df.loc[i-1,'洛伦茨曲线'] #梯形的下底
    people2=df.loc[i,'洛伦茨曲线'] #梯形的上底
    people_ratio=df.loc[i,'people_ratio']
    s+=(people1+people2)*people_ratio*0.5
Gini=round((100*100*0.5-s)/(100*100*0.5),2)
Gini    

#夏普
for code in 个股夏普率.index:    
    df12=df11[df11['证券代码']==code]
    个股夏普率.loc[code,'夏普率']=(df12['考虑现金红利再投资的日个股回报率'].mean()
                           *交易日数-0.015)/(df12['考虑现金红利再投资的日个股回报率'].std()
                                        *交易日数**0.5) #每年242个交易日

#计算多年涨幅
years=sorted(list(set(df["year"])))
for y in years:
    df0=df[df["year"]==y].sort_values("trade_date")
    mul=1
    for i in df0.index:
        mul=mul*(df0.loc[i,"pct_chg"]+100)/100
    df1.loc[df1.shape[0]+1]={"年份":y,"涨幅":mul*100-100}

#按照涨幅复权价格
df1['price']=(df1['pct_chg']/100+1).cumprod()

#360日移动平均线
df1['360days_avg']=df1['price'].rolling(360,min_periods=10).mean() #对时间序列数据进行快速的移动平均计算
df1.plot(y=['price','360days_avg'])

js['市值']= js['总股数'] * js['日收盘价']

df_demand["demand_nominal"]=df_demand["demand_reali"]+(100*inlfation-100)

china["名义增长率"]=china["地区生产总值"].pct_change()*100
china["实际增长率"]=china["地区生产总值指数(上年＝100)"]-100

#同比环比
#pct_change(12) 表示相对于12个月前的变化，计算同比；默认计算环比变化
df["M0环比"]=df["m0"].pct_change()
df["M0同比"]=df["m0"].pct_change(12)

#用环比算环比指数
for i in df2.index:
    if i==0:
        df2.loc[i,'房价100指数']=(df2.loc[i,'房价100环比']+100)/100
    else:
        df2.loc[i,'房价100指数']=(100+df2.loc[i,'房价100环比'])*df2.loc[i-1,'房价100指数']/100

#季节趋势
import statsmodels.tsa.seasonal as sea
mul=sea.seasonal_decompose(df3['m0'], model='multiplicative', extrapolate_trend='freq')  
add = sea.seasonal_decompose(df3['m0'], model='additive', extrapolate_trend='freq')

#pmdarima 自动搜索 ARIMA 模型的最佳参数组合
from pmdarima import auto_arima # 需要将numpy降级 pip3 install "numpy<2" 
import pandas as pd
import time
model = auto_arima(df['m0'][:279],seasonal=True, m=12, trace=True,error_action="ignore")
forecasts = model.predict(4)#预测值
df['m0'][279:]#实际值

import numpy as np
benford= np.log10(1 + 1 / np.arange(1, 10))

#离差标准化
import pandas as pd
df=pd.DataFrame([1,9,1,2,2,3,4,5,6,500],columns=["data"])
x_max = df['data'].max()
x_min = df['data'].min()
df['离差标准化'] = (df['data'] - x_min) / (x_max - x_min)

#标准差标准化，标准差为1
x_mean = df['data'].mean()
x_std = df['data'].std()
df['标准差标准化'] = (df['data'] - x_mean) / x_std
df['变量中心化'] = (df['data'] - x_mean) 

#小数定标标准化
import numpy as np
k_max = abs(df['data']).max()
k = np.ceil(np.log10(k_max))
df['小数定标标准化'] = df['data'] / 10 ** k

#取对数
df['取对数'] = df['data'].apply(np.log)
df['取对数+1']=df['data'].apply(lambda x:np.log10(x+1))

#取变量排序值
df["排序"]=df['data'].rank(method='average')

df.corr()
df.describe()

#多重共线性检验
X=df1[["除被解释变量外的变量列"]].copy()
X["常数项"]=1
vif=pd.DataFrame()
vif["features"] = X.columns
vif["vif factor"]=[statsmodels.stats.outliers_influence.variance_inflation_factor(X.values,i) for i in range(X.shape[1])]      
vif
#=1没有多重共线性。1-5表示存在中度多重共线性；大于5表示存在严重的多重共线性。

import statsmodels.formula.api as smf
from linearmodels.panel import PanelOLS
from linearmodels import RandomEffects
import statsmodels as sm

#直接关系
results = smf.ols('Y  ~  X1 +  X2', data=df).fit()
print(results.summary())
results.params
results.resid
results.pvalues
results.rsquared
#OLS法二
exog_vars =['X1','X2']
exog = df[exog_vars].copy()
exog['常数项']=1
mod = PanelOLS(df['Y'], exog)
ols_res = mod.fit()

#调节关系
df=df.copy()
df['price1']=df['price']-df['price'].mean()
df['m_quanqiugou1']=df['m_quanqiugou']-df['m_quanqiugou'].mean()
df['price_quanqiu']=df['price1']*df['m_quanqiugou1'] #交叉项
results = smf.ols('Y  ~  price1 + m_quanqiugou1 + price_quanqiu ', data=df).fit()

#随机效应
mod = RandomEffects(df['Y'], exog)
re_res=mod.fit()

#固定效应
mod = PanelOLS(df['Y'], exog,entity_effects=True)
fe_res = mod.fit()

#2SLS
reg4 = smf.ols('产权保护指数89_95  ~   居民死亡率对数 ', data=df7).fit()
df7['预测产权保护指数4'] = reg4.predict()
reg7 = smf.ols('人均GDP95对数  ~   预测产权保护指数4 ', data=df7).fit()

import numpy as np
from scipy.stats import chi2
def hausman_test(fe_res, re_res):
    # 提取系数
    b_FE = fe_res.params
    b_RE = re_res.params
    # 系数的差异
    beta_diff = b_FE - b_RE
    # 协方差矩阵差异的逆矩阵
    cov_diff = fe_res.cov - re_res.cov
    cov_diff_inv = np.linalg.inv(cov_diff)
    # 计算豪斯曼统计量
    hausman_stat = beta_diff.T @ cov_diff_inv @ beta_diff
    # 自由度为参数数量
    df_hausman = len(b_FE)
    # 计算 p 值
    p_value = 1 - chi2.cdf(hausman_stat, df_hausman)
    return hausman_stat, df_hausman, p_value #卡方，自由度，P值
hausman_test(fe_res, re_res)    

if p_value < 0.05:
    print("选择固定效应模型")
else:
    print("选择随机效应模型")

#排版单列
def show_one(result,title=""):
    df0=pd.DataFrame(columns=["变量",title])
    list1=list(range(1,len(result.params)))+[0]
    for i in list1:
        beta=str(round(result.params.iloc[i],3))
        p=result.pvalues.iloc[i]
        star=""
        if p <= 0.01:
            star="***"
        elif p <= 0.05:
            star="**"
        elif  p <= 0.1:
            star="*"
        if hasattr(result,'bse'):
            bse="("+str(round(result.bse.iloc[i],3))+")"
        elif hasattr(result,'std_errors'):
            bse="("+str(round(result.std_errors.iloc[i],3))+")"
        df0.loc[df0.shape[0]+1]={"变量":result.params.index[i],title:beta+star+""+bse}
    if hasattr(result,'resid'):
        lens=len(result.resid)
    elif hasattr(result,'resids'):
        lens=len(result.resids)
    df0.loc[df0.shape[0]+1]={"变量":"常数项",title:round(result.params.iloc[0],3)}
    df0.loc[df0.shape[0]+1]={"变量":"样本量",title:lens}
    df0.loc[df0.shape[0]+1]={"变量":"R平方",title:round(result.rsquared,3)}
    #df0.loc[df0.shape[0]+1]={"变量":"x ",title:"x"}
    return df0.set_index("变量")

#排版多个回归，先设置showone
def show_more(rs):
    df0=pd.DataFrame()
    for i in range(len(rs)):
        df1=show_one(rs[i],"("+str(i+1)+")")
        df0=pd.concat([df0,df1],axis=1,sort=False)
    df0=df0.fillna("")
    df1=df0.drop(["样本量","R平方","常数项"])
    df1.loc["常数项",:]=df0.loc["常数项",:]
    df1.loc["样本量",:]=df0.loc["样本量",:]
    df1.loc["R平方",:]=df0.loc["R平方",:]    
    #df1.loc[df0.shape[0]+1]={"变量":"x ",title:"x"}
    from IPython.display import display
    display(df0.style.set_properties(**{
        'white-space': 'pre-wrap',
    }))
    return df1 

re_fixs=[]
for exog_vars in [exog_vars1,exog_vars2,exog_vars3,exog_vars4]:
    exog = df[exog_vars].copy()
    exog['常数项']=1
    mod = PanelOLS(df['Log应用绩效'], exog,entity_effects=True)
    re_fixs.append( mod.fit())
show_more(re_fixs)

df['state']=df['code'].apply(lambda x:int(x[0]=='6'))
df['time']=df['time'].apply(lambda x:int(x>=201307))

#文件处理
df=pd.read_csv(filename, encoding='gbk'/'UTF-8')
df=pd.read_table(filename, sep=',', encoding='gbk')#从限定分隔符,的文件或文本读取数据

df=pd.read_json(r'路径')
#{"name1":"rose1","name2":"rose2","name3":"rose3"}
#{"authors":[ {"name":"rose1"},  {"name":"rose2"}, ], "musicians":[ {"name":"rose1"} ] }
df=pd.read_excel(r'路径')
df=pd.read_feather(r'路径')

df.to_csv('1.csv')
df.to_excel('1.xlsx',index=False)
df.to_json('1.txt')

#基本操作
df=pd.DataFrame(columns=["A","B"])
df.head(num)
df.tail(num)
df.shape
df.shape[0] #行数，[1]列数
pd.set_option('display.max_rows')
pd.set_option('display.max_columns', 100)
df.values #不含行列索引的二维array
df.T

#缺失
pd.isnull(df)#判断数据是否为nan
df.isnull().any()#检查哪些列包含缺失值
df.isnull().sum()#统计各列空值
df[~df['A'].isnull()]#删除本列中空值的行
df[df['A'].isnull()]#仅保留本列中是空值的行

#修改
df.drop(0, axis=0)#去掉某行
df.drop('A', axis=1)#去掉某列
df.dropna()#删除所有包含空值的行
df.dropna(axis=1)#删除所有包含空值的列
df.append({"A":1,"B":1})#添加一行
df.loc[df.shape[0]+1]=d #添加一行d={"A":1,"B":1}

#行索引
df.index
df.set_index('A') #将A列设置为index
df = df.reset_index(drop=True) #重设index
df.rename(lambda x: x + 10)

#列索引
df.columns
df.rename(columns={'A':'a'},inplace=True)
df.rename(columns=lambda x: x + '_1')

#切片
df['列名1']#选取一列，得到Series格式
df[ ['列名1','列名2'] ]#选取多列，得到DataFrame格式
df[0:3] #选取行索引0,1,2这3条记录，也是DataFrame格式

df.loc[行标签，列标签]， df.loc[行标签]#如果行标签和列标签都是列表，则得到DF格式，否则只有一个为值得Series,两者都为值则得到一个具体的值。
df.loc['001', :]#索引为'001'的行，所有列
df.loc[['001','003'], :]#索引为'001'或'003'的行，所有列
df2.loc[:, '姓名']#列索引为'姓名'，所有行

df.iloc[行数值索引，列数值索引]#基本同df.loc，只是用索引数值进行引用
df.iloc[:3, :]#选取前3行
df.iloc[:, 0:3]#选取前3列

#筛选
df[(df.A >=1 ) & (df.B < 0) ]
df.loc[df2['A']>80,['B','C']]
df[df['D'].isin([0,9])]#选取 D 列中数为 0 和 9 的数
df.query('a > b') #即 df[df.a > df.b]

#排序
df.sort_values(by=['col1','col2'],ascending=True)#升序

#排名
df.rank(axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)
'''axis:0 或 'index';1 或 'columns'
method:'average':如果多个元素具有相同的值排名平均值/'min'/'max'/'first': 按出现顺序;'dense': 与 'min' 类似，但排名是连续的。
numeric_only:True: 仅对数值列进行排名/False: 对所有列进行排名/None（默认）: 根据数据类型自动判断。
na_option:'keep'（默认）: 保留 NaN 值/'top': 将 NaN 值排在最前面。'bottom': 将 NaN 值排在最后面。
ascending:True（默认）: 从小到大排名。False: 从大到小排名。
pct:True: 返回百分位排名。'''

#平移 多用于时间序列
df.shift(periods=1, freq=None, axis=0, fill_value=None)
'''periods：整数，表示要平移的周期数。正值表示向下或向右平移，负值表示向上或向左平移。
freq：日期偏移量，用于时间序列数据。例如，'D' 表示按天偏移，'M' 表示按月偏移。
axis：整数或字符串，表示沿哪个轴进行平移。0 或 'index' 表示沿行方向平移，1 或 'columns' 表示沿列方向平移。
fill_value：用于填充平移后空缺位置的值。默认为 NaN。'''

#分割列
df1['time']=df1['month'].apply(lambda x:str(x)[:10])# 伪字符串转字符串
df2 = df['姓名'].str.split('-',expand=True)
df2.columns = ['学号','姓名']

#找最小值
df[df["x"]==df["x"].min()]

#跨行计算
df['A'].cumsum 样本值累计和
df.cummin，cummax 样本值累计最大值和累计最小值
df.cumprod 样本值累计积
df.diff 计算一阶差分（对时间序列很有用）
df.pct_change 计算百分数变化

#分组
df.groupby(列名).sum() #分组求和
df.groupby(['列名1','列名2']).count() #分组计数
df.groupby(['列名1','列名2']).mean() #分组求均值
df2.groupby('省份')['B'].agg([np.sum, np.mean])#按省份分组计算B总分和平均分
df2['平均分'] = df2.groupby('省份')['A'].transform('mean')

df.groupby(列名).apply(自定义函数) #自定义函数的参数为列表

#合并
df3=pd.concat([df1,df2])#竖着拼，列名一致

df4=pd.concat([df41,df51],axis=1)#共同索引
df4=pd.merge(df1,df2,how="left",on=['A','B'])

#取对数
df[列].apply(lambda x: np.log(x))

df['date'] = pd.to_datetime(df['date'],format='') #字符串转换为日期格式
df['days_interval'] = df['date'].diff().dt.days  # 计算相邻日期的天数差

%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
mpl.rcParams['font.serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus']=False
plt.rcParams["figure.dpi"] = 300

df.plot(y='A',title='B',kind='scatter/bar/line',ax=plt.gca())
plt.savefig('filename.png', dpi=300, format='png') #保存为 png格式

df.plot(y=['列1','列2'],figsize=(10,5), title="标题")
#x只能一个，但y可以指定多个，多个y一般需要在一个数量级上，否则需要建立双坐标
df.plot(secondary_y=['列2']) #双坐标体系

fig,ax = plt.subplots(1,2, figsize=(10, 5))#双子图
df3.sort_values('A',ascending=False).head(10).plot(y=['A','B'],kind='bar',ax=ax[0])
df3.sort_values('B',ascending=False).head(10).plot(y=['A','B'],kind='bar',ax=ax[1])

import seaborn as sns
sns.set(rc={"figure.dpi":300, 'savefig.dpi':300})
sns.set_context('notebook')
sns.set_style("ticks")

sns.pairplot(df1)
sns.lmplot(x='price',y='sales',hue='m_quanqiugou',data=df)

sns.barplot(x="",y="",data=df)

sns.boxplot(x='', y='', data=df)

import matplotlib as mpl

## 先累计再算比重
df['all_income']=df['people']*df['income']#每类人群的总收入
df['people_cum']=df['people'].cumsum() #累积人口（总人口）
df['people_ratio']=df['people']/df['people'].sum()*100
df['people_ratio_cum']=df['people_cum']/df['people_cum'].max()*100 
#最后累积总数
df['all_income_cum']=df['all_income'].cumsum()
df['洛伦茨曲线']=df['all_income_cum']/df['all_income_cum'].max()*100
df['绝对平均线']=df['people_ratio_cum']

## 先比再累积
df2011['收入占比']=df2011['家庭年收入']/df2011['家庭年收入'].sum()
df2011['洛伦茨曲线']=df2011['收入占比'].cumsum() 
df2011['人数占比']=1/df2011.shape[0]
df2011['人数累计占比']=df2011['人数占比'].cumsum()
df2011['绝对平均线']=df2011['人数累计占比']

df.plot(x='people_ratio_cum', y=['洛伦茨曲线','绝对平均线'])

from urllib import request, parse
import time
import random

#函数化处理GET
def get_url(url):
    head = {}
    head['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) \n
    AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 \n
    Safari/537.36'
    req = request.Request(url, headers=head)
    response = request.urlopen(req)   
    html=response.read()
    string=html.decode('utf8')
    time.sleep(random.random()*2) #平均间隔1秒,避免过度查询
    return string

#函数化处理POST
def post_url(url,data):
    head = {}
    head['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) \n
    AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 \n
    Safari/537.36'
    data = parse.urlencode(data).encode('utf-8')
    req = request.Request(url,data=data, headers=head)
    response = request.urlopen(req)   
    html=response.read()
    string=html.decode('utf-8')
    time.sleep(random.random()*2) #平均间隔1秒,避免过度查询
    return string

''' SnowNLP'''
s = SnowNLP(u'xxxx')
print(s.sentiments)

from snownlp import SnowNLP
import pandas as pd
mix=pd.read_csv('/home/public/Data/mix.csv',encoding='gbk')
mix=mix.dropna()
mix

#测评
right=0
wrong=0
for i in mix.index:
    txt=mix.loc[i,'txt']
    fen=mix.loc[i,'fen']
    s = SnowNLP(txt)
    f=s.sentiments #打分
    print((f,fen))
    if  f>0.5 and fen>=3 or f<0.5 and fen<2.5:
        right += 1
    else:
        wrong += 1
print("机器评分正确率为：",right/(right+wrong))

# 训练保存
sentiment.train('/home/public/Data/low.txt',
                '/home/public/Data/high.txt')
sentiment.save('/home/public/Data/douban.marshal')
sentiment.load('/home/public/Data/douban.marshal')

# 人脸识别cv2模块
#图片中的人脸识别  pip3 install opencv-python  ipywidgets
%matplotlib inline
import cv2
from matplotlib import pyplot as plt
import ipywidgets as widgets
from IPython.display import display
import os
img = cv2.imread('/home/public/Data/nju1.jpg')

case = cv2.CascadeClassifier()
case.load('/home/public/Data/haarcascade_frontalface_default.xml')
faces = case.detectMultiScale(img)
print(faces)
#使用detectMultiScale方法检测图像中的人脸，
#返回值是一个矩形列表，每个矩形表示一个人脸的位置和大小

sampleNum=0
for (x, y, w, h) in faces:
    sampleNum+=1
    img = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 255), 2)
    #对于每个检测到的人脸，在原图上绘制黄色矩形框
    cv2.imwrite("/home/public/data/face"+str(sampleNum) +
                ".jpg", img[y:y + h, x:x + w]) 
    #截取的人脸区域保存为新的图像文件。
show_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #从BGR颜色空间转换为RGB
plt.imshow(show_img)

import networkx as nx
import matplotlib.pyplot as plt 
import random

## 无向图
G = nx.Graph()
G.add_nodes_from([1, 2, 3, 4,5])
G.add_edges_from([(1, 2), (2, 1), (2, 3),(2,4),(4,5)])
nx.draw(G,with_labels=True,node_color='red',
        font_size =25, node_size=1000)

##有向图
G = nx.DiGraph()
G.add_nodes_from([1, 2, 3, 4,5])
G.add_edges_from([(1, 2), (2, 1), (2, 3),(2,4),(5,2)])
nx.draw(G,with_labels=True,node_color='red',
        font_size =20, node_size=500)

## 随机生成网络,不允许自指向，20节点，60条边
G = nx.DiGraph()
nodes=range(1,21)
G.add_nodes_from(nodes)
edges=[]
for i in range(61):
    x=random.choice(nodes)
    y=random.choice(list(set(nodes)-set([x])))
    edges.append((x,y))
G.add_edges_from(edges)
nx.draw(G,with_labels=True,node_color='red',font_size =15, node_size=500)


## 随机,不允许自指向，20节点，每个节点关注3个邻居
G = nx.DiGraph()
nodes=range(1,21)
edges=[]
for i in nodes: #为每个节点随机选择三个不同的节点并生成边
    x1=random.choice(list(set(nodes)-set([i])))
    x2=random.choice(list(set(nodes)-set([i,x1])))
    x3=random.choice(list(set(nodes)-set([i,x1,x2])))
    edges.append((i,x1))
    edges.append((i,x2))
    edges.append((i,x3))
G.add_edges_from(edges)
pos=nx.shell_layout(G)
nx.draw(G,pos,with_labels=True,node_color='',
        font_size =15, node_size=500)

## 中心-边缘网络
G1 = nx.DiGraph()
nodes=range(1,21)
nodes1=list(range(1,11))#中心节点
nodes2=list(range(11,21))#边缘节点
edges=[]
for i in nodes1: #中心节点，只关注中心节点
    x1=random.choice(list(set(nodes1)-set([i])))
    x2=random.choice(list(set(nodes1)-set([i,x1])))
    x3=random.choice(list(set(nodes1)-set([i,x2,x1])))
    edges.append((i,x1))
    edges.append((i,x2))
    edges.append((i,x3))
for i in nodes2: #边缘节点，关注中心节点
    x1=random.choice(list(set(nodes)-set([i]+nodes2)))
    x2=random.choice(list(set(nodes)-set([i,x1]+nodes2)))
    x3=random.choice(list(set(nodes)-set([i,x2,x1]+nodes2)))
    edges.append((i,x1))
    edges.append((i,x2))
    edges.append((i,x3))    
G1.add_edges_from(edges)
pos=nx.shell_layout(G1)
nx.draw(G1,pos,with_labels=True,node_color='red',
        font_size =15, node_size=500)

## 环形网络，每个节点关注后面3个其他节点，均匀对称
G2 = nx.DiGraph()
nodes=range(1,21)
edges=[]
for i in nodes: #中心节点，只关注中心节点
    edges.append((i,(i)%len(nodes)+1))
    edges.append((i,(i+1)%len(nodes)+1))
    edges.append((i,(i+2)%len(nodes)+1))  
G2.add_edges_from(edges)
pos=nx.circular_layout(G2)
nx.draw(G2,pos,with_labels=True,node_color='red',
        font_size =15, node_size=500)

## 中心度
df=pd.DataFrame(nx.degree_centrality(G1), #同理查看其他中心度
             index=["度中心度"]).T.sort_values("度中心度",
                                           ascending=False)
nx.degree_centrality(G1)#度中心度
nx.in_degree_centrality(G1)#入中心度
nx.out_degree_centrality(G2)#出中心度

nx.closeness_centrality(G1)#接近中心度
nx.betweenness_centrality(G1)#中介中心度
nx.eigenvector_centrality(G1)#特征向量中心度
nx.clustering(G1) #群聚系数

len(G.edges())#边的总数，当网络可变时，可衡量网络效应大小