python学习笔记（二）更新中

数据结构：序列
1。python包含6中内建的序列：列表，元组，字符串，Unicode字符串，buffer对象,xrang对象。
序列是一种数据结构，它包含的元素都进行了编号（从0开始）。典型的序列包括列表、字符串、元组。其中列表是可变的，而元组和字符串是不可变。

列表和元组的区别是列表可修改，元组不能修改，绝大部分情况下列表可以代替元组（用元组作为字典的K时不行，K不能修改）,。列表元素用中括号( [ ])包裹，元素的个数及元素的值可以改变。元组元素用小括号(( ))包裹.
元组：
tag = ('robots', 77, 93, 'try')
列表：
tag = [1,2,3,4,5,6,7,8,9]
字典：
tag = {'host': 'earth'}
2。通用的序列操作：索引，分片(sliceing)，加，乘，计算序列长度，找出最大或最小元素，检查某个元素是否属于该序列

分片示例：(包含起始不包含结尾，和JAVA一样)
>>> tag = ('abcdefghijklmnopqrstuvwxyz')
>>> tag[3:6]
def

>>> tag = [1,2,3,4,5,6,7,8,9]
>>> tag[3:6]

[4,5,6]
如果要从尾向头截取：(索引从尾算9就是-1，8是-2)

>>> tag = [1,2,3,4,5,6,7,8,9]
>>> tag[-6:-3]

[4,5,6]

如果要截取到尾部最后一个数应该这样
>>>tag[-6:]
>>>[4,5,6,7,8,9]

分片赋值
>>>name=list('perl')
>>>name[2:]=list('ar')
>>>print name
['p', 'e', 'a', 'r']

利用分片插入元素
>>>numbers=[1,5] 
>>>numbers[1:1]=[2,3,4]
>>>print numbers
[1, 2, 3, 4, 5]

利用分片删除元素
>>>numbers=[1,2,3,4,5]
>>>numbers[1:4]=[]
>>>print numbers
[1, 5]

分片可以设置步长

>>>n=[1,2,3,4,5]

>>>print n[::2]
[5, 3, 1]

分片可以实现反转，通过讲步长设置为负值

>>>n=[1,2,3,4,5]

>>>print n[::-2]

列表
list函数适用于所有类型的序列，而不只是字符串
>>>list('hello')
['h','e','l','l','o']

extend方法可以在列表的末尾一次性追加另一个序列中的多个值。
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a.extend(b)
print a
[1, 2, 3, 4, 5, 6]

append方法用于在列表末尾追加新的对象
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a.append(b)
>>>print a
[1, 2, 3, [4, 5, 6]]

count方法统计某个元素在列表中出现的次数
>>>['1','2','3','4','1'].count('1')
2

index方法用于从列表中找出某个值第一个匹配项的索引位置：
>>>knights=['we','are','knights','who','say']
>>>knights.index('who')
4

insert方法用于将对象插入到列表中：
>>>numbers=[1,2,3,4]
>>>numbers.insert(3,'four')
>>>print numbers
[1,2,3,'four',4]

pop方法会移除列表中的一个元素（默认是最后一个元素），并且返回该元素的值（pop方法是唯一一个既能修改列表又返回元素值的列表方法）
>>>x=[1,2,3]
>>>print x.pop()
3
>>>print x
[1,2]
>>>print x.pop(0)
1
>>>print x
[2]

remove方法用于移除列表中某个值的第一个匹配项
>>>x=['to','be','or','not','to','be']
>>>x.remove('be')
>>>print x
['to','or','not','to','be']

删除列表中元素
names=['a','b','c']
del names[2]

reverse方法将列表中的元素反向存放，reverse方法没有返回值，reversed方法会返回一个iterator对象,可用于：
>>>x=[1,2,3]
>>>list(reversed(x))
[3,2,1]

sort方法用于在原位置对列表进行排序。sort方法是没有返回值的
>>>x=[4,5,2,1,7,9]
>>>y=x.sort() #Don`t do this
>>>print y
None

sorted函数返回排序后的列表,sorted函数可以用于任何序列，却总是返回一个列表。

>>>x=[4,5,2,1,7,9]
>>>y=sorted(x) 

>>>print x
[4,5,2,1,7,9]
>>>print y
[1,2,4,5,7,9]

元组
tuple函数的功能与list函数基本上是一样的：以一个序列作为参数并把它转换为元组。如果参数就是元组，那么该参数就会被原样返回。
>>>tuple([1,2,3])
(1,2,3)
>>>tuple('abc')
('a','b','c')

字符串
字符串格式化
>>>format="Hello,%s.%s enough for ya?"
>>>values=('world','Hot')\
>>>print format % values
Hello,world.Hot enough for ya?

>>>'Price of eggs: $%d' %  42
'Price of eggs: $42'

>>> '%s is %s' % (names[i],ages[i])

字符串可以按照字母顺序排列进行比较
>>>'alpha'<'beta'
True
字符串方法
find方法可以在一个较长的字符串中查找子字符串。它返回子串所在位置的最左端索引。如果没有找到返回-1.
find方法还可以接受可选的起始点和结束点参数：
>>>subject='abcdefg'
>>>subject.find('bcd')
>>>subject.find('bcd',2) #只提供起始点
>>>subject.find('bcd',2,6) #提供起始点和结束点

join方法是非常重要的字符串方法，它是split方法的逆方法。
>>>dirs='','usr','bin','env'
>>>'/'.join(dirs)
/usr/bin/env
>>>print 'C:'+'\\'.join(dirs)
C:\usr\bin\env

lower方法返回字符串的小写母板,相关的方法有：islowe、capitalize、swapcase、title、istitle、upper、isupper。
title方法
>>>"hello word".title()
"Hello Word"

replace方法
>>>'This is a test'.replace('is','eez')
'This eez a test'

split方法(如果不提供任何分隔符，程序会把所有空格作为分隔符)
>>>'1+2+3+4+5'.split('+')
['1','2','3','4','5']

strip方法返回去除两侧（不包括内部）空格的字符串
>>>'            This is a test          '.strip()
'This is a test'

字符串反转
>print ''.join(reversed("abcd"))
也可以用分片来实现
>print 'abcd'[::-1]

字典
dict函数，通过其他映射（比如其他字典）或者（键，值）这样的序列对建立字典。
>>>items=[('name','Gumby'),('age',42)]
>>>d
{'age':42,'name':'Gumby'}

clear方法清除字典中所有的项。这个是原地操作（类似list.sort），所以无返回值（或者说返回值为None）

copy方法返回一个具有相同键-值的新字典（这个方法实现的是浅复制（shallow copy）,因为值本身就是相同的，而不是副本），深复制（deep copy）参见deepcopy函数

 fromkeys方法使用给定的键建立新的字典，每个键默认对应的值为None.

get方法是个更宽松的访问字典项的方法。一般来说，如果试图访问字典中不存在的项时会出错：
>>>d={}
>>>print d['name']
#error
而使用get就不会:
>>>print d.get{'name'}
None

has_key方法可以检查字典中是否含有给出的键。表达式d.has_key(k)相当于表达式 k in d。

items方法将所有的字典项以列表方式返回，这些列表项中的每一项都来自于（键，值）。但是项在返回时并没有特殊的顺序。

iteritems方法作用大致相同，但是会返回一个迭代器对象而不是列表。

keys方法将字典中的键以列表形式返回，而iterkeys则返回针对键的迭代器。

pop方法用来获得对应于给定键的值，然后将这个键-值从字典中移除。

popitem方法类似于list.pop，后者会弹出列表的最后一个元素。但不同的是，popitem弹出随机的项，因为字典并没有“最后的元素”或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效了（因为不用首先获取键的列表）

setdefault方法在某种程度上类似于get方法，就是能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值。
>>>d={}
>>>d.setdefault('name','N/A')
>>>print d
{'name': 'N/A'}

update方法可以利用一个字典项更新另外一个字典，提供的字典中的项会被添加到旧的字典中，若有相同的键则会覆盖。
>>>d={1:'a',2:'b',3:'c',4:'d'}
>>>x={1:'c',5:'e'}
>>>d.update(x)
>>>d
{1: 'c', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

values方法以列表的形式返回中的值（itervalues返回值的迭代器）。与返回键的列表不同的是，返回值的列表中可以包含重复元素。

循环遍历字典元素
>>>d={1:'a',2:'b'}
>>>for D in d:
          print D,' ',d[D]
1 a
2 b

条件、循环和其他语句

从模块中导入函数
import somemodule
from somemodule import somefunction
from somemodule import somefunction,yetanotherfunction
from somemodule import *
为整个模块起别名
>>>imort math as foobar
>>>foobar.sqrt(4)
2.0
为函数起别名
>>>from math import sqrt as foobar
>>>foobar(4)
2.0

赋值
序列解包
>>>x,y,z=1,2,3
>>>print x,y,z
1 2 3
>>>x,y=y,x
>>>print x,y,z
2 1 3
这种就是序列解包，更形象的表示：
>>>values=1,2,3
>>>values
(1,2,3)
>>>x,y,z=values
>>>x
1
应用：
>>>scoundrel={'name'：'Robin','girlfirend':'Marion'}
>>>key,value=scoundrel.popitem()   #随机弹出一项,详细说明搜索本文popitem方法
>>>key
'girlfriend'
>>>value
'Marion'

条件和条件语句
除了下面的值在做布尔表达式的时候，会被解释器看作false，其他的值都是true
False None 0 "" () [] {}
True和False属于布尔类型，bool函数可以用来（和list、str、tuple一样）转换其他值
>>>bool('ewafeawf')
True
>>>bool(42)
True
>>>bool('')
False
>>>bool(0)
False
注意虽然[]和""都是假值，但是他们本身却不相等。也就是说[]！=""

if用法见笔记一，这里只做补充
python中比较运算符和赋值运算一样是可以连接的：
>>>i=12
>>>if 0<i<20:
             print True
True

对于python中==和is的用法：
==是同等运算符
is是同一性运算符
总结：使用==运算符来判定两个对象是否相等，使用is判定两者是否等同（同一个对象）
注意：避免将is运算符用于比较类似数值和字符串这类不可变值。由于python内部操作这些对象的方式的原因，使用is运算符的结果是不可预
测的。

并行迭代
同时迭代两个序列
>>>names = ['a','b','c','d','e']
>>>ages = [1, 2, 3, 4, 5]
>>>for i in range(len(names)):
              print '%s is %s' % (names[i],ages[i])

zip函数可以用来进行并行迭代，可以把两个序列“压缩”在一起，然后返回一个元组列表。
>>>zip(names,ages)
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]

解包元组
>>>for name,age in zip(names,ages)
                print name,'is',age
zip函数也可以作用于任意多的序列。zip可以应付不等长的序列：当最短的序列“用完”的时候就会停止：
>print zip(range(5),xrange(1000000000))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
在上面的代码中，不推荐用range替换xrange。尽管只需要前5个数字，但是range会计算所有的数字，这要花费很长时间。而使用xrange就不用担心这个问题，它只计算前5个数字。

列表推导式-轻量级循环
>print [x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>print [x*x for x in range(10) if x%3==0]
[0, 9, 36, 81]
>print [(x,y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

抽象
创建函数
用python写的斐波那契数举例：

def fibs(num):
'这里可以添加函数注释'
result = [0, 1]
for x in range(num-2):
result.append(result[-2] + result[-1])
return result

print fibs(8)
#[0, 1, 1, 2, 3, 5, 8, 13]

定义函数时可以给参数设置默认值：

def test(name,age=22,sex='man'):
print '%s %d %s' %(name,age,sex)

test('zhangsan',25)
#zhangsan 25 man

不定长参数：
参数分装在元组中：

def test(*params):
print params

test('zhangsan','lisi','wangwu')
#('zhangsan', 'lisi', 'wangwu')

应用：

def test(*params):
print params

para={'a','b','c'}
test(*para)
#('a', 'c', 'b')

参数分装在字典中：

def test(**params):
print params

test(a=1,b=2,c=3)
#{'a': 1, 'c': 3, 'b': 2}

应用：

def test(**params):
print params

para={'a':1,'b':2,'c':3}
test(**para)
#{'a': 1, 'c': 3, 'b': 2}