433 lines
8.1 KiB
Markdown
433 lines
8.1 KiB
Markdown
# 认识函数
|
|
|
|
## 什么是函数
|
|
|
|
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
|
|
|
|
## 函数的定义与调用
|
|
|
|
```python
|
|
def my_len():
|
|
s = 'hello world'
|
|
length = 0
|
|
for i in s:
|
|
length = length + 1
|
|
print(length)
|
|
|
|
my_len()
|
|
```
|
|
|
|
```
|
|
定义：def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。
|
|
|
|
def 是固定的，不能变，他就是定义函数的关键字。
|
|
|
|
空格 为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空多少都行，但正常人还是空1格。
|
|
|
|
函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能
|
|
|
|
括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！
|
|
|
|
注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。
|
|
|
|
调用：就是 函数名() 要记得加上括号。
|
|
```
|
|
|
|
## 函数的返回值
|
|
|
|
```python
|
|
def my_len():
|
|
s = 'hello world'
|
|
length = 0
|
|
for i in s:
|
|
length = length + 1
|
|
return length
|
|
|
|
str_len = my_len()
|
|
print(str_len)
|
|
```
|
|
|
|
**return关键字的作用**
|
|
|
|
- return 是一个关键字，这个词翻译过来就是“返回”，所以我们管写在return后面的值叫“返回值”。
|
|
- 不写return的情况下，会默认返回一个None
|
|
- 一旦遇到return，结束整个函数。
|
|
- 返回的多个值会被组织成元组被返回，也可以用多个值来接收
|
|
|
|
```python
|
|
def ret_demo():
|
|
return 1,2,'a',['hello','world']
|
|
|
|
ret = ret_demo()
|
|
print(ret)
|
|
```
|
|
|
|
## 函数的参数
|
|
|
|
带参数的函数
|
|
|
|
```python
|
|
def my_len(s):
|
|
length = 0
|
|
for i in s:
|
|
length += 1
|
|
return length
|
|
|
|
ret = my_len('hello world!')
|
|
print(ret)
|
|
```
|
|
|
|
实际的要交给函数的内容，简称实参。
|
|
|
|
在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。
|
|
|
|
1. 按照位置传值：位置参数
|
|
|
|
```python
|
|
def maxnumber(x,y):
|
|
the_max = x if x > y else y
|
|
return the_max
|
|
|
|
ret = maxnumber(10,20)
|
|
print(ret)
|
|
```
|
|
|
|
1. 按照关键字传值：关键字参数。
|
|
|
|
```python
|
|
def maxnumber(x,y):
|
|
the_max = x if x > y else y
|
|
return the_max
|
|
|
|
ret = maxnumber(y = 10,x = 20)
|
|
print(ret)
|
|
```
|
|
|
|
1. 位置、关键字形式混着用：混合传参。
|
|
|
|
```python
|
|
def maxnumber(x,y):
|
|
the_max = x if x > y else y
|
|
return the_max
|
|
|
|
ret = maxnumber(10,y = 20)
|
|
print(ret)
|
|
```
|
|
|
|
位置参数必须在关键字参数的前面
|
|
|
|
对于一个形参只能赋值一次
|
|
|
|
1. 默认参数。
|
|
|
|
```python
|
|
def stu_info(name,age = 18):
|
|
print(name,age)
|
|
|
|
stu_info('aaron')
|
|
stu_info('song',50)
|
|
```
|
|
|
|
1. 默认参数是一个可变数据类型
|
|
|
|
```python
|
|
def demo(a,l = []):
|
|
l.append(a)
|
|
print(l)
|
|
|
|
demo('abc')
|
|
demo('123')
|
|
```
|
|
|
|
1. 动态参数
|
|
|
|
```python
|
|
def demo(*args,**kwargs):
|
|
print(args,type(args))
|
|
print(kwargs,type(kwargs))
|
|
|
|
demo('aaron',1,3,[1,3,2,2],{'a':123,'b':321},country='china',b=1)
|
|
|
|
##动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。
|
|
```
|
|
|
|
## 命名空间和作用域
|
|
|
|
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
|
|
|
|
在函数的运行中开辟的临时的空间叫做局部命名空间。
|
|
|
|
命名空间一共分为三种：
|
|
|
|
- 全局命名空间
|
|
- 局部命名空间
|
|
- 内置命名空间
|
|
|
|
取值顺序：
|
|
|
|
- 在局部调用：局部命名空间->全局命名空间->内置命名空间
|
|
- 在全局调用：全局命名空间->内置命名空间
|
|
|
|
作用域
|
|
|
|
- 全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
|
|
- 局部作用域：局部名称空间，只能在局部范围内生效
|
|
|
|
### globals和locals方法
|
|
|
|
```python
|
|
print(globals())
|
|
print(locals())
|
|
|
|
def func():
|
|
a = 12
|
|
b = 20
|
|
print(globals())
|
|
print(locals())
|
|
|
|
func()
|
|
```
|
|
|
|
**global**
|
|
|
|
1. 声明一个全局变量。
|
|
2. 在局部作用域想要对全局作用域的全局变量进行修改时，需要用到 global(限于字符串，数字)。
|
|
|
|
```python
|
|
def func():
|
|
global a
|
|
a = 3
|
|
|
|
func()
|
|
print(a)
|
|
|
|
count = 1
|
|
def search():
|
|
global count
|
|
count = 2
|
|
|
|
search()
|
|
print(count)
|
|
```
|
|
|
|
对可变数据类型（list，dict，set）可以直接引用不用通过global
|
|
|
|
```python
|
|
li = [1,2,3]
|
|
dic = {'name':'aaron'}
|
|
|
|
def change():
|
|
li.append(4)
|
|
dic['age'] = 18
|
|
print(dic)
|
|
print(li)
|
|
|
|
change()
|
|
print(dic)
|
|
print(li)
|
|
```
|
|
|
|
**nonlocal**
|
|
|
|
1. 不能修改全局变量。
|
|
2. 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。
|
|
|
|
```python
|
|
def add_b():
|
|
b = 1
|
|
def do_global():
|
|
b = 10
|
|
print(b)
|
|
def dd_nolocal():
|
|
nonlocal b # 应用了上一层的变量b
|
|
b = b + 20
|
|
print(b) # 发生了改变
|
|
dd_nolocal() # 调用函数，导致do_global的命名空间b也改变了
|
|
print(b)
|
|
do_global()
|
|
print(b)
|
|
add_b() # 最上面一层没有变化
|
|
```
|
|
|
|
## 函数的嵌套和作用域链
|
|
|
|
```python
|
|
def mymax(x,y):
|
|
m = x if x > y else y
|
|
return m
|
|
|
|
def maxx(a,b,c,d):
|
|
res1 = mymax(a,b)
|
|
res2 = mymax(res1,c)
|
|
res3 = mymax(res2,d)
|
|
return res3
|
|
|
|
ret = maxx(23,453,12,-13)
|
|
print(ret)
|
|
|
|
# 传入任意多的数字，甚至有重复的，还有非数字(忽略)，得到最大的值
|
|
|
|
def my_max(x, y):
|
|
m = x if x > y else y
|
|
return m
|
|
|
|
|
|
def maxx(*nums):
|
|
temp_nums = []
|
|
for i in nums:
|
|
if type(i) is int:
|
|
temp_nums.append(i)
|
|
while len(temp_nums) > 1:
|
|
a_num = temp_nums.pop()
|
|
b_num = temp_nums.pop()
|
|
ret = my_max(a_num, b_num)
|
|
temp_nums.append(ret)
|
|
return temp_nums[0]
|
|
|
|
|
|
ret = maxx(123, 3345, 123, 9999, 123, 345, 345, 667, 123, 435, 657, 16, 21, "aabc", ["a", "b"])
|
|
print(f"数值类型中最大的是{ret}")
|
|
```
|
|
|
|
```python
|
|
def f1():
|
|
print("in f1")
|
|
def f2():
|
|
print("in f2")
|
|
f2()
|
|
|
|
f1()
|
|
```
|
|
|
|
## 函数名的本质
|
|
|
|
函数名本质上就是函数的内存地址
|
|
|
|
1. 可以被引用
|
|
|
|
```python
|
|
def func():
|
|
print('in func')
|
|
|
|
f = func
|
|
|
|
print(f)
|
|
f()
|
|
```
|
|
|
|
1. 可以被当作容器类型的元素
|
|
|
|
```python
|
|
def f1():
|
|
print('f1')
|
|
|
|
def f2():
|
|
print('f2')
|
|
|
|
def f3():
|
|
print('f3')
|
|
|
|
l = [f1,f2,f3]
|
|
d = {'f1':f1,'f2':f2,'f3':f3}
|
|
|
|
#调用
|
|
l[0]()
|
|
d['f2']()
|
|
```
|
|
|
|
1. 可以当作函数的参数和返回值
|
|
|
|
```python
|
|
def f1():
|
|
print('f1')
|
|
|
|
def func(argv):
|
|
argv()
|
|
return argv
|
|
|
|
f = func(f1)
|
|
f()
|
|
```
|
|
|
|
## 闭包
|
|
|
|
```python
|
|
def func():
|
|
name = 'aaron'
|
|
def inner():
|
|
print(name)
|
|
return inner
|
|
|
|
f = func()
|
|
f()
|
|
```
|
|
|
|
内部函数包含对外部作用域而非全剧作用域变量的引用，该内部函数称为闭包函数
|
|
|
|
判断闭包函数的方法**closure**
|
|
|
|
```python
|
|
def func():
|
|
name = 'aaron'
|
|
def inner():
|
|
print(name)
|
|
print(inner.__closure__)
|
|
return inner
|
|
|
|
f = func()
|
|
f()
|
|
# 最后运行的结果里面有cell就是闭包
|
|
|
|
name = 'aaron'
|
|
def func():
|
|
def inner():
|
|
print(name)
|
|
print(inner.__closure__)
|
|
return inner
|
|
|
|
f = func()
|
|
f()
|
|
# 输出结果为None，说明不是闭包
|
|
```
|
|
|
|
```python
|
|
def wrapper():
|
|
money = 1000
|
|
def func():
|
|
name = 'apple'
|
|
def inner():
|
|
print(name,money)
|
|
return inner
|
|
return func
|
|
|
|
f = wrapper()
|
|
i = f()
|
|
i()
|
|
```
|
|
|
|
```python
|
|
def func(a,b):
|
|
def inner(x):
|
|
return a*x + b
|
|
return inner
|
|
|
|
func1 = func(4,5)
|
|
func2 = func(7,8)
|
|
print(func1(5),func2(6))
|
|
```
|
|
|
|
```python
|
|
from urllib.request import urlopen
|
|
def func():
|
|
content = urlopen('http://myip.ipip.net').read()
|
|
def get_content():
|
|
return content
|
|
return get_content
|
|
|
|
code = func()
|
|
content = code()
|
|
print(content.decode('utf-8'))
|
|
|
|
content2 = code()
|
|
print(content2.decode('utf-8'))
|
|
``` |