轻量级Python IDE使用（三）——函数

1、函数

1.1、函数的概述

在程序设计中，函数的使用可以提升代码的复用率和可维护性。

系统内建函数pow()进行幂运算:

a = pow(2,4)

自定义函数func()

def func(a,b):
    return a ** b
a=func(2,4)
print(a)

自定义函数func(),功能是输出a的b次幂

1.2、函数的定义

python语言中，函数通常是由函数名、参数列表以及一系列语句组成的函数体构成的。函数定义一般如下

def 函数名(参数列表)
    函数体

例：

def foo():
    print("I am")
    print("foo")

以上第一的foo()函数虽然不含任何参数，但是函数名后的一对括号是不能省略的。在实际应用中，稍复杂的函数通常会包含一个或多个参数。

def area(width,height):
    return width * height
#调用area
w = 7
h = 9
print("width=",w,"height=",h,"area=",area(w,h))

以下定义了无任何操作的空函数none()

def none():
    pass

在Python中，pass语句通常可以用来作为占位符，表示什么操作也不执行。比如在项目起始阶段，如果还没想好函数具体实现时，可以先放置一个pass语句让代码先成功运行起来。待项目框架搭建完毕后，在进行相应的具体实现。

通常情况下，在Python语言中定义一个具有特定功能的函数需要符和以下规则：

函数代码块以def关键字开头，后接函数标识符名称和形参列表；
任何传入的参数和自变量必须放在圆括号内；
函数的第一行语句可以选择性地使用文档字符串；
函数内容以冒号起始，并且严格统一缩进；
函数都有返回值，默认返回None

1.3、形参和实参

在编程语言中，函数定义的时形参，调用的是实参。
形参（parameter）,全称"形式参数",不是实际存在的变量。又称虚拟变量。用来接收调用该函数时传入的参数。

实参（argument）,全称"实际参数",是调用时传递给函数的参数。实参可以是常量、变量、表达式、函数等。

def area(width,height):
    return width * height
#调用area
w = 7
h = 9
print("width=",w,"height=",h,"area=",area(w,h))
其中w=7,h=9中的w,h是实参，area(w,h))中的w,h是形参

可见实参传入函数形参位置，调用完后不会影响实参的值

a = 1
b = 2

def func(x,y):
    x+=1
    y+=2
    print(x)#2
    print(y)#4
func(a,b)
print(a)#1
print(b)#2

func(a,b)等效于func(1,2)、func(x=1,y=2)、func(y=2,x=1)

1.4、函数的返回值

在Python中，当函数运行到return语句时即执行完毕，同时将结果返回。因此，可以在函数内部同通过条件判断和循环设置实现较复杂的逻辑，并返回预期的结果。如果没有return语句，函数体内所有语句执行完毕后默认返回None。

def add(x,y):
    print('x+y=',x+y)
    return x+y
result = add(y=1,x=2)
print(result)

函数也可以有多个返回值

def add(x,y):
    print('x+y=',x+y)
    print('x*y=',x*y)
    return x+y,x*y
a,b = add(y=1,x=2)
print(a,b)

注意返回值和接收变量的关系是一一对应的

2、函数分类

2.1 内置函数

Python语言中自带的函数叫做内建函数，这些内建函数对大部分常用操作进行有效封装，可以直接调用，为开发提供了极大便利。由于内建函数是Python语言内置的函数，因此不需要导入任何函数库即可直接调用。常用的内建函数如下：

abs(x)：返回x的绝对值。
all(iterable)：如果iterable的所有元素都为True，则返回True；否则返回False。
any(iterable)：如果iterable的任意一个元素为True，则返回True；否则返回False。
ascii(obj)：返回一个可打印的对象的字符串表示。
bin(x)：将整数x转换为二进制字符串。
bool(x)：将x转换为布尔值。如果x为False、0、空列表、空字典和空字符串，则转换为False；否则转换为True。
bytearray(iterable)：返回一个由可迭代对象iterable中的元素组成的字节数组。
bytes(iterable)：返回一个由可迭代对象iterable中的元素组成的字节对象。
callable(obj)：如果obj是可调用的（例如函数、方法、类），则返回True；否则返回False。
chr(i)：返回Unicode值为i的字符。
classmethod(func)：将函数func转换为类方法。
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)：将source编译为代码对象或AST对象。可用于动态执行代码。
complex(real, imag)：创建一个复数，其中real为实部，imag为虚部。
delattr(obj, name)：从对象obj中删除名为name的属性。
dict()：创建一个空字典。
dir(obj)：返回一个包含对象obj定义的所有属性和方法名称的列表。
divmod(a, b)：返回a除以b的商和余数的元组。
enumerate(iterable, start=0)：返回一个枚举对象，其中包含iterable中的每个元素及其对应的索引。
eval(expression, globals=None, locals=None)：将字符串expression作为Python代码执行，并返回结果。
exec(obj[, globals[, locals]])：将对象obj（可以是字符串或代码对象）作为Python代码执行。
filter(function, iterable)：返回一个由iterable中满足函数function的元素组成的迭代器。
float(x)：将x转换为浮点数。
format(value[, format_spec])：根据format_spec的格式将value转换为字符串。
frozenset(iterable)：创建一个不可变的集合。
getattr(obj, name[, default])：返回对象obj的名为name的属性的值。
globals()：返回当前全局符号表的字典。
hasattr(obj, name)：如果对象obj具有一个名为name的属性，则返回True；否则返回False。
hash(obj)：返回对象obj的哈希值。
help(obj)：提供对象obj的帮助信息。
hex(x)：将整数x转换为十六进制字符串。
id(obj)：返回对象obj的唯一标识符。
input([prompt])：从标准输入读取一行字符串。
int(x[, base])：将x转换为整数。如果base提供，则将x视为base进制的字符串，将其转换为十进制。
isinstance(obj, classinfo)：如果对象obj是classinfo的实例或派生类的实例，则返回True；否则返回False。
issubclass(class, classinfo)：如果class是classinfo的派生类，则返回True；否则返回False。
iter(obj[, sentinel])：返回一个迭代器对象。
len(obj)：返回对象obj的长度（元素个数）。
list(iterable)：将可迭代对象iterable转换为列表。
locals()：返回当前局部符号表的字典。
map(function, iterable)：将函数function应用于iterable中的每个元素，并返回一个包含结果的迭代器。
max(iterable[, key])：返回iterable中的最大元素。可以使用key函数指定比较规则。
memoryview(obj)：返回对象obj的内存视图，可以用于对对象进行原生内存操作。
min(iterable[, key])：返回iterable中的最小元素。可以使用key函数指定比较规则。
next(iterator[, default])：返回迭代器iterator的下一个元素。如果已经到达迭代器的末尾，则返回default。
object()：返回一个没有任何特别行为的新对象。
oct(x)：将整数x转换为八进制字符串。
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：打开文件，返回文件对象。
ord©：返回字符c的Unicode值。
pow(x, y[, z])：返回x的y次方，如果提供了参数z，则计算结果的模为z。
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)：将对象打印到流文件，默认为标准输出。
property(fget=None, fset=None, fdel=None, doc=None)：创建一个属性，其中fget、fset和fdel为获取、设置和删除属性值的方法。
range(stop)：返回一个从0到stop-1的整数序列。
repr(obj)：返回对象obj的字符串表示形式。
reversed(seq)：返回一个逆序迭代器，用于迭代序列seq的元素。
round(number[, ndigits])：返回一个浮点数的四舍五入值。
set(iterable)：创建一个集合，其中包含iterable中的元素。
setattr(obj, name, value)：将对象obj的属性name设置为value。
slice(stop)：创建一个切片对象，用于切取从0到stop-1的元素。
sorted(iterable[, key[, reverse]])：返回iterable排序的副本。
staticmethod(func)：将函数func转换为静态方法。
str(obj)：将对象obj转换为字符串。
sum(iterable[, start])：返回iterable的求和结果。
super([type[, object-or-type]])：返回一个链式对象，用于在多重继承中调用父类方法。
tuple(iterable)：将可迭代对象iterable转换为元组。
type(obj)：返回对象obj的类型。
vars([object])：返回对象object的__dict__属性，或返回当前局部符号表的字典。
zip(*iterables)：将多个迭代器作为参数，将对应位置的元素组合成元组。
1__import__ (name[, globals[, locals[, fromlist[, level]]]])：使用import机制导入一个模块。
openpyxl()：用于操作Excel文件的库。

在Python语言中，除内建函数外的其他类型函数通常被称为第三方函数。

a = abs(-100)
b = max(-1,4,0,-2,13,4)
print(a,b)#100 13

Python语言常用的内建函数还包括数据类型转换函数。

print("int('12'):",int('12'))
print("int(12.5):",int(12.5))
print("float('12.5'):",float('12.5'))
print("str(1.25):",str(1.25))
print("str(10):",str(10))
print("bool(1):",bool(1))#True
print("bool(''):",bool(''))#False

Python语言中，还可以把函数名赋给一个变量，相当于给这个函数起了一个别名。

a = abs
print(a(-1))

2.2 自定义函数

当内建函数不能满足要求时，开发者可以根据实际需要自定义函数。函数自定义完成后，开发者可以在其他代码处通过函数名调用。

def printme(str):
    "函数功能：打印传入的字符串"
    print(str)

printme("调用自定义函数")

在Python语言中，内建函数可以直接使用，第三方函数需要使用import命令导入相应的库才能使用。对于自定义函数，其定义和调用可以在用一个文件中，也可分离成不同的文件。
定义一个func.py并写入hello函数

def hello():
    print("你好")

在一个新的xx.py文件中调用hello

from func import hello
hello()

3、函数参数

3.1 参数种类

函数参数分为可变类型和不可变类型，其调用结果是不同的。

可变类型：类似c++的引用传递。如列表、字典等。如果传递的参数是可变类型，则在函数内部对传入参数的修改会影响到外部变量。
不可变类型：类似c++的值传递，如整数、字符串、元组等。如果传递到达参数是不可变类型，则在函数内部对传入的参数的修改不会影响到外部变量。

不可变类型参数，例：

def change_int(a):
    a=10
b=2
change_int(b)
print(b)#结果是2

b的值不变
可变类型参数，例：

def change_int(my_list):
    my_list.append([1,2,3])
    print("函数内修改后的变量：", my_list)#[10, 20, 30, [1, 2, 3]]

my_list =[10,20,30]
change_int(my_list)
print("函数外变量的值：", my_list)#[10, 20, 30, [1, 2, 3]]

my_list的值改变

3.2 位置参数

调用函数时，Python语言必须将函数调用中的每个实参都关联到函数的相应形参。最简单的关联方式是基于实参的顺序，这种关联方式被称为位置实参。

def student_info(name,age):
    print("my name is",name ,age," years old")

student_info('jack',24)

输出

my name is jack 24  years old

3.3 默认参数

编写函数时，可给每个形参指定默认值。注意，必选参数在前，默认参数在后。
以下错误示例

def student_info(name='liuj',age):
    print("my name is",name ,age," years old")

正确操作

def student_info(name,age=24):
    print("my name is",name ,age," years old")

student_info('jack')

3.4 不定长参数

开发者可以将一个list或tuple传进来

def sum(numbers):
    i=0
    for n in numbers:
        i = i + n
    return i
print(sum([1,2,3]))#6
print(sum([1,2,3,4]))#10

也可以在函数参数前面添加一个*号把该参数定义为不定长参数

def sum(*numbers):
    i=0
    for n in numbers:
        i = i + n
    return i
print(sum())#0
print(sum(1,2,3,4))#10
num = [1,2,3]
print(sum(*num))#6

3.5 关键字参数

关键字实参是传递参数时使用“名称-值”对的方式，在实参中将名称和值关联起来。无须考虑函数调用中的实参顺序。

def func(a,b):
    return pow(a,b)
print(func(b=4,a=3))#81

3.6 命名关键字参数

如果要限制关键字参数的名字，可以使用命名关键字参数。和关键字参数**kw不同，如果没有可变参数，命名参数关键字参数就必须加一个 * 号作为特殊分隔符。如果缺少 * ,Python语言解释器将无法识别位置参数和命名关键字参数。

例如，若只接收age和city作为关键字参数，可以采用如下形式。

def person_info(name,denger,*,age,city):
    print(name,denger,age,city)

person_info('jack','M',age=18,city='guangzhou')

注意
*表示不定长参数
**表示不定长的关键字参数

3.7 参数组合

在Python语言中定义函数，开发者可以组合使用这些参数（必选参数、默认参数、可变参数、关键字参数和命名关键字参数）。注意参数定义是有顺序的。定义顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数。

def func(a,b,c=0,*args,**kw):
    print(a,b,c,args,kw)

func(1,2,3,'a','b',x=4,y=7,z=8)

运行结果：

1 2 3 ('a', 'b') {
    
    'x': 4, 'y': 7, 'z': 8}

4、函数式编程

函数式编程是一种编程范式，是面向数学的抽象，其将计算描述为一种表达式求值。
函数式编程中的函数不是指计算机的函数，而是指数学中的函数，即自变量的映射。
函数式编程的一个特点是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

4.1、高阶函数

接受函数为参数，或者把函数作为结果返回的函数称为高阶函数。

word = ['apple','blue','car','did']
def reverse(word):
    return word[::-1]
    
print(sorted(word,key=len))

print(reverse('testing'))

print(sorted(word,key=reverse))

4.2、匿名函数

所谓的匿名函数，就是不再使用def语句这样的标准形式定义的函数，Python经常使用lambda来创建匿名函数。
lambda arg1,arg2…:expression

sum = lambda arg1,arg2:arg1+arg2
print(sum(2,3))