Python学习（六） —— 函数

一、函数的定义和调用

　　为什么要用函数：例如，计算一个数据的长度，可以用一段代码实现，每次需要计算数据的长度都可以用这段代码，如果是一段代码，可读性差，重复代码多；

　　　　　　　　　　但是如果把这段代码封装成一个函数，用的时候直接调用，一是简洁明了，二是节省代码量

　　定义函数：def 函数名():函数体　　调用函数：函数名()

　　写函数的时候，要尽量以功能为导向，结果最好不要直接在函数打印

def func(para):
    count = 0
    for i in para:
        count += 1
    return count
a = func('1232ffsdfsdfwe')  #调用函数
print(a)  #14

二、函数的返回值

　　函数的返回值用return

　　1.没有返回值：不写return == return None，默认返回None

　　　　　　　　   只写一个return == return None

　　　　　　　　   　　return的作用：1.返回一个值  2.终止一个函数的继续

　　2.返回一个值：可以返回任意的数据类型，返回什么，就接收什么

　　3.返回多个值：用一个变量接收返回值，接收到的是一个元组

　　　　　　　　   返回值用多个变量接收，那么返回值的个数应该和接收变量的个数完全一致

三、函数的参数

　　传递参数：简称传参，是在调用函数时输入的参数传递到函数中（可以传递多个参数）（对于一个参数只能赋值一次）

　　实际参数：简称实参，调用函数时输入的函数称为实参；

　　形式参数：简称形参，定义函数的时候输入的参数称为形参

def func(para):  #p形参：ara
    count = 0
    for i in para:
        count += 1
    return count
a = func('asd')  #实参：asd
print(a)

　　位置参数：1.按照位置传参

　　　　　　　2.按照关键字传参

　　　　　　　3.按照位置、关键字混合着传参，混合传参必须把位置参数写在前面，否则会报错

def f2(arg1,arg2):   #站在接受、形参的角度上：位置参数
    print(arg1,arg2)
f2(123,'abc')  #123 abc （按位置传参）
f2(arg2=123,arg1='abc')  #abc 123 （按关键字传参）
f2(123,arg2='abc')  #123 abc(混合传参)

　　默认参数：将变化比较小的值变成默认参数

　　特点：可以不传的参数；在不传参数的情况下可以使用默认的值；如果传了，就会使用传的值

　　　　　默认参数尽量避免使用可变数据类型

def func(name,sex='man'):  #man是默认参数
    print(name,sex)
func('abc')  

li = []
def func(para):
    li.append(para)
    print(li)
func('abc')  #['abc']
func('abc')  #['abc', 'abc']

 　　动态函数：顺序：位置参数，*args，默认参数，**kwargs

　　　　　　　*args：可以接收多个按位置传参，以元组的方式接收

　　　　　　　**kwargs：可以接收多个关键字传参，以字典的方式接收

def func1(*args):
    print(args)
func1(1,2,3,4)  #(1,2,3,4)

def func2(**kwargs):
    print(kwargs)
func2(a=1,b=2)  #{'a':1,'b':2}

　　动态参数的魔性用法：在调用函数的时候，对于实参：*的作用是将一个实参中的每一个元素作为一个参数传到形参数

　　　　　　　　　　　　　　　　　　　　　　　　　：**的作用是将实参中的字典变成a = b的形式传到形参

def func1(*args):
    print(args)
a = '12345'
b = [1,2,3,4,5]
func1(*a)  #('1','2','3','4','5')
func1(*b)  #(1,2,3,4,5)

def func2(**kwargs):
    print(kwargs)
a = {'a':1,'b':2} 
func2(**a)  #{'a':1,'b':2}

 四、函数的命名空间

　　全局命名空间：写在函数外面的变量名

　　局部命名空间：写在函数内部的变量名

　　内置命名空间：python解释器启动之后就能使用的名字

　　加载顺序：先加载所有内置命名空间中的名字，然后按顺序加载全局命名空间中的名字

　　局部命名空间的名字：在调用函数的时后产生，并且随着调用的结束而消失

　　内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

五、函数的作用域

　　作用域：一个名字可以使用的区域

　　全局作用域：内置命名空间和全局命名空间的名字都属于全局作用域

　　局部作用域：局部命名空间中的名字属于局部作用域

　　局部作用域可以使用全局作用域的变量，而全局作用域不能使用局部作用域的变量

　　局部作用域还可以嵌套更小的局部作用域

　　作用域链：小范围作用域可以使用大范围的作用域，但作用域链是单向的，不能反向应用

　　globals和locals的用法:

　　　　小范围可以使用大范围的，但不能修改

　　　　如果想要修改全局的，使用global关键字  —— 尽量避免

　　　　如果想要最近拥有该变量的外层函数，使用nonlocal  —— 不影响全局

六、函数的名字

　　第一类对象：函数名可以赋值

　　　　　　　   可以作为一个数据结构的元素

　　　　　　　　可以作为一个函数的参数

　　　　　　　　可以作为一个函数的返回值

七、闭包

　　内部函数引用了外部函数的变量

　　闭包函数：内部函数对外部作用域而非全局作用域的名字的引用。  #函数内部定义的函数称为内部函数

def func()：
    def inner():
        print(123)
    return inner

f = func() #f = inner
f() #==>innner()

　　判断闭包函数的方法：__closure__，输出的__closure__有cell元素是闭包函数，输出的__closure__为None，不是闭包函数

def func():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)
    return inner

func()  #(<cell at 0x00000177528655E8: int object at 0x00000000574760E0>,)

a =1
def func2():
    def inner():
        print(a)
    print(inner.__closure__)
    return inner

func2()  #None

　　闭包函数获取网路应用

from urllib.request import urlopen  #导入模块

def get_url():
    def inner(url):
       return urlopen(url).read()  #返回网站内容
    return inner

g = get_url()
ret = g('http://www.baidu.com')
print(ret)

# 因为如果用 urllib.request.urlopen 方式打开一个URL,服务器端只会收到一个单纯的对于该页面访问的请求,但是服务器并不知道发送这个请求使用的浏览器,操作系统,硬件平台等信息,而缺失这些信息的请求往往都是非正常的访问,例如爬虫.
# 有些网站为了防止这种非正常的访问,会验证请求信息中的UserAgent(它的信息包括硬件平台、系统软件、应用软件和用户个人偏好),如果UserAgent存在异常或者是不存在,那么这次请求将会被拒绝(如上错误信息所示)
# 所以可以尝试在请求中加入UserAgent的信息
# 解决方法：在请求中添加UserAgent的信息,代码如下
#如果不加上下面的这行出现会出现urllib2.HTTPError: HTTP Error 403: Forbidden错误
    #主要是由于该网站禁止爬虫导致的，可以在请求加上头信息，伪装成浏览器访问User-Agent,具体的信息可以通过火狐的FireBug插件查询
from urllib import request
def get_url(chaper_url):
    headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:23.0) Gecko/20100101 Firefox/23.0'}
    req = request.Request(url=chaper_url, headers=headers)
    return request.urlopen(req).read()