Python学习笔记八_函数

一、函数是什么

定义：函数是指一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需要调用函数名即可。

C中的函数叫function，java中的函数叫method，python中的函数用def做关键字。

二、使用函数的好处

1.提高代码的复用性

2.让代码更简洁、简化代码

3.代码可扩展

三、python中函数的定义

定义函数使用def关键字，后面是函数名，函数名不能重复

def sayHello(): #定义函数，函数名
    print('hello') #函数体
#函数不调用是不会被执行的
sayHello() #调用函数

四、函数的参数

1、形参与实参

函数在调用的时候，可以传入参数，有形参和实参。形参就是函数接收的参数，而实参就是你实际传入的参数

形参：

只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。

实参：

可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

def calc(a,b): #形参：形式参数
    print('%s * %s = %s'%(a,b,a*b))
calc(7,8) #实参：实际参数

2、函数的四种形参

   (1) 位置参数

按照参数的位置来传参，calc这个函数中，a和b就是位置参数，是必传的，没有会报错

def calc(a,b): #位置参数，必填，不填会报错missing 2 required positional arguments
    print('%s * %s = %s'%(a,b,a*b))
calc(7,8) 

有几个位置参数在调用的时候就要传几个，否则会报错，如果有多个位置参数的话，记不住哪个位置传哪个了，可以使用位置参数的名字来指定调用

def size(ength,width,height): 
    print('Size is %s'%(ength * width * height))
size(height=7,ength=8,width=10)#关键字传参,参数过多可以使用未知参数的名字来指定调用

def op_mysql(host,port,username,passwd,charset,sql):
    print('连接数据库')

#一一对应传参
op_mysql('192.168.1.1',3306,'Amy','sfsd','utf-8','select * from user')

#不按顺序传参（关键字传参）
op_mysql(sql = 'select * from user',
         host = '192.168.1.1',
         username = 'Amy',
         passwd = 'sfsd',
         charset = 'utf-8',
         port = '3306'
         )

#也可以将两种传参相结合
op_mysql('192.168.1.1',3306,
         sql = 'select * from user',
         username = 'Amy',
         passwd = 'sfsd',
         charset = 'utf-8',
         )

 (2) 默认参数

在定义形参的时候，给函数默认赋一个值，比如说数据库的端口这样的，默认给它一个值，这样就算你在调用的时候没传入这个参数，它也是有值的。

默认参数不是必填的，如果给默认参数传值，它就会使用你传入的值。如果使用默认值参数的话，必须放在位置参数后面定义。

def op_file(file_name,content=None): #content:默认值参数,它是非必填的
    f = open(file_name, 'a+', encoding='utf-8')
    f.seek(0)
    if content: #不为空代表写文件
        f.write(content)
        f.flush()
    else: #为空代表读文件
        all_user = f.read() #all_users是局部变量
        return all_user #调用完函数之后，返回什么结果
    f.close()
print(op_file('username'))

   (3) 非固定参数

位置参数和默认参数的参数个数都是固定的，如果一个函数参数是不固定的，以后也不知道会扩展成什么样，那么再用固定函数，后面程序就不好扩展了。这时候需要非固定参数。非固定参数有两种，可变参数和关键字参数。

   　　(i) 可变参数

　　　　可变参数用*来接收，后面想传多少个参数就传多少个，如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。

　　　　a、非必填参数

　　　　b、它没有限制参数个数

　　　　b、它把传回来的参数放在元组里

def syz(name,*args): #参数组
    # 位置参数、默认值参数、可变参数，可变参数会把后面多传的参数都放到args这个元组中
    # args名字是随便写的，不过一般我们都写args
    print(name,args)
syz('双鱼座') #双鱼座 (),非必填
syz('双鱼座','111') #双鱼座 ('111',)
syz('asd','sdf',23224) #asd ('sdf', 23224),没有限制参数个数

   　　(ii) 关键字参数

　　　　关键字参数用**来接收，后面的参数也是不固定的，位置参数、默认值参数、可变参数，关键字参数一起使用的话，关键字参数必须在最后面。

　　　　a、非必填参数

　　　　b、它没有限制参数个数

　　　　c、它把传回来的参数放在字典里

　　　　d、使用关键字参数的话，调用的时候必须使用关键字传参

def syz(name,**kwargs): #关键字参数,必须有k-v，两个参数
    # 位置参数、关键字参数，调用的时候会把传入的关键字参数放到kwargs这个字典中
    print(name,kwargs)
syz('双鱼座') #非必填,双鱼座 {}
syz('双鱼座','111') #报错，必须有k-v，两个参数
syz('双鱼座',room = '111') #双鱼座 {'room': '111'}
syz('双鱼座',room = '111',addr = '北京') #没有限制参数个数,双鱼座 {'addr': '北京', 'room': '111'}

五、函数的返回值

　　每个函数都有返回值，如果没有在函数里指定返回值，则默认返回None，函数可以有多个返回值，如果有多个返回值，会把返回值放到一个元组中，返回的是一个元组。

def calc(x,y):
    res = x * y
    return x,y,res
print(calc(2,3)) #多个返回值的函数，返回一个元组(2, 3, 6)

　　返回值作用：

　　1、把函数处理的结果返回回来，供后面的程序用。

　　2、结束函数，函数里面遇到return，函数会立即结束

def r():
    for i in range(5):
        if i == 3:
            print(i)
            return #只写一个return的话，就返回None
r() #3,遇到return函数立即结束
res = r()
print(res) #默认返回None

import string
def check(pwd):
    if len(pwd) >5 and len(pwd) <12: #长度6-11
        if set(pwd) & set(string.ascii_letters) and set(pwd) & set(string.digits):#必须包含字符和数字
            print('密码合法')
        else:
            print('密码不合法')
    else:
        print('密码不合法')
res = check('ad1234') #调用函数，并把函数返回值赋给res
# 函数里面如果没有return的话，默认返回none，return不是必须写的
print(res)

六、局部变量和全局变量

常量：

一个不变的值，通常用大写字母定义

PORT = 3306 #常量
FLIENAME = 'user.txt'

局部变量：

函数里面定义的变量，都是局部变量，只能在函数里面用，出了函数之后就不能用了

name = 'Lily' #全局变量
def sayName():
    name = 'Kate'#局部变量
    print(name) #kate
sayName()
print(name) #Lily

全局变量：

公共的变量，都可以用的变量。

在整个程序里面都生效的，在程序最前面定义的都是全局变量，全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改

name = 'Lily' #字符串全局变量
names = [] #list全局变量
def sayName():
    global name #修改全局变量name，加global关键字
    name = 'Kate'
    names.append(name)#修改全局list变量，不用加global关键字
    print(name) #kate
sayName()
print(name) #kate
print(names) #['Kate'] 

最好少用全局变量的原因：

　　(1) 不安全，因为所有人都可以改
　　(2) 全局变量它会一直占着内存

七、递归

 函数自己调用自己。

 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归调用的意思就是，在这个函数内部自己调用自己，就有点循环的意思。

def test1():
    num = int(input('please enter a number：'))
    if num%2==0:#判断输入的数字是不是偶数
       return True #如果是偶数的话，程序就退出了，返回True
    print('不是偶数请重新输入！')
    return test1()#如果不是偶数的话继续调用自己，输入值
print(test1())#调用test

递归调用的特性：

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

少用递归，递归最多递归999，递归的效率不高

i = 0
def test():
    global i
    i += 1
    print(i)
    test()
test() #循环999次后会报错，3.6版本以后不会报错

八、高阶函数

如果一个函数的参数是一个函数的话，那么这个函数就是一个高阶函数

def s_int(n):#把传入的参数类型转换成int类型
    return int(n)
def add(x,y,z):#接收3个参数，x,y,z，z是一个函数
    print(z(x)+z(y))#z是一个函数，把x和y的值传给z，然后用z函数的返回值把两个值相加
add('8','9',s_int)#调用，传入x和y的值，再把上面的那个定义好的函数传进去