python 学习笔记6（函数）

函数

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

　　1.减少代码重复

　　2.保持代码的一致性

　　3.方便修改，可扩展性

函数的创建

#简单的函数
 def f():
     print("It's ok")
 f()                                   #It's ok

def ：定义一个函数名

f：函数名（自己定义）

()：方便传输参数，可写可不写

f():函数调用

 函数名的命名规则：

　　1.函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；

　　2.函数名是区分大小写的。

　　3.函数名不能是保留字。

形参和实参

　　形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）

　　实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参

　　区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

# 形参与实参

 def f(a):                          #a为形参，不占用内存
     print("It's %s"%a)
 f("ok")                             #It's ok      "ok"为实参             

 def f(a,b):
     print(a+b)
 f(2,3)                              #

函数的参数

　　必备参数

　　关键字参数

　　默认参数

　　不定长参数

必需的参数：

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

def f(name,age):
    print('I am %s,I am %d'%(name,age))
f('liu',18)
f('lst',16)

关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。它的数据在实参里加。

def f(name,age):
    print('I am %s,I am %d'%(name,age))
# f(16,'alvin') #报错
f(age=23,name='liu')

默认参数（缺省参数）：

调用函数时，默认参数的值如果没有传入，则被认为是默认值。默认参数必须放在必须参数或者关键字参数后边。它是在形参里边加数据。下例会打印默认的age，如果age没有被传入：

def print_info(name,age,sex='male'):

    print('Name:%s'%name)
    print('age:%s'%age)
    print('Sex:%s'%sex)
    return

print_info('liu',18)
print_info('aaa',23,'female')

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。将所有参数作为元组。

# def add(x,y):
#     return x+y

def add(*args):
    sum=0
    for i in args:
        sum+=i

    return sum

print(add(1,2,3,4))
print(add(2,3,4,6,5))

加了星号（*）的变量名会存放所有未命名的变量参数。而加(**)的变量名会存放命名的变量参数，将所有参数作为字典。

def print_info(**kwargs):

    print(kwargs)
    for i in kwargs:
        print('%s:%s'%(i,kwargs[i]))#根据参数可以打印任意相关信息了

    return

print_info(name='liu',age=18,sex='male',hobby='girl',nationality='Chinese',ability='Python')

def print_info(name,*args,**kwargs):#def print_info(name,**kwargs,*args):报错

    print('Name:%s'%name)

    print('args:',args)
    print('kwargs:',kwargs)

    return

print_info('alex',18,hobby='girl',nationality='Chinese',ability='Python')
# print_info(hobby='girl','alex',18,nationality='Chinese',ability='Python')  #报错
#print_info('alex',hobby='girl',18,nationality='Chinese',ability='Python')   #报错

参数优先级  def func(必需的参数,默认参数，不定长参数（*args,**kwargs）)

传参数的另一种方法

def f(*args):
    print(args)

f(*[1,2,5])

def f(**kargs):
    print(kargs)

f(**{'name':'liu'})

函数的返回值

要想获取函数的执行结果，就可以用return语句把结果返回

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，也可以理解为 return 语句代表着函数的结束；
2. 如果未在函数中指定return,那这个函数的返回值为None；
3. return多个对象，解释器会把这多个对象组装成一个元组作为一个一个整体结果输出。

作用域

作用域介绍

python中的作用域分4种情况：

　　L：local，局部作用域，即函数中定义的变量；

　　E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

　　G：globa，全局变量，就是模块级别定义的变量；

　　B：built-in，系统固定模块里面的变量，比如int, bytearray等。

　　搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

x = int(2.9)  # int built-in  内置作用域

g_count = 0  # global 全局作用域

def outer():
    o_count = 1  # enclosing    嵌套作用域

    def inner():
        i_count = 2  # local    局部作用域
        print(o_count)

    # print(i_count) 找不到
    inner()

outer()

# print(o_count) #找不到

作用域产生

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的，如下代码：

if 2>1:
    x = 1
print(x)  #

这个是没有问题的，if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。

def test():
    x = 1
#print(x) # NameError: name 'x2' is not defined
test()

def、class、lambda是可以引入新作用域的。

变量的修改

局部作用域变量不可修改全局作用域变量的值

(一个不在局部作用域里的变量默认是只读的，如果试图为其绑定一个新的值，python认为是在当前的局部作用域里创建一个新的变量，也就是说在当前局部作用域中，如果直接使用外部作用域的变量，那么这个变量是只读的，不能修改)

count = 10
def outer():
    print(count)  #local variable 'count' referenced before  assignment
    count = 100
    print(count)
outer()　

这里第一个print中，使用到了外部作用域的count，这样后面count就指外部作用域中的count了，再修改就会报错。 如果没使用过这个变量，而直接赋值，会认为是新定义的变量，此时会覆盖外部作用域中变量

count = 10
def outer():
    #print(count)  #10
    count = 100
    print(count)
outer() #

内部作用域中直接声明了count=100，后面使用count都是内部作用域的了。 count+=1报错的原因是一样的，先使用了外部count＋1，在修改count自然报错。

global，nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量需要nonlocal关键字先申明一下。

count = 10
def outer():
    global count
    print(count)  #1   local variable 'count' referenced before assignment           2   10
    count = 100
    print(count)       #
outer()

def outer():
    count = 10
    def inner():
        nonlocal count
        count = 20
        print(count)
    inner()
    print(count)
outer()

小结

（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

（2）只有模块、类、及函数才能引入新作用域；

（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个关键字，就能完美的实现闭包了。

高阶函数：

         高阶函数是至少满足下列一个条件的函数:

　　　　接受一个或多个函数作为输入

　　　　输出一个函数

# 高阶函数
def f(n):
    return n*n
def foo(a,b,func):
    return func(a)+func(b)
print(foo(2,3,f))                  #

关于函数名：

　　函数名可以进行赋值

　　函数名可以作为函数参数，还可以作为函数返回值

递归函数

　　定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

　　

#函数阶乘
 def f(b):
     a = 1
     for i in range(1,b+1):
         a *= i
     return a
 print(f(5))

 def f(n):
     b = 1
     a = 1
     while a<=n:
         b*=a
         a+=1
     return b
 print(f(3))

------------------------------------------------------------
#递归函数
def f(n):
    if n == 1:
        return 1
    return n*f(n-1)
print(f(6))

递归函数的优点:    是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

递归特性:

　　1. 必须有一个明确的结束条件

　　2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

　　3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返     　　    回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)

内置函数

数学运算类

abs(x)	求绝对值 1、参数可以是整型，也可以是复数 2、若参数是复数，则返回复数的模
complex([real[, imag]])	创建一个复数
divmod(a, b)	分别取商和余数 注意：整型、浮点型都可以
float([x])	将一个字符串或数转换为浮点数。如果无参数将返回0.0
int([x[, base]])	将一个字符转换为int类型，base表示进制
long([x[, base]])	将一个字符转换为long类型
pow(x, y[, z])	返回x的y次幂
range([start], stop[, step])	产生一个序列，默认从0开始
round(x[, n])	四舍五入
sum(iterable[, start])	对集合求和
oct(x)	将一个数字转化为8进制
hex(x)	将整数x转换为16进制字符串
chr(i)	返回整数i对应的ASCII字符
bin(x)	将整数x转换为二进制字符串
bool([x])	将x转换为Boolean类型

集合类操作

basestring()	str和unicode的超类 不能直接调用，可以用作isinstance判断
format(value [, format_spec])	格式化输出字符串 格式化的参数顺序从0开始，如“I am {0},I like {1}”
unichr(i)	返回给定int类型的unicode
enumerate(sequence [, start = 0])	返回一个可枚举的对象,该对象的next()方法将返回一个tuple
iter(o[, sentinel])	生成一个对象的迭代器，第二个参数表示分隔符
max(iterable[, args...][key])	返回集合中的最大值
min(iterable[, args...][key])	返回集合中的最小值
dict([arg])	创建数据字典
list([iterable])	将一个集合类转换为另外一个集合类
set()	set对象实例化
frozenset([iterable])	产生一个不可变的set
str([object])	转换为string类型
sorted(iterable[, cmp[, key[, reverse]]])	队集合排序
tuple([iterable])	生成一个tuple类型
xrange([start], stop[, step])	xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

逻辑判断

all(iterable)	1、集合中的元素都为真的时候为真 2、特别的，若为空串返回为True
any(iterable)	1、集合中的元素有一个为真的时候为真 2、特别的，若为空串返回为False
cmp(x, y)	如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

反射

callable(object)	检查对象object是否可调用 1、类是可以被调用的 2、实例是不可以被调用的，除非类中声明了__call__方法
classmethod()	1、注解，用来说明这个方式是个类方法 2、类方法即可被类调用，也可以被实例调用 3、类方法类似于Java中的static方法 4、类方法中不需要有self参数
compile(source, filename, mode[, flags[, dont_inherit]])	将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。 1、参数source：字符串或者AST（Abstract Syntax Trees）对象。 2、参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 3、参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。 4、参数flag和dont_inherit：这两个参数暂不介绍
dir([object])	1、不带参数时，返回当前范围内的变量、方法和定义的类型列表； 2、带参数时，返回参数的属性、方法列表。 3、如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。 4、如果参数不包含__dir__()，该方法将最大限度地收集参数信息
delattr(object, name)	删除object对象名为name的属性
eval(expression [, globals [, locals]])	计算表达式expression的值
execfile(filename [, globals [, locals]])	用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。
filter(function, iterable)	构造一个序列，等价于[ item for item in iterable if function(item)] 1、参数function：返回值为True或False的函数，可以为None 2、参数iterable：序列或可迭代对象
getattr(object, name [, defalut])	获取一个类的属性
globals()	返回一个描述当前全局符号表的字典
hasattr(object, name)	判断对象object是否包含名为name的特性
hash(object)	如果对象object为哈希表类型，返回对象object的哈希值
id(object)	返回对象的唯一标识
isinstance(object, classinfo)	判断object是否是class的实例
issubclass(class, classinfo)	判断是否是子类
len(s)	返回集合长度
locals()	返回当前的变量列表
map(function, iterable, ...)	遍历每个元素，执行function操作
memoryview(obj)	返回一个内存镜像类型的对象
next(iterator[, default])	类似于iterator.next()
object()	基类
property([fget[, fset[, fdel[, doc]]]])	属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter
reduce(function, iterable[, initializer])	合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推
reload(module)	重新加载模块
setattr(object, name, value)	设置属性值
repr(object)	将一个对象变幻为可打印的格式
slice（）
staticmethod	声明静态方法，是个注解
super(type[, object-or-type])	引用父类
type(object)	返回该object的类型
vars([object])	返回对象的变量，若无参数与dict()方法类似
bytearray([source [, encoding [, errors]]])	返回一个byte数组 1、如果source为整数，则返回一个长度为source的初始化数组； 2、如果source为字符串，则按照指定的encoding将字符串转换为字节序列； 3、如果source为可迭代类型，则元素必须为[0 ,255]中的整数； 4、如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.
zip([iterable, ...])	实在是没有看懂，只是看到了矩阵的变幻方面

IO操作

file(filename [, mode [, bufsize]])	file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作 1、参数filename：文件名称。 2、参数mode：'r'（读）、'w'（写）、'a'（追加）。 3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。
input([prompt])	获取用户输入 推荐使用raw_input，因为该函数将不会捕获用户的错误输入
open(name[, mode[, buffering]])	打开文件 与file有什么不同？推荐使用open
print	打印函数
raw_input([prompt])	设置输入，输入都是作为字符串处理

重要的内置函数：

1 filter(function, sequence)

#filter   作用：过滤
str = ["a","b","c"]
def f(n):
    if n != "a":
        return n
ret = filter(f,str)        #ret为迭代器对象
print(ret)                #<filter object at 0x0000000000B1A5F8>
print(list(ret))           #['b', 'c']

对sequence中的item依次执行function(item)，将执行结果为True的item做成一个filter object的迭代器返回。可以看作是过滤函数。

2 map(function, sequence)

#map     对元素值进行修改
str = ["a","b","c"]
def f(n):
    return n+"hello"
ret = map(f,str)           #ret为迭代器对象
print(ret)                 #<map object at 0x00000000007AA5F8>
print(list(ret))           #['ahello', 'bhello', 'chello']

对sequence中的item依次执行function(item)，将执行结果组成一个map object迭代器返回.
map也支持多个sequence，这就要求function也支持相应数量的参数输入：

3 reduce(function, sequence, starting_value)

#reduce    就是一个值，无需迭代器

from functools import reduce
def f(x,y):
    return x+y
print(reduce(f,range(1,10)))       #

对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用.

4 lambda

#lambda    无定义函数
lambda a,b : a+b        #a,b为参数，a+b为返回值

普通函数与匿名函数的对比：

匿名函数的命名规则，用lamdba 关键字标识，冒号（：）左侧表示函数接收的参数（a,b） ,冒号（：）右侧表示函数的返回值（a+b）。

因为lamdba在创建时不需要命名，所以，叫匿名函数