2.python-练习(日期-函数式编程)

计算活的天数

"""
    定义函数，根据生日(年月日)，计算活了多天
"""
from datetime import datetime


def calculate_alive_day(year: int, month: int, day: int) -> int:
    """
        计算出生到现在活着天数
    :param year: int类型 年份
    :param month: int类型 月份
    :param day: int类型 天
    :return: int类型 活着天数
    """
    birthday_day = datetime(year, month, day)
    teday = datetime.now()
    live_delta = teday - birthday_day
    return live_delta.days


print(calculate_alive_day(2022, 12, 15))

计算星期几

"""
   定义函数，根据年月日,计算星期(星期一、星期二、星期三...星期日)
"""


def calculate_week(year: int, month: int, day: int) -> str:
    """
        计算星期几
    :param year: int类型 年份
    :param month: int类型 月份
    :param day: int类型 天
    :return: str类型 星期几
    """
    list_week = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"]
    date = datetime(year, month, day)
    return list_week[date.weekday()]


print(calculate_week(2022, 12, 16))

定时练习

from datetime import datetime, timedelta
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
from apscheduler.triggers.interval import IntervalTrigger
from apscheduler.triggers.date import DateTrigger


def job():
    print("执行啦")


scheduler = BlockingScheduler()  # 阻塞
scheduler.add_job(job, CronTrigger(hour=16))  # 每天16点执行一次
scheduler.add_job(job, IntervalTrigger(hours=1))  # 每1小时执行一次
scheduler.add_job(job, DateTrigger(datetime.now() + timedelta(minutes=1)))  # 延迟1分钟执行
scheduler.start()

计算生日还有几天

from datetime import date, timedelta


def calculate_birthday_day(month: int, day: int) -> int:
    """
        计算生日还有几天
    :param month: int类型 月份
    :param day: int类型 天
    :return: int类型 天数
    """
    today = date.today()
    year = today.year
    birthday = date(year, month, day)
    if birthday < today:
        birthday = date(year + 1, month, day)

    delta_days = (birthday - today).days
    return delta_days


print(calculate_birthday_day(12, 17))

定期获取新闻数据

import requests
from datetime import datetime, timedelta

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
from apscheduler.triggers.interval import IntervalTrigger
from apscheduler.triggers.date import DateTrigger

key = "ad72c95410abbc25dc9ef5588887c2df"
new_type = "top"
url = "http://v.juhe.cn/toutiao/index?type=%s&key=%s" % (new_type, key)def get_news():
    data = requests.get(url).json()
    return data


scheduler = BlockingScheduler()  # 阻塞
scheduler.add_job(get_news, CronTrigger(hour=16))  # 每天16点整获取
scheduler.add_job(get_news, IntervalTrigger(hours=1))  # 每隔1小时获取
scheduler.add_job(get_news, DateTrigger(datetime.now() + timedelta(minutes=1)))  # 一分钟后获取
scheduler.start()

函数做参数练习1

"""
需求：
定义函数，在列表中查找第一个奇数
定义函数，在列表中查找第一个能被3或5整除的数字
步骤：
    -- 根据需求，写出函数。
    -- 因为主体逻辑相同,核心算法不同.
       所以使用函数式编程思想(分、隔、做)
       创建通用函数first
    -- 在当前模块中调用
"""
list01 = [6, 34, 55, 6, 7, 8, 89, 65, 866, 16, 2654, 72, 562]


def func01():
    """
        查找列表第一个奇数
    """
    for item in list01:
        if item % 2 == 1:
            return item


def func02():
    """
        查找列表中第一个被5或3整除的数
    """
    for item in list01:
        if item % 3 == 0 or item % 5 == 0:
            return item


print(func01())  # 55
print(func02())  # 6


# 抽取函数共同点
def first(condition):
    for item in list01:
        if condition(item):
            return item


# 抽取不同点
def condition01(item):
    return item % 2 == 1


def condition02(item):
    return item % 3 == 0 or item % 5 == 0


print(first(condition01))  # 55
print(first(condition02))  # 6

函数做参数练习2

"""
    需求：
    定义函数，在列表中查找所有偶数
    定义函数，在列表中查找所有被4或7整除的数字
    提示：满足条件的元素存入列表
    步骤：
        -- 根据需求，写出函数。
        -- 因为主体逻辑相同,核心算法不同.
           所以使用函数式编程思想(分、隔、做)
           创建通用函数find_all
        -- 在当前模块中调用
"""
list01 = [6, 4, 49, 6, 7, 28, 89, 626, 714, 64, 6461, 61, 551, 545, 515, 14, 355, 11, 51, 6547]


def find_all(condition):
    list_number = []
    for item in list01:
        if condition(item):
            list_number.append(item)
    return list_number


def condition01(item):
    return item % 2 == 0


def condition02(item):
    return item % 4 == 0 or item % 7 == 0


print(find_all(condition01))
print(find_all(condition02))

封装工具类

"""
    在common/iterable_tools模块中定义IterableHelper类
    添加first、find_all静态方法
    实现下列功能：
       在列表中查找所有偶数
       在列表中查找所有被4或7整除的数字
       查找第一个大于10的数字
       查找第一个小于100的数字
"""


class IterableHelper:
    @staticmethod
    def first(iterable, condition):
        for item in iterable:
            if condition(item):
                return item

    @staticmethod
    def find_all(iterable, condition):
        list_number = []
        for item in iterable:
            if condition(item):
                list_number.append(item)
        return list_number

    @staticmethod
    def select(iterable, condition):
        list_result = []
        for item in iterable:
            list_result.append(condition(item))
        return list_result


list01 = [3, 443, 54, 6, 7, 7, 414, 124, 41, 4, 6, 2, 388, 4, 32543]


def condition01(item):
    return item % 2 == 0


def condition02(item):
    return item % 4 == 0 or item % 7 == 0


def condition03(item):
    return item > 10


def condition04(item):
    return item < 100


print(IterableHelper.find_all(list01, condition01))  # [54, 6, 414, 124, 4, 6, 2, 388, 4]
print(IterableHelper.find_all(list01, condition02))  # [7, 7, 124, 4, 388, 4, 32543]
print(IterableHelper.first(list01, condition03))  # 443
print(IterableHelper.first(list01, condition04))  # 3

工具类练习

"""
    实现下列功能：
       在汽车列表中查找所有"中型车"
       在汽车列表中查找所有价格小于180000的汽车
       在汽车列表中查找"迈腾"
       在汽车列表中查找第一个"中型车"
"""
from common.iterable_tools import IterableHelper


class Car:
    def __init__(self, brand="", price=0, rank=""):
        self.brand = brand
        self.price = price
        self.rank = rank


list_car = [
    Car("五菱宏光", 46000, "微面"),
    Car("迈腾", 19000, "中型车"),
    Car("雅阁", 170000, "中型车"),
]


def condition01(item):
    return item.rank == "中型车"


def condition02(item):
    return item.price < 180000


def condition03(item):
    return item.brand == "迈腾"


def condition04(item):
    return item.rank == "中型车"


list_medium_sized = IterableHelper.find_all(list_car, condition01)  # 查找中型车
list_low_price = IterableHelper.find_all(list_car, condition02)  # 价格小于180000
list_maiteng = IterableHelper.find_all(list_car, condition03)  # 查找迈腾
medium_sized = IterableHelper.first(list_car, condition04)  # 查找第一个中型车

"""
    实现下列功能：
       在员工列表中查找员工编号是1003的员工对象
       在员工列表中查找所有部门编号是9001的员工对象
"""


class Employee:
    def __init__(self, eid, did, name, money):
        self.eid = eid  # 员工编号
        self.did = did  # 部门编号
        self.name = name
        self.money = money


list_employees = [
    Employee(1001, 9002, "师父", 60000),
    Employee(1002, 9001, "孙悟空", 50000),
    Employee(1003, 9002, "猪八戒", 20000),
    Employee(1004, 9001, "沙僧", 30000),
    Employee(1005, 9001, "小白龙", 15000),
]


def condition05(item):
    return item.eid == 1003


def condition06(item):
    return item.did == 9001


employees1003 = IterableHelper.first(list_employees, condition05)
list_did_employees = IterableHelper.find_all(list_employees, condition06)

"""
(1) 在电影列表中查找阿凡达2的电影对象
(2) 在电影列表中查找所有搞笑的电影
(3) 在电影列表中查找所有沈腾的电影
(4) 在电影列表中查找张译的第一个电影
"""


class Movie:
    def __init__(self, name="", type="", actor=""):
        self.name = name
        self.type = type
        self.actor = actor


list_movie = [
    Movie("独行月球", "搞笑", "沈腾"),
    Movie("阿凡达2", "冒险", "萨姆·沃辛顿"),
    Movie("万里归途", "战争", "张译"),
    Movie("疯狂72小时", "搞笑", "闫妮"),
]


def condition07(item):
    return item.name == "阿凡达2"


def condition08(item):
    return item.type == "搞笑"


def condition09(item):
    return item.actor == "沈腾"


def condition10(item):
    return item.actor == "张译"


avatar2 = IterableHelper.first(list_movie, condition07)
list_funny_movie = IterableHelper.find_all(list_movie, condition08)
list_shenteng_movie = IterableHelper.find_all(list_movie, condition09)
zhangyi_movie = IterableHelper.first(list_movie, condition10)

匿名函数lambda练习1

from common.iterable_tools import IterableHelper


class Car:
    def __init__(self, brand="", price=0, rank=""):
        self.brand = brand
        self.price = price
        self.rank = rank


class Movie:
    def __init__(self, name="", type="", actor=""):
        self.name = name
        self.type = type
        self.actor = actor


list_car = [
    Car("五菱宏光", 46000, "微面"),
    Car("迈腾", 19000, "中型车"),
    Car("雅阁", 170000, "中型车"),
]

list_movie = [
    Movie("独行月球", "搞笑", "沈腾"),
    Movie("阿凡达2", "冒险", "萨姆·沃辛顿"),
    Movie("万里归途", "战争", "张译"),
    Movie("疯狂72小时", "搞笑", "闫妮"),
]

list_medium_sized = IterableHelper.find_all(list_car, lambda c: c.rank == "中型车")  # 在汽车列表中查找所有"中型车"
list_low_price = IterableHelper.find_all(list_car, lambda c: c.price < 180000)  # 在汽车列表中查找所有价格小于180000的汽车
liat_maiteng = IterableHelper.find_all(list_car, lambda c: c.brand == "迈腾")  # 在汽车列表中查找 "迈腾"
medium_sized_car = IterableHelper.first(list_car, lambda c: c.rank == "中型车")  # 在汽车列表中查找第一个 "中型车"
avatar = IterableHelper.first(list_movie, lambda e: e.name == "阿凡达2")  # 在电影列表中查找阿凡达2的电影对象
list_funny_movie = IterableHelper.find_all(list_movie, lambda e: e.type == "搞笑")  # 在电影列表中查找所有搞笑的电影
list_shenteng_movie = IterableHelper.find_all(list_movie, lambda e: e.actor == "沈腾")  # 在电影列表中查找所有沈腾的电影
zhangyi_movie = IterableHelper.first(list_movie, lambda e: e.actor == "张译")  # 在电影列表中查找张译的第一个电影

匿名函数lambda练习2

"""
    需求：
        定义函数，在员工列表中查找所有员工姓名
        定义函数，在员工列表中查找所有员工工资
    步骤：
        -- 根据需求，写出函数。
        -- 因为主体逻辑相同,核心算法不同.
           所以使用函数式编程思想(分、隔、做)
           创建通用函数select
            -- 在当前模块中调用
"""


class Employee:
    def __init__(self, eid, did, name, money):
        self.eid = eid  # 员工编号
        self.did = did  # 部门编号
        self.name = name
        self.money = money


list_employees = [
    Employee(1001, 9002, "师父", 60000),
    Employee(1002, 9001, "孙悟空", 50000),
    Employee(1003, 9002, "猪八戒", 20000),
    Employee(1004, 9001, "沙僧", 30000),
    Employee(1005, 9001, "小白龙", 15000),
]


def select(iterable, condition):
    list_result = []
    for item in iterable:
        list_result.append(condition(item))
    return list_result


list_name = select(list_employees, lambda e: e.name)  # 查找姓名
list_money = select(list_employees, lambda e: e.money)  # 查找工资
list_eid_did = select(list_employees, lambda e: (e.eid, e.did))  # 查找工号和部门编号

"""
    需求：
        定义函数，在员工列表中累加所有员工薪资
        定义函数，在员工列表中累加所有员工编号
"""


def sum_method(iterable, condition):
    result = 0
    for item in iterable:
        result += condition(item)
    return result


total_money = sum_method(list_employees, lambda e: e.money)
total_eid = sum_method(list_employees, lambda e: e.eid)

匿名函数lambda练习3

class Car:
    def __init__(self, brand="", price=0, rank=""):
        self.brand = brand  # 汽车品牌
        self.price = price  # 汽车价格
        self.rank = rank  # 汽车型号


class Movie:
    def __init__(self, name="", mold="", actor=""):
        self.name = name  # 电影名称
        self.type = mold  # 电影类型
        self.actor = actor  # 电影演员


class Employee:
    def __init__(self, eid, did, name, money):
        self.eid = eid  # 员工编号
        self.did = did  # 部门编号
        self.name = name  # 员工姓名
        self.money = money  # 员工工资


def find_all(iterable, condition):
    """
        查找可迭代对象中所有符合条件的元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: list类型 查找结果列表
    """
    list_result = []
    for item in iterable:
        if condition(item):
            list_result.append(item)
    return list_result


def first(iterable, condition):
    """
        查找可迭代对象中符合条件的第一个
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: 可迭代对象中符合条件的第一个
    """
    for item in iterable:
        if condition(item):
            return item


def select(iterable, condition):
    """
        筛选可迭代对象中的属性
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: list类型 筛选结果列表
    """
    list_result = []
    for item in iterable:
        list_result.append(condition(item))
    return list_result


def get_sum(iterable, condition):
    """
        对可迭代对象元素累加
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: 可迭代对象元素累加结果
    """
    total = 0
    for item in iterable:
        total += condition(item)
    return total


def last(iterable, condition):
    """
        查找可迭代对象中符合条件的最后一个
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: 可迭代对象中符合条件的最后一个
    """
    for i in range(len(iterable) - 1, -1, -1):
        if condition(iterable[i]):
            return iterable[i]


def delete(iterable, condition):
    """
        删除可迭代对象中所有符合条件的元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: int类型 删除元素个数
    """
    count = 0
    for i in range(len(iterable) - 1, -1, -1):
        if condition(iterable[i]):
            del iterable[i]
            count += 1
    return count


def delete_single(iterable, condition):
    """
        删除可迭代对象中所有符合条件第一个元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: bool类型 删除成功True 反之False
    """
    status = False
    for i in range(len(iterable)):
        if condition(iterable[i]):
            del iterable[i]
            status = True
            return status
    return status


def delete_last(iterable, condition):
    """
        删除可迭代对象中所有符合条件最后一个元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: bool类型 删除成功True 反之False
    """
    status = False
    for i in range(len(iterable) - 1, -1, -1):
        if condition(iterable[i]):
            del iterable[i]
            status = True
            return status
    return status


def get_max(iterable, condition):
    """
        按条件查找可迭代对象中最大的元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: 可迭代对象中最大的元素
    """
    max_value = iterable[0]
    for i in range(1, len(iterable)):
        if condition(max_value) < condition(iterable[i]):
            max_value = iterable[i]
    return max_value


def get_min(iterable, condition):
    """
        按条件查找可迭代对象中最小的元素
    :param iterable: 类型 可迭代对象
    :param condition: 类型 函数
    :return: 可迭代对象中最小的元素
    """
    min_value = iterable[0]
    for i in range(1, len(iterable)):
        if condition(min_value) > condition(iterable[i]):
            min_value = iterable[i]
    return min_value


list_car = [
    Car("五菱宏光", 46000, "微面"),
    Car("迈腾", 19000, "中型车"),
    Car("雅阁", 170000, "中型车"),
]
list_movie = [
    Movie("独行月球", "搞笑", "沈腾"),
    Movie("阿凡达2", "冒险", "萨姆·沃辛顿"),
    Movie("万里归途", "战争", "张译"),
    Movie("疯狂72小时", "搞笑", "闫妮"),
]
list_employees = [
    Employee(1001, 9002, "师父", 60000),
    Employee(1002, 9001, "孙悟空", 50000),
    Employee(1003, 9002, "猪八戒", 20000),
    Employee(1004, 9001, "沙僧", 30000),
    Employee(1005, 9001, "小白龙", 15000),
]

data01 = select(list_car, lambda c: c.brand)  # 在汽车列表中查找所有汽车的品牌brand
data02 = first(list_car, lambda c: c.rank == "中型车")  # 在汽车列表中查找第一个中型车rank
data03 = last(list_car, lambda c: c.rank == "中型车")  # 在汽车列表中查找最后一中型车rank
data04 = find_all(list_car, lambda c: c.price < 100000)  # 在汽车列表中查找所有价格小于100000的汽车price
data05 = get_max(list_car, lambda c: c.price)  # 在汽车列表中查找最贵的汽车price
data06 = get_sum(list_car, lambda c: c.price)  # 累加所有汽车的价格
data07 = select(list_movie, lambda m: m.actor)  # 在电影列表中查找所有演员姓名actor
data08 = find_all(list_movie, lambda m: m.type == "搞笑")  # 在电影列表中查找所有搞笑的电影type
data09 = first(list_movie, lambda m: m.name == "万里归途")  # 在电影列表中查找万里归途name
data10 = last(list_movie, lambda m: m.type == "搞笑")  # 在电影列表中查找最后一个搞笑的电影
data11 = last(list_employees, lambda e: e.did == 9002)  # 在员工列表中查找最后一个部门是9002的员工
data12 = last(list_employees, lambda e: e.money > 20000)  # 在员工列表中查找最后一个薪资大于20000的员工
data13 = get_min(list_employees, lambda e: e.money)  # 在员工列表中查找薪资最小的员工
data14 = get_min(list_employees, lambda e: e.eid)  # 在员工列表中查找编号最小的员工
data15 = delete(list_movie, lambda m: m.type == "战争")  # 删除所有战争类型的电影type
# data16 = delete_single(list_movie, lambda m: m.name == "阿凡达2")  # 在电影列表中删除阿凡达2
data17 = delete(list_car, lambda c: c.brand == "雅阁")  # 在汽车列表中删除雅阁
data18 = delete(list_employees, lambda e: e.did == 9001)  # 在员工列表中删除部门是9001的所有员工
# data19 = delete(list_employees, lambda e: e.eid > 1002)  # 在员工列表中删除员工编号大于1002的所有员工