python中定义一个函数、求两个数任意运算_Python基础之函数

Python基础之函数

一、函数基础

1、函数概念:

函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

2、函数的作用

(1)减少重复代码

(2)使程序变的可扩展

(3)使程序变得易维护

3、语法定义

def sayhi(x):               #函数名

’’’函数说明’’’

print("Hello, I'mnobody!")

return x                    #函数返回值

sayhi()                     #调用函数

关键字说明：

def:创建函数

sayhi()：函数名

print("Hello, I'm nobody!")：函数体

return()：返回值

sayhi() #调用函数

4、函数的执行过程

定义函数，在程序执行过程中，函数体不执行，只有当程序调用函数时，函数才会执行。

函数执行过程：

def f1():

print(123)

return "111"   #在函数中，一旦执行return，函数执行过程立即终止

print(456)

r = f1()           #只有调用函数时，函数才会执行

print(r)           #打印函数返回值

5、函数的返回值

(1)返回值数量为0时，返回None

(2)返回值数量等于1时，返回object

(3)返回值数量大于1时，返回tuple

deftest():

print("first")

#没有返回值

deftest2():

print("second")

return 2                      #返回值数量为1时

deftest3():

print("three")

return3,"dayi123",{"age":18,'name':"yiliu"}    #返回值数量多个时

one =test()

two =test2()

three= test3()

print(one)

print(two)

print(three)

二、函数的参数

1函数的基本参数

(1)、普通参数

1)形参：变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2)实参：可以是常量、变量、表达式、函数等，无论实参是何种类型的值，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def send(xxoo,content):                   #xxoo、content为实参

print(xxoo,content)

print("发送邮件成功：",xxoo,content)

return True

send(dayi, is)                           #dayi、is为形参

(2)、默认参数

def send(xxoo,content,xx="ok"):     #默认参数必须放在参数列表最后，可以有多个默认参数

print(xxoo,content,xx)

print("发送邮件成功：",xxoo,content,xx)

return True

send('dayi','is')                   #如果没有传参、则传递默认参数

send('dayi','is','niuB')              #如果传递参数，则返回结果为传递参数

(3)、制定参数

默认传递的参数是根据顺序，制定参数，可以打乱参数的顺序：

def send(xxoo,content):

print(xxoo,content)

print("发送邮件成功：",xxoo,content)

return True

send(content='dayi',xxoo='is')     #将’dayi’传递给conttent,将‘is’换递给xxoo

2、函数的动态参数

(1)、动态参数：传参时可以传一个或任意多个参数

1)、传参时加一个”*”

作用：会将传的参数放入元组中、

应用场景：传的参数有顺序

def fl(*args):          # 行参中带*则表示动态参数

print(args,type(args))

fl(11)

li = [22,"dayi","liu"]

fl(li)                 # 把 "li"当做一个整体传到元组里面

fl(*li)                #加"*"把li中元素传到元组里面

fl(li,12)

li2 = "dayi123"

fl(li2)                #不带*，将li2整体传进元组，带"*",将li2中每个字符串分别传进元组

fl(*li2)

2)、传参时加两个”*”

作用：会将传的参数放入字典中

应用场景：传的参数没有顺序

def f1(**args):

print(args,type(args))

f1(n1="dayi123",n2=24)             #传参时必须传两个，一个“KEY”一个“value”

dic = {'name':"dayi",'age':18}

f1(kk=dic)                         #传参是把字典当做一个整体传进字典中

f1(**dic)                          #传参时将字典中的每一个值分别传进字典中

3)、传参时既有两个”*”，又有一个”*”

作用：万能参数，既可以传一个”*”的参数，又可以传”**”的参数

ef f1(*args,**kwargs):

print(args,type(args))

print(kwargs)

f1(1,2,3,name="dayi",age=24)

tup = (22,33,44,55)

dic = {'name':"dayi123",'age':23}

f1(*tup,**dic)

f1(yz=tup,cd=dic)

(2)、利用动态参数实现format功能

s1 = "i am {0},age{1}".format("dayi123",18)

print(s1)

s2 = "i am {0},age {1}".format(*["dayi123",24])        #传递列表中的参数，前面必须加“*”

print(s2)

s3 = "i am {name},age {age}".format(name="dayi123",age=24)

print(s3)

dic = {'name':'dayi123',"age":24}

s4 = "i am {name},age {age}".format(**dic)              #将字典中参数传递给s4,必须加“**”

print(s4)

(3)、函数传参传递的是引用

def f1(a1):

a1.append(999)     # 函数传参传递的是引用

li = [11,22,33,44]

f1(li)

print(li)

3、全局变量与局部变量

全局变量针对所有作用域均可读，局部变量只针对部分作用域可读，全局变量声明要用大写，全局变量可以是列表、字典。全局变量可以通过global修改，如果全局变量是字典、列表，则可以修改，但不能重新赋值。

NAME = "alex"            #全局变量，所有作用域都可读,全局变量的声明要大写

#NAME = [123,456,789]     #如果全局变量是列表字典，则可以修改，但不可重新赋值

def fl():

age = 18

global NAME        #修改全局变量，对全局变量重新赋值，需要先global

NAME = "123"        #局部变量，只对当前作用于生效

print(age,NAME)

def f2():

age = 19

print(age,NAME)

fl()

f2()

定义的字符串、数字格式的全局变量不能再局部变量中直接修改，但定义的列表，字典等全局变量可在局部变量中直接修改：

names= ["dayi",18,"boy"]

defchange_name():

names[0] = "liu"

print("inside func",names)

print(names)

change_name()

print(names)

例：用函数实现登录功能

def login(username,password):

f = open("db",'r')             #打开db.txt文件，’r’代表读取

for line in f:

line_list = line.split("|") #一行一行读取，使用“|”分隔

if line_list[0] == username and line_list[1] == password:

return True

def register(username,password):

f = open("db",'a')             #打开db.txt文件，’a’代表追加

temp = "\n" + username + "|" + password

f.write(temp)                   #向db.txt中写入

f.close()                       #关闭并生效

def main():

t = input("1:登录；2：注册")

if t == "1":

user = input("请输入用户名：")

pwd = input("请输入密码：")

r = login(user,pwd)

if r:

print("登录成功")

else:

print("登录失败")

elif t == "2":

user = input("请输入用户名：")

pwd = input("请输入密码：")

register(user,pwd)

main()

同时，新建db.txt文件，输入：dayi123|dayi123

三、三元(三目)运算及lambda表达式

1、三元运算

if 1 ==1:

name= "liu"

else:

name= "sb"

#等同于：

name = "liu" if 1 == 1 else "sb"

2、lambda表达式(匿名函数)

def f1(a1,a2):

return a1 + a2 + 100

ret = f1(10,12)

print(ret)

#等同于

f2 = lambda a1,a2: a1 +a2 + 100

ret2 = f2(10,12)

print(ret2)

3、中括号中的条件判断以及循环举例：

a = range(10)

print([i for i in a if i<5])

输出结果为： [0, 1, 2, 3, 4]

四、递归

1、递归：

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

2、递归算法特点：

(1)递归就是在过程或函数里调用自身。

(2)在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3)递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。

(4)在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

3、递归举例――阶乘

def func(num):

if num == 1:

return 1

return num * func(num-1)

x = func(7)

print(x)

五.高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

#!/usr/bin/env python

# Author:dayi123

def fuc(a,b,f):

return f(a)+f(b)     #将a、b的值交给函数f处理后求和再返回

add = fuc(7,-10,abs)      #将内置函数abs传递给f

print(add)