回味Python2.7——笔记1

一、基本知识

1、一个值可以同时赋给几个变量:

>>> x = y = z = 0  # Zero x, y and z
>>> x
0
>>> y
0
>>> z
0

2、创建复数

>>> a=1+6j
>>> x=complex(1,3) # x=1+3j
>>>x.real
1
>>>x.imag 
3

3、字符串

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

字符串可以标识在一对三引号中： """ 或 ''' 。三引号中，不需要行属转义，它们已经包含在字符串中。

hello = r"This is a."
print(hello)

字符串也可以被截取（检索）

Unicode

>>> u'Hello World !'
u'Hello World !'

>>> str(u"abc")
'abc'

4、列表

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

就像字符串索引，列表从 0 开始检索。列表可以被切片和连接

允许嵌套列表（创建一个包含其它列表的列表）

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2

5、for语句

Python 的 for 语句依据任意序列（链表或字符串）中的子项，按它们在序列中的顺序来进行迭代。

>>> # Measure some strings:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
...     print x, len(x)
...
cat 3
window 6
defenestrate 12

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]

6、定义函数

全局变量不能在函数中直接赋值（除非用 global 语句命名）

>>> def fib(n):
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print a,
...         a, b = b, a+b

函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring 。

　　6.1、Lambda 形式

Lambda 形式可以用于任何需要的函数对象。

类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

　　6.2、文档字符串

第一行应该是关于对象用途的简介

如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分隔。

Python 的解释器不会从多行的文档字符串中去除缩进，所以必要的时候应当自己清除缩进。

文档第一行通常空出，如果写了，__doc__格式不是很好

def test():
    """
    aaaaaaaaaaaaaaaaaaaa
    this is a test document!
    bbbbbbbbbbbbbbbbbbbb
    """
    pass

print test.__doc__
输出如下：

    aaaaaaaaaaaaaaaaaaaa
    this is a test document!
    bbbbbbbbbbbbbbbbbbbb

7、 插曲：编码风格建议

• 使用 4 空格缩进，而非 TAB。

  在小缩进（可以嵌套更深）和大缩进（更易读）之间，4空格是一个很好的折中。TAB 引发了一些混乱，最好弃用。

• 折行以确保其不会超过 79 个字符。

  这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。

• 使用空行分隔函数和类，以及函数中的大块代码。

• 可能的话，注释独占一行

• 使用文档字符串

• 把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格： a = f(1, 2) + g(3, 4) 。

• 统一函数和类命名。

  推荐类名用 驼峰命名， 函数和方法名用 小写_和_下划线。总是用 self 作为方法的第一个参数（关于类和方法的知识详见 初识类 ）。

• 不要使用花哨的编码，如果你的代码的目的是要在国际化 环境。 Python 的默认情况下，UTF-8，甚至普通的 ASCII 总是工作的最好。

• 同样，也不要使用非 ASCII 字符的标识符，除非是不同语种的会阅读或者维护代码。

二、数据结构

1. 关于列表更多的内容

Python 的列表数据类型包含更多的方法。 这里是所有的列表对象方法：

• list.append(x)　　把一个元素添加到链表的结尾
• list.extend(L) 　　将一个给定列表中的所有元素都添加到另一个列表中
• list.insert(i, x)　　在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引
• list.remove(x)　　删除链表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
• list.pop([i])　　从链表的指定位置删除元素，并将其返回。如果没有指定索引， a.pop() 返回最后一个元素。元素随即从链表中被删除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
• list.index(x)　　返回链表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
• list.count(x)　　返回 x 在链表中出现的次数。
• list.sort()　　对链表中的元素就地进行排序
• list.reverse()　　就地倒排链表中的元素
• del 语句　　 有个方法可以从列表中按给定的索引而不是值来删除一个子项： del 语句。它不同于有返回值的 pop() 方法。语句 del 还可以从列表中删除切片或清空整个列表（我们以前介绍过一个方法是将空列表赋值给列表的切片）。del 也可以删除整个变量

  >>> a = [-1, 1, 66.25, 333, 333, 1234.5]
  >>> del a[0]
  >>> a
  [1, 66.25, 333, 333, 1234.5]
  >>> del a[2:4]
  >>> a
  [1, 66.25, 1234.5]
  >>> del a[:]
  >>> a
  []

tips:

collections模块中的deque，可以实现在首处插入和删除数据

from collections import deque
a=deque([1,2,3,4,5,6,7])
a.appendleft(0)
print a
a.popleft()
print a

输出结果：

deque([0, 1, 2, 3, 4, 5, 6, 7])
deque([1, 2, 3, 4, 5, 6, 7])

2、函数式编程工具

对于链表来讲，有三个内置函数非常有用: filter(), map(), 以及 reduce()

　　2.1、filter（）

filter(function, sequence) 返回一个 sequence（序列），包括了给定序列中所有调用 function(item) 后返回值为 true 的元素。（如果可能的话，会返回相同的类型）。如果该 序列（sequence） 是一个 string （字符串）或者 tuple （元组），返回值必定是同一类型，否则，它总是 list 。

>>> def f(x):
...         return x % 2 != 0 and x % 3 != 0
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]    

　　2.2、map()

map(function, sequence) 为每一个元素依次调用 function(item) 并将返回值组成一个链表返回。

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

可以传入多个序列，函数也必须要有对应数量的参数，执行时会依次用各序列上对应的元素来调用函数（如果某些序列比其它的短，就用 None 来代替）。如果把 None 做为一个函数传入，则直接返回参数做为替代。

>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]

　　2.3、reduce（）

reduce(function, sequence) 返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数 function，再以返回值和第三个参数调用，依次执行下去。

>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

如果序列中只有一个元素，就返回它，如果序列是空的，就抛出一个异常。

3、 列表推导式

squares = [x**2 for x in range(10)]

列表推导式由包含一个表达式的括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。 结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等同于：

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表推导式可使用复杂的表达式和嵌套函数:

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

matrix=[[1,2,3],[4,5,6]]
[[row[i] for row in matrix] for i in range(3)]

[[1, 4], [2, 5], [3, 6]]

4、元组和序列、集合、字典

元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可以有或没有括号，不过经常括号都是必须的（如果元组是一个更大的表达式的一部分）。不能给元组的一个独立的元素赋值（尽管你可以通过联接和切割来模拟）。还可以创建包含可变对象的元组。元组就像字符串，不可改变。

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合），intersection（交），difference（差）和 sysmmetric difference（对称差集）等数学运算。大括号或 set() 函数可以用来创建集合。 注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False

字典以 关键字 为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键： 值对 （key:value pairs）集合，键必须是互不相同的（在同一个字典之内）。一对大括号创建一个空的字典： {} 。

字典的主要操作是依据键来存储和析取值。也可以用 del 来删除键：值对（key:value）。如果你用一个已经存在的关键字存储值，以前为该关键字分配的值就会被遗忘。试图从一个不存在的键中取值会导致错误。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

dict() 构造函数可以直接从 key-value 对中创建字典:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推导式可以从任意的键值表达式中创建字典:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便:

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

5、others

在序列中循环时，索引位置和对应值可以使用 enumerate() 函数同时得到:

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时循环两个或更多的序列，可以使用 zip() 整体打包:

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print 'What is your {0}?  It is {1}.'.format(q, a)
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

深入条件控制

比较操作符 in 和 not in 用来判断值是否在一个区间之内。操作符 is 和 is not 比较两个对象是否相同；这只和诸如链表这样的可变对象有关。所有的比较操作符具有相同的优先级，低于所有的数值操作。

比较操作可以传递。例如 a < b == c 判断是否 a 小于 b 并且 b 等于 c 。

比较操作可以通过逻辑操作符 and 和 or 组合，比较的结果可以用 not 来取反义。这些操作符的优先级又低于比较操作符，在它们之中，not 具有最高的优先级， or 优先级最低，所以 A and not B or C 等于 (A and (notB)) or C 。当然，括号也可以用于比较表达式。

逻辑操作符 and 和 or 也称作 短路操作符 ：它们的参数从左向右解析，一旦结果可以确定就停止。