Python的基本用法
---恢复内容开始---
一、函数
1.1 默认参数
想要计算一个数x的n次方，可以定义如下的函数。但是有时候我们仅仅只需要计算x^2，所以只想使用一个参数即power(x)，这时如果仍用如下代码会报错
def power(x, n): s = 1 while n > 0: n = n - 1 s = s * x return s
def power(x,n=2)
可以改成上面的形式，不传入参数，即默认n=2。同时，当有多个默认参数时，我们可以指定为哪个默认参数赋值如下
def fun(a,b=2,c=3): pass fun(4,c=6)
有一点需要注意：默认参数必须是不变对象，不能是list这样的可变对象
def add_end(L=[]): L.append('END') return L >>> add_end() ['END'] >>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END']
函数定义后，默认参数的值就被计算出来了。如果默认参数是可变的，那么每次调用函数后，默认参数的值就会发生改变。
1.2 可变参数
如果参数的个数是不确定的，可以使用list或者tuple进行封装，也可以使用可变参数，方法如下：
def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum
""" 使用list作为可变参数时，可以使用下面的简单方法
>>> nums = [1, 2, 3]
>>> calc(*nums)
141.3 关键字参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw): print('name:', name, 'age:', age, 'other:', kw) """ 函数除了接收两个必填参数name和age外，还可以接收若干个关键字参数kw >>> person('Michael', 30) name: Michael age: 30 other: {} >>> person('Bob', 35, city='Beijing') name: Bob age: 35 other: {'city': 'Beijing'} >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
1.4 命名关键字参数
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job): print(name, age, city, job)
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job): print(name, age, args, city, job)
二 List和Tuple
2.1 List和Tuple相当于一个数组，但是数组里可以存放的内容是不受限制的，也不需要全部相同，同时一个List里可以有一个List。List是可变的对象，而Tuple是不可变的对象
对于List和Tuple的访问，可以使用切片技术：
>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] >>> L[1:3] ['Sarah', 'Tracy'] """ L[i:j]表示从索引i开始，取到索引j-1的内容
2.2 遍历元素时，C或其他语言是按照下标进行的，而Python的遍历可以不需要下边，只要变量是可以迭代的即可，如dict就可以迭代
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
... print(key)
...
a
c
b
""" 遍历key和value
>>> for k,v in d.items():
... print(k,v)
...
a 1
b 2
c 3
如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
>>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True >>> isinstance(123, Iterable) # 整数是否可迭代 False
最后一个小问题，如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']): ... print(i, value) ... 0 A 1 B 2 C
2.3 列表生成式：
如果要创建一个列表，可以使用for循环，同时也可以有更简单的方法进行创建
>>> list(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]
""" for循环后可以增加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 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
2.4 列表生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630>
""" 如果要访问生成器g的元素，可以使用for循环，也可以使用next(g)一个个访问
>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81生成器类似于函数，保存的是算法，所以可以在打印输出时通过算法进行计算。
定义一个计算斐波拉契数列的函数
def fib(max): n, a, b = 0, 0, 1 while n < max: print(b) a, b = b, a + b n = n + 1 return 'done'
>>> fib(6)
1
1
2
3
5
8
'done'
此时，只要把print(b)写成yield b就可以把函数fib改成一个generator了
def fib(max): n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1 return 'done' >>> f = fib(6) >>> f <generator object fib at 0x104feaaa0>
2.5 迭代器
可用next函数不断访问下一个元素的对象是迭代器，如generator就是一个迭代器
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
三、 函数式编程
3.1 高阶函数
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
>>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81]
再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
filter()函数接收一个函数和一个序列，filter()函数将函数作用于序列上，根据作用的结果是True or False来决定保留还是舍弃。
注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
Python实现素数的筛选：
"""定义一个生成器，生成一个3开始的无限奇数序列
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
定义一个筛选函数
def _not_divisible(n):
return lambda x: x % n > 0定义一个生成器，不断返回下一个元素
def primes(): yield 2 it = _odd_iter() # 初始序列 while True: n = next(it) # 返回序列的第一个数 yield n it = filter(_not_divisible(n), it) # 构造新序列
打印输出前1000的素数
for n in primes():
if n < 1000:
print(n)
else:
break
排序函数可以使用sorted()这个函数
>>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36] 可以自定义一个函数进行排序，传入函数到key >>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36] 对字符串进行排序，默认是按照ASCII进行排序 >>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob'] 忽略大小写： >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo'] 默认是从小到大，如果是从大到小 >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']
3.2 函数作为返回值
Python中不仅函数可以作为参数传入，同时，函数也可以作为结果输出
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function lazy_sum.<locals>.sum at 0x101c6ed90> >>> f() 25
注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。
另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。我们来看一个例子
def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count()
f1(),f2(),f3()的结果全为9，原因是f1(),f2(),f3()是一起执行的。
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
匿名函数lambda是对函数的一种简化
def f(x): return x * x
可以写成
>>> f = lambda x: x * x
函数模块中的作用域问题：
在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。
正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；
之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
