pythonstorage用法

① / storage/ emulated/0/是什麼意思

/storage/emulated/0 手機的內部儲存根目錄，/storage/emulated/1 手機的內存卡儲存根目錄。

android的API的得到的就是/storage/emulated/0/，這個路徑我們用的時候一般直接進/sdcard/或者/mnt/sdcard/，其實是一個相同的位置。

/storage/emulated/0這個是手機內部存儲空間（即手機內存），手機連接電腦後，在手機上選擇管理文件就可以查看了。

擴展汪搭資料

主要敬余包含自身系統占據的空間和用戶可用的空間困稿拿兩部分。ROM相當於PC機上的硬碟，用來存儲和保存數據。

即使是斷電，ROM也能夠保留數據。手機中的系統文件，或者圖片、音樂、照片等通常是存儲在這裡面的。

從技術上講，這個代碼在Windows上也能運行，因為python會在調用open()函數時識別出任何一種斜杠。即便如此，你也不應該依賴它。

不是所有的python庫都可以在錯誤的操作系統上使用錯誤的斜杠，特別是當它們有外部程序或庫介面時。並且，Python對混合斜杠類型的支持僅限Windows，它無法反向工作。

參考資料

網路—手機系統內存

鳳凰網—Python小技巧：3個處理文件路徑的簡單方法

② python 操作excel 讀 寫 xlsx

原文非常清晰，全程無bug，調試通過，留作記錄以防丟失

一、xlrd和xlwt

使用之前需要先安裝，windows上如果直接在cmd中運行python則需要先執行pip3 install xlrd和pip3 install xlwt，如果使用pycharm則需要在項目的解釋器中安裝這兩個模塊，File-Settings-Project:layout-Project Interpreter，點擊右側界面的＋號，然後搜索xlrd和xlwt，然後點擊Install Package進行安裝。

對於excel來說，整個excel文件稱為工作簿，工作簿中的每個頁稱為工作表，工作表又由單元格組成。

對於xlrd和xlwt，行數和列數從0開始，單元格的行和列也從0開始，例如sheet.row_values(2)表示第三行的內容，sheet.cell(1,2).value表示第二行第三列單元格的內容。

1.xlrd模塊讀取excel文件

使用xlrd模塊之前需要先導入import xlrd，xlrd模塊既可讀取xls文件也可讀取xlsx文件。

獲取工作簿對象 ：book = xlrd.open_workbook('excel文件名稱')

獲取所有工作表名稱 ：names = book.sheet_names()，結果為列表

根據索引獲取工作表對象 ：sheet = book.sheet_by_index(i)

根據名稱獲取工作表對象 ：sheet = book.sheet_by_name('工作表名稱')

獲取工作錶行數 ：rows = sheet.nrows

獲取工作表列數 ：cols = sheet.ncols

獲取工作表某一行的內容 ：row = sheet.row_values(i) ，結果為列表   【sheet.row(i)，列表】

獲取工作表某一列的內容 ：col = sheet.col_values(i)  結果為列表   【sheet.col(i)，列表】

獲取工作表某一單元格的內容 ：cell = sheet.cell_value(m,n)、 sheet.cell(m,n).value、sheet.row(m)[n].value，sheet.col(n)[m].value，結果為字元串或數值    【sheet.cell(0,0)，xlrd.sheet.Cell對象】

示例：假設在py執行文件同層目錄下有一fruit.xls文件，有三個sheet頁Sheet1、Sheet2、Sheet3，其中Sheet1內容如下：

import xlrd

book = xlrd.open_workbook('fruit.xls')print('sheet頁名稱:',book.sheet_names())

sheet = book.sheet_by_index(0)

rows = sheet.nrows

cols = sheet.ncolsprint('該工作表有%d行，%d列.'%(rows,cols))print('第三行內容為:',sheet.row_values(2))print('第二列內容為%s,數據類型為%s.'%(sheet.col_values(1),type(sheet.col_values(1))))print('第二列內容為%s,數據類型為%s.'%(sheet.col(1),type(sheet.col(1))))print('第二行第二列的單元格內容為:',sheet.cell_value(1,1))print('第三行第二列的單元格內容為:',sheet.cell(2,1).value)print('第五行第三列的單元格內容為:',sheet.row(4)[2].value)print('第五行第三列的單元格內容為%s,數據類型為%s'%(sheet.col(2)[4].value,type(sheet.col(2)[4].value)))print('第五行第三列的單元格內容為%s,數據類型為%s'%(sheet.col(2)[4],type(sheet.col(2)[4])))# 執行結果# sheet頁名稱: ['Sheet1', 'Sheet2', 'Sheet3']# 該工作表有5行，3列.# 第三行內容為: ['梨', 3.5, 130.0]# 第二列內容為['單價/元', 8.0, 3.5, 4.5, 3.8],數據類型為<class 'list'>.# 第二列內容為[text:'單價/元', number:8.0, number:3.5, number:4.5, number:3.8],數據類型為<class 'list'>.# 第二行第二列的單元格內容為: 8.0# 第三行第二列的單元格內容為: 3.5# 第五行第三列的單元格內容為: 300.0# 第五行第三列的單元格內容為300.0,數據類型為<class 'float'># 第五行第三列的單元格內容為number:300.0,數據類型為<class 'xlrd.sheet.Cell'>

可以看出通過sheet.row(i)、sheet.col(i)也可獲取行或列的內容，並且結果也是一個列表，但是列表中的每一項類似字典的鍵值對，形式為數據類型:值。

而sheet.cell(0,0)獲取單元格內容，結果是一個鍵值對，並且是一個xlrd.sheet.Cell對象。

2.xlwt寫入excel文件

使用xlwt模塊之前需要先導入import xlwt，xlwt模塊只能寫xls文件，不能寫xlsx文件(寫xlsx程序不會報錯，但最後文件無法直接打開，會報錯)。

創建工作簿 ：book = xlwt.Workbook()，如果寫入中文為亂碼，可添加參數encoding = 'utf-8'

創建工作表 ：sheet = book.add_sheet('Sheet1')

向單元格寫入內容 ：sheet.write(m,n,'內容1')、sheet.write(x,y,'內容2')

保存工作簿 ：book.save('excel文件名稱')，默認保存在py文件相同路徑下，如果該路徑下有相同文件，會被新創建的文件覆蓋，即xlwt不能修改文件。

import xlwt

book = xlwt.Workbook()

sheet = book.add_sheet('Sheet1')

sheet.write(0,0,'hello')

sheet.write(1,0,'你好')

book.save('hello.xls')

逐個單元格寫入excel比較麻煩，可以按行或者列寫入。

import xlwt

proj = ['名稱','單價/元','庫存/kg']

fruit = ['蘋果','梨','香蕉','橘子']

price = [8,3.5,4.5,3.8]

storage = [150,130,100,300]

book = xlwt.Workbook()

sheet = book.add_sheet('Sheet1')foriin range(0,len(proj)):

    sheet.write(0,i,proj[i]) #按行插入行標題foriin range(0,len(fruit)):

    sheet.write(i+1,0,fruit[i])#插入第一列水果名稱foriin range(0,len(price)):

    sheet.write(i+1,1,price[i])#插入第二列單價foriin range(0,len(storage)):

    sheet.write(i+1,2,storage[i])#插入第三列庫存book.save('fruit2.xls')

二、openpyxl模塊

openpyxl模塊可實現對excel文件的讀、寫和修改，只能處理xlsx文件，不能處理xls文件，使用之前同樣需要先安裝該模塊，再導入 import openpyxl。

對於openpyxl，行數和列數都從1開始，單元格的行和列也從1開始。例如sheet.cell(1,2).value表示第一行第二列單元格的內容

1.openpyxl讀取excel文件

獲取工作簿對象：book = openpyxl.load_workbook('excel文件名稱')

獲取所有工作表名稱：names = book.sheetnames

獲取工作表對象：sheet1 = book.worksheets[n]、sheet2 = book['工作表名稱']、sheet3 = book[book.sheetnames[n]]

獲取工作表名稱：title = sheet1.title

獲取工作錶行數：rows = sheet1.max_row

獲取工作表列數：cols = sheet1.max_column

獲取某一單元格內容：cell = sheet.cell(1,2).value、sheet['單元格'].value例如sheet['B1'].value

假設有一fruit2.xlsx，除後綴名其他與上述fruit.xls完全一樣

import openpyxl

book = openpyxl.load_workbook('fruit2.xlsx')print('所有sheet頁名稱：',book.sheetnames) 

sheet = book.worksheets[0]

sheet2 = book['Sheet1']

sheet3 = book[book.sheetnames[0]]print('工作表名稱：',sheet3.title)

rows = sheet.max_row

cols = sheet.max_columnprint('該工作表有%d行，%d列.'%(rows,cols))# 執行結果# 所有sheet頁名稱： ['Sheet1', 'Sheet2', 'Sheet3']# 工作表名稱： Sheet1# 該工作表有5行，3列.

2.行和列生成器

對於xlrd模塊來說，可直接通過sheet.row[i]和sheet.col[i]獲取行和列的內容，但是對於openpyxl模塊來說，無法直接獲取某一行或列的內容，openpyxl模塊的sheet.rows和sheet.columns表示行和列的生成器，即generator object，需要通過循環或轉換成列表、元組的形式得到行或列的值。

print(sheet.rows,sheet.columns)forcolin sheet.columns:

    print(col)forrowin sheet.rows:

    foriin row:

        print(i.value,end='')

    print()# 執行結果# <generator object Worksheet._cells_by_row at 0x00000230E011A2A0> <generator object Worksheet._cells_by_col at 0x00000230E102FC00># (<Cell 'Sheet1'.A1>, <Cell 'Sheet1'.A2>, <Cell 'Sheet1'.A3>, <Cell 'Sheet1'.A4>, <Cell 'Sheet1'.A5>)# (<Cell 'Sheet1'.B1>, <Cell 'Sheet1'.B2>, <Cell 'Sheet1'.B3>, <Cell 'Sheet1'.B4>, <Cell 'Sheet1'.B5>)# (<Cell 'Sheet1'.C1>, <Cell 'Sheet1'.C2>, <Cell 'Sheet1'.C3>, <Cell 'Sheet1'.C4>, <Cell 'Sheet1'.C5>)# 名稱  單價/元  庫存/kg# 蘋果  8  150# 梨  3.5  130# 香蕉  4.5  100# 橘子  3.8  300

如果要獲取某一行或者列的內容，可將行、列生成器對象轉換成列表或者元組，再循環列表或者元組得到內容。

前面說過openpyxl模塊的行和列都從1開始，但是由於將生成器轉化成了列表list(sheet.rows)，而列表的索引從0開始，因此list(sheet.rows)[1]還是表示第二行的內容，不是第一行的內容。

foriinlist(sheet.rows)[1]:

    print(i.value,end='')print()foriin list(sheet.columns)[0]:

    print(i.value,end='')# 執行結果# 蘋果  8  150# 名稱  蘋果  梨  香蕉  橘子

獲取單元格的內容

print(sheet.cell(1,2).value)#第一行第二列單元格的內容print(sheet['a2'].value)#使用excel單元格的表示法，字母不區分大小寫

3.openpyxl寫excel文件 

創建工作簿 ：book = openpyxl.Workbook()，如果寫入中文為亂碼，可添加參數encoding = 'utf-8'

創建工作表： sheet = book.create_sheet('工作表名稱',0)，0表示創建的工作表在工作薄最前面

向單元格寫入內容 ：sheet.cell(m,n,'內容1')、sheet.cell(x,y,'內容2')

保存工作簿 ：book.save('excel文件名稱')，默認保存在py文件相同路徑下，如果該路徑下有相同文件，會被新創建的文件覆蓋。

book = openpyxl.Workbook()

sheet = book.create_sheet('Sheet1',0)

proj = ['名稱','單價/元','庫存/kg']

fruit = ['蘋果','香蕉','梨','橘子']

price = [8,3.5,4.5,3.8]

storage = [150,130,300,100]foriin range(len(proj)):

    sheet.cell(1,i+1,proj[i])foriin range(len(fruit)):

    sheet.cell(i+2,1,fruit[i])foriin range(len(price)):

    sheet.cell(i+2,2,price[i])foriin range(len(storage)):

    sheet.cell(i+2,3,storage[i])

book.save('fruit2.xlsx')

4.openpyxl修改excel文件

sheet.insert_rows(m)和sheet.insert_cols(n)分別表示在第m行、第n列前面插入行、列

sheet.delete_rows(m)和sheet.delete_cols(n)分別表示刪除第m行、第n列

rows = sheet.max_row

sheet.insert_rows(rows+2)

cherry = ['櫻桃',17,80]  forjin cherry:

    sheet.cell(rows+1,cherry.index(j)+1,j)

book.save('fruit2.xlsx')

修改單元格內容：sheet.cell(m,n) = '內容1'或者sheet['B3'] = '內容2' 

sheet.cell(3,2,4)

sheet['B3'] = 5book.save('fruit2.xlsx')

在最後追加行：sheet.append(可迭代對象)

straberry = ['草莓',20,50]

sheet.append(straberry)

book.save('fruit2.xlsx')

三、xlsxwriter 模塊

只能操作xlsx，只能寫。在excel中插入圖片

import matplotlib.pyplot as plt

  2 import pandas as pd

  3 import random

  4 import xlsxwriter

  5

  6 ts = pd.Series(random.randrange(10))

  7 fig = plt.figure()

  8 ax = fig.add_subplot(1,1,1)

  9 ts.plot(ax=ax)

10 fig.savefig('foo.png')

11

12 workbook = xlsxwriter.Workbook('pngxls.xlsx')    # 創建excel文件

13 worksheet1 = workbook.add_worksheet('png')  # 括弧內為工作表表名

14 # 第一個參數是插入的起始單元格，第二個參數是圖片你文件的絕對路徑

15 worksheet1.write('A1','hello')

16 worksheet1.insert_image('B2','foo.png')

18 workbook.close()

xlrd、xlwt和openpyxl處理excel文件，在寫入文件的時候不如pandas簡單，pandas處理excel文件見另外一篇博客 https://www.cnblogs.com/Forever77/p/11298173.html

③ 新手提問，python問題，先謝謝了。

索引必須是整數。
rank= sorted(ran,reverse = True,key = lambda x:x['lv'])你是想按某個屬性來排序。
key = lambda x:x['lv']中的x['lv']是錯誤的扮氏寫法，應該是x[0],x[1]......例：
>>> L = [('d',2),('a',4),('b',3),('c',2)]
>>> print sorted(L, key=lambda x:(x[1],x[0]))
>>>[('c', 2), ('廳陵散d', 2), ('b', 3), ('a', 4)]
先按第二個排序，在按第一個屬性排汪納序。
或者直接key=lambda x:x.lv

④ 訪問字典中的對象時可以使用什麼來實現

在python中訪問字典中的元素都是通過下標，但是通過某些方式，我們可以像訪問成員變數那樣訪問字典：

a = {

'foo': 1,

'bar': 2

}

print a.foo

print a.bar

setattr和__getattr__的使用

看如下的代碼：

# coding: utf-8

class Test(object):

def __init__(self):

self.a = 1

self.b = 2

# 設置屬性都會調用

def __setattr__(self, key, value):

print '__setattr__: %s' % key

self.__dict__[key] = value

# __getattr__ 只有在訪問不存在亮謹的成員時才會被調用

def __getattr__(self, key):

print '__getattr__: %s' % key

return self.__dict__[key]

if __name__ == '__main__':

t = Test()

print t.a

print t.b

t.c = 12

print t.c

t.c = 13

t.a = 123

print t.d

setattr是每次設置屬性時都會調用，而__getattr 則只有當訪問不存在的元素時才會調用。

對象的攜友屬性均保存在

dict 這個字典中。默認的

setattr 和

getattr__也是訪問這個字典。

通過一個Storage類的包裝訪問字典

#!/usr/bin/env python

# coding: utf8

import json

class Storage(dict):

def __init__(self, *args, **kw):

dict.__init__(self, *args, **kw)

def __getattr__(self, key):

return self[key]

def __setattr__(self, key, value):

self[key] = value

def __delattr__(self, key):

del self[key]

if __name__ == '__main__':

l = {'foo': 'bar'}

s = Storage(l)

print s.foo

print s['foo']

我們可以看到，經過Storage類的包裝，此時不僅可以通過下標s['foo']，還可以使用s.foo來調辯鍵槐用foo對應的元素。

原理很簡單，我們改變了Storage默認的__getattr 和

setattr 實現，默認實現是訪問內部的

dict__，而該邂逅訪問的是基類dict，所以訪問s.foo時，訪問的是內部的dict['foo']，所以能訪問到元素。

json庫loads中的object_hook參數的使用

看如下的代碼，常規的json序列化和反序列化是這樣做：

import json

from decimal import *

obj = {'name': 'haha', 'age': 23, 'height': 1.75}

json_string = json.mps(obj)

print json_string

new_obj = json.loads(json_string)

print new_obj

我們從上面看到，dict經過包裝，可以改造成Storage，使用訪問屬性的方式訪問元素。json的loads功能也提供了類似的功能。

# coding: utf-8

import json

obj = {'name': 'haha', 'age': 23, 'height': 1.75}

json_string = json.mps(obj)

from collections import namedtuple

Student = namedtuple('Student',['name', 'age', 'height'])

def object_hook_handler(dict_obj):

return Student(name=dict_obj['name'],

age=dict_obj['age'],

height=dict_obj['height'])

new_obj = json.loads(json_string, object_hook=object_hook_handler)

print new_obj

列印結果為：

Student(name=u'haha', age=23, height=1.75)

可以看到，通過object_hook這個參數傳入一個函數，將dict改造成一個有名元組。

其實，在python中，類也可以看做一個函數，所以直接傳入類名做參數即可。

from collections import OrderedDict

new_obj = json.loads(json_string, object_hook=OrderedDict)

print new_obj

輸出結果為：

OrderedDict([(u'age', 23), (u'name', u'haha'), (u'height', 1.75)])

隱藏Storage

為了使用方便，最好不讓用戶接觸到Storage，所以可以這樣寫：

#!/usr/bin/env python

# coding: utf8

import json

class Storage(dict):

def __init__(self, *args, **kw):

dict.__init__(self, *args, **kw)

def __getattr__(self, key):

return self[key]

def __setattr__(self, key, value):

self[key] = value

def __delattr__(self, key):

del self[key]

def storage_object_hook(dct):

return Storage(dct)

def json_decode(data, *args, **kw):

return json.loads(data, object_hook=storage_object_hook, *args, **kw)

def json_encode(data, *args, **kw):

return json.mps(data, *args, **kw)

if __name__ == '__main__':

l = {'foo': 'bar'}

l = json_decode(json_encode(l))

print l

print l.foo

⑤ python循環結構數據 怎麼以txt或者xls保存

handle = open("storage.txt", "螞判悉悶乎wt"沖信)

for ...
retrieved_text = do_something_with_your_business()
handle.write(retrieved_text)

handle.close()

⑥ storage/emulated/0/ifly是什麼

storage/emulated/0這個是手機內部存儲空間（即手機內存），手機連接電腦後，在手機上選擇管理文件就可以查看了。

storage：名詞，意思是存儲、倉庫、保管。

emulated：動詞過去分詞，努力趕上，與...競爭的意思，動詞原形的意思殲陵是模擬。

/storage/emulated/0/ifly這個應該是文件夾的一個目錄，軟體或者APP的存儲地址。

(6)pythonstorage用法擴展閱讀

主要包含自身系統占據的空間和用戶可用的空間兩部分。ROM相當於PC機上的硬碟，用來存儲和保存數據。

即使是斷電，ROM也能夠保留數據。手機中的系統文件，或大改畢者圖片、音樂、照片等通常是存儲在這裡面的滾芹。

從技術上講，這個代碼在Windows上也能運行，因為Python會在調用open()函數時識別出任何一種斜杠。即便如此，你也不應該依賴它。

⑦ python必學英語單詞

computational adj. 計算的，電腦的

mode n. 模式

primitive n. 原始、基元，是後續操作的基礎

gigabyte n. 千兆位元組，是數據單位

storage n. 儲存體, 倉庫

retrieve n. 檢索,恢復

algorithm n. 演算法

accomplish vt. 完成

scheme n. 方案, 計劃, v. 設計, 體系, 結構,

compute vt. 計算

code n. 碼,密碼 vt. 把…編碼

halt v 停止

computation n. 計算，計算方法，計算結果

knowledge n. 知識,了解

declarative adj. 說明的, 陳述的 declarative knowledge 陳述性知識

imperative adj. 命令式的,互動的 imperative knowledge 互動性知識

recipe n. 掛起，暫停

evaluate vt. 評估,評價

square root 平方根 the square root of a number x x的平方根

dece vt. 演繹,推斷

capture vt. 採集,描繪,製作

fix vt. &vi.修理,安裝

calculator n. 計算器

decode v. 解碼, 譯解 [計算機] 解碼

enigma n. 謎

manipulate v. [計算機] 操作

instruction n. 指令,說明

set n.集合 predefined set 預設集合

arithmetic n. 算術，運算

store n. (在計算機里)存貯；記憶

test n.vt. 測試

execute vt. [計算機] 執行

source n. 來源 source code 源代碼

sequence n. 序列, 一系列, 順序

architecture n.體系結構

abstract n.簡化，抽象

computable adj. 可計算的

mechanism n. 機制

syntax n. 語法 （規范代碼的結構，成分和順序上正確）

02

static adj. 靜態的

ambiguous adj. 歧義的

unpredictable adj. 不可預知的

intend v. 打算 （打算使之成為。。。）

crash n 崩潰，停止運行

algorithmic adj.[計]演算法的,規則系統的

process n.過程，進程，步驟

programming language n.程序設計語言

checker n. 檢驗器, 檢查員

internal adj. 內部的

interpreter n. 解釋器

compiler n. [計算機]編譯器, 編譯程序

invert v. 使反向;invert a matrix反轉矩陣

abstraction n. 抽象, 參數化

converter n. 轉換器 =convertor

script n. 腳本

definition n. 清晰度

command n. [計算機]指令；命令

shell n.[計算機] DOS命令 ，殼

instruct [計算機] 指示

object n. 對象

type n.類型

scalar 標量(的)

represent vt. 代表

integer [計算機] 整數

int 整型

float n. 浮點型

const abbr. 常數（=constant）

expression 表達式

denote vt. 表示，意味著

sum n. 總數(計) vi. 總計

difference n. 差

proct n. 乘積

division n. 除法

quotient n. 商

remainder n. 余數，余

power n.次方，冪

operator n. 運算符

precedence n. 優先

truncate vt. 舍位

indicate v.說明，指示

decimal n.十進制

arbitrary adj. 任意的

variable adj. 可變的 n. 變數

value n. 值

assignment n. 賦值

bind vt. 綁定

invoke [計算機] 調用

binding n.綁定關系

rebound n. 回跳，反彈

diagram n. 圖解,關系圖

transcript n. 抄本，腳本

compound n. 混合物,復合詞

literal [計算機] 文字的,文本

quote n. 引用 quotes引號

character n. 字元

extract [計算機] 提取、取值、查看

index n.索引

boundary n. 分界線, 邊界boundaries 邊界

slice n. 薄的切片,一部份,鍋鏟 vt. 切成薄片,大幅降低

essentially adv. 基本上

⑧ Python 有什麼奇技淫巧

顯示有限的介面到外部
當發布python第三方package時, 並不希望代碼中所有的舉嘩租函數或者class可以被外部import, 在__init__.py中添加__all__屬性,
該list中填寫可以import的類或者函數名, 可以起到限制的import的作用, 防止外部import其他函數或者類

Python

1
2
3
4
5
6
7
8
9
10
11
12

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from base import APIBase
from client import Client
from decorator import interface, export, stream
from server import Server
from storage import Storage
from util import (LogFormatter, disable_logging_to_stderr,
enable_logging_to_kids, info)
__all__ = ['APIBase', 'Client', 'LogFormatter', 'Server',
'Storage', 'disable_logging_to_stderr', 'enable_logging_to_kids',
'export', 'info', 'interface', 'stream']

with的魔力
with語句需要支持上下文管理協議的對象, 上下文管理協議包含 __enter__ 和__exit__ 兩個方法. with語句建立運行蘆差時上下文需要通過這兩個方法執行進入和退出操作.
其中上下文表達式是跟在with之後的表達式, 該表示大返回一個上下文管理對象

Python

1
2
3
4

# 常見with使用場景
with open("test.txt", "r") as my_file: # 注意, 是__enter__()方法的返回值賦值給了my_file,
for line in my_file:
print line

詳細原理可以查看這篇文章《淺談 Python 的 with 語句》
知道具體原理, 我們可以自正兆定義支持上下文管理協議的類, 類中實現 __enter__ 和__exit__ 方法

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class MyWith(object):
def __init__(self):
print "__init__ method"
def __enter__(self):
print "__enter__ method"
return self # 返回對象給as後的變數
def __exit__(self, exc_type, exc_value, exc_traceback):
print "__exit__ method"
if exc_traceback is None:
print "Exited without Exception"
return True
else:
print "Exited with Exception"
return False
def test_with():
with MyWith() as my_with:
print "running my_with"
print "------分割線-----"
with MyWith() as my_with:
print "running before Exception"
raise Exception
print "running after Exception"
if __name__ == '__main__':
test_with()

執行結果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

__init__ method
__enter__ method
running my_with
__exit__ method
Exited without Exception
------分割線-----
__init__ method
__enter__ method
running before Exception
__exit__ method
Exited with Exception
Traceback (most recent call last):
File "bin/python", line 34, in <mole>
exec(compile(__file__f.read(), __file__, "exec"))
File "test_with.py", line 33, in <mole>
test_with()
File "test_with.py", line 28, in test_with
raise Exception
Exception

證明了會先執行 __enter__ 方法, 然後調用with內的邏輯, 最後執行 __exit__ 做退出處理, 並且, 即使出現異常也能正常退出
filter的用法
相對filter而言, map和rece使用的會更頻繁一些, filter正如其名字, 按照某種規則過濾掉一些元素

Python

1
2
3
4
5
6
7

#!/usr/bin/env python
# -*- coding: utf-8 -*-
lst = [1, 2, 3, 4, 5, 6]
# 所有奇數都會返回True, 偶數會返回False被過濾掉
print filter(lambda x: x % 2 != 0, lst)
#輸出結果
[1, 3, 5]

一行作判斷
當條件滿足時, 返回的為等號後面的變數, 否則返回else後語句

Python

1
2
3
4
5

lst = [1, 2, 3]
new_lst = lst[0] if lst is not None else None
print new_lst
# 列印結果
1

裝飾器之單例
使用裝飾器實現簡單的單例模式

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 單例裝飾器
def singleton(cls):
instances = dict() # 初始為空
def _singleton(*args, **kwargs):
if cls not in instances: #如果不存在, 則創建並放入字典
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return _singleton
<a href="">@singleton</a>
class Test(object):
pass
if __name__ == '__main__':
t1 = Test()
t2 = Test()
# 兩者具有相同的地址
print t1, t2

staticmethod裝飾器
類中兩種常用的裝飾, 首先區分一下他們
普通成員函數, 其中第一個隱式參數為對象
classmethod裝飾器, 類方法(給人感覺非常類似於OC中的類方法), 其中第一個隱式參數為類
staticmethod裝飾器, 沒有任何隱式參數. python中的靜態方法類似與C++中的靜態方法

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class A(object):
# 普通成員函數
def foo(self, x):
print "executing foo(%s, %s)" % (self, x)
@classmethod # 使用classmethod進行裝飾
def class_foo(cls, x):
print "executing class_foo(%s, %s)" % (cls, x)
@staticmethod # 使用staticmethod進行裝飾
def static_foo(x):
print "executing static_foo(%s)" % x
def test_three_method():
obj = A()
# 直接調用噗通的成員方法
obj.foo("para") # 此處obj對象作為成員函數的隱式參數, 就是self
obj.class_foo("para") # 此處類作為隱式參數被傳入, 就是cls
A.class_foo("para") #更直接的類方法調用
obj.static_foo("para") # 靜態方法並沒有任何隱式參數, 但是要通過對象或者類進行調用
A.static_foo("para")
if __name__ == '__main__':
test_three_method()

# 函數輸出
executing foo(<__main__.A object at 0x100ba4e10>, para)
executing class_foo(<class '__main__.A'>, para)
executing class_foo(<class '__main__.A'>, para)
executing static_foo(para)
executing static_foo(para)

property裝飾器
定義私有類屬性
將property與裝飾器結合實現屬性私有化(更簡單安全的實現get和set方法)

Python

1
2

#python內建函數
property(fget=None, fset=None, fdel=None, doc=None)

fget是獲取屬性的值的函數,fset是設置屬性值的函數,fdel是刪除屬性的函數,doc是一個字元串(like a comment).從實現來看，這些參數都是可選的
property有三個方法getter(), setter()和delete() 來指定fget, fset和fdel。 這表示以下這行

Python

1
2
3
4
5
6
7
8
9
10
11

class Student(object):
@property #相當於property.getter(score) 或者property(score)
def score(self):
return self._score
@score.setter #相當於score = property.setter(score)
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value

iter魔法
通過yield和__iter__的結合, 我們可以把一個對象變成可迭代的
通過__str__的重寫, 可以直接通過想要的形式列印對象

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class TestIter(object):
def __init__(self):
self.lst = [1, 2, 3, 4, 5]
def read(self):
for ele in xrange(len(self.lst)):
yield ele
def __iter__(self):
return self.read()
def __str__(self):
return ','.join(map(str, self.lst))

__repr__ = __str__
def test_iter():
obj = TestIter()
for num in obj:
print num
print obj
if __name__ == '__main__':
test_iter()

神奇partial
partial使用上很像C++中仿函數(函數對象).
在stackoverflow給出了類似與partial的運行方式

Python

1
2
3
4
5
6

def partial(func, *part_args):
def wrapper(*extra_args):
args = list(part_args)
args.extend(extra_args)
return func(*args)
return wrapper

利用用閉包的特性綁定預先綁定一些函數參數, 返回一個可調用的變數, 直到真正的調用執行

Python

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import partial
def sum(a, b):
return a + b
def test_partial():
fun = partial(sum, 2) # 事先綁定一個參數, fun成為一個只需要一個參數的可調用變數
print fun(3) # 實現執行的即是sum(2, 3)
if __name__ == '__main__':
test_partial()

# 執行結果
5

神秘eval
eval我理解為一種內嵌的python解釋器(這種解釋可能會有偏差), 會解釋字元串為對應的代碼並執行, 並且將執行結果返回
看一下下面這個例子

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test_first():
return 3
def test_second(num):
return num
action = { # 可以看做是一個sandbox
"para": 5,
"test_first" : test_first,
"test_second": test_second
}
def test_eavl():
condition = "para == 5 and test_second(test_first) > 5"
res = eval(condition, action) # 解釋condition並根據action對應的動作執行
print res
if __name__ == '_

exec
exec在Python中會忽略返回值, 總是返回None, eval會返回執行代碼或語句的返回值
exec和eval在執行代碼時, 除了返回值其他行為都相同
在傳入字元串時, 會使用compile(source, '<string>', mode)編譯位元組碼. mode的取值為exec和eval

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test_first():
print "hello"
def test_second():
test_first()
print "second"
def test_third():
print "third"
action = {
"test_second": test_second,
"test_third": test_third
}
def test_exec():
exec "test_second" in action
if __name__ == '__main__':
test_exec() # 無法看到執行結果

getattr
getattr(object, name[, default])Return the value of the named attribute of object. name must be a string. If the string is the name of one of the object』s attributes, the result is the value of that attribute. For example, getattr(x, 『foobar』) is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise AttributeError is raised.
通過string類型的name, 返回對象的name屬性(方法)對應的值, 如果屬性不存在, 則返回默認值, 相當於object.name

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 使用範例
class TestGetAttr(object):
test = "test attribute"
def say(self):
print "test method"
def test_getattr():
my_test = TestGetAttr()
try:
print getattr(my_test, "test")
except AttributeError:
print "Attribute Error!"
try:
getattr(my_test, "say")()
except AttributeError: # 沒有該屬性, 且沒有指定返回值的情況下
print "Method Error!"
if __name__ == '__main__':
test_getattr()

# 輸出結果
test attribute
test method

命令行處理

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78),
add_help_option=None)
# define options here:
parser.add_option( # customized description; put --help last
'-h', '--help', action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args,))
# further process settings & args if necessary
return settings, args
def main(argv=None):
settings, args = process_command_line(argv)
# application code here, like:
# run(settings, args)
return 0 # success
if __name__ == '__main__':
status = main()
sys.exit(status)

讀寫csv文件

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 從csv中讀取文件, 基本和傳統文件讀取類似
import csv
with open('data.csv', 'rb') as f:
reader = csv.reader(f)
for row in reader:
print row
# 向csv文件寫入
import csv
with open( 'data.csv', 'wb') as f:
writer = csv.writer(f)
writer.writerow(['name', 'address', 'age']) # 單行寫入
data = [
( 'xiaoming ','china','10'),
( 'Lily', 'USA', '12')]
writer.writerows(data) # 多行寫入

各種時間形式轉換
只發一張網上的圖, 然後差文檔就好了, 這個是記不住的

字元串格式化
一個非常好用, 很多人又不知道的功能

Python

1
2
3

>>> name = "andrew"
>>> "my name is {name}".format(name=name)
'my name is andrew'