函数基本使用
python中定义函数所用的关键字是def， def 函数名() : 冒号代替其他编程语言的大括号，然后换行缩进写的代码就是函数体。
def welcome():
'''
一个简单的函数
:return:
'''
print("Hello World ！")
welcome()
打印结果：
Hello World ！
三引号中间的内容属于函数的注释文档，在实际项目中都尽量要把每个函数的文档注释写好，在这里为了节约篇幅，本文下面的代码示例就不再添加这个注释了。
函数还可以嵌套，也就是函数里面有函数：
def welcome(name):
def go(name):
print('我最棒：' + name)
go(name)
welcome('小明')
打印结果：
我最棒：小明
函数的参数
形参和实参
def welcome(username):
print("Hello World ！ My name is " + str(username))
welcome("小明")
welcome("小花")
打印结果：
Hello World ！ My name is 小明
Hello World ！ My name is 小花
这是一个带参数的函数，在函数welcome中，username就是一个形参，也就是形式参数，是用来接收调用函数时传入的参数，你传的是啥它就是啥，传人它就是人，传鬼它就是鬼的那种。
实参就是实际参数，在调用函数的时候，传递是小明，那么小明就是实参，传递的是小花，那么小花也是实参，实参传递给函数后，会赋值给函数中的形参，然后我们就可以在函数中使用到外部传入的数据了。
参数默认值
写Java的时候最痛恨的就是方法不能设置默认值，使得必须得重载才行。
python允许我们给函数的形参设置一个默认值，不传参数调用的话，就统一默认是这个值。
def welcome(username = '奥特曼'):
print("Hello World ！ My name is " + str(username))
welcome("小明")
welcome()
打印结果：
Hello World ！ My name is 小明
Hello World ！ My name is 奥特曼
修改参数后影响外部
在函数中修改参数内容会不会影响到外部，这个问题取决于实参的类型是不是可变的，可不可变就是可不可以修改。
字符串就是一种不可变的类型。
比如：
name = "小明" name = "小花"
请问，我是把"小明"修改成了"小花"吗？ 答案是 非也。
实际上我是把"小花"这个字符串赋值给了name，让name指向了这个新字符串，替换掉了原来的"小明"，原来的"小明"仍然是"小明"，没有受到一点改变。
在python中，不可变类型有：整数、字符串、元组，可变类型有：列表、字典。如果传递的参数包含可变类型，并且在函数中对参数进行了修改，那么就会影响到外部的值。
def change(lis):
lis[1] = '小明他大爷'
names = ['小明','小花','小红']
change(names)
print(names)
打印结果：
['小明', '小明他大爷', '小红']
如果我们不希望出现这种事情，那么就将对象复制一份再传递给函数。
def change(lis):
lis[1] = '小明他大爷'
names = ['小明','小花','小红']
change(names[:])
print(names)
打印结果：
['小明', '小花', '小红']
我们用切片的方法拷贝了一份names，函数中尽管修改了参数，也不过是修改的是副本，不会影响到原始的names。
关键字参数
关键字参数让你可以不用考虑函数的参数位置，你需以键值对的形式指定参数的对应形参。
def welcome(name,address):
print(f"你好 {name} , 欢迎来到 {address} !")
welcome(address='上海',name='小强')
打印结果：
你好 小强 , 欢迎来到 上海 !
收集参数
有时候我们需要允许用户提供任意数量的参数，函数的形参可以带个星号来接收，不管调用函数的时候传递了多少实参，都将被收集到形参这个变量当中，形参的类型是元组。
def welcome(*names):
print(names)
welcome('小明','小强','小红','小黑')
打印结果：
('小明', '小强', '小红', '小黑')
还有一种是带两个星号的形参，用于接收键值对形式的实参，导入到函数中的类型是字典。
def welcome(**names):
print(names)
welcome(name='小明',age=18,sex='男')
打印结果：
{'name': '小明', 'age': 18, 'sex': '男'}
分配参数
分配参数是收集参数的相反操作，可使得一个元组或字典变量自动分配给函数中的形参。
def welcome(name,address):
print(f"你好 {name} , 欢迎来到 {address} !")
a = ('小红','山东')
welcome(*a)
打印结果：
你好 小红 , 欢迎来到 山东 !
我们改成字典的方式：
def welcome(name,address):
print(f"你好 {name} , 欢迎来到 {address} !")
a = {'address':'山东','name':'小红'}
welcome(**a)
打印结果：
你好 小红 , 欢迎来到 山东 !
函数的返回值
首先说明，所有的函数都是有返回值的，如果编程人员没有指定返回值，那么默认会返回None，对标其他语言中的null。
一个简单的函数返回值的例子：
def get_full_name(first_name,last_name):
return first_name + last_name
r = get_full_name('王','大锤')
print(r)
打印结果：
王大锤
然而python中的函数还可以返回多个值，返回出的值被装载到元组中：
def func(num):
return num**2,num**3,num**4
result = func(2)
print(result)
打印结果：
(4, 8, 16)
在python中函数定义的时候没有返回值的签名，导致我们无法提前知道函数的返回值是什么类型，返回的什么完全看函数中的return的是什么，特别是逻辑代码比较多的函数，比如里面有多个if判断，有可能这个判断return出来的是布尔值，另一个判断return出来的是列表，还一个判断啥也不return，你调用的时候你都搞不清楚该怎么处理这个函数的返回值，在这一点来说，Java完胜。
所以在无规则限制的情况下，代码写的健不健壮，好不好用，主要取决于编程人员的素质。
匿名函数
匿名函数就是不用走正常函数定义的流程，可以直接定义一个简单的函数并把函数本身赋值给一个变量，使得这个变量可以像函数一样被调用，在python中可以用lambda关键字来申明定义一个匿名函数。
我们把王大锤的例子改一下：
get_full_name = lambda first_name,last_name : first_name + last_name
r = get_full_name('王','大锤')
print(r)
打印结果：
王大锤
函数的作用域
访问全局作用域
python每调用一个函数，都会创建一个新命名空间，也就是局部命名空间，函数中的变量就叫做局部变量，与外部的全局命名空间不会相互干扰。
这是常规状态，当然也会有非常规需求的时候，所以python给我们提供了globals()函数，让我们可以在局部作用域中访问到全局的变量。
def func():
a = globals()
print(a['name'])
name = '小明'
func()
打印结果：
小明
globals()函数只能让我们访问到全局变量，但是是无法进行修改的，如果我们要修改全局变量，需要用到global关键字将全局变量引入进来。
def func():
global name
name = '小花'
name = '小明'
func()
print(name)
打印结果：
小花
访问嵌套作用域
对于嵌套函数的情况，如果想要使用嵌套作用域（非全局作用域）的变量，就需要用到nonlocal关键字。
def welcome(name):
def go():
nonlocal name
name = '我变成小花了'
go()
print(name)
my_name = '小明'
welcome(my_name)
print(my_name)
打印结果：
我变成小花了
小明
函数与模块
导入模块
模块的官方定义是包含函数和变量的python文件就叫做模块，然而你照着这个定义去看，你会发现只要是.py的文件，其实都符合模块的定义。
我新建一个user.py文件 他也叫做user模块 里面写两个函数
def get_name():
print('我的名字是小明')
def get_age():
print('我今年11岁了')
然后我用import导入这个user模块 并调用模块中的函数
import user user.get_name()
打印结果：
我的名字是小明
这个用处相当于公共函数的封装，当然了，我们面向对象的做法一般都是封装到类里面。
为了防止模块名字被当前程序的变量覆盖，你可以选择导入的时候用as指定别名：
import user as model_user model_user.get_name()
打印结果：
我的名字是小明
导入函数
还是拿上面user模块来做例子 我现在只导入其中某个函数
from user import get_name get_name()
打印结果：
我的名字是小明
from ... import ... 的意思就是 从...中获取...，从user模块中获取get_name函数。
导入模块中所有函数
通配符星号表示导入所有函数，只是这种做法，有大几率出现函数被覆盖的风险
from user import * get_name() get_age()
打印结果：
我的名字是小明
我今年11岁了