【一】函数的调用方法

【1】直接调用函数

def student(name,age):
    print(f"my name is {name} and my age is {age}")

直接调用函数
student(name='qwer',age=22)

【2】用表达式调用函数

用一个新变量存储函数的内存地址然后调用
def add(x,y):
    return x + y

result = add(2,10) + 100
print(result)

【3】函数作为返回值

# 【1】
def add(x,y):
    return x + y

def delete(a,b):
    return add(a,b)

print(delete(10,101))

# 【2】
def add(x,y):
    return x + y

def func():
    return add
q = func()
print(q)
# 返回内存地址
# <function add at 0x0000018235A63E20>
print(q(10,111))
121

【4】函数可以作为参数传递给另一个函数

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

def func():
    return add
q = func()


def login(func):
    return func()
login(add) # 括号内放函数名不带括号 传的是内存地址
	

函数的参数

【一】按功能（位置）不同分为两种

【1】形参

• 形参就是在函数定义阶段定义在函数名后面的（）里面的参数
• 需要在函数调用的时候传递进去，并且这个参数只在当前函数内部生效

【2】实参

• 实参就是在调用函数的时候传递进去的那个真实的值
• 可以按照位置和关键字传递参数
• 实参可以是表达式，常量，变量
• 表达式的意思就是表达式 如 1+1 x+y x/y

（1）按位置传参数

• 有位置但是不传参数（参数不够）--->报错 ，提示缺少必要的位置参数
• 没有位置但是多传了参数（参数过多）--->提示只需要指定数量参数，但是参数给多了

位置参数必须按照位置传递值，如果换位置就会导致函数内的参数错乱

（2）按关键字传参数

• 关键字传参数的时候要指定上函数定义时的位置参数名
• 允许按照位置传递参数，并且指定上关键字
• 允许不按照位置传递参数，指定上关键字

（3）位置参数和关键字参数连用

要传递的位置参数一定要在关键字参数之前，否则报错

def add(x,y,z):
    print(x,y,z)
    
# 正常输出 1 2 3
add(1,2,3)
add(1,y=2,z=3)

# 报错  SyntaxError: positional argument follows keyword argument
add(y=2,1,z=3)

【3】默认参数

1. 在函数定义阶段的时候定义在函数名后面的（）里面的参数可以给默认值

2. 位置参数给了默认值后

   • 在函数调用时，可以不指定默认参数的值，不给值默认就是默认值

   • 若是给了新值，将会把默认值覆盖

def add(x,y='1'):
    print(x,y)
# 没给y值 输出默认为1
add(2)
# 2 1

# 给y一个新值 33 输出会覆盖默认值
add(x=2,y=33)
# 2 33

def add(x,y=[]):
    y.append(x)
    print(y)

add(1)
add(2)
add(3)
# [1]
# [1, 2]
# [1, 2, 3]

# 每次调用 y都是一个空的列表 
def add(x):
    y = []
    y.append(x)
    print(y)

add(1)
add(2)
add(3)
# [1]
# [2]
# [3]

【二】可变长位置参数

【1】什么是可变长位置参数

• 我们在定义函数的时候会指定位置参数，在调用函数并且传递参数的时候不能多传也不能少传
• 不能少传可以通过指定默认值解决
• 多传可以通过可变长位置参数解决 ，可以用一个变量来接收所有超出指定参数的位置参数

【2】定义一个函数

def add(x,y,z = 3):
  print(x)
  print(y)
  print(z)

add(1,2,4,100)
# 报错 add() takes from 2 to 3 positional arguments but 4 were given

*args 默认的属性，可以指定

在形参后面加一个*args 可以将多余的位置参数都接收并且放到一个元组中
def add(x,y,z=3,*args):

  print(x)
  print(y)
  print(z)
  print(args)
add(1,2,4,100)

1
2
4
(100,)

# 所有多余位置参数都被*args接收并放进元组
add(1,2,4,100,1111,1231312,123,11113)

1
2
4
(100, 1111, 1231312, 123, 11113)

解包语法 （只能用在可迭代类型中）

可以将每一个元素单独解包出来

语法 * + 可迭代类型
定义一个列表
list = [1,2,3,4,5,6,1123]
# 列表名前加一个*
print(*list)
# 1 2 3 4 5 6 1123
# list不带*号
add(1,2,4,list)

1
2
4
([1, 2, 3, 4, 5, 6, 1123],)

# list带*号
add(1,2,4,*list)

1
2
4
(1, 2, 3, 4, 5, 6, 1123)

【三】可变长关键字参数

可变长关键字参数接收到多余的关键字参数放到字典中

**kwargs

def add(x,y,z,*args,**kwargs):
    print(x,y,z)
    print(args)
    print(kwargs)
add(1,2,3,12123,22,23,234,a=123,b=456)

1 2 3
(12123, 22, 23, 234)
{'a': 123, 'b': 456}

• 字典不支持**解包，
• 支持*解包，解包后得到字典的每一个键

【四】命名关键字参数

一般用不到

在位置参数中间用星号隔开，之前的位置参数支持位置和关键字传参，后面的只能用关键字传参

def add(x,y,z,a,b):
    print(x,y,z,a,b)
add(1,2,3,4,5)   
1 2 3 4 5
# 可以按照关键字和位置参数传递参数

#加入*号
def add(x,y,z,*,a,b):
    print(x,y,z,a,b)
add(1,2,3,4,5)

报错
add() takes 3 positional arguments but 5 were given
#使用关键字传参
add(1,2,3,a=4,b=5)

1 2 3 4 5

在命名关键字参数中指定默认参数的时候，默认参数允许放在位置参数之前

*号后面关键字参数a=11 可以放在默认参数b之前
def add(x,y,z,*,a=11,b):
    print(x,y,z,a,b)

add(1,2,3,a=4,b=5)

1 2 3 4 5

【五】混合使用

• 以上所有参数（除了*命名关键字参数）可以随意组合使用
• 但定义顺序必须是：
  • 位置参数、默认参数、*args、**kwargs

def add(x,y=1,*args,**kwargs):
    print(x,y,args,kwargs)

add(1,2,3,123,a=1234,b=222,c=32313)

1 2 (3, 123) {'a': 1234, 'b': 222, 'c': 32313}

类型提示

Optional : 类型提示语法

在Python 3.5版本后引入的typing模块为Python的静态类型注解提供了支持。

这个模块在增强代码可读性和维护性方面提供了帮助。

【一】什么是注解

在定义函数的位置参数的时候可以指定参数的类型

【二】基本数据类型的注解

【1】不可变数据类型

字符串 整数 浮点数 布尔

def		add(name:str,age:int,money:float,is_male:bool):
    print(name,type(name))
    print(age,type(age))
    print(money,type(money))
    print(is_male,type(is_male))

add(name='qwer',age=123,money=100.1,is_male=True)

qwer <class 'str'>
123 <class 'int'>
100.1 <class 'float'>
True <class 'bool'>

弱类型约束 ：建议你按照指定类型进行传值，但是不按照指定类型也可以

将age 和 money的值类型改变 发现不会报错
def		add(name:str,age:int,money:float,is_male:bool):
    print(name,type(name))
    print(age,type(age))
    print(money,type(money))
    print(is_male,type(is_male))

add(name='qwer',age=123.5,money=100,is_male=True)

qwer <class 'str'>
123.5 <class 'float'>
100 <class 'int'>
True <class 'bool'>

【2】可变类型

字典 列表 元组 集合

• 字典：{键：值} --->约束键和值的数据类型

from typing import Dict,List,Tuple,Set

def add(a:Dict[str,int],list:List[int],tuple:Tuple[str],set:Set[int]):
    print(a,type(a))
    print(list,type(list))
    print(tuple,type(tuple))
    print(set,type(set))

add({'qwer':11},[1,2,3],(1,2),{1,2,3})

{'qwer': 11} <class 'dict'>
[1, 2, 3] <class 'list'>
(1, 2) <class 'tuple'>
{1, 2, 3} <class 'set'>

【三】约定函数的返回值类型

函数名后加 -> 来指定函数返回值类型

def add(x:int,y:int)->int:
    return x + y

print(add(1,2))
3

【四】函数返回值既可以是字符串也可以是数字

union 既可以返回一个又可以返回另一个类型

from typing import  Union
def add(x:int,y:int)->Union[str,int]:
    return x + y
    return str(x + y)

print(add(1,2))
print(add('1','2'))

3
12

【五】可以返回可选的采纳数类型

可以返回None 也可以返回int

from typing import Optional
def add(x:int,y:int)->Optional[None]:
    return '1'

print(add(1,2))

名称空间

【一】什么是名称空间

• 名称空间就是存放函数名与函数值对应关系的地方
• 变量名=变量值
• 先开辟一块内存空间 ，把函数值扔到内存空间中 ---> 内存空间
• 然后你需要 用变量名 和 变量值进行绑定 ---> 名称空间

【二】名称空间的分类

【1】内建名称空间

• 在python解释器中自带的名称空间
• 会随着代码启动而生成，随着代码结束而关闭
• 是第一个加载的名称空间

【2】全局名称空间

• 随着内建名称空间加载完成
• 走到了自己写的代码里面
• 自己创建的变量名 / 函数名 / 类名

这个列表是全局的列表

列表是可变数据类型，列表被修改后id不变

num_list = []
print(id(num_list)) # 1621715457792
def add_list(num):
    num_list.append(num)
    print(id(num_list)) # 1621715457792
add_list(1)
add_list(2)
add_list(3)
print(num_list) # [1, 2, 3]
print(id(num_list)) # 1621715457792

【3】局部名称空间

• 在函数内部或者是类内部定义的变量
• 随着函数启动而创建，随着函数结束而消失

这个列表是全局的列表

列表是可变数据类型，列表被修改后id不变

def add_list(num):
    # 垃圾回收机制 ---> 节省内存开销
    num_list = []
    num_list.append(num)
    print(num_list)
    print(id(num_list)) 
add_list(1)
add_list(2)
add_list(3)

[1]
2344555779840
[2]
2344555779840
[3]
2344555779840

【3】名称空间的加载顺序

内建名称空间 >>> 全局名称空间 >>> 局部名称空间

【4】名称空间的查找顺序

• 若在全局查 先全局后内建--->在python中执行代码

• 若在局部查 先局部后全局再内建 --->在函数内部执行代码

  所有的变量 尤其是 可变数据类型 字典，列表

  尽量写在文件开头，若是放在函数下面可能导致检索不到变量

num_list = []

def add_list(num):
    num_list.append(num)
    print(num_list)
add_list(num=1)

[1]