Python基础（十二）

最新推荐文章于 2024-08-28 19:34:23 发布
最新推荐文章于 2024-08-28 19:34:23 发布
阅读量149 收藏
点赞数
文章标签： Python基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianlang1996/article/details/101869020
版权

今日主要内容

  • 推导式
  • 生成器表达式
  • 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()

  • 后续补充…

天狼大大
关注
Python基础知识点总结
Python全栈系列
08-25 7万+
本文包括python基本知识：简单数据结构，数据结构类型（可变：列表，字典，集合，不可变：数值类型，字符串，元组），分支循环和控制流程，类和函数，文件处理和异常等等。
python基础（十二）：名称空间与作用域
01-21
文章目录一、名称空间1、内置名称空间2、全局名称空间3、局部名称空间二、作用域1、作用域与名字查找的优先级2、LEGB（四种名称空间）3、global关键字4、nonlocal关键字 一、名称空间 首先我们应该知道，栈一般存...
Python 生成器的惰性机制
weixin_45332302的博客
02-10 477
Python 生成器的惰性机制 def add(a, b): return a + b def test(): for x in range(4): yield x g=test() for n in [2, 10]: g = (add(n, i) for i in g) # 惰性机制，当n=2时并不会往里面代值，只有拿值的时候才会代值 # 后面出现...
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 118万+
Python 入门必备知识，你都掌握了吗？
Python基础十二：切片
CSer
07-12 162
Python基础十二：迭代
CSer
07-12 132
python基础知识点大全
liuyu_719的博客
06-01 3万+
什么是CPython?编译型与解释型编程语言一般认为，Python与Java都是解释型语言，只是不那么纯粹。也可以认为它们是先编译再解释的编程语言。并非所有高级语言都是要么是编译型语言，要么就是解释型语言。打印输出什么是变量：为什么要有变量：如何使用变量：变量的命名规范：变量名只能是字母、数字或下划线的任意组合变量名的第一个字符不能是数字关键字不能声明为变量名，常用关键字如下 变量的命名风格驼峰体 纯小写下划线(在python中，变量名的命名推荐使用该风格) 变量具有的三大特性 可以多个变量一起
Python基础十二：面向对象编程一：类和实例
永春的CSDN博客
05-14 1万+
Python基础十二：面向对象编程一：类和实例 Python基础系列内容为学习廖雪峰老师Python3教程的记录，廖雪峰老师官网地址：廖雪峰Python3教程 Author:yooongchun Email:yooongchun@foxmail.com 面向对象编程简介：面向对象编程Object Oriented Programming简称OOP，是一种区别于面向过程...
python基础学习总结(十二)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-28 976
Python 标准数据库接口为 Python DB-API，Python DB-API为开发人员提供了数据库应用编程接口。GadFlymSQLMySQLPostgreSQLInformixInterbaseOracleSybase不同的数据库你需要下载不同的DB API模块，例如你需要访问Oracle数据库和Mysql数据，你需要下载Oracle和MySQL数据库模块。
python基础语法
weixin_49390750的博客
12-26 1217
python基础语法
Python基础知识(十二)
qq_41511262的博客
09-27 125
Python基础知识（十二） 一、CSV文件读取处理 （1） 创建一个虚拟环境，避免和主解释器混淆 （2） 下载包 （3） 把不同的文件放在不同的目录中 （4） 写入文件 运行结果 （5） 从SQL中导出一张表csv放在项目下进行操作 打开sql,点击导出数据 点击下一步 服务器名称： . 数据名名称PMS 到处平面文件目标 放入python项目所在的目...
Python 基础课程《3.python基础语法》
05-28
### Python基础课程知识点详解 #### 一、变量 在编程中，**变量**是指用于存储数据的内存位置。我们可以将变量想象成一个容器或者盒子，这个盒子用来存储各种类型的数据。例如，在Python中，你可以创建一个名为`...
十二、python基础：函数的返回值return
12-22
在Python编程语言中，函数是组织良好、可重复使用的代码块，它们用于执行特定任务。在函数中，`return`语句是一个至关重要的概念，它允许函数向调用它的代码传递结果。本节将深入探讨Python函数的返回值及其作用。 ...
Python编程基础 Python语言程序教程 Python基础入门教程 共131页.pptx
06-22
### Python编程基础知识点详解 #### 一、Python语言的历史、简介及发展方向概述 - **历史**: Python由Guido van Rossum在1989年圣诞节期间构思设计，并于1991年发布了第一个公开发行版——Python 0.9.0。Python的...
python基础语法全解
03-08
### Python基础语法全解 #### 一、了解Python Python是一种功能强大且易于学习的编程语言，具有简单清晰的语法特点。它支持多种编程范式，包括面向对象、过程式和函数式编程风格。Python的设计哲学强调代码的...
基于H5的宿舍管理系统.zip
11-09
基于SSM的毕业设计源码
CSP-J历年复赛真题资源.txt
最新发布
11-09
CSP-J历年复赛真题资源.txt
【激光雷达】激光雷达数据处理（点云数据滤波、误差分析、模型验证、三维表面拟合）【含Matlab源码 9065期】.mp4
11-09
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
macOS_Sequoia_15.1.password(imacos.top).rdr.split.012
11-09
macOS_Sequoia_15.1.password(imacos.top).rdr.split.012
深入掌握人工智能中的Python基础技巧
资源摘要信息: "人工智能python基础2" 知识点一：Python语言特性 Python是一种解释型、高级、面向对象的编程语言，它以其简洁明了的语法和强大的功能支持库而广受开发者的喜爱。Python的语法简单，适合快速开发。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值