def 函数名(参数1，参数2，参数3...)：  # 也可以没有参数
    执行语句
    return (没有返回值，返回None)

# 函数是功能模块化，代码复用的

def func():
    print('这是一个函数')
func()              # 函数调用  func函数对象

def func1(x,y):     # 定义参数，定义时候写的参数，形参(形式参数)
    print('和是：',x+y) 
func1(2,3)          # 传参 2,3 实际传递进来的参数叫做实参

# 必备参数必须以正确的顺序传入函数，调用时数量也必须和声明时的一样
def func(userName,userAge):
    print('userName:',userName)
    print('userAge:',userAge)
userName = 'Jack'
userAge = 16

print('--------------------')
func(userName,userAge) # 正确的参数顺序
print('--------------------')
func(userAge,userName) # 错误的参数顺序，结果就会错误k
print('--------------------')

# func(userAge)   缺少参数会报错，注释掉

# 显示的给形参传值，也叫命名参数，可以打乱顺序传递参数
def func(userName,userAge):
    print('userName:',userName)
    print('userAge:',userAge)
userName = 'Jack'
userAge = 16
func(userAge = userAge, userName = userName) # 显式的给形参传值

# 设置缺省参数 一定是从右向左，如果给默认参数传递了值，那么会覆盖掉之前的默认值

# def func(userName='小明',userAge):  错误的
def func(userAge,userSex='male',userName='小明'):   # 给形参加默认值，一定是从右向左
    print('userName:',userName)
    print('userAge:',userAge)
    print('userSex:',userSex)
userAge = 16
func(userAge,'female')

# 一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会具体定义
def func(*arg):       # 1个* 默认把传递进来的多个参数处理成元组类型
    print(arg)
    print(type(arg))
    print('----------------------')
    print(list(arg))  # 转换函数，工厂函数
func(1,2,3,4,5,6,7,8,'a','b','c',[1,2,3])

print('----------------------')
def func1(**arg):     # 2个* 传递参数的时候，要以键值对的形式，传递进来的多个键值对会默认处理成字典
    print(arg)
    print(type(arg))
func1(a=1,b=2,c=3)

# 输出结果
(1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', [1, 2, 3])
<class 'tuple'>
----------------------
[1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', [1, 2, 3]]
----------------------
{'a': 1, 'b': 2, 'c': 3}
<class 'dict'>

#ctrl + / 批量注释

# return 可以返回任意种类的对象，同时也能返回多个值

def func1():
    #return (1,2)
    return 1,2        # 代码实际上只有一个返回值，是一个包含2个元素的元组，它的圆括号是可选
print (func1())
print(type(func1()))
# 输出结果
(1, 2)
<class 'tuple'>

def func2(a,b,c):
    # return list((a,b,c))
    return [a,b,c]        # 可以显式的修改返回值的类型

res = func2(1,2,3)         # 可以打包接受返回值
print(res)
# 输出结果
[1, 2, 3]

# 函数参数多态 一个操作的意义，取决于被操作对象的类型
def add(x,y):
    print(x+y)

add(1,2)
add('a','b')
add([1,2,3],['a','b','c'])

# 输出结果
3
ab
[1, 2, 3, 'a', 'b', 'c']

a = 1                # 全局作用域，作用范围是当前文件，这个a变量只有在这个脚本执行结束后才失效
def func3():
    a = 2            # 局部作用域，这个a变量只有在fun3函数执行过程中有效，函数结束后就失效了
    print('函数内部的a是：',a)

func3()
print('函数外部的a是：',a)

# 输出结果
函数内部的a是： 2
函数外部的a是： 1
--------------------------------------------------------------------------------------------

# 函数内声明全局变量 global
a = 1 
def func3():
    global a # 在函数内部声明了一个全局变量
    a = 2
    print('函数内部的a是：',a)

func3()
print('函数外部的a是：',a)

# 输出结果
函数内部的a是： 2
函数外部的a是： 2