列表

list是处理一组有序项目的数据结构，可以在一个列表中存储一个序列的项目。列表是可变的数据类型。

shoplist = ['apple','amngo','carrot','banana']

list的主要方法有：

len()
append():在列表尾部添加一个项目
sort()

list和tuple-元组

要删除 list 末尾的元素用 pop()
要删除指定位置的元素，用 pop(i)方法，其中 i 是索引位置
另一种有序列表叫元组：tuple。tuple 和 list 非常类似，但 tuple 一旦初始化就不能修改。
classmate = ('Michael','Bob','Tracy')
如果定义只有一个元素的tuple：
t = (1,)

元组最常用的地方是用在输出中：

#!/usr/bin/python
# Filename: print_tuple.py
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?' % name

结果：

$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?

print语句可以使用跟着%符号的项目元组的字符串。

字典-dict

names = {'Michael':95,'Bob':75,'Tracy':85}
for name, address in names.items():#遍历输出键和值
    print '%s is %d years old.' %(name, address)

实现原理：给定一个名字，比如 Michael ，dict 在内部就可以直接计算出 Michael 对应的存放成绩的“页码”，也就是 95 这个数字存放的内存地址，直接取出来，所以速度非常快。
函数：函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了个“别名”：

a = abs #变量a指向abs函数
a(-1)   #所以也可以通过a调用abs函数

空函数:

def nop():
    pass

Python的返回多值其实就是返回一个tuple

默认参数

def add_end(L = []):
    L.append("END")
    return L
b = add_end()
print b
c = add_end()
print c

结果：

['END']
['END','END']

为什么会这样呢？
Python 函数在定义的时候，默认参数 L 就计算出来了，即 [] ，因为默认参数 L 也是一个变量,它指向对象 [] ，每次调用该函数,如果改变了L的内容,则下次调用时，默认参数的内容就变了，不再是函数定义时的 [] 了`。
定义默认参数时：默认参数必须指向不变对象。
改进：

def add_end2(L = None):
    if L is None:
        L = []
    L.append('END')
    return L

d = add_end2()
print d
e = add_end2()
print e

结果：

['END']
['END']

递归函数

def fact(n): 
    if n == 1:
        return 1 
    return n*fact(n-1) 
print fact(100)

这样可以计算fact(n) = 1 × 2 × 3 × ... × (n-1) × n
使用递归函数要防止栈溢出。在计算机中，函数的调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，就会导致溢出。
解决方法：尾递归优化
尾递归是指，在函数返回的时候，调用函数自身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def fact2(n):
    return fact_iter(n,1)

def fact_iter(num,product):
    if num == 1:
        return product
    return fact_iter(num - 1,num * product)

字符串的方法

startwith方法是用来测试字符串是否以给定字符串开始。
in操作符用来检验一个给定字符串是否为另一个字符串的一部分。
find方法用来找出给定字符串在另一个字符串中的位置

高级特性

列表、元组和字符串都是序列。序列的两个主要特点是：

索引操作符：可以让我们从序列中抓取一个项目
切片操作符：让我们能够获取序列的一个切片，即一部分序列。

切片

取一个list或tuple的部分元素是很常见的操作。
list:
假如有一个列表L，L = []

L[0:3]表示，从索引0开始取，知道索引3为止，但不包括索引3。
L[:10:2]表示前十个值，每两个取一个。
L[::5]所有值，每五个取一个

tuple:

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

字符串：

'abcdefg'[:3]
'abc'
'ABCDEFG'[::2]
'ACEG'

迭代

dict:

for key in d                #默认，迭代key
for value in d.itervalues() #迭代value
for k,v in d.iteritems()    #同时迭代key和value

判断一个对象是否可以迭代:

from collections import Iterable
isinstance('abc',Iterable)       #判断str是否可以迭代

enumrate函数：可以把list变成索引-元素对

for i, value in enumrate(['a','b','c']):
    print i,value

列表生成式
要生成[1×1,2×2, ... ,10×10]怎么做？

>>>[x*x for x in range(1,11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

使用两层循环生成全排列：

>>> [m + n for n in 'abc'for m in 'def']
['da', 'ea', 'fa', 'db', 'eb', 'fb', 'dc', 'ec', 'fc']

>>> import os
>>> [d for d in os.listdir('.')]
['DLLs', 'Doc', 'helloworld.py', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'python.exe', 'pythonw.exe', 'README.txt', 'Scripts', 'tcl', 'Tools', 'var.py', 'w9xpopen.exe']

列表生成式可以使用两个变量来生成list：

>>> d = {'x':'A','y':'B','z':'C'}
>>> [k+'='+v for k,v in d.iteritems()]
['y=B', 'x=A', 'z=C']

把一个list中所有的字符串变成小写：

>>> L = ['Hello','World','IBM','Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器
在python中，一边循环，一边计算的机制，称为生成器（Generator）

>>> g= (x*x for x in range(1,10))
>>> g
<generator object <genexpr> at 0x0299DCD8
>>> g.next()
1
>>> g.next()
4
>>> g.next()
9
>>> g.next()
16
>>> g.next()
25
>>> g.next()
36
>>> g.next()
49
>>> g.next()
64
>>> g.next()
81
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

输出斐波那契数列的前N个数：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a ,b = b, a+ b
        n = n + 1

fib(6)

python学习笔记-基础篇续