Python编程-面向对象基础与入门到实践一书的内容拓展

Python编程-面向对象基础与入门到实践一书的内容拓展

通过编程，模拟现实生活中的事物编程，叫做面向对象编程，此过程也叫做实例化编程

简单类的创建

class Test():def __init__ (self,id):self.id = iddef print_id(self):print(self.id)

这里建立了一个名为test的类，其中有两个函数，__init__与print_id,有一个数据成员id

  • __init__函数

__init__是一种特殊方法，用于创建类时的初始化，其中带有两个参数self与id,其中__init__初始化类对象时，将参数全部自动传递给self（无需我们手动传参）,self相当于为每个对象划定了一个用于存放数据成员的位置，保证每个对象的数据成员独立且不受干扰，需要注意的是**self必须放置在最前面**，而后面的id就是我们需要传递的参数，并且它的数量是任意的（需要多少个，参数就写多少个）

  • 成员函数访问数据

在一个类中的成员函数使用对应对象的数据成员时，必须要使用self获取对应的数据成员，如self.id

熟悉c++的同学应该看出来了，这和c++的构造函数是类似的

  • 拓展思维

既然成员是函数（虽然类中叫方法），那么能否使用关键字实参，默认值与不定参数呢？当然是可以的，后文实验源码将会写到

__init__的使用

我们先看如下代码：

class Base():def fun(self):self.a = 1self.data = 2def print_all(self):print(self.id, self.data)op = Base()
op.print_all()

我们定义了上述代码，通过运行我们会发现，这几行代码是没有办法运行的，解释器会丢出以下错误：

在这里插入图片描述

可以看到，解释器提示我们，缺少了对应的属性，原因就是因为我们没有使用__init__来创建对应的self数据，类中并没有存储我们的id与data，但是没有该方法，代码能不能跑呢，答案是可以，如下的特殊情况：

class Base():def fun(self,x,y):return x,yop = Base()
print(op.fun(1,2))

可以看到运行是正常的，但是我们进行类创建时最好加上__init__,不然实例化将失去意义

此处注意一个细节，建立无参类的对象时需要加上(),例如 op = Base()

创建与访问对象

class Test():def __init__ (self,id_):self.id = id_self.age = 16def print_id(self):print(self.id)a = Test(11)
a.print_id()
a.id = 12
print(a.id)
print(a.age)

我们的__init__函数中传入了一个id_,所以传入了一个参数11,而我们要访问对应对象的数据或函数成员则需要.运算符,同理要修改某一成员时，也需要用.运算符操作，并且我们还可以为对象指定默认参数，如上述代码中的self.age = 16

子类继承

通常一个大类下可能有，多个有差异的子类，此时则需要继承操作，我们注意到，前面的Test的对象后面有一个括号，在未进行继承时该括号可以省略

无参构造的继承

class Base():def __init__(self):self.id = 1self.data = 2def print_all(self):print(self.id, self.data)class Dome(Base):def __init__(self):super().__init__()self.a = 3def print_all(self):print(self.id, self.data, self.a)object = Dome()
object.print_all()

如上代码中的无参数类继承，这里需要提出几个关键点：

  • 在C++中在继承时无参数基类是可以省略派生类与基类的构造，但是python不能够省略
  • 派生类的super().__init__()也不能省略，它是用来链接基类与派生类的，省略后将无法从基类继承

对于第二点有以下情况，当我们不使用基类继承成员时能否省略super().__init__()呢？我们运行以下代码：

class Base():def __init__(self):print("yes")  # 我们加入了基类构造提示self.id = 1self.data = 2def print_all(self):print(self.id, self.data)class Dome(Base):def __init__(self):# super().__init__()  # 将之注释掉self.a = 3def print_all(self):print(self.a)object = Dome()
object.print_all()

通过上述代码运行结果可知，此代码并没有进行继承操作，仅仅只是输出了a的值，即class Dome(Base)失去意义，如果我们取消注释，那么它又将正常继承

有参构造的继承

class Base():def __init__(self, id, data):self.id = idself.data = datadef print_all(self):print(self.id, self.data)class Dome(Base):def __init__(self, id, data, a):super().__init__(id, data)self.a = adef print_all(self):print(self.id, self.data, self.a)object = Dome(1, 2, 3)
object.print_all()

如上述代码，我们在子类Dome的括号内填入基类的的名字，Dome中的第一个__init__用于初始化传入派生类的值super函数用于连接基类与派生类，其后跟随的__init__用于向基类传递参数，并且不加self（作为实参，调用基类的__init__），并且在为基类构造时，派生类的构造函数参数数量至少要大于或等于基类参数的数量，否则将构建失败

重写基类成员

有时候我们需要对于派生类与基类的不同之处做出不同的行为，但是为了保证代码的可读性，我们要派生类调用同名函数，于是我们有以下操作：

class Base():def __init__ (self,id_):self.id = id_def print_id(self):print(self.id)class Dome(Base):def __init__ (self,id_):super().__init__(id_)self.a = 12def print_id(self):print(self.a)object = Dome(11)
object.print_id()

运行上述代码，使用与基类中同名的函数得到子类中a的值

在子类中调用基类方法

class Base():def __init__ (self,id_):self.id = id_def print_id(self):print(self.id)class Dome(Base):def __init__ (self,id_):super().__init__(id_)self.a = 12def print_id(self):super().print_id()object = Dome(11)
object.print_id()

运行上述代码，使用与基类中同名的函数得到基类中id的值

多继承的super参数处理

class BaseClass:def __init__(self, base_param):self.base_param = base_paramprint("BaseClass constructor with base_param:", self.base_param)class Mixin1(BaseClass):def __init__(self, mixin1_param, **kwargs):super().__init__(**kwargs)  # 调用父类的构造函数self.mixin1_param = mixin1_paramprint("Mixin1 constructor with mixin1_param:", self.mixin1_param)class Mixin2(BaseClass):def __init__(self, mixin2_param, **kwargs):super().__init__(**kwargs)  # 调用父类的构造函数self.mixin2_param = mixin2_paramprint("Mixin2 constructor with mixin2_param:", self.mixin2_param)class MyClass(Mixin1, Mixin2):def __init__(self, base_param, mixin1_param, mixin2_param):super().__init__(base_param=base_param, mixin1_param=mixin1_param, mixin2_param=mixin2_param)print("MyClass constructor")# 创建实例
obj = MyClass(base_param="BaseParam", mixin1_param="Mixin1Param", mixin2_param="Mixin2Param")

在这个例子中，每个类的构造函数都接收一些参数，并使用 super().__init__(**kwargs) 来调用父类的构造函数。在 MyClass 中，通过使用 super() 来确保调用了 Mixin1 和 Mixin2 的构造函数，并传递了适当的参数。

类的嵌套

总所周知python中套娃是非常普遍的，通常情况下，我们在构建一个实例时，实例的属性是非常复杂的，我们为了简化代码，需要为某些特定属性建立一个类：

class build:def __init__(self):self.time = 1998def print_time(self):print(self.time)class Base:def __init__ (self,id_):self.id = id_self.build = build()def print_id(self):print(self.id)ob = Base(22)
ob.build.print_time()

如上，我们为Base类建立了一个嵌套的子类build，用于存储建立的时间，但是访问time时时我们需要注意：要通过Base对象去访问build中的成员print_time

类的访问权限

Python中对类中数据的访问权限并没有C++那样严格，可以暂时认为只有私有与公有两种权限（先暂时这样理解，后文将细说）

公有权限

class Test:def __init__(self,a):self.a = adef print_(self):print(self.a)object = Test(22)
print(object.a)
object.a = 33
print(object.a)

如上，定义一个简单的类，然后访问并且修改它，可以看到修改成功，即按上述代码进行编写代码，所有数据都是公有的，外界可以修改

私有权限

class Test:def __init__(self,a):self.__a = adef print_(self):print(self.__a)ob = Test(22)
print(ob.__a)

先看如上错误代码，我们运行后可以发现会抛出如下错误：

在这里插入图片描述

它会提示我们，Test类中没有这个属性，原来我们在成员前加上__后解释器对数据成员进行了一个类似于重命名的操作，不同版本的解释的方式也不同，如果我们要强行访问，也可以想办法找到对应解释器的重构规则进行访问，一般这类成员我们通过成员方法进行访问

class Test:def __init__(self,a):self.__a = adef print_(self):print(self.__a)ob = Test(22)
ob.print_()

需要注意的是：

  • 类似于__init__这类前后带有双下划线的，在python中是特殊的变量，可以直接访问
  • 从上面可知，python中的权限实际上是没有限制的，只要你有对应的访问方式
  • 和C++类似，python的方法和C++的函数一样是可以作为私有成员的，如下套娃代码
class Test:def __init__(self,a):self.__a = adef __print_(self):print(self.__a)def printf(self):self.__print_()ob = Test(22)
ob.printf()

保护权限

python中实际上是没有保护权限的，但是有一种约定俗成的规定，即在变量前加 _,这类成员实际上仍然是公有的，但是约定为保护成员

class Test:def __init__(self,a):self._a = adef print_(self):print(self._a)object = Test(22)
print(object._a)
object.a = 33
print(object._a)

通过上述讲解，我们可以将继承进行拓展，即在继承时，实际上是继承了所有成员，但是由于我们不知道对应变量的变量名，而变得难以访问对应成员

单类模块使用

和函数一样，python也支持将类装进一个模块，我们建立一个Test模块进行使用

# test.py
class Test:def __init__(self,a):self._a = adef print_(self):print(self._a)

这个模块包含了一个Test类，其中有一个数据成员_a和一个函数print_

使用该模块可以通过如下引入：from [模块文件名] import [对应类名]

则引入方式为 from test import Test

多类模块的引入

通常在构建项目时，会建立多个类的模块，可能会包含多个同等地位的类，子类嵌套或继承，此时引入方式和上述仍然一致：

# test.py
class Test_one:def __init__(self,a):self._a = adef print_(self):print(self._a)class Test_two:def __init__(self,a):self._a = adef print_(self):print(self._a)

如上建立同等地位的类，我们的访问方式没有太多变化：

from test import Test_one
from test import Test_two

访问带有子类嵌套的类模块

# test.py
class Test_one:def __init__(self, x, y):self.a = xself.b = Test_two(y)def print_(self):print(self.a)class Test_two:def __init__(self, x):self.a = xdef print_(self):print(self.a)

定义类如上，接下来我们进行访问：

from test import Test_oneobject = Test_one(22, 33)
print(object.a, object.b.a)

我们注意到运行是正常的，即python在引入带子类的类Test_one后初始化其对象时，会自动创建其子类，但是并没有自动为文件引入模块中的子类，即如下操作是错误的：

from test import Test_oneobject = Test_two(22)

访问带有继承类模块

# test.py
class Base():def __init__(self, id, data):self.id = idself.data = datadef print_all(self):print(self.id, self.data)class Dome(Base):def __init__(self, id, data, a):super().__init__(id, data)self.data = dataself.a = adef print_all(self):print(self.id, self.data, self.a)

建立如上模块，进行以下操作：

from test import Domeobject = Dome(1, 2, 3)
object.print_all()

正常运行，并且访问带有继承类模块时，导入其派生类不会自动导入基类

还有一点，类模块和函数一样也是可以取别名的，就像以下操作：

from test import Dome as dobject = d(1, 2, 3)
object.print_all()

其他导入情况

我们经常会遇到下述情况：

  • 使用同一模块中的所有类
  • 使用同一模块中的两个或两个以上的类

这方面和函数类似，我们依次介绍

使用同一模块中的所有类

from test import *

此操作将取出该模块中所有类，并且不使用.运算符操作

格式：from [模块名] import *

import test

此操作导入了整个模块，需要使用.运算符操作

格式：import [模块名]

类与函数混合模块的导入

在python中可以将函数与类放在同一模块下，如下：

# test.py
class Base():def __init__(self, id, data):self.id = idself.data = datadef print_all(self):print(self.id, self.data)class Dome(Base):def __init__(self, id, data, a):super().__init__(id, data)self.data = dataself.a = adef print_all(self):print(self.id, self.data, self.a)def hello_world():print(("hello World").title())

但是我们使用时仍然是一致的：

from test import *object = Dome(1, 2, 3)
object.print_all()hello_world()

实验源码

# Chicken.py
class Person:def __init__(self, name, time, *show): # 不定参数self.name = nameself.time = timedef print_all(self):print(self.name, self.time)class PersonShow(Person):def __init__(self, name, time, *show):super().__init__(name=name, time=time) # 关键字实参self.showList = []for i in range(0, len(show)):self.showList.append(show[i])def print_all(self):byte_str = bytes.fromhex('e894a1e5be90e59da4')string = byte_str.decode('utf-8')print("我是练习时长"+str(self.time)+"的个人练习生"+str(self.name))print("喜欢", self.showList)if self.name == string:print("鸡 你 太 美")print("喜欢的话 请多多为我投票吧")

from Chicken import *if __name__ == "__main__" :player = PersonShow("蔡徐坤","两年半","唱","跳","RAP","篮球")player.print_all()

所有类的超类object

在Python中，所有的类都直接或间接地继承自object类，类似于Java中的Object类。不过在Python 3中一般不需要显式继承object，因为所有的类默认就是新式类。与Java的Object类类似，Python中的object类也提供了一些通用的方法，这些方法可以在自定义类中使用或者覆盖：

  1. __str__()方法： 类似于Java中的toString()方法，它返回对象的字符串表示形式。
def __str__(self):return "This is a custom object"
  1. __eq__()方法： 用于比较两个对象是否相等。默认的实现是比较对象的身份标识（identity），即是否指向同一内存地址。可以根据实际需要覆盖该方法。
def __eq__(self, other):if isinstance(other, MyClass):return self.some_value == other.some_valuereturn False
  1. __hash__()方法： 返回对象的哈希码值。与Java中的hashCode()类似，用于在散列表等数据结构中使用。
def __hash__(self):return hash(self.some_value)
  1. __repr__()方法： 返回对象的“官方”字符串表示，通常是一个可以用来重建对象的表达式。
def __repr__(self):return f"MyClass({self.some_value})"

这些方法在Python中的使用与Java中的Object类的方法类似，但是命名方式略有不同。在Python中，双下划线（__）表示特殊方法（也称为魔法方法或魔术方法），用于实现类的特殊行为。

注意事项和建议与Java类似：

  • __eq__()和__hash__()一致性： 如果两个对象通过__eq__()方法相等，那么它们的__hash__()值应该相等，以确保在使用散列表等数据结构时能够正确地工作。

  • __str__()和__repr__()可读性： 类似于Java中的toString()方法，这两个方法的实现应该返回清晰、简洁且可读性强的字符串。

魔术方法

你可能注意到了，上述出现的所有方法均以两个短横线开始或结束，这便是python中的魔术方法，它们大多数都来自object类，下面是一些常见的魔术方法参考表格：

魔术方法描述
__init__(self, ...)初始化对象，在创建对象时调用
__del__(self)删除对象时调用
__str__(self)返回对象的字符串表示
__repr__(self)返回对象的“官方”字符串表示，用于开发和调试
__len__(self)返回对象的长度，使用内置的len()函数时调用
__getitem__(self, key)定义获取元素的行为，例如obj[key]
__setitem__(self, key, value)定义设置元素的行为，例如obj[key] = value
__delitem__(self, key)定义删除元素的行为，例如del obj[key]
__iter__(self)定义迭代器的行为，使对象可迭代
__next__(self)定义迭代器的next方法，返回下一个迭代值
__contains__(self, item)定义成员测试行为，例如item in obj
__call__(self, ...)实例对象可调用，类似函数调用的行为
__eq__(self, other)定义相等比较的行为，例如obj == other
__ne__(self, other)定义不相等比较的行为，例如obj != other
__lt__(self, other)定义小于比较的行为，例如obj < other
__le__(self, other)定义小于等于比较的行为，例如obj <= other
__gt__(self, other)定义大于比较的行为，例如obj > other
__ge__(self, other)定义大于等于比较的行为，例如obj >= other
__add__(self, other)定义加法行为，例如obj + other
__sub__(self, other)定义减法行为，例如obj - other
__mul__(self, other)定义乘法行为，例如obj * other
__truediv__(self, other)定义真除法行为，例如obj / other
__floordiv__(self, other)定义整除法行为，例如obj // other
__mod__(self, other)定义取模行为，例如obj % other
__pow__(self, other[, modulo])定义幂运算行为，例如obj ** other
__enter__(self)在进入with语句块时调用，用于资源的初始化和分配
__exit__(self, exc_type, exc_value, traceback)在离开with语句块时调用，用于资源的释放和清理
__setattr__(self, name, value)在设置属性时调用，例如obj.attr = value
__getattr__(self, name)在获取不存在的属性时调用，例如obj.nonexistent_attr

类属性使用

在Python中，类属性是属于类而不是类的实例的属性。它们是在类定义中声明的变量，而不是在类的实例中创建的。所有属于类的实例共享相同的类属性。

class CarClass:# 类属性num_wheels: int = 4def __init__(self, make, model) -> None:# 实例属性self.make = makeself.model = modelif __name__ == "__main__":# 创建两个 Car 实例car_one: CarClass = CarClass("Toyota", "Camry")car_two: CarClass = CarClass("Honda", "Accord")# 访问实例属性print(car_one.make)  # 输出: Toyotaprint(car_two.model)  # 输出: Accord# 访问类属性（使用类名或实例都可以）print(CarClass.num_wheels)  # 输出: 4print(car_one.num_wheels)  # 输出: 4print(car_two.num_wheels)  # 输出: 4# 修改类属性（注意这会影响所有实例）CarClass.num_wheels = 6# 检查修改后的类属性print(CarClass.num_wheels)  # 输出: 6print(car_one.num_wheels)  # 输出: 6print(car_two.num_wheels)  # 输出: 6

需要注意的是：类属性不会被实例化给每个对象，而是被所有该类的实例所共享。当你创建一个类属性时，它属于类本身，而不是类的实例。所有通过该类创建的实例都可以访问和共享相同的类属性。

在Python中，实例在访问属性时首先查找实例本身是否有该属性，如果没有，它会继续查找类的属性。这就是为什么实例可以访问类属性的原因。

实例属性遮蔽

接下来考虑以下问题：

我们在 CarClass.num_wheels = 6 前增加一行代码 car_one.num_wheels = 233，此时运行代码将会的出什么结果呢？

在这里插入图片描述

当你运行 car_one.num_wheels = 233时，它会创建一个新的实例属性 num_wheels，而不是修改类属性。这是因为在 Python 中，如果你为实例赋值一个属性，它会在实例上创建一个同名的属性，而不会影响到类属性。这就是实例属性遮蔽

self引用实例对象

在 Python 中，self 是一个惯例，用于表示对象实例本身。它是在类的方法中作为第一个参数传递的，但在调用该方法时不需要显式传递。self 提供了一种引用对象实例属性和方法的方式

但是self 的命名并不是强制的，你可以使用其他名称，但 self 是一个广泛接受的约定，因此建议在大多数情况下使用它（不推荐自己定义，应使用self或团队，公司的约定）。如以下不推荐的自定义示例：

class TestClass:def __init__(my_self, value):my_self.value = valuedef printf(my_self):print(my_self.value)obj = TestClass(233)
obj.printf()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/587413.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

c++简易AI

c++简易AI

今天小编一时雅兴大发&#xff0c;做了一个c的简易AI&#xff0c;还是很垃圾的&#xff01; 题外话&#xff08;每期都会有&#xff09;&#xff1a;我的蛋仔名叫酷影kuying&#xff0c;大家能加我好友吗&#xff1f; 上代码咯&#xff01; #include<bits/stdc.h> #in…
阅读更多...
文件描述符

文件描述符

文件描述符 2.1 文件描述符 文件描述符&#xff08;File Descriptor&#xff09;是在Unix-like操作系统中用于标识和访问文件或I/O设备的抽象概念。它是一个非负整数&#xff0c;用于**唯一标识一个打开的文件、套接字&#xff08;socket&#xff09;或其他类型的I/O资源。**…
阅读更多...
Elasticsearch-8.11.1 （2+1）HA（高可用）集群部署

Elasticsearch-8.11.1 （2+1）HA（高可用）集群部署

目录 一、环境描述 二、安装 ES 2.1 下载Elasticsearch 2.2 解压Elasticsearch 2.3 创建es服务账号/密码 2.3 修改服务器配置 2.4 配置节点 2.4.1 配置说明 2.4.2 配置高可用集群 2.4.2.1 maser节点服务配置 2.4.2.2 node1 节点服务配置 2.4.2.3 node2 节点服务配置…
阅读更多...
redis的基本使用

redis的基本使用

一、 Redis简介 Redis是一个基于内存的 key-value 结构数据库。Redis是一款采用key-value数据存储格式的内存级NoSQL数据库&#xff0c;重点关注数据存储格式&#xff0c;是key-value格式&#xff0c;也就是键值对的存储形式。与MySQL数据库不同&#xff0c;MySQL数据库有表、…
阅读更多...
Pearson correlation coefficient (Pearson’s r) 皮尔森相关系数

Pearson correlation coefficient (Pearson’s r) 皮尔森相关系数

此图用的是箱状图&#xff0c;的纵轴是“Pearson’s r”&#xff0c;是实际观测值与机器学习模型预测值之间的相关性 Pearsons f得分&#xff0c;它是一个统计量&#xff0c;用来衡量两个变量之间线性相关性的强度。这个得分可能是用来衡量实际观测值与机器学习模型预测值之间的…
阅读更多...
YOLOv8改进 | 检测头篇 | ASFF改进YOLOv8检测头（全网首发）

YOLOv8改进 | 检测头篇 | ASFF改进YOLOv8检测头（全网首发）

一、本文介绍 本文给大家带来的改进机制是利用ASFF改进YOLOv8的检测头形成新的检测头Detect_ASFF&#xff0c;其主要创新是引入了一种自适应的空间特征融合方式&#xff0c;有效地过滤掉冲突信息&#xff0c;从而增强了尺度不变性。经过我的实验验证&#xff0c;修改后的检测头…
阅读更多...
Tomcat和Servlet

Tomcat和Servlet

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、Tomcat是什么&#xff1f;1.1下载&#xff1a;1.2 tomcat是什么1.3启动服务器&#xff1a; 二.部署三、Servlet3.1创建项目3.2引入依赖pom.xml的所有代码 3…
阅读更多...
Tg-5511cb: tcxo高稳定性+105℃高温

Tg-5511cb: tcxo高稳定性+105℃高温

爱普生推的一款TG-5511CB是一种高稳定的TCXO温补晶体振荡器&#xff0c;频率范围十分广泛从 10mhz ~ 54mhz&#xff0c;它的电源电压只需要3.3V&#xff0c;无论是手机还是其他电子设备&#xff0c;都能轻松提供稳定的电力支持。频率/温度特性表现出色&#xff0c;0.28 10^6Ma…
阅读更多...
（2023，提示扩展，图像反演，文本到文本生成）自适应文本到图像生成的提示扩展

（2023，提示扩展，图像反演，文本到文本生成）自适应文本到图像生成的提示扩展

Prompt Expansion for Adaptive Text-to-Image Generation 公众&#xff1a;EDPJ&#xff08;添加 VX&#xff1a;CV_EDPJ 或直接进 Q 交流群&#xff1a;922230617 获取资料&#xff09; 目录 0. 摘要 3. 提示扩展数据集 3.1 图像审美数据集 3.2 图像到文本反演 3.3 查…
阅读更多...
Obsidian笔记软件无公网远程同步数据到群辉Webdav

Obsidian笔记软件无公网远程同步数据到群辉Webdav

文章目录 1. 群晖开启Webdav服务2. 群晖安装Cpolar3. 配置Webdav远程地址4. Obsidian 安装Remotely Save5. Obsidian远程连接Webdav6. 固定Cpolar公网地址7. PC和移动端笔记同步演示 Obsidian是一款笔记软件&#xff0c;它基于Markdown&#xff0c;支持Windows、macOS、iOS和An…
阅读更多...
个人博客主题 vuepress-hope

个人博客主题 vuepress-hope

文章目录 1. 简介2. 配置2.1 个人博客&#xff0c;社媒链接配置 非常推荐vuepress-hope 1. 简介 下面的我的博客文章的截图 通过md写博客并且可以同步到github-page上 2. 配置 2.1 个人博客&#xff0c;社媒链接配置 配置文件 .vuepress/theme.ts blog: {medias: {BiliB…
阅读更多...
计算机毕业设计 基于HTML5+CSS3的在线英语阅读分级平台的设计与实现 Java实战项目 附源码+文档+视频讲解

计算机毕业设计 基于HTML5+CSS3的在线英语阅读分级平台的设计与实现 Java实战项目 附源码+文档+视频讲解

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…
阅读更多...
C#编程-使用变量

C#编程-使用变量

使用变量 请考虑以下场景：您必须创建一个程序，接受来自用户的两个数字并在屏幕上显示着两个数字之和。现在，读取用户提供的数字时，您需要将这些数字存储在内存中的某个位置，以便您能对这些数字执行加操作。您可以使用变量将这些数字存储在内存中。 下图显示了使用变量将…
阅读更多...
股票价格预测 | Python实现Autoformer, FEDformer和PatchTST等模型用于股价预测

股票价格预测 | Python实现Autoformer, FEDformer和PatchTST等模型用于股价预测

文章目录 效果一览文章概述环境描述源码设计效果一览 文章概述 Autoformer、FEDformer和PatchTST是一些用于时间序列预测，包括股价预测的模型。它们都是在Transformer模型的基础上进行了改进和扩展，以更好地适应时间序列数据的特点。 Autoformer：Autoformer是一种自适应Tran…
阅读更多...
pytorch05:卷积、池化、激活

pytorch05:卷积、池化、激活

目录 一、卷积1.1 卷积的概念1.2 卷积可视化1.3 卷积的维度1.4 nn.Conv2d1.4.1 无padding 无stride卷积1.4.2 无padding stride2卷积1.4.3 padding2的卷积1.4.4 空洞卷积1.4.5 分组卷积 1.5 卷积输出尺寸计算1.6 卷积的维度1.7 转置卷积1.7.1 为什么被称为转置卷积1.7.2 nn.Con…
阅读更多...
【HDFS联邦（2）】HDFS Router-based Federation官网解读：HDFSRouterFederation的架构、各组件基本原理

【HDFS联邦（2）】HDFS Router-based Federation官网解读：HDFSRouterFederation的架构、各组件基本原理

文章目录 一. 介绍二、HDFS Router-based Federation 架构1. 示例说明2. Router2.1. Federated interface2.2. Router heartbeat2.3. NameNode heartbeat2.4. Availability and fault toleranceInterfaces 3. Quota management4. State Store 三、部署 ing 本文主要参考官网&am…
阅读更多...
JavaScript系列——正则表达式

JavaScript系列——正则表达式

文章目录 需求场景正则表达式的定义创建正则表达式通过 / 表示式/ 创建通过构造函数创建 编写一个正则表达式的模式使用简单模式使用特殊字符常用特殊字符列表特殊字符组和范围 正则表达式使用代码演示 常用示例验证手机号码合法性 小结 需求场景 在前端开发领域&#xff0c;在…
阅读更多...
C语言 指针

C语言 指针

C语言学习&#xff01; 目录 文章目录 前言 一、指针是什么&#xff1f; 二、指针变量的大小 三、指针和指针类型 四、指针和函数 五、野指针 5.1野指针成因 5.2 如何规避野指针 六、指针运算 6.1 指针- 整数 6.2 指针-指针 6.3 指针的关系运算 总结 前言 指针理解的2个要点&a…
阅读更多...
前端Vue中自定义Popup弹框、按钮及内容的设计与实践

前端Vue中自定义Popup弹框、按钮及内容的设计与实践

标题&#xff1a;前端Vue中自定义Popup弹框、按钮及内容的设计与实践 一、引言 在Web前端开发中&#xff0c;弹框&#xff08;Popup&#xff09;是一种常见的用户界面元素&#xff0c;用于向用户显示额外的信息或提供额外的功能。然而&#xff0c;标准的弹框往往不能满足所有…
阅读更多...
Django学习3——靓号管理

Django学习3——靓号管理

目录 靓号管理 表结构和数据 根据表结构的需求&#xff0c;在models.py中创建类&#xff08;由类生成数据库中的表&#xff09; 在数据库生成表 自己在数据模拟创建一些数据&#xff1a; 靓号列表 新建靓号 编辑靓号 删除靓号 搜索靓号 靓号管理 表结构和数据 根…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023