前言

    内容摘自Python参考手册(第4版) 及 自己测试后得出。仅作为一个简单记录,方便使用查询之用。

另 dir(func)及func.__doc__可以查看对象属性及说明文档。

序列Sequence

  序列包括字符串、列表、元组。

a = [5,6,3,2]
b = [1,3]

1、连接 s+r

c = a + b # [5,6,3,2,1,3]

2、解包 V1,V2..,Vn  = s

v1,v2,v3,v4 = a #v1 = 5,v2 = 6 ,v3 = 3 ,v4 =2

3、索引 s[i],切片 s[i:j],s[i:j:stride]

v = a[0]       #
c = a[0:2] # [5,6]
d = a[0:2:2] # [5]
e = a[3:2:-1] # [2] stride负数则反过来取子序列

4、从属关系 x in s , x not  in s

3 in a  #  True
0 in a # False

5、迭代  for x in s:

for x in a:
print x
# 5 6 3 2

6、其他

print all(a)      # True   全部为True返回True
print any(a) # True 任意为True返回True
print len(a) # 4 长度
print min(a) # 2 最小值
print max(a) # 6 最大值
print sum(a) # 16 和

7、复制

a = [ 1,2 ,[3,4]]
b = list(a) # 浅复制 地址拷贝,值类型拷贝
b[0] = 6 # a = [1,2,[3,4]] b = [6,2,[3,4]]
b[2][0] = 5 # a = [1,2,[5,4]] b = [6,2,[5,4]] # 深拷贝
import copy
b = copy.deepcoy(a)
b[2][0] =5 # a = [1,2,[3,4]] b = [6,2,[5,4]]
字符串格式化

  一、取模运算符(s%d) 生成格式化字符串,s是一个格式字符串,d是对象元组或映射对象(字典)。

在 字符串内 %后修饰符意思:

1)位于括号内的键名,映射对应字典内的对象。

2)  ' - ' 字符 表示左对齐,默认右对齐。 ' + ' 表示包含数字符号(正负号)  。 ' 0 ' 表示一个零填充。

3) 一个指定最小自动宽度的数字。(%10d ) 长度为10

4) 一个小数点,按精度分割字段宽度。

5) 一个数字,指定打印字符串的最大字符个数 ,浮点数中小数点之后的位数,或者整数最小位数。

6) 星号(*),用于在任意宽度字段中替换数字。

栗子: 

a = 42
b = 3.1415926
c = "hello world"
d ={'x':13,'y':b,'z':c}
e = 123456789012345678901234567890
r ="a is 10:%d 16:%x 8:%o" % (a,a,a) #a is 10:42 16:2a 8:52
r ="%10d %f %E" % (a,b,b) # 42 3.141593 3.141593E+00
r ="%(x)-10d %(y)0.3g" % d #13 3.14 #g,G表示指数小于-4使用%e或%E,否则使用%f
stock ={
'name': 'GooG',
'shares':100,
'price': 490.10
}
r = "%(shares)d of %(name)s at %(price)0.2f" % stock #100 of GooG at 490.10
shares =111
name ="currect_name"
r = "%(shares)d of %(name)s" %vars() # 111 of currect_name #vars() 取当前变量名表示的值

   二、用字符串的 s.format(*args,*kwargs) 方法。

1) {n} 占位符,n为数字,将被format()方法的位置参数n代替。

2)  {name} 占位符,将被format()方法关键字参数name所代替。

栗子:

r = "{0} {1} {2} {age}".format('GOOG',100,490.10,age =47)      # GOOG 100 490.1 47
r = "Use {{ and }} to output single curly braces".format() # Use { and } to output single curly braces
r = "{0[name]:8} {0[shares]:8d} {0[price]:0.3f}".format(stock) # GooG 100 490.100
装饰器

  装饰器是一个函数,主要用途是包装另一个函数或类。

栗子:

1) 函数装饰器

enable_tracing = True
def trace(func):
if enable_tracing:
def callf(*args,**kwargs):
print("Calling %s: %s, %s\n" % (func.__name__,args,kwargs))
r = func(*args,**kwargs)
print("%s returned %s\n" % (func.__name__,r))
return r
return callf
else:
return func @trace
def square(x):
return x*x
print square(5) #>>>>>>>>>>>>>
Calling square: (5,), {} square returned 25 25

上述trace就是装饰器,添加@trace相当于执行square = trace(square)。而为了保持被装饰函数的属性不被改变,装饰器需要做如下处理:

def trace(func):
if enable_tracing:
def callf(*args,**kwargs):
print("Calling %s: %s, %s\n" % (func.__name__,args,kwargs))
r = func(*args,**kwargs)
print("%s returned %s\n" % (func.__name__,r))
return r
callf.__doc__ = func.__doc__
callf.__name__ = func.__name__
callf.__dict__.update(func.__dict__)
return callf
else:
return func

2) 类装饰器:

def register(cls):
def cls__init(self): print 'register init!'
cls.__init__ =cls__init
return cls
@register
class Foo(object):
def __init__(self):
print "Foo init!" Foo() #register init!
类对象

  类定义了一组属性,这些属性与一组叫做实例的对象相关且由其共享。类通常是由函数(方法)、变量(类变量)和计算出的属性(特性)组成的集合。

1) 继承

# 父类
class classA(object):
var = 0
def __init__(self):
self.classname = classA.__name__
def show(self):
print self.var,self.classname
# 子类
class classB(classA):
def __init__(self):
classA.__init__(self)
self.classname = classB.__name__
f = classB()
f.show() # 0 classB

实例方法默认第一个参数都是self,函数定义也要有self作为第一个参数。

2) 静态方法

  相当于用类名作为命名空间的方式的普通函数。

class Foo(object):
@staticmethod
def add(x,y):
return x+y
x = Foo.add(233,332) # x = 565

3) 类方法

  将类作为第一个参数的函数。

class Foo(object):
@classmethod
def show_classname(cls):
return cls.__name__
f = Foo()
print f.show_classname() # 'Foo'
print Foo.show_classname() # 'Foo'

4) 特性 (property)

  实例或者类的属性方法,可以直接通过访问属性得到函数值。

import math
class Circle(object):
__radius = 1.0
@property
def area(self):
return math.pi*self.__radius**2
@property
def perimeter(self):
return 2*math.pi*self.__radius
@property
def radius(self):
return self.__radius
@radius.setter
def radius(self,var):
self.__radius = var
@radius.deleter
def radius(self):
self.__radius = 1.0
f = Circle()
f.radius =4.0
print f.area # 50.2654824574
print f.perimeter # 25.1327412287
del f.radius
print f.area # 3.14159265359
print f.perimeter # 6.28318530718

属性.setter和.deleter分别表示对属性设置和删除

除了上述方法外,也可以用类的默认属性函数 __getattr__,__setattr__,__delattr。如下所示,还实现了只读的功能。

class Circle(object):
radius = 1.0
def __getattr__(self,name):
if name == 'area':
return math.pi*self.radius**2
elif name == 'perimeter':
return 2*math.pi*self.radius
else:
return object.__getattr__(self,name)
def __setattr__(self,name,value):
if name in ['area','perimeter'] :
raise TypeError("%s readonly" % name)
object.__setattr__(self,name,value)

5) 元类 __metaclass__

  用来创建和管理类的对象。

class DocMeta(type):
def __init__(self,name,bases,dict):
for key,value in dict.items():
print key,value
# 以"__"开始的 默认函数不检查
if key.startswith("__"):continue
# 仅检测可以调用 "__call__" 的函数
if not hasattr(value,"__call__"):continue
# 判断函数是否有说明文档
if not getattr(value,"__doc__"):
raise TypeError("%s must have a docstring" % key)
type.__init__(self,name,bases,dict)
class Circle(object):
__metaclass__ = DocMeta

6) 弱引用 weakref

  可以用来检测对象是否被正常释放。简单栗子如下:

import weakref
class LeakObserver(object):
table_observers = []
@classmethod
def add(cls,obj):
"添加需要监听释放的对象"
cls.table_observers.append(weakref.ref(obj))
@classmethod
def findLeak(cls):
"查找未被正常释放对象"
cls.table_observers = [ref for ref in cls.table_observers if ref()]
print cls.table_observers
a = Circle()
LeakObserver.add(a)
#del a
LeakObserver.findLeak()
协程

  通过在函数内使用yield语句的方式,称为协程。先执行next()或for循环才会时函数执行到yield语句。如果yield在左侧则循环生成列表返回,如果在右侧则挂起等待send()消息传入yield处。

1) yield在左侧

import os
import fnmatch
def find_files(topdir,pattern):
for path,dirname,filelist in os.walk(topdir):
for name in filelist:
if fnmatch.fnmatch(name,pattern):
yield os.path.join(path,name) import gzip,bz2 def opener(filenames):
for name in filenames:
if name.endswith(".gz"): f = gzip.open(name)
elif name.endswith(".bz2"): f = bz2.BZ2File(name)
else: f = open(name,"r")
yield f
def cat(filelist):
for f in filelist:
for line in f:
yield line
def grep(pattern,lines):
for line in lines:
if pattern in line:
yield line debuglogs = 'debug.log'
files = opener(debuglogs)
lines = cat(files)
pylines = grep("python",lines)
for line in pylines:
sys.stdout.write(line)

在该栗子中,整个程序由最后的for语句驱动,中间不会产生临时列表等,占用内存极少。

2)yield在右侧

def receiver():
print("ready to receiver")
while True:
n = (yield)
print("Got %s" % n)
r = receiver()
r.next()
r.send("hello")

执行next()后,函数执行到yield处。

消息日志

  通过 import logging 来使用 logging模块记录日志。

1) 基本配置

通过 basicConfig设置默认的日志配置。如下:

import logging
logging.basicConfig(
filename ="app.log",
format = "%(levelname)-10s %(asctime)s %(message)s",
level = logging.INFO
)

然后通过正常的logging记录如下:

log = logging.getLogger('app')
log.info("hello world")

这样可以在 app.log文件中看到按format格式输出的记录了。

2) 筛选日志

  通过addFilter,setLevel可以对单独的logging对象进行输出控制。如下:

format = logging.Formatter("%(levelname)-10s %(asctime)s %(message)s")
log = logging.getLogger('app.test')
log.addHandler(logging.FileHandler('app.test.log')) # 添加输出到文件
stdout_hand = logging.StreamHandler(sys.stdout) # 输出到控制台显示
stdout_hand.setFormatter(format) # 设置输出格式
log.addHandler(stdout_hand) # 添加输出Handler
log.setLevel(logging.ERROR) # 设置消息级别
log.info("info message!")
log.log(logging.ERROR,"error message!")       

这样控制台和app.test.log文件都会按格式输出错误消息!"ERROR      2016-03-28 10:29:28,651 error message!"

而因为基础设置上的设置,app.log上会输出info和error的日志信息。

3) 其他

log.propagate = False            #禁止输出到父级log对象  'app.test'  -> ‘app’

log.close()                            #关闭当前输出log对象

命令行输入

  optparse模块处理sys.argv中提供的UNIX风格命令行选项高级支持。栗子如下:

import optparse
p = optparse.OptionParser() #简单项,不带参数
p.add_option("-t",action = "store_true",dest = "tracing")
#接受字符串参数
p.add_option("-o","--outfile",action = "store", type = "string",dest= "outfile")
#接收整数
p.add_option("-d","--debuglevel",action = "store", type = "int",dest= "debug")
#带选项参数
p.add_option("--speed",action = "store" , type ="choice",dest="speed",choices=["slow","fast","ludicrous"])
#多个参数
p.add_option("--coord",action = "store", type="int", dest="coord",nargs =2)
#一组控制常用目的地的选项
p.add_option("--novice",action="store_const",const="novice",dest="mode")
p.add_option("--guru",action="store_const",const="guru",dest="mode")
#设置默认值
p.set_defaults(tracing=False,debug=0,speed="fast",coor=(0,0),mode="novice")
opt,args = p.parse_args()
print opt,args

可以通过输入test.py(文件名) -h参看说明。

调优策略

  以下仅摘自参考手册并没有进行过系统测试。

1、理解程序

  a、 理解算法

b、使用内置类型

2、不要添加层

import timeit
print timeit.timeit("s= {'name':'GOOG','shares':100,'price':490.10}") #0.139700907932
print timeit.timeit("s = dict(name='GOOG',shares=100,price = 490.10)") #0.341468762487

3、了解如何基于字典构建类和实例

  如果值构建简单数据结构存储数据,字典比类可能更好。

4、使用__slots__

  不实用字典(__dict__)存储实例数据,内存少,访问效率高。__slots__ =['name','shares','price']

5、避免使用(.)运算符

6、使用异常处理不常见的情况

  正常情况下不会抛出异常的代码设置try代码块比if语句速度更快。

7、避免对常见情况使用异常

#方法1
try:
value = items[key]
except KeyError:
value = None #方法2
if key in items:
value = items[key]
else:
value = None

   大部分是查找得到值的情况下,方法2运算是方法1的17倍。而且in运算符比方法调用(items.get(key))更快。

8、鼓励使用函数编程和迭代

9、使用装饰器和元类

python - 常用模块栗子的更多相关文章

  1. Python常用模块之sys

    Python常用模块之sys sys模块提供了一系列有关Python运行环境的变量和函数. 常见用法 sys.argv 可以用sys.argv获取当前正在执行的命令行参数的参数列表(list). 变量 ...

  2. Python常用模块中常用内置函数的具体介绍

    Python作为计算机语言中常用的语言,它具有十分强大的功能,但是你知道Python常用模块I的内置模块中常用内置函数都包括哪些具体的函数吗?以下的文章就是对Python常用模块I的内置模块的常用内置 ...

  3. python——常用模块2

    python--常用模块2 1 logging模块 1.1 函数式简单配置 import logging logging.debug("debug message") loggin ...

  4. python——常用模块

    python--常用模块 1 什么是模块: 模块就是py文件 2 import time #导入时间模块 在Python中,通常有这三种方式来表示时间:时间戳.元组(struct_time).格式化的 ...

  5. Python常用模块——目录

    Python常用模块学习 Python模块和包 Python常用模块time & datetime &random 模块 Python常用模块os & sys & sh ...

  6. python 常用模块之random,os,sys 模块

    python 常用模块random,os,sys 模块 python全栈开发OS模块,Random模块,sys模块 OS模块 os模块是与操作系统交互的一个接口,常见的函数以及用法见一下代码: #OS ...

  7. python常用模块之时间模块

    python常用模块之时间模块 python全栈开发时间模块 上次的博客link:http://futuretechx.com/python-collections/ 接着上次的继续学习: 时间模块 ...

  8. python常用模块之subprocess

    python常用模块之subprocess python2有个模块commands,执行命令的模块,在python3中已经废弃,使用subprocess模块来替代commands. 介绍一下:comm ...

  9. python常用模块之string

    python常用模块string模块,该模块可以帮我们获取字母.数字.特殊符号. import string #打印所有的小写字母 print(string.ascii_lowercase) #打印所 ...

随机推荐

  1. 集美大学网络1413第十四次作业成绩(团队九) -- 测试与发布&博客展示(Beta版本)

    题目 团队作业9--测试与发布(Beta版本) 团队作业9成绩  团队/分值 Beta版本测试报告 Beta版本发布说明       总分  Bug类别. 数量 场景测试 测试结果 测试矩阵 出口条件 ...

  2. 【Alpha】——Seventh Scrum Meeting

    一.今日站立式会议照片 二.每个人的工作 成员 昨天已完成的工作 今天计划完成的工作 李永豪 将项目做成APK 用户界面改善 郑靖涛 协助设计账目一览表板块 用户界面改善 杨海亮 查询功能测试 用户界 ...

  3. 201521123072《java程序设计》第十二周学习总结

    201521123072<java程序设计>第十二周学习总结 1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多流与文件相关内容. 2. 书面作业 将Student对象 ...

  4. Java课设-购物车系统

    1.团队课程设计博客链接 /[博客链接]http://www.cnblogs.com/yayaya/p/7062197.html 2.个人负责模板或任务说明 1.建立Action类 2.购物车的属性 ...

  5. 201521123080《Java程序设计》第12周学习总结

    1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多流与文件相关内容. 流(Stream): Stream是从起源(source)到接收(sink)的有序数据 按照流向分可以分为输入 ...

  6. 201521123068《Java程序设计》第12周学习总结

    1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多流与文件相关内容. 2. 书面作业 将Student对象(属性:int id, String name,int age,doubl ...

  7. PHP面向对象简单总结

    类和对象对象:一切东西都可以看做对象,对象是类的实例化.类:类是对象的抽象,用来描述众多对象共有的特征. 定义类 class成员变量 和 成员方法访问修饰符 public共有的 private 私有的 ...

  8. [UWP]分享一个基于HSV色轮的调色板应用

    1. 前言 上一篇文章介绍了HSV色轮,这次分享一个基于HSV色轮的调色板应用,应用地址:ColorfulBox - Microsoft Store 2. 功能 ColorfulBox是Adobe 色 ...

  9. iOS多线程编程

    废话不多说,直接上干货.先熟悉一下基本知识,然后讲一下常用的两种,NSOperation和GCD. 一.基础概念 进程: 狭义定义:进程是正在运行的程序的实例(an instance of a com ...

  10. apriori关联规则

    挖掘数据集:贩物篮数据 频繁模式:频繁地出现在数据集中的模式,例如项集,子结构,子序列等 挖掘目标:频繁模式,频繁项集,关联规则等 关联规则:牛奶=>鸡蛋[支持度=2%,置信度=60%] ...