python字符反转

原文链接：https://blog.csdn.net/a1007720052/article/details/82911813

s = 'abcd'
s[::-1]
#dcba
s[::-2]
#db

Excel打开csv文件乱码

可先用记事本打开，再通过记事本保存文件，保存时选择ANSI编码。（Excel默认编码格式是ANSI编码）

Pandas 较长数字数据导出csv文件后变成科学计数法（带E）的解决办法

通过把每条数据转变成字符串类型后加上‘\t’字符就可以了。
原文链接：https://blog.csdn.net/qq_39290225/article/details/107633758

def deal_str(data):
    data = str(data)+'\t'
    return data

df['平台单号'] = df['平台单号'].map(deal_str)
df.to_csv('D:/data/a.csv')

GPS数据相关

python自己实现geohash
python安装geohash包，报错解决方式:

解决方式

geohash在本地的文件夹
C:\ProgramData\Anaconda3\Lib\site-packages\geohash

geohash前6位字符的精度为600m，即若两个gps位置的geohash编码前6位相同，则地址不超过600m。

路径

读取路径下的所有文件名

import os
for filename in os.listdir(r'c:\windows'):
    print filename

变量赋值、引用

不可变数据类型

对于字符串、整数型、元组等不可变的数据类型的值，变量保存值本身。

spam = 42
cheese = spam
spam = 100
>>>spam
100
>>>cheese
42

可变数据类型

对于list、字典等可变数据类型的值，变量保存对值的引用，而非实际值。要保存实际值，而非引用，可使用a_list.copy()

spam = [0,1,2]
cheese = spam
cheese[1] = 'a' 
>>>spam
[0,'a',1,2]
>>>cheese
[0,'a',1,2]

删除list元素

Del删除指定索引处元素，remove删除指定元素

a_list = [1,3,5]
del a_list[2]
a_list.remove(5)

list排序

a_list.sort()
#逆序
a_list.sort(reverse = True)

按照"ASCII"字符顺序，大写字母排在小写字母之前。

将大csv拆为多个小csv（chunksize分块）

data = pd.read_csv(open('trans.csv'),chunksize = 25000,header = None,sep = '\t')
i = 0
for chunk in data:
  chunk.to_csv('trans_out{}.to_csv'.format(i))
  print(chunk.shape)
  print(i)
  i += 1
  

计算每个字段的空值数量

col_nm = data1.isnull().sum().index.tolist()
null_num = data1.isnull().sum().values.tolist()
a = pd.DataFrame()
a['字段名'] = col_nm
a['空值数量'] = null_num

选取某列不为空值的行

df[df['id'].notnull()]

选取某列为空值的行

df[df['id'].isnull()]

list元素从小到大排序

l2 = [12, 34, 21, 45, 12, 7, 2]
l3 = sorted(l2)

某些列满足特定条件，改变另外某些列的值

import pandas as pd

df = pd.DataFrame({"A": [1, 2, 3, 4], "B": list('abcd'), 'C': [1.2, 2.3, 3.4, 4.5]})
print(df)  # 看一看df
df.loc[df.A > 2, 'B'] = 'changed'  # 关键句
print(df)

list转df

pd.DataFrame(node2_list,columns = ['uid'])

两个list的交集、并集、差集

交集：

#方法一:
a=[2,3,4,5]
b=[2,5,8]
tmp = [val for val in a if val in b]
print tmp
#[2, 5]

#方法二
print list(set(a).intersection(set(b)))

#方法二比方法一快很多！

并集：

list(set(a).union(set(b)))

差集：

list(set(b).difference(set(a))) # b中有而a中没有的      非常高效！

jupyter误删

输入history

两个list循环的简介写法

[x for  x in list1 if x in list2]

去除空白字符

参考

s = 'fh   '
s.strip()
#s = 'fh'

对list做差分

#赌博侦测
wo = [7, 5, 7, 3, 5, 1, 2]
diff = [ wo[i]-wo[i+1] for i in range(len(wo)-1) ]
print(diff)

计算list中某个元素连续出现次数最大值

import itertools
s = [-175, -842, -187, -66, -1, -1, -148, -17, -32, -35, 35, -1, -1, -1, -278, 278, -432,-92, -25, 549, -666, -45, -547, -38, -7, -101,-28, -43, -31, -4, 1510, -1958, -40, -25, -7, -1, -1, -1, -1, -15]
a=[len(list(v)) for k,v in itertools.groupby(s) if k==-1]
print('-1连续出现的最大次数为：%d'%max(a))

一次性取出指定一组key对应的value

from operator import itemgetter
keys = ['a', 'b', 'j']
itemgetter(*keys)(d_dict)

将两个list转化为一对一的字典形式

list1 = ['key1','key2','key3']
list2 = ['1','2','3']
dict(zip(list1,list2))
{'key1':'1','key2':'2','key3':'3'}

将大的csv拆为多个小的csv，并保存

指定每500000行保存为一个csv文件。

import pandas as pd 
rows = pd.read_csv("csvfile.csv", chunksize=500000) 
for i, chuck in enumerate(rows): 
    chuck.to_csv('out{}.csv'.format(i)) # i is for chunk number of each iteration 

判断两个list是否为包含关系（父子集关系）

a = [1,2]
b = [1,2,3]
c = [0, 1]
 
set(b) > set(a)
set(b) > set(c) 

返回
True
False

画多个子图拼在一起

plt.figure(figsize=(10, 3))
plt.subplot(1, 2, 1)
nx.draw_networkx(part_G,labels = None,with_labels = False,node_color = color_train)
plt.title('连通子图编号%d-输入'%i)
plt.subplot(1, 2, 2)
nx.draw_networkx(part_G,labels = None,with_labels = False,node_color = color_train)
plt.title('连通子图编号%d-输出'%i)
plt.show()

image.png

python颜色表

各颜色的代码

df按照某list排序

参考

#df中的card按照node_list排序（gcn算法实现中用到）
#2.构建对应标签
    node_list = list(e.nodes())
    #子网中的卡对应的标签
    df = label_df[label_df['card'].isin(node_list)]
    #将子网的卡按照邻接矩阵的卡顺序排序
    df['card'] = df['card'].astype('category')
    df['card'].cat.reorder_categories(node_list, inplace=True)

   # inplace = True，使 df生效
    df.sort_values('card', inplace=True)

array获取每行的最大值、最大值所在位置

#d为gcn模型输出的5229*3维数组，需得到标签5229*1
idx = np.argmax(d, axis=1)
pro = np.amax(d, axis=1)

统计各元素出现次数

from collections import Counter
Counter(array)

df中：

df['col1'].value_counts()

截取指定字符串

str1 = "Hello.python";
str2 = ".";
  
print str1.index(str2);#结果5
print str1[:str1.index(str2)]     #获取 "."之前的字符(不包含点)  结果 Hello
print str1[str1.index(str2):] ; #获取 "."之前的字符(包含点) 结果.python

去字符化

a = '{a,b,c}'
b = eval(a)
#b = {a,b,c}

匹配或包含模式的字符串

参考资料

In [103]: pattern = r'[0-9][a-z]'

In [104]: pd.Series(['1', '2', '3a', '3b', '03c']).str.contains(pattern)
Out[104]: 
0    False
1    False
2     True
3     True
4     True
dtype: bool

或者是否元素完整匹配一个正则表达式

In [105]: pd.Series(['1', '2', '3a', '3b', '03c']).str.match(pattern)
Out[105]: 
0    False
1    False
2     True
3     True
4    False
dtype: bool

只包含数字的字符串的正则表达式写法

var reg = new RegExp('^[0-9]+$');

要么

var reg = new RegExp('^\\d+$');

包含数字和小数点的字符串的正则表达式写法:

r'^[0-9]+\.[0-9]+$'

删除字符中全部为数字的行

#查找字符串中以某字符开头的行
#以重庆市开头的名称
cut_new[cut_new['原名称'].str.startswith('重庆市')]
#以重庆市结尾的名称
cut_new[cut_new['原名称'].str.endswith('重庆市')]
#包含重庆市的名称
cut_new[cut_new['原名称'].str.contains('重庆市')]

常见报错：

常见报错

解决办法

#删掉全部为数字的名称
new = cut_new[~cut_new['原名称'].str.isdigit()]
print(new.shape)

#重置索引
new = new.reset_index(drop=True)

df按某列的中文拼音顺序重新行排序

a = ['完','莫', 'm', '莫啊里','啊','a', '赵']
out = sorted(a, key=lambda x: x.encode('gbk'))  # ['a', 'm', '啊', '莫', '莫啊里', '完', '赵']

商品名称清洗案例：

#各字段不同取值数
print(name_cut.nunique())
#按照商品名称去重
name_cut = name_cut.drop_duplicates('原名称')
print(name_cut.shape)

#按中文拼音排序

#将名称作为索引
cut_new = name_cut.set_index('原名称')
print(cut_new.shape)

#将名称按照拼音排序
rank = sorted(list(cut_new.index), key=lambda x: x.encode('gbk'))
print(len(rank))
#将索引按照新顺序排序
cut_new = cut_new.reindex(index =rank )
print(cut_new.shape)

cut_new = cut_new.reset_index()
cut_new

cut_new.head()

批量替换元素

df = df.replace({"单身薯片":'单身粮薯片',"达利薯片":'可比克薯片','董薯片':'董小姐薯片','盼薯片':'盼盼薯片','好友薯片':"好丽友薯片",'好丽薯片':"好丽友薯片",'好友趣薯片':"好丽友薯片"})

找出包含特定字符的行

df=data[data['name'].str.contains("薯片")]

排列组合

参考

from itertools import combinations
combinations(str_list, 2)

去除array中的nan、inf等

以0替代

a = np.array([1,2,-1,np.nan,np.inf])
a
array([ 1.,  2., -1., nan, inf])
np.nan_to_num(a)
array([ 1.00000000e+000,  2.00000000e+000, -1.00000000e+000,
        0.00000000e+000,  1.79769313e+308])

标准化

#假设上面有一个DataFrame叫做data
data2 = (data-data.min())/(data.max()-data.min())#即简单实现标准化

data2 = (data-data.mean())/(data.std())  

计算分位数

import numpy as np
 
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# 中位数
print(np.median(a))
# 25%分位数
print(np.percentile(a, 25))
# 75%分位数
print(np.percentile(a, 75))

连续数据离散化

pandas.cut(x,bins,right=True,labels=None,retbins=False,precision=3,include_lowest=False)

bins:划分区间
right:是否包含右端点
precision:精度
include_lowest:是否包含左端点

一行拆分为多行

一行list拆为多行
参考

#对黄牛聚类的卡，分别对每张卡打标
card_label=np.dstack((np.repeat(a.判定结果.values,list(map(len,a.card.values))),np.concatenate(a.card.values)))
pd.DataFrame(data=card_label[0],columns=['判定结果','card'])

同一行数据的多个值拆开
参考

import pandas as pd
    df = pd.DataFrame({'Country': ['China,US', 'Japan,EU', 'UK,Australia', 'Singapore,Netherland'],
                       'Number': [100, 150, 120, 90],
                       'Value': [1, 2, 3, 4],
                       'label': list('abcd')})
    df_split_row = df.drop('Country', axis=1).join(
        df['Country'].str.split(',', expand=True).stack().reset_index(level=1, drop=True).rename('Country'))

github进入、退出python环境

#进入python环境
D:\Softwares\cmder
λ python
#退出
exit()

github 源代码下载至指定文件夹

首先将当前路径跳转至指定文件夹路径下,

C:\Users\Hooper
λ cd Desktop/Recomder-system-20191210/code

其次在指定文件夹路径下复制代码

C:\Users\Hooper\Desktop\Recomder-system-20191210\code
λ git clone https://github.com/qcymkxyc/RecSys.git

跳过错误

stderr

用于重定向错误信息至某个文件。

这里我们先定向错误信息都写入errorlog_abc.txt
__stderr__ = sys.stderr                     #将当前默认的错误输出结果保存为__stderr__
sys.stderr = open('errorlog_abc.txt', 'a')  #将后续的报错信息写入对应的文件中

try except

try...except...检测一段代码，定位错误类型与错误明细。

a = [1,2,3]
try:
    a[3]
except Exception as e:
    print('错误类型是',e.__class__.__name__)
    print('错误明细是',e)

输出结果为：

错误类型是 IndexError
错误明细是 list index out of range

trace模块的traceback函数

讲错误明细的结果保存在指定文件夹，若不指定文件夹，错误明细直接在终端输出。
相关博客

a = [1,2,3]
 
try:
    a[3]
except Exception as e:
    traceback.print_exc(file = open('E:/coding/errorlog_abc.txt','a'))

字典

setdefault

如果键在字典中，返回这个键所对应的值。如果键不在字典中，向字典中插入这个键，并且以default为这个键的值，并返回 default。default的默认值为None.
相关博客介绍

result = dict.setdefault(key, default)

def _init_train(origin_data):
        """初始化训练集数据"""
        train = dict()
        for i in origin_data.index:
            user,item = origin_data.loc[i]['open_id'],origin_data.loc[i]['coupon_id']
            train.setdefault(user, {})
            train[user][item] = 1
        #输出结果为每个用户购买的券
        return train

对其他列求合

#将聚类转账网络由df格式转为图格式
def graph_net(df):
    #输入：转账数据
    #输出：转出卡：转入卡：总笔数，总金额
    gr = dict()
    
    for i in df.index:
        out_card,in_card = df.loc[i]['transfer_outer_card'],df.loc[i]['transfer_in_card']
        gr.setdefault(out_card,{})
        gr[out_card][in_card] = [df[(df['transfer_outer_card'] == out_card) &(df['transfer_in_card'] == in_card)]['trans_num'].sum(),df[(df['transfer_outer_card'] == out_card) &(df['transfer_in_card'] == in_card)]['trans_at'].sum()]
    return gr

get

当所查询的key存在时，key查询和get查询没有区别。

>>> dic = {1:'This is 1', 2:'This is 2'}
>>> dic[1]
'This is 1'
>>> dic.get(2)
'This is 2'

但是当key不存在时，通过key查询报错，get查询不输出任何结果，即程序不停止。

dic = {1:'This is 1', 2:'This is 2'}

for i in [1,0,2]:
    print(dic.get(i))
dic.get(0,'不存在')

输出结果为：

This is 1
None
This is 2
out[79]':不存在'

python跳出for循环

当for循环时，如果满足if条件，自动迭代下一轮，跳过当前i。

#输出结果存储路径
print(city)
out_path = 'md5/md5_results/' + tar + '/' + city
if os.path.exists(out_path):
  continue 
#shutil.rmtree(out_path)
os.makedirs(out_path)

dataFrame按某列值累加

data['new'] = data['Times'].cumsum()

dataFrame按某列从大到小排序

df.sort_values('col1',ascending = False)

dataFrame和字典转化

订单数据为dataframe，包含每个用户买了什么礼券，先需转化为字典形式，train为字典:key为28562个不同的用户,values:为该用户买过的礼券id(原电影数据中还有对应的电影打分)

train = dict()
i = 0

for line in open('../data/only_order_train.csv','r'):
#跳过第一行（第一行为列名）
    i += 1
    if i == 1:
        continue
    #第一列、第二列分别为用户和对应的购买礼券
    user, item = line.strip().split(",")
#转化为字典
    train.setdefault(user, {})
#打分均为1
    train[user][item] = float(1)

range 问题

for i,val in enumerate(list1)

matplotlib

画图中文显示问题

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']

负号显示问题

plt.rcParams['axes.unicode_minus'] = False 

多个dataframe循环拼接

横着拼接

df_list = [df1,df2,...,]
data = pd.DataFrame()
data = pd.concat([df for df in df_list],axis = 1)

merge拼接

pd.merge(df1,df3,on='name',how='outer')
how取值为：
left：只包含左列
right：只包含右列
inner：交集
outer：并集

apply函数

apply：应用在DataFrame的行或列中；
applymap：应用在DataFrame的每个元素中；
map：应用在单独一列（Series）的每个元素中。

df['val'] = df.apply(lambda row: my_min(row['val_1'], row['val_2']), axis=1)
#有时候会报错，可改写为
df['name'] = df.apply(lambda x:f(x) if x.name == '列名' else x,axis = 1)
#依旧来自研究院的奇葩报错，前两种方式均报错
df['name'] = df['列名'].apply(lambda x:f(x))

将某列指定位置的元素进行修改

#将col列指定的index位置的元素修改为0
df.loc[a.index,'col'] = 1

python读取txt文件

按行读取

file = open('兼职模特联系方式.txt', 'r')

try:
    while True:
        text_line = file.readline()
        if text_line:
            print(type(text_line), text_line)
        else:
            break
finally:
    file.close()
"""
<class 'str'> 吴迪 177 70 13888888

<class 'str'> 王思 170 50 13988888

<class 'str'> 白雪 167 48 13324434

<class 'str'> 黄蓉 166 46 13828382
"""

删除某列

withoutSummer = odata.drop(['summer'],axis=1)

读取Excel文件

参考文档

pd.read_excel(io, sheetname=0,header=0,skiprows=None,index_col=None,names=None,
                arse_cols=None,date_parser=None,na_values=None,thousands=None, 
                convert_float=True,has_index_names=None,converters=None,dtype=None,
                true_values=None,false_values=None,engine=None,squeeze=False,**kwds)

读取csv时，自己命名列名

trans = pd.read_csv(f,header=None,sep = '\t',names=['uid','trans_tm','name','dctid','num'] )

将列名按指定顺序排序

order = ['col1','col2',...]
df = df[order]

列名重命名

全部列名重命名

df = pd.DataFrame({'$a':[1,2], '$b': [10,20]})
>>> df.columns = ['a', 'b']
>>> df
   a   b
0  1  10
1  2  20

注：

重命名时需注意

指定列重命名

df = df.
(columns={'oldName1': 'newName1', 'oldName2': 'newName2'})

索引

将索引变为一列

df.reset_index()

重置索引

df.reset_index(drop=True)

将一列变为索引

data = pd.DataFrame(np.arange(1,10).reshape(3,3),index=["a","b","c"],columns=["A","B","C"])
print(data)
'''
  A B C
a 1 2 3
b 4 5 6
c 7 8 9
'''
#将列索引为B的列变成data的行索引
print(data.set_index("B"))
'''
 A C
B
2 1 3
5 4 6
8 7 9

dataframe索引

data = pd.DataFrame(np.arange(9).reshape(3,3),index=["a","b","c"])
#获取第二、三列
print(data.ix[:,1:3])
    '''
       1  2
    a  1  2
    b  4  5
    c  7  8
    '''
    #获取第二行和第三行
    print(data.ix[1:3,:])
    '''
       0  1  2
    b  3  4  5
    c  6  7  8
    '''

选取某一行

#第一行
df.iloc[0]

将多列作为索引

df.set_index(['col','col'])

计算每一列的缺失值

import pandas as pd

a=pd.read_csv(r'路径\数据集.csv',encoding="utf-8") #这里路径尽量用英文，我用中文做路径的时候各种报错

data=pd.DataFrame()

dd=[]
cc=[]
rr=[]

for i in a.columns:
    d=len(a)-a[i].count()
    r=(d/len(a))*100
    rate='%.2f%%' % r
    print('字段名为：',str(i).ljust(10),'缺失值数量:',str(d).ljust(4),'缺失数量占比：',rate) #这里print主要是为了在脚本中观察是否获取到想要的数据，方便调试。
    dd.append(i)
    cc.append(d)
    rr.append(rate)

data[u'字段名为']=dd
data[u'缺失值数量']=cc
data[u'缺失数量占比']=rr

outfile=r'输出路径\处理后数据.xls' 
data.to_excel(outfile) #同样输出路径尽量用英文，输出为xls格式

缺失值处理

只选取包含缺失值的数据

df[df.isnull().values==True].drop_duplicates()

计算某列不含缺失值的个数

#某列不含缺失值的个数
df['a'].count()
#某列不含缺失值的值
df['a'].count

删除表中全部为NA的行

df.dropna(axis=0,how='all')

删除满足某条件的行：

df_clear = df.drop(df[df['x']<0.01].index)
# 也可以使用多个条件
df_clear = df.drop(df[(df['x']<0.01) | (df['x']>10)].index) #删除x小于0.01或大于10的行

删除某列

df.drop(['col',axis = 1)

去重

去重指定列（默认去重所有列）

df.drop_duplicates('col1')

List

list嵌套展开

简单展开

# 普通方法
list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
list_2 = []
for _ in list_1:
    list_2 += _
print(list_2)
 
# 列表推导
list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
list_2 = [i for k in list_1 for i in k]
print(list_2)

复杂情况

def flat(nums):
    res = []
    for i in nums:
        if isinstance(i, list):
            res.extend(flat(i))
        else:
            res.append(i)
    return res

list删除指定元素

list1 = ['1','a',3]
list1.remove('a')