廖雪峰--python教程：笔记二

聊一下条件控制和循环：
条件控制：

strBirth = input('please enter your birth:')
birth = int(strBirth)
if birth < 2000:
    print('You are after 00')
elif birth < 2010:
    print('You are after 10')
else:
    print('You are before 00')

当用户从屏幕上输入出生年份的时候，python接收的类型是字符串类型，所以在做判断之前，先将strBirth转换为int类型birth，然后再和整数进行比较。

elif 是else if 的缩写，完全可以有多个elif

循环：有两种循环，一种是for...in，另一种是while
for...in循环，依次把list或者tuple中的每一个元素迭代出来：
如计算1+2+...+100:

sum = 0
for i in range(101):
    sum = sum + i

range():生成一个整数序列，从0开始。

while循环：只要条件满足就继续循环，条件不满足时结束循环
如，计算100以内的奇数和

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n-2

break：在循环中，break语句可以提前退出循环
continue: 在循环中，结束本次循环，开始下一轮的循环
这两个语句通常都是配合着if语句使用

字典dict和无序不重复的集合set
字典dict:使用键值对(key-value)存储，key必须是不可变对象，具有极快的查找速度

d = {'A':21,'B':{'C':2,'D':1}} 或 d = dict(A=21,B=dict(C=2,D=1))
所以取d['A']，为21

查看key是否在d中，两种方法：
通过 in:
'A' in d: 返回True 或则 False
通过get():
d.get('A',value): value是自己指定的值，若d中不存在'A',返回value,默认value是None,若存在则返回'A'对应的值21

要删除key，使用pop(key)，对应的值也会一同被删除
注意：dict内部存放的顺序和key放入的顺序无关

dict和list相比：
dict:查找和插入速度快、但是费内存空间（以空间换时间）
list:查找和插入的时间随着元素的增加而逐渐增加，但是占内存小（以时间换空间）

set:
set和dict一样，但是仅仅存储key，并不存储key对应的value，由于key是不能重复的，且是无序的，所以set是元素不重复的，无序的集合，要创建一个set，需提供一个list作为输入集合
s = set([2,,3,1]) or s = {2,3,1}: {1,2,3}
add(key)：添加元素
remove(key)：删除元素
因为set可以看作是数学上的没有重复元素，无序的集合，所以set可以做交(&)，并(|)等操作

不可变对象：
str是不可变对象，list是可变对象
如，
a = 'abc'
b =a.replace('a','A')
则，变量a还是指向字符串'abc'，变量b则是指向字符串'Abc'
对于不可变对象，调用对象自身的任何方法，不会改变对象本身；相反，这些方法会创建新的对象并返回，这样就保证了不可变对象本身是永远不变的

函数：
Python内置了很多有用的函数，可供调用使用，还可以导入第三方包，调用需要的函数。函数名实际上是一个函数变量，是这个函数对象的引用，所以完全可以给这个函数起个”别名“，也就是定义一个新的变量名来指向这个函数对象（类似于变量之间那样），可以通过help(函数名)这个命令来查看该函数的使用。

定义函数：
在Python中，定义一个函数要使用def语句，然后是函数名、圆括号、括号中的参数和冒号：然后在缩进块里编写函数体，函数的返回值用return语句返回。函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回；如果没有return，函数执行完毕后也会返回结果，只不过结果是None。return None可以简写为return。

空函数：也就是什么事情都不干的函数，作用是充当一个占位符
def non():
pass

函数返回多个值：
实际上返回值是一个tuple，但是在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。所以，python的函数返回多值实际上就是返回一个tuple。

函数参数：
定义函数时，我们把参数的名字和位置确定下来，函数的接口就完成了。对于调用者来说，无需知道函数内部的复杂实现逻辑，他只要知道，传入哪些正确的参数，返回一个什么样的值就行啦。

python函数的定义非常简单，但灵活度很大，对于函数参数，不仅可以有必选参数，还可以有可选参数，可变参数和关键字参数。

必选参数（位置参数）：

def power(x,n):
    s = 1
    while n > 0:
        n = n-1
        s = s * x
   return s

power(x,n): x ，n都是位置参数，调用函数时，传入的值按照位置顺序依次赋给参数x和n

默认参数：

def power(x,n=2):
    s = 1
    while n > 0
        n = n-1
        s = s * n
    return s

这样，当传入一个值的时侯power(5):就是计算5的平方；
设置默认参数的时候需要注意：
位置参数在前，默认参数在后，否之解释器会报错
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
定义默认参数要牢记一点，默认参数必须指向不变对象（字符串，整数，浮点数，None等）

可变参数：
要定义一个可变参数的函数，我们把输入作为一个list或者tuple传进来，这样，函数可以这样定义

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n*n
    return sum

但是，在调用时需要先将输入组装成list或者tuple：calc([1,2,3])或者calc((1,2,3))
如果利用可变的参数，可以把调用简化为：calc(1,2,3)
所以，可变参数定义如下：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n*n
    return sum

定义一个可变参数函数，和定义一个接收list或者tuple的参数函数相比，仅仅在参数numbers前多了一个*号。在参数内部，函数接收的时一个tuple，因此函数代码不用改变。
如果说，已经有一个list或者tuple，调用可变参数怎么办呢？
nums = [1,2,3];
只需要把nums变为*nums

关键字参数：
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
如：

def person(name,age,**kw):
    print(name,age,'other:',kw)

person('doublelin','23',city='Heifei'): doublelin 23 other:{'city':'Beijing'}

extra = {'city':'Heifei','job':'Student'}

和可变参数类似，也可以先组装出一个 extra字典，然后，把该dict转换为关键字参数传入进去，我们使用**变量名，将这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra.

命名关键字参数：
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。如果要限制关键字参数的名字，就可以用命名关键字参数，例如：仅仅接收city和job作为关键字参数。

def person(name,age,*,city,job,**kw):
    print(name,age,city,job,'other:',kw)

person('doublelin','23',city='Hefei',job='Student',learn_language='Python')

doublelin 23 Hefei Student other: {'learn_language': 'Python'}

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数视为命名关键字参数。需要将命名关键字参数排在关键字参数之前。
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。当然，命名关键字参数也可以在函数定义时，添加默认值，调用时，可以不传入具有默认值的命名关键字参数。

参数组合：
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
如：

def f1(a,b,c=0,*args,**kw):
    print(a,b,c,'args=',args,'kw=',kw)

通过一个tuple和dict,可以这样调用上述函数：
args = (1,2,3,4)
kw={'d':99,'x':'#'}
f1(*args,**kw)
输出： 1 2 3 args= (4,) kw= {'d': 99, 'x': '#'}
所以，对于任意函数，都可以通过类似func(*args,**kw)的形式调用它，无论它的参数是如何定义的。

递归函数：
当函数调用自身函数时，该函数就是递归函数；递归函数逻辑清晰，简单实现，但因为函数调用是通过栈这个数据结构实现的，每当进行一个函数调用，栈就会增加一层栈帧。由于栈的大小有限，所以进行多次递归函数，会导致栈溢出。理论上，所有的递归函数都可以写成循环的方式。

汉诺塔--递归函数实现：

def move(n,a,b,c):
    if n==1:
        print(a,'-->',c)
    else:
       move(n-1,a,c,b)
       print(a,'-->',c)
       move(n-1,b,a,c)

move(3,'A','B','C')                        

输出：
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C