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'