python基础 - 函数

---

前言

函数：带名字的代码块，用于完成具体的工作。
要执行函数定义的任务，可调用该函数。需要在程序中多次执行同一项任务时，无需反复编写完成该任务的代码，而只需调用执行该任务的函数，让Python运行其中的代码。

常用内置函数

类型转换：bool,int,float,str,bytes,tuple,list,dict,set,enumerate,range
序列操作：all,any,filter,map,zip,next,reversed,sorted
对象操作：dir,id,hash,type,len,format
变量操作：globals,locals
交互操作：input,print
文件操作：open
反射操作：isinstance,issubclass,hasattr,getattr,setattr,delattr
装饰器：property,classmethod,staticmethod

---

一、定义函数

• 使用def关键字来定义一个函数，greet_user为函数名，括号内指出函数为完成其任务所需要的信息，最后，函数定义以冒号结尾。
• 紧跟在def greet_user():后面的所有缩进构成了函数体。文档字符串用三括号括起，描述了函数是做什么的，生成有关程序中函数的文档。

def greet_user():
	"""显示简单的问候语"""
    print('Hello!')
greet_user()  # Hello!

二、函数参数

1.向函数传递参数

在函数定义def greet_user()的括号内添加username，通过添加username，可让函数接收给username指定的任何值。

def greet_user(username):
    print("Hello, " + username + "!")
greet_user("jesse")  # Hello, jesse!

函数执行过程：

• 代码greet_user(“jesse”)调用函数greet_user()，并向它传递"jesse"，提供执行print语句所需要的信息。

2.实参和形参

• 形参：写在函数声明的位置的变量叫形参，形式上的一个完整表示；
• 实参：在函数调用的时候给函数传递的值，实际执行的时候给函数传递的信息；
• 传参：给函数传递信息的时候将实际参数交给形式参数的过程被称为传参。
• 形参就是一个变量名，实参就是值，传参就是在赋值。
• 在函数greet_user()定义中，变量username是一个形参 — 函数完成其工作所需的一项信息；
• 在greet_user(“jesse”)中，值"jesse"是一个实参。实参是调用函数时传递给函数的信息；
• 调用函数时，将要让函数使用的信息放在括号内，在greet_user(“jesse”)中，将实参"jesse"传递给了函数greet_user()，这个值被存储在形参username中。

3.传递参数

鉴于函数定义中可能包含多个参数，因此函数调用中也可能包含多个实参；
向函数传递参数的方式很多，可使用
位置参数：要求实参的顺序与形参的顺序相同；
关键字参数：每个实参都由变量名和值组成，还可使用列表和字典。

3.1.位置实参

在函数调用时，python必须将函数调用中的每个参数都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置参数。

def describe_pet(animal_type,pet_name):
    """显示宠物的信息"""
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster','harry')
describe_pet('dog','willie')

执行过程：

• 函数定义表明，describe_pet函数需要两个参数，animal_type和pet_name；
• 调用describe_pet()时，按顺序提供两个参数。实参’hamster’存储在形参animal_type中，实参’harry’存储在形参pet_name中；
• 在函数体内，使用了这两个参数来显示宠物的信息。

注：

• 函数调用多次：可根据需要调用函数任意次。要再描述一个宠物，只需再次调用describe_pet（）即可；
• 位置参数的顺序：使用位置实参来调用函数时，如果实参的顺序不正确，结果可能出乎意料；

3.2.关键字实参

• 关键字实参是传递给函数的名称 — 值对。直接在实参中将名称和值关联起来，在向函数传递实参时不会混淆；
• 关键字实参无需考虑函数调用中的实参顺序，清楚地指出了函数调用中各个值的用途。

def describe_pet(animal_type,pet_name):
    """显示宠物的信息"""
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster',pet_name='harry')

执行过程：

• 调用函数时，向python明确指出各个参数对应的形参；
• 将实参’hamster’和’harry’分别存储在形参animal_type和pet_name中；
• 关键字参数的顺序无关紧要，python知道各个值该存储到哪个形参中。

注：

• 使用关键字实参时，务必准确地指出函数定义中的形参名。

3.3.混合参数

• 在调用函数的时候既可以给出位置参数，也可以指定关键字参数。
• 在使用混合参数的时候，位置参数在前，关键字参数在后。

def describe_pet(pet_name,animal_type):
    """显示宠物的信息"""
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('willie',animal_type='dog')
describe_pet(animal_type='dog','willie') # 报错，SyntaxError: positional argument follows keyword argument

小结：

在实参的角度来看，分为三种：

• 位置参数
• 关键字参数
• 混合参数，位置参数必须在关键字参数前面

3.4.默认实参

• 编写函数时，可给每个参数指定默认值。
• 在调用函数中给形参提供了实参时，python将使用指定的实参值；否则，将使用形参的默认值。
• 给形参指定默认值后，可在函数调用中省略相应的实参，使用默认值可简化函数调用，还可清楚地指出函数的典型用法。

def describe_pet(pet_name,animal_type='dog'):
    """显示宠物的信息"""
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie')

执行过程：

• 函数定义给形参animal_type指定了默认值’dog’；
• 函数调用时，如果没有给animal_type指定值，python将把这个形参设置为’dog’；

注：

• 使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参，能让python正确地解读位置参数。

3.5.动态接收位置参数

• 在参数位置用*表示接受任意参数

def eat(*args):
    print('我想吃:',args)
eat('米饭','面条','馄饨')   # 收到的结果是一个tuple元组
# 我想吃: ('米饭', '面条', '馄饨') 

• 动态接受参数时注意：动态参数必须在位置参数后面

def eat(*args,a,b):
    print('我想吃:',args,a,b)
eat('米饭','面条','馄饨')  # TypeError: eat() missing 2 required keyword-only arguments: 'a' and 'b'

      若动态参数在前，就会报错，eat函数在调用的时候发现缺少俩个位置参数没有进行传递；原因是动态参数把所有的位置参数都给接受了，所以会报错。

• 形参的顺序：位置参数，动态参数，默认参数

def eat(a,b,*args,c='白菜'):
    print('我想吃',a,b,args,c)
eat('猪肉','粉条','豆腐','大葱')  # 我想吃 猪肉 粉条 ('豆腐', '大葱') 白菜

执行过程：

• 函数定义给形参animal_type指定了默认值’dog’；
• 函数调用时，如果没有给animal_type指定值，python将把这个形参设置为’dog’；

注：

• 使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参，能让python正确地解读位置参数。

小结：

在形参的角度来看，分为三种：

• 位置参数
• 动态参数
• 默认值参数（如果大多数传进来的参数都是一样的，一般使用默认参数）

3.6.动态接收关键字参数

• 使用**来接收动态关键字参数

def func(**kwargs):
    print(kwargs)
func(a=1,b=2,c=3)  # 动态关键字参数最后获取的是一个dict字典的形式
# {'a': 1, 'b': 2, 'c': 3}

• 形参的最终顺序：位置参数 > *args(动态位置参数) > 默认值参数 > **kwargs(动态默认参数)

def func(*args,**kwargs):
    print(args,kwargs)
func(1,23,5,a=1,b=6)  # (1, 23, 5) {'a': 1, 'b': 6}

• 打散动态参数

def func(*args):
    print(args)

lst = [1,2,3,4,5]
func(*lst)

def func2(**kwargs):
    print(kwargs)

dic = {
     'a':111,'b':222}
func2(**dic)
# 在实参位置上用*将lst（可迭代对象）按照顺序打散
# 在形参位置上用*把接收到的参数组合成一个元组

三、函数返回值

• 执行完函数之后，使用return来返回结果；
• 函数中遇到return，此函数结束，return后面的代码不再继续执行；
• return返回值：
  • 如果return后面什么都不写或者干脆就没有写return，返回的结果就是None；
  • 如果return后面写了一个值，返回给调用者这个值；
  • 如果return后面写了多个结果，返回给调用者一个tuple（元组），调用者可以直接使用解构获取多个变量。

def func():
    print(1111)
    return      # ret为 None
    return 555  # ret为 555
    return 555,'asd','fgd'  # ret为 (555, 'asd', 'fgd') 
    print(2222)

ret = func()
print(ret,type(ret))

四、函数调用

• 函数调用让python执行函数的代码。要调用函数，可依此指定函数名以及用括号括起的必要信息。
• 只要遇见了()就是函数的调用。如果没有()就不是函数的调用

五、名称空间

• 在python解释器开始执行之后，就会在内存中开辟一个空间，每当遇到一个变量的时候，就把变量名和值之间的关系记录下来；
• 但当遇到函数定义时，解释器只是把函数名读入内存，表示这个函数已经存在，至于函数内部的变量和逻辑，解释器是不关心的，也就是说一开始函数只是加载进来，仅此而已；
• 只有当函数被调用和访问的时候，解释器才会根据函数内部声明的变量来进行开辟变量的内部空间，随着函数执行完毕，这些函数内部变量占用的空间也会随着函数执行完毕而被清空。

def func():
    a = 80
    print(a)
func()  # 80
print(a)  # NameError: name 'a' is not defined

命名空间：

      存放名字和值的关系的空间称为命名空间。变量在存储时，就存储在该空间内。

命名空间分类：

1. 全局命名空间 — 直接在py文件中，函数外声明的变量都属于全局命名空间；
2. 局部命名空间 — 在函数中声明的变量会放在局部命名空间；
3. 内置命名空间 — 存放在python解释器为我们提供的名字，list,tuple,str,int等这些都是内置命名空间。

加载顺序：

      内置命名空间 > 全局命名空间 > 局部命名空间（函数被执行的时候）

取值顺序：

      局部命名空间 > 全局命名空间 > 内置命名空间

a = 20
def func():
    a = 80
    print(a)
func()  # 80 函数内执行局部命名空间中的a=80
print(a)  # 20 函数外执行全局命名空间中的a=20

作用域：

      作用域就是作用范围，按照生效范围来看分为全局作用域和局部作用域。

• 全局作用域：包括全局命名空间和内置命名空间。在整个文件的任何位置都可以使用（遵循从上到下逐行执行）。可通过globals()函数查看全局作用域中的内容；
• 局部作用域：包括局部命名空间。在函数内部使用。可通过locals()函数查看局部作用域中的变量名和函数信息。

a = 20
def func():
    a = 80
    b = 30
    print(a,b)
    print('haha')
    print(globals())
    print(locals())
func() 
# 执行结果
80 30
haha
{
     '__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001DFB012FFD0>, '__spec__': None, '__annotations__': {
     }, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'c:/Users/Administrator/Desktop/def.py', '__cached__': None, 'a': 20, 'func': <function func at 0x000001DFB00471F0>}
{
     'a': 80, 'b': 30}

六、内置函数

lambda函数：

lambda表示的是匿名函数，不需要用def来声明，一句话就可以声明出一个函数

语法：
      函数名 = lambda 参数：返回值

注意：
      1. 函数的参数可以有多个，多个参数之间用逗号隔开；
      2. 匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据；
      3. 返回值和正常函数一样，可以是任意数据类型，返回值的时候只能返回一个不能返回多个。

def func(n):
    return n**n
print(func(4))      # 256
f = lambda x:x**x
print(f(4))         # 256

Python Lambda函数的几种使用方法：

• Lambda函数+sorted函数    sorted(iterable,key=None,reverse=False)

dic = {
     'a':4,'b':2,'c':10,'d':6}
print(sorted(dic.items(),key=lambda item: item[0]))     # [('a', 4), ('b', 2), ('c', 10), ('d', 6)]
lst = ['1','0','33','45675']
print(sorted(lst,key=lambda s: len(s)))     # 根据lst中字符串的长度进行排序 ['1', '0', '33', '45675']
lst2 = [{
     'id':1,'name':'alex','age':18},{
     'id':2,'name':'wusir','age':17},{
     'id':3,'name':'taibai','age':16}]
print(sorted(lst2,key=lambda e: e['age']))  # 根据lst2中的age大小进行排序 [{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

• Lambda函数+filter函数    filter(function,iterable)

lst = [{
     'id':1,'name':'alex','age':18},{
     'id':2,'name':'wusir','age':17},{
     'id':3,'name':'taibai','age':16}]
f = filter(lambda e: e['age']>17,lst)
print(list(f))    # 筛选lst中年龄大于17的元素 [{'id': 1, 'name': 'alex', 'age': 18}]

• Lambda函数+map函数    map(function,iterable)

lst = [1,2,3,4,5]
lst2 = [6,7,8,9,10]
m = map(lambda n: n*n,lst)
print(list(m))      # [1, 4, 9, 16, 25]
m2 = map(lambda x,y: x+y,lst,lst2)
print(list(m2))     # 计算两个列表中相同位置的数据的和 [7, 9, 11, 13, 15]

• Lambda函数+reduce函数    reduce(function,iterable)

reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
from functools import reduce
def func(x,y):
    return x+y
lst = [1,2,3,4,5]
print(reduce(func,lst))     # 15 此例子使用sum也可以实现

def func2(x,y):
    return x*10+y
ret = reduce(func2,lst)
print(ret)
# 第一次：x=1,y=2,结果12
# 第二次：x=12,y=3,结果123
# 第三次：x=123,y=4,结果1234
# 第四次：x=1234,y=5,结果12345

内置函数：

      python提供的可以直接拿来用的函数。截至python3.9.1，python一共提供了69个内置函数。为了方便记忆和查询，将这些内置函数进行如下分类：

数学运算（7个）

• abs：求数值的绝对值
• divmod ：返回两个数值的商和余数
• max：返回可迭代对象中的元素中的最大值或者所有参数的最大值
• min：返回可迭代对象中的元素中的最小值或者所有参数的最小值
• sum：对元素类型是数值的可迭代对象中的元素求和
• pow（a,b）：求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
• round：对浮点数进行四舍五入求值

print(abs(-10))            # 10
print(divmod(15,2))        # (7,1)
print(max([2,4,3,8]))      # 8
print(min([2,4,3,8]))      # 2
print(sum([2,4,3,8]))      # 17
print(pow(2,3))            # 8
print(pow(2,3,6))          # 2
print(round(12.3356,2))    # 12.34

类型转换（24个）

• bool：根据传入的参数的逻辑值创建一个新的布尔值，如果不给值，返回False
• int：根据传入的参数创建一个新的整数，如果不给值，返回0
• float：根据传入的参数创建一个新的浮点数，如果不给值，返回0.0
• complex：根据传入参数创建一个新的复数，如果不给值，返回0j

print(bool())             # False
print(bool(0))            # False
print(bool(1))            # True
print(int())              # 0
print(int(3.6))           # 3
print(float())            # 0.0
print(float(3))           # 3.0
print(float('3'))         # 3.0
print(complex())          # 0j       当两个参数都不提供时，返回复数 0j
print(complex('1+2j'))    # (1+2j)   传入字符串创建复数
print(complex(3,4))       # (3+4j)   传入数值创建复数

• str：返将数据转化成字符串
• bytearray：根据传入的参数创建一个新的字节数组
• bytes：根据传入的参数创建一个新的不可变字节数组
• memoryview：根据传入的参数创建一个新的内存查看对象

print(str())                        # ''
print(str(None))                    # None
print(str(123))                     # '123'
print(bytearray('中文','utf-8'))    # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
print(bytes('中文','utf-8'))        # b'\xe4\xb8\xad\xe6\x96\x87'
v = memoryview(b'abcdefg')
print(v[0])                         # 97
print(v[1])                         # 98
print(v[-1])                        # 103
# 补充
s1 = '中国'
bs1 = bytes(s1,encoding='utf-8')
print(bs1)           # b'\xe4\xb8\xad\xe6\x96\x87'  字符串转字节
bs2 = str(bs1,encoding='utf-8')
print(bs2)          # 中国 将字节转换成字符串

s2 = '你好'
bs3 = s2.encode('utf-8')
print(bs3)          # b'\xe4\xbd\xa0\xe5\xa5\xbd' 以指定的编码格式编码字符串，此处为utf-8，返回编码后的字符串
bs4 = bs3.decode('utf-8')
print(bs4)          # 你好 以指定的编码格式解码字符串，此处为utf-8，返回解码后的字符串

• ord：返回Unicode字符对应的整数
• chr：返回整数所对应的Unicode字符
• bin：将整数转换成2进制字符串
• oct：将整数转化成8进制数字符串
• hex：将整数转换成16进制字符串

print(ord('a'))  # 97
print(chr(97))   # a
print(bin(10))   # 0b1010 
print(oct(10))   # 0o12
print(hex(10))   # 0xa

• tuple：将一个可迭代对象转换成元组
• list：将一个可迭代对象转换成列表
• dict：根据传入的参数创建一个新的字典
• set：根据传入的参数创建一个新的集合
• frozenset：根据传入的参数创建一个新的不可变集合；创建一个冻结的集合，冻结的集合不能进行添加和删除

print(tuple())          # () 不传入参数，创建空元组
print(tuple('123'))     # ('1', '2', '3') 传入可迭代对象。使用其元素创建新的元组  
print(list())           # [] 不传入参数，创建空列表
print(list('1234'))     # ['1', '2', '3', '4'] 传入可迭代对象，使用其元素创建新的列表
print(dict())                           # {} 不传入任何参数时，返回空字典
print(dict(a = 1,b = 2))                # {'a': 1, 'b': 2} 可以传入键值对创建字典
print(dict((('a',1),('b',2))))          # {'a': 1, 'b': 2} 可以传入可迭代对象创建字典
print(dict(zip(['a','b'],[11 ,22])))    # {'a': 11, 'b': 22} 可以传入映射函数创建字典
print(set())            # set() 不传入参数，创建空集合
print(set(range(10)))   # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 传入可迭代对象，创建集合
print(frozenset(range(10))) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

• enumerate：根据可迭代对象创建枚举对象
• range：根据传入的参数创建一个新的range对象
• iter：根据传入的参数创建一个新的可迭代对象
• slice：根据传入的参数创建一个新的切片对象
• super：根据传入的参数创建一个新的子类和父类关系的代理对象
• object：创建一个新的object对象

lst = ['a','b','c']
for i,k in enumerate(lst):
    print('序号：', i ,'元素：', k)  # 序号： 0 元素： a ;序号： 1 元素： b;序号： 2 元素： c

print(range(10))               # range(0, 10)
print(list(range(10)))         # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(10):
    print(i)                   # 0,1,2,3,4,5,6,7,8,9

a = iter('ab')
print(next(a))          # a
print(next(a))          # b
print(next(a))          # 没有元素，停止迭代，后面的代码不执行  StopIteration

s1 = slice(1,5,2)       # 定义步长和范围，开始idx=1，结束idx=2，步长为2，注意区间是左闭右开
str = 'abcdefg'
print(s1)               # slice(1, 5, 2) 
print(str[s1])          # bd 使用定义好的s1进行切片

class A:
    def add(self,x):
        y = x + 1
        print('aaa')
        print(y)
class B(A):
    def add(self,x):
        print('bbb')
        super().add(x)

b = B()
b.add(3)        # bbb    aaa    4

a = object()
print(a)            #