条件判断
Format
if
<
条件判断
1
>
:
<
执行
1
>
elif
<
条件判断
2
>
:
<
执行
2
>
elif
<
条件判断
3
>
:
<
执行
3
>
else:
<
执行
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
Format
For 循环分为 2 种格式
For item in < 数组 >
for
item
in
[
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
]:
sum = sum +
item
foritem range < 范围 >
for
item
in
(0,10)
:
sum = sum +
item
设置 for 循环步长为 2 ：
for
item
in
(0,10
，
2
)
:
sum = sum +
item
while
Format
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
系统函数
https://docs.python.org/3/library/functions.html?highlight=abs#abs
函数
Format
def<function Name> (parameter):
多个参数与多个返回值
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语句：
def
nop
()
:
pass
pass 语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass 还可以用在其他语句里，比如：
if
age >=
18
:
pass
缺少了pass，代码运行就会有语法错误。
指向函 数的变量
函数本身也可以赋值给变量，即：变量可以指向函数。
>>>
f = abs
>>>
f(-
10
)
10
成功！说明变量
f
现在已经指向了
abs
函数本身。
作为参数的函 数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数
def
add
(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
作为返回 值的 函数
我们来实现一个可变参数的求和。通常情况下，求和的函数是这样定义的：
def
calc_sum
(*args)
:
ax =
0
for
n
in
args:
ax = ax + n
return
ax
但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？可以不返回求和的结果，而是返回求和的函数！
def
lazy_sum
(*args)
:
def
sum
()
:
ax =
0
for
n
in
args:
ax = ax + n
return
ax
return
sum
当我们调用
lazy_sum()
时，返回的并不是求和结果，而是求和函数：
>>> f = lazy_sum(
1
,
3
,
5
,
7
,
9
)
>>> f
<
function
sum
at
0
x10452f668
>
调用函数
f
时，才真正计算求和的结果：
>>>
f()
25
总结，当调用
f = lazy_sum(
1
,
3
,
5
,
7
,
9
)
函数的返回值是
sum,
因此是
sum
的地址，此时
sum
函数未开始执行，当调用
f()
时，
sum
函数才会开始执行
D ecorator
假如函数调用前后自动打印日志，但又不希望修改
now()
函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
函数对象有一个
__name__
属性，可以拿到函数的名字：
>>>
now.__name__
‘now‘
>>>
f.__name__
‘now‘
假设我们要增强
now()
函数的功能，比如，在本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：
def
log
(func)
:
def
wrapper
(*args, **kw)
:
print
‘call %s():‘
% func.__name__
return
func(*args, **kw)
return
wrapper
观察上面的
log
，因为它是一个
decorator
，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：
@log
def
now
()
:
print
‘2013-12-25‘
调用
now()
函数，不仅会运行
now()
函数本身，还会在运行
now()
函数前打印一行日志：
>>> now()
call
now():
2013
-
12
-
25
把
@log
放到
now()
函数的定义处，相当于执行了语句：
now =
log(now)
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
def
log
(text)
:
def
decorator
(func)
:
def
wrapper
(*args, **kw)
:
print
‘%s %s():‘
% (text, func.__name__)
return
func(*args, **kw)
return
wrapper
return
decorator
这个3层嵌套的decorator用法如下：
@log(‘execute‘)
def
now
()
:
print
‘2013-12-25‘
执行结果如下：
>>>
now()
execute now():
2013
-
12
-
25
和两层嵌套的decorator相比，3层嵌套的效果是这样的：
>>>
VariantN
ow = 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()
‘xffxd8xffxe1x00x18Exifx00x00...‘
#
十六进制表示的字节
字符编 码
要读取非ASCII编码的文本文件，就必须以二进制模式打开，再解码。比如GBK编码的文件：
>>>
f = open(
‘/Users/michael/gbk.txt‘
,
‘rb‘
)
>>>
u = f.read().decode(
‘gbk‘
)
>>>
u
u‘u6d4bu8bd5‘
>>>
print
u
如果每次都这么手动转换编码嫌麻烦（写程序怕麻烦是好事，不怕麻烦就会写出又长又难懂又没法维护的代码），Python还提供了一个codecs模块帮我们在读文件时自动转换编码，直接读出unicode：
import
codecs
with
codecs.open(
‘/Users/michael/gbk.txt‘
,
‘r‘
,
‘gbk‘
)
as
f:
f.read()
# u‘u6d4bu8bd5‘
写文件
写文件和读文件是一样的，唯一区别是调用
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
def
test
()
:
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://blog.csdn.net/tiankefeng19850520/article/details/47428841
【说明】：本文章由站长整理发布，文章内容不代表本站观点，如文中有侵权行为，请与本站客服联系(QQ:254677821)！