函数
1、什么是函数
函数就是一种工具。
可以重复调用
2、为什么要用函数
1、防止代码冗（rong）余
2、代码的可读性差
3、怎么用函数
1、定义函数-->制造工具
2、调用函数-->使用工具
1、无参函数：
def index():
print('ok')
2、空函数：
def login():
pass
3、有参函数：
def login(username):
print(username)
可以：a=index
a()使用函数
返回值：
1、不写return：默认返回None
2、只写return：只有结束函数体代码的效果，返回None
3、写return None ：与只写return的效果相同
4、return返回一个值: 可以将返回的结果，当做一个变量值来使用
5、return返回多个值:
1、将返回的多个值，默认存入元组返回
2、函数的返回值不想被修改
3、可以自己指定返回的数据类型
函数的参数：
参数的类型：
形参：
实参：
传参方式：
位置参数
关键字参数
默认参数
可变长参数：
*args：接收所有溢出的位置参数
**kwargs：接收所有溢出的关键字参数
*：放到实参中就是打散
函数名的命名规范与变量名一样
关键字(def) 函数名(index) 括号:
函数描述：描述函数体代码的功能
def index(a, b):
if a > b:
return a
else:
return b
print(index(1, index(2, 3))) #调用函数
函数的返回值
1、不写return：默认返回None
2、只写return：只有结束函数体代码的效果，返回None
3、写return None ：与只写return的效果相同
4、return返回一个值: 可以将返回的结果，当做一个变量值来使用
5、return返回多个值:
1、将返回的多个值，默认存入元组返回
2、函数的返回值不想被修改
3、可以自己指定返回的数据类型
return:它是一个函数结束的标志，函数体代码只要执行到return，函数执行结束
l1 = [1, 6, 3, 4, 5, 6] def my_len():
count = 0
while True:
for i in l1:
if i == 4:
print(count)
return
count += 1 print(my_len())
------------------------------
def func(a, b, c, d, e):
return a, b, c, d, e print(func(a, b, c, d, e))
-------------------------------
def func1():
return 1, "" print(func1())
函数的参数
函数是先定义，后调用
在定义阶段只检测语法，
不执行任何代码
positional arguments 位置参数
形参：
是在函数定义阶段就规定的参数，它就相当于定义变量时的变量名
实参：
是在函数调用阶段传入的参数，它相当于定义变量时的变量值
#python代码从上到下依次执行
def index(a): # 形参:相当于变量名
print(a)
print(b)
if a > b:
print(a)
else:
print(b) a = 1
b = 2
index(a) # 实参：相当于变量值
位置参数：
通过位置进行传参
关键字参数：
指定参数进行传参
ps:位置参数一定一定一定要在关键字参数之前，
连用的时候，不要对同一个形参重复赋值
def foo(a, b, c, d):
print(a, b, c, d) foo(1, 2, c=1, d=2) #a,b为位置参数，c,d为关键字参数
默认参数：
在定义函数阶段就已经传入参数，
如果说你在实参的时候传入了一个新的参数，就会使用新参数
默认参数在传值的时候，不要将可变类型当做参数传递
应用场景：
当参数对应值重复出现的情况下使用默认参数
def reg(username, password, gender='male'):
print(f"用户名：{username}，密码:{password},性别：{gender}") reg('tank','dsb')
reg('jason','dsb')
reg('egon','xsb')
reg('胡晨阳','dsb','female')
注意：如果默认参数使用可变类型数据，那么地址会相同
# 第一种解决
def reg(hobby, l1=None): # 四个形参
if l1 == None:
l1 = []
l1.append(hobby)
print(f"爱好：{l1}") reg(hobby='生蚝')
reg('大保健')
reg('女教练') # 第二种解决方案 def reg(hobby, l1): # 四个形参
l1.append(hobby)
print(f"爱好：{l1}") reg('生蚝', [])
reg('大保健', [])
reg('女教练', [])
可变长参数：
*args:接收所有溢出的位置参数
接收的值都被存入一个元组
官方认证：*args
只要有*就有可变长参数的效果
*:打散你传入容器类型
**kwargs:接收所有溢出的关键字参数
接收的值都被存入一个字典
官方认证：**kwargs
def index(a, b, c,d,e):
print(a, b, c,d,e) index(1,2,*(3,4,5))
----------------------------------------
def index(a, b, c,*args): #接收溢出的位置参数
print(a, b, c,*args) # 不写*打印args元组 index(1,2,3,4,5) # 1 2 3 4 5
-----------------------------------------
def func(a, b, c, d,**kw): # 接收所有溢出的关键字参数
print(a, b, c, d,kw) # 打印字典，只能写*(打散，显示key),不能写** func(1, 2, c=3, d=4, e=5, f=6) # 1 2 3 4 {'e': 5, 'f': 6}
l1 = [1,2,3,4]
t1 = (1,2,3,4) print(*l1) # 1 2 3 4
print(*t1) # 1 2 3 4
-------------------------------
def foo(a,b,c,d,e,f):
print(a,b,c,d,e,f) def bar(*args,**kwargs): #接收所有位置参数，关键字参数
foo(*args,**kwargs) bar(1,2,3,d=10,e=20,f=30)
命名关键字参数
# 定义在*与**之间
# 在给命名关键字传值的时候一定要以关键字形式传递
# 关键字参数一定不能放在位置参数前
def index(x, y, z, *args, a=1, b, **kwargs):
print(x, y, z)
print(args)
print(a, b)
print(kwargs) index(1, 2, 3, 354353, 4342, 3213123, a=111, b=222, c=333, d=444)
typing模块
一、为什么要使用该模块
二、typing模块作用
- 1.类型检查，防止运行时出现参数和返回值类型不符合。
- 2.作为开发文档附加说明，方便使用者调用时传入和返回参数类型。
- 3.该模块加入后并不会影响程序的运行，不会报正式的错误，只有提醒。
注意：typing模块只有在python3.5以上版本中才能使用,pycharm目前支持typing检查
三、typing的使用方法
from typing import List, Tuple, Dict def test(a:int, s:str, f:float, b:bool) -> Tuple[int, Tuple, Dict, bool]:
l = a
tup = tuple(s)
di = {'key': f}
bo = b
return l, tup, di, bo # 此处返回的类型如果不是箭头声明的类型会报黄警告，比如l=str(a) print(test(12, 'test', 1.00, 1)) # 输入正确类型的参数 # 结果
(12, ('t', 'e', 's', 't'), {'key': 1.0}, 1) print(test('sss', 'test', 1, 'h')) # 输入错误的参数类型，pycharm会报黄警告，与设定的输入类型不符，但是能正常运行
注意：
在传入参数时通过“参数名:类型”的形式声明参数的类型；
返回结果通过"-> 结果类型"的形式声明结果的类型。
在调用的时候如果参数的类型不正确pycharm会有提醒，但不会影响程序的运行。
对于如list列表等，还可以规定得更加具体一些，如：“-> List[str]”,规定返回的是列表，并且元素是字符串。
四、typing常用的类型
int,long,float: 整型,长整形,浮点型;
bool,str: 布尔型，字符串类型；
List, Tuple, Dict, Set:列表，元组，字典, 集合;
Iterable,Iterator:可迭代类型，迭代器类型；
Generator：生成器类型；
- python天生支持多态，迭代器中的元素可能是多种类型，使用or或者Union操作符
from typing import List, Union def func(a: int, string: str) -> List[int or str]:
list1 = []
list1.append(a)
list1.append(string)
return list1
def get_next_id() -> Union[int, None]:
return 1
return None