定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
　　1.减少代码重复
　　2.保持代码的一致性
　　3.方便修改，可扩展性
函数的创建
#简单的函数
print("It's ok")
def ：定义一个函数名
f：函数名（自己定义）
()：方便传输参数，可写可不写
f():函数调用
&函数名的命名规则：
　　1.函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；
　　2.函数名是区分大小写的。
　　3.函数名不能是保留字。
&形参和实参
　　形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）
　　实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参& &
　　区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参
# 形参与实参
#a为形参，不占用内存
print("It's %s"%a)
"ok"为实参
def f(a,b):
print(a+b)
函数的参数
　　必备参数
　　关键字参数
　　默认参数
　　不定长参数
必需的参数：
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
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)
print_info('liu',18)
print_info('aaa',23,'female')
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。将所有参数作为元组。
# def add(x,y):
return x+y
def add(*args):
for i in args:
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]))#根据参数可以打印任意相关信息了
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)
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语句把结果返回
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，也可以理解为 return 语句代表着函数的结束；
如果未在函数中指定return,那这个函数的返回值为None； &
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
局部作用域
print(o_count)
# print(i_count) 找不到
# print(o_count) #找不到
作用域产生&
在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的，如下代码：
这个是没有问题的，if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。
def test():
#print(x) # NameError: name 'x2' is not defined
def、class、lambda是可以引入新作用域的。&
变量的修改&
局部作用域变量不可修改全局作用域变量的值
(一个不在局部作用域里的变量默认是只读的，如果试图为其绑定一个新的值，python认为是在当前的局部作用域里创建一个新的变量，也就是说在当前局部作用域中，如果直接使用外部作用域的变量，那么这个变量是只读的，不能修改)
count = 10
def outer():
print(count)
#local variable 'count' referenced before
assignment
count = 100
print(count)
这里第一个print中，使用到了外部作用域的count，这样后面count就指外部作用域中的count了，再修改就会报错。 如果没使用过这个变量，而直接赋值，会认为是新定义的变量，此时会覆盖外部作用域中变量
count = 10
def outer():
#print(count)
count = 100
print(count)
outer() #100
内部作用域中直接声明了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)
local variable 'count' referenced before assignment
count = 100
print(count)
def outer():
count = 10
def inner():
nonlocal count
count = 20
print(count)
print(count)
（1）变量查找顺序：LEGB，作用域局部&外层作用域&当前模块中的全局&python内置作用域；
（2）只有模块、类、及函数才能引入新作用域；
（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；
（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个关键字，就能完美的实现闭包了。
高阶函数：
& & & & &高阶函数是至少满足下列一个条件的函数:
　　　　接受一个或多个函数作为输入
　　　　输出一个函数
# 高阶函数
return n*n
def foo(a,b,func):
return func(a)+func(b)
print(foo(2,3,f))
关于函数名：
　　函数名可以进行赋值
　　函数名可以作为函数参数，还可以作为函数返回值
　　定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
for i in range(1,b+1):
print(f(5))
while a&=n:
print(f(3))
------------------------------------------------------------
if n == 1:
return n*f(n-1)
print(f(6))
递归函数的优点: & &是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
　　1. 必须有一个明确的结束条件
　　2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
　　3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返 & & 　　 & &回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)
&数学运算类
求绝对值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])&
对集合求和
将一个数字转化为8进制
将整数x转换为16进制字符串
返回整数i对应的ASCII字符
将整数x转换为二进制字符串
将x转换为Boolean类型
&集合类操作
basestring()
str和unicode的超类不能直接调用，可以用作isinstance判断
format(value [, format_spec])
格式化输出字符串格式化的参数顺序从0开始，如&I am {0},I like {1}&
返回给定int类型的unicode
enumerate(sequence [, start = 0])
返回一个可枚举的对象,该对象的next()方法将返回一个tuple
iter(o[, sentinel])
生成一个对象的迭代器，第二个参数表示分隔符
max(iterable[, args...][key])&
返回集合中的最大值
min(iterable[, args...][key])
返回集合中的最小值
dict([arg])
创建数据字典
list([iterable])&
将一个集合类转换为另外一个集合类
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
如果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的函数，可以为None2、参数iterable：序列或可迭代对象
getattr(object, name [, defalut])
获取一个类的属性
返回一个描述当前全局符号表的字典
hasattr(object, name)
判断对象object是否包含名为name的特性
hash(object)
如果对象object为哈希表类型，返回对象object的哈希值
id(object)
返回对象的唯一标识
isinstance(object, classinfo)
判断object是否是class的实例
issubclass(class, classinfo)
判断是否是子类
返回集合长度
返回当前的变量列表
map(function, iterable, ...)&
遍历每个元素，执行function操作
memoryview(obj)&
返回一个内存镜像类型的对象
next(iterator[, default])&
类似于iterator.next()
property([fget[, fset[, fdel[, doc]]]])&
属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter
reduce(function, iterable[, initializer])&
合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推
reload(module)&
重新加载模块
setattr(object, name, value)
设置属性值
repr(object)&
将一个对象变幻为可打印的格式
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, ...])&
实在是没有看懂，只是看到了矩阵的变幻方面
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
raw_input([prompt])&
设置输入，输入都是作为字符串处理
重要的内置函数：
1&filter(function, sequence)
作用：过滤
str = ["a","b","c"]
if n != "a":
ret = filter(f,str)
#ret为迭代器对象
print(ret)
#&filter object at 0xB1A5F8&
print(list(ret))
#['b', 'c']
对sequence中的item依次执行function(item)，将执行结果为True的item做成一个filter object的迭代器返回。可以看作是过滤函数。
2&map(function, sequence)&
对元素值进行修改
str = ["a","b","c"]
return n+"hello"
ret = map(f,str)
#ret为迭代器对象
print(ret)
#&map object at 0xAA5F8&
print(list(ret))
#['ahello', 'bhello', 'chello']
对sequence中的item依次执行function(item)，将执行结果组成一个map object迭代器返回.map也支持多个sequence，这就要求function也支持相应数量的参数输入：
3 reduce(function, sequence, starting_value)
就是一个值，无需迭代器
from functools import reduce
def f(x,y):
return x+y
print(reduce(f,range(1,10)))
对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用.
无定义函数
lambda a,b : a+b
#a,b为参数，a+b为返回值
&普通函数与匿名函数的对比：
&匿名函数的命名规则，用lamdba&关键字标识，冒号（：）左侧表示函数接收的参数（a,b）&,冒号（：）右侧表示函数的返回值（a+b）。
因为lamdba在创建时不需要命名，所以，叫匿名函数
阅读(...) 评论()Python的return如何理解？ - 知乎47被浏览18478分享邀请回答36 条评论分享收藏感谢收起我的图书馆
喜欢该文的人也喜欢