Python基础——二分法、面向过程编程思想、有名函数、lambda、max、_min的应用、sorted排序、map的应用、filter的应用、reduce的应用

内容回顾

1、叠加多装饰器
    @deco1     => wrapper1
    @deco2     => wrapper2
    @deco3(1)  => wrapper3
    def index():
        pass

2、yield（了解）
    x=yield 返回值

    next(g)
    g.send(1)

3、三元表达式
    res=值1 if 条件 else 值2

4、生成式
    l=[表达式 for x in 可迭代对象 if 条件]


    g=(表达式 for x in 可迭代对象 if 条件)
    next(g)
    sum(表达式 for x in 可迭代对象 if 条件)
    list(表达式 for x in 可迭代对象 if 条件)


    dic={键:值 for k in 可迭代对象 if 条件}
    set1={元素 for k in 可迭代对象 if 条件}

5、函数的递归调用
    def f1():
        print(1111)
        print(2222)
        f2()


    def f2():
        print(2222)
        f1()

    f1()


 def f1():
    print(1111)
    print(2222)
    print(3333)
    f1()

二分法

算法：是高效解决问题的办法算法之二分法
需求：有一个按照从小到大顺序排列的数字列表需要从该数字列表中找到我们想要的那个一个数字如何做更高效？？？

nums = [-3, 4, 7, 10, 13, 21, 43, 77, 89]
find_num = 10

nums = [-3, 4, 13, 10, -2, 7, 89]
nums.sort() # 二分的前提，序列有序，或者有一个明确的分解点
print(nums)

方案一：整体遍历效率太低

for num in nums:
    if num == find_num:
        print('find it')
        break

方案二：二分法

伪代码模板

def binary_search(find_num, 列表):
    mid_val = 找列表中间的值
    if find_num > mid_val:
        # 接下来的查找应该是在列表的右半部分
        列表 = 列表切片右半部分
        binary_search(find_num, 列表)
    elif find_num < mid_val:
        # 接下来的查找应该是在列表的左半部分
        列表 = 列表切片左半部分
        binary_search(find_num, 列表)
    else:
        print('find it')

示范

nums = [-3, 4, 7, 10, 13, 21, 43, 77, 89]
find_num = 8


def binary_search(find_num, l):
    print(l)
    if len(l) == 0:
        print('找的值不存在')
        return
    mid_index = len(l) // 2

    if find_num > l[mid_index]:
        # 接下来的查找应该是在列表的右半部分
        l = l[mid_index+1:]
        binary_search(find_num, l)
    elif find_num < l[mid_index]:
        # 接下来的查找应该是在列表的左半部分
        l = l[:mid_index]
        binary_search(find_num, l)
    else:
        print('find it')

binary_search(find_num, nums)

面向过程编程思想

编程思想/范式
面向过程的编程思想：核心是"过程"二字，过程即流程，指的是做事的步骤：先什么、再什么、后干什么基于该思想编写程序就好比在设计一条流水线
优点：复杂的问题流程化、进而简单化缺点：扩展性非常差
面向过程的编程思想应用场景解析： 1、不是所有的软件都需要频繁更迭：比如编写脚本 2、即便是一个软件需要频繁更迭，也不并不代表这个软件所有的组成部分都需要一起更迭

函数式

def用于定义有名函数

func = 函数的内存地址
def func(x, y):
    return x+y

print(func)

lambda用于定义匿名函数

print(lambda x, y: x+y)

调用匿名函数

res = (lambda x, y: x+y)(1, 2)
print(res)

匿名函数作用

用于临时调用一次的场景：更多的是将匿名与其他函数配合使用

匿名函数的示范

from functools import reduce

salaries = {
    'siry': 3000,
    'tom': 7000,
    'lili': 10000,
    'jack': 2000
}

max的应用

res = max(salaries)
print(res)

def func(k):
    return salaries[k]

res = max(salaries, key=func)  # 返回值=func('siry')
print(res)

res = max(salaries, key=lambda k: salaries[k])
print(res)

min的应用

res = min(salaries, key=lambda k: salaries[k])
print(res)

sorted排序

对List、Dict进行排序，Python提供了两个方法对给定的List L进行排序，方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

--------------------------------sorted---------------------------------------
sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.


-----------------------------------------------------------------------------

参数说明： iterable：是可迭代类型; key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序; reverse：排序规则. reverse = True 降序或者 reverse = False 升序，有默认值。返回值：有序列表
例：列表按照其中每一个值的绝对值排序

l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)

列表按照每一个元素的len排序

l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))

map的应用(了解)

Python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。下面两个返回的都是生成器

l = ['alex', 'lxx', 'wxx', '薛贤妻']
new_l = (name + '_dsb' for name in l)
print(new_l)

res = map(lambda name: name + '_dsb', l)
print(res)  # 生成器

filter的应用（了解）

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

l = ['alex_sb', 'lxx_sb', 'wxx', '薛贤妻']
res = (name for name in l if name.endswith('sb'))
print(res)

res = filter(lambda name: name.endswith('sb'), l)
print(res)

reduce的应用(了解)

from functools import reduce

res = reduce(lambda x, y: x + y, [1, 2, 3], 10)  # 16
print(res)

res = reduce(lambda x, y: x + y, ['a', 'b', 'c'])  # abc
print(res)

模块

什么是模块？

模块就是一系列功能的集合体, 分为三大类
I：内置的模块
II：第三方的模块
III：自定义的模块一个python文件本身就一个模块，文件名m.py，模块名叫m

模块的形式

模块有四种形式

使用python编写的.py文件 2. 已被编译为共享库或DLL的C或C++扩展 3. 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包） 4. 使用C编写并链接到python解释器的内置模块

为何有用模块

I: 内置与第三的模块拿来就用，无需定义，这种拿来主义，可以极大地提升自己的开发效率 II: 自定义的模块，可以将程序的各部分功能提取出来，放到一模块中为大家共享使用，好处是减少了代码冗余，程序组织结构更加清晰

如何用模块

1、 import 使用时 模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句）
PS：我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

import sys 
print(sys.modules)

2、首次导入模块会发生3件事

① 执行foo.py
② 产生foo.py的名称空间，将foo.py运行过程中产生的名字都丢到foo的名称空间中
③ 在当前文件中产生的有一个名字foo，该名字指向2中产生的名称空间；
	之后的导入，都是直接引用首次导入产生的foo.py名称空间, 不会重复执行代码

3、使用

print(foo.x)
print(foo.get)
print(foo.change)

强调1：模块名.名字，是指名道姓地问某一个模块要名字对应的值，不会与当前名称空间中的名字发生冲突强调2：无论是查看还是修改操作的都是模块本身，与调用位置无关强调3：可以以逗号为分隔符在一行导入多个模块，不建议在一行同时导入多个模块
4、导入模块的规范（书写顺序）

I. python内置模块
II. 第三方模块
III. 程序员自定义模块

5、from…import 与import的对比 还有一种导入：from…import ，但是不采用
可以使用__all__来控制（用来发布新版本），在spam.py中新增一行
all=[‘money’,‘read1’] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字
唯一的区别就是：使用from…import…则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀.
from…import…的方式有好处也有坏处好处：使用起来方便了坏处：容易与当前执行文件中的名字冲突
5、模块重命名
为已经导入的模块起别名的方式对编写可扩展的代码很有用 import XXX as xxx
6、模块是第一类对象
7、自定义模块的命名应该采用纯小写+下划线的风格
8、可以在函数内导入模块

def func():
    import foo

接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀.
from…import…的方式有好处也有坏处好处：使用起来方便了坏处：容易与当前执行文件中的名字冲突
5、模块重命名
为已经导入的模块起别名的方式对编写可扩展的代码很有用 import XXX as xxx
6、模块是第一类对象
7、自定义模块的命名应该采用纯小写+下划线的风格
8、可以在函数内导入模块

def func():
    import foo

posted @ 2022-02-28 17:22 喝茶看猴戏阅读(15) 评论(0) 收藏举报来源

刷新页面返回顶部

喝茶看猴戏