Python基础（十二）

2024年3月5日 132次阅读

今日主要内容

  • 推导式
  • 生成器表达式
  • lambda匿名函数
  • 内置函数介绍

一、推导式

（一）列表推导式

  • 先来看一段代码

    • 建立一个空列表，向空列表中添加元素
    lst = list()
for i in range(5):
  lst.append(i)
print(lst)

运行结果：
[0, 1, 2, 3, 4]
    • 利用列表推导式，效果一样
    lst = [i for i in range(5)]
print(lst)

运行结果：
[0, 1, 2, 3, 4]

  1. 循环模式：

    • 格式：[元素 for 元素 in 可迭代对象]
    • 执行流程：每次for循环将元素添加到列表中
    lst = [i for i in range(5)]
print(lst)

运行结果：
[0, 1, 2, 3, 4]

  2. 筛选模式

    筛选模式：

    • 格式：[元素 for 变量 in 可迭代对象 if 条件]
    • 执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到列表中
    lst = [i for i in range(5) if i > 2]
print(lst)

运行结果：
[3, 4]

（二）字典推导式

  • 同理，先来看一段代码

    • 建立一个空字典，向字典中添加键值对
    dic = dict()
for i in range(1, 5):
  dic[f"k{i}"] = i
print(dic)

运行结果：
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
    • 使用字典推导式，效果一样
    dic = {f"k{i}": i for i in range(1, 5)}
print(dic)

运行结果：
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

  1. 循环模式：

    • 格式：{键值对 for 元素 in 可迭代对象}
    • 执行流程：执行for循环利用元素组成键值对添加到字典中
    dic = {f"k{i}": i for i in range(1, 5)}
print(dic)

运行结果：
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

  2. 筛选模式：

    • 格式：{键值对 for 元素 in 可迭代对象 if 条件}
    • 执行流程：执行for循环并判断元素是否符合条件，利用符合条件的元素组成键值对添加到字典中
    dic = {f"k{i}": i for i in range(1, 5) if i > 2}
print(dic)

运行结果：
{'k3': 3, 'k4': 4}

（三）集合推导式

  • 与列表一样，这里就不再举例了

  1. 循环模式：

    • 格式：{元素 for 元素 in 可迭代对象}
    • 执行流程：每次for循环将元素添加到集合中
    st = {i for i in range(5)}
print(st)

运行结果：
{0, 1, 2, 3, 4}

  2. 筛选模式：

    • 格式：{元素 for 变量 in 可迭代对象 if 条件}`
    • 执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到集合中
    lst = {i for i in range(5) if i > 2}
print(st)

运行结果：
{3, 4}

（四）推导式应用

  • 来看几个推导式的应用例题

  1. 求字符串s = "zxdhnbhnb"中”h”的索引

    s = "zxdhnbhnb"
lst = [i for i in range(len(s)) if s[i] == "h"]
print(lst)

运行结果：
[3, 6]

  2. 将下列列表中带两个”e”的元素添加到新列表

    names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
lst = [name for i in names for name in i if name.count("e") == 2]
print(lst)

运行结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']

二、生成器表达式

（一）回顾：通过函数实现生成器

  • 回顾一下通过函数实现生成器

    • 将函数return变成yield就变成了生成器
    def func():
  yield 1
  yield 2
  yield 3

g = func()
print(next(g))
print(next(g))
print(next(g))

运行结果：
1 2 3

（二）生成器表达式

  1. 通过表达式实现生成器

    • 将列表推导式的方括号[]变成圆括号()，就成了生成器表达式
    lst = [i for i in range(5)]
print(type(lst))
g = (i for i in range(5))
print(type(g))

运行结果：
<class 'list'>
<class 'generator'>
    • 转换成通过函数实现的生成器（二者等价）
    # g = (i for i in range(5))

def func():    # 二者等价
 for i in range(5):
     yield i
g= func()

print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

运行结果：
0 1 2 3 4

  2. 生成器表达式结构：

    • 普通模式：

      • 格式：(元素 for 元素 in 可迭代对象)
      • 运行机制：惰性机制，不取值不运行，每次取值得到一个结果
      g = (i for i in range(5))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

运行结果：
0 1 2 3 4

    • 筛选模式：

      • 格式：(元素 for 元素 in 可迭代对象 if 条件)
      • 运行机制：惰性机制，不取值不运行，每次取值得到一个满足判断条件的结果
      g = (i for i in range(5) if i > 2)
print(next(g))
print(next(g))

运行结果：
3 4

  3. 生成器的取值方式补充：

    • 之前提到过的最正宗的next(生成器)
    g = (i for i in range(5))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

运行结果：
0 1 2 3 4
    • 通过for循环取值
    g = (i for i in range(5))
for el in g:
 print(el)

运行结果：
0 1 2 3 4
    • 通过list()、tuple()、set()取值
    g = (i for i in range(5))
print(list(g))
print(tuple(g))
print(set(g))

运行结果：
[0, 1, 2, 3, 4]
(0, 1, 2, 3, 4)
{0, 1, 2, 3, 4}

  4. 真正理解生成器的惰性机制，来看一道例题：

    def add(a, b):
    return a + b


def test():
    for r_i in range(4):
        yield r_i


g = test()

for n in [2, 10]:
    g = (add(n, i) for i in g)
print(list(g))

运行结果：
[20,21,22,23]
    解析：生成器只有在取值的时候才会去运行，上述例题只有最后'print(list(g))'取值。

"""
g = test()
for n in [2, 10]:
    g = (add(n, i) for i in g)
"""

所以上面的for循环可以写成如下代码：
"""
n = 10
g = (add(n, i) for i in (add(n, i) for i in test()))
"""
最终代入得到的列表为：[20, 21, 22, 23]

三、lambda匿名函数

（一）匿名函数定义

  1. python中为了解决一些简单的需求可以使用一句话定义一个函数，这就是lambda匿名函数

  2. lambda语法结构：

    • 函数名 = lambda 形参:返回值
    # def func(x, y):  
#     return x + y
# print(func(1, 2))

func = lambda x, y: x+y  # 两个函数等价
print(func(1, 2))

运行结果：
3

  3. 注意事项：

    • 形参：可以接受多个所有类型参数（位置、动态位置、默认值、动态关键字）
    func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs
print(func(3, 4,c=666,name='zxd'))  
# 只返回kwargs

运行结果：
{'name': 'zxd'}
    • 返回值：只能返回一个数据（任意数据类型），必须写
    func = lambda x:(x[0],x[2])
print(func('zxdnb'))

运行结果：
('z', 'd')
    • 返回值也可以是三元表达式
    func = lambda x,y: x if x > y else y
print(func(3,100))

运行结果：
100

（二）结合匿名函数的列表推导式

  • 例一：

    • 列表推导式：
    g = [lambda :i+1 for i in range(3)]
print([em() for em in g])

运行结果：
[3, 3, 3]
    • 转换为普通代码
    g = list()
for i in range(3):
  def func():
      return i + 1
  g.append(func)

new_g = list()
for em in g:
  new_g.append(em())
print(new_g)

运行结果：
[3, 3, 3]

  • 例二：

    • 列表推导式：
    g = [lambda i:i+1 for i in range(3)]
print([em(3) for em in g])

运行结果：
[4, 4, 4]
    • 转换为普通代码
    g = list()
for i in range(3):
  def func(i):
      return i + 1
  g.append(func)

new_g = list()
for em in g:
  new_g.append(em(3))
print(new_g)

运行结果：
[4, 4, 4]

（三）结合匿名函数的生成器表达式

  • 例一：

    • 生成器表达式：
    g = (lambda i:i+1 for i in range(3))
print([em(3) for em in g])

运行结果：
[4, 4, 4]
    • 转换为函数实现的生成器：
    def g():
    for i in range(3):
        def func(i):
            return i + 1
        yield func

new_g = list()
for em in g():
    new_g.append(em(3))
print(new_g)

运行结果：
[4, 4, 4]

  • 例二：

    • 生成器表达式：
    g = (lambda :i+1 for i in range(3))
print([em() for em in g])

运行结果：
[1, 2, 3]
    • 转换为函数实现的生成器：
    def g():
    for i in range(3):
        def func():
            return i + 1
        yield func

new_g = list()
for em in g():
    new_g.append(em())
print(new_g)

运行结果：
[1, 2, 3]

  • 例三：

    • 生成器表达式
    g = (lambda x:x*i for i in range(3))
for j in [2,10]:
    g1 = (em(3) for em in g)
print([e+j for e in g1])

运行结果：
[10, 13, 16]
    • 转换为普通代码
    def g():
    for i in range(3):
        def func(x):
            return x * i
        yield func

for j in [2, 10]:
    def g1():
        for em in g():
            yield em(3)

new_g = list()
for e in g1():
  new_g.append(e + j)
print(new_g)

运行结果：
[10, 13, 16]

四、内置函数

  • 查看解释器内置常量和内置函数的方法

    • dir(__builtins__)

  • Python3.6.8的内置函数（共72个）

    absallanyasciibinbool
    bytearraybytescallablechrclassmethodcompile
    complexcopyrightcreditsdelattrdictdir
    divmodenumerateevalexecexitfilter
    floatformatfrozensetgetattrglobalshasattr
    hashhelphexidinputint
    isinstanceissubclassiterlenlicenselist
    localsmapmaxmemoryviewminnext
    objectoctopenordpowprint
    propertyquitrangereprreversedround
    setsetattrslicesortedstaticmethodstr
    sumsupertupletypevarszip

（一）基础函数（了解）

  • all()any()bytes()callable()
    chr()ord()complex()divmid()
    eval()exec()frozenset()help()
    globals()locals()hash()id()
    iter()next()bin()oct()
    int()hex()pow()repr()
    round()bool()

  1. all()

    • 函数定义：all(*args, **kwargs)
    • 函数说明：填入参数为可迭代对象，如果可迭代对象中每一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True
    print(all([1, 2, 3, 4, 5]))
print(all([0, 1, 2, 3, 4]))
print(all([]))

运行结果：
True
False
True

  2. any()

    • 函数定义：any(*args, **kwargs)
    • 函数说明：填入参数为可迭代对象，如果可迭代对象中只要有一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True
    print(any([0, "", 1, False]))
print(any([0, "", [], False]))
print(any([]))

运行结果：
True
False
False

  3. bytes()

    • 函数定义：bytes(value=b'', encoding=None, errors='strict')
    • 函数说明：将填入对象转换为字节形式，需要指定编码方式
    print("张旭东".encode("utf-8"))
print(bytes("张旭东", encoding="utf-8"))

运行结果：
b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c'
b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c'

  4. callable()

    • 函数定义：callable(i_e_, some_kind_of_function)
    • 函数说明：判断对象是否可以调用（类也是可调用的，类的实例可调用__call__()方法）
    def func():
 print("hello world")

print(callable(func))

运行结果：
True

  5. chr()

    • 函数定义：chr(*args, **kwargs)
    • 函数说明：返回Unicode对应的字符串
    print(chr(65))

运行结果：
A

  6. ord()

    • 函数定义：ord(*args, **kwargs)
    • 函数说明：返回一个字符串对应的Unicode编码值
    print(ord("A"))

运行结果：
65

  7. complex()

    • 函数定义：complex(real, imag=None)
    • 函数说明：返回一个数的复数形式
    print(complex(20))

运行结果：
(20+0j)

  8. divmid()

    • 函数定义：divmod(x, y)
    • 函数说明：返回元组(x // y, x % y)
    print(divmod(10, 3))

运行结果：
(3, 1)

  9. eval()（不推荐使用）

    • 函数定义：eval(*args, **kwargs)
    • 函数说明：可以计算给定的参数，参数只能是简单表达式
    print(eval("5 + 3"))

运行结果：
8

  10. exec()（不推荐使用）

    • 函数定义：exec(*args, **kwargs)
    • 函数说明：可以计算给定的参数，参数可以是代码块
    exec("for i in range(10):print(i)")

运行结果：
0
1
2
3
4

  11. frozenset()

    • 函数定义：frozenset(obj)
    • 函数说明：将对象转换为不可变集合
    print(frozenset((1,2,3)))

运行结果：
frozenset({1, 2, 3})

  12. help()

    • 函数定义：help(args)
    • 函数说明：查看帮助
    help(list.append)

运行结果：
Help on method_descriptor:

append(...)
    L.append(object) -> None -- append object to end

  13. globals()

    • 函数定义：globals(*args, **kwargs)
    • 函数说明：返回包含当前作用域的全局变量的字典
    a = 5
b = 10
def func():
    print("hello world")
print(globals())

运行结果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000221ED9D69E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python_S26/day12/exercise.py', '__cached__': None, 'a': 5, 'b': 10, 'func': <function func at 0x00000221ED8D1EA0>}

  14. locals()

    • 函数定义：locals(*args, **kwargs)
    • 函数说明：返回一个包含当前作用域的局部变量的字典
    a = 5
def func():
    b = 10
    print(locals())

func()

运行结果：
{'b': 10}

  15. hash()

    • 函数定义：hash(*args, **kwargs)
    • 函数说明：返回对象的哈希值
    print(hash("zxd"))

运行结果：
5236597812272808709

  16. id()

    • 函数定义：id(*args, **kwargs)
    • 函数说明：返回对象的id，在CPython中返回的是对象的内存地址
    print(id(10))

运行结果：
1864728976

  17. iter()

    • 函数定义：iter(iterable, sentinel=None)
    • 函数说明：传入可迭代对象，获取迭代器
    lst = [1, 2, 3, 4, 5]
t = iter(lst)
print(t)

运行结果：
<list_iterator object at 0x00000181FB2CA9B0>

  18. next()

    • 函数定义：next(iterator, default=None)
    • 函数说明：返回迭代器的下一项，若提供了默认值，并且迭代器已耗尽，则返回它而不是引发StopIteration
    t = iter([1, 2, 3, 4, 5])
print(next(t, None))
print(next(t, None))
print(next(t, None))
print(next(t, None))
print(next(t, None))
print(next(t, None))

运行结果：
1
2
3
4
5
None

  19. bin()

    • 函数定义：bin(*args, **kwargs)
    • 函数说明：返回整数的二进制形式
    print(bin(10))

运行结果：
0b1010

  20. oct()

    • 函数定义：oct(*args, **kwargs)
    • 函数说明：返回整数的八进制形式
    print(oct(10))

运行结果：
0o12

  21. int()

    • 函数定义：int(x, base=10)
    • 函数说明：返回对应进制的十进制，需填入对应进制数字符串形式，并填入进制数
    print(int("0b1010", 2))
print(int("0o12", 8))

运行结果：
10
10

  22. hex()

    • 函数定义：hex(*args, **kwargs)
    • 函数说明：返回整数的十六进制形式
    print(hex(20))

运行结果：
0x14

  23. pow()

    • 函数定义：pow(*args, **kwargs)
    • 函数说明：填入两个参数时，求x的y次幂；填入三个参数时，求x的y次幂在与z取余
    print(pow(2, 4))
print(pow(2, 4, 3))

运行结果：
16
1

  24. repr()

    • 函数定义：repr(obj)
    • 函数说明：返回规范字符串的表现形式
    s = "zxd"
print(repr(s))

运行结果：
'zxd'

  25. round()

    • 函数定义：round(number, ndigits=None)
    • 函数说明：将数字四舍五入为十进制整数
    print(round(3.5))

运行结果：
4

（二）常用函数（会用）

  • abs()format()enumerate()open()
    range()print()input()len()
    list()dict()str()set()
    tuple()float()reversedsum()
    dir()type()zip()bool()

  1. abs()

    • 函数定义：abs(*args, **kwargs)
    • 函数说明：返回参数的绝对值
    print(abs(-1))

运行结果：
1

  2. format()

    • 函数定义：format(*args, **kwargs)
    • 函数说明：返回格式化后的字符串
    s = "你好"
print(format(s, ">20"))  # 右对齐20位，多余的部分用空格补齐
print(format(s, "<20"))  # 左对齐20位，多余的部分用空格补齐
print(format(s, "^20"))  # 居中共20位，多余的部分用空格补齐

运行结果：
                  你好
你好                  
         你好         
    s = 18
print(format(s, "08b"))  # 共八位，转换为二进制
print(format(s, "08o"))  # 共八位，转换为八进制
print(format(s, "08x"))  # 共八位，转换为十六进制
print(format(s, "08d"))  # 共八位，转换为十进制

运行结果：
00010010
00000022
00000012
00000018

  3. enumerate()

    • 函数定义：enumerate(iterable, start=0)
    • 函数说明：枚举，遍历可迭代对象并给定对应遍历的数字，以元组的形式返回，第二个参数可指定遍历数字的起始值
    lst = [1, 2, 3, 4, 5]
for i in enumerate(lst):
    print(i)

运行结果：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
    lst = [1, 2, 3, 4, 5]
for i in enumerate(lst, 10):  # 指定起始值
    print(i)

运行结果：
(10, 1)
(11, 2)
(12, 3)
(13, 4)
(14, 5)

  4. open()

    • 函数定义：open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)
    • 函数说明：打开一个文件，指定文件路径file 、文件打开模式mode、文件编码encoding，返回一个文件句柄用于操作文件，其余参数暂时忽略
    f = open("text.txt", mode="r", encoding="utf-8")
f.read()
f.close()

  5. range()

    • 函数定义：range(start, stop[, step])
    • 函数说明：返回一个对象，该对象可以从开始一个一个返回一个递增的整数序列一直到结束，如果有步长参数，则按照步长返回
    for i in range(5):
 print(i)

运行结果：
0
1
2
3
4

  6. print()

    • 函数定义：print(self, *args, sep=' ', end='\n', file=None)
    • 函数说明：在控制台打印参数，可填入参数sep来替代元素之间的逗号，可填入参数end来控制结尾的换行，可填入参数file将打印的内容写入文件
    print("zxd", "znb", sep="-", end="!")

运行结果：
zxd-znb!

  7. input()

    • 函数定义：input(*args, **kwargs)
    • 函数说明：将输入内容转换为字符串，可填出参数用来提示用户
    name = input("请输入姓名:")
print(name)

运行结果：
zxd

  8. len()

    • 函数定义：len(*args, **kwargs)
    • 函数说明：返回容器中的项数
    lst = [1, 2, 3, 4, 5]
print(len(lst))

运行结果：
5

  9. list()

    • 函数定义：
      • list()
      • list(iterable)
    • 函数说明：
      • 默认创建空列表
      • 将可迭代对象转换为列表
    print(list())
print(list(range(5)))

运行结果：
[]
[0, 1, 2, 3, 4]

  10. dict()

    • 函数定义：
      • dict()
      • dict(mapping)
      • dict(iterable)
      • dict(**kwargs)
    • 函数说明：
      • 默认创建空字典
      • 可填入映射创建字典
      • 可填入二元组列表创建字典
      • 可填入关键字参数常见列表
    print(dict())
print(dict({"k1": 1, "k2": 2}))
print(dict([("k1", 1), ("k2", 2)]))
print(dict(k1=1, k2=2))

运行结果：
{}
{'k1': 1, 'k2': 2}
{'k1': 1, 'k2': 2}
{'k1': 1, 'k2': 2}

  11. str()

    • 函数定义：

      • str()

      • str(value='', encoding=None, errors='strict')

    • 函数说明：

      • 默认创建空字符串

      • 可将参数转换为字符串类型，若填入参数为字节类型，需指定编码方式

    print(repr(str(123)))
print(str(b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c',encoding="utf-8"))

运行结果：
张旭东
'123'

  12. set()

    • 函数定义：
      • set()
      • set(iterable)
    • 函数说明：
      • 默认创建空集合
      • 将可迭代对象转换为集合（自动去重）
    print(set())
print(set([1,2,3,4,5]))

运行结果：
set()
{1, 2, 3, 4, 5}

  13. tuple()

    • 函数定义：
      • tuple()
      • tuple(iterable)
    • 函数说明：
      • 默认创建空元组
      • 将可迭代对象转换为元组
    print(tuple())
print(tuple([1, 2, 3, 4, 5]))

运行结果：
()
(1, 2, 3, 4, 5)

  14. float()

    • 函数定义：float(x)
    • 函数说明：将参数转换为浮点型
    print(float(123))

运行结果：
123.0

  15. reversed

    • 函数定义：reversed(sequence)
    • 函数说明：将传入的可迭代对象反向迭代，返回一个迭代器
    lst = [1, 2, 3, 4, 5]
print(reversed(lst))
print(list(reversed(lst)))

运行结果：
<list_reverseiterator object at 0x000002043A55A9B0>
[5, 4, 3, 2, 1]

  16. sum()

    • 函数定义：sum(*args, **kwargs)
    • 函数说明：将填入的参数求和，填入的参数必须是可迭代对象
    print(sum([1, 2, 3, 4, 5]))

运行结果：
15

  17. dir()

    • 函数定义：dir([object])
    • 函数说明：查看对象的方法
    print(dir(list))

运行结果：
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

  18. type()

    • 函数定义：type(object_or_name, bases, dict)
    • 函数说明：查看对象的类型（其实type()既是函数，又是元类(创造类的类)，可以通过type()创建一个类）
    print(type(list()))

运行结果：
<class 'list'>

  19. zip()

    • 函数定义：zip(iter1 [,iter2 [...]])
    • 函数说明：拉链函数，返回一个迭代器，将所有可迭代对象的元素按照位置打包成元组，直到耗尽项数最少的可迭代对象
    lst1 = [1, 2, 3]
lst2 = [1, 2, 3, 4, 5]
print(zip(lst1, lst2))
print(list(zip(lst1, lst2)))

运行结果：
<zip object at 0x00000204D6E621C8>
[(1, 1), (2, 2), (3, 3)]

  20. bool()

    • 函数定义：bool(x)
    • 函数说明：将传入的参数转换成布尔值，若不填入参数返回False
    print(bool())
print(bool(123))

运行结果：
False
True

（三）高阶函数（熟练）

  • 高阶函数全部需要结合规则函数，利用lambda匿名函数构造规则函数

  • filter()筛选过滤
    map()映射
    sorted()排序
    max()求最大值
    min()求最小值
    reduce()累计算

  1. filter()

    • 筛选过滤功能
    • 函数定义：filter(function or None, iterable)
    • 函数说明：返回一个迭代器，该迭代器返回满足规格函数的可迭代对象中的元素，若函数为None，返回可迭代对象中为True的元素
    # 规则函数为None，返回可迭代对象中True的元素
print(list(filter(None, [0, 1, 2, 3])))

运行结果：
[1, 2, 3]
    # 返回满足规则函数可迭代对象中的元素
print(list(filter(lambda x: x > 1, [0, 1, 2, 3])))

运行结果：
[2, 3]

  2. map()

    • 映射功能
    • 函数定义：map(func, *iterables)
    • 函数说明：创建一个迭代器，它使用可迭代对象中的每个元素当作参数执行规则函数，直到最短的可迭代对象耗尽为止
    print(list(map(lambda x: x ** 2, [1, 2, 3])))

运行结果：
[1, 4, 9]

  3. sorted()

    • 排序功能
    • 函数定义：sorted(*args, **kwargs)
    • 函数说明：返回一个列表，按照可迭代对象中的元素升序排列，还可以指定key=规则函数按照规则函数来排序，还可以指定reverse=True来降序排列
    • 与列表中list.sort()的区别：
      • list.sort()改变的是原有列表
      • sorted()建立的新列表
    lst = [4, 2, 3, 7, 1]
print(sorted(lst))
print(lst)  # 不改变原来列表

运行结果：
[1, 2, 3, 4, 7]
[4, 2, 3, 7, 1]
    dic = {"k1": 3, "k2": 13, "k3": 1}
print(sorted(dic, key=lambda x: dic[x], reverse=True))

运行结果：
['k2', 'k1', 'k3']

  4. max()

    • 返回最大值

    • 函数定义：

      • max(iterable, *[, default=obj, key=func])
      • max(arg1, arg2, *args, *[, key=func])

    • 函数说明：

      • 使用单个可迭代对象，返回其中的最大值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数
      lst1 = [1, 2, 3, 4, 5, -6]
lst2 = []
print(max(lst1))
print(max(lst1, key=abs))  # 制定规则参数，返回绝对值最大的元素
print(max(lst2, default=1)) # 当lst2为空的时候返回1

运行结果：
5
-6
1
      • 使用两个或更多的参数，返回其中最大的参数
      a = 5
b = 10
print(max(a, b))

运行结果：
10

  5. min()

    • 返回最小值

    • 函数定义：

      • min(iterable, *[, default=obj, key=func])
      • min(arg1, arg2, *args, *[, key=func])

    • 函数说明：

      • 使用单个可迭代对象，返回其中的最小值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数
      lst1 = [1, -2, 3, -4, 5, -6]
lst2 = []
print(min(lst1))
print(min(lst1, key=abs))
print(min(lst2, default=1))

运行结果：
-6
1
1
      • 使用两个或更多的参数，返回其中最小的参数
      a = 5
b = 10
print(min(a, b))

运行结果：
5

  6. reduce()

    • 累计算
    • 函数定义：reduce(function, sequence, initial=None)
    • 函数说明：按照规则函数将序列从左到右累计算，若有initial参数则作为序列的第一项，并在序列为空时作为默认值
    from functools import reduce

print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5]))
print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5], 5))
print(reduce(lambda x, y: x * y, [], 5))

运行结果：
120
600
5

（四）面向对象函数

  • classmethod()delattr()getattr()
    hasattr()issubclass()isinstance()
    object()property()setattr()
    staticmethod()super()
  • 后续补充…
点赞