python学习核心Day17（P179~~188）

最新推荐文章于 2024-06-17 17:35:06 发布
最新推荐文章于 2024-06-17 17:35:06 发布
阅读量75 收藏
点赞数
文章标签： python 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43838595/article/details/129702687
版权

P179 Python核心-4.1 课程回顾

一、Day16复习

"""
    迭代
        可迭代对象
        迭代器
    生成器

class 可迭代对象:
    def __iter__():
        创建迭代器对象

class 迭代器:
    def __next__():
        返回一个元素
        如果没有元素,则抛出一个StopIteration异常.

for 变量 in 可迭代对象:
    变量得到的就是__next__方法返回值

原理:
iterator = 可迭代对象.__iter__()
while True:
    try:
        变量 = iterator.__next__()
    except:
        break

启发:调用next执行一次,计算一次,返回一次.

生成器函数:
    def 函数名():
        ...
        yield 数据
        ...

    # 调用方法不执行
    生成器 = 函数名()
    # for 生成器 才执行函数体
    for item in 生成器:
        ...
    优势:延迟/惰性操作

    生成器源码
        class 生成器:
            def __iter__():
                return self

            def __next__():
                 定义着yield以前的代码
                 返回yield后面的数据
"""

P180 Python核心-4.2 练习解析

一、练习1：实现enumerate函数

"""
    练习:定义生成器函数my_enumerate,实现下列现象.
         将元素与索引合成一个元组.
list01 = [3, 4, 55, 6, 7]
for item in enumerate(list01):
    # (索引,元素)
    print(item)

for index, element in enumerate(list01):
    print(index, element)
"""


def my_enumerate(iterable_target):
    index = 0
    for item in iterable_target:
        yield (index, item)
        index +=1
    # for index in range(len(iterable_target)):
    #     yield (index,iterable_target[index])

list01 = [3, 4, 55, 6, 7]
for index, element in my_enumerate(list01):
    print(index, element)

二、练习2：实现zip函数

"""
# 练习: 定义生成器函数my_zip,实现下列现象.
# 将多个列表的每个元素合成一个元组.
list02  = ["孙悟空","猪八戒","唐僧","沙僧"]
list03  = [101,102,103,104]
for item in zip(list02,list03):
    print(item)
"""

# 练习: 定义生成器函数my_zip,实现下列现象.
# 将多个列表的每个元素合成一个元组.
list02  = ["孙悟空","猪八戒","唐僧","沙僧"]
list03  = [101,102,103,104]

def my_zip(list01,list02):
    for i in range(len(list01)):
        yield (list01[i],list02[i])

for item in my_zip(list02,list03):
    print(item)

# (扩展)
def my_zip2(*args):
    # 根据星号元组形参args第一个参数的长度生成索引len(args[0])
    for i in range(len(args[0])):
        list_result = []
        for item in args:
            list_result.append(item[i])
        yield tuple(list_result)

for item in my_zip2(list02,list03):
    print(item)

三、内置生成器

枚举函数enumerate

语法：
for 变量 in enumerate(可迭代对象):
     语句

for 索引, 元素in enumerate(可迭代对象):
    语句
作用

遍历可迭代对象时，可以将索引与元素组合为一个元组。

zip

语法：
for item in zip(可迭代对象1, 可迭代对象2….):
    		语句
作用

将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。

P181 Python核心-4.3 生成器表达式

一、生成器表达式

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

二、示例代码

"""
    生成器表达式
    练习:exercise03.py
"""
list01 = [3, "54", True, 6, "76", 1.6, False, 3.5]
# 生成器函数
def find01():
    for item in list01:
        if type(item) == int:
            yield item + 1
re = find01()
for item in re:
    print(item)

#  生成器表达式
# 此时没有计算,更没有结果
re = (item + 1 for item in list01 if type(item) == int)
# 一次循环,一次计算,一个结果
for item in re:
    print(item)

# 列表推导式
# 此时已经完成所有计算,得到所有结果
re = [item + 1 for item in list01 if type(item) == int]
# 只是获取所有结果
for item in re:
    print(item)
"""
# 变量 = [itme for item in 可迭代对象 if 条件] 列表推导
# 变量 = {k,v for k,v in 可迭代对象 if 条件} 字典推导
# 变量 = {item for item in 可迭代对象 if条件} 集合推导
# 变量 = (item for item in 可迭代对象 if条件) 生成器表达式
"""

P182 Python核心-4.4 练习解析

一、练习1&2

# 练习:1. 获取列表中所有字符串
#     2. 获取列表中所有小数
# 要求:分别使用生成器函数/生成器表达式/列表推导式完成.
list01 = [3, "54", True, 6, "76", 1.6, False, 3.5]
# 练习:1
def find01():
    for itme in list01:
        if type(itme) == str:
            yield itme

re = find01()
for item in re:
    print(item)

re = (itme for itme in list01 if type(itme) == str)
for item in re:
    print(item)

re = [itme for itme in list01 if type(itme) == str]
for item in re:
    print(item)

# 练习:2
def find02():
    for itme in list01:
        if type(itme) == float:
            yield itme

for item in find02():
    print(item)

for item in (item for item in list01 if type(item) == float):
    print(item)

for item in [item for item in list01 if type(item) == float]:
    print(item)

二、练习3：

"""
    参照day10/exercise02.py
    完成下列练习
"""
class SkillData:
    def __init__(self,id,name,atk_ratio,duration):
        self.id = id
        self.name = name
        self.atk_ratio = atk_ratio
        self.duration = duration

    def __str__(self):
        return "技能数据是:%d,%s,%d,%d"%(self.id,self.name,self.atk_ratio,self.duration)

list_skill = [
    SkillData(101,"乾坤大挪移",5,10),
    SkillData(102,"降龙十八掌",8,5),
    SkillData(103,"葵花宝典",10,2),
]
# 练习1:获取攻击比例大于6的所有技能
# 要求:使用生成器函数/生成器表达式完成
def find01():
    for item in list_skill:
        if item.atk_ratio > 6:
            yield item

for item in find01():
    print(item)

for item in (item for item in list_skill if item.atk_ratio > 6):
    print(item)

# 练习2:获取持续时间在4--11之间的所有技能
print("--------------------")
def find02():
    for item in list_skill:
        if 4<item.duration<11:
            yield item

for item in find02():
    print(item)

for item in (item for item in list_skill if 4<item.duration<11):
    print(item)

# 练习3:获取技能编号是102的技能
print("--------------------")
def find03():
    for item in list_skill:
        if item.id == 102:
            return item

re = find03()
print(re)

# 练习4:获取技能名称大于4个字并且持续时间小于6的所有技能
print("--------------------")
def find04():
    for item in list_skill:
        if len(item.name) > 4 and item.duration < 6:
            yield item

for item in find04():
    print(item)

# 不建议使用生成器表达式
# for item in (item for item in list_skill if len(item.name) > 4 and item.duration < 6):
#     print(item)

P183 Python核心-4.5 函数式编程01

一、函数式编程

定义

用一系列函数解决问题。
– 函数可以赋值给变量，赋值后变量绑定函数。
– 允许将函数作为参数传入另一个函数。
– 允许函数返回一个函数。

示例代码

"""
    函数式编程 语法
"""

def fun01():
    print("fun01执行喽")

# 调用方法,执行方法体
re1 = fun01()
print(re1)

# 将函数赋值给变量
re2 = fun01
# 通过变量,调用函数
re2()

def fun02():
    print("fun02执行喽")

# 将函数作为函数的参数进行传递
# 将一个函数的代码(fun02/fun01),注入到另外一个函数中(fun03).
def fun03(func):
    print("fun03执行喽")
    func()

fun03(fun01)
fun03(fun02)

二、函数式编程思想

"""
    函数式编程 思想
    练习:exercise05.py
"""

class SkillData:
    def __init__(self,id,name,atk_ratio,duration):
        self.id = id
        self.name = name
        self.atk_ratio = atk_ratio
        self.duration = duration

    def __str__(self):
        return "技能数据是:%d,%s,%d,%d"%(self.id,self.name,self.atk_ratio,self.duration)

list_skill = [
    SkillData(101,"乾坤大挪移",5,10),
    SkillData(102,"降龙十八掌",8,5),
    SkillData(103,"葵花宝典",10,2),
]

# 需求1:获取攻击比例大于6的所有技能
def find01():
    for item in list_skill:
        if item.atk_ratio > 6:
            yield item

# 需求2:获取持续时间在4--11之间的所有技能
def find02():
    for item in list_skill:
        if 4<item.duration<11:
            yield item

# 需求3:获取技能名称大于4个字并且持续时间小于6的所有技能
def find04():
    for item in list_skill:
        if len(item.name) > 4 and item.duration < 6:
            yield item

# "封装"(分而治之 变则疏之)
# 将每个变化的条件,单独定义在函数中.
def condition01(item):
    return item.atk_ratio > 6

def condition02(item):
    return 4<item.duration<11

def condition03(item):
    return len(item.name) > 4 and item.duration < 6

# "继承"(隔离变化)
def find(func_condition):
    """
        通用的查找方法
    :param func_condition: 查找条件,函数类型.
            函数名(变量) --> 返回值bool类型
    :return:
    """
    for item in list_skill:
        # "多态":调用父(变量),执行子(具体函数).
        #       不同子类重写父类方法,执行逻辑不同.

        # if item.atk_ratio > 6:
        # if condition01(item):
        if func_condition(item):
            yield item

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

for item in find(condition02):
    print(item)

P184 Python核心-4.6 练习解析

一、练习

"""

"""
# 1. 使用生成器函数实现以上3个需求
# 2. 体会函数式编程的"封装"
#    将三个函数变化点提取到另外三个函数中.
#    将共性提取到另外一个函数中
# 3. 体会函数式编程的"继承"与"多态"
#    使用变量隔离变化点,在共性函数中调用变量.
# 4. 测试(执行上述功能)

list01 = [43, 4, 5, 5, 6, 7, 87]


# 需求1:在列表中查找所有偶数
def find01():
    for item in list01:
        if item % 2 == 0:
            yield item


# 需求2:在列表中查找所有大于10的数
def find02():
    for item in list01:
        if item > 10:
            yield item


# 需求3:在列表中查找所有范围在10--50之间的数
def find03():
    for item in list01:
        if 10 < item < 50:
            yield item


# "封装"
def condition01(item):
    return item % 2 == 0


def condition02(item):
    return item > 10


def condition03(item):
    return 10 < item < 50


# "继承"
def find(func_condition):
    for item in list01:
        # "多态"
        # 调用:具体条件的抽象
        # 执行:具体条件的函数
        if func_condition(item):
            yield item

for item in find(condition02):
    print(item)

# 方法参数,如果传递10/"张无忌"/True,叫做传递数据
# 方法参数,如果函数1/函数2/函数3,叫做传递逻辑

P185 Python核心-4.7 函数式编程02

一、练习

新建common包并内部建立通用模块list_helper模块，创建ListHelper类用于存储静态方法，方法为 函数调用函数

"""
    列表助手模块
"""


class ListHelper:
    """
        列表助手类
    """

    @staticmethod
    def find_all(list_target, func_condition):
        """
            通用的查找某个条件的所有元素方法
        :param list_target: 需要查找的列表
        :param func_condition: 需要查找的条件,函数类型
                函数名(参数) --> bool
        :return: 需要查找的元素,生成器类型.
        """
        for item in list_target:
            if func_condition(item):
                yield item

    @staticmethod
    def find_single(list_target, func_condition):
        """
            通用的查找某个条件的单个元素方法
        :param list_target: 需要查找的列表
        :param func_condition: 需要查找的条件,函数类型
                函数名(参数) --> bool
        :return: 需要查找的元素
        """
        for item in list_target:
            if func_condition(item):
                return item

另一模块导入并调用函数

"""
    测试 通用模块list_helper
"""
from  common.list_helper import *


class SkillData:
    def __init__(self, id, name, atk_ratio, duration):
        self.id = id
        self.name = name
        self.atk_ratio = atk_ratio
        self.duration = duration

    def __str__(self):
        return "技能数据是:%d,%s,%d,%d" % (self.id, self.name, self.atk_ratio, self.duration)


list_skill = [
    SkillData(101, "乾坤大挪移", 5, 10),
    SkillData(102, "降龙十八掌", 8, 5),
    SkillData(103, "葵花宝典", 10, 2),
]


def condition01(item):
    return item.atk_ratio > 6


def condition02(item):
    return 4 < item.duration < 11


def condition03(item):
    return len(item.name) > 4 and item.duration < 6


generate01 = ListHelper.find_all(list_skill, condition01)
for item in generate01:
    print(item)

# 练习:在list_helper.py中,定义通用的查找满足条件的单个对象.
# 案例:查找名称是"葵花宝典"的技能.
#     查找编号是101的技能.
#     查找持续时间大于0的技能.

# 建议:
# 1. 现将所有功能实现
# 2. 封装变化(将变化点单独定义为函数)
#    定义不变的函数
# 3. 将不变的函数转移到list_helper.py中
# 4. 在当前模块测试

"""
def find01():
    for item in list_skill:
        if item.name =="葵花宝典":
            return item

def find02():
    for item in list_skill:
        if item.id ==101:
            return item

def find03():
    for item in list_skill:
        if item.duration > 0:
            return item
"""


def condition04(item):
    return item.name == "葵花宝典"


def condition05(item):
    return item.id == 101


def condition06(item):
    return item.duration > 0


"""
def find(func_condition):
    for item in list_skill:
        # if item.duration > 0:
        # if condition06(item):
        if func_condition(item):
            return item
     
print("-------")
re = find(condition04)
print(re)
"""

re = ListHelper.find_single(list_skill, condition05)
print(re)

P186 Python核心-4.8 lambda表达式

一、lambda表达式

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

二、示例代码

"""
    lambda 匿名函数
        语法:lambda 参数列表:函数体
        注意:函数体自带return
    练习1:将exercise06.py中,使用def定义的函数,
          改为使用lambda.

"""
from common.list_helper import *

list01 = [43, 4, 5, 5, 6, 7, 87]

# def condition01(item):
#     return item % 2 == 0
#
# def condition02(item):
#     return item > 10
#
# def condition03(item):
#     return 10 < item < 50

# for item in ListHelper.find_all(list01, condition02):
#     print(item)

for item in ListHelper.find_all(list01, lambda item: item % 2 == 0):
    print(item)


# ------------------------------
# 无参数函数 --> lambda
def fun01():
    return 100


a = lambda: 100
re = a()
print(re)


# 多参数函数 --> lambda
def fun02(p1, p2):
    return p1 > p2


b = lambda p1, p2: p1 > p2
re = b(1, 2)
print(re)

# 无返回值函数 --> lambda
def fun03(p1):
    print("参数是:", p1)


c = lambda p1: print("参数是:", p1)
c(100)

# 方法体只能有一条语句，且不支持赋值语句
def fun04(p1):
    p1 = 2

# d = lambda p1:p1 = 2

P187 Python核心-4.9 lambda练习

一、练习

from  common.list_helper import *


class SkillData:
    def __init__(self, id, name, atk_ratio, duration):
        self.id = id
        self.name = name
        self.atk_ratio = atk_ratio
        self.duration = duration

    def __str__(self):
        return "技能数据是:%d,%s,%d,%d" % (self.id, self.name, self.atk_ratio, self.duration)


list_skill = [
    SkillData(101, "乾坤大挪移", 5, 10),
    SkillData(102, "降龙十八掌", 8, 5),
    SkillData(103, "葵花宝典", 10, 2),
]

# 使用lambda实现
# 案例:查找名称是"葵花宝典"的技能.
#     查找编号是101的技能.
#     查找持续时间大于0的技能.
re = ListHelper. \
    find_single(list_skill,
                lambda item: item.name == "葵花宝典")
print(re)

re = ListHelper.find_single(list_skill, lambda element: item.id == 101)
print(re)

re = ListHelper.find_single(list_skill, lambda element: item.duration > 0)
print(re)

P188 Python核心-4.10 练习解析及作业

一、练习1

在通用模块list_helper模块，ListHelper类中新增静态方法如下

    @staticmethod
    def get_count(list_target, func_duration):
        """
               通用的计算满足某个条件的元素数量方法
           :param list_target: 需要查找的列表
           :param func_condition: 需要查找的条件,函数类型
                   函数名(参数) --> bool
           :return: 满足条件元素的数量
        """
        count_value = 0
        for item in list_target:
            if func_duration(item):
                count_value += 1
        return count_value

实现lambda

# 需求1:计算技能列表中技能名称大于4个字的技能数量.
# 需求2:计算技能列表中技能持续时间小于等于5的技能数量.
# 步骤:
# 实现每个需求/单独封装变化/定义不变的函数("继承"/"多态")
# 将不变的函数提取到list_helper.py中
"""
def get_count01():
    count_value = 0
    for item in list_skill:
        if len(item.name) > 4:
            count_value +=1
    return count_value

def get_count02():
    count_value = 0
    for item in list_skill:
        if item.duration <= 5:
            count_value +=1
    return count_value

def get_count(func_duration):
    count_value = 0
    for item in list_skill:
        # if item.duration <= 5:
        if func_duration(item):
            count_value +=1
    return count_value
"""
re = ListHelper.get_count(list_skill,lambda item:len(item.name) > 4)
print(re)
re = ListHelper.get_count(list_skill,lambda item:item.duration <= 5)
print(re)
weixin_43838595
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python基础学习Day9
birdooo的博客
12-30 2万+
Day 9 导引问题 在实际工作中，我们遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在或者文件格式不对；你要读取数据库的数据，数据可能是空的；我们的程序再运行，但是内存或硬盘可能满了等等。 软件程序再运行过程中，非常可能遇到刚刚提到的这些问题，我们称之为异常，英文是：Exception，意思是例外。遇到这些例外情况，或者叫异常，我们怎么让写的程序做出合理的处理，而不至于程序崩溃呢？ 如果我们要拷贝一个文件，在没有异常
Python100天学习教程（Python学习视频_Python学习路线）：Day01 初识Python
chen801090的博客
05-20 3450
话说，520情人节啥的跟咱程序员有关系吗？都慌着干啥呢，不用学Python的吗？ 哈哈哈，大家视情况而定哈，没对象的赶紧跟唐唐一起学Python100天学习教程吧！ 今天起唐唐会跟大家出系统的Python100天专题课程和习题，100天从新手到大神，你也可以！ Python100天学习教程（Python学习视频_Python学习路线）：Day01 初识Python Python简介 Python的...
Python学习 Day11 进程和线程（二）
weixin_45492364的博客
05-21 954
定义一个异步函数，这样的函数可以包含等待IO操作（或其他异步操作）的挂起点。
Python 学习笔记
分享快乐，让笑容感染每一个角落！
06-13 900
概述Python编程的核心内容与应用。从基础语法出发，涵盖变量、数据类型、条件判断、循环结构以及函数定义等关键概念。进阶部分深入探讨了模块与包管理、异常处理以及文件操作等技能。此外，还介绍了生成器、迭代器、装饰器等高级特性，提升了代码效率和优雅度。通过实践应用，将理论知识与实际操作相结合，展示了Python在Web开发、数据分析和自动化脚本编写等方面的广泛应用。
Python 迁移学习实用指南：6~11
龙哥盟
04-15 2171
原文：Hands-On Transfer Learning with Python 协议：CC BY-NC-SA 4.0 译者：飞龙 本文来自【ApacheCN 深度学习 译文集】，采用译后编辑（MTPE）流程来尽可能提升效率。 不要担心自己的形象，只关心如何实现目标。——《原则》，生活原则 2.3.c 六、图像识别与分类 知识投资永远是最大的利益。 ——本杰明·富兰克林 在计算机视觉的保护下，图像识别是一个活跃的跨学科研究领域。 顾名思义，图像或对象识别是识别图像或视频序列中的对象的任务。 传统上，该
python+大数据学习打卡day1
weixin_56306635的博客
02-27 1309
【大数据从0-1打卡-day1】 1、简单了解一些关于大数据的概念 数据：数据就是对客观事件进行记录并可以鉴别的符号。他不仅仅是指数字，还可以是有一定意义的字母、文字、符号、语音、文字、图画、视频或者这些元素的结合等。 企业数据分析方向：现状分析：离线分析 原因分析：实时分析 预测分析：机器学习 数据分析基本流程：采集、处理、分析、应用 大数据：大数据(big data)，指的是所涉及的资料量规模巨大到无法透过主流软件工具，在合理时间内达到撷取、管理、处理、并整理成为帮助企业经营决策更积极目的
Python深度学习-基于pytorch-2
fyh2944163240的博客
10-17 1407
在训练模型过程中，经常会出现刚开始训练时，训练和测试精度不高（或损失值较大），然后通过增加迭代次数或通过优化，训练精度和测试精度继续提升，如果出现这种情况，当然最好。现在，如果要最小化这个新的损失函数，应要让，和04尽可能的小。因为如果你在原有损失函数的基础上加上10000乘以，这一项，那么这个新的损失函数将变得很大，所以，当要最小化这个新的损失函数时，将使。，该模块提供了常用的初始化策略，如xavier、kaiming等经典初始化策略，使用这些初始化策略有利于激活值的分布呈现出更有广度或更贴近正态分布。
python+大数据学习day4
weixin_56306635的博客
03-08 1224
HDFS HDFS（Hadoop Distributed File System ），意为：Hadoop分布式文件系统。 是Apache Hadoop核心组件之一，作为大数据生态圈最底层的分布式存储服务而存在。也可以说大数据首先要解 决的问题就是海量数据的存储问题。 HDFS主要是解决大数据如何存储问题的。分布式意味着是HDFS是横跨在多台计算机上的存储系统。 HDFS是一种能够在普通硬件上运行的分布式文件系统，它是高度容错的，适应于具有大数据集的应用程序，它非 常适于存储大型数据 (比
Python学习记录day5
ygqygq2的IT博客
11-28 1207
1.多层装饰器 2.字符串格式化 3.迭代器和生成器 4.函数递归 5.模块 6.序列化 7.time & datetime模块 8.logging模块
深度学习入门python知识总结
naexting的博客
09-02 1130
1.环境配置安装 Python+Anaconda+PyCharm 1.1Anaconda 是一个开源的Python发行版本。其包含了720多个数据科学相关的开源包，在数据可视化、机器学习、深度学习等多方面都有涉及。不仅可以做数据分析，甚至可以用在大数据和人工智能领域。因为包含了大量的科学包，Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）。 Anaconda通过管理工具包、开
python 学习使用 按位取反（~）（示例）
11-16
# 题目： # 学习使用 按位取反（~）。 # 分析： # 0=1;1=0; # (1) 先使a右移4位。 # (2) 设置一个低4位全为1,其余全为0的数。可用(0) # (3) 将上面二者进行&运算。
python学习 day3
12-21
python学习day3容器类型补全1. set 集合2. dict 字典定义字典获取字典的值修改字典的值3. 二级容器变量的缓存机制【1】Number型int 整型float 浮点型bool 布尔型complex 复数型【2】容器类型强制类型转换Number型的...
学习python核心编程从小白到大师NO.2
01-20
02——python要点 1.Python语言 1.1 Python语言的基本概念 • Python 是一种极少数能兼具 简单 与 功能强大 的编程语言。你将惊异于发现你正在使用的这门编程语言是如此简单，它专注于如何解决问题，而非拘泥于语法...
python学习day06.txt
05-05
Day05回顾 1、json模块 1、json.loads() json格式(对象、数组) -> Python(字典、列表) 2、json.dumps() Python(字典、元组、列表) -> json(对象、数组) 2、Ajax动态加载 1、抓包工具抓参数 ：WebForms -> ...
htb_Blurry
weixin_62621015的博客
06-13 734
hack the box linux
GLM+vLLM 部署调用
qq_38915354的博客
06-13 1229
vLLM 框架是一个高效的大型语言模型（LLM）推理和部署服务系统
找出Python潜在的编程问题
svygh123的专栏
06-13 1090
Pylint 是一个非常强大的静态代码分析工具，主要用于检查 Python 代码的语法错误、代码风格问题以及潜在的编程错误。它是 Open Source Initiative 认证的开源软件，由 Logilab 团队开发维护。
第9章 类
最新发布
我走的每一步都算数
06-17 932
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。class Car:class ElectricCar(Car): # 继承Carself.battery = 85 # 新属性mycar = ElectricCar(2024, 'Au', 'A7') # 创建实例mycar.prt_battery() # 新方法熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。
python生成一个含有数字0~99的列表
06-06
可以使用Python中的range函数来生成一个含有数字0~99的列表，具体代码如下： ```python my_list = list(range(100)) print(my_list) ``` 这里的range函数会生成一个从0开始，步长为1，到99结束的数字序列，然后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值