Python 函数

#1.函数说明文档
#作用 : 可以通过help函数快速查看函数的说明
#help(函数名)  注意，这里不需要括号
'''
def 函数名(参数):
    """说明文档的位置"""
    代码
    ......
查看函数的说明文档
help(函数名)
'''
#函数说明文档的高级写法:
def my_sum(a, b):
    """
    求和函数
    :param a: 参数1
    :param b: 参数2
    :return:  返回值
    """
    return a + b

help(my_sum)

#2.局部变量和全局变量
a = 100  #全局变量
def funA():
    print(a) #使用全局变量

def funB():
    a = 200 #定义了一个局部变量a
    print(a)#输出的是局部变量

def funC():
    global a #这里声明，a是全局变量
    a = 300  #对全局变量a经行赋值
    print(a)

funA()    #输出 100
funB()    #输出 200
print(a)  #输出 100
funC()    #输出 300
print(a)  #输出 300

#3.一个函数多个返回值
def return_num():
    return 1, 2 #(默认返回元组)

def return_dict():
    return {'name':'Jack', 'age':20}

def return_list():
    return [1, 2]

def return_set():
    return {1, 2, 3, 4, 2, 3, 4}

print(return_num())  #输出 (1, 2)
print(type(return_num()))  #输出 <class 'tuple'>

print(return_dict())        #输出 {'name': 'Jack', 'age': 20}
print(type(return_dict()))  #输出 <class 'dict'>

print(return_list())        #输出 [1, 2]
print(type(return_list()))  #输出 <class 'list'>

print(return_set())         #输出 {1, 2, 3, 4}
print(type(return_set()))   #输出 <class 'set'>

#4.函数的参数
#4.1 位置参数 : 调用函数时，根据函数定义的参数位置来传递参数
#注意 : 传递和定义参数的顺序以及个数必须一致

def user_info(name, age, gender):
    print(f'name = {name}, age = {age}, gender = {gender}')

user_info('Jack', 30, 'Man')  #输出 name = Jack, age = 30, gender = Man

#4.2 关键字参数 : 函数调用，通过'键 = 值'形式加以指定。可以让函数更加清晰，容易使用
#同时也不需要注意参数的传递顺序
#注意 : 函数调用时，如果有位置参数时，位置参数必须在关键字参数前面，但关键字参数之间不存在先后顺序
#第一个参数按照位置参数传入，第二个和第三个按照关键字参数传递，不用考虑顺序

user_info('Bruce', gender = 'Man', age = 30)  #输出 name = Bruce, age = 30, gender = Man

#4.3 缺省参数，也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。
#注意 : 所有位置参数必须出现在默认参数前，包括定义和调用的时候

def member_info(name, age, gender = 'Man'):
    print(f'name = {name}, age = {age}, gender = {gender}')

member_info('Jone', age = 33)                    #输出 name = Jone, age = 33, gender = Man
member_info('Lucy', age = 25, gender = 'Women')  #输出 name = Lucy, age = 25, gender = Women

#4.4 不定长参数
#不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
#此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便
#4.4.1 包裹位置传递
#注意 : 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，
#args是元组类型，这就是包裹位置传递

def fun_tuple_parm(*args):
    print(args)
    print(type(args))

fun_tuple_parm('Lucy', 20, 'Women')
'''
输出:
('Lucy', 20, 'Women')
<class 'tuple'>
'''
fun_tuple_parm('Jay')
'''
输出
('Jay',)
<class 'tuple'>
'''
fun_tuple_parm()
'''
输出
()
<class 'tuple'>
'''
#4.4.2 包裹关键字传递
#当我们用关键子传递参数，且不知道关键字个数的时候，用包裹关键字传递方法传递参数

def fun_dict_parm(**kwargs):
    print(kwargs)
    print(type(kwargs))

fun_dict_parm(name = 'Jack')
'''
输出
{'name': 'Jack'}
<class 'dict'>
'''
fun_dict_parm()
'''
输出
{}
<class 'dict'>
'''

def return_value(*args, **kwargs):
    return args, kwargs

print(return_value())
print(type(return_value()))
'''
输出
((), {})
<class 'tuple'>
'''

#5.拆包
#5.1 元组拆包
def return_tuple():
    return 100, 200

num1, num2 = return_tuple()
print(num1)  #输出 100
print(num2)  #输出 200
#注意 : 这里函数返回多少个值，拆包的时候，也要用相应多少个变量去接
#否则就会报错
#当返回值个数大于变量个数时 : ValueError: too many values to unpack (expected 2)
#当变量个数大于返回值个数时 : ValueError: not enough values to unpack (expected 3, got 2)

#5.2 字典拆包
dict1 = {'name':'Jack', 'age':20}
a, b = dict1
print(a) #输出 name
print(b) #输出 age
print(dict1[a])  #输出 Jack
print(dict1[b])  #输出 20

def fun_dict_param(**kwargs):
    return kwargs

a, b, c, d = fun_dict_param(name = 'Lucy', age = 20, gender = 'Women', id = 3)
print(len(fun_dict_param(name = 'Lucy', age = 20, gender = 'Women', id = 3))) #输出 4
print(a)  #输出 name
print(b)  #输出 age
print(c)  #输出 gender
print(d)  #输出 id
#注意 : 包裹关键字参数时，函数调用传递了多少个关键子参数，拆字典包就要用对应多少个变量去接

#6.引用
#在python中，值是靠引用来传递的
#我们可以用id()函数来判断两个变量是否是同一个值的引用
#可以将 id 值理解为那块内存的地址标识(十进制)
#6.1 整型 : 是不可变数据类型
a = 1 #这里实际是 a是指向1的一个引用
b = a
print(f'a = {a}')          #输出 a = 1
print(f'id(1) = {id(1)}')  #输出 id(1) = 140718809585312 (十进制)
print(f'id(a) = {id(a)}')  #输出 id(a) = 140718809585312
print(f'id(b) = {id(b)}')  #输出 id(b) = 140718809585312
a = 2  #这里将a变为指向2的引用
print(f'a = {a}')          #输出 a = 2
print(f'id(2) = {id(2)}')  #输出 id(2) = 140718809585344
print(f'id(a) = {id(a)}')  #输出 id(a) = 140718809585344
print(f'id(b) = {id(b)}')  #输出 id(b) = 140718809585312  这里 b 仍然还是整型 1 的引用

#6.2 列表 : 可变数据类型
l1 = [1, 2]
l2 = l1
print(l1)      #输出 [1, 2]
print(l2)      #输出 [1, 2]
print(id(l1))  #输出 2598130673920
print(id(l2))  #输出 2598130673920

l1.append(3)
print(l1)      #输出 [1, 2, 3]
print(l2)      #输出 [1, 2, 3]
print(id(l1))  #输出 2598130673920
print(id(l2))  #输出 2598130673920

#6.3 引用当作实参(可以理解为变量当作实参)
def testA(a):
    print(a)
    print(id(a))
    a += a
    print(a)
    print(id(a))

m = 20
testA(m) #传引用m(不可变类型)
'''
输出
20
140718661409024
40
140718661409664
'''
l1 = [10, 11]
testA(l1) #传引用 l1(可变类型)
'''
输出
[10, 11]
1865269193152
[10, 11, 10, 11]
1865269193152
'''
#7. 可变类型和不可变类型
#7.1 可变类型 : 数据可以直接修改的类型
'''
列表  list()
字典  dict() 
集合  set()
'''
#7.2 不可变类型 : 数据不能直接修改
'''
整型
浮点型
字符串
元组    tuple()
'''