共计 7069 个字符,预计需要花费 18 分钟才能阅读完成。
1 函数的创立和调用
1.1 函数创立
- 创立函数即定义函数
- 应用关键字 def 实现
- 语法:
def fname([pname]):
["comm"]
[fuc]
- 阐明:
def:定义函数的,固定写法
fname:函数名
pname:参数,可选,指定向函数中传入的参数,若有多个的话,参数之间用逗号隔开
comm:可选,函数的正文,即阐明函数的性能、传递的参数,晋升代码可浏览性
fuc:函数体,可选,具体的函数性能,如有返回值,应用 return()
comm 和 fuc 必须要进行缩进显示
如果想定义空函数,函数体间接用 pass 作占位符即可
# -*- coding:utf-8 -*-
import random
def 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 random
def 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
out = mgame(2) # 调用函数,因为这个函数定义了有返回值,所以调用函数后,并且把后果给 out 变量;因为函数定义的时候有一个参数 num,所以调用的时候给了一个传入参数 2
print(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)
④依据实参的类型不同,可将实参的传递分为【值转递】和【援用传递】,这里当然是把实参传递给形参了,怎么辨别这两个概念呢?
A、当实参为不可变对象时,为值传递;
B、当实参为可变对象时,为援用传递;
C、本质区别为:值传递后,不会扭转形参的值,实参的值也不变;援用传递后,扭转形参的值,实参的值也扭转。
**********************************
有点感觉了,貌似了解了!不过,还是不太分明!
*********************************
⑤再举个例子:
# -*- 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 -*-
# 也就是说 在调用函数时,指定的实参数量与形参数量统一,否则会抛出异样 TypeError
def test(num1, num2):
sum = 0
sum = num1 + num2
print(sum)
test(1, 2)
test(2) # 这个会抛出异样,因为参数数量不统一
后果:
3
Traceback (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 或者不抛异样,然而程序存在 bug
def person(name, age, height):
print(name, age, height)
person("小张", 18, 170)
# 地位换一下,如果类型不一样,尽管后果没有抛出异样,然而名字是 18,年龄是小张,如同不适合,有 bug
person(18, "小张", 170)
后果:
小张 18 170
18 小张 170
2.3 关键字参数
- 即应用形参的名字来确定输出的参数值
- 此形式指定实参时,毋庸与形参的地位完全一致,只需将参数名写正确即可
# -*- coding:utf-8 -*-
def person(name, age, height):
print(name, age, height)
person(height=170, name="小张", age=18)
后果:
小张 18 170
2.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
请输出以下名称中的任意一个, 请输出: 隔壁老王
隔壁老王 的英文名为:gblw
4 变量的作用域
- 即程序代码可能拜访该变量的区域
- 依据变量的”无效范畴“,将变量分为 局部变量 和 全局变量
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 defined
4.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_one
speak()
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 计算两个数之和 ======
300
6 罕用 python 内置函数
- python 内置,间接调用应用即可
python3.7 中 69 个内置函数,点击此处查看