python基础之函数v1

Posted 为了等

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python基础之函数v1相关的知识,希望对你有一定的参考价值。

Python基础之函数

1:函数

一:什么是函数

函数就是对某一个功能的代码,进行打包。类似于一修车师傅有工具箱一样,需要用什么工具直接拿来用就行。

二:为什么要有函数

当需要重复的用一些功能的时候,就可以直接调用,不用再复制粘贴

三:函数的分类

三.一:内置函数
print,id,map,filter...都是内置函数,你只需要怎么用就行。。。
三.二:自定义函数
就是你需要用什么功能,都是需要自己造

四:使用函数的优点

1,代码逻辑清晰,可读性好
2,不用写重复的代码
3,后面扩展容易,管理方便

2:函数的定义

一:如何定义函数

#语法
def 函数名(参数1,参数2,参数3,...):
    ‘‘‘注释‘‘‘
    函数体
    return 返回的值

#函数名要能反映其意义
def login():
	name = input(‘请输入你的用户名:‘)
	pwd = input("请输入的密码:")
	if name == ‘alex‘ and pwd = ‘alexdsb‘:
		print(‘登录成功‘)
	else:
		print("登录失败!")

#上述代码定义函数

二:函数的使用(先定义,后调用)

# 函数与变量的定义也差多,变量名如果不定义,调用变量就睡报错,函数名其实可以理解为变量名,不定义调用就报错

def login():
	name = input(‘请输入你的用户名:‘)
	pwd = input("请输入的密码:")
	if name == ‘alex‘ and pwd = ‘alexdsb‘:
		print(‘登录成功‘)
	else:
		print("登录失败!")

login() # 这就是调用函数

测试一

def f1():
	print(‘from f1‘)
	f2()

f1()	

测试二

def f2():
	print(‘from f2‘)
	f1()

def f1():
	print(‘from f1‘)
	
f2()

测试三

def f1():
	print(‘from f1‘)
	f2()
i
def f2():
	print("from f2")

f1()

结果

测试一报错
测试二和测试三正常
结论:函数的使用,必须先要定义,后调用。
使用函数时,一定要明确区分定义阶段和调用阶段

三:函数定义解释器做了什么?

#只检测语法,不执行代码
也就说,语法错误在函数定义阶段就会检测出来,而代码的逻辑错误只有在执行时才会知道

四:函数定义的三种形式

一:无参
应用场景仅仅只是执行一些操作,比如与用户交互,打印
def foo():
	print(‘foo‘)
二:有参
需要根据外部传进来的参数,才能执行相应的逻辑,比如统计长度,求最大值最小值
def max_(arg1, arg2):
    ‘‘‘
    参数必须是int类型
    ‘‘‘
	if arg1 > arg2:
		print(arg1)
	else:
		print(arg2)
三:空函数
设计代码结构
def login():
	pass
	
def registry():
	pass
    
........        

3:调用函数

一:调用函数

函数的调用:函数名加括号
1 先找到名字
2 根据名字调用代码
def foo():
	print("foo")
	
foo() # 这就是调用函数	

二:函数返回值

一般没有定义返回值,函数默认的返回值为None

返回值要用关键字return
return 可以返回单个值,或者多个值(多个值是以元组的形式放回)
# 默认
def foo():
	print(‘foo‘)
	
# 一个值
def foo():
	print(‘foo‘)
	return ‘foo‘

# 多个值
def foo():
	print(‘foo‘)
	return 0, 1, 2, ‘foo‘


三:函数调用的三种形式

一:语句形式

foo()

二:表达式形式

res = 3*len(‘helloword‘)
print(res)

三:函数作为另外一个函数的参数

res = max(max(1,30),3)
print(res)

4:函数的参数

一:形参与实参

形参即变量名,实参即变量值,函数调用时,将值绑定到变量名上,函数调用结束,解除绑定
def max_(arg1, arg2): # arg1与arg2是形参
    ‘‘‘
    参数必须是int类型
    ‘‘‘
	if arg1 > arg2:
		print(arg1)
	else:
		print(arg2)

res = max_(100,101)  # 100和101是实参      

二:参数分类

一:位置参数
1:位置形参
1、位置形参:按照从左到右的顺序依次定义形参
特点:必须被传值,多一个不行少一个也不行
def foo(x, y, z):
	print(x, y, z)
foo(1,2,3)
foo(1) # 报错

2:位置实参
2、位置实参:按照从左到右的顺序依次定义实参
特点:按照位置与形参一一对应

def bar(x,y):
	print(x,y)
	
bar(3,1)
bar(1,3)	
二:关键字实参
关键字实参:按照key=value的形式为指定的形参传值
特点:指名道姓为某个形参传值,可以完全打乱顺序

def foo(x,y):
	print(x,y)
	
foo(x=1,y=2)
foo(y=2,x=1)
foo(2,1)
/////////////////////////////////
def bar(x,y):
	print(x,y)

bar(1,2,x=101) # 报错
warning:关键字实参与位置实参可以混用,但是不能对同一个形参重复赋值
////////////////////////////////
def func(x,y):
	print(x,y)

func(x=1,3) # 报错
func(1,y=3)
func(y=3,1) # 报错
Warning:关键字实参必须放到位置实参右边
三:默认参数
默认参数:具有默认值的形参,指的是在定义函数阶段就已经为参数赋值,这意味着在调用函数阶段可以不用为默认参数传值

def  func(x,y=1111):
	print(x,y)

func(100)
func(100,101)

def func(y=111,x):
	print(x,y)
定义的时候就保错了
warning:位置形参必需在默认参数左边
/////////////////////////////

def func(name, names=[]):
    # name = "张三"
    # names=[]
    names.append(name)  # names=["张三"]
    print(names)


func("egon")
func("张三")
func("李四")
默认形参的值是在函数定义阶段就被固定的,如果调用没有为默认形参传值,那么不会每次调用都重新赋值

函数的调用彼此之间应该做到没有关联,所以说默认形参的通常应该是不可变类型

def func(name, names=None):
    if names is None:
        names = []
    names.append(name)  # names=["张三"]
    print(names)

func("egon")
func("张三")
func("李四")
四:可变长参数
一:可变长参数
可变长指的是在调用函数时,传入的实参个数不固定,而实参是为形参赋值的
所以对应着也应该有新的形参格式来负责接收不固定长度的实参
二:*args形参
def func(a,b,*args):
	print(a,b,args)

func(1,2) # 1 2 ()
func(1,3,4) # 1 2 (4,)
func(3,4,5,6) # 3 4 (5,6)
func() # 报错
*形参名:*会负责把溢出的位置实参存成元组然后赋值给后面的形参名,形参名通过应该是args
三:**kwargs形参
def bar(x,y,z=11,**kwargs):
	print(x,y,z,kwargs)

bar(1,2,a=1,c=2,d=3) #1 2 11 {‘a‘: 1, ‘c‘: 2, ‘d‘: 3}
**形参名:**会负责把溢出的关键字实参存成字典然后赋值给后面的形参名,形参名通过应该是kwargs

?

四:*args实参
def foo(x,y):
	print(x,y)

foo(*(2,3))
foo(*‘he‘)
foo(*[1,2])
foo(*{‘k1‘:1,‘K3‘:3})
foo(*(1,2,3)) # 报错 这个是因为打散以后有三个值,但是函数的位置形参只有两个,所以报语法错误 
warning实参中带*,*后跟的那个值应该是一个可以被for循环遍历的值。*会后面的那个值打散成位置实参(应该是可迭代数据类型)
五:**kwargs实参
def bar(x,y):
	print(x,y)

bar(**{‘k1‘:1,"k2":3})
bar(**{‘name‘:"alen",‘age‘:18})
bar(**{‘name‘:‘sb‘,‘gender‘:‘female‘})
实参中带**,**后跟的那个值应该是一个字典。**会后面的那个值打散成关键字实参


六:参数中混用*args,**kwargs
def foo(*args,**kwargs):
	print(args,kwargs)
	
foo(1,2,3,4,5,6,x=1,b=3,c=4,d=1)  # (1, 2, 3, 4, 5, 6) {‘x‘: 1, ‘b‘: 3, ‘c‘: 4, ‘d‘: 1}
foo(*[1,2,3,4,5],**{‘x‘:1,‘y‘:2}) # (1, 2, 3, 4, 5) {‘x‘: 1, ‘y‘: 2}
foo((1,2,3,4,5),{‘k2‘:1,‘k2‘:3})
/////////////////////////////

def inner(x,y):
	print(x,y)
	
def wrapper(*args,**kwargs):
	inner(args,kwargs)
	
wrapper(1,2) # (1,2) {}
wrapper(x=1,y=2) # () {‘x‘:1,‘y‘:2}
wrapper(1,y=2) # (1,) {‘y‘:2}
七:扩展
#5、命名关键字参数:*后定义的参数,必须被传值(有默认值的除外),且必须按照关键字实参的形式传递
可以保证,传入的参数中一定包含某些关键字
def foo(x,y,*args,a=1,b,**kwargs):
    print(x,y)
    print(args)
    print(a)
    print(b)
    print(kwargs)

foo(1,2,3,4,5,b=3,cc=4,dd=5)
结果:
    1
    2
    (3, 4, 5)
    1
    3
    {‘cc‘: 4, ‘dd‘: 5}

5:函数的进阶应用

引子

在python中函数是第一类对象,简称函数对象
函数对象指的就是可以把函数当做变量一样去使用
1:赋值
def bar():
	print(‘from bar‘)
print(bar)
f=bar
f()

2:可以当做参数传给另外一个函数
def func(aaa):
	print(aaaa)
	aaa()

def foo():
	print("from foo")

func(foo)

3:可以当做函数的返回值
def foo(aaa):
	return aaa

def bar():
	print(‘from bar‘)

res=foo(bar)
print(res)
res()
4:可以当做容器类型的元素
def foo():
	print("from foo")
l=[]
l.apend(foo)
l[0]()
# 示范
def login():
    print(‘登录功能‘)


def register():
    print(‘注册功能‘)


def transfer():
    print(‘转账功能‘)


def charge():
    print(‘充值‘)

def withdraw():
    print(‘提现‘)

func = {
    "1": ("登录",login),
    "2": ("注册",register),
    "3": ("转账",transfer),
    "4": ("充值",charge),
    "5": ("提现",withdraw)
}


while True:
    print("0 退出")
    for k,v in func.items():
        print(k,v[0])
    choice = input("请输入你的操作编号:").strip()
    if choice == "0":
        break
    if choice in func:
        func[choice][1]()
    else:
        print("输入的指令不存在")

以上是关于python基础之函数v1的主要内容,如果未能解决你的问题,请参考以下文章

python之基础篇——模块与包

python基础之函数

Python之如何优雅的重试

Python 之 基础知识

python基础之函数

python之函数基础