第六章 抽象

抽象可节省人力，使程序能够被人理解的关键所在。

一、自定义函数

1. 定义函数用def函数：

def hello(name):
    return 'hello,' +name+'!'
print (hello('world'))->hello, world!

这里的hello就是新定义的函数，return语句中就是该函数的返回值。
2. callable( ):判断函数是否被调用，被调用返回True,否则返回False.
3. return语句：用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None.
注意：函数都必须有返回值的，如果没有return语句，则默认返回一个空值None.

def sum(arg1, arg2):
    total=arg1+arg2
    print('函数内：', total)
    return total
#调用sum函数
total=sum(10,20)
print('函数外：', total)
返回：
函数内：30
函数外：30
#如果没有return语句则返回：
函数内：30
函数外：None

4. help(函数）：可以获取函数的相关信息；
5. 给函数编写文档
   #加注释信息
   __doc__是函数的一个属性，属性名中的双下划线表示这是一个特殊的属性。

二、函数魔法

参数从调用的角度来说，分为形式参数和实际参数（简称形参和实参）；形参只是代表一个位置，一个变量名，而实参是一个具体的内容，是赋值到变量名中的值！

1. 关键字参数：即传入实参时指定形参的变量名，尽管使用这种技巧要多打点字，但这种技巧非常有用。

def saySomething(name, words):
    print(name+'->'+words)
saySomething(words="让编程改变世界！”，name="小甲鱼")
小甲鱼->让编程改变世界！
saySomething()->小甲鱼->让编程改变世界！
上面的name、words为形参，”让编程改变世界“是实参，而words="让编程改变世界"则是关键字参数.  

2. 默认参数：即不输入任何参数的情况下会有默认值打印出来，使用默认参数的话，就可以不带参数去调用参数。
3. 收集参数：（也陈可变参数），即在参数前添加一个星号（），如果要将多个参数传入到函数中，也是需要用加列表名才能正常调用；星号不能收集关键字参数，如果要收集需要使用两个星号（**），其可以将参数打包成字典的形式（关键字参数）。

def test(*params):
    print ("有%d个参数" %len(params))
    print("第二个参数是：", params[1])
a=[1,2,3,4,5,6,7,8]
test(a) ->有一个参数  error...
test(*a)->有8个参数  第二个参数是：2

4. 作用域：（局部变量和全局变量)

• L(Local)局部作用域
• E(Enclosing)闭包函数外的函数中
• G(Global)全局作用域
• B(Built-in)内建作用域
  以L->E->G->B的规则查找，即：在局部找不到，便会去局部外的局部查找（如闭包），再找不到就会去全局找，再者就去内建中找
  Python中只有模块(module)、类(class)、函数（def、lambda)才会引入新的作用域，其它的代码块（如if/elif/else、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

def discounts(price, rate):
    final_price= price*rate
    return final_price
old_price=float(input('请输入原价：'))
rate=float(input('请输入折扣率：'))
new_price=discount(old_price, rate)
print('打折后价格是：’，new_price)
请输入原价：80
请输入折扣率：0.75
打折后的价格是：60.0

这个函数中price/rate/final_price是整个函数的局部变量，而old_price/rate/new_price则是全局变量。局部变量的作用范围只在函数内部，除了这个函数discounts局部变量变不起作用；而全局变量在整个代码段中都是可以访问的，但是不要试图在函数内部修改全局变量的值，这样会导致python自动在函数内部新建一个名字一样的局部变量，很容易犯错。一般千万不要再函数内部修改全局变量，会使得代码非常麻烦。如果非要修改，则要用到global函数。

count=5
def myFun():
    global count
    count=10
    print(count)
myFun()->10

5. 内嵌函数：python的函数定义是可以嵌套的，也就是允许在函数内部创建另一个函数，这种函数叫做内嵌函数或者内部函数。
6. 闭包：如果在一个内部函数里，对在外部作用域（但不在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。

def funX(x):
    def funY(y):
        return x*y
    return funY
i=funX(8)
i(5)->40.

如果在一个内部函数里（FunY就是这个内部函数）对外部作用域（但不是在全局作用域）的变量进行引用（x就是被引用的变量，x在外部作用域FunX函数里面，但不在全局作用域里）则这个内部函数FunY就是一个闭包。
nonlocal也可以在内部函数里修改外部函数里的局部变量值，使用方法与global一致 。

def funX():
    x=5
    def funY():
        nonlocal x
        x*=x
        return x 
    rerurn funY
funX()()->25.   

三、递归

递归即调用自身。

def factorial(n):
    if n==1:
        return 1
    else:
    return n*factorial(n-1)

四、lambda表达式

Python允许使用lambda关键字来创建匿名函数。
语法：lambda x: 2*x+1
其语法结构非常精简，冒号左边放原函数的参数，可以有多个参数，用逗号隔开，冒号右边是返回值。如果lambda语句是返回一个对象，则需要对它进行赋值操作

g=lambda x:2*x+1
g(5)->11
g=lambda x,y:x+y
g(3,4)->7
#lambda也可以使用关键字参数
g=lambda x, y: x**2+y**2
g(2,3)->13
g(y=4, x=3)->25

lambda表达式的作用：
1）可以省下定义函数过程，也不需要命名函数，使得代码更为精简；
2）简化代码可读性

2. 两个内置函数

• filter()：过滤器
  filter有两个参数，第一个参数可以是一个函数也可以是None,如果是一个函数的话，则将第二个可迭代数据里的每一个元素作为函数的参数进行计算，把返回True的值筛选出来，如果是None,则直接将第二个参数中True的值筛选出来。

  temp=filter(None, [1,0,False,  True])
  list(temp)->[1, True]
  
  def odd(x):
      return x%2
  temp=filter(odd, range(10))
  list(temp)->[1,3,5,7,9]
  
  #用lambda表达式表示为：
  list(filter(lambda x: x%2, range(10))) ->[1,3,5,7,9]
  

• map( )：映射
  仍然是两个参数，一个函数和一个可迭代序列，将序列的每一个元素作为函数的参数进行运算加工，直到可迭代序列每个元素都加工完毕，返回所有加工后的元素构成的新序列。
  list(map(lambdax :x*2, range(10)))->[0,2,4,6,8,10,12,14,16,18]