进击python第三篇：基础

基础拾遗

序列解包

例：

>>>x,y,z=1,2,3

>>>print x,y,z

1 2 3

交换变量也是没问题

>>>x,y=y,x

>>>print x,y,z

2 1 3  　　　　#这个很实用

当函数或方法返回元组（或其它序列或可迭代对象）时，这个特性特别有用。假如需要获取（和删除）字典中任意的键-值对，可以使用popitem方法，将键值对作为元组返回，那么就可以直接赋值到两变量中

例：

>>> dic1={'name':'lzl','girlfriend':'None'}

>>> key,value=dic1.popitem()

>>> print key,value

girlfriend None

赋值时要求序列中的元素和=左边的变量数量一致，否则引发异常valueError

注：python 3.0另一解包特性：允许像在函数中的参数列表中一样使用星号，例如 a,b,*test=[1,2,3,4,5],这样test的结果是[3,4,5]

链式赋值

是将同一值赋值给多变量的捷径。

x=y=somefunction()

等同于

y=somefunction()

x=y

但与如下不一定等同：

x=somefunction()

y=somefunction()

布尔值知识补充

标准值False、None、所有类型的数字0、空序列、空字典都为假；其它一切为真，包括特殊值True

name=''

while not name or name.isspace() :

name = raw_input('please input your name:')

print 'hello,%s' % name

实用：在做判断输入是否为空时，输入了空格会判断为真，却又不易察觉，可以使用while not name or name.isspace()或while not name.strip()

断言

如果需要确保程序中某条件为真才能继续运行，assert语句就有用了，相当于if语句做了一次判断

例子：

>>> age = 1

>>> assert 0<age <10

>>> age = -1

>>> assert 0<age<10,'The age must be realistic'

Traceback (most recent call last):

  File "<input>", line 1, in <module>

AssertionError: The age must be realistic

一些迭代工具

在python中迭代序列（或其它可迭代对象），有一些函数非常好用

1.并行迭代

names = ['lzl','Bruce Li','damon']

age = [18,20,28]

print zip(names,ages)

输出：[('lzl', 18), ('Bruce Li', 20), ('damon', 28)]

内建的zip函数可用来并行迭代，像是上面介绍序列解包的相反过程

重要的一点是zip可处理不等长的序列，当最短的序列“用完”的时候就停止。

>>> zip(range(5),xrange(100))

[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

2.按索引迭代

有些时候想要迭代序列中的对象，同时还要获取对象对应的索引。这时内建函数enumerate可以在提供索引的地方迭代索引-值对，默认索引从0开始

例子：

>>> li=['北京','四川','重庆']

>>> for index,string in enumerate(li,1):  #索引从1开始

...     print index,"---",string

...

1 --- 北京

2 --- 四川

3 --- 重庆

实用：可用作菜单选项制作

3.翻转和排序迭代

函数reserved和sorted同列表的reserve和sort方法类似，但作用于任何和序列或可迭代对象上，不是原地修改对象，而是返回翻转或排序后的版本

例子：

>>> list1=[4,3,6,2,1]

>>> sorted(list1)

[1, 2, 3, 4, 6]

>>> list1    #list1没有改变

[4, 3, 6, 2, 1]

>>> reversed(list1)

<listreverseiterator object at 0x02A98C70>

>>> list1   #list1没有改变

[4, 3, 6, 2, 1]

注意：sorted方法返回列表，而reserved返回一个可迭代对象

列表推导式--轻量级循环

列表推导式（list comprehension）是利用其它列表创建新列表（类似数学术语中的集合推导式）的一种方法。

>>> [x*x for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> [x*x for x in range(10) if x % 3 == 0]   #输出能被3整除的

[0, 9, 36, 81]

对比，以for语句创建列表：

result = []

for a in range(3):

    for b in range(3):

        result.append((a,b))

print result

输出：[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

例：

>>> girls=['alice','bernice','clarice']

>>> boys=['chris','arnold','bob']

>>> [b+'+'+g for b in boys for g in girls if b[0] == g[0]] #要求得到首字母相同的男孩女孩

['chris+clarice', 'arnold+alice', 'bob+bernice']

函数

内置函数

vars():显示当前模块的变量,比如

__file__:路径

__doc__:当前模块的注释

__name__:被执行的脚本__name__值=__main__,代表就是主函数（程序入口）

id():显示内存地址 is：比对两值得内存地址

all():接受一个序列，如果内部所有的值都是真的，返回真，否则返回假；用于用户输入判定

any():接受一个序列，只要内部元素有一个真，返回真

ord():接受一个字符返回ascci码对应值相反chr()

hex():转换十进制成16进制 oct():转换十进制成8进制 bin():转换十进制成2进制

自定义函数

while True：

    if cpu利用率 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

    if 硬盘使用空间 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

    if 内存占用 > 80%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

上述代码，if条件语句下的内容可以被提取出来公用，如下：

def 发送邮件(内容)

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

while True：

    if cpu利用率 > 90%:

        发送邮件('CPU报警')

    if 硬盘使用空间 > 90%:

        发送邮件('硬盘报警')

    if 内存占用 > 80%:

对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

函数的定义主要有如下要点：

· def：表示函数的关键字
· 函数名：函数的名称，日后根据函数名调用函数
· 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...不自动执行，调用后才执行
· 参数：为函数体提供数据
· 返回值：当函数执行完毕后，可以给调用者返回数据。如果没有指定返回值，返回None

def 函数名(参数):

    ...

    函数体

    ...

返回值

所有的函数都返回了东西，没有指定返回值时返回None

>>> def test():

    print 'this is printed'

    return         #return后没接任何参数，起到结束函数作用

    print 'this is not'

>>> x=test()

this is printed

参数

形式参数：写在def语句中函数名后的变量

注：参数只是变量而已，在函数内为参数赋予新值不会改变外部任何变量的值，即局部作用域（local scope）;

实际参数：调用函数时提供的实参

默认参数：必须放到最后，可以有多个

动态参数：

第1种

>>> def func(*args):

    print args

>>> func(18)

(18,)

>>> func(18,'qq')

(18, 'qq')

>>> li=[1,2,'a']

>>> func(li)

([1, 2, 'a'],)

>>> func(*li)

(1, 2, 'a')

特点：

可以接受多个参数；
内部自动构造元组，即返回元组类型
序列前加*避免内部构造元组

第2种

>>> def func(**args):

... print args

...

>>> func(123)

Traceback (most recent call last):

File "<input>", line 1, in <module>

TypeError: func() takes exactly 0 arguments (1 given)

>>> func(k1=123,k2='abc')   #以key=value形式传入参数

{'k2': 'abc', 'k1': 123}

>>> dic={'k1':18,'k2':'lzl'}

>>> func(dic)

Traceback (most recent call last):

File "<input>", line 1, in <module>

TypeError: func() takes exactly 0 arguments (1 given)

>>> func(**dic)    #传入字典类型时，加**

{'k2': 'lzl', 'k1': 18}

特点：

1.只接受key=value的参数

2.当是字典时，加**

通过以上验证得出动态参数除了是单值就是‘key=value’形式,因此如果结合使用就强大了，同字符串的forma()方法
>>> help(str.format)

Help on method_descriptor:

format(...)

    S.format(*args, **kwargs) -> string

    Return a formatted version of S, using substitutions from args and kwargs.

    The substitutions are identified by braces ('{' and '}').

以上内容参考《python基础教程第二版》和武sir博客http://www.cnblogs.com/wupeiqi/articles/4943406.html 整理完成，主要记录要点。