15. 第十五章 类和对象

15. 类和对象

到现在你已经知道如何使用函数组织代码, 以及如何使用内置类型来组织数据.
下一步将学习'面向对象编程', 面向对象编程使用自定义的类型同时组织代码和数据.
面向对象编程是一个很大的话题, 需要好几章来讨论.

本章的代码示例可以从↓下载,
https://github.com/AllenDowney/ThinkPython2/blob/master/code/Point1.py 
练习的解答可以在↓下载.
https://github.com/AllenDowney/ThinkPython2/blob/master/code/Point1_soln.py
15.1 用户定义类型
我们已经使用了很多Python的内置类型; 现在我们要定义一个新类型.
作为示例, 我们将会新建一个类型Point, 用来表示二维空间中的一个点.
在数学的表示法中, 点通常使用括号中逗号分割两个坐标表示.
例如, (0, 0)表示原点, 而(x, y)表示一个在圆点右侧x单位, 上方y单位的点.

在Python中, 有好几种方法可以表达点.
* 我们可以将两个坐标分别保存到变量x和y中.
* 我们可以将坐标作为列表或元组的元素存储.
* 我们可以新建一个类型用对象表达点.

新建一个类型比其他方法更复杂一些, 但它的优点很快就显现出来.
用户定义的类型也称为'类'(class). 类的定义如下:

class Point:
	""" Represents a point in 2-D space. """


定义头表示新的类名为Point. 定义体是一个文档字符串, 解释这个类的用途.
可以在类定义中定义变量和函数, 我们会后面回到这个话题.
定义一个叫作Point的类会创建一个'对象类'(object class).

>>> Point
<class '__main__.Point'>


因为Point是在程序顶层定义的, 它的'全名'是__main__.Point.
类对象项一个创建对象的工厂. 要新建一个Point对象, 可以把Point当作函数类调研:

>>> blank = Point()
>>> blank
<__main__.Point object at 0x00000230EBFBB490>


返回值是一个Point对象的引用, 它们将它赋值给变量blank.
新建一个对象的过程称为'实例化'(instantiation), 而对象是这个类的一个实例.

在打印一个实例时, Python会告诉你它所属的类型,
以及存在内存中的位置(前缀0x表示后面的数字是十六进制的).

每个对象都是某个类的实例, 所以'对象'和'实例'这个两个词很多情况下都可以互换,
但是在本章中我们使用'实例'来表示一个自定义类型的对象.
15.2 属性
可以使用句点表示法给实例赋值:

>>> blank.x = 3.0
>>> blank.y = 4.0


这个语法和从模块中选择变量的语法类似, 如math.pi或者strings.whitespace.
但在种情况下, 我们是将值赋值给一个对象的有命名的元元素. 这些元素称为属性(attribute).
作为名词时, 'AT-trib-ute'发音的重音在第一个音节, 这与作为动词的'a-TRIB-ute'不同.

下面的图标展示了这些赋值的结果.
展示一个对象和其属性的状态图称为'对象图'(object diagram), 参见图15-1.

2023-04-14_00002

变量blank引用一个Point对象, 它包含了两个属性. 每个属性引用一个浮点数.
可以使用相同的语法来读取一个属性的值.

>>> blank.y
4.0
>>> x = blank.x
>>> x
3.0


表达式blank.x表示, '找打blank引用的对象, 并取得它的x属性的值'.
在这个例子中, 我们将那个值 赋值给一个变量x. 变量x和属性x并不冲突.
可以在任意表达式中使用句点表示法. 例如:

# %g用于打印浮点型数据时，会去掉多余的零，至多保留六位有效数字.
>>> '(%g, %g)' % (blank.x, blank.y)
'(3, 4)'
>>> import math
>>> distance = math.sqrt(blank.x ** 2 + blank.y ** 2)
>>> distance
5.0


可以将一个实例作为实参按通常的方式传递. 例如:

def print_point(p):
	print('(%g, %g)' % (p.x, p.y))
    

print_point接收一个点作为形参, 并按照属性表达式展示它.
可以传入blank作为实参来调用它:

>>> print_point(blank)
(3, 4)


在函数中, p是blank的一个别名, 所以如果函数修改了p, 则blank也会被修改.

作为练习, 编写一个叫作distance_between_points的函数, 
接收两个Point对象作为形参, 并返回它们之间的距离.
第一个坐标(x1=3, y1=4)
第二个坐标(x2=5, y2=6)
计算公式:(✓根号)
|AB| = ✓(x1 - x2) ** 2 + (y1 - y2) ** 2
或:
|AB| = (x1 - x2) ** 2 + (y1 - y2) ** 2 ** 0.5


import math


# 自定义对象
class Point:
    """自定义对象"""
    x = None
    y = None


# 实例两个对象
blank1 = Point()
blank1.x = 3.0
blank1.y = 4.0

blank2 = Point()
blank2.x = 5.0
blank2.y = 6.0


def distance_between_points(p1, p2):
    """
    计算两个Point对象之间的距离,
    :param p1: 第一个Point对象.
    :param p2: 第二个Point对象.
    :return: 两个Point对象之间的距离.
    """
    px = p1.x - p2.x
    py = p1.y - p2.y
    # return math.sqrt(px ** 2 + py ** 2)
    return ((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2) ** 0.5


res = distance_between_points(blank1, blank2)
print(res)  # 2.8284271247461903
15.3 矩形
有时候对象因该有哪些属性非常明显, 但也有时候需要你来做决定,
例如, 假设你子啊设计一个表达矩形的类. 你会用什么属性来指定一个矩形的位置和尺寸呢?
可以忽视角度, 为了简单起见, 假定矩形不是垂直的就是水平的.
最少有以下两种可能.
* 可以指定一个矩形的一个角落(或者中心点), 宽度以及高度.
* 可以指定两个相对的角落.
现在还很难说哪一种方案更好, 所以作为示例, 我们仅限实现第一个.

class Rectangle:
    """Represents a rectangle.
    attributes: width, height, corner.
    """
    

文档字符列出了属性: width和height是数字, 用来指定左下角的顶点.
要表达一个矩形, 需要实例化一个Rectangle对象, 并对其属性赋值:

box = Rectangle()
# 设置宽
box.width = 100.0
# 设置高
box.height = 200.0
# 坐标对象 (0, 0)
box.corner = Ponint()
box.corner.x = 0.0
box.corner.y = 0.0


表达式box.corner.x表示, '去往box引用的对象, 并选择属性corner; 接着去往过那个对象, 并选择属性x'.

图15-2展示了这个对象的状态. 作为另一个对象的属性存在的对象是'内嵌'的.

2023-04-15_00001

15.4 作为返回值得示例
函数可以返回实例. 
例如, find_center接收一个Rectangle对象作为参数, 并返回一个Point对象,
包含这个Rectangle的中心点的坐标:

# 计算矩形的中心点.
def find_center(rect):
	p = Point()
	p.x = rect.corner.x + rect.width / 2
	p.y = rect.corner.y + rect.height / 2
	return p
	

下面是一个示例, 传入box作为实参, 并将结果的point对象赋值给center:

>>> center = find_center(box)
>>> print_point(center)
(50, 100)


# 完整代码

def print_point(p):
    print('(%g, %g)' % (p.x, p.y))


# 中心点
def find_center(rect):
    p = Point()
    p.x = rect.corner.x + rect.width / 2
    p.y = rect.corner.y + rect.height / 2
    # 实例作为返回值
    return p


class Point:
    """ Represents a point in 2-D space. """


class Rectangle:
    """Represents a rectangle.
    attributes: width, height, corner.
    """


if __name__ == '__main__':
    box = Rectangle()
    box.width = 100.0
    box.height = 200.0
    # 设置坐标
    box.corner = Point()
    box.corner.x = 0.0
    box.corner.y = 0.0
    
    center = find_center(box)
    print_point(center)  # (50, 100)
15.5 对象是可变的
可以通过一个对象的某个属性赋值来修改它的状态.
例如, 要修改一个矩形的尺寸而保持它的位置不变(左下角坐标为0, 0不变.),
可以修改属性width和height的值:

box.width = box.width + 50
box.height = box.width.height + 100


也可以编写函数来修改对象.
例如, grow_rectangle接收一个Rectangle对象和两个数, dwidth, dheight,
并把这些数加到矩形的宽度和高度上:

def grow_revtangle(rect, dwidth, dheight):
	rect.width += dwight
	rect.height += dheight
	

下面是展示这个函数效果的实例:

>>> box.width, box.height
(150.0, 300.0)
>>> grow_rectangle(box, 50, 100)
>>> box.width, box.height
(200.0, 400.0)


在函数中, rect是box的别名, 所以如果当修改了revt时, box也改变.

作为练习, 编写一个名为move_rectangle的函数, 接收一个Rectangle对象和两个分别名为dx和dy的数值.
它应当通过将dx添加到corner的x坐标和将dy添加到corner的y坐标来改变矩形的位置.

# 打印坐标
def print_point(p):
    print('(%g, %g)' % (p.x, p.y))


# 中心点
def find_center(rect):
    p = Point()
    p.x = rect.corner.x + rect.width / 2
    p.y = rect.corner.y + rect.height / 2
    # 实例作为返回值
    return p


# 移动坐标
def move_rectangle(rect, dx, dy):
    rect.corner.x += dx
    rect.corner.y += dy


class Point:
    """ Represents a point in 2-D space. """


class Rectangle:
    """Represents a rectangle.
    attributes: width, height, corner.
    """


if __name__ == '__main__':
    box = Rectangle()
    box.width = 100.0
    box.height = 200.0
    # 设置坐标
    box.corner = Point()
    box.corner.x = 0.0
    box.corner.y = 0.0
    # 打印坐标
    print_point(box.corner)  # (0, 0)
    # 移动坐标
    move_rectangle(box, 100, 100)
    print_point(box.corner)  # (100, 100)
15.6 复制
别名的使用有时候会让程序更难阅读, 因为一个地方的修改可能会给其他地方带来意想不到的变化.
要跟踪掌握所有引用到一个给定对象的变量非常困难.
使用别名的常用替代方案是复制对象. copy模块里有一个函数copy可以复制任何对象:

>>> p1 = Point()
>>> p1.x = 3.0
>>> p1.y = 4.0
>>> import copy
>>> p2 = copy.copy(p1)


p1和p2包含相同的数据, 但是它们不是同一个Point对象.

>>> print_point(p1)
(3, 4)
>>> print_point(p2)
(3, 4)
>>> p1 is p2
False
>>> p1 == p2
False


正如我们预料, is操作符告诉我们p1和p2不是同一个对象.
但你可能会预料==能得到True值, 因为这两个点(坐标点)包含相同的数据.
如果那样, 你会失望地发现对于实例来说, ==操作符的默认行为和is操作符相同,
它会检查对象同一性, 而不是对象相等性.
这是因为对于用户自定义类型, Python并不知道怎么才算相等. 至少现在还不行.


对象同一性(object identity): 当两个引用类型的变量存储的地址相同时, 它们引用的是同一个对象.
在Python中, ==操作符的默认行为是检查两个对象的值是否相等.
而is操作符则检查两个对象是否是同一个对象,即它们是否具有相同的内存地址。

对于内置类型(例如整数、浮点数、字符串等)Python已经定义了如何判断相等性.
但对于自定义类型, Python不会自动判断相等性, 因为它不知道如何判断两个对象是否相等.
因此, 如果你定义了自己的类, 你需要自己定义__eq__()方法来定义该类的相等性行为.
在这种情况下, ==操作符将使用您定义的__eq__()方法进行比较.

需要注意的是, 即使您定义了__eq__()方法, 使用is操作符也不会调用该方法,
因为is操作符只检查两个对象是否具有相同的内存地址.

如果使用copy.copy复制一个Rectangle, 你会发现它复制了Rectangle对象但并不复制内嵌的Point对象:

>>> box2 = copy.copy(box)
>>> box2 is box
False
# corner引用内嵌对象
>>> box2.corner is box.corner
True


图15-3展示了这个操作的对象图.
这个操作成为浅复制(shallow copy), 因为它复制对象及其包含的任何引用, 但不复制内嵌对象.
(复制了内嵌对象的引用, 两个Recrangle对象的corner属性共用一个内嵌对象的引用,
哪个Recrangle对象对内嵌对象做了改动都会影响另一个Recrangle对象.)

2023-04-15_00005

对大多数应用, 这并不是你所想要的.
在这个例子里, 对一个Recrangle对象调用grow_rectangle并不影响其他对象,
当对任何Recrangle对象调用move_rectangle都会影响全部两个对象!
这种行为即混乱不清, 又容易导致错误.

幸好, copy模块还提供了一个名为deepcopy的方法, 它不但赋值对象, 还会复制对象中引用的对象,
甚至它们引用的对象, 以此类推.
所以你并不会惊讶这个操作为何称为深复制(deep copy).

>>> box3 = copy.deepcopy(box)
>>> box3 is box
False
>>> box3.corner is box.corner
False


box3个box是两个完全分开的对象.

作为练习, 编写move_rectangle的另一个版本, 它会新建并返回一个Rectangle对象, 而不是直接修改旧对象.

import copy


# 打印坐标
def print_point(p):
    print('(%g, %g)' % (p.x, p.y))


# 中心点
def find_center(rect):
    p = Point()
    p.x = rect.corner.x + rect.width / 2
    p.y = rect.corner.y + rect.height / 2
    # 实例作为返回值
    return p


# 移动坐标
def move_rectangle(rect, dx, dy):
    # 深复制一个Rectangle对象
    box2 = copy.deepcopy(rect)
    box2.corner.x += dx
    box2.corner.y += dy

    return box2


class Point:
    """ Represents a point in 2-D space. """


class Rectangle:
    """Represents a rectangle.
    attributes: width, height, corner.
    """


if __name__ == '__main__':
    box = Rectangle()
    box.width = 100.0
    box.height = 200.0
    # 设置坐标
    box.corner = Point()
    box.corner.x = 0.0
    box.corner.y = 0.0

    # 深复制一个矩形对象, 移动新矩形对象的坐标, 并返回新的矩形对象.
    box2 = move_rectangle(box, 100, 100)
    print_point(box2.corner)  # (100, 100)
    # 旧矩形对象不变
    print_point(box.corner)  # (0, 0)
15.7 调试
开始操作对象时, 可能会遇到一些新的异常.
如果试图访问一个并不存在的属性, 会得到AttrbuteErroe:

>>> p = Point()
>>> p.x = 3
>>> p.y = 4
>>> p.z

# 新版本
AttributeError: 'Point' object has no attribute 'z'
属性错误: 'Point'对象没有属性'z'

# 老版本
AttributeError: Point instance has no attribute 'z'
属性错误: 'Point'实例没有属性“z”

如果不清楚一个对象是什么类型, 可以问:

>>> type(p)
<class '__main__.Point'>

# 2.7版本, 显示 instance实例
<type 'instance'>

如果不确定一个对象是否拥有某个特定的属性, 可以使用内置函数hasatter:

>>> hasattr(p, 'x')
True
>>> hasattr(p, 'z')
False


第一个情形可以是任何对象, 第二个形参是一个包含属性名称的字符串.
也可以使用try语句来尝试对象是否拥有你需要的属性:

try:
	x = p.x
except AttributeEeeor:
	X = 0
	

这种方法可以使编写适用于不同类型的函数更加容易. 
关于这一主题的更多内容参见17.9节.
15.8 术语表
类(class): 一个用户定义的类型. 类定义会新建一个类对象.

类对象(class object): 一个包含用户定义类的信息的对象. 类对象可以用来创建改类型的实例.

实例(instance): 属于某个类的一个对象.

属性(sttribute): 一个对象中关联的有命名的值.

内嵌对象(embedded object): 作为一个对象的属性存储的对象.

浅复制(shallow copy): 复制对象的内容, 包括内嵌对象的引用; copy模块中的copy函数实现了这个功能.

深复制(deep copy): 复制对象的内容, 也包括内嵌对象, 以及它们内嵌的对象, 依次类推;
	copy模块中的deepcopy函数实现了这个功能.

对象图(object diagram): 一个展示对象, 对象的属性以及属性的值的图.
15.9 练习
1. 练习1
定义一个新的名为Circle的类表示圆形, 它的属性有center和radius, 
其中center(中心坐标)是一个Point对象, 而radius(半径)是一个数.

实例化一个Circle对象来代表一个圆心在(150, 100), 半径为75的圆形.

编写一个函数point_in_circle, 接收一个Circle对象和一个Point对象, 
并当Point处于Circle的边界或其内时返回True.

编写一个函数cert_in_circle, 接收一个Circle对象和一个Rectangle对象, 
并在Rectangle的任何一个角落在Circle之内是返回True.

另外, 还有一个更难的版本, 需要在Rectangle的任何部分都落在圆圈之内时返回True.

解答: https://github.com/AllenDowney/ThinkPython2/blob/master/code/Circle.py

如何判断一个坐标是否在圆内:
1. 圆心到这个点的距离小于圆的半径, 则这个点在圆内.
2. 圆心到这个点的距离等于圆的半径, 则这个点在圆周上.
3. 圆心到这个点的距离大于圆的半径, 则这个点在圆外.


计算两个坐标的距离:
|AB| = (x1 - x2) ** 2 + (y1 - y2) ** 2 ** 0.5

# 自定义对象
class Point:
    """坐标"""
    x = None
    y = None


class Circle:
    """圆"""


class Rectangle:
    """矩形"""


def distance_between_points(p1, p2):
    """
    计算两个Point对象之间的距离,
    :param p1: 第一个Point对象.
    :param p2: 第二个Point对象.
    :return: 两个Point对象之间的距离.
    """
    return ((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2) ** 0.5


def point_in_circle(cir, p):
    # 计算两个坐标之间的距离.
    distance = distance_between_points(cir.center, p)
    # 距离是否在圆的半径内
    print('输入的坐标离圆的距离为:%d,' % distance, end='\t')
    if distance <= cir.radius:
        return True


def cert_in_circle(cir, rect):
    # 计算矩形的四个角的坐标离圆心坐标的距离
    # 左下角就是矩形的坐标
    bottom_left = rect.corner
    # 左上角, y + height
    upper_left = Point()
    upper_left.x = rect.width
    upper_left.y = bottom_left.y + rect.height
    # 右下角 x + width
    bottom_right = Point()
    bottom_right.y = rect.height
    bottom_right.x = bottom_left.x + rect.width

    # 右上角
    top_right = Point()
    # x = 左上角加width
    top_right.x = upper_left.x + rect.width
    top_right.y = upper_left.y

    # 计算四个角的是否在圆内
    corner_list = [('左下角', bottom_left), ('左上角', upper_left),
                   ('右下角', bottom_right), ('右上角', top_right)]

    count = 0
    for corner_name, corner_point in corner_list:
        distance = distance_between_points(cir.center, corner_point)
        print('矩形的%s离圆心的距离为: %d.' % (corner_name, distance), end=' ')

        if distance <= cir.radius:
            count += 1
            print('矩形这个角在圆内!')
        else:
            print('矩形这个角不在圆内!')

    if count == 4:
        print('圆的任何部分都在圆内')


def main(p2_obj):
    # 实例化对象得到一个圆
    round1 = Circle()
    # 设置圆的坐标150.0
    round1.center = Point()
    round1.center.x = 150
    round1.center.y = 100
    # 设置圆的半径75
    round1.radius = 75

    # 判断坐标是否在圆内.
    is_inside_circle = point_in_circle(round1, p2_obj)
    if is_inside_circle:
        print('坐标在圆内!')
    else:
        print('坐标不在圆内!')

    # 输入的矩形的任何一个角是否在圆内
    # 实例化一个矩形对象
    rect = Rectangle()
    rect.width = 100
    rect.height = 200
    rect.corner = p2

    cert_in_circle(round1, rect)


if __name__ == '__main__':
    p2 = Point
    p2.x = 300
    p2.y = 300
    main(p2)

2023-04-16_00002

2. 练习2
编写一个名为draw_rect的函数, 接收一个Turtle对象, 和一个Rectangle对象组我形参,
并使用Turtle来绘制这个Rectangle. 如何使用Turtle对象的示例参见第4章.

编写一个draw_cect的函数, 接收一个Turtle对象和一个Circle对象, 并绘制出Circle.
解答: https://github.com/AllenDowney/ThinkPython2/blob/master/code/polygon.py

import turtle

from Point1 import Point, Rectangle
# polygon.py 文件以及写的练习文件.
import polygon


class Circle:
    """"""


def draw_circle(t, circle):

    t.pu()
    t.goto(circle.center.x, circle.center.y)
    t.fd(circle.radius)
    t.lt(90)
    t.pd()
    polygon.circle(t, circle.radius)


def draw_rect(t, rect):
    t.pu()
    t.goto(rect.corner.x, rect.corner.y)
    t.setheading(0)
    t.pd()

    for length in rect.width, rect.height, rect.width, rect.height:
        t.fd(length)
        t.rt(90)


if __name__ == '__main__':
    bob = turtle.Turtle()

    length = 400
    bob.fd(length)
    bob.bk(length)
    bob.lt(90)
    bob.fd(length)
    bob.bk(length)

    box = Rectangle()
    box.width = 100.0
    box.height = 200.0
    box.corner = Point()
    box.corner.x = 50.0
    box.corner.y = 50.0

    draw_rect(bob, box)

    circle = Circle
    circle.center = Point()
    circle.center.x = 150.0
    circle.center.y = 100.0
    circle.radius = 75.0

    draw_circle(bob, circle)

    turtle.mainloop()

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

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

相关文章

嵌入式实训day3

嵌入式实训day3

1、 # 82261773 # y6ufuT9yGQxddpSzSe3zZpbP # BJsEfKFNGOwHtLuKoHsfVIWrGWjXVKut"""1、PC需要联网2、不能使用MicroPython解释器 """ from aip import AipFace import base64# 查看REST-API-SDK if __name__ "__main__":# 设置APP_I…
阅读更多...
数字电路中二进制的数据表达

数字电路中二进制的数据表达

文章目录 1. 二进制数据表达 1.1 二进制简介 1.2 用二进制表达文字 1.2.1 最开始的表达方式 1.2.2 通讯系统的编码和解码 1.2.3 集成电路 1.2.4 ASCII编码 1.2.5 GBK编码 1.2.6 Unicode编码 2. 用二进制表达图像 2.1 图片像素化 2.2 像素数字化 2.3 二值图像 2.4…
阅读更多...
C++ 43 之 自增运算符的重载

C++ 43 之 自增运算符的重载

#include <iostream> #include <string> using namespace std;class MyInt{friend ostream& operator<< (ostream& cout , MyInt& int1); public:MyInt(){this->m_num 0;}// 前置自增&#xff1a; 成员函数实现运算符的重载 返回的是 引用&a…
阅读更多...
ARTS Week 32

ARTS Week 32

Algorithm 本周的算法题为 1512. 好数对的数目 给你一个整数数组 nums 。 如果一组数字 (i,j) 满足 nums[i] nums[j] 且 i < j &#xff0c;就可以认为这是一组 好数对 。 返回好数对的数目。 示例 1&#xff1a;输入&#xff1a;nums [1,2,3,1,1,3]输出&#xff1a;4解释…
阅读更多...
使用python绘制三维散点图

使用python绘制三维散点图

使用python绘制三维散点图 三维散点图三维散点图的用途效果代码 三维散点图 三维散点图&#xff08;3D Scatter Plot&#xff09;是一种用于展示三维数据的图表。与二维散点图类似&#xff0c;三维散点图通过点在三维空间中的位置来表示数据点的三个特征。每个点在 x、y 和 z …
阅读更多...
如何清除anaconda3缓存？

如何清除anaconda3缓存？

如果长期使用anaconda不清理缓存&#xff0c;会导致anaconda占用磁盘空间越来越多&#xff0c;甚至系统磁盘撑爆。 清除包缓存&#xff1a; 打开 Anaconda Prompt 或者命令行窗口。运行以下命令清除包缓存&#xff1a;conda clean --all这会清除所有的包缓存&#xff0c;释放磁…
阅读更多...
一次基于 rebase 的 PR 提交

一次基于 rebase 的 PR 提交

目录标题 基于 rebase 的 PR 提交git 命令idea 操作 基于 rebase 的 PR 提交 git 命令 &#xff11;・git fetch &#xff12;・git checkout -b dev2 origin/dev2 新拉分支dev2&#xff13;・date >> 1.txt && git add . && g…
阅读更多...
Midjourney提示词终极指南(完整版)

Midjourney提示词终极指南(完整版)

在这篇博客中&#xff0c;我们深入研究了使用提示的艺术&#xff0c;以利用Midjourney的AI功能的力量。我们将探索各种技术&#xff0c;以创建个性化和迷人的图像&#xff0c;将你的创意想法转变为令人惊叹的视觉杰作。 1. 了解提示词 提示是简短的文字描述或关键词&#xff…
阅读更多...
人工智能在风险管理中的创新之路及案例分析

人工智能在风险管理中的创新之路及案例分析

随着科技的日新月异&#xff0c;人工智能&#xff08;AI&#xff09;技术已广泛应用于各个领域&#xff0c;特别是在风险管理方面&#xff0c;其展现出的巨大潜力和实际应用价值引人瞩目。本文将结合具体案例&#xff0c;深入探讨AI在风险管理中的创新应用及其带来的行业变革。…
阅读更多...
springboot原理篇-配置优先级

springboot原理篇-配置优先级

springboot原理篇-配置优先级&#xff08;一&#xff09; springboot项目一个支持三种配置文件 application.propertiesapplication.ymlapplication.yaml 其中&#xff0c;优先级的顺序是&#xff1a; application.properties > application.yml > application.yaml 也…
阅读更多...
【Unity】如何做一个很平滑的行人动画，且可以根据行人速度动态调整动画速度？

【Unity】如何做一个很平滑的行人动画，且可以根据行人速度动态调整动画速度？

首先我们定一下不同速度对应的行人动作状态&#xff0c;设计为四种状态&#xff1a; 静止站立Stand&#xff1a;0~maxStandSpeed走路Walk&#xff1a;minWalkSpeed~maxWalkSpeed慢跑Jog&#xff1a;minJogSpeed~maxJogSpeed快跑Run&#xff1a;大于MinRunSpeed 我们可以使用A…
阅读更多...
Linux笔记--ubuntu文件目录+命令行介绍

Linux笔记--ubuntu文件目录+命令行介绍

文件目录 命令行介绍 当我们在ubuntu中命令行处理位置输入ls后会显示出其所有目录&#xff0c;那么处理这些命令的程序就是shell&#xff0c;它负责接收用户的输入&#xff0c;并根据输入找到其他程序并运行 命令行格式 linux的命令一般由三部分组成&#xff1a;command命令、…
阅读更多...
关于yolov5训练的那些事儿

关于yolov5训练的那些事儿

1.YOLOv5 的模型系列包括从最小到最大的多种模型&#xff1a;YOLOv5n&#xff08;Nano&#xff09;&#xff0c;YOLOv5s&#xff08;Small&#xff09;&#xff0c;YOLOv5m&#xff08;Medium&#xff09;&#xff0c;YOLOv5l&#xff08;Large&#xff09;&#xff0c;以及 YO…
阅读更多...
【C++】【期末考】【基本概念和语法】概括总结——期末速成

【C++】【期末考】【基本概念和语法】概括总结——期末速成

目录 1. C简介 C的历史与发展 C的特点与优势 2. 基本语法 注释 数据类型与变量 常量 运算符 输入与输出 3. 控制结构 条件语句 循环语句 4. 函数 函数定义与声明 参数传递 返回值 函数重载 5. 数组与字符串 一维数组 多维数组 字符串处理 6. 指针 指针的…
阅读更多...
主窗体设计

主窗体设计

自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm1001.2014.3001.5501 Python、QT与PyCharm配置完成后&#xff0c;接下来需要对快手爬票的主窗体进行设计&#xff0c;首先需要创建主窗体外层为&#xff08;红色框内&…
阅读更多...
聊天页面样式

聊天页面样式

聊天页面样式 代码&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-width, initial-scale1.0" /><link rel"styleshee…
阅读更多...
docker下载ridis

docker下载ridis

1、执行 docker pull redis:4.0.1 命令&#xff0c;下载 redis 镜像 &#xff08;需确保装有并启动bocker&#xff09; 通过docker启动redis 分配端口和端口映射 密码等 rootiZf8z985hmyc9bkejcfmqrZ:~# docker run --rm -d --name redis6379 -p 6379:6379 redis:4.0.1 --req…
阅读更多...
atmega8 上传程序

atmega8 上传程序

使用icsp 烧写时先关闭串口程序&#xff0c;与串口uart连接相关的电路勿于电脑连接 接触不良 1.使用icsp 上传 1&#xff09;可以直接上传程序 如官方示例blink 或是 serial示例 2&#xff09;可以先烧录bootload 方便下次使用串口上传程序代码 A)使用专门的icsp 上传器上传…
阅读更多...
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] URL拼接(100分) - 三语言AC题解(Python/Java/Cpp)

【2024最新华为OD-C/D卷试题汇总】[支持在线评测] URL拼接(100分) - 三语言AC题解(Python/Java/Cpp)

🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员 ✨ 本系列打算持续跟新华为OD-C/D卷的三语言AC题解 💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导 👏 感谢大家的订阅➕ 和 喜欢💗 📎在线评测链接 URL拼接(100分) 🌍 评测功能需要订阅专栏后私信联系清隆解…
阅读更多...
建造者模式(大话设计模式)C/C++版本

建造者模式(大话设计模式)C/C++版本

建造者模式 C 参考&#xff1a;https://www.cnblogs.com/Galesaur-wcy/p/15907863.html #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std;// Product Class&#xff0c;产品类&#xff0c;由多个…
阅读更多...
最新文章

Copyright @ 2022~2023