Python-面向对象编程（超详细易懂）

面向对象编程（oop）

       面向对象是Python最重要的特性，在Python中一切数据类型都是面向对象的。

       面向对象的编程思想：按照真实世界客观事物的自然规律进行分析，客观世界中存在什么样的实体，构建的软件系统就存在什么样的实体。

       例如：在学校里，有学生实体，学生是抽象的描述，称为“类”；而张同学、李同学等具体的学生个体称为“对象”，也称为“实例”；学生有学号、姓名、班级等属性，还有吃饭、走路等操作。

面向对象三大特性：封装性、继承性、多态性

封装性：使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，操作对象变得简单。

继承性： 特殊类继承一般类，拥有一般类的全部数据和操作。一般类称为“父类”或“超类”，特殊类称为“子类”或“派生类”。

多态性：在父类中成员被子类继承后，可以具有不同的状态或表现行为。

类和对象

       Python中的数据类型都是类，类是组成Python程序的基本要素，它封装了一个类对象的数据和操作。

定义类

Python语言中一个类的实现包括类定义和类体。语法格式如下：

class 类名[(父类)]:
    类体

 输入下面代码

class Animal:
    pass
print(id(Animal))
print(type(Animal))

代码运行结果

2519404222224
<class 'type'>

       注意：object类是所有类的根类，在Python中任何一个类都直接或间接的继承object；代码的pass语句表示什么操作都不执行，用来维持程序结构的完整。

创建、使用和销毁对象

       一个对象的生命周期包括创建、使用和销毁。类实例化可生成对象，所以对象也称为“实例”。

       创建对象就是在类对象的后面加上一对小括号，表示调用类对象的构造方法，这就创建了一个对象，示例代码如下

class Animal:
    pass
'''
Animal()表达式创建了一个对象，并把创建的对象赋给animal变量
animal是指向对象的一个引用。通过animal可以使用刚刚创建的对象
'''
animal = Animal()
# print函数实际上是调用了对象的__str__()方法（__str__()是object类的一个方法，
# 用于返回有关该对象的描述信息）输出字符串信息
print(animal)

代码运行结果

<__main__.Animal object at 0x000001A74F1F1970>

销毁对象

       Python会实现自动的垃圾回收：当对象没有被引用时（引用计数为0），由垃圾回收器调用__del__()（析构函数），__del__()被称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源（例如：打开的文档资源、网络连接等）。我们也可以通过del语句删除对象，系统会自动调用__del__()方法，一般不需要自定义析构方法。

示例代码如下

class Person:
    def __del__(self):
        print("销毁对象：{0}".format(self))
p1 = Person()
p2 = Person()
del p2
'''
当 p2 的引用被 del 语句删除时
p2 的 __del__ 方法会被调用
但是，p1 的 __del__ 方法可能在程序结束前不会被调用
因为它的引用仍然存在于变量 p1 中
'''
print("程序结束")

代码运行结果

销毁对象：<__main__.Person object at 0x000001B649C01AF0>
程序结束
销毁对象：<__main__.Person object at 0x000001B649C01AC0>

 实例变量

“实例变量”就是某个实例（或对象）个体特有的数据

示例代码如下

class Animal(object):
    def __init__(self,name,age,weight,gender):
        self.name = name # 定义姓名实例变量
        self.age= age # 定义年龄实例变量
        self.weight = weight # 定义体重实例变量
        self.gender =gender   # 定义性别实例变量
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)

print("姓名：{0}，年龄：{1}，体重：{2}".format(animal.name,animal.age,animal.weight))
print("男性" if animal.gender==1 else '女性')
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal1.name,animal1.age,animal1.weight))
print("男性" if animal1.gender==1 else '女性')

代码运行结果

姓名：Tom，年龄：18，体重：66
男性
姓名：Mary，年龄：18，体重：50
女性

 类变量

       “类变量”是所有实例（或对象）共有的变量，需要在方法外定义，访问实例变量通过“实例名.实例变量名”的形式，而访问类变量“类名.类变量名”的形式访问。

示例代码如下

class Account:
    interest_rate = 0.068 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount
account = Account('Tony',1_800_000.0)
# 查看实例变量
print('account实例所有变量：{0}'.format(account.__dict__))
# 为account.interest_rate变量赋值，此时无论类中是否有同名变量都会创建一个新的实例变量
account.interest_rate = 0.01
account.interest_rate2 = 0.01
print('账户名：{0}'.format(account.owner))
print('账号金额：{0}'.format(account.amount))
print('利率：{0}'.format(Account.interest_rate))
# 查看实例变量
print('account实例所有变量：{0}'.format(account.__dict__))

代码运行结果

account实例所有变量：{'owner': 'Tony', 'amount': 1800000.0}
账户名：Tony
账号金额：1800000.0
利率：0.068
account实例所有变量：{'owner': 'Tony', 'amount': 1800000.0, 'interest_rate': 0.01, 'interest_rate2': 0.01}

       注意：不要通过实例存取类变量数据。当通过实例读取变量时，Python解释器会先在实例中找这个变量，如果没有再到类中去找；当通过实例为变量赋值时，无论类中是否有该同名变量，Python解释器都会创建一个同名实例变量。 

构造方法

       __init_()方法是构造方法，用来创建和初始化实例变量，定义时它的第一个参数应该是self，其后的参数才是用来初始化实例变量的；其中参数可以有默认值。调用构造方法时不需要传入self。如果未定义构造方法，则会自动调用默认的构造方法；一旦定义了构造方法，则不会调用默认的构造方法。

输入下面代码

class Animal(object):
    # 构造方法
    def __init__(self,name='mark',age=20,weight=120,gender=120):
        self.name = name # 定义姓名实例变量
        self.age= age # 定义年龄实例变量
        self.weight = weight # 定义体重实例变量
        self.gender =gender   # 定义性别实例变量
animal0 = Animal() # 此时没有传入参数，参数为默认值
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)

print("姓名：{0}，年龄：{1}，体重：{2}".format(animal0.name,animal0.age,animal0.weight))
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal.name,animal.age,animal.weight))
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal1.name,animal1.age,animal1.weight))

代码运行结果

姓名：mark，年龄：20，体重：120
姓名：Tom，年龄：18，体重：66
姓名：Mary，年龄：18，体重：50

实例方法

       实例方法与实例变量一样都是某个实例个体特有的。定义实例方法时它的第一个参数应该是self，这个过程是将当前实例与该方法绑定起来，使该方法成为实例方法。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.weight = weight

    def eat(self):
        self.weight += 0.05
        print("eat...")

    def run(self):
        self.weight -= 0.01
        print("run...")
a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.eat()
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.run()
print('a1体重：{0:0.2f}'.format(a1.weight))

代码运行结果

a1体重：10.00
eat...
a1体重：10.05
run...
a1体重：10.04

类方法

       类方法不需要与实例绑定，但需要与类绑定，定义时它的第一个参数是类的type实例。type是描述Python数据类型的类，Python中所有数据类型都是type的一个实例。类方法可以访问类变量和其他类方法，但不能访问其他实例方法和实例变量。

       定义类方法：方法第一个参数cls是type类型的一个实例；方法使用装饰器@classmethod声明该方法是类方法。

示例代码如下

class Account:
    interest_rate = 0.0668 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount

    # 类方法
    @classmethod
    def interest_by(cls,amt):
        return cls.interest_rate * amt

interest = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest))

代码运行结果

计算利息：801.6000

静态方法

       如果定义的方法既不想与实例绑定，也不想与类绑定，只是想把类作为它的命名空间，那么可以定义静态方法。定义时使用@staticmethod装饰器，声明方法是静态方法，方法参数不指定self 和 cls。

示例代码如下

class Account:
    interest_rate = 0.0668 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount

    # 类方法
    @classmethod
    def interest_by(cls,amt):
        return cls.interest_rate * amt

    @staticmethod
    def interst_with(amt):
        return Account.interest_by(amt)
interest1 = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest1))
interest2 = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest2))

代码运行结果

计算利息：801.6000
计算利息：801.6000

封装性

私有变量

       默认情况下，Python中的变量是公有的，可以在类的外部访问他们。如果想让他们成为私有变量，可以在变量前加上双下划线“__”

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__wight = weight

    def eat(self):
        self.__wight += 0.05
        print("eat...")

    def run(self):
        self.__wight -= 0.01
        print("run...")

a1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.eat()
a1.run()

代码运行结果

       Python语言并不像Java，私有变量只是形式上私有，并非严格意义上的私有；如果想要访问私有变量，可以通过  _类名__变量名 来访问，但是一般不推荐这么做，因为这违反了封装的原则，使代码的维护变得困难。（可见Python的封装性靠的是程序员的自律，而非强制性的语法）

输入下面代码

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def run(self):
        self.__weight -= 0.01
        print("run...")

a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1._Animal__weight))
a1.eat()
a1.run()

代码运行结果

a1体重：10.00
eat...
run...

 推荐的做法是定义一个公共方法来访问

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1.run()
print('a1体重：{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
eat...
run...
a1体重：10.04

私有方法

       私有方法与私有变量是类似的，只要在方法前加上双下划线“__”就是私有方法，在类外面强制使用也是“_变量名__方法名”（不推荐）。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def __run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1._Animal__run() #强制访问,不推荐这样做
print('a1体重：{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
eat...
run...
a1体重：10.04

定义属性

       在实际的面向对象设计中，一个类是不应该有公有的实例成员变量的，这些实例成员变量被设计为私有的，然后通过共有的 setter 和 getter 访问器访问。（访问器形式的封装需要一个私有变量，需要提供 setter 和 getter 访问器，只读变量不用提供 setter 访问器）

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def __run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

    def set_weight(self,weight): # 添加一个set方法来访问
        self.__weight = weight

a1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.set_weight(20.00)
print('a1体重：{0}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
a1体重：20.0

       访问器形式的封装在编写代码时比较麻烦，Python提供了属性（poperty），定义属性可以使用@property 和 @属性名.setter装饰器。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量
    @property
    def weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

    @weight.setter
    def weight(self,weight): # 添加一个set方法来访问
        self.__weight = weight

a1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.weight = 20.0
print('a1体重：{0}'.format(a1.weight))

代码运行结果

a1体重：10.00
a1体重：20.0

 继承性

       多态性的前提是继承性，子类继承父类时只是继承父类中公有的成员变量和方法，不能继承私有的成员变量和方法。

示例代码如下

class Person:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

class Student(Person): # Student继承了Person类
    def __init__(self,name,age,school):
        super().__init__(name,age) 
# 定义子类的构造方法时先要调用父类的构造方法，初始化父类实例变量
        self.school = school

 重写方法

       如果子类方法名与父类方法名相同，而且参数列表也相同，只是方法体不同，那么子类重写了父类的构造方法；此时在用子类对象调用该方法时，会执行子类的该方法，而不是父类的。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.weight = weight #定义私有变量
    def eat(self):
        self.weight += 0.1
        print("动物吃...")


class Dog(Animal):
    def eat(self):
        self.weight += 0.1
        print("狗狗吃...")

a1 = Dog(2,0,10.0)
a1.eat()

代码运行结果

狗狗吃...

多继承

       多继承就是一个子类继承多个父类，在Java中只能单继承，因为多继承会发生方法冲突。Python支持多继承，当子类实例调用一个方法时，先从子类中查找，如果没有则查找父类，查找父类的顺序是按照子类声明的父类列表从左到右查找，若没有则查找父类的父类。

示例代码如下

class ParentClass1:
    def run(self):
        print('ParentClass1 run...')

class ParentClass2:
    def run(self):
        print('ParentClass2 run...')

class SubClass1(ParentClass1,ParentClass2):
    pass

class SubClass2(ParentClass2,ParentClass1):
    pass

class SubClass3(ParentClass1,ParentClass2):
    def run(self):
        print('SubClass3 run...')

sub1 = SubClass1()
sub1.run()
sub2 = SubClass2()
sub2.run()
sub3 = SubClass3()
sub3.run()

代码运行结果

ParentClass1 run...
ParentClass2 run...
SubClass3 run...

多态性

 发生多态有两个前提条件：

  1. 继承—多态发生一定是子类和父类之间
  2. 重写—子类重写了父类的方法

示例代码如下

class Figure:
    def draw(self):
        print("Figure draw...")

class Ellipse(Figure):
    def draw(self):
        print("Ellipse draw...")

class Triangle(Figure):
    def draw(self):
        print("Triangle draw...")

f2 = Ellipse()
f2.draw()
f3 = Triangle()
f3.draw()

代码运行结果 

Ellipse draw...
Triangle draw...

 类型检查

       与Java语言相比，多态性对于动态语言Python而言意义不大。但是无论多态性对Python的多大，Python作为面向对象的语言多态性是存在的。

函数描述
isinstance(object,classinfo)可以检查 object 实例是否由 classinfo 类或 infoclass 子类所创建的实例 
issubclass(class,classinfo)可以检查 class 是否是 classinfo 的子类

示例代码如下

class Figure:
    def draw(self):
        print("Figure draw...")

class Ellipse(Figure):
    def draw(self):
        print("Ellipse draw...")

class Triangle(Figure):
    def draw(self):
        print("Triangle draw...")
f1 = Figure()
f2 = Ellipse()
f3 = Triangle()
print(isinstance(f2,Figure)) # True
print(isinstance(f3,Figure)) # True
print(isinstance(f1,Figure)) # True
print(isinstance(f1,object)) # True,因为任何类都是 object 类的子类
print(issubclass(Figure,object)) # True
print(issubclass(Ellipse,Triangle))# False

代码运行结果

True
True
True
True
True
False

 鸭子类型

       不关注变量的类型，而是关注变量具有的方法。鸭子类型像多态一样工作，但是没有继承，只要像“鸭子”一样的行为（方法）就可以了。（用“鸭子类型”代替多态性设计能够充分发挥Python动态语言特点，但是对程序员要求也非常高）

示例代码如下

class Animal(object):
    def run(self):
        print("Animal run...")

class Dog(Animal):
    def run(self):
        print("Dog run...")

class Car:
    def run(self):
        print("Car run...")

def go(animal):
    if not isinstance(animal, (Animal, Car)):  # 检查 animal 是否为 Animal 或 Car 的实例
        return  # 如果不是，则作为递归的基案结束递归
    animal.run()  # 调用 run 方法

# 创建实例
animal_instance = Animal()
dog_instance = Dog()
car_instance = Car()

# 使用实例调用 go 函数
go(animal_instance)
go(dog_instance)
go(car_instance)
#添加了一个类型检查来确保只有 Animal 或 Car 的实例才会调用 run 方法。如果传入的不是这些类的实例，#go 函数将直接返回，避免递归调用。

代码运行结果

Animal run...
Dog run...
Car run...

 Python根类—object

Python所有类都直接或间接的继承 object 类，object类有很多方法。

方法描述
__str__()默认返回对象的类名，以及内存地址等信息；可以重写该方法，输出描述信息
__eq__()重写该方法指定相等的规则（即指定比较的是哪些实例变量相等）

 示例代码1如下

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self): # 重写str方法，返回什么样的字符串可以自己指定
        template = 'Person[name={0},age={1}]'
        s = template.format(self.name,self.age)
        return s
Person = Person('Tony',18)
print(Person)

代码运行结果

Person[name=Tony,age=18]

示例代码2如下

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self): # 重写str方法，返回什么样的字符串可以自己指定
        template = 'Person[name={0},age={1}]'
        s = template.format(self.name,self.age)
        return s

    def __eq__(self,other): # 重写eq方法，指定只有姓名和年龄都相等时才是True
        if self.name == other.name and self.age == other.age:
            return True
        else:
            return False

p1 = Person('Tony',18)
p2 = Person('Tony',18)
p3 = Person('Mary',18)
print(p1 == p2)
print(p1 == p3)

代码运行结果

True
False

参考书籍《Python从小白到大牛》（第2版）关东升 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Spring自定义标签体系和应用

Spring自定义标签体系和应用

我们知道&#xff0c;在使用Dubbo框架时&#xff0c;需要指定配置文件中的application、protocol、registry、provider、service等服务器端和客户端的配置项&#xff0c;典型的配置方法如下所示。通过这些配置项&#xff0c;我们可以基于Spring容器来启动Dubbo服务。 <!-- …
阅读更多...
Docker Desktop进入界面时一直转圈的解决办法记录

Docker Desktop进入界面时一直转圈的解决办法记录

我的win10版本如下&#xff0c;是支持安装的&#xff0c;不支持安装的&#xff0c;可以先升级系统版本&#xff1a; 起初是因为运行Docker Desktop时一直转圈&#xff0c;无法进入主面板&#xff0c;百度之&#xff0c;需要安装hype-v环境&#xff0c;找到以下 勾选Hyper-V下的…
阅读更多...
怎么学习PMP才是最正确的？

怎么学习PMP才是最正确的？

每个人的学习方式各不相同&#xff0c;不能一概而论说某种学习方式就是错误的。学习方式并没有绝对的对错之分&#xff0c;只能说是否适合自己&#xff0c;是否能够达到预期的学习效果。并不是别人的学习方式就一定适合自己&#xff0c;也不是不适合自己的学习方式就一定是错误…
阅读更多...
嵌入式系统基础

嵌入式系统基础

嵌入式系统基础主要包括以下几个方面&#xff1a; 1、定义&#xff1a; 嵌入式系统是以应用为中心&#xff0c;以计算机技术为基础&#xff0c;软硬件可裁剪&#xff0c;适应应用系统对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。它由硬件和软件组成&#xff0…
阅读更多...
YOLOv8模型代码学习

YOLOv8模型代码学习

1.参考文献 链接1 2.网络模型解析 2.1卷积神经单元&#xff08;conv.py&#xff09; 在该文件中定义了yolov8网络中的卷积神经单元&#xff0c;位置如图所示。 def autopad(k, pNone, d1): # kernel(卷积核), padding(填充), dilation(扩张)"""Pad to same…
阅读更多...
数据中心技术：大数据时代的机遇与挑战

数据中心技术：大数据时代的机遇与挑战

在大数据时代&#xff0c;数据中心网络对于存储和处理大量信息至关重要。随着云计算的出现&#xff0c;数据中心已成为现代技术的支柱&#xff0c;支持社交媒体、金融服务等众多行业。然而&#xff0c;生成和处理的大量数据带来了一些挑战&#xff0c;需要创新的解决方案。在这…
阅读更多...
不同版本的 Rocky Linux 快速更换阿里镜像源

不同版本的 Rocky Linux 快速更换阿里镜像源

环境&#xff1a;兼容 Rocky Linux 任意版本。 搞服务器系统从 CentOS 折腾到 Rocky Linux&#xff0c;然后又折腾到 Alma Linux&#xff1b;最近因为 RKE2 没有做 Alma Linux 的兼容性&#xff0c;又折腾到了 Rocky Linux &#xff0c;真的是一把鼻涕一把泪呀。但是实在是不理…
阅读更多...
深入理解和实现Windows进程间通信（共享内存）

深入理解和实现Windows进程间通信（共享内存）

常见的进程间通信方法 常见的进程间通信方法有&#xff1a; 管道&#xff08;Pipe&#xff09;消息队列共享内存信号量套接字 下面&#xff0c;我们将详细介绍共享内存的原理以及具体实现。 什么是共享内存&#xff1f; Windows共享内存&#xff08;Shared Memory in Windo…
阅读更多...
【linux】内核源码TCP-＞IP-＞L2层函数调用继续摸索中

【linux】内核源码TCP-＞IP-＞L2层函数调用继续摸索中

日志打印的时候&#xff0c;把行数也打印了&#xff1a; 登录 - Gitee.comhttps://gitee.com/r77683962/linux-6.9.0/commit/b847489a9910f68b9581fd8788807c697c82cdbd 上回基于应用层wget操作找到TCP调用的一些接口&#xff0c;并且已经到IP层的一些接口&#xff0c;当前基…
阅读更多...
Windows系统Maven下载安装

Windows系统Maven下载安装

下载&#xff1a; 官网地址&#xff1a;https://maven.apache.org/download.cgi 安装&#xff1a; 下载下来的是一个压缩包&#xff0c;首先将其解压到你的Maven目标安装位置 接下来为其配置其环境变量 &#xff08;Maven的基础是Java&#xff0c;因此要首先确认已为你的电…
阅读更多...
求求你别学了：从 Prompt 到 RAG，从 RAG 到 DSPy

求求你别学了：从 Prompt 到 RAG，从 RAG 到 DSPy

如本瓜在此前的文章中提到过&#xff0c;Prompt 工程已经不中用了&#xff0c;没有人愿意废那么大的劲来学习如何结构化提问&#xff0c;大家想要的就是傻瓜式提问&#xff0c;但是大模型的回答还是精准的、合意的&#xff1b; 后来&#xff0c;大兴 RAG 技术&#xff0c;做专…
阅读更多...
Nuxt快速学习开发 - Nuxt3静态资源Assets

Nuxt快速学习开发 - Nuxt3静态资源Assets

Nuxt 使用两个目录来处理样式表、字体或图像等资产。 public/目录内容按原样在服务器根目录中提供。 assets/目录包含您希望构建工具&#xff08;Vite 或 webpack&#xff09;处理的所有资产。 public/目录 public目录用作静态资产的公共服务器&#xff0c;可在您的应用程序定…
阅读更多...
景联文科技构建高质量多轮对话数据库，赋能AI交互新飞跃

景联文科技构建高质量多轮对话数据库，赋能AI交互新飞跃

近年来&#xff0c;大语言模型的发展极大推动了自然语言处理领域的进步&#xff0c;大语言模型正引领智能对话领域进入一个全新时代&#xff0c;不仅提升了对话体验的自然度和效率&#xff0c;也为探索更加人性化、智能化的交互方式开辟了道路。 景联文科技作为大语言模型数据服…
阅读更多...
文心一言 VS 讯飞星火 VS chatgpt （285）-- 算法导论21.2 4题

文心一言 VS 讯飞星火 VS chatgpt （285）-- 算法导论21.2 4题

四、请给出图 21-3 所示操作序列的一个运行时间的渐近紧确界&#xff0c;假定使用链表表示和加权合并启发式策略。如果要写代码&#xff0c;请用go语言。 文心一言&#xff1a; 图 21-3 没有直接给出&#xff0c;但通常这种操作序列可能与某种数据结构&#xff08;如并查集或…
阅读更多...
算法：分治(归并)题目练习

算法：分治(归并)题目练习

目录 题目一&#xff1a;排序数组 题目二&#xff1a;数组中的逆序对 题目三&#xff1a;计算右侧小于当前元素的个数 题目四&#xff1a;翻转对 题目一&#xff1a;排序数组 给你一个整数数组 nums&#xff0c;请你将该数组升序排列。 示例 1&#xff1a; 输入&#xf…
阅读更多...
收银系统源码推荐收银系统二次开发

收银系统源码推荐收银系统二次开发

千呼新零售收银系统是一套线下线上一体化的收银系统&#xff0c;给商户提供了含有线下收银/称重、线上小程序商城、精细化会员管理、ERP进销存、营销活动、移动店务管理等一体化解决方案&#xff01; 1. 多样化线下收银 线下收银支持Windows收银、安卓收银、智能称重收银、无人…
阅读更多...
BFS:FloodFill算法

BFS:FloodFill算法

文章目录 FloodFill算法简介1.图像渲染2.岛屿数量3.岛屿的最大面积4.被围绕的区域总结 FloodFill算法简介 Flood Fill算法是一种用于确定与某个给定节点相连的区域的算法&#xff0c;常用于计算机图形学和图像处理。该算法可以用于诸如填充多边形、检测连通区域等任务。Flood …
阅读更多...
Linux 一键部署 Nginx1.26.1 + ModSecurity3

Linux 一键部署 Nginx1.26.1 + ModSecurity3

前言 ModSecurity 是 Apache 基金会的一个开源、高性能的 Web 应用程序防火墙（WAF），它提供了强大的安全规则引擎，用于检测和阻止各种攻击行为，如 SQL 注入、XSS 跨站点脚本攻击等。而 nginx 是一个高性能的 Web 服务器，常用于处理大量的并发请求，具有很高的负载均衡能力…
阅读更多...
蓝牙数传芯片TD5325A，蓝牙5.1—拓达半导体

蓝牙数传芯片TD5325A，蓝牙5.1—拓达半导体

拓达TD5325A芯片是一款支持蓝牙BLE&SPP的纯数传芯片&#xff0c;蓝牙5.1版本。芯片的亮点在于性能强&#xff0c;支持APP端直接对芯片做设置与查询操作&#xff0c;包括修改蓝牙名、UUID、MAC地址&#xff0c;以及直接操作蓝牙芯片自身的IO与PWM口&#xff0c;还包括支持简…
阅读更多...
Linux:用户账号和权限管理的命令

Linux:用户账号和权限管理的命令

目录 一、Linux用户的分类和组的分类 1.1、用户账号和组账号 1.2、用户的分类 1.3、组账号 1.4、用户账号文件/etc/passwd 二、用户管理相关命令 2.1、chage命令&#xff1a;用来修改帐号和密码的有效期限&#xff0c;针对目前系统已经存在的用户 2.2、useradd&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站