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檔案和目錄操作方法大全