Python学习函数

一、函数及使用函数的目的

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

使用函数目的：

1、简化代码
2、提高代码的复用性
3、代码可扩展

二、定义函数

在Python中定义函数要使用def关键字，依次写出函数名、括号、参数和冒号（:），然后在缩进块中编写函数体

def say(): #函数名
    print('hello')#函数体

上面只是定义了一个函数，不调用函数，函数是不会被执行的

say()  #调用函数

三、函数的参数

定义函数时就确定了参数名字和位置。调用函数，只需知道如何传递正确的参数，以及函数将返回什么样的值。函数内部的复杂逻辑被封装起来，调用者无需知道。

函数在调用的时候，可以传入参数，有形参和实参：

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

2、实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

总结来说就是，形参就是函数接收的参数，而实参就是实际传入的参数。

#函数的参数
def calc(a,b):  #a,b为形参， 形式参数
    res = a * b
    print('%s * %s = %s'%(a,b,res))

calc(7,8)  #调用函数，7，8即为实参，实际参数

函数的4中形式参数：

1）位置参数

上面例子中的a,b即为位置参数，是必传的；调用函数的时候，有几个位置参数就要传几个，不然就要报错。

如图，调用上面的函数，只传一个参数，报错：

calc(7)

2）默认参数

默认参数是指定义形参时，给参数设定一个默认值。

默认参数不是必填；给默认参数传值，它就会使用你传入的值。若使用默认值参数，则必须放在位置参数后面，否则会报错

默认参数可以简化函数代码，能降低调用函数的难度

举例如下：不传内容时则为读文件，传了content则写文件

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

非固定参数：位置参数、默认参数的参数个数都是固定的。当函数参数不固定时，需要用非固定参数，非固定参数包含：可变参数、关键字参数。

3）可变参数

可变参数用*来接收，可变参数就是传入的参数个数是可变的，想传多少个参数就传多少个；这些可变参数在函数调用时自动组装为一个tuple。

如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。可变参数也是非必传的。

def get_info(name,age=18,*args):  #可变参数，可变参数会把后面多传的参数都放到args这个元组中
    print(name,age,args)

#调用
get_info('Lucy','white','red','blue')
get_info('Lucy')  #不传可变参数

结果：

4）关键字参数

关键字参数使用**来接收，参数也不固定的，想传多少个参数就传多少个；这些关键字参数在函数内部自动组装为一个dict。

使用关键字参数，调用的时候必须使用关键字传参，关键字参数也是非必传的。

可以和上面的几种一起来使用，一起使用时关键字参数必须在最后面。

def my(name,sex='男',*args,**kwargs): #位置参数、默认参数、可变参数、关键字参数
    print(name,sex,args,kwargs)      #关键字参数，调用的时候会把传入的关键字参数放到kwargs这个字典中

my('xhei',)
my('xhei','hhh','args','args2',k='1',k2='v2')  #调用，k,k2就是关键字参数
my(name='hahah',sex='男',age=18)

输出结果：

四、函数的返回值

在Python中，当函数里面没有指定返回值，函数执行完之后，默认会返回一个None。

当函数有多个返回值时，会把返回值都放到一个元组中，返回的是一个元组。

函数中的返回值使用return，函数遇到return就立即结束。

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

结果：

五、局部变量、全局变量

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

全局变量：在文件最上面定义的这个变量，就是全局变量。在函数中要修改全局变量的话，需要加global关键字声明；如果是list、字典和集合的话，则不需要加global直接可修改

name = '小黑' #全局变量
FILE_NAME = 'goods.json' #常量
def demo():
    global name  #修改全局变量，需要加global
    name='小白'
    print(name)
demo()
print('修改后的name:',name)

查看结果：

#字典、list和集合，这种可变变量，不需要用global来声明，就可直接修改该
d = {'name':'abc'}
def test():
    d['sex'] = 29
    print(d)
test()
print(d)

六、递归函数

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

#判断是否为偶数
def my2():
    num = input('输入一个数字：')
    num = int(num)
    if num%2 !=0:
        print('请输入偶数')
        return my2() 1#不是偶数的话继续调用自己
my2()

# 递归:函数自己调用自己
count = 1  #统计最多循环的次数，超出最大次数就报错
def add():
    global count
    count +=1
    print('hhh',count)
    add()
add()

递归函数的特性：

1、定义简单，逻辑清晰

2、使用递归必须有一个明确的结束条件

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

4、递归最多循环999次

七、内置函数

print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真
print(any([0,1,2,3,4]))#判断可迭代的对象里面的值是否有一个为真
print(bin(10))#十进制转二进制
print(bool('s'))#把一个对象转换成布尔类型
print(bytearray('abcde',encoding='utf-8'))#把字符串变成一个可修改的bytes
print(callable('aa'))#判断传入的对象是否可调用
print(chr(10))#打印数字对应的ascii
print(ord('b'))#打印字符串对应的ascii码
print(dict(a=1,b=2))#转换字典
print(dir(1))#打印传入对象的可调用方法
print(eval('[]'))#执行python代码，只能执行简单的，定义数据类型和运算
print(exec('def a():pass'))#执行python代码
print(filter(lambda x:x>5,[12,3,12,2,1,2,35]))#把后面的迭代对象根据前面的方法筛选
print(map(lambda x:x>5,[1,2,3,4,5,6]))
print(frozenset({1,2,3,3}))#定义一个不可修改的集合
print(globals())#返回程序内所有的变量，返回的是一个字典
print(locals())#返回局部变量
print(hash('aaa'))#把一个字符串哈希成一个数字
print(hex(111))#数字转成16进制
print(max(111,12))#取最大值
print(oct(111))#把数字转换成8进制
print(round(11.11,2))#取几位小数
print(sorted([2,31,34,6,1,23,4]))#排序
dic={1:2,3:4,5:6,7:8}
print(sorted(dic.items()))#按照字典的key排序
print(sorted(dic.items(),key=lambda x:x[1]))#按照字典的value排序
__import__('decorator')#导入一个模块

print(max(111,12))#取最大值
print(min((1,2,3)))#取最小值
print(abs(-1))#取绝对值
print(round(11.119999,3)) #取几位小数
print(sorted([2,31,34,6,1,23,4])) #排序
print(sorted([2,31,34,6,1,23,4],reverse=True)) #降序排