Python学习第十七天

最新推荐文章于 2022-04-11 22:20:15 发布
最新推荐文章于 2022-04-11 22:20:15 发布
阅读量225 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44687626/article/details/106890232
版权
""" 复习"""def func01(): print("第1部分") yield "结果1" print("第2部分") yield "结果2" print("第3部分")"""class Generate: def __next__(self): print("第n部分") return "结果n""""# 调用函数返回生成器(推算数据),惰性操作/延迟操作result = func01()
摘要由CSDN通过智能技术生成 
"""
    复习
"""
def func01():
    print("第1部分")
    yield "结果1"

    print("第2部分")
    yield "结果2"

    print("第3部分")

"""
class Generate:
    def __next__(self):
        print("第n部分")
        return "结果n"
"""

# 调用函数返回生成器(推算数据),惰性操作/延迟操作
result = func01()
data = result.__next__()
print(data)

data = result.__next__()
print(data)

内置生成器
枚举函数enumerate
1. 语法：
for 变量 in enumerate(可迭代对象):
语句
for 索引, 元素in enumerate(可迭代对象):
语句
2. 作用：遍历可迭代对象时，可以将索引与元素组合为一个元组。

"""
    内置生成器
"""
list01 = [54, 5, 6, 76, 8, 9]
# 遍历元素 -- 读取
for item in list01:
    print(item)

# 遍历索引 -- 修改
# for i in range(len(list01)):
#     list01[i] = 0

# 需求:修改奇数为0
# for i in range(len(list01)):
#     if list01[i] % 2:
#         list01[i] = 0

# (索引, 元素)
# for item in enumerate(list01):
for i, element in enumerate(list01):
    if element % 2:
        list01[i] = 0

print(list01)

zip
1. 语法：
for item in zip(可迭代对象1, 可迭代对象2….):
语句
2. 作用：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。

"""
    内置生成器
"""
list01 = ["a", "b", "c"]
list02 = ["A", "B", "C"]
for item in zip(list01, list02):
    print(item)

生成器表达式
1. 定义：用推导式形式创建生成器对象。
2. 语法：变量 = ( 表达式 for 变量 in 可迭代对象 [if 真值表达式] )

"""
    生成器函数
        给其他人用
    生成器表达式
        给自己使用

"""
list01 = [54, 65.5, True, "a", False, "b", 3, "c"]
# 查找所有字符串
# list_result = []
# for item in list01:
#     if type(item) == str:
#         list_result.append(item)
# print(list_result)

# 列表推导式
list_result = [item for item in list01 if type(item) == str]
for item in list_result:
    print(item)

# 生成器表达式
list_result = (item for item in list01
               if type(item) == str)
for item in list_result:
    print(item)

函数式编程
1. 定义：用一系列函数解决问题。
– 函数可以赋值给变量，赋值后变量绑定函数。
– 允许将函数作为参数传入另一个函数。
– 允许函数返回一个函数。
2. 高阶函数：将函数作为参数或返回值的函数

"""
    函数式编程 - 语法
        理论支柱：
            将函数赋值给变量,通过变量调用函数
        应用：
            将函数赋值给参数,通过参数调用函数
            （价值：通过参数调用函数,可以将(核心)逻辑注入到函数中.）
"""
def func01():
    print("func01执行了")

# 将函数赋值给变量
a = func01
# 通过变量调用函数
a()

def func02():
    print("func02执行了")

# 价值:通过参数调用函数,可以将(核心)逻辑注入到函数中.
def func03(a):
    print("func03执行了")
    a()# 执行?

func03(func01)
func03(func02)

lambda 表达式
1. 定义：是一种匿名方法。
2. 作用：作为参数传递时语法简洁，优雅，代码可读性强。
随时创建和销毁，减少程序耦合度。
3. 语法
– 定义：
变量 = lambda 形参: 方法体
– 调用：
变量(实参)
4. 说明：
– 形参没有可以不填
– 方法体只能有一条语句，且不支持赋值语句。

"""
    lambda 表达式
        匿名函数:
            lambda 参数: 函数体

            def不能转换为lambda写法
                1. lambda表达式不能赋值
                2. lambda 函数体只能有一条语句

            应用:作为实参
"""

# 写法1:有参数,有返回值
# def func01(p1, p2):
#     return p1 > p2
#
# print(func01(10, 5))

func01 = lambda p1, p2: p1 > p2
print(func01(10, 5))

# 写法2:有参数,无返回值
# def func02(p1):
#     print("参数是:",p1)
#
# func02(10)

func02 = lambda p1: print("参数是:", p1)
func02(10)

# 写法3:无参数,有返回值
# def func03():
#     return "结果"
#
# result = func03()
# print(result)

func03 = lambda: "结果"
result = func03()
print(result)

# 写法4:无参数,无返回值
# def func04():
#     print("func04执行喽")
#
# func04()

func04 = lambda: print("func04执行喽")
func04()

# def不能转换为lambda写法
def func05(p1):
    p1[0] = 100

list01 = [10]
func05(list01)
print(list01[0]) # 100

# 1. lambda表达式不能赋值
# func05 = lambda p1:p1[0] = 100


def func06():
    for i in range(5):
        print(i)

func06()

# 2. lambda 函数体只能有一条语句
# func06 = lambda :for i in range(5):
#                     print(i)




"""
    函数式编程 - 思想
        面向对象
            封装：分
            继承：隔
            多态：做
        函数式编程
            分：将通用和变化点分为多个函数
            隔：使用参数隔离具体变化的函数
            做：通常使用lambda定义变化函数
"""
list01 = [42, 45, 5, 66, 7, 89]


# 提取变化函数
# def condition01(item):
#     return item > 10
#
# def condition02(item):
#     return item % 2 == 0

# 提取通用函数 -- 万能查找
def find(func):  # 创建了钩子
    for item in list01:
        if func(item):  # 拉起钩子(执行条件)
            yield item


# for number in find(condition02):# 向钩子上挂条件
for number in find(lambda item: item % 2 == 0):  # 向钩子上挂条件
    print(number)

from common.iterable_tools import IterableHelper

# for number in IterableHelper.find(list01, condition01):
for number in IterableHelper.find_all(list01, lambda item: item % 2 == 0):
    print(number)

静态方法
1. 语法
(1) 定义：
@staticmethod
def 方法名称(参数列表):
方法体
(2) 调用：类名.方法名(参数列表)
不建议通过对象访问静态方法
2. 说明
(1) 使用@ staticmethod修饰的目的是该方法不需要隐式传参数。
(2) 静态方法不能访问实例成员和类成员
3. 作用：定义常用的工具函数。

"""
    common/
        iterable_tools.py
    可迭代对象工具
"""
class IterableHelper:
    """
        可迭代对象助手
    """
    @staticmethod
    def find_all(iterable, func):
        for item in iterable:
            if func(item):
                yield item
    
    @staticmethod
    def find_single(iterable,func):
        for emp in iterable:
            if func(emp):
                return emp

    @staticmethod
    def select(iterable,func):
        for emp in iterable:
            yield func(emp)
# for item in IterableHelper.find(列表,函数):
#  ...

练习一

"""
    练习1: 创建字典,遍历字典,打印索引/键/值
    练习2: 创建列表,将列表中大于10的数字,设置为0
"""
dict01 = {"a": "A", "b": "B"}
# (0, ('a', 'A'))
# for item in enumerate(dict01.items()):
for i, (k, v) in enumerate(dict01.items()):
    print(i, k, v)

list01 = [5, 6, 67, 8, 9, 9, 65, 43, 7]
for i, item in enumerate(list01):
    if item > 10:
        list01[i] = 0

print(list01)

练习二

# 练习:通过zip实现矩阵转置
list01 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16],
]
# 固定行
# (1, 5, 9, 13)
# for item in zip(list01[0],list01[1],list01[2],list01[3]):
#     print(item)

# 使用*号将列表元素拆开
# for item in zip(*list01):
#     print(item)

# [(1, 5, 9, 13), (2, 6, 10, 14), (3, 7, 11, 15), (4, 8, 12, 16)]
# list02 = list(zip(*list01))
# print(list02)

# list02 = []
# for item in zip(*list01):
#      list02.append(list(item))

list02 = [list(item) for item in zip(*list01)]
print(list02)

练习三

# 练习1:在列表中获取所有整数,并计算它的平方.
# 练习2:在列表中获取所有大于10的小数.
# 要求：使用列表推导式，生成器表达式完成.
# 通过调试，体会差异.

list01 = [54, 65.5, True, "a", False, "b", 3, "c"]

# 练习1:
list02 = [item ** 2 for item in list01 if type(item) == int]
for number in list02:
    print(number)

generator02 = (item ** 2 for item in list01 if type(item) == int)
for number in generator02:
    print(number)

# 练习2:
list03 = [item for item in list01 if type(item) == float and item > 10]
for number in list03:
    print(number)

generator03 = (item for item in list01 if type(item) == float and item > 10)
for number in generator03:
    print(number)

练习四

"""
    将生成器函数,改写为生成器表达式
"""


class EmployeeModel:
    def __init__(self, eid=0, did=0, name="", money=0.0):
        self.eid = eid
        self.did = did
        self.name = name
        self.money = money


list_employee = [
    EmployeeModel(1001, 9003, "林", 13000),
    EmployeeModel(1002, 9003, "王", 16000),
    EmployeeModel(1003, 9003, "刘", 11000),
    EmployeeModel(1004, 9003, "冯", 17000),
    EmployeeModel(1005, 9003, "曹", 15000),
    EmployeeModel(1006, 9003, "魏", 12000),
]

# 1. 在list_employee中查找薪资大于等于15000的所有员工
employees_gt_15k = (emp for emp in list_employee if emp.money >= 15000)
for item in employees_gt_15k:
    print(item.__dict__)

# 3. 在list_employee中查找所有员工的姓名
names_by_employee = (emp.name for emp in list_employee)
for name in names_by_employee:
    print(name)

练习五

"""

"""
from common.iterable_tools import IterableHelper


class EmployeeModel:
    def __init__(self, eid=0, did=0, name="", money=0.0):
        self.eid = eid
        self.did = did
        self.name = name
        self.money = money


list_employee = [
    EmployeeModel(1001, 9003, "林", 13000),
    EmployeeModel(1002, 9005, "王", 16000),
    EmployeeModel(1003, 9003, "刘", 11000),
    EmployeeModel(1004, 9007, "冯", 17000),
    EmployeeModel(1005, 9005, "曹", 15000),
    EmployeeModel(1006, 9005, "魏", 12000),
]


# 1. 定义函数,在list_employee中查找薪资大于等于15000的所有员工
def find01():
    for emp in list_employee:
        if emp.money >= 15000:
            yield emp


# 2. 定义函数,在list_employee中查找部门编号是9005的所有员工
def find02():
    for emp in list_employee:
        if emp.did == 9005:
            yield emp


for item in find02():
    print(item.__dict__)


# ---------------------------
# 变化
def condition01(emp):
    return emp.money >= 15000


def condition02(emp):
    return emp.did == 9005


# 通用
def find(func):
    for emp in list_employee:
        # if emp.did == 9005:
        # if condition02(emp):
        if func(emp):
            yield emp

# 变化 + 通用
for item in find(condition02):
    print(item.__dict__)

for item in find(condition01):
    print(item.__dict__)


for item in IterableHelper.find_all(list_employee, condition01):
    print(item.__dict__)

练习六

"""
    exercise06.py
    练习:使用lambda代替condtion0x函数
"""
from common.iterable_tools import IterableHelper


class EmployeeModel:
    def __init__(self, eid=0, did=0, name="", money=0.0):
        self.eid = eid
        self.did = did
        self.name = name
        self.money = money


list_employee = [
    EmployeeModel(1001, 9003, "林", 13000),
    EmployeeModel(1002, 9005, "王", 16000),
    EmployeeModel(1003, 9003, "刘", 11000),
    EmployeeModel(1004, 9007, "冯", 17000),
    EmployeeModel(1005, 9005, "曹", 15000),
    EmployeeModel(1006, 9005, "魏", 12000),
]


# def condition01(emp):
#     return emp.money >= 15000
#
# def condition02(emp):
#     return emp.did == 9005

# 通用
def find(func):
    for emp in list_employee:
        if func(emp):
            yield emp


# 变化 + 通用
for item in find(lambda emp: emp.did == 9005):
    print(item.__dict__)

for item in find(lambda emp: emp.money >= 15000):
    print(item.__dict__)

for item in IterableHelper.find_all(list_employee, lambda emp: emp.money >= 15000):
    print(item.__dict__)

练习七

"""
    练习1需求:
        在员工列表中,查找姓名是"刘"的员工
        在员工列表中,查找员工编号是1005的员工

    练习2需求:
        在员工列表中,查找所有员工的姓名
        在员工列表中,查找所有员工的编号和薪资

    步骤
        1. 定义函数,完成需求.
        2. 将变化点定义为函数
           将通用代码定义为函数
        3. 通用函数使用参数隔离变化点
        4. 将通用函数移动到IterableHelper类中
        5. 在当前模块中调用通用函数(lambda)
"""
from common.iterable_tools import IterableHelper


class EmployeeModel:
    def __init__(self, eid=0, did=0, name="", money=0.0):
        self.eid = eid
        self.did = did
        self.name = name
        self.money = money


list_employee = [
    EmployeeModel(1001, 9003, "林", 13000),
    EmployeeModel(1002, 9005, "王", 16000),
    EmployeeModel(1003, 9003, "刘", 11000),
    EmployeeModel(1004, 9007, "冯", 17000),
    EmployeeModel(1005, 9005, "曹", 15000),
    EmployeeModel(1006, 9005, "魏", 12000),
]


def find01():
    for emp in list_employee:
        if emp.name == "刘":
            return emp


def find02():
    for emp in list_employee:
        if emp.eid == 1005:
            return emp


def condition01(emp):
    return emp.name == "刘"


def condition02(emp):
    return emp.eid == 1005


def find(func):
    for emp in list_employee:
        # if emp.eid == 1005:
        # if condition02(emp):
        if func(emp):
            return emp


emp01 = IterableHelper.find_single(list_employee, lambda emp: emp.name == "刘岳浩")
print(emp01.__dict__)


# 2.
def select01():
    for emp in list_employee:
        yield emp.name

def select02():
    for emp in list_employee:
        yield (emp.eid, emp.money)


def handle01(emp):
    return emp.name

def handle02(emp):
    return  (emp.eid, emp.money)

def select(func):
    for emp in list_employee:
        # yield (emp.eid, emp.money)
        # yield handle02(emp)
        yield func(emp)

for item in IterableHelper.select(list_employee,lambda emp:(emp.eid, emp.money)):
    print(item)
wwwchah
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python-程序结构
weixin_43336407的博客
11-03 460
Python-程序结构，基础知识
Python爬虫，京东自动登录，在线抢购商品
LLand520的博客
10-21 1万+
京东抢购 Python爬虫，自动登录京东网站，查询商品库存，价格，显示购物车详情等。 可以指定抢购商品，自动购买下单，然后手动去京东付款就行。 chang log 2017-03-30 实现二维码扫码登陆 2017-06-27 Golang版JD_AutoBuy 运行环境 Python 2.7 第三方库 Requests: 简单好用，功能强大的Http请求库 beautifulsoup4: HTM...
Day18——函数式编程
**kwargs的博客
11-22 209
函数式编程 定义：用一系列函数解决问题。 – 函数可以赋值给变量，赋值后变量绑定函数。 – 允许将函数作为参数传入另一个函数。 – 允许函数返回一个函数。 高阶函数：将函数作为参数或返回值的函数。 函数作为参数 将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。 lambda 表达式 定义：是一种匿名方法。 作用：作为参数传递时语法简洁，优雅，代码可读性强。 随时创建和销毁...
函数式编程
07-22 94
语法 """ 函数式编程 -- 语法 """ def fun01(): print("fun01执行喽") # 1. 函数可以赋值给变量 a = fun01 # 通过变量调用函数 a()# 活的 fun01()# 死的 # 2. 将函数作为参数传递 # 如果传入基本数据类型(整数/小数/字符串..),称之为传入数据 # 如果传入函数,...
python_EMS练习
qq_39128254的博客
02-01 294
EMS 练习 # 定义一个字典 emps = { '孙悟空': { "name": '孙悟空', "age": 18, "gender": '男', "address": '火锅山' }, '猪八戒': { "name": '猪八戒', "age": 28, "gender": '男', "address": '高老庄' } } # 定义几个函数
python学习-17-futures
01-04
简单易学：Python的语法简洁明了，易于理解和学习。 高级特性：Python支持面向对象编程、函数式编程等高级特性，使得代码更加模块化和可重用。 广泛的库和框架：Python拥有丰富的第三方库和框架，可以快速开发各种...
Python3机器学习实战教程.zip
01-24
《Python3机器学习实战教程》是一份深度剖析机器学习理论与实践的综合资源包，它以Python3编程语言为工具，旨在帮助读者掌握各种机器学习算法，并通过实战案例加深理解。教程涵盖了从基础到进阶的多个主题，包括K-...
python学习-17-futures-py3.7
最新发布
01-04
简单易学：Python的语法简洁明了，易于理解和学习。 高级特性：Python支持面向对象编程、函数式编程等高级特性，使得代码更加模块化和可重用。 广泛的库和框架：Python拥有丰富的第三方库和框架，可以快速开发各种...
Python 100 天学习计划 从小白到工程师的学习之路
07-12
第17天：Python 函数之参数 第18天：Python 高阶函数 第19天：Python 之迭代器 第20天： Web开发 Jinja2模板引擎 第21天：Python NameSpace&Scope 第22天：Python 之装饰器 第23天：Python 标准库概览1 第24天：...
浪潮优派Python实习学习记录
03-26
浪潮优派Python实习学习记录 本资源摘要信息主要记录了Python语言的基础知识，包括Python的起源、优缺点、版本选择、安装测试环境、第一个Python程序、开发工具、开发环境、包管理工具、变量和常量定义等。 知识点...
Python学习第十八天
weixin_44687626的博客
06-22 209
内置高阶函数 1. map（函数，可迭代对象）：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。 2. filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。 3. sorted(可迭代对象，key = 函数,reverse = bool值)：排序，返回值为排序结果。 4. max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。 5. min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。 """
Iterator，Iterable
cod16xx的博客
10-19 218
Iterable（可迭代对象）是实现了__iter__方法的对象，其中__iter_需要返回一个Iterator对象。 Iterator（迭代器）是实现了def iter(): return (new Iterator())、__next__的对象，__iter__方法返回对象本身。class Iterable: def __iter__(): retur
python笔记之函数式编程，lambda表达式，内置高阶函数
qq_58112820的博客
04-11 769
python笔记之函数式编程，lambda表达式，内置高阶函数
Iterables vs. Iterators vs. Generators
bubblelone的专栏
04-08 435
来源：http://nvie.com/posts/iterators-vs-generators/ 译文：http://www.jianshu.com/p/4c8e4fb4ef37# Occasionally I've run into situations of confusion on the exact differences between the following rela
函数式编程（万能查找公式的推导）
Uranus_user的博客
02-26 465
""" 需求：1.定义函数,在老婆列表中,查找颜值大于90的所有老婆 2.定义函数,在老婆列表中,查找存款小于十万的所有老婆 """ # 万能查找的推导过程 class Wife: def __init__(self, name, face_score, money, age): self.name = name self....
亿豪的python学习 day17
weixin_45819795的博客
11-21 83
今天的学习内容 生成器generator 定义：能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。 作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。 以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。 生成器 --> 迭代器 + 可迭代对象 生成器函数 定义：含有y...
LINQ教程三：Lambda表达式解剖
weixin_34101784的博客
01-13 100
C#3.0（.NET3.5）中引入了Lambda表达式和LINQ。Lambda表达式是使用一些特殊语法表示匿名方法的较短方法。 最基本的Lambda表达式语法如下： （参数列表）=>{方法体} 说明： 1、参数列表中的参数类型可以是明确类型或者推断类型。 2、如果是推断类型，则参数的数据类型将由编辑器根据上下文自动推断出来。 让我们看看Lambda表达式是如何从匿名方法演变而来的。 相关示例...
python中lambda函数的理解与使用
热门推荐
Little_Fire的博客
05-29 3万+
Lambda函数，即Lambda 表达式(lambda expression)，是一个匿名函数（不存在函数名的函数），Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)。入门Python的朋友会问，函数没有名字也可以吗？当然可以。有些函数如果只是临时一用，而且它的业务逻辑也很简单（比如做个简单加法、取绝对值、简单过滤等）时，就没必要非...
Python 学习笔记 第三版1
08-03
Python 学习笔记第三版是一本讲解 Python 编程语言的教材。该书作者自称已经摆脱了新手的身份，算得上是一个有经验的作者。然而，他也承认无法保证书中的内容是完全正确并且适合每个读者。本书分为上卷和下卷两部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值