python基础

  1. 有序集合：list,tuple,str,unicode
  2. 无序集合：set
  3. 无序集合并且具有key-value对：dict

列表

1
list: L = ['Michael', 100, True]
列表,是一种有序的集合,可以随时添加和删除其中的元素
list中包含的元素并不要求都必须是同一种数据类型
list查找速度随着元素增加而逐渐下降、占用内存小,但是查找速度慢

1.访问元素:可通过索引的方式访问列表元素,第一个元素为L[0],也可倒序访问,如最后一个元素为L[-1]
2.添加元素:append()方法在list末尾添加元素、insert(索引号,待添加的新元素)在指定索引位置添加
3.删除元素:pop()方法删掉list的最后一个元素,并返回这个元素、pop(索引号)删除指定索引位置的元素

元祖

1
tuple: t = ('Adam', 'Lisa', 'Bart')
元祖,是另一种有序的列表,一旦创建完毕,就不能修改
访问元素的方式与list相同、单元素tuple定义方式:(1,)可防止被解析为整数1

字典

1
2
3
4
5
dict: d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
查找速度快(所有元素查找速度相同、但占用内存大)、元素无序、作为key的元素不可变(故list不可作为key)
通过key访问dict的value、也可通过dict本身提供的一个get(key)方法返回对应value

集合

1
set: s = set(['A', 'B', 'C'])

可变对象不能放入set中、元素无序(传入包含重复元素的list,set会自动去掉重复的元素)

1.创建set:调用set()并传入一个list,list的元素将作为set的元素
2.访问set:只能判断一个元素是否在set中
3.添加元素:add(添加的元素)、删除元素:remove(删除的元素)

数据类型

整型、浮点型、字符串、布尔值、空值

raw字符串

在字符串前面加个前缀 r ,表示这是一个 raw 字符串,
里面的字符则无需要转义(r'...'不能表示多行字符串，也不能表示包含'和"的字符串)
多行字符串:用'''...'''表示

定义可变参数

可变参数的名字前面有个*号,Python解释器会把传入的一组参数组装成一个tuple传递给可变参数

1
2
def fn(*args):
    print args

切片

对list进行切片:

L[0:3] 表示,从索引0开始取,直到索引3为止,但不包括索引3的3个元素(第一个索引是0,可以省略为L[:3])
L[:]   表示所有元素,实际上复制出了一个新list
L[::2] 第三个参数表示每N个取一个,L[::2]会每两个元素取出一个来,也就是隔一个取一个

同理可得倒序切片与对字符串的切片

迭代

1.形式:
    for ... in ...
2.索引迭代:    
    enumerate()函数把 
    ['Adam', 'Lisa', 'Bart', 'Paul']
    变成了类似 
    [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
    因此,迭代的每一个元素实际上是一个tuple: 

1
2
for index, name in enumerate(L):
    print index, '-', name
3.迭代dict的value: 
    values()方法把dict转换成一个包含所有value的list,再通过遍历这个list来遍历value
    itervalues()方法会在迭代过程中依次从dict中取出value,所以比values()方法节省了生成list所需的内存

4.迭代dict的key和value: 
    items()方法把dict对象转换成了包含tuple的list,对这个list进行迭代,可同时获得key和value
    iteritems()不把dict转换成list,而是在迭代过程中不断给出tuple,所以,iteritems()不占用额外的内存

列表生成式

1.生成列表:        
        range(1, 11)
        >>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        [x * x for x in range(1, 11)] 
        >>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2.多层表达式:
            [m + n for m in 'ABC' for n in '123']
        >>> ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

高阶函数

1.函数作为参数:    

1
2
def add(x, y, f):
    return f(x) + f(y)
2.map():
  接收一个函数f和一个list,并通过把函数f依次作用在list的每个元素上,
  得到一个新的list并返回(不改变原有的list)

1
2
3
def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
3.reduce():
    接收的参数和map()类似,但reduce()传入的函数f必须接收两个参数,
    reduce()对list的每个元素反复调用函数f,并返回最终结果值

1
2
3
def f(x, y):
    return x + y
reduce(f, [1, 3, 5, 7, 9])
    实际上是对 list 的所有元素求和,结果为25
    reduce()还可以接收第3个可选参数,作为计算的初始值,reduce(f, [1, 3, 5, 7, 9], 100)结果将变为125
4.filter():
    接收的参数和map()类似,传入的函数f的作用是对每个元素进行判断,
    返回True或False,根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list

1
2
3
def is_odd(x):
    return x % 2 == 1
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果为[1, 7, 9, 17]

闭包

内层函数引用了外层函数的变量(参数也算变量),然后返回内层函数的情况,称为闭包
闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,
就要确保引用的局部变量在函数返回后不能变

匿名函数

关键字lambda表示匿名函数,冒号前面的x表示函数参数
匿名函数 lambda x : x * x 实际上就是:

1
2
def f(x):
    return x * x