△命令行模式和Python交互模式
在Windows开始菜单选择“命令提示符”，就进入到命令行模式，它的提示符类似C:\>；
在命令行模式下敲命令python，就看到类似如下的一堆文本输出，然后就进入到Python交互模式，它的提示符是>>>。
在Python交互模式下输入exit()并回车，就退出了Python交互模式，并回到命令行模式。
△Python文件名只能是英文字母、数字和下划线的组合。(但是实践证明中文也是可以的，但是不建议。)
print()会依次打印每个字符串，遇到逗号“,”会输出一个空格
△每一行都是一个语句，当语句以冒号:结尾时，缩进的语句视为代码块。
缩进有利有弊。好处是强迫你写出格式化的代码，但没有规定缩进是几个空格还是Tab。按照约定俗成的管理，应该始终坚持使用4个空格的缩进。
缩进的另一个好处是强迫你写出缩进较少的代码，你会倾向于把一段很长的代码拆分成若干函数，从而得到缩进较少的代码。
缩进的坏处就是“复制－粘贴”功能失效了，这是最坑爹的地方。当你重构代码时，粘贴过去的代码必须重新检查缩进是否正确。此外，IDE很难像格式化Java代码那样格式化Python代码。
最后，请务必注意，Python程序是大小写敏感的，如果写错了大小写，程序会报错。
△整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！无论整数做//（地板除）除法还是取余数%，结果永远是整数，所以，整数运算结果永远是精确的。而/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数），而浮点数运算则可能会有四舍五入的误差。
注意：Python的整数没有大小限制；
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
△字符串是以单引号'或双引号"括起来的任意文本，请注意，''或""本身只是一种表示方式，不是字符串的一部分。如果'本身也是一个字符，那就可以用""括起来。如果字符串内部既包含'又包含"可以用转义字符\来标识（比如：'I\'m\"OK\"!'），也可以用三个单引号或者三个双引号来标识（比如：'''I'm "OK"!'''）。
Python还允许用r''表示''内部的字符串默认不转义（比如：>>> print(r'\\\t\\') 打印结果为 \\\t\\）。
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''多行内容'''的格式表示多行内容。（比如：
a='''line1
line2
line3'''
print(a)
打印结果为
line1
line2
line3）△空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
△所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。
△字符编码
ASCII编码（1个字节） → Unicode编码（2个字节） → UTF-8编码（可变字节）
现在计算机系统通用的字符编码工作方式：
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。（内存中是Unicode，输出设备上就是UTF-8）
△Python的字符串
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
>>> ord('A')
65
>>> chr(66)
'B'由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
Python对bytes类型的数据用带b前缀的单引号或双引号表示：
x = b'ABC'
要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
>>> len('中文')
2
>>> len('中文'.encode('utf-8'))
6△格式化
%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
占位符 替换内容
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
print('%2d-%02d' % (3, 1)) 结果为 3-01
print('%.2f' % 3.1415926) 结果为 3.14
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串。
另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
△Python内置的一种数据类型是列表：list。list是一种有序且可变的集合（可以看成是一个数组），可以随时添加和删除其中的元素。list里面的元素的数据类型也可以不同。用len()函数可以获得list元素的个数；用索引来访问list中每一个位置的元素，记得从左边起索引是从0开始的，从右边起索引是从-1开始的。
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']1追加元素到末尾：>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
2把元素插入到指定的位置：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
3要删除list末尾的元素，用pop()方法：
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
4要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
5要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
注意：这几个对list的操作中，只有删除（4和5）是本身有输出的。
另一种有序且指向不变（tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变）的列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来：>>> classmates = ('Michael', 'Bob', 'Tracy')
只有1个元素的tuple定义时必须加一个逗号,，来消除歧义（>>> t = (1)这种情况下，Python规定，按数学公式中的小括号进行计算，计算结果是1）：
>>> t = (1,)
>>> t
(1,)
小结：list和tuple是Python内置的有序集合，一个可变，一个不可变。
△条件判断 if语句（注意不要少写了冒号:。）
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。
△循环（for和while条件语句后面也有冒号:的 ）
一种是for...in循环，依次把list或tuple中的每个元素迭代出来
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
执行这段代码，会依次打印names的每一个元素
Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：
>>> list(range(5))
[0, 1, 2, 3, 4]第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。在循环中，break语句可以提前退出循环；在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。
小结：
break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。
要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，常常可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。
程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序。
△Python内置了字典：dict（key-value存储方式）的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
把数据放入dict的方法，除了初始化时指定外，还可以通过key放入（多次对一个key放入value，后面的值会把前面的值冲掉）：
>>> d['Adam'] = 67
>>> d['Adam']
67
要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：
>>> 'Thomas' in d
False
二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas') #注意：返回None的时候Python的交互环境不显示结果。
>>> d.get('Thomas', -1)
-1
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。dict是用空间来换取时间的一种方法。
dict的key必须是不可变对象。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。
重复元素在set中自动被过滤：
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果。
通过remove(key)方法可以删除元素。
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}注意：
set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。
>>> classmates = ['Michael', 'Bob', 'Tracy'] #list 用[]定义
>>> classmates = ('Michael', 'Bob', 'Tracy') #tuple 用()定义
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} #dic 用{}来定义
>>> s = set([1, 2, 3]) #set 用()来定义
△函数
数据类型转换
>>> int(12.34)
12
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
△定义函数
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
我们以自定义一个求绝对值的my_abs函数为例：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
空函数
如果想定义一个什么事也不做的空函数，可以用pass语句：
def nop():
pass
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
小结
定义函数时，需要确定函数名和参数个数；
如果有必要，可以先对参数的数据类型做检查；
函数体内部可以用return随时返回函数结果；
函数执行完毕也没有return语句时，自动return None。
函数可以同时返回多个值，但其实就是一个tuple。
练习
请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程：
ax2 + bx + c = 0
的两个解。
提示：计算平方根可以调用math.sqrt()函数：
import math参考代码如下：
1 def quadratic(a, b, c):
2 if not isinstance(a,(int,float)) | isinstance(b,(int,float)) | isinstance(a,(int,float)):
3 raise TypeError('bad operand type')
4 if b**2-4*a*c>=0 :
5 x1=(-b+math.sqrt(b**2-4*a*c))/(2*a)
6 x2=(-b-math.sqrt(b**2-4*a*c))/(2*a)
7 return(x1,x2)
8 else :
9 return('wrong ')
10 # 测试:
11 print('quadratic(2, 3, 1) =', quadratic(2, 3, 1))
12 print('quadratic(1, 3, -4) =', quadratic(1, 3, -4))
13
14 if quadratic(2, 3, 1) != (-0.5, -1.0):
15 print('测试失败')
16 elif quadratic(1, 3, -4) != (1.0, -4.0):
17 print('测试失败')
18 else:
19 print('测试成功')
20
21 运行结果：
22 quadratic(2, 3, 1) = (-0.5, -1.0)
23 quadratic(1, 3, -4) = (1.0, -4.0)
24 测试成功
△函数的参数
位置参数
power(x, n)，用来计算xn，
1 def power(x, n):
2 s = 1
3 while n > 0:
4 n = n - 1
5 s = s * x
6 return s
7
8 #测试代码：
9 >>> power(5, 2)
10 25
11 >>> power(5, 3)
12 125power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
默认参数
由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：
1 def power(x, n=2):
2 s = 1
3 while n > 0:
4 n = n - 1
5 s = s * x
6 return s
7
8 #测试代码：
9 >>> power(5)
10 25
11 >>> power(5, 2)
12 25
这样，当我们调用power(5)时，相当于调用power(5, 2)；而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)。
从上面的例子可以看出，默认参数可以简化函数的调用。设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错；
二是如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个。
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。
注意： 定义默认参数要牢记一点：默认参数必须指向不变对象！
为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
可变参数
在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。
1 def calc(*numbers):
2 sum = 0
3 for n in numbers:
4 sum = sum + n * n
5 return sum
6
7 #测试
8 #调用该函数时，可以传入任意个参数，包括0个参数
9 >>> calc(1, 2)
10 5
11 >>> calc()
12 0
13
14 #Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去； *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见
15 >>> nums = [1, 2, 3]
16 >>> calc(*nums)
17 14成员运算符： not in 、in （判断某个单词里是不是有某个字母）
成员运算符用来判断一个元素是否是另一个元素的成员。 比如说我们可以判断 “hello” 中是否有 “h”， 得到的结果也是True 或者 False。
1 >>> "h" in "hello" # 这里的意思是 “h” 在“Hello” 中，判断后结果为True
2 True
3 >>> "h" not in "hello" # 这里的意思是 “h” 不在“Hello” 中，判断后结果为False
4 False身份运算符： is、is not（讲数据类型时讲解，一般用来判断变量的数据类型）
用来判断身份。
1 >>> a = 123456
2 >>> b = a
3 >>> b is a #判断 a 和 b 是不是同一个 123456
4 True
5 >>> c = 123456
6 >>> c is a #判断 c 和 a 是不是同一个 123456
7 False
8 >>> c is not a #判断 c 和 a 是不是不是同一个 123456
9 True这里我们首先将123456赋值给a，后有将a赋值给b， 这样其实是 a和b 的值都是123456, 但是后面c的值也是123456,为什么 第一次a is b 的结果为True ，c和 a 的结果为False 呢？
原因是这样的： 我们知道程序是运行在内存里的，第一次 我们将123456赋值给a的时候，其实是在内存里开辟了一块空间，将123456放在这块空间里，为了找到这里的123456， 会有一个指向这块空间的地址，这个地址叫做内存地址，是123456存储在内存中的地址。a其实指向的就是存储123456的内存空间的地址。执行了b=a，就是让b指向的地址和a一样。之后我们执行了 c = 123456 ，这里就会再开辟一块内存空间，并将指向该空间的内存地址赋值给c ，这样的话 ，a和b 指向的是同一个123456, c 指向的是另外一个123456 。
关键字参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
1 def person(name, age, **kw):
2 print('name:', name, 'age:', age, 'other:', kw)
3
4 #调用
5 >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
6 >>> person('Jack', 24, **extra)
7 name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
8
9 #**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。如果要限制关键字参数的名字，就可以用命名关键字参数，例如，仍以person()函数为例，只接收city和job作为关键字参数。这种方式定义的函数如下：
1 #和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
2 def person(name, age, *, city, job):
3 print(name, age, city, job)
4
5 #调用方式如下：
6 >>> person('Jack', 24, city='Beijing', job='Engineer')
7 Jack 24 Beijing Engineer
8
9 #如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
10 def person(name, age, *args, city, job):
11 print(name, age, args, city, job)
12
13 #命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：
14 >>> person('Jack', 24, 'Beijing', 'Engineer')
15 Traceback (most recent call last):
16 File "<stdin>", line 1, in <module>
17 TypeError: person() takes 2 positional arguments but 4 were given
18 #上面的错误说的是：由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。
19
20
21 #命名关键字参数可以有缺省值，从而简化调用：
22 def person(name, age, *, city='Beijing', job):
23 print(name, age, city, job)
24
25 #由于命名关键字参数city具有默认值，调用时，可不传入city参数：
26 >>> person('Jack', 24, job='Engineer')
27 Jack 24 Beijing Engineer使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：
def person(name, age, city, job):
# 缺少 *，city和job被视为位置参数
pass
参数组合（不是很理解！！！）
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
1 #必选参数：应该就是位置参数
2 #默认参数：
3 def power(x, n=2): pass #把位置参数的某一个设置为默认固定的
4 #可变参数：
5 def calc(*numbers): pass #可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple（或list）。
6 #命名关键字参数:
7 def person(name, age, *, city, job):pass #*后面的参数被视为命名关键字参数（即只接收city和job作为关键字参数）。
8 #关键字参数:
9 def person(name, age, **kw):pass #关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
小结
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。
练习
以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：
1 # -*- coding: utf-8 -*-
2 def product(*numbers):
3 if len(numbers)==0:
4 raise TypeError('bad operand type')
5 mul=1
6 for n in numbers:
7 mul=mul*n
8 return mul
9 # 测试
10 print('product(5) =', product(5))
11 print('product(5, 6) =', product(5, 6))
12 print('product(5, 6, 7) =', product(5, 6, 7))
13 print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))
14 if product(5) != 5:
15 print('测试失败!')
16 elif product(5, 6) != 30:
17 print('测试失败!')
18 elif product(5, 6, 7) != 210:
19 print('测试失败!')
20 elif product(5, 6, 7, 9) != 1890:
21 print('测试失败!')
22 else:
23 try:#下面两行代码就意味着这个自定义的函数的参数个数不能为0。
24 product()
25 print('测试失败!')
26 except TypeError:
27 print('测试成功!')△递归函数
如果一个函数在内部调用自身本身，这个函数就是递归函数。
在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
练习
汉诺塔的移动可以用递归函数非常简单地实现。
请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法，例如：
1 # -*- coding: utf-8 -*-
2 def move(n, a, b, c):
3 if n == 1:
4 print(a, '-->', c) #a上只有1个盘子
5 else:#a上有n个盘子
6 move(n-1,a,c,b) #把a上的n-1块移动到b
7 move(1,a,b,c) #把a上的最后一块移动到c
8 move(n-1,b,a,c) #把b上的n-1块移动到c
9
10
11 # 期待输出:
12 # A --> C
13 # A --> B
14 # C --> B
15 # A --> C
16 # B --> A
17 # B --> C
18 # A --> C
19 move(3, 'A', 'B', 'C')高级特性
在Python中，代码不是越多越好，而是越少越好。代码不是越复杂越好，而是越简单越好。请始终牢记，代码越少，开发效率越高。
△切片
取一个list或tuple或字符串的指定索引范围的部分元素，Python提供了切片（Slice）操作符。
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3，如果第一个索引是0，还可以省略；记住倒数第一个元素的索引是-1。
△迭代
如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。
在Python中，迭代是通过for ... in来完成的。只要作用于一个可迭代对象，for循环就可以正常运行。
如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
1 >>> from collections import Iterable
2 >>> isinstance('abc', Iterable) # str是否可迭代
3 True
4 >>> isinstance([1,2,3], Iterable) # list是否可迭代
5 True
6 >>> isinstance(123, Iterable) # 整数是否可迭代
7 FalsePython内置的enumerate函数可以把一个list变成索引-元素对：
1 >>> for i, value in enumerate(['A', 'B', 'C']):
2 ... print(i, value)
3 ...
4 0 A
5 1 B
6 2 C
△列表生成式
列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，for循环后面还可以加上if判断：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
△生成器
在Python中，这种列表元素可以按照某种算法推算出来，一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。
第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
1 >>> L = [x * x for x in range(10)] #列表生成式
2 >>> L
3 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4 >>> g = (x * x for x in range(10)) #生成器
5 >>> g
6 <generator object <genexpr> at 0x1022ef630>打印出generator的每一个元素，正确的方法是使用for循环，因为generator也是可迭代对象：
1 >>> g = (x * x for x in range(10))
2 >>> for n in g:
3 ... print(n)
4 ...
5 0
6 1
7 4
8 9
9 16
10 25
11 36
12 49
13 64
14 81
定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。
generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
小结
generator是非常强大的工具，在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。
要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。
请注意区分普通函数和generator函数，普通函数调用直接返回结果，generator函数的“调用”实际返回一个generator对象。
△迭代器
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象。
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
1 >>> isinstance(iter([]), Iterator)
2 True
3 >>> isinstance(iter('abc'), Iterator)
4 True小结
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的。
■函数式编程
△高阶函数：
变量可以指向函数：函数本身也可以赋值给变量，即：变量可以指向函数。例如
>>> f = abs
>>> f
<built-in function abs>>>> f(-10)
10函数名也是变量：函数名其实就是指向函数的变量！
对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！如果把abs指向其他对象，会有什么情况发生？
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！
当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。
传入函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。编写高阶函数，就是让函数的参数能够接收别的函数。
小结
把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
△△ map/reduce
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并 把结果作为新的Iterator返回。
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
△△ filter
filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后 根据返回值是True还是False决定保留还是丢弃该元素。
可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。
注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要 用list()函数获得所有结果并返回list。
小结
filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取 filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。
△△ sorted
Python内置的sorted()函数就可以对list进行排序：
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36] 此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小 排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
△返回函数
△ 匿名函数
△装饰器
△偏函数
