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

文章目录

• 内容回顾
• 二分法
• • 伪代码模板
• 面向过程编程思想
• 函数式
• • def用于定义有名函数
  • 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

模块的形式

模块有四种形式

1. 使用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