Python基础知识总结3-面向对象进阶知识

面向对象三大特征介绍

  • 继承
    • 子类扩展父类
    • 语法格式
    • 关于构造函数:
    • 类成员的继承和重写
    • 查看类的继承层次结构
  • object根类
    • dir() 查看对象属性
    • 重写 __str__() 方法
  • 多重继承
  • MRO方法解析顺序
  • super()获得父类定义
  • 多态
  • 特殊方法和运算符重载
    • 特殊属性
  • 对象的浅拷贝和深拷贝
  • 组合
  • _ _init_ _ 构造方法和 _ _new_ _ 方法
  • 实例属性和实例方法
    • 实例属性
    • 实例方法
    • 函数和方法的区别
    • 实例对象的方法调用本质
    • 其他操作
  • 类对象、类属性、类方法、静态方法
    • 类对象
    • 类属性
  • __del__方法 (析构函数)和垃圾回收机制
  • __call__ 方法和可调用对象
  • 方法没有重载
  • 方法的动态性
  • 私有属性和私有方法(实现封装)
  • @property 装饰器
  • 属性和方法命名总结

在这里插入图片描述
Python是面向对象的语言,支持面向对象编程的三大特性:继承、
封装(隐藏)、多态。

封装(隐藏)

隐藏对象的属性和实现细节,只对外提供必要的方法。相当于 将“细节封装起来”,只对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式,实现“封装”。 Python追求简洁的语法,没有严格的语法级别的“访问控制
符”,更多的是依靠程序员自觉实现。

继承

继承可以让子类具有父类的特性,提高了代码的重用性。 从设计上是一种增量进化,原有父类设计不变的情况下,可以 增加新的功能,或者改进已有的算法。

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生 活中这样的例子比比皆是:同样是休息方法,人不同休息方法
不同。张三休息是睡觉,李四休息是玩游戏,程序员休息是“敲 几行代码”。

继承

在这里插入图片描述

子类扩展父类

继承是面向对象编程的三大特征之一。继承让我们更加容易实现类
的扩展。实现代码的重用,不用再重新发明轮子(don’t reinvent
wheels)。
如果一个新类继承自一个设计好的类,就直接具备了已有类的特
征,就大大降低了工作难度。已有的类,我们称为“父类或者基
类”,新的类,我们称为“子类或者派生类”。

在这里插入图片描述

语法格式

Python支持多重继承,一个子类可以继承多个父类。继承的语法格
式如下:

class  子类类名(父类1[,父类2...]):类体

如果在类定义中没有指定父类,则默认父类是 object类 。也就是 说, object 是所有类的父类,里面定义了一些所有类共有的默认
实现,比如: new()

关于构造函数:

1 子类不重写 init ,实例化子类时,会自动调用父类定义的 init
2 子类重写了 init 时,实例化子类,就不会调用父类已经定义的 init
3 如果重写了 init 时,要使用父类的构造方法,可以使用 super 关键字,也可以使用如下格式调用:
父类名.init(self, 参数列表)

class Person:def __init__(self,name,age):print("Person的构造方法")self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是:",self.age)class Student(Person):def __init__(self,name,age,score):# 子类并不会自动调用父类的__init__(),我们必须显式的调用它。# Person.__init__(self, name, age)#super(Student,self).__init__(name,age)print("Student的构造方法")# self.name = name# self.age = ageself.score = score# 调用
s1 = Student("张三",15,85)
#s1.say_age()
print(dir(s1))

类成员的继承和重写

1 成员继承:子类继承了父类除构造方法之外的所有成员。
⚠️(私有属性、私有方法也被继承)
2 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类
的方法,也称为“重写”

class Person:def __init__(self,name,age):self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是:",self.age)def say_name(self):print("我是",self.name)class Student(Person):def __init__(self,name,age,score):Person.__init__(self,name,age)  self.score = scoredef say_score(self):print(self.name,"的分数是:",self.score)def say_name(self):      #重写父类的方法print("报告老师,我是",self.name)s1 = Student("张三",15,85)s1.say_score()s1.say_name()s1.say_age()

张三 的分数是: 85
报告老师,我是 张三
张三 的年龄是: 15

查看类的继承层次结构

通过类的方法 mro() 或者类的属性 _ _mro_ _ 可以输出这个类的继承层次
结构。

class A:pass
class B(A):pass
class C(B):pass
print(C.mro())

[<class ‘main.C’>, <class ‘main.B’>,
<class ‘main.A’>, <class ‘object’>]
在这里插入图片描述

object根类

object 类是所有类的父类,因此所有的类都有 object 类的属性和方法。

dir() 查看对象属性

class Person:def __init__(self,name,age):self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是:",self.age)
obj = object()
print(dir(obj))
s2 = Person("高淇",18)
print(dir(s2))

[‘class’, ‘delattr’, ‘dir’,
doc’, ‘eq’, ‘format’, ‘ge’,
getattribute’, ‘gt’, ‘hash’,
init’, ‘init_subclass’, ‘le’,
lt’, ‘ne’, ‘new’, ‘reduce’,
reduce_ex’, ‘repr’, ‘setattr’,
sizeof’, ‘str’, ‘subclasshook’]
[‘class’, ‘delattr’, ‘dict’,
dir’, ‘doc’, ‘eq’, ‘format’,
ge’, ‘getattribute’, ‘gt’,
hash’, ‘init’, ‘init_subclass’,
le’, ‘lt’, ‘module’, ‘ne’,
new’, ‘reduce’, ‘reduce_ex’,
repr’, ‘setattr’, ‘sizeof’,
str’, ‘subclasshook’, ‘weakref’,
‘age’, ‘name’, ‘say_age’]

从上面我们可以发现这样几个要点:
1 Person 对象增加了六个属性:
__dict_ _\ __module__ __eakref__ age name say_age
2 object 的所有属性, Person 类作为 object 的子类,显然包含了所有的
属性
3 我们打印 age 、 name 、 say_age ,发现 say_age 虽然是方法,实际上也
是属性。只不过,这个属性的类型是 method 而已。

重写 str() 方法

object 有一个 _ _str_\ _() 方法,用于返回一个对于“对象的描述”。内置函数 str(对象) ,调用的就是
_ _str_\ _()

_ _str_\ _() 经常用于 print() 方法,帮助我们查看对象的信息。_ _str_\ _() 可以重写

多重继承

在这里插入图片描述
Python支持多重继承,一个子类可以有多个“直接父类”。这样,就
具备了“多个父类”的特点。但是由于,这样会被“类的整体层次”搞的
异常复杂,尽量避免使用。

1 class A:
2    def aa(self):
3        print("aa")
4
5 class B:
6    def bb(self):
7        print("bb")
8
9 class C(B,A):
10    def cc(self):
11        print("cc")
12
13 c = C()
14 c.cc()
15 c.bb()
16 c.aa()

在这里插入图片描述

MRO方法解析顺序

Python支持多继承,如果父类中有相同名字的方法,在子类没有指 定父类名时,解释器将“从左向右”按顺序搜索。

MRO(Method Resolution Order):方法解析顺序。 我们可以通 过 mro()
方法获得“类的层次结构”,方法解析顺序也是按照这个“类的 层次结构”寻找的。

class A:def aa(self):print("aa")def say(self):print("say AAA!")
class B:def bb(self):print("bb")def say(self):print("say BBB!")
class C(B,A):def cc(self):print("cc")c = C()
print(C.mro())          #打印类的层次结构
c.say()      #解释器寻找方法是“从左到右”的方式寻找,此时会执行B类中的say()

执行结果:

[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class
‘object’>] say BBB!

super()获得父类定义

在子类中,如果想要获得父类的方法时,我们可以通过 super() 来做。
super() 代表父类的定义,不是父类对象。

❤️想调用父类的构造方法:
super(子类名称,self).init(参数列表)

class A:def __init__(self):print("A的构造方法")def say(self):print("A: ",self)print("say AAA")class B(A):def __init__(self):super(B,self).__init__() #调用父类的构造方法# super().__init__(self) print("B的构造方法")def say(self):#A.say(self)   调用父类的say方法super().say()   #通过super()调用父类的方法print("say BBB")b = B()b.say()

1 A: <main.B object at 0x007A5690>
2 say AAA
3 say BBB

多态

在这里插入图片描述

多态(polymorphism)是指同一个方法调用由于对象不同可能会
产生不同的行为。

关于多态要注意以下2点:
1 多态是方法的多态,属性没有多态。
2 多态的存在有2个必要条件:继承、方法重写

#多态
class Animal:def shout(self):print("动物叫了一声")class Dog(Animal):def shout(self):print("小狗,汪汪汪")class Cat(Animal):def shout(self):print("小猫,喵喵喵")def animalShout(a):a.shout()   #传入的对象不同,shout方法对应的实际行为也不同。animalShout(Dog())animalShout(Cat())

特殊方法和运算符重载

Python的运算符实际上是通过调用对象的特殊方法实现的。

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

c= 50
d= 50

常见的特殊方法
在这里插入图片描述
在这里插入图片描述
我们可以重写上面的特殊方法,即实现了“运算符的重载”。

#测试运算符的重载
class Person:def __init__(self,name):self.name = namedef __add__(self, other):if isinstance(other,Person):return "{0}--{1}".format(self.name,other.name)else:return "不是同类对象,不能相加"
def __mul__(self, other):if isinstance(other,int):return  self.name*otherelse:return "不是同类对象,不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)

特殊属性

Python对象中包含了很多双下划线开始和结束的属性,这些是特殊
属性,有特殊用法。这里我们列出常见的特殊属性:
在这里插入图片描述

#测试特殊属性
class A:pass
class B:pass
class C(B,A):def __init__(self,nn):self.nn = nndef cc(self):print("cc")
c = C(3)
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())

1 [‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’,
eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’,
hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’,
module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’,
repr’, ‘setattr’, ‘sizeof’, ‘str’,
subclasshook’, ‘weakref’, ‘cc’, ‘nn’]
2 {‘nn’: 3}
3 <class’main.C’>
4 (<class ‘main.B’>, <class ‘main.A’>)
5 [<class’main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class
‘object’>]
6 [<class ‘main.C’>]

对象的浅拷贝和深拷贝

在这里插入图片描述

  • 浅拷贝

Python拷贝一般都是浅拷贝。
浅拷贝:拷贝时,拷贝源对象,但对象包含的子对象内容不拷
贝。

  • 深拷贝

使用 copy 模块的 deepcopy 函数,递归拷贝对象中包含的子对象。
深拷贝:拷贝时,拷贝源对象,也递归拷贝对象中包含的子对象。

#测试对象的引用赋值、浅拷贝、深拷贝
import copy
class MobilePhone:def __init__(self,cpu):self.cpu = cpu
class CPU:pass
c = CPU()
m = MobilePhone(c)print("----浅拷贝-------")
m2 = copy.copy(m)   #m2是新拷贝的另一个手机对象
print("m:",id(m))
print("m2:",id(m2))
print("m的cpu:",id(m.cpu))
print("m2的cpu:",id(m2.cpu))   #m2和m拥有了一样的cpu对象
print("----深拷贝--------")
m3 = copy.deepcopy(m)
print("m:",id(m))
print("m3:",id(m3))
print("m的cpu:",id(m.cpu))
print("m3的cpu:",id(m3.cpu))   #m3和m拥有不一样的cpu对象

----浅拷贝-------
m: 1879267229360
m2: 1879267228592
m的cpu: 1879267229648
m2的cpu: 1879267229648
----深拷贝--------
m: 1879267229360
m3: 1879267222256
m的cpu: 1879267229648
m3的cpu: 1879267221968

组合

在这里插入图片描述
两人组合后,可以复用对方的属性和方法!

#组合测试
class MobilePhone:def __init__(self,cpu,screen):self.cpu = cpuself.screen = screen
class CPU:def calculate(self):print("计算,算个12345")
class Screen:def show(self):print("显示一个好看的画面")c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()       #通过组合,我们也能调用cpu对象的方法。相当于手机对象间接拥有了“cpu的方法”

_ init _ 构造方法和 _ new _ 方法

初始化对象,我们需要定 义构造函数 init() 方法。构造方法用于执
行“实例对象的初始化工作”,即对象创建后,初始化当前对象的相
关属性,无返回值。

__init__ 的要点如下:
名称固定,必须为: __init__
第一个参数固定,必须为: self 。 self 指的就是刚刚创建好的实
例对象
构造函数通常用来初始化实例对象的实例属性,如下代码就是初
始化实例属性: name 和 score
通过“类名(参数列表)”来调用构造函数。调用后,将创建好的对
象返回给相应的变量。 比如: s1 = Student(‘张三’, 80)

__init__ 方法:初始化创建好的对象,初始化指的是:“给实例属
性赋值”

__new__ 方法: 用于创建对象,但我们一般无需重定义该方法
如果我们不定义 init 方法,系统会提供一个默认的 init 方法。
如果我们定义了带参的 init 方法,系统不创建默认的 init 方法

实例属性和实例方法

实例属性

实例属性是从属于实例对象的属性,也称为“实例变量”。他的使用
有如下几个要点:

1 实例属性一般在 init() 方法中通过如下代码定义: self.实例属性名 = 初始值

2 在本类的其他实例方法中,也是通过 self 进行访问: self.实例属性名

3 创建实例对象后,通过实例对象访问: obj01 = 类名() #创建和初始化对象,调用 init() 初始化属性
obj01.实例属性名 = 值 #可以给已有属性赋值,也可以新加属性

class Student:def __init__(self,name,score):self.name = name #增加name属性self.score = score #增加score属性def say_score(self):self.age = 18     #增加age属性print("{0}的分数是{1}".format(self.name,self.score))s1 = Student("张三",80)
s1.say_score()
print(s1.age)
s1.salary = 3000 #s1对象增加salary属性
s2 = Student("李四",90)
s2.say_score()
print(s2.age)

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下:

def  方法名(self [, 形参列表]):函数体

方法的调用格式如下:
对象.方法名([实参列表])

要点:
1 定义实例方法时,第一个参数必须为 self 。和前面一样, self 指当前的实例对象。
2 调用实例方法时,不需要也不能给self 传参。 self 由解释器自动传参

函数和方法的区别

1 都是用来完成一个功能的语句块,本质一样。
2 方法调用时,通过对象来调用。方法从属于特定实例对象,普通函数没有这个特点
3 直观上看,方法定义时需要传递self,函数不需要

实例对象的方法调用本质

在这里插入图片描述

其他操作

dir(obj) 可以获得对象的所有属性、方法
obj._ _dict_ _ 对象的属性字典
pass 空语句
isinstance(对象,类型) 判断“对象”是不是“指定类型”

类对象、类属性、类方法、静态方法

类对象

我们在前面讲的类定义格式中, class 类名: 。实际上,当解释器执行
class 语句时,就会创建一个类对象。

类属性

类属性是从属于“类对象”的属性,也称为“类变量”。由于,类属性从
属于类对象,可以被所有实例对象共享。
类属性的定义方式:

class  类名:类变量名= 初始值

__del__方法 (析构函数)和垃圾回收机制

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

1 #析构函数
2 class Person:
3
4    def __del__(self):
5        print("销毁对象:{0}".format(self))
6
7 p1 = Person()
8 p2 = Person()
9 del p2
10 print("程序结束")

call 方法和可调用对象

1 Python 中,凡是可以将 () 直接应用到自身并执行,都称为可调
用对象。
2 可调用对象包括自定义的函数、Python 内置函数、以及本节所
讲的实例对象。
3 定义了 call() 的对象,称为“可调用对象”,即该对象可以像函数
一样被调用。
4 该方法使得实例对象可以像调用普通函数那样,以“对象名()”的
形式使用。

1 def f1():
2    print("f1")
3
4 f1()   #本质也是调用了__call__()方法
5
6 class Car:
7    def __call__(self, age,money):
8        print("__call__方法")
9        print("车龄:{0},金额:{1}".format(age,money))
10
11 f2 = Car()
12 f2(3,200000)    #像调用函数那样调用,本质也是调用了__call__()

f1
车龄:3,金额:200000

方法没有重载

如果我们在类体中定义了多个重名的方法,只有最后一个方法有效。
建议:不要使用重名的方法!Python中方法没有重载。

在其他一些语言(比如:Java)中,可以定义多个重名的方法,只要保证方法签名唯一即可。方
法签名包含3个部分:方法名、参数数量、参数类型。
Python中,方法的的参数没有声明类型(调用时确定参数的类型),参数的数量也可以由可
变参数控制。因此,Python中是没有方法的重载的。

方法的动态性

在这里插入图片描述

Python是动态语言,我们可以动态的为类添加新的方法,或者动态
的修改类的已有的方法

#测试方法的动态性
#测试方法的动态性
class Person:def work(self):print("努力上班!")
def play_game(self):print("玩游戏")
def work2(s):print("好好工作,努力上班!")
Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

我们可以看到, Person 动态的新增了 play_game 方法,以及用 work2 替换
了 work 方法

私有属性和私有方法(实现封装)

在这里插入图片描述
Python对于类的成员没有严格的访问控制限制,这与其他面向对象
语言有区别。关于私有属性和私有方法,有如下要点:
1 通常我们约定,两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2 类内部可以访问私有属性(方法)
3 类外部不能直接访问私有属性(方法)
4 类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。
@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个
属性,我们可以直接通过:
emp1.salary = 30000
如上的操作读操作、写操作。但是,这种做法不安全。比如,我需
要限制薪水必须为 1-10000 的数字。这时候,我们就需要通过使用装
饰器 @property 来处理。

@property
def 方法名(self)代码块
class Rect:def __init__(self,area):self.__area = area@propertydef area(self):return self.__area
rect = Rect(30)
#直接通过方法名来访问 area 方法
print("矩形的面积是:",rect.area)

而要想实现修改 area 属性的值,还需要为 area 属性添加 setter 方法,就需要用到 setter 装饰器,它的语法格式如下:

@方法名.setter
def 方法名(self, value):代码块
#测试@property
class Employee:def __init__(self,name,salary):self.name = nameself.__salary = salary@property               #相当于salary属性的getter方法def salary(self):print("月薪为{0},年薪为{1}".format(self.__salary,*self.__salary)))return self.__salary;@salary.setterdef salary(self,salary):    #相当于salary属性的setter方法if(0<salary<1000000):self.__salary = salaryelse:print("薪水录入错误!只能在0-1000000之间")emp1 = Employee("高淇",100)print(emp1.salary)emp1.salary = -200

这样,area 属性就有了 getter 和 setter 方法,该属性就变成了具有读写功能的属性。

除此之外,还可以使用 deleter 装饰器来删除指定属性,其语法格式为:

@方法名.deleter
def 方法名(self):代码块
@area.deleter
def area(self):self.__area = 0
del rect.area
print("删除后的area值为:",rect.area)

属性和方法命名总结

_xxx :保护成员,不能用 from module import * 导入,只有类对象和子类对象能访问这些成员。

_ _xxx_ _ :系统定义的特殊成员
_ _xxx : 类中的私有成员,只有类对象自己能访问,子类对象也不能访问。(但,在类外部可以通
过 对象名. _类名__xxx 这种特殊方式访问。Python不存在严格意义的私有成员)

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

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

相关文章

专为Mac用户设计的思维导图软件MindNode 2023 for Mac助您激发创意!

在现代快节奏的生活中&#xff0c;我们经常需要整理思绪、规划项目、记录灵感。而思维导图作为一种高效的思维工具&#xff0c;能够帮助我们更好地整理和展现思维。现在&#xff0c;我们介绍一款强大而直观的思维导图软件——MindNode 2023 for Mac&#xff0c;助您拓展思维边界…

SpingBoot的项目实战--模拟电商【5.沙箱支付】

&#x1f973;&#x1f973;Welcome Huihuis Code World ! !&#x1f973;&#x1f973; 接下来看看由辉辉所写的关于SpringBoot电商项目的相关操作吧 目录 &#x1f973;&#x1f973;Welcome Huihuis Code World ! !&#x1f973;&#x1f973; 一. 沙箱支付是什么 二.Sp…

ONLY在线商城系统设计与实现

&#x1f345;点赞收藏关注 → 私信领取本源代码、数据库&#x1f345; 本人在Java毕业设计领域有多年的经验&#xff0c;陆续会更新更多优质的Java实战项目希望你能有所收获&#xff0c;少走一些弯路。&#x1f345;关注我不迷路&#x1f345;一 、设计说明 1.1 研究背景 当…

普中STM32-PZ6806L开发板(HAL库函数实现-访问多个温度传感器DS18B20)

简介 我们知道多个DS18B20的DQ线是可以被挂在一起的, 也就是一根线上可以访问不同的DS18B20而不会造成数据错乱, 怎么做到的&#xff0c;其实数据手册都有说到&#xff0c; 就是靠64-bit ROM code 进行识别, 也可以理解成Serial Number进行识别, 因为主要差异还是在Serial Numb…

实战Flink Java api消费kafka实时数据落盘HDFS

文章目录 1 需求分析2 实验过程2.1 启动服务程序2.2 启动kafka生产 3 Java API 开发3.1 依赖3.2 代码部分 4 实验验证STEP1STEP2STEP3 5 时间窗口 1 需求分析 在Java api中&#xff0c;使用flink本地模式&#xff0c;消费kafka主题&#xff0c;并直接将数据存入hdfs中。 flin…

【C++】类和对象详解(类的使用,this指针)

文章目录 前言面向过程和面向对象的初步认识类的引入类的定义类的访问限定符和封装性访问限定符封装性 类的作用域类的实例化类对象模型如何计算类对象的大小类对象的存储方式猜测结构体内存对齐规则 this指针this指针的引出this指针的特性 总结 前言 提示&#xff1a;这里可以…

linux反汇编工具: ida pro、rizinorg/cutter; ubuntu 22 flameshot延迟截图 以应对下拉菜单

rizinorg/cutter rizinorg/cutter 是 命令行反汇编工具 rizinorg/rizin 的图形化界面, 这比 ida pro跑在kvm虚拟机中方便多了, ubuntu22.04下直接下载Cutter-v2.3.2-Linux-x86_64.AppImage后即可运行,如下图: 注意 有个同名的报废品: radare2/Cutter 即 radare2的图形化界…

基于日照时数计算逐日太阳辐射

基于日照时数计算逐日太阳辐射

彻底认识Unity ui设计中Space - Overlay、Screen Space - Camera和World Space三种模式

文章目录 简述Screen Space - Overlay优点缺点 Screen Space - Camera优点缺点 World Space优点缺点 简述 用Unity中开发了很久&#xff0c;但是对unity UI管理中Canvas组件的Render Mode有三种主要类型&#xff1a;Screen Space - Overlay、Screen Space - Camera和World Spa…

【elfboard linux开发板】7.i2C工具应用与aht20温湿度寄存器读取

1. I2C工具查看aht20的温湿度寄存器值 1.1 原理图 传感器通过IIC方式进行通信&#xff0c;连接的为IIC1总线&#xff0c;且设备地址为0x38&#xff0c;实际上通过后续iic工具查询&#xff0c;这个设备是挂载在iic-0上 1.2 I2C工具 通过i2c工具可以实现查询i2c总线、以及上面…

普中STM32-PZ6806L 使用FlyMcu串口烧录程序

简介 我的串口下载电路坏掉了, 所以研究了下如何通过USB转TTL进行程序的下载, 为后续Bootloader部分做准备;连接 我的板几乎是十年前买的&#xff0c; 所以电路与现有网上的资料有些差异, 所以仅供参考 USB 转 TTL线 与开发板 连接&#xff0c; 如图图中 ①, 需要去掉第一个…

计算机组成原理 指令流水线

文章目录 指令流水线指令流水线的概念流水线性能分析流水线的吞吐率流水线的加速比流水线的效率 影响流水线的因素结构相关 (资源冲突)数据相关 (数据冲突)控制相关 (控制冲突) 流水线分类超量流水线 指令流水线 #mermaid-svg-VKNFSIxU0RiY8pAm {font-family:"trebuchet m…

XAgent调研

文章目录 1 简介2 快速测试 Quick Start3 结构分析 1 简介 XAgent&#xff08;链接&#xff09;是一个开源的&#xff0c;基于大语言模型的agent构建框架&#xff1b;其目标是构建出能够辅助人类处理各类任务的自动助手 定位&#xff1a;一个全能的&#xff0c;自动的辅助agen…

LeetCode-移动零(283)

题目描述&#xff1a; 给定一个数组 nums&#xff0c;编写一个函数将所有 0 移动到数组的末尾&#xff0c;同时保持非零元素的相对顺序。 请注意 &#xff0c;必须在不复制数组的情况下原地对数组进行操作。 思路&#xff1a; 这里的思路跟以前做过的去重复数字的思路有点像&…

Java学习——设计模式——结构型模式2

文章目录 结构型模式装饰者模式桥接模式外观模式组合模式享元模式 结构型模式 结构型模式主要涉及如何组合各种对象以便获得更好、更灵活的结构。虽然面向对象的继承机制提供了最基本的子类扩展父类的功能&#xff0c;但结构型模式不仅仅简单地使用继承&#xff0c;而更多地通过…

IDEA 每次新建工程都要重新配置 Maven的解决方案

文章目录 IDEA 每次新建工程都要重新配置 Maven 解决方案一、选择 File -> New Projects Setup -> Settingsfor New Projects…二、选择 Build,Execution,Deployment -> Build Tools -> Maven IDEA 每次新建工程都要重新配置 Maven 解决方案 DEA 每次新建工程都要…

CSS基础笔记-04cascade-specificity-inheritance

CSS基础笔记系列 《CSS基础笔记-01CSS概述》《CSS基础笔记-02动画》CSS基础笔记-03选择器 前言 Cascading Style Sheets&#xff0c;关键就在于这个cascading&#xff0c;对于这个术语理解&#xff0c;感觉对于我这种CSS新手有点儿不太friendly。本文记录下我对这个术语的理…

Lumerical------关闭 drawing grid 去更好地显示 mesh grid

Lumerical------关闭 drawing grid 去更好地显示 mesh grid 引言正文 引言 在 Lumerical 结构设置的时候&#xff0c;有时候我们想要查看 mesh 结构的 grid&#xff0c;但是本身默认的 dtawing grid 黑框会阻碍我们的观察&#xff0c;这时&#xff0c;我们便可以通过设置关闭这…

K8S陈述式资源管理

陈述式 命令行&#xff1a;kubectl命令行工具 优点&#xff1a;90%以上的场景都可以满足&#xff0c;对增&#xff0c;删&#xff0c;查比较方便&#xff0c;对改不是很友好 缺点&#xff1a;命令比较冗长&#xff0c;复杂&#xff0c;难记 声明式 k8s当中的yaml文件来实现资…

【DevOps-07-3】Jenkins集成Sonarqube

一、简要说明 Jenkins安装Sonarqube插件Jenkins安装和配置Sonar-Scanner信息Jenkins打包项目中,增加Sonar-Scanner代码质量扫描二、Jenkins安装Sonarqube插件 1、登录Jenkins管理后台,搜索安装Sonar-Scanner插件 Jenkins管理后台示例:http://192.168.95.131:8080/jenkins/