日知录（二）：python函数定义与高级特性

一、函数

1、参数

（1）位置参数

def power (x):      #此处的x看做是位置参数
    return x*x        

（2）默认参数

指向不可变对象。
eg

#计算任意数的任意次方
def power (x,n):
    s=1
        while n>0:
            n=n-1
            s=s*x
            return s

#上述的函数定义语句修改一下

def power(x,n=2)

# 此处的n=2就是一个默认参数

降低调用函数的难度
只有与默认参数不符的项才需提供额外信息

（3）可变参数

即传入参数的个数可变

#计算a^+b^+c^·······
def calc(*args):
    sum-0
    for n in args:
        sum=sum=n*n
    return sum

也可以一个已有的numbers 的list/tuple，用*numbers表示将这个list的所有元素作为可变参数传入

（4）关键字参数

接收后在函数内部组装成一个dict

（5）命名关键字参数

要限制关键字参数的名字，就可以用命名关键字参数。

2.函数的定义和调用

1.调用内部参数时，参数个数不对

2.参数检查

（1）区分一下自己定义的函数 my_abs()和python的内部参数abs()的差别
（2）在自己定义的函数中增加一个内置函数进行参数检查

接上图续

3.交作业—求一元二次方程的两个解

（1）导入了math包，并使用了math内置函数
（2）定义函数时不要忘了return输出（函数执行完毕也没有return语句时，自动return None）

4.交作业–递归函数之汉诺塔问题

二、高级特性

1.切片slice与迭代lteration

（1）当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行
（2）判断一个对象是可迭代对象？方法是通过collections模块的Iterable类型判断。
（3）默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

eg1排序练习

2.列表生成式List Comprehensions

1.函数isinstance()可以判断一个变量的类型，既可以用在Python内置的数据类型如str、list、dict，也可以用在我们自定义的类，它们本质上都是数据类型
isinstance(object, classinfo)
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者有它们组成的元组。
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

2.
3.在列表生成式内使用 if-else语句
在一个列表生成式中，for前面的if … else是表达式，而for后面的if是过滤条件，不能带else

#if 在前
x if x%2 ==0 else -x for x in range (1,11)
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
#if在后表示过滤
[x for x in range(1, 11) if x % 2 == 0]
[2, 4, 6, 8, 10]

3.生成器generator与迭代器

（1）生成器：

列表元素可按某种算法推算。

1.创建生成器的第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator
**2.创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。通过for循环来迭代g
3.generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误


4.创建generator的第二种方法：在函数定义中包含yield关键字，将print（x）看成yield（x）。变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
5.用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中。

eg2迭代练习：杨辉三角

关于杨辉三角
（1）目前的理解，把yield L看成 print L,输出列表L中的每个元素
（2）主要难在如果表示下一行的数据，并且下一行的数据还是不断增加不断在求和的。也是受他人代码启发。

L = [1]+  [L[i]+L[i+1] for i in range(len(L)-1)]+   [1]  #除左右两边的[1]外，都是通过上个list里的元素两两相加而来，
                                                               #表达式为L[i]+L[i+1]两两相加的形式，L[0]+L[1]  L[1]+L[2] ... L[len(L)-1-1]+L[Len(L)-1]
                                                                 #range(len(L)-1)=[0,1,...,len(L)-1-1]

当L=[1,1]时，len(L)=2，range(2-1)=range(1)=(0)，[L[0]+L[1]]=[1+1]=[2]
当L=[1,2,1]时，range(len(L)-1)=range(2)=(0,1)，[L[0]+L[1]]=[1+2]=[3] [L[1]+L[2]]=[2+1]=[3]

L=[sum(i) for i in zip([0]+L,L+[0])]

sum()作为python内置函数，直接调用。
zip()也是内置函数，用作遍历。

（2）迭代器

太多概念性的东西不做赘述，暂时也还没理解，找到了一个评论区的例子。

eg3迭代例子

a=sorted(a,key=add)    #排序列表
#改成
a = sorted(a)    #会出现下图所示，自动排序

此处再贴上关于上述修改后排序排好的原因。
1.sort() 是list的内置方法，只有list有 ：sort(cmp=None, key=None, reverse=False)
2.sorted()方法是Python内置的，可以对所有可迭代的序列排序生成新的序列，只要可迭代就行，返回的都是一个list：sorted(iterable, cmp=None, key=None, reverse=False)
3.参数：
cmp：比较函数，比较什么参数由key决定。
key：用列表元素的某个属性或函数作为关键字。
reverse：排序规则，可以选择True或者False。
iterable：待排序的可迭代类型的容器
4.区别：
a.sort()修改待排序的列表内容,返回排序后的a;
sorted(a)，返回一个新的列表，而对a不产生影响