python基础语法5 函数定义,可变长参数

函数

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模块

一、为什么要使用该模块

Python是一门弱类型的语言，很多时候我们可能不清楚函数参数类型或者返回值类型，很有可能导致一些类型没有指定方法，在写完代码一段时间后回过头看代码，很可能忘记了自己写的函数需要传什么参数，返回什么类型的结果，就不得不去阅读代码的具体内容，降低了阅读的速度，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