Python-学习笔记
本文笔记由Python入门和Python进阶两门课程整理而来
列表 List
list1 = ['physics', 'chemistry', 1997, 2000];- 倒序访问 [-1]下标访问倒数第一个元素 [0]下标访问正数第一个元素
- 切片同样适用于元组
>>> L[0:3]
#L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
['physics', 'chemistry', 1997]
#如果第一个索引是0，还可以省略：>>> L[:3]
#也可以从索引1开始，取出2个元素出来：>>> L[1:3]
#只用一个 '': ''表示从头取到尾：>>> L[:]
#切片操作还可以指定第三个参数,表示每N个取一个：>>> L[::2]
- 倒序切片
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:] //[-2~末尾]
['Bart', 'Paul']
>>> L[:-2]//[0~-2)
['Adam', 'Lisa']
>>> L[-3:-1]//[-3~-1)
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart']
- 列表生成式
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]#生成一个包含1-10的列表
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]#生成[1x1, 2x2, 3x3, ..., 10x10]
#range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
- 列表生成式+if判断
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
- 多层表达式
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
元组 Tuple
- t = ('Adam', 1, 'Bart')
- 元组定义后无法修改,tuple没有 append()方法，也没有insert()和pop()方法。
- 空tuple
>>> t = () - 创建单元素数值tuple
>>> t = (1,) - 索引迭代
for index, name in enumerate(L):
print index, '-', name
#由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身
字符串 string
字典 dict
- 定义
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59,
'Paul': 75
}
- 打印出的字典并不按给出顺序排列 原因是 字典对于元素的存储是通过hash算法 因此 dict是无序的
- 查询字典
d['Adam']即dict[key] - 使用 in 操作符查询key是否存在
if 'Paul' in d:
print d['Paul']
- 使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None
- key的元素类型可以是字符串 整数 浮点数 元组 , 而 value 的类型不限
- dict的特点:查找速度快,但所用空间大,牺牲空间换取速度
- 删除字典
dict.clear(); - 清空字典
dict.clear(); - 迭代字典的Key
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for v in d.itervalues():
sum = sum + v
print sum / len(d)
- 迭代字典的key和value
>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]
>>> for key, value in d.items():
... print key, ':', value
...
Lisa : 85
Adam : 95
Bart : 59
集合 set
- set的元素没有重复，而且集合是无序的
- 创建 set
s = set(['A', 'B', 'C'])//调用 set() 并传入一个 list - 使用 in 操作符查询元素是否存在
>>> 'Bart' in s
True
- 使用add(x)添加元素
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])
- 使用remove删除元素
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])
if语句
- Python使用4个空格作为缩进,相同缩进代码作为一个代码块
- if 语句后接表达式，然后用:表示代码块开始
for循环
- 使用for语句遍历元组or列表
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
函数
- 定义
def my_abs(x):
if x >= 0:
return x
else:
return -x
- 返回多个参数的函数(返回值是一个tuple)
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151.961524227 70.0
- 默认参数 默认参数只能定义在必需参数的后面
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
- 可变参数 名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
def average(*args):
sum = 0.0
if len(args) == 0:
return sum
for x in args:
sum = sum + x
return sum / len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)
函数式编程
python支持的函数式编程
（1）它支持的不是纯的函数式编程，因为它允许有变量；
（2）支持高阶函数，即函数也可以作为变量传入；
（3）支持闭包，有了闭包就能返回一个函数；
（4）有限度地支持匿名函数。
高阶函数
1.变量可以指向函数，直接对变量调用与直接对函数调用效果是一样的。例如：f=abs
，就是把变量f指向绝对值函数abs。f(-20)就等于abs（-20）
2.函数名其实就是一个指向函数的变量的名字。比如：abs=len，这时候abs这个名字就不指向绝对值函数，运算完了就是取list长度的一个函数。
3.能够接收函数作为参数的函数称之为高阶函数。因为变量可以指向函数，如f=abs；函数的参数可以接受变量，如def add（x,y,f）:；所以一个函数可能可以接收另一个函数作为参数，例如：在add函数内部就调用了abs函数f ，return f（x）+f（y）
(1)map()函数
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。map()函数不改变原有的 list
- 例如
def f(x):
return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])#操作函数在前,被操作的list在后
#结果为 [1, 4, 9, 10, 25, 36, 49, 64, 81]
(2)reduce()函数
reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
- 例如
def f(x, y):
return x + y
#先计算头两个元素：f(1, 3)，结果为4；
#再把结果和第3个元素计算：f(4, 5)，结果为9；
#再把结果和第4个元素计算：f(9, 7)，结果为16；
#再把结果和第5个元素计算：f(16, 9)，结果为25；
#由于没有更多的元素了，计算结束，返回结果25。
- reduce()还可以接收第3个可选参数，作为计算的初始值。
reduce(f, [1, 3, 5, 7, 9], 100)#结果为125
(3)filter()函数
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list
- 例如
def is_odd(x):
return x % 2 == 1
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
#输出为 [1, 7, 9, 17]
(4)sorted()函数
- 自定义比较函数:传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。
def reversed_cmp(x, y):#倒序排序
if x > y:
return -1
if x < y:
return 1
return 0
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]
(5)函数作为返回值
- 例如
def f():
print 'call f()...'
# 定义函数g:
def g():
print 'call g()...'
# 返回函数g:
return g
>>> x = f() # 调用f()
call f()...
>>> x # 变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x() # x指向函数，因此可以调用
call g()... # 调用x()就是执行g()函数定义的代码
(6)闭包
内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。
def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
