1 函数的创立和调用
1.1 函数创立
- 创立函数即定义函数
- 应用关键字def实现
- 语法：
def fname([pname]): ["comm"] [fuc]- 阐明：
def：定义函数的，固定写法
fname：函数名
pname：参数，可选，指定向函数中传入的参数，若有多个的话，参数之间用逗号隔开
comm：可选，函数的正文，即阐明函数的性能、传递的参数，晋升代码可浏览性
fuc：函数体，可选，具体的函数性能，如有返回值，应用return()
comm和fuc必须要进行缩进显示
如果想定义空函数，函数体间接用pass作占位符即可
# -*- coding:utf-8 -*-import randomdef mgame(num): """ 模仿石头剪刀布游戏： :param num: 输出一个0-2之间的任意一个整数(0:石头、1：剪刀、2：布) :return: 返回输出的num以及计算机随机给的数值 """ computernum = random.randint(0, 2) if num == computernum: print("平局！") elif num == 0 and computernum == 1 or num == 1 and computernum == 2 or num == 2 and computernum == 0: print("我赢了！") else: print("计算机赢了") return num, computernum后果：
D:\Python37\python.exe F:/python_study/main.py过程已完结，退出代码 0运行上边的代码，不显示任何内容，也不会抛出异样，因为函数没有调用！！！
1.2 函数调用
- 函数调用即执行函数
- 简略了解一下：函数就是实现某种性能或者用处的工具，而调用函数就是应用这个工具
- 语法：
fname([pname])- 阐明：
fname：函数名
panme：参数，依据函数的定义来确定传入参数的类型以及是否传入参数
# -*- coding:utf-8 -*-import randomdef mgame(num): """ 模仿石头剪刀布游戏： :param num: 输出一个0-2之间的任意一个整数(0:石头、1：剪刀、2：布) :return: 返回输出的num以及计算机随机给的数值 """ computernum = random.randint(0, 2) if num == computernum: print("平局！") elif num == 0 and computernum == 1 or num == 1 and computernum == 2 or num == 2 and computernum == 0: print("我赢了！") else: print("计算机赢了") return num, computernumout = mgame(2) # 调用函数，因为这个函数定义了有返回值，所以调用函数后，并且把后果给out变量；因为函数定义的时候有一个参数num，所以调用的时候给了一个传入参数2print(out) # 使出变量out的值后果：
# 每次后果可能不一样，因为计算机是随机给的值，我这里运行了好几次，取了几个后果如下：计算机赢了(2, 1)我赢了！(2, 0)平局！(2, 2)1.3 pass空语句
- pass语句示意空语句，不做任何事件，个别起到占位符的作用
- 怎么用呢？比方咱们写一个函数，临时不确定他的性能，能够应用pass来填充，通知他人当前我会加上的，哈哈
def fname(): pass- 在python中上边的pass能够应用三个间断的点来代替
def fname(): ...2 参数传递
如【1.2 函数调用】中的函数pname就是参数，然而参数也有两个：理论参数(实参)和形式参数(形参)
2.1 形式参数和理论参数
如何了解两个的区别？
- 通过作用了解
① 就是通过她两的作用来定的，书本上是这么说的 ” 在定义函数时，函数名后边括号中的参数为【形式参数】，称形参；在调用函数时，函数名后边括号中的参数为【理论参数】，称实参“.......
②说实话上一句话，真没有了解！！！
③举个例子：
# 定义和创立函数的时候，这里的num就是形式参数def test(num): print(num)# 调用函数，此时的函数参数5，(11, 22, 33 44)就是理论参数test(5)test((11, 22, 33, 44))后果：
5(11, 22, 33, 44)④依据实参的类型不同，可将实参的传递分为 【值转递】 和 【援用传递】，这里当然是把实参传递给形参了，怎么辨别这两个概念呢？
Ａ、当实参为不可变对象时，为值传递；
Ｂ、当实参为可变对象时，为援用传递；
Ｃ、本质区别为：值传递后，不会扭转形参的值，实参的值也不变；援用传递后，扭转形参的值，实参的值也扭转。
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
有点感觉了，貌似了解了！不过，还是不太分明！
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
⑤再举个例子：
# -*- coding:utf-8 -*-def test(name): print("原来的值：", name) name += name# 调用函数print("=======1、开始进行值传递======")mtr = "咱们都有一个幻想，那就是明年不止挣一个亿！"print("调用前：", mtr)test(mtr)print("调用后：", mtr)print("=======2、开始进行援用传递======")mlist = ["1个亿", "2个亿", "3个亿"]print("调用前：", mlist)test(mlist)print("调用后：", mlist)后果：
=======1、开始进行值传递======调用前： 咱们都有一个幻想，那就是明年不止挣一个亿！原来的值： 咱们都有一个幻想，那就是明年不止挣一个亿！调用后： 咱们都有一个幻想，那就是明年不止挣一个亿！=======2、开始进行援用传递======调用前： ['1个亿', '2个亿', '3个亿']原来的值： ['1个亿', '2个亿', '3个亿']调用后： ['1个亿', '2个亿', '3个亿', '1个亿', '2个亿', '3个亿']- 应用一个比喻来了解
函数定义时参数列表的参数就是形参，而函数调用时传递进来的参数就是实参，比方就像：
剧本中的角色就是形参，而演角色的演员就是实参。＝＝＝＝这句话，不是我说的，起源课本！！
2.2 地位参数
- 即必备参数，必须依照正确的程序传到函数中
- 即调用时的数量和地位必须和定义时时一样的
①数量必须与定义时统一
# -*- coding:utf-8 -*-# 也就是说 在调用函数时，指定的实参数量与形参数量统一，否则会抛出异样TypeErrordef test(num1, num2): sum = 0 sum = num1 + num2 print(sum)test(1, 2)test(2) # 这个会抛出异样，因为参数数量不统一后果：
3Traceback (most recent call last): File "F:/python_study/main.py", line 12, in <module> test(2)TypeError: test() missing 1 required positional argument: 'num2'②地位必须与定义时统一
# -*- coding:utf-8 -*-# 也就是说 在调用函数时，指定的实参地位与形参地位统一，否则会抛出异样TypeError或者不抛异样，然而程序存在bugdef person(name, age, height): print(name, age, height)person("小张", 18, 170)# 地位换一下，如果类型不一样，尽管后果没有抛出异样，然而名字是18，年龄是小张，如同不适合，有bugperson(18, "小张", 170)后果：
小张 18 17018 小张 1702.3 关键字参数
- 即应用形参的名字来确定输出的参数值
- 此形式指定实参时，毋庸与形参的地位完全一致，只需将参数名写正确即可
# -*- coding:utf-8 -*-def person(name, age, height): print(name, age, height)person(height=170, name="小张", age=18)后果：
小张 18 1702.4 为参数设置默认值
- 即定义函数时，间接指定形式参数的默认值
- 当没有传入参数时间接应用默认值
- 语法：
def fname(pname=defaultname): [func]- 阐明：
fname：函数名称
pname：参数，可选
defaultname：参数pname的默认值
func：函数体
# -*- coding:utf-8 -*-def person(name="小张"): print(name)person() # 没有传参，应用默认值person("小李") # 传参了，应用传入的值后果：
小张小李- 可应用" 函数名.__ defaults__"来查看函数的默认值参数的以后值，后果为元组
# -*- coding:utf-8 -*-def person(name="小张", age=18, height=172): print(name)person() # 没有传参，应用默认值person("小李") # 传参了，应用传入的值print(person.__defaults__) # 查看函数参数的默认值后果：
小张小李('小张', 18, 172)2.5 可变参数
- 即不定长参数
- 即传入函数中的实参可为0个，1个，两个以及任意个
- 定义可变参数的模式有两种：parameter 和 *parameter
① *parameter： 示意接管任意多个实参并将其放到元组中
# -*- coding:utf-8 -*-def person(*name): print(name) for item in name: print(item)person("小张", "小李", "老王", "隔壁老王") # 字符串间接写person(*["小张", "小李", "老王", "隔壁老王"]) # 如果传入的可变参数时列表，须要在列表前加*号后果：
('小张', '小李', '老王', '隔壁老王')小张小李老王隔壁老王('小张', '小李', '老王', '隔壁老王')小张小李老王隔壁老王② **parameter：示意接管任意多个显示赋值的实参，并将其放到一个字典中
# -*- coding:utf-8 -*-def person(**name): print(name) for key, value in name.items(): print(""+key+"的英文名为：", value)person(小张="xiaozhang", 小李="xiaoli", 老王="laowang", 隔壁老王="gblw")后果：
{'小张': 'xiaozhang', '小李': 'xiaoli', '老王': 'laowang', '隔壁老王': 'gblw'}小张的英文名为： xiaozhang小李的英文名为： xiaoli老王的英文名为： laowang隔壁老王的英文名为： gblw到这一步，感觉能够歇歇了
3 返回值
- 应用return语句为函数指定返回值
- 无论return在什么地位，执行到return后，就会完结函数的执行
# -*- coding:utf-8 -*-def name_to_xname(name): xname = "" if name == "小张": xname = "xiaozhang" elif name == "老王": xname = "laowang" elif name == "老李": xname = "laoli" elif name == "隔壁老王": xname = "gblw" else: print("输出的名字不存在，请从新输出以下内容中的一个：", ["小张", "老王", "老李", "隔壁老王"]) return(xname)while True: name = input("请输出以下名称中的任意一个,请输出:") xname = name_to_xname(name) print("{} 的英文名为：{}".format(name, xname))后果：
请输出以下名称中的任意一个,请输出:小李输出的名字不存在，请从新输出以下内容中的一个： ['小张', '老王', '老李', '隔壁老王']小李 的英文名为：请输出以下名称中的任意一个,请输出:小张小张 的英文名为：xiaozhang请输出以下名称中的任意一个,请输出:老王老王 的英文名为：laowang请输出以下名称中的任意一个,请输出:老李老李 的英文名为：laoli请输出以下名称中的任意一个,请输出:隔壁老王隔壁老王 的英文名为：gblw4 变量的作用域
- 即程序代码可能拜访该变量的区域
- 依据变量的”无效范畴“，将变量分为 局部变量 和 全局变量
4.1 局部变量
- 即在函数外部定义并应用的变量，只在函数内无效
# -*- coding:utf-8 -*-def love(): love_to_you = "如果入地能再给我一次机会，我将对那个...(此处略去一万字！)" print("我是局部变量:", love_to_you) # 打印这个局部变量love()print("这里打印会报错：", love_to_you) # 如果在函数以外来打印这个局部变量就会报错后果：
我是局部变量: 如果入地能再给我一次机会，我将对那个...(此处略去一万字！)Traceback (most recent call last): File "F:/python_study/main.py", line 8, in <module> print("这里打印会报错：", love_to_you) # 如果在函数以外来打印这个局部变量就会报错NameError: name 'love_to_you' is not defined4.2 全局变量
- 即可能作用于函数内外的变量，有以下两种状况：
①变量在函数外定义，此变量可在函数外和函数内都可被拜访到，即在函数体外定义的变量为全局变量
# -*- coding:utf-8 -*-love_to_you = "已经有一份真挚的恋情摆在我的背后，可是我没有珍惜，如果..."love_recive = "没有如果，你活该，早知当初，何必当初！！"love_to = "说实话，省略号后的内容，我是遗记怎么说了，哈哈哈"def love(): print("我是全局变量1:", love_to_you) # 打印这个全副变量def love_add(): love_to_you_add = love_to_you + love_recive print("我是全局变量2:", love_to_you_add)love()love_add()print("我是全局变量3:", love_to)后果：
我是全局变量1: 已经有一份真挚的恋情摆在我的背后，可是我没有珍惜，如果...我是全局变量2: 已经有一份真挚的恋情摆在我的背后，可是我没有珍惜，如果...没有如果，你活该，早知当初，何必当初！！我是全局变量3: 说实话，省略号后的内容，我是遗记怎么说了，哈哈哈②在函数体内定义，应用关键字global润饰后的变量为全局变量，可在函数外调用，函数体内批改
# -*- coding:utf-8 -*-def speak(): global speak_to_all speak_to_all = "他大舅他二舅都是他舅，" print("全局变量1：", speak_to_all)def speaks(): global speak_to_one speak_to_one = "高桌子低板头都是木头" print("全局变量2：", speak_to_one)def speakss(): global speak_to speak_to = speak_to_all + speak_to_onespeak()speaks()speakss()print("间接在内部调用全局变量1：", speak_to_all)print("间接在内部调用全局变量2：", speak_to_one)print("间接在内部调用全局变量3：", speak_to)后果：
全局变量1： 他大舅他二舅都是他舅，全局变量2： 高桌子低板头都是木头间接在内部调用全局变量1： 他大舅他二舅都是他舅，间接在内部调用全局变量2： 高桌子低板头都是木头间接在内部调用全局变量3： 他大舅他二舅都是他舅，高桌子低板头都是木头5 匿名函数
- 即没有名字的函数
- 利用在须要一个函数、但又不想去命名这个函数的场合
- 个别，这样的函数只会应用一次
- 可应用lambda表达式创立匿名函数
- 语法：
result = lambda[arg1[,arg2,......,argn]]:exp- 阐明：
result ：调用lambda表达式
[arg1[,arg2,......,argn]]：可选参数，指定要传递的参数列表，多参数间用逗号隔开
exp：必选参数，用于实现具体性能的表达式
# -*- coding:utf-8 -*-def nsum(a, b): sums = a + b print(sums)def lsum(c, d): lsum = lambda c,d:(c+d) print(lsum(c, d))print("======一般办法计算两个数之和======")nsum(100, 200)print("======lambda计算两个数之和======")lsum(100, 200)后果：
======一般办法计算两个数之和======300======lambda计算两个数之和======3006 罕用python内置函数
- python内置，间接调用应用即可
python3.7中69个内置函数，点击此处查看