定义函数可以用默认参数n=10，但是默认参数要在必须参数后面

Python中，迭代永远是取出元素本身，而非元素的索引。

如果想在for循环中拿到索引，可以使用enumerate()函数。

使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。实际上enumerate()函数是：

索引迭代并不是真的按索引访问，而是由

enumerate() 函数自动把每个元素变成(index,element)这样的tuple，再迭代，旧同事获得了索引和元素本身。

zip()函数可以把两个list变成一个list。

在Python中，迭代是通过for ... in来完成的。

很多语言中，迭代list是通过下标完成的。

Python的for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代的对象上。

迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

集合：

1. 有序集合：list,tuple,str和unicode。

2. 无序集合：set。

3. 无序集合且具有key-value对：dict。

迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。

字符串也可以用切片操作，只是操作结果仍是字符串。

在很多编程语言中，针对字符串提供了各种截取函数，其实目的就是对字符串切片。

注意：Python中没有针对字符串的截取函数，只需要切片一个操作就可以完成。

upper()函数:把字符变成大写字母。

对于list，Python支持[-1]取倒数第一个元素，同样支持倒数切片。

注意：倒数第一个元素的索引是-1。

倒数切片包含起始索引，不包含结束索引。

• list      变量名[] 有序列表

变量名.pop()

pop()删除元素

insert(索引号，list列表字符串) 把新元素对应索引号排列

append(list字符串)把新元素加入list列表

• tuple   变量名()有序

列表【不可分配，不可修改，不可赋值给其他元素】（中文称：元组）

但是加入list[] 可以修改和分配

取前N个元素，也就是索引为0至(n-1)的元素，可以使用循环实现，但对于指定索引范围的操作，使用循环是十分繁琐的。Python中切片(slice)操作符，大大简化这种操作。

L[0:3]表示：从索引0开始取，直到索引3为止，但是不包括索引3。

注意：如果第一个索引是0，还可以省略L[:3]；还可以从索引1开始取。只用L[:]表示从头到尾，相当于重新赋值出了一个新list。

切片还可以指定第三个参数：第三个参数表示每N个取一次，相当于步长。

list换成tuple，切片操作完成相同，只是切片的结果变成了tuple。

可变参数的名字前面有个 * 号，我们可以传入0个，1个或多个参数给可变参数。

python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此直接把可变args堪称一个tuple就好了。

定义可变参数的目的是为了简化调用。

但是一般可变参数都需要将特殊情况特殊处理。

a=python,定义a是字符串，因此，a为T，短路计算，在"or"中，左面为T则整体为T

b=""，空的字符串，因此b为F，短路计算，在"or"中，左面为F则整体看右边

定义函数的时候，还可以有默认参数。

如int()函数，其实就有两个参数，我们既可以传一个参数，也可以传两个参数。第二个参数的作用是转换进制，如果不传，默认是十进制，如果传了，就用传入的参数。

函数的默认参数的作用是简化调用，需注意可以传入额外的参数来覆盖默认参数值。

注意：函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。

7-5 Python之递归函数???????

兄弟，讲解步骤还是比较麻烦的，每n层，就需要有2^n-1次步骤，4层就有15步

所以简单讲解一下3和2层，然后自己验证4层的移动，验证move(4,a,b,c)的第一步骤move（3,a,c,b)下面的7个步骤就可以。

2层：

move （2,a,b,c)

   #都会先判断是否为1

   #然后不是，就会进行接下来三步： 1：move(n-1, a, c, b)，2： print a, '-->', c，3：move(n-1, b, a, c)

   1:move(1,a,c,b)#分析此处的内部运作

       #因为是1，所以不走三步，直接执行if下print a-c，但是这里可能就导致不好理解了

       #其实这里是指print 1位到3位，可见在 move(1,a,c,b)中，1位是a，3位是b

       #打印结果是A--》B

   2:print a-c #其实也是执行print本层move的 1位到3位  

        #在本层的move （2,a,b,c)中，1位是a，3位是c

       #打印结果是A--》C

  3:move(1,b,a,c)

       #因为是1，所以执行print a-c---》print 1位到3位，1位是b，3位是c

       #打印结果是B--》C

       #后面不在重复打印的是本层move的1位到3位

       AB  AC   BC

3层：

 move(3,a,b,c)

    #判断不是1

    #进入接下来三步

    1：move(2,a,c,b)

        #这里的abc位置刚才没讲，因为刚才和程序的变化一样

        #这里因为有多层，讲解一下：

        #1步骤：move(n-1, a, c, b)程序的意思是，上层的move里的第二位和第三位互换

        #3步骤：move(n-1, b, a, c)程序的意思是，上层move里的第一位和第二位互换

        #这里2不是1，所以要进行三步

        ①：move(1,a,b,c)#上层move的2，3位互换

                    #打印结果是A--》C

        ②：打印结果是A--》B

        ③：move(1,c,a,b)#上层move的1，2位互换

                    #打印结果是C--》B

     2：打印结果是A--》C#提示一下，本层是：move(3,a,b,c)

     3：move(2,b,a,c)#上层move的1，2位互换

         ①：move(1,b,c,a)#上层move的2，3位互换

                     #打印结果是B--》A

1. 当n=1时，函数执行到return就截止，结果为a-->c,同时也得出move(1,x,y,z）的结果为x-->z(为了防止混淆，用另外三个字母代替变量)。

2. 当n=2时,if条件不满足，则跳过if函数块，执行后面的语句，即move(1,a,c,b),根据move(1,x,y,z)的结果，这个地方会得到a-->b。紧接着执行print语句，得到a-->c。后面又执行move(1,b,a,c),根据move(1,x,y,z)的结果，这个地方会得到b-->c。

   因此，当n=2时，函数的执行结果为a-->b，a-->c，b-->c。通过这个结果我们也可以看出，move((2,x,y,z)的结果为x-->y，x-->z，y-->z.

   依次类推，当n=3时，我们在执行函数时就会遇到move(2,a,c,b),move(2,b,a,c)这个结果可以直接套用n=2时move(2,x,y,z)的结果为x-->y，x-->z，y-->z的结果。

3. 综上，该函数是一个迭代函数，会层层套用前面的结果。当然，该函数也很好的体现了该游戏的规则，建议百度了解该游戏的具体内容

         ②：打印结果是B--》C

         ③：move(1,a,b,c)#上层move的1，2位互换

                     #打印结果是A--》C  

AC   AB   CB   AC   BA   BC   AC 

print u'''   '''

和

print r'''  '''

有啥不同

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：

单元素 tuple 要多加一个逗号“,",避免歧义

set()里面必须是list[]

tuple一旦创建完毕，就不能修改了,list可以；

t=（'...','...','...'）

tuple没有 append()方法，也没有insert()和pop()方法

也不能赋值成别的元素，但可以正常使用 t[0]，t[-1]等索引方式访问元素