Python基础（五）—— def、lambda、面向对象编程

share16

已于 2022-05-14 22:05:56 修改

阅读量876

点赞数 1

分类专栏： Python # python基础文章标签： python

于 2022-04-12 23:08:19 首次发布

本文链接：https://blog.csdn.net/weixin_42330887/article/details/124098596

版权

Python 同时被 2 个专栏收录

26 篇文章 6 订阅

订阅专栏

python基础

7 篇文章 0 订阅

订阅专栏

Python基础

Python基础（五）

Python基础（五）

大家可以关注知乎或微信公众号的‘share16’，我们也会同步更新此文章。

在 Python 里有两类函数：

第一类：用 def 关键词定义的正规函数；
第二类：用 lambda 关键词定义的匿名函数；

十一、函数(def)

11.1 函数的定义

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

# 函数的定义

def 函数名(参数列表):
    "文档字符串"  #（用于说明存放的函数；可以是单/双/三引号，不能是#号；此行可有可无）
    function_suite
    return [表达式]

11.2 函数的调用及文档

函数的调用：定义完一个函数后，可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
函数的文档：查看函数的文档字符串，用 print(函数名._doc_) 或 help(函数名)。

def printresult(str):
    '打印字符串'
    print(str)
    
s = '1234567890'
printresult(s)                    # 函数的调用
print(printresult.__doc__)   # 函数的文档
help(printresult)               # 函数的文档


# 运行结果：
# >> 1234567890 
# >> 打印字符串 
# >> help(printresult) 的结果，如下：
''' Help on function printresult in module __main__:

printresult(str)
    打印字符串 '''

11.3 函数的参数

位置参数 (positional argument)，这些参数在调用函数时位置要固定；
默认参数 (default argument)，调用函数时，默认参数的值如果没有传入，则被认为是默认值；默认参数一定要放在位置参数后面，不然程序会报错；
可变参数 (variable argument)，就是传入的参数个数是可变的，可以是0到任意个(自动组装成元组)，是不定长的参数；加了星号(*)的变量名会存放所有未命名的变量参数；
关键字参数 (keyword argument)，可以是从0到任意个，自动组装成字典；
命名关键字参数 (name keyword argument)，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
参数组合：可以用上述5种参数，其中的 4 个都可以一起使用，但是注意：参数定义的顺序必须是：(位置参数、默认参数、可变参数和关键字参数) 或 (位置参数、默认参数、命名关键字参数和关键字参数)；警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。

def 函数名(arg1, arg2=v, *args, *, nkw, **kw):
# arg1     位置参数
# arg2 = v 默认参数，arg2 = 默认值
# *args    可变参数
# *, nkw   命名关键字参数
# **kw     关键字参数

11.4 变量的作用域

Python 中程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
定义在函数外部的变量拥有全局作用域，该变量称为全局变量。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

# 内嵌函数

def outer():
    print('outer函数在这被调用')
    def inner():
        print('inner函数在这被调用')
    inner()  # 该函数只能在outer函数内部被调用
outer()

# >> outer函数在这被调用
# >> inner函数在这被调用

# 若没有 inner() ，执行结果只有 ‘outer函数在这被调用’

闭包：如果要修改闭包作用域中的变量则需要 nonlocal 关键字

是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

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

# 斐波那契数列 " f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1 "
def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)

x = []
y = list()
for k in range(11):
    x.append(k)
    y.append(recur_fibo(k))

print(x)
print(y)

# >> [0, 1, 2, 3, 4, 5, 6,  7,  8,  9, 10]
# >> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

十二、匿名函数(lambda)

12.1 匿名函数的定义

使用 lambda 关键词来创建，语法为：lambda 参数:表达式

注意：

表达式中没有return语句，因为lambda不需它来返回，其本身结果就是返回值；
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数；

12.2 匿名函数的应用

函数式编程：是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

匿名函数，常应用于函数式编程的高阶函数中，主要有两种形式：

参数是函数 (filter, map)
返回值是函数 (closure)

filter(function, iterable)

用于过滤序列，过滤掉不符合条件的元素，返回iterable中符合条件的元素；用‘y=f(x)’来看的话，filter返回的是x；
iterable可以是列表/元组/集合，但里面的元素不能有字符串；
运行结果是一个迭代器对象，如果要转换为列表，可以使用 list() 来转换；
function可以是lambda，也可以是def；

map(function, *iterables)

根据提供的函数对指定序列做映射，用‘y=f(x)’来看的话，map返回的是y；
iterable可以是字符串/列表/元组/集合，具体方法根据function来决定；
运行结果是一个迭代器对象，如果要转换为列表，可以使用 list() 来转换；
function可以是lambda，也可以是def；

# filter 函数
print(filter(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9]),type(filter(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9])), sep=',  ')
# >> <filter object at 0x1046f43d0>,  <class 'filter'>

print(list(filter(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9])), type(list(filter(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9]))), sep=', ')
# >> [3, 9], <class 'list'>


# map 函数
print(map(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9]),type(map(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9])), sep=',  ')
# >> <map object at 0x1051365e0>,  <class 'map'>

print(list(map(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9])), type(list(map(lambda x : x%3 == 0 ,  [1, 3, 5, 7, 9]))), sep=', ')
# >> [False, True, False, False, True], <class 'list'>

十三、面向对象编程

13.1 面向对象的基本特征

类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。
方法：类中定义的函数。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量；实例变量就是一个用 self 修饰的变量，相当于 C++ 的 this 指针。
类变量：在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
继承：子类自动共享父类之间数据和方法的机制。
多态：不同对象对同一方法响应不同的行动；
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
私有变量：只需要在变量名或函数名前加上“__”两个下划线