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)

本文出自 “dayi123” 博客，请务必保留此出处http://dayi123.blog.51cto.com/12064061/1917700

Python基础之函数