python基础3-函数定义、函数返回值、函数参数、局部变量和全局变量、递归、高阶函数、函数式编程、匿名函数、嵌套函数、内置方法

1、函数定义

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

特性:

• 减少重复代码
• 使程序变的可扩展
• 使程序变得易维护

语法定义

def sayhi():#函数名
    print("Hello, I am severen!")
 
sayhi() #调用函数

带有参数的函数

def calc(x,y):
    res = x**y
    return res #返回函数执行结果
 
c = calc(a,b) ＃结果赋值给c变量
print(c)

2、函数返回值

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

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，所以，也可以理解为 return 语句代表着函数的结束

如果未在函数中指定return,那这个函数的返回值为None

• 返回值个数=0,返回None
• 返回值个数=1,返回object
• 返回值个数>1，返回tuple

3、函数参数

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

实参：位置参数、关键字参数、默认参数

• 位置参数与行参一一对应
• 关键字调用与行参顺序无关
• 关键参数不能写在位置参数前面
• 默认参数特点：调用函数时，默认参数非必须传递；用途：默认安装值

参数组（参数个数不固定，接收列表）

# 接收N个位置参数，转换成元组	
def test(*args):
	print(args)

test(1,2,3,4) # output=>(1,2,3,4)
test(*[1,2,3,4,5]) # output=>(1,2,3,4,5)

参数组（参数个数不固定，接收字典）

# **kwargs: 把N个关键字参数，转换成字典的形式
def test(**kwargs):
	print(kwargs)
	print(kwargs['name'])

test(name="xue", age=23, sex="M") # output=>{'name'='xue', 'age'=23, 'sex'='M'}
test(**{'name'='xue', 'age'=23, 'sex'='M'}) # output=>{'name'='xue', 'age'=23, 'sex'='M'}

4、局部变量和全局变量

• String、int这些都不能够在函数內局部修改
• list、dic、set都是能在函数中被修改的
• 要想在函数内部修改全部变量，需要在函数中声明全局变量 global

局部变量

# Author: Mr.Severen
# 2019.10.23
# 局部变量
	
def change_name(name):
	print("before change: ", name)
	name = "Xue"
	print("after change: ", name)
	
>>>name = "severen"
>>> change_name(name)
before change:  severen
after change:  Xue
>>> print(name)
severen	

全局变量

# Author: Mr.Severen
# 2019.10.23
# 全局变量

name = "bob"
	
def change_name():
	global name
	print("before change: ", name)
	name = "Xue"
	print("after change: ", name)

>>> print(name)
bob
>>> change_name()
before change:  bob
after change:  Xue
>>> print(name)
Xue

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：

• 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

5、递归（最大999层）

# Author: Mr.Severen
# 2019.10.23

def calc(n):
	print(n)
	if int(n/2) > 0:
		return calc(int(n/2))
	print("->", n)
			
calc(10)

/*
输出：
10
5
2
1
*/

递归特性：

• 必须有一个明确的结束条件
• 每次进入更深一层的时候，问题规模要相应减少
• 效率不高，调用过多栈溢出

6、高阶函数

• 把一个函数名当作实参给另一个函数

• 返回值包含函数名

  def add(x,y,f): # f:函数
  	return f(x)+f(y)
  
  res = add(3,-6,abs)
  print(res)
  

7、函数式编程

越低级的语言，越贴近计算机，抽象程度低，执行效率高，如C；越高级的语言，越贴近计算，抽象程度高，执行效率低

函数编程的一个特点就是，只要输入是确定的，输出就是确定的

8、匿名函数

匿名函数就是不需要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

匿名函数例子：

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)


输出：
1
25
49
16
64

9、嵌套函数

name = "severen"

def change_name():
    name = "severen2"

    def change_name2():
        name = "severen3"
        print("第3层打印", name)

    change_name2()  # 调用内层函数
    print("第2层打印", name)

change_name()
print("最外层打印", name)


输出：
第3层打印 severen3
第2层打印 severen2
最外层打印 severen

10、内置方法

内置参数详解：
https://docs.python.org/3/library/functions.html?highlight=built#all

abs(x) 取绝对值
all(iterable) 可迭代对象中有一个元素为假结果就是假
any(iterable) 可迭代对象中有一个元素为真结果就是真
bin(x) 十进制->二进制
bool(x) 判断真假
chr(x) x必须是数字，返回该数字在ascill码对应的字符
ord(x) x必须是字符，返回该字符在ascill码对应的数字

divmod(x, y) 返回x/y的商和余数
eval(str) 把字符串转换成字典

filter():
	匿名函数：
		calc = lambda n:print(n)
		calc(5)
	res = filter(lambda n:n>5, range(10)) # 过滤出符合条件的数据
	for i in res:
		print(i)

map():
	res = map(lambda n:n*2, range(10)) # 将所有的值按照匿名函数的规则做处理
	for i in res:
		print(i)

reduce():
	import functools
	res = functools.reduce(lambda x,y:x+y, range(10))

frozenset([1,4,33,32,54]) 将一个集合变成不可变
globals() 返回一个字典，当前文件中的所有变量
hex(int) 把一个十进制的数字转成16进制
oct(int) 把一个十进制的数字转成8进制
pow(2,3) 2的3次方
round(3.1415, 2) 保留两位小数

sorted()
	a = {6:2, 8:0, 1:4, -5:6, 99:11, 4:22}
	sorted(a.items()) # 按照key来排序
	sorted(a.items(), key=lambda x:x[1]) # 按照来排序

zip()
	a = [1,2,3,4]
	b = ['a', 'b', 'c', 'd']
	for i in zip(a, b):
		print(i)


#compile
#然而直接exec(code)可以直接执行，compile有啥用？
>>> code = 'for i in range(10):print(i)'
>>> c = compile(code, '', 'exec')
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> code2 = "1+6/2+9"
>>> c = compile(code2, '', 'eval')
>>> eval(c)
13.0