pandas库的学习

pandas

官方手册

定义：pandas是基于NumPy数组构建的，使数据预处理、清洗、分析工作变得更快更简单。pandas是专门为处理表格和混杂数据设计的，而NumPy更适合处理统一的数值数组数据。

import pandas as pd

数据结构：Series | DataFrame。

Series：pd.Series(list,index=[ ]) 类似于一维数组的得对象，是由一组数据+一列索引组成。可以使用切片，运算等操作，类似于ndarray。

DataFrame：pd.DataFrame(data,columns = [ ],index = [ ]) 是一个表格形的数据类型。常用类型。axis = 1 列 axis = 0 行

数据转换：

1：pd.DataFrame(Series) 可以把Series结构变为DataFrame。

2：DataFrame.values 可以把DataFrame结构变为 一个numpy 的ndarray。也可以通过索引或者列名获得一个Series。df['列名'] 或者 df.列名。

pd.read_excel()

pandas.read_excel(io, sheet_name=0, header=0, names=None, index_col=None, parse_cols=None, usecols=None, squeeze=False, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, verbose=False, parse_dates=False, date_parser=None, thousands=None, comment=None, skip_footer=0, skipfooter=0, convert_float=True, mangle_dupe_cols=True, **kwds)

读取Excel参数详解

读取tmp.xlsx文件，指定第一列和第二列数据类型：
>>> pd.read_excel('tmp.xlsx', index_col=0, dtype={'Name': str, 'Value': float})
    Name  Value
0   string1    1.0
1   string2    2.0

如果需要返回多个表，可以将sheet_name指定为一个列表，例如['sheet1', 'sheet2']

可以根据sheet名或索引index来指定要选取的sheet

pd.read_excel('1.xlsx', sheet_name=0)
pd.read_excel('1.xlsx', sheet_name='Sheet1')
# 返回的是相同的DataFrame

usecols：读取指定列，也可以通过名字或索引值

usecols参数是一个列表，不支持切片写法。比如：
usecols=[1,2,3,4,5]，不能写成usecols=[1:5]会报错。

pd.read_excel(path,None)*#读取数据,设置None可以生成一个字典，字典中的key值即为sheet名字

读取两列保存为list

import pandas as pd
def excel_one_line_to_list():
    df = pd.read_excel("test.xlsx", usecols=[1, 2],
                       names=None)
    df_li = df.values.tolist()
    print(df_li)

输出  
[['51有色', '电子商务'], ['优生国际', '医疗健康'], ['名片侠', '工具软件'], ['约珥传媒', '文娱传媒']]

DataFrame转dict

df =  a	  b	  c
0	test sun red
1	test sun red
2	test sun red

以columns列名为key，每列元素为value
要获得：{'a' : [test,test,test], 'b' : [sun,sun,sun], 'c' : [red,red,red]}
>>>{col:df[col].tolist() for col in df.columns}

按行操作数据

import pandas as pd
df=pd.read_excel('data.xlsx') #这个会直接默认读取到这个Excel的第一个表单
data=df.ix[[1,2]].values #读取指定多行的话，就要在ix[]里面嵌套列表指定行数

#读取指定的多行多列值
data=df.ix[[1,2],['red','green']].values#读取第一行第二行的title以及data列的值，这里需要嵌套列表

#获取所有行的指定列
data=df.ix[:,['red','green']].values

对某一行进行筛选

# 筛选使用的是data.loc[列名称 = 提取的信息]
import pandas as pd
path = 'G:\动力系\新建文件夹\什么.xls'
data = pd.DataFrame(pd.read_excel(path))
result = data.loc[data['院系'] == '动力']#以院系列为key筛选，选出动力的行
print(result)

数据导入导出

#数据导入
pd.read_csv(filename)：从CSV文件导入数据
pd.read_table(filename)：从限定分隔符的文本文件导入数据
pd.read_excel(filename)：从Excel文件导入数据
pd.read_sql(query, connection_object)：从SQL表/库导入数据
pd.read_json(json_string)：从JSON格式的字符串导入数据
pd.read_html(url)：解析URL、字符串或者HTML文件
pd.read_clipboard()：从粘贴板获取内容
pd.DataFrame(dict)：从字典对象导入数据

#数据导出
df.to_csv(filename)：导出数据到CSV文件
df.to_excel(filename)：导出数据到Excel文件
df.to_sql(table_name, connection_object)：导出数据到SQL表
df.to_json(filename)：以Json格式导出数据到文本文件

数据清洗

pd.isnull()：检查DataFrame对象中的空值，并返回一个Boolean数组
pd.notnull()：检查DataFrame对象中的非空值，并返回一个Boolean数组
df.dropna()：删除所有包含空值的行
df.fillna(x)：用x替换DataFrame对象中所有的空值
s.astype(float)：将Series中的数据类型更改为float类型

数据处理

df.count()：返回每一行或列包含的非空数据个数，不包括None, NaN, NaT等
df['col1'].unique()：查看某一列内有哪些不同的值
df.describe()：查看数据值列的汇总统计
df.max()：返回每一列的最大值
df.min()：返回每一列的最小值

数据选取

df[col]：根据列名，并以Series的形式返回列
df[[col1, col2]]：以DataFrame形式返回多列
s.iloc[0]：按位置选取数据
s.loc['index_one']：按索引选取数据

df.loc基于标签，df.iloc基于索引（从0开始），ix基于标签或索引
df.iloc[0,:]：返回第一行
df.iloc[3] #第四行
df.iloc[:,3] #第四列
df.iloc[3:5,0:2] #第四到六行，第一到三列
df.iloc[[4,5,6],[0,1,2]] #第四到六行，第一到三列

df[] #这是对行进行切片

举例：
df.loc[0:10] #切片方式查看前10个元素
df.loc(83, "列名")#定位到某个元素，行列分别是：83为行数和列名

Dataframe或series转换成list

df = pd.DataFrame({'a':[1,3,5,7,4,5,6,4,7,8,9], 'b':[3,5,6,2,4,6,7,8,7,8,9]})
 
# 把a列的元素转换成list：
df['a'].values.tolist()   或  df['a'].tolist()

# 把a列中不重复的元素转换成list
df['a'].drop_duplicates().values.tolist()

# 把series转换为list
Series.tolist()

dataframe to array/dict

import numpy as np
import pandas as pd
from pandas import DataFrame
 
data=[["animal",2000,1.5],["ambition",2001,1.7],["balance",2002,3.6],["city",2001,2.4],["decade",2002,2.9]]
pd=DataFrame(data,index=["A","B","C","D","E"],columns=['words', 'year', 'number'])
#dataframe to array
ndarray=np.array(pd)
print(ndarray)
print(ndarray.shape)
#输出为：
#[['animal' 2000 1.5]
# ['ambition' 2001 1.7]
# ['balance' 2002 3.6]
# ['city' 2001 2.4]
# ['decade' 2002 2.9]]
#(5, 3)
 
 
#dataframe to dict
#dict返回的是dict of dict；list返回的是列表的字典；series返回的是序列的字典；records返回的是字典的列表
dict_data1=pd.to_dict(orient="dict")
print(dict_data1)
#输出为：{'words': {'A': 'animal', 'B': 'ambition', 'C': 'balance', 'D': 'city', 'E': 'decade'}, 'year': {'A': 2000, 'B': 2001, 'C': 2002, 'D': 2001, 'E': 2002}, 'number': {'A': 1.5, 'B': 1.7, 'C': 3.6, 'D': 2.4, 'E': 2.9}}
dict_data2=pd.to_dict(orient="list")
print(dict_data2)
#输出为：{'words': ['animal', 'ambition', 'balance', 'city', 'decade'], 'year': [2000, 2001, 2002, 2001, 2002], 'number': [1.5, 1.7, 3.6, 2.4, 2.9]}
dict_data3=pd.to_dict(orient="series")
print(dict_data3)
#输出为：
#{'words': A      animal
#B    ambition
#C     balance
#D        city
#E      decade
#Name: words, dtype: object, 'year': A    2000
#B    2001
#C    2002
#D    2001
#E    2002
#Name: year, dtype: int64, 'number': A    1.5
#B    1.7
#C    3.6
#D    2.4
#E    2.9
#Name: number, dtype: float64}
dict_data4= pd.to_dict(orient='records')
print(dict_data4)
#输出为：[{'words': 'animal', 'year': 2000, 'number': 1.5}, {'words': 'ambition', 'year': 2001, 'number': 1.7}, {'words': 'balance', 'year': 2002, 'number': 3.6}, {'words': 'city', 'year': 2001, 'number': 2.4}, {'words': 'decade', 'year': 2002, 'number': 2.9}]

list to series/dataframe/array

import numpy as np
import pandas as pd
from pandas import Series, DataFrame
 
data=[["animal",2000,1.5],["ambition",2001,1.7],["balance",2002,3.6],["city",2001,2.4],["decade",2002,2.9]]
#list to series
ser=Series(data)
print(ser)
#输出为：
#0      [animal, 2000, 1.5]
#1    [ambition, 2001, 1.7]
#2     [balance, 2002, 3.6]
#3        [city, 2001, 2.4]
#4      [decade, 2002, 2.9]
#dtype: object
#或者指定series的index
ser=Series(data,index=["A","B","C","D","E"])
print(ser)
#输出为：
#A      [animal, 2000, 1.5]
#B    [ambition, 2001, 1.7]
#C     [balance, 2002, 3.6]
#D        [city, 2001, 2.4]
#E      [decade, 2002, 2.9]
#dtype: object
#series to list
a_list=ser.tolist()
print(a_list)
#输出为：[['animal', 2000, 1.5], ['ambition', 2001, 1.7], ['balance', 2002, 3.6], ['city', 2001, 2.4], ['decade', 2002, 2.9]]
 
#list to dataframe
df=DataFrame(data,index=["A","B","C","D","E"],columns=['words', 'year', 'number'])
print(df)
#输出为：
#      words  year  number
#A    animal  2000     1.5
#B  ambition  2001     1.7
#C   balance  2002     3.6
#D      city  2001     2.4
#E    decade  2002     2.9
 
#list to array
ndarray=np.array(data)
print(ndarray)
#输出为：
#[['animal' '2000' '1.5']
# ['ambition' '2001' '1.7']
# ['balance' '2002' '3.6']
# ['city' '2001' '2.4']
# ['decade' '2002' '2.9']]
print(ndarray.shape)
#输出为：(5, 3)

https://yam.gift/series/

数据清洗

列索引（columns）处理
df.columns = ['a','b','c']：直接重命名列标签
df.rename()：批量或者单个更改列标签

行索引（index）处理
df.set_index()：将某列作为行索引，可处理多重索引
df.reset_index()：更改行索引，可处理多重索引

判断某值是否存在
df.isin([……])：判断[……]内的元素是否在df中，返回一个与df同维的bool型DataFrame

null和na处理
pd.isnull(df)或df.isnull()：判断哪些是null，返回一个与df同维的bool型DataFrame
pd.isna(df)或df.isna()：判断哪些是null，返回一个与df同维的bool型DataFrame
pd.notnull(df)或df.notnull()：判断哪些不是null，返回一个与df同维的bool型DataFrame
pd.notna(df)或df.notna()：判断哪些不是na，返回一个与df同维的bool型DataFrame
df.fillna(value)：用value填充所有的空值

df['列名'].isna()、df['列名'].isnull()、df['列名'].notna()、df['列名'].notnull()：判断某列是否有空值，返回列同维布尔值。
df['列名'].fillna(value)：用value填充某列所有空值

df.dropna(axis=, how=)：删除所有包含空值的行（axis=0）或列（axis=1），how='any'只要出现一个空值就删，how='all'只有当所以值空才删。
df['列名'].dropna()：删除某列的空值

重复数据判断处理
df.duplicated(subset=['col1','col2',……],keep=) 等同于df[['col1','col2',……]].duplicated(keep=)：返回一个与“行数”同维的bool型Series对象，标True的行表示，这些行里面某几列（由['列名'list]指定）或所有列都相同。keep='first'/'last'/False。'first'：第一次出现的行不标注True；'表示'：最后一次出现的行不标注True；False(无引号)：所有满足要求的行都表True。
df.duplicated()：标出完全相同的行，且第一次出现那行不标注。
df.duplicated(subset=['age','id'] ,keep=False)：比较‘age’和‘id’这两列完全相同的行，并全部标注为True，比如第2行：age=5，id=123；第7行：age=5，id=123，显然第2行和第7行在age和id这两个维度上是完全相同的，那么这两行都将被标注为True。该结果同df[['city','price']].duplicated(keep=False)。

pd.read_csv用法

数据预处理

20、http://df.info() 可显示表中哪个数据为空

21、df.isnull() 方法可以判断哪个值是缺失值，如果缺失返回True，否则为False

22、df.dropna() 默认删除含缺失值的行

23、df.dropna(how=’all’) 删除全为空值的行，不全为空值的行不会删除

24、df.fillna(0) 用0填充所有空值

25、df.fillna({‘性别’:’男’,’年龄’:’30’}) 对性别列中空值填充男，年龄填充30

26、df.drop_duplicates() 默认对所有值进行重复值检查，保留第一行的值

27、df.drop_duplicates(subset=’性别’) 对性别列中重复值查询保留第一行

28、df.drop_duplicates(subset=[’性别’,’公司’]，keep=’last’) 对性别和公司两列查重

keep设置默认为first（保留第一个），可设置为last（保留最后一个） 或False(不部不保留)

29、df[‘ID’].dtype 查看ID列的数据类型

30、df[‘ID’].astype(‘float’) 将ID列的数据类型转换为float类型

31、数据类型：int、float、object、string、unicode、datetime

32、df[‘ID’][1] ID列的第二个数据

33、df.columns=[‘大写’,’小写’,’中文’] 为无索引表添加列索引

34、df.index=[1,2,3] 添加行索引

35、df.set_index(‘编号’) 指明要用的列作为行索列

36、df.rename(index={‘订单编号’:’新订单编号’,’客户姓名’:’新客户姓名’}) 对行索引进行重新命名

37、df.rename(columns={1:’一’,2:’二’}) 对列索引进行重新命名

38、df.reset_index() 默认将全部index转化为column

39、df.reset_index(level=0) 将0级索引转化为column

40、df.reset_index(drop=True) 删除原有索引

数值操作 replace drop

55、df[‘年龄’].replace(100,33)#对年龄列中的100替换成33

56、df.replace(np.NaN,0)#相当于fillna(),其中np.NaN是python中缺省值的表示方式

57、df.replace([A,B],C)#多对一替换，A、B替换成C

58、df.replace({‘A’:’a’,‘B’:’b’,‘C’:’c’})#多对多替换

59、df.sort_values(by=['申请单编号'],ascending=False)#申请单编号列降序排列，Ture升序排列（默认）

60、df.sort_values(by=['申请单编号'],na_position=’first’)#申请单编号列升序排列，缺失值排在第一位

默认缺失值在最后一位last

61、df.sort_values(by=['col1',’col2’],ascending=[False,True])#多列排序

62、df[‘销量’].rank(method=’first’)#销量排名（不是排序），method有first\min\max\average

63、df.drop([‘销量’,’ID’],axis=1)#删除列,直接是列名

64、df.drop(df.columns[[4,5]],axis=1)#删除列,是编号

65、df.drop(colums=[‘销量’,’ID’])#此种方式删除列，可以不写axis=1

66、df.drop([‘a’,’b’],axis=0)#删除行,直接是列名

67、df.drop(df.index[[4,5]],axis=0)#删除行,是编号

68、df.drop(index=[‘a’,’b’])#此种方式删除行，可以不写axis=0

69、df[‘ID’].value_counts()#对ID列中数据出现的次数进行统计

70、df[‘ID’].value_counts(normalize=Ture,sort=False)#对ID列中数据出现的次数占比进行统计，并降序排序

71、df[‘ID’].unique()#获取列的唯一值

72、df[‘年龄’].isin([‘a’,11])#查看这列中是否包含a或11

73、pd.cut(df[‘ID’],bins=[0,3,6,10])#用bins指明切分区间

74、pd.qcut(df[‘ID’],3)#ID列切分成3个部分，每部分数据个数尽量一致

75、df.insert(2,’商品’,[‘书’,’笔’,’计算器’])#插入第三列

76、df[’商品’]=[‘书’,’笔’,’计算器’])#插新列，在表的最后面

77、df.T行列互换

78、df.tack()#把表格型数据转化成树形数据

79、df.set_index([‘ID’,’姓名’]).stack().reset_index()#宽表转换成长表，先将共同列设置成行索引，再对其他列

进行转化成树形数据，再重置行索引

80、df.melt(id_vars=[‘ID’,’姓名’],var_name=’year’,value_name=’sale’)#id_var参数指明宽表转换成长表时保持不

变的列，var_name参数表示原来的列索引转化为行索引对应的列名，value_name表示新索引对应值的列名

81、df[‘C1’].apply(lambda x:x+1)#相当于map(),只是需要和lambda配合

82、df.applymap(lambda x:x+1),对表中的所有数据执行相同函数运算

Pandas进阶修炼系列

国外大神制作的超棒 Pandas 可视化教程

Python函数式编程——map()、reduce()

数据选择

41、df[[‘ID’,’姓名’]] 多个列名要装入list

42、df.iloc[[1,3],[2,4]] 用行列编号选择数据

43、df.iloc[1,1] 选取表中的第3行2列数据，第一行默认为列索引

44、df.iloc[:,0:4] #获取第1列到第4列的值

45、df.loc[‘一’] #loc用行名选取的行数据，格式是Series，但可以用列表形式访问

46、df.loc[‘一’][0] 或 df.loc[‘一’][‘序号’]

47、df.iloc[1]#iloc用行编号选取行数据

48、df.iloc[[1,3]]#多行编号选取行数据，要用list封装，不然变成行列选取

49、df.iloc[1:3]#选择第二行和第四行

50、df[df[‘年龄’]<45] #加判断条件返回符合条件的全部数据，不局限年龄列

51、df[(df[‘年龄’]<45)&(df[‘ID’]<4)] #判断多条件选择数据

52、df.iloc[[1,3],[2,4]] 相当于df.loc[[‘一’,’二’],[‘年龄’,’ID’]] #loc是名，iloc是编号

53、df[df[‘年龄’]<45][[‘年龄’,’ID’]]#先通过年龄条件选择行，再通过不同索引指定列

54、df.iloc[1:3,2:4]#切片索引

数据透视表 df.groupby()

数据运算

83、df[‘ID’]+Df[‘ID’]#可进行加减乘除
84、df[‘ID’]>Df[‘ID’]#可进行> < == !=等比较运算
85、df.count()#统计每列的非空值的个数
86、df.count(axis=1)#统计每行的非空值的个数
87、df[‘ID’].count()#统计指定列的非空值的个数
88、df.sum(axis=1)#每列/行求和结果
89、df.mean(axis=1)#每列/行求均值
90、df.max(axis=1)#每列/行求最大值
91、df.min(axis=1)#每列/行求最小值
92、df.median(axis=1)#每列/行求中间值
93、df.mode(axis=1)#每列/行中出现最多的值
94、df.var(axis=1)#每列/行求方差
95、df.std(axis=1)#每列/行求标准差
96、df.quantile(0.25)#求1/4分位数，可以0.5、0.75等分位数
97、df.corr()#求整个DataFrame表中的相关性

to_excel()

将数据保存至excel

删除excel的行、列

drop

>>> # 删除列, 需要指定axis为1，当删除行时，axis为0>>> data = data.drop('属性1', axis=1) # 删除`属性1`列>>> data
     名字   等级   属性2  天赋    特性
0  艾欧里娅  100     冰  29    瞬杀
1   泰格尔   80    战斗  16  None
2  布鲁克克  100  None  28    炎火
3   小火猴 1  None  31  None

>>> # 删除第3,4行，这里下表以0开始，并且标题行不算在类, axis用法同上>>> data = data.drop([2, 3], axis=0)
>>> data
     名字   等级 属性2  天赋    特性
0  艾欧里娅  100   冰  29    瞬杀
1   泰格尔   80  战斗  16  None

Python标准库技巧代码片段

将list中的string转换为int

方法一：map
输入stringList = ['1', '2', '3']
输出 intList = [1, 2, 3]

intList = list(map(int, stringList))

方法二：lambda
result = [int(x) for x in stringList]

将list中的int转为string

输入intList = [1,2,3,5,6]
输出 stringList=['1','2','3','5','6']

方法1：
res = [str(x) for x in intList]

方法2：
res = list(map(str, intList))
同理map用法Function
res = list(map(x:Function(x), intList))

字符串排序、List排序--sort() 与 sorted()

s="abxc"
l1=list(s)     #['a', 'b', 'x', 'c']
l1.sort()      #['a', 'b', 'c', 'x']
s1="".join(l1) #'abcx'

list的sort()函数。sort()函数对原列表进行排序，没有返回值
l1=[1,6,2]
l1.sort(reverse = True)  #[6,2,1]

sorted() 函数
sorted() 函数对列表等可迭代的对象进行排序操作。返回一个新的list，而不是在原来的基础上进行的操作，不同于list.sort()，必须使用返回值。也可以进行降序排列，示例代码如下：

l1=[1,6,2]
l2=sorted(l1)      #[1, 2, 6]，升序（缺省模式），必须使用返回值，l1本身不变。
l2=sorted(l1,reverse = True)  #[6, 2, 1],降序
 另外二函数直接应用于字符串的情况，代码如下：
l1="162"
l1.sort()  #str没有sort()函数，程序报错
l2=sorted(l1)      #['1', '2', '6']，返回排序后的列表，而不是字符串

两个List转为dict字典

d1 = dict(zip(l1, l2))

字典dict转为list列表

>>> list(d1)
[1, 2, 3]
>>> list(d1.values())
['1', '2', '3']

dict字典的value为list类型

方法1：defaultdict 也叫 multidict
d = {
    'a' : [1, 2, 3],
    'b' : [4, 5]
}
e = {
    'a' : {1, 2, 3},
    'b' : {4, 5}
}
from collections import defaultdict

d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)

d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)

方法2：手动创建
>>> b = {1:[]}
>>> b[1]
[]
>>> b[1].append(1)
>>> b
{1: [1]}
>>> b[1].append(23)

方法3：
dic = {}
dic.setdefault(key，[]).append(value)
#如:
d1.setdefault('bob_hu'，[]).append(1)
d1.setdefault('bob_hu'，[]).append(2)

列表去重的几种方法

方法一: 使用内置set方法来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> lst2 = list(set(lst1))
>>> print(lst2)
[1, 2, 3, 4]

方法二: 使用字典中fromkeys()的方法来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> lst2 = {}.fromkeys(lst1).keys()
>>> print(lst2)
dict_keys([2, 1, 3, 4])

方法三: 使用常规方法来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> temp = []
>>> for item in lst1:
	    if not item in temp:
		    temp.append(item)	
>>> print(temp)
[2, 1, 3, 4]

方法四: 使用列表推导来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> temp = []
>>> [temp.append(i) for i in lst1 if not i in temp]
[None, None, None, None]
>>> print(temp)
[2, 1, 3, 4]

方法五: 使用sort函数来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> lst2.sort(key=lst1.index)
>>> print(lst2)
[2, 1, 3, 4]

方法六: 使用sorted函数来去重
>>> lst1 = [2, 1, 3, 4, 1]
>>> lst2 = sorted(set(lst1), key=lst1.index)
>>> print(lst2)
[2, 1, 3, 4]
备注： 前面的几种方法，有几种是不能保证其顺序的，比如用set（）函数来处理！

如果要删除列表列表中的重复项，则同样可以用下面的几种方法来处理

>>> # 方法一:
>>> data = [2, 1, 3, 4, 1]
>>> [item for item in data if data.count(item) == 1]
[2, 3, 4]
>>> # 方法二:
>>> data = [2, 1, 3, 4, 1]
>>> list(filter(lambda x:data.count(x) == 1, data))
[2, 3, 4]

列表list中元素去重的6种方式总结

'''
输入  s = [1, 3, 2, 34, 4, 6, 6, 7, 1, 4, 8, 98]

输出
string_duplicate_1 [1, 3, 2, 34, 4, 6, 7, 8, 98]
string_duplicate_2 dict_keys([1, 3, 2, 34, 4, 6, 7, 8, 98])
string_duplicate_3 dict_keys([1, 3, 2, 34, 4, 6, 7, 8, 98])
string_duplicate_4 [1, 3, 2, 34, 4, 6, 7, 8, 98]
string_duplicate_5 [1, 2, 3, 4, 6, 7, 8, 34, 98]
string_duplicate_6 [1, 2, 3, 4, 6, 7, 8, 34, 98]
'''

from functools import reduce  
class StringReverse(object):
    '''
    列表去重，并按照原来的顺序排序
    '''
 
    # 1.利用set方法和sort方法，原序
    def string_duplicate_1(self, s):
        new_s = list(set(s))  # set无序
        new_s.sort(key=s.index)
        return new_s
 
    # 2.用列表中的元素作为字典中的key生成一个新字典，然后获取字典的key，非原序
    def string_duplicate_2(self, s):
        a = {}
        # fromkeys(s,v)该方法的功能是生成一个字典，字典的key是 s中的值，s为可迭代对象，可以为str,tuple,list,set,dict，v为每一个key的值，默认为None
        return a.fromkeys(s).keys()
 
    # 3.利用defaultdict, 非原序
    def string_duplicate_3(self, s):
        # 按照之前的顺序
        from collections import defaultdict
        a = defaultdict()
        for x in s:
            a[x] = 0
        return a.keys()
 
    # 4.最简单的循环，添加入新的列表，如果新列表中没有相同元素，则加入。原序
    def string_duplicate_4(self, s):
        new_s = []
        for x in s:
            if x not in new_s:
                new_s.append(x)
        return new_s
 
    # 5.利用itertools的groupby方法。非原序
    def string_duplicate_5(self, s):
        from itertools import groupby
        s.sort()
        new_groupby = groupby(s)
        new_s = []
        for x, y in new_groupby:
            new_s.append(x)
        return new_s
 
    # 6.reduce方法。非原序
    def string_duplicate_6(self, s):
        return reduce(lambda x, y: x if y in x else x + [y], [[], ] + s)
 
 
if __name__ == "__main__":
    stringReverse = StringReverse()
    s = [1, 3, 2, 34, 4, 6, 6, 7, 1, 4, 8, 98]
    print("string_duplicate_1", stringReverse.string_duplicate_1(s))
    print("string_duplicate_2", stringReverse.string_duplicate_2(s))
    print("string_duplicate_3", stringReverse.string_duplicate_3(s))
    print("string_duplicate_4", stringReverse.string_duplicate_4(s))
    print("string_duplicate_5", stringReverse.string_duplicate_5(s))
    print("string_duplicate_6", stringReverse.string_duplicate_6(s))

os.path方法

当前目录、上级目录、上上级目录

import os

print '***获取当前目录***'
print os.getcwd()
print os.path.abspath(os.path.dirname(__file__))
# __file__ 为当前文件, 若果在ide中运行此行会报错,可改为  #d = path.dirname('.') 
# 但是改为.后，就是获得当前目录，接着使用dirname函数访问上级目录
print '***获取上级目录***'
print os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
print os.path.abspath(os.path.dirname(os.getcwd()))
print os.path.abspath(os.path.join(os.getcwd(), ".."))

print '***获取上上级目录***'
print os.path.abspath(os.path.join(os.getcwd(), "../.."))

os.path.dirname(abs_path) basename与dirname

功能：去掉文件名，返回目录, 若以相对路径运行，输出空目录
print(os.path.dirname("E:/Read_File/read_yaml.py"))
#结果： E:/Read_File123
print(os.path.dirname("E:/Read_File"))
#结果： E:/

basename/dirname：获取路径尾部和路径头部。其实就是以路径中最后一个 / 为分割符，分为头（head） 和尾（tail）两部分，tail 是 basename 返回的内容，head 是 dirname 返回的内容。经常用于获取文件名，目录名等操作
>>> os.path.basename("test/test-1/test-1.txt")   # 文件名
'test-1.txt'
>>> os.path.basename("test/test-1/")     # 空内容
''
>>> os.path.basename("test/test-1")      # 目录名
'test-1'
>>> os.path.dirname("test/test-1/test-1.txt")   # 文件所在目录路径
'test/test-1'
>>> os.path.dirname("test/test-1/")   # 目录路径
'test/test-1'
>>> os.path.dirname("test/test-1")   # 父目录路径
'test'

文件判断

方法	说明
os.path.isdir(s)	判断是否为目录 ，如果为目录返回True
os.path.isfile(s)	判断是否为文件 ，如果为文件返回True
os.path.exists(path)	判断文件或目录是否存在 ，存在返回True

文件路径获取

方法	说明
os.path.dirname(path)	返回目录所在路径
os.path.split(p)	目录切分，返回元组（head,tail
os.path.basename(p)	返回最后一级目录
os.path.join(a, *p)	目录拼接
os.path.abspath(path)	获取文件绝对路径

路径拼接os.path.join

可以避免：
1>跨平台问题，linux与window下目录表达方式不一样
2>路径拼接，注意目录之间分隔符，有严格限制，容易出错

path = '/home/linux/test/'
print(os.path.join(path, '1.txt'))

path = '/home/linux/test'
print(os.path.join(path, '1.txt'))

输出结果：
/home/linux/test/1.txt
/home/linux/test/1.txt
path的最后有没有反斜杠，join都可以处理，但是字符串拼接这种方式显然不行。

python文件和目录操作方法大全