《面向对象程序设计（python）》期末复习

Jules_wwy

已于 2024-05-09 17:42:26 修改

阅读量824

点赞数 25

文章标签： python 开发语言

于 2024-05-09 16:53:33 首次发布

本文链接：https://blog.csdn.net/weixin_73061781/article/details/138619371

版权

本文是针对《面向对象程序设计（python）》期末考的要点复习，归纳了一些常见的基本考点，只是对知识点做了一个大致的梳理，没有细节地解释每个概念。（因为博主是全英考试，所以比较多英文）

1. Classes & Objects

2. Attributes

3. Key Principles of OOP

4. Inheritance

5. Association, Composition & Aggregation

10. Abstract Data Types(ATDs)

11. Sort and Search

12. Object-Oriented Analysis (OOA)

13. CRC Cards

14. UML图

15. Iterator迭代器和Generator生成器

16. Patterns设计模式

1. Classes & Objects

Constructors, Initializers & Destructors

__init__()构造函数的运用（记得self参数）

如果子类要访问父类的属性，要在构造函数中调用父类的构造函数

class ParentClass:
    def __init__(self，name):
        self.name = name

class ChildClass(ParentClass):
    def __init__(self, name, age):
        super().__init__(name)  # 调用父类的构造函数
        self.age = age

c = ChildClass() 
print(c.name)

2. Attributes

Data attributes数据属性:__init__函数里定义的属性

Class attributes类属性:在__init__函数之外

Instance attributes:实例属性

类数据属性属于类本身，可以通过类名进行访问或修改
类数据属性也可以被类的所有实例访问或修改
在类定义后，可以通过类名动态添加类数据属性，新增的类属性也被类和所有实例共有
实例数据属性只能通过实例访问
在实例生成后，还可以动态添加实例数据属性，但是这些实例数据属性只属于该实例。

3. Key Principles of OOP

(1)Encapsulation & Information-Hiding封装

(2)Inheritance继承

(3)Polymorphism多态

4. Inheritance

describe the subsumption (is-a) relationship

重写overriding （不同类中名字相同，参数相同）

重载overloading （同一类中名字相同，但参数和行为不同）

Multiple Inheritance（python允许多重继承）

5. Association, Composition & Aggregation

1. Association关联

One class uses functionalities provided by another

一个类使用另一个类的方法

2. Composition组合

part-of relationship

the child class cannot exist without the parent

3. Aggregation聚合

has-a relationship

the child can exist independently of the parent

6. Modules

modules就是.py文件

用import导入

package:collection of modules in a folder

require a __init__.py file (can be empty)

7. Namespaces

Attributes within an object

local names in a function

globals defined within a module

Set of built-in names

8. File

f = open(‘inputFile’,’r’)

f.read()

f.readline() 只读一行，要写循环才能读完。默认会保留换行符，读到末尾时会返回一个空字符串

f.readlines()一次读取所有行并返回一个列表，每一行都是一个字符串，默认保留换行符

f.writelines()要自己加换行符

9. Exceptions

try:

except <exception type>:

10. Abstract Data Types(ATDs)

抽象数据类型，用于描述一种数据类型的抽象特性和操作，而不涉及其具体实现

An ADT specified:

1. Data stored要存储什么数据

2. Operations on the data支持什么操作

3. Error conditions associated with operations可能出现的错误

11. Sort and Search

冒泡排序Bubble Sort

def bubbleSort(lst):
    for j in range(0,len(lst)-1):
        for i in range(0,len(lst)-1-j):
            if lst[i] >= lst[i+1]:
                lst[i],lst[i+1] = lst[i+1],lst[i]
    return lst

选择排序Selection Sort

def selectionSort(lst):
    for j in range(0,len(lst)):
        min = lst[j]
        for i in range(j,len(lst)-1):
            if lst[i] <= min:
                min = lst[i]
        lst[lst.index(min)] = lst[j]
        lst[j] = min

插入排序Insertion Sort

def insertionSort(lst):
    for i in range(1,len(lst)):
        newindex = i
        for j in range(i):
            if lst[i]<lst[j]:
                newindex-=1
        lst.insert(newindex,lst.pop(i))
    return lst

折半查找（Binary Search）：数组排好序，选择中间数(low+high)//2作为基准，判断查找值与中间数的大小关系，来判断查找值在哪个区间。将区间逐渐细化直到low>=high

def binarySearch(arr, target):
    left = 0
    right = len(arr)-1

    while left <= right:
        mid = (left + right)//2
        if arr[mid] == target:
            return "目标数在第"+ str(mid+1) +"个"
        elif arr[mid] > target:
            right = mid - 1
        else:
            left = mid +1
    return "key not in the list"

12. Object-Oriented Analysis (OOA)

four parts: Problem Statement, Use Cases, CRC Cards, Class Diagram

13. CRC Cards

CRC卡用于职责分配，是交互图和类图的极简版，在初始阶段使用

Class类类名写在整个CRC卡的最上方。

Responsibility职责包括这个类对自身信息的了解，以及这些信息将如何运用。这个部分在CRC卡的左边。

Collaborators协作指代另一个类，这里写的信息是协作的类名。我们通过这个类获取我们想要的信息或者相关操作。这个部分在CRC卡的右边。

14. UML图

Class Diagram类图

1. 泛化（Generalization/Inheritance）

【泛化关系】是一种继承关系，表示子类继承父类的所有特征和行为。

【箭头指向】空心三角，实线，箭头指向父类

class Vehicle:
    pass

class Car(Vehicle):
  pass

2. 实现（Realization）

【实现关系】是一种类与接口的关系。

【箭头指向】空心三角，虚线，箭头指向接口。

Flyable可看作一个接口，Airplane是实现了这个接口的类

class Flyable:
    def fly(self):
        pass

class Airplane(Flyable):
    def fly(self):
        print('Airplane is flying.')

3. 关联（Association）

【关联关系】表示不同类或对象之间的联系。一种拥有关系，它使得一个类知道另一个类的属性和方法。

【箭头指向】普通箭头，实线，指向被拥有者。

双向的关联可以有两个箭头，或者没有箭头（无箭头的实线）。单向的关联有一个箭头。

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.driver = None

    def assign_driver(self, driver):
        self.driver = driver

class Driver:
    def __init__(self, name):
        self.name = name

car1 = Car("Benz")
driver1 = Driver("John")
car1.assign_driver(driver1)

4. 聚合（Aggregation）

【聚合关系】是一种整体与部分的关系。且部分可以离开整体而单独存在。关联和聚合在语法上无法区分，必须考察具体的逻辑关系。

【箭头指向】空心菱形，实线，空心菱形指向整体。

class Book:
    def __init__(self, title):
        self.title = title

class Library:
    def __init__(self, books=[]):
        self.books = books

    def add_book(self, book):
        self.books.append(book)

b1 = Book('The Lord of the Rings')
b2 = Book('Harry Potter and the Philosopher\'s Stone')
l1 = Library([b1])
l1.add_book(b2)

5. 组合（Composition）

【组合关系】是一种整体与部分的关系。部分不能离开整体而单独存在。

【箭头指向】实心菱形，实线，实心菱形指向整体。

class Engine:
    def __init__(self):
        self.is_started = False

    def start(self):
        self.is_started = True

    def stop(self):
        self.is_started = False

class Car:
    def __init__(self):
        self.engine = Engine()

    def start(self):
        self.engine.start()

    def stop(self):
         self.engine.stop()

6. 依赖（Dependency）

【依赖关系】一个类的实现需要另一个类的协助。

【箭头指向】普通箭头，虚线，普通箭头指向被使用者。

class Printer:
    def print_document(self, document):
        print(f"Printing {document}...")

class Document:
    def __init__(self, content):
        self.content = content

document = Document("Hello, world!")
printer = Printer()
printer.print_document(document.content)

还可以在线上加入数字，表示两者之间的数量关系

用例图：

时序图：

15. Iterator迭代器和Generator生成器

迭代器是一个对象，包含了可以逐个访问元素的方法。

它的主要特点是惰性计算，即只有在需要时才会生成下一个元素。

迭代器通过 __iter__ 和 __next__ 方法来实现。

__iter__ 方法返回迭代器对象本身，而 __next__ 方法返回迭代器的下一个元素。当没有元素可迭代时，__next__ 方法会引发 StopIteration 异常。

class MyIterator:
    def __init__(self, max_num):
        self.max_num = max_num
        self.current_num = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_num < self.max_num:
            self.current_num += 1
            return self.current_num
        else:
            raise StopIteration

my_iterator = MyIterator(5)

for num in my_iterator:
    print(num)

Generator生成器

生成器是一种特殊的迭代器，可以通过函数来创建。

生成器使用 yield 语句来暂停并返回一个值，保留函数的状态，直到下次调用 next() 方法时继续执行。这样可以节省内存空间，因为它们在需要时生成值，而不是一次性生成所有值。

def my_generator(max_num):
    current_num = 0
    while current_num < max_num:
        current_num += 1
        yield current_num

gen = my_generator(5)

for num in gen:
    print(num)