1.函数的引入
如果现在有一个需求需要实现用户登录注册的功能，我们该怎么实现呢？
def register():
"""注册功能"""
count = 0
while count < 3:
username_inp = input('请输入你的用户名:')
pwd_inp = input('请输入你的密码:')
re_pwd_inp = input('请在此输入你的密码:')
if not pwd_inp == re_pwd_inp:
print('两次密码输入不一致')
count += 1
continue
with open('user_info.txt', 'a', encoding='utf8') as fa:
fa.write(f'{username_inp}:{pwd_inp}
') # :表示用户名和密码的分割;|用户和用户之间的分割
fa.flush()
break
def login():
"""登录功能"""
# 登录
username_inp = input('请输入你的用户名:')
pwd_inp = input('请输入你的密码:')
with open('user_info.txt', 'r', encoding='utf8') as fr:
for user_info in fr:
username, pwd = user_info.split(':')
if username.strip() == username_inp and pwd.strip() == pwd_inp: # strip可以去掉两端的换行符
print('登录成功')
break
# else:
# continue # continue一般不写在最后一行
else:
print('登录失败')
# register()
# login()
函数不会改变某一个功能的代码，它只做了一件事情--》封装（接口），只会让你的代码更加简洁而已.(写入计算机)
def caculator():
num1 = input('请输入一个数字')
num1 = int(num1)
sig = input('请输入一个符号')
num2 = input('请输入另一个数字')
num2 = int(num2)
if sig == '-':
print(num1 - num2)
elif sig == '+':
print(num1 + num2)
elif sig == '*':
print(num1 * num2)
elif sig == '/':
print(num1 / num2)
else:
print('傻逼，我不认识')
caculator()
2.函数的定义
函数：表示一种工具。
定义函数：实用工具之前 --》 必须得造一个工具。
函数的定义功能 : 包裹一部分代码,实现某一个功能,达成某一个目的
函数的基本格式：
# 函数的定义
def 函数名（等同于变量名）():
# """对函数（工具）的描述信息"""
# 代码块
def 函数名():
"""描述的信息"""
code1..
code2..
# 函数的调用
函数名()
def guess():
"""给定两个数，打印较大的数"""
x = 30
y = 20
if x > y:
print(x)
else:
#函数定义的特性: 函数定义过程，只检测语法，不执行代码。
# 函数的定义处
def func():
print(123)
# 函数的调用处
func() # 调用阶段，会执行代码
函数的定义：和函数的调用。
# 函数的定义
#def 函数名（等同于变量名）():
# """对函数（工具）的描述信息"""
# 代码块
def chengfabiao():
"""描述的信息"""
for i in range(1, 10):
for j in range(1, i + 1):
print("%d*%d=%2d " % (i, j, i * j), end="")
print()
# 函数的调用
chengfabiao()
chengfabiao()
chengfabiao()
#结果：
1*1= 1
2*1= 2 2*2= 4
3*1= 3 3*2= 6 3*3= 9
4*1= 4 4*2= 8 4*3=12 4*4=16
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
# ### 水平翻转乘法表
# 函数的定义处
def chengfabiao_99():
for i in range(1, 10):
# 循环空格
for k in range(9 - i, 0, -1): # 8 ~ 1
print(" ", end="")
# 循环表达式
for j in range(1, i + 1):
print("%d*%d=%2d " % (i, j, i * j), end="")
print()
# 函数的调用处
chengfabiao_99()
# 要打印10次
for i in range(10):
# 函数的调用处
chengfabiao_99()
#结果: 1*1= 1
2*1= 2 2*2= 4
3*1= 3 3*2= 6 3*3= 9
4*1= 4 4*2= 8 4*3=12 4*4=16
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
3.定义的三种形式。
3.1无参函数：
定义函数时参数是函数体接收外部传值的一种媒介，其实就是一个变量名
在函数阶段括号内没有参数，称为无参函数。需要注意的是：定义时无参，意味着调用时也无需传入参数。
如果函数体代码逻辑不需要依赖外部传入的值，必须得定义成无参函数。
def func():
print('hello oldboy')
func() # hello oldboy
3.2有参函数
在函数定义阶段括号内有参数，称为有参函数。需要注意的是：定义时有参，意味着调用时也必须传入参数。
如果函数体代码逻辑需要依赖外部传入的值，必须得定义成有参函数。
def sum_self(x, y):
"""求和"""
res = x+y
print(res)
sum_self(1,2) # 3
3.3空函数
当你只知道你需要实现某个功能，但不知道该如何用代码实现时，你可以暂时写个空函数，然后先实现其他的功能。
空函数 待输入
def func():
pass
def register():
pass
def login():
pass
4.函数的调用。
4.1什么是函数调用？
第一次讲函数其实就讲了函数的调用，但是你不得不再次更新你对函数调用的对象。
函数名（...）即调用函数，会执行函数体代码，直到碰到return或者执行完函数体内所有代码结束。
函数运行完毕所有代码，如果函数体不写return，则会返回None。
def func()
pass
print(func())
4.2为何用调用函数
使用函数的功能。
4.3 函数调用的三种形式
def max_self(w,q):
if w>q:
return w
else:
return q
# 1.
max_self(1,2)
# 2.
res = max_self(1,2)*12
# 3.
max_self(max_self(20000,30000),40000)
5.函数的返回值。
# return的特性：
# 1. return 返回一个返回值，如果没有返回值，返回None
# 2. 没有return 默认返回None
# 3. return 会终止函数，不运行下面的代码，假设有多个return的时候，运行到第一个就会结束，不会运行第二个
# 4. return 通过逗号隔开，可以返回多个值，返回值以元组的形式接收
. 0个 ： 返回None
。 1个 ： 返回值是该值本身。
。 多个：返回值是元素。
什么是返回值：函数内部代码经过一些列逻辑处理获得的结果。
def = func():
name = "liangjing"
resurn name
name = func()
print(name) #liangjing
为什么要返回值？
#为什么要返回值。
def shu (count_w,total_q):
if count_w > total_q:
return (count_w)
else:
return (total_q)
shuzhi = shu(123,150)
print(shuzhi*2) #300
# 函数返回多个值
def func():
name = "liangjing"
age = 20
hobby_list = ["听歌","睡觉","购物"]
return name ,age , hobby_list
name,age,hobby_list = func()
print(f"name,age,hobby_list:{name,age,hobby_list}")
6.函数的参数
一 .形参和实参
6.1 形参：
在函数定义阶段括号内定义的参数，称之为形式参数，简称形参，本质就是变量名。
def func(x, y):
print(x)
print(y)
二 实参
在函数调用阶段括号内传入的参数，称之为实际参数，简称实参，本质就是变量的值。
func(1, 2)
6.2 .位置参数
在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。
def func(x, y):
print(x)
print(y)
特点：按照位置定义的形参，都必须被传值，多一个不行，少一个也不行。
6.3 位置实参
在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参。
func(1, 2)
三 .默认形参
在定义阶段，就已经被赋值。
def func(x, y=10):
print(x)
print(y)
func(2)
特点：在定义阶段就已经被赋值，意味着在调用时可以不用为其赋值。
注意：
位置形参必须放在默认形参的左边。
默认形参的值只在定义阶段赋值一次，也就是说默认参数的值在函数定义阶段就已经固定了。
m = 10
def foo(x=m):
print(x)
m = 111
foo() # 10
默认参数的值通常应该是不可变类型。
# 演示形参是可变类型
def register(name, hobby, hobby_list=[]):
hobby_list.append(hobby)
print(f"{name} prefer {hobby}'")
print(f"{name} prefer {hobby_list}")
register('nick', 'read')
register('tank', 'zuipao')
register('jason', 'piao')
nick prefer read'
nick prefer ['read']
tank prefer zuipao'
tank prefer ['read', 'zuipao']
jason prefer piao'
jason prefer ['read', 'zuipao', 'piao']
# 修改形参是可变类型代码
def register(name, hobby, hobby_list=None):
if hobby_list is None:
hobby_list = []
hobby_list.append(hobby)
print(f"{name} prefer {hobby}'")
print(f"{name} prefer {hobby_list}")
register('nick', 'read')
register('tank', 'zuipao')
register('jason', 'piao')
nick prefer read'
nick prefer ['read']
tank prefer zuipao'
tank prefer ['zuipao']
jason prefer piao'
jason prefer ['piao']
6.4普通形参(位置)
# 函数的定义处 hang , lie 是普通形参,在函数的定义处
def small_star(hang,lie):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处 => 形参实参 一 一 匹配
small_star(10,10) # 十行十列
small_star(8,80) # 八行八十列
# 注：普通形参 必须放到 默认形参 的前面
6.5 默认形参 在一开始的时候就赋予默认值，在调用没给实参时，使用参数默认值
"""
如果没有给实际参数,使用自己的默认值
如果给与实际参数,使用实际值
"""
def small_star(hang=10,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
small_star()
small_star(5,9) # 5 9实际参数
print("<=====>")
# 3被hang收走了,lie使用了默认值 10，形参实参一一匹配
small_star(3) # 3 实际参数
6.6普通收集参数
'''
在参数的前面加上一个星星，这样的参数叫做普通收集参数
作用:专门用来收集那些，多余的没人要的 普通实参（即 实参 多余 形参 的普通实参部分，打包成一个 元组）
普通收集参数:
def func(*args):
pass
'''
# 函数的定义处
def func(a,b,c,d,*args):
print(a,b,c,d) # 1 2 3 4
print(args) # (5, 6, 7) 元组
# 函数的调用处
func(1,2,3,4,5,6,7)
关键字收集参数
'''
在参数的前面加上二个星星,这样的参数叫做关键字收集参数
作用:专门用来收集那些,多余的没人要的 关键字实参（即 实参 多余 形参 的关键字实参部分，打包成一个 字典）
关键字收集参数：
def func(**kwargs):
pass
'''
# 函数的定义处
def func(a,b,c,**kwargs):
print(a,b,c)
print(kwargs)
# 函数的调用处
func(1,2,3,dd=4,ff=5,zz=6) # kwargs = {'dd': 4, 'ff': 5, 'zz': 6}
func(a=1,b=2,c=3,pp=90) # kwargs = {'pp': 90}
6.7关键实参
普通实参
- 普通实参 必须放到 关键字实参 前面
"""
(1) 关键字实参在进行调用时,顺序可以任意
(2) 如果定义时是普通形参，调用时用的关键字实参，那么这个形参后面的所有参数都必须使用关键字实参；
因为普通形参 必须放到 默认形参的前面，而且要一一匹配，所以后面必须跟关键字实参
"""
def small_start(hang,a,b,c,lie = 10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
# 关键字实参
# small_start(hang=3,lie=8)
# small_start(lie=8,hang=3)
# small_start(hang = 3,a=4,b=5,c=6)
small_start(lie=90,b=5,a=4,hang = 3,c=6)
区分默认形参和关键字实参：
"""
总结:
默认形参 和 关键字实参 在写法上一模一样
只不过，一个是在函数的定义处，一个是在函数的调用处;
"""
6.8 总结
实参的应用：取决于个人习惯
形参的应用：
大多数情况的调用值一样，就应该将该参数定义成位置形参
大多数情况的调用值一样，就应该将该参数定义成默认形参
7.可变长参数
-
和 ** 的魔术用法
""" 在函数的定义处，*和**用来接收打包，* 打包成一个 元组， ** 会打包成一个 字典 在函数的调用处，*和**用来解包，*应用在列表或者元组，**应用在 字典 """ -
def func(a,b,*,c,d):
print(a,b)
print(c,d)
lst = [10,11]
''' *lst 相当于把列表中的每一个元素单独拿出来,扔到参数中进行赋值;'''
func(*lst,c=12,d=13) # func(10,11,c=12,d=13)
-
**
def func(a,b,*,c,d): print(a,b) print(c,d) dic = {"c":12,"d":13} ''' **dic 相当于把字典当中每一个元素变成 c=12,d=13 的形式传入关键字实参 ''' func(10,11,**dic) #func(10,11,c=12,d=13) -
终极形态
func(*lst,**dic) # 用于解包容器类型数据，然后将解包后的数据传入实参处，要与形参一一匹配 def func(*args,**kwargs): # 可以收到所有的参数，用在形参处
return 返回值
"""
可以自定义函数的返回值；return 是把这个值 返回到函数的调用处（打印此函数才能得到返回值）
(1) return 返回值 后面除了可以接6大标准数据类型之外,还可以返回函数和类对象,如果不定义返回值,默认返回None
(2) 在函数中,如果执行了return 返回值,意味着函数立刻终止,后面的代码不执行
"""
# return的作用：将函数执行结果返回给调用处程序，然后可以用来保存进行再计算等。return 旨在立即中断控制流并退出当前函数，将指定值返回给调用函数的调用者
- 可以返回的类型 6大标准数据类型 / 函数和类对象
# 函数的定义处
def func():
# return 19
# return 8.19
# return True
# pass
# return 6+7j
# return "你好"
# return [1,2,3]
return {"a":1,"b":2}
# 函数的调用处
res = func() # 此时函数func()已调用
print(res)
- 遇到 return 后，意味着函数终止，后面的代码不再执行
# 模拟一个计算器 + - * /
def calc(sign,num1,num2):
if sign == "+":
res = num1+num2
elif sign == "-":
res = num1 - num2
elif sign == "*":
res = num1 * num2
elif sign == "/":
if num2 == 0:
return "除数不能为0"
res = num1 / num2
else:
return "对不起,这个我不会算!"
# print(res)
return res
res = calc("/",10,20)
print(res) # 打印该函数的返回值