本文共 5936 字,大约阅读时间需要 19 分钟。
if <条件判断1> : 条件判断1>
<执行1>执行1>
elif <条件判断2> : 条件判断2>
<执行2>执行2>
elif <条件判断3> : 条件判断3>
<执行3>执行3>
else:
<执行4>执行4>
E.g
age = 20
if age >= 6:
print'teenager'
elif age >= 18:
print'adult'
else:
print'kid'
默认情况下,dict迭代的是key。如果要迭代value,可以用for value in d.itervalues()
,如果要同时迭代key和value,可以用for k, v ind.iteritems()
d={'k1':1,'k2':2,'k3':3}
for j in d.itervalues():
print j
for i,j in d.iteritems():
print i,j
For 循环分为2种格式
For item in <数组>
foritemin [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + item
foritem range <范围>
foritemin(0,10):
sum = sum + item
设置for循环步长为2:
foritemin(0,10,2):
sum = sum + item
While <判断条件>:
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print sum
Python内置的常用函数还包括数据类型转换函数,比如int()函数可以把其他数据类型转换为整数:
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> unicode(100)
u'100'
>>> bool(1)
True
>>> bool('')
False
函数名其实就是指向一个函数对象的引用,完全可以把函数名赋给一个变量,相当于给这个函数起了一个“别名”:
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
def<function Name> (parameter):
if x >= 0:
return x
else:
return -x
def my_abs(x,y):
if x >= 0 and y>6:
return -x,y
else:
return +x,y
x,y=my_abs(5,5)//使用2个变量进行接收
print x,y
如果想定义一个什么事也不做的空函数,可以用pass语句:
defnop():
pass
pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来。
pass还可以用在其他语句里,比如:
if age >= 18:
pass
缺少了pass,代码运行就会有语法错误。
函数本身也可以赋值给变量,即:变量可以指向函数。
>>> f = abs
>>> f(-10)
10
成功!说明变量f
现在已经指向了abs
函数本身。
既然变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数
defadd(x, y, f):
return f(x) + f(y)
当我们调用add(-5, 6, abs)
时,参数x
,y
和f
分别接收-5
,6
和abs
,根据函数定义,我们可以推导计算过程为:
x ==> -5
y ==> 6
f ==> abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
我们来实现一个可变参数的求和。通常情况下,求和的函数是这样定义的:
defcalc_sum(*args):
ax = 0
for n in args:
ax = ax + n
return ax
但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求和的函数!
deflazy_sum(*args):
defsum():
ax = 0
for n in args:
ax = ax + n
return ax
returnsum
当我们调用lazy_sum()
时,返回的并不是求和结果,而是求和函数:
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
调用函数f
时,才真正计算求和的结果:
>>> f()
25
总结,当调用f = lazy_sum(
1,
3,
5,
7,
9)
函数的返回值是
sum,
因此是
sum
的地址,此时
sum
函数未开始执行,当调用
f()
时,
sum
函数才会开始执行
假如函数调用前后自动打印日志,但又不希望修改now()
函数的定义,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)。
函数对象有一个__name__
属性,可以拿到函数的名字:
>>> now.__name__
'now'
>>> f.__name__
'now'
假设我们要增强now()
函数的功能,比如,在本质上,decorator就是一个返回函数的高阶函数。所以,我们要定义一个能打印日志的decorator,可以定义如下:
deflog(func):
defwrapper(*args, **kw):
print'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
观察上面的log
,因为它是一个decorator,所以接受一个函数作为参数,并返回一个函数。我们要借助Python的@语法,把decorator置于函数的定义处:
@log
defnow():
print'2013-12-25'
调用now()
函数,不仅会运行now()
函数本身,还会在运行now()
函数前打印一行日志:
>>> now()
call now():
2013-12-25
把@log
放到now()
函数的定义处,相当于执行了语句:
now = log(now)
如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数,写出来会更复杂。比如,要自定义log的文本:
deflog(text):
defdecorator(func):
defwrapper(*args, **kw):
print'%s %s():' % (text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator
这个3层嵌套的decorator用法如下:
@log('execute')
defnow():
print'2013-12-25'
执行结果如下:
>>> now()
execute now():
2013-12-25
和两层嵌套的decorator相比,3层嵌套的效果是这样的:
>>> VariantNow = log('execute')(now)
总结:wrapper()函数的参数定义是(*args, **kw) 是函数对应的2个参数,args是参数个数,kw是指向参数数组首元素的指针。wrapper()函数参数不能改变,decorator(func)中的参数是func=now,
因此当调用@log('execute')是可认为变量VariantNow指向了一个函数(decorator)
VariantNow =log('execute')(now)
当执行VariantNow()时候可认为执行了一下内容
Decorator(now)à wrapper(now函数参数个数,now函数参数内容)->print
要以读文件的模式打开一个文件对象,使用Python内置的open()
函数,传入文件名和标示符:
>>> f = open('/Users/michael/test.txt', 'r')
标示符'r'表示读,这样,我们就成功地打开了一个文件。
如果文件打开成功,接下来,调用read()
方法可以一次读取文件的全部内容,Python把内容读到内存,用一个str
对象表示:
>>> f.read()
'Hello, world!'
最后一步是调用close()
方法关闭文件。文件使用完毕后必须关闭,因为文件对象会占用操作系统的资源,并且操作系统同一时间能打开的文件数量也是有限的:
>>> f.close()
由于文件读写时都有可能产生IOError
,一旦出错,后面的f.close()
就不会调用。所以,为了保证无论是否出错都能正确地关闭文件,我们可以使用try ... finally
来实现:
try:
f = open('/path/to/file', 'r')
print f.read()
finally:
if f:
f.close()
但是每次都这么写实在太繁琐,所以,Python引入了with
语句来自动帮我们调用close()
方法:
with open('/path/to/file', 'r') as f:
print f.read()
这和前面的try ... finally
是一样的,但是代码更佳简洁,并且不必调用f.close()
方法。
调用read()
会一次性读取文件的全部内容,,要保险起见,可以反复调用read(size)
方法,每次最多读取size个字节的内容。另外,调用readline()
可以每次读取一行内容,调用readlines()
一次读取所有内容并按行返回list
。因此,要根据需要决定怎么调用。
如果文件很小,read()
一次性读取最方便;如果不能确定文件大小,反复调用read(size)
比较保险;如果是配置文件,调用readlines()
最方便:
for line in f.readlines():
print(line.strip()) # 把末尾的'\n'删掉
要读取二进制文件,比如图片、视频等等,用'rb'
模式打开文件即可:
>>> f = open('/Users/michael/test.jpg', 'rb')
>>> f.read()
'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...'# 十六进制表示的字节
要读取非ASCII编码的文本文件,就必须以二进制模式打开,再解码。比如GBK编码的文件:
>>> f = open('/Users/michael/gbk.txt', 'rb')
>>> u = f.read().decode('gbk')
>>> u
u'\u6d4b\u8bd5'
>>> print u
如果每次都这么手动转换编码嫌麻烦(写程序怕麻烦是好事,不怕麻烦就会写出又长又难懂又没法维护的代码),Python还提供了一个codecs
模块帮我们在读文件时自动转换编码,直接读出unicode:
import codecs
with codecs.open('/Users/michael/gbk.txt', 'r', 'gbk') as f:
f.read() # u'\u6d4b\u8bd5'
写文件和读文件是一样的,唯一区别是调用open()
函数时,传入标识符'w'
或者'wb'
表示写文本文件或写二进制文件:
>>> f = open('/Users/michael/test.txt', 'w')
>>> f.write('Hello, world!')
>>> f.close()
你可以反复调用write()
来写入文件,但是务必要调用f.close()
来关闭文件。当我们写文件时,操作系统往往不会立刻把数据写入磁盘,而是放到内存缓存起来,空闲的时候再慢慢写入。只有调用close()
方法时,操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()
的后果是数据可能只写了一部分到磁盘,剩下的丢失了。所以,还是用with
语句来得保险:
with open('/Users/michael/test.txt', 'w') as f:
f.write('Hello, world!')
当我们需要引用第三方的模块代码时,可以使用import 关键字进行引用
如:import hello
需要注意的是我们需要能找到hello.py这个文件才能倒入,对于windows可以通过设置环境变量来解决这个问题
调用方式:hello.test()
hello.py
deftest():
args = sys.argv
if len(args)==1:
print'Hello, world!'
elif len(args)==2:
print'Hello, %s!' % args[1]
else:
print'Too many arguments!'
使用as 关键字进行设置别名
如:import hello as h
调用方式:h.test()
转载地址:http://ncumi.baihongyu.com/