5、函数

内置函数

数学相关

abs(a) : 求取绝对值。abs(-1) >>> 1 
max(list) : 求取list最大值。max([1,2,3]) >>> 3
min(list) : 求取list最小值。min([1,2,3]) >>> 1
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3]) >>> 3
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

类型转换

int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65

功能相关

eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']

函数的定义

def funcName(arg1,arg2):
    "函数的文档说明"
    return 1

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串（单行""，多行""" """）—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

返回值

python的返回值，可以同时返回多个值，被多个变量按顺序接收

实际上，函数返回值只有一个，是Tuple类型的元组，只是在赋值的时候会按照位置赋值给变量

def address():
    "生成x、y坐标值"
    return 98,77

x,y = address()

print(x)
print(y)

参数

必须参数

def printStr(str):
    "打印字符串，str为必填参数"
    print(str)

printStr("hello")

关键字参数

由于传参时必须按照参数列表顺序，使用参数名，可以不按照顺序进行传参

def msg(name,age):
    "打印个人信息"
    print('姓名：',name,'年龄：',age)

msg(age=18,name='lucy')

默认参数

声明函数时默认参数必须声明在非默认参数后面

传参时可以不传，使用默认值

默认参数必须指向不变对象

def msg(name,age,sex = '男'):
    "打印个人信息，性别默认值为男"
    print('姓名：',name,'年龄：',age,'性别：',sex)

msg(age=18,name='lucy',sex = '女')
msg('tom',25)

可变参数

def add(*nums):
    total = 0
    for i in nums:
        total += i
    return total

#多个参数可以由逗号分隔传入
print(add(1,2,3,4,5))

#列表、元组、集合传入可以在变量名前加*进行解构，以参数的形式传入
li = [1,2,3,4,5]
tup = (1,2,3,4,5)
se = {1,2,3,4,5}
print(add(*li))
print(add(*tup))
print(add(*se))

传入字典

传入字符串的时候，可以不加引号

def showDect(**dec):
    print(dec)

showDect(lucy = 18,tom = 25)

>>>{'lucy': 18, 'tom': 25}

类型标注

声明一个函数参数的类型，只要在参数名称的后面加个:号，带上类型名称就行了。声明函数的返回值类型，只要在函数声明结束之前，也就是:号之前加入一个->，带上类型名称。

• int,long,float: 整型,长整形,浮点型
• bool,str: 布尔型，字符串类型
• list, tuple, dict, set:列表，元组，字典, 集合
• Iterable,Iterator:可迭代类型，迭代器类型
• Generator：生成器类型
• None: 空

def address(a:int,b:int) -> tuple[int,int]:
    "生成x、y坐标值"
    return 98,77

函数式编程

#此处可以看到，函数名也是变量
print(abs)
#将内置函数赋值给自定义变量
myAbs = abs
print(myAbs)
#调用函数
print(myAbs(-1))

函数作为形参传入

def add(a,b):
    "两数相加"
    return a + b

def handle(num1,num2,func):
    "对两数进行运算"
    return func(num1,num2)

a = handle(5,6,add)

print(a)

函数作为返回值

在函数handle中定义了add函数，内部函数add可以引用handle的参数和局部变量，当调用handle返回add时，所有的参数和变量都保存在add中，这种称为闭包

#调用handle时并没有执行add函数，而是返回add函数
#nums会在add函数中保存
def handle(*nums):
    def add():
        total = 0
        for i in nums:
            total = total + i
        return total
    return add
#接收返回的add函数
addFunc = handle(1,2,3,4,5)
#调用函数
print(addFunc())

匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

#lambda声明格式：lambda 参数：返回值
lambda x:x * x
#相当于
def func(x):
    return x * x

def handle(num1,num2,func):
    "对两数进行运算，运算逻辑可以由func传入"
    return func(num1,num2)

a = handle(5,6,lambda num1,num2:num1 + num2)
print(a)

装饰器

使用装饰器（装饰器设计模式Decorator），可以在代码运行期间动态增加功能

原理

def log(func):
    print('函数',func.__name__,'被执行')
    return func
    
@log
def now():
    "获取当前日期"
    return '2022-2-11'

print(now())

>>>>>相当于<<<<<

def log(func):
    print('函数',func.__name__,'被执行')
    return func
    
def now():
    "获取当前日期"
    return '2022-2-11'

print(log(now)())

对于有参

def log(func):
    def handle(a,b):
        print('函数',func.__name__,'被执行')
        return func(a,b)
    return handle

@log
def now(a,b):
    "获取当前日期"
    return '2022-2-11'

print(now(1,2))

>>>>>相当于<<<<<

def log(func):
    def handle(a,b):
        print('函数',func.__name__,'被执行')
        return func(a,b)
    return handle
    
def now(a,b):
    "获取当前日期"
    return '2022-2-11'

print(log(now)(1,2))

例子

def log(func):
    def handle(*args,**dicArg):
        print('函数',func.__name__,'被调用')
        print('参数列表',args,dicArg)
        ret = func(*args,**dicArg)
        print('返回值',ret)
        return ret
    return handle

@log
def add(num1,num2):
    return num1 + num2
@log
def printMsg(msg):
    print(msg)
@log
def sayHello():
    print('Hello')

add(4,5)
printMsg('lucy')
sayHello()

>>>>>
函数 add 被调用
参数列表 (4, 5) {}
返回值 9
>>>>>
函数 printMsg 被调用
参数列表 ('lucy',) {}
lucy
返回值 None
>>>>>
函数 sayHello 被调用
参数列表 () {}
Hello
返回值 None