Python学习笔记2

标签：python

条件判断

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 <数组>

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

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):

defmy_abs(x):

    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

<functionsumat 0x10452f668>

调用函数f时，才真正计算求和的结果：

>>> f()

25

总结，当调用f = lazy_sum(1, 3, 5, 7, 9) 函数的返回值是sum,因此是sum 的地址，此时sum函数未开始执行，当调用f()时，sum函数才会开始执行

Decorator

假如函数调用前后自动打印日志，但又不希望修改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()

Python学习笔记2

标签：python

原文地址：http://blog.csdn.net/tiankefeng19850520/article/details/47428841