实验7 面向对象编程与内置模块

实验1

task1.py

实验源码：

class Account:
    '''一个模拟银行账户的简单类'''
    def __init__(self, name, account_number, initial_amount = 10):
        '''构造新账户'''
        self._name = name
        self._card_no = account_number
        self._balance = initial_amount
    def deposit(self, amount):
        '''存款'''
        self._balance += amount
    def withdraw(self, amount):
        '''取款'''
        if self._balance < amount:
            print('余额不足')
            return

        self._balance -= amount

    def info(self):


        print('持卡人姓名:', self._name)
        print('持卡人账号:', self._card_no)
        print('持卡人账户余额:', self._balance)

    def get_balance(self):
        return self._balance

def main():
    '''创建Account类对象，测试类'''

    print('测试账户1：'.center(30, '*'))
    a1 = Account('Bob', '5002311', 20000)
    a1.deposit(5000)
    a1.withdraw(4000)
    a1.info()

    print()

    print('测试账户2：'.center(30, '*'))
    a2 = Account('Joe', '5006692', 20000)
    a2.withdraw(10000)
    a2.withdraw(5000)
    a2.info()
if __name__ == '__main__':
    main()

实验结果：

• 类对象：定义的类就是类对象
• 实例对象：类对象实例化后就是实例对象
• 类属性：定义在 __init__ 外部的变量
• 实例属性：定义在__init__内部的带有self.的变量
• 类方法：定义在类对象中 且 被@classmethod 装饰的方法就是类方法
• 实例方法：定义在类对象中，且 未被@classmethod 装饰的方法就是实例方法

task2.py

实验源码：

'''
shape.py是一个图形类模块
包括:
基类: 图形类Shape
派生类: 矩形类Rect, 圆形类Circle, 三角形类Triangle
'''

class Shape:
    '''形状基类'''
    def info(self):
        '''打印图形信息'''
        pass

def area(self):
    '''计算面积'''
    pass

def perimeter(self):
    '''计算周长'''
    pass

class Rect(Shape):
    '''
    矩形类 , 继承自Shape
    属性：矩形左上角点的坐标、宽、高
    方法：  打印矩形信息，计算面积、周长
    '''
    def __init__(self, x = 0, y = 0, length = 2, width = 1):
        '''构造矩形对象，根据矩形左上角顶点坐标(x,y)和长、宽 '''

        self._x = x
        self._y = y
        self._width = width
        self._length = length

    def info(self):
        print(f'矩形左上角顶点坐标: ({self._x}, {self._y})')
        print(f'矩形长 : {self._length}')
        print(f'矩形宽 : {self._width}')

    def area(self):
        return self._length * self._width

    def perimeter(self):
        return (self._length + self._width) * 2

class Circle(Shape):


    def __init__(self, x=0, y=0, radius=1):
        self._x = x
        self._y = y
        self._r = radius

    def info(self):
        print(f'圆心 : ({self._x}, {self._y})')
        print(f'半径 : {self._r}')

    def area(self):
        return 3.14 * self._r * self._r

    def perimeter(self):
        return 2 * 3.14 * self._r

class Triangle(Shape):
    def __init__(self, a=1, b=1, c=1):
        self._a, self._b, self._c = a, b, c

    def info(self):
        print(f'三角形三边长 : ({self._a}, {self._b}, {self._c})')

    def area(self):
        s = (self._a + self._b + self._c) / 2
        ans = (s * (s - self._a) * (s - self._b) * (s - self._c)) ** 0.5

        return ans

    def perimeter(self):
        return (self._a + self._b + self._c)

# 测试类
def main():
    print('测试1： '.center(40, '*'))

    shapes_lst1 = [Circle(), Rect(), Triangle()]

    for t in shapes_lst1:
        t.info()
        print(f'面积 : {t.area():.2f}')
        print(f'周长 : {t.perimeter():.2f}')
        print()

    print('测试2： '.center(40, '*'))

    shapes_lst2 = [Circle(x=2, y=2, radius=10),
                   Rect(x=50, y=50, length=10, width=5), Triangle(a=3, b=4, c=5)]
    for t in shapes_lst2:
        t.info()
        print(f'面积 : {t.area():.2f}')
        print(f'周长 : {t.perimeter():.2f}')
        print()

if __name__ == '__main__':
    main()

 

from Shape import Rect, Circle

shape_lst = [Rect(5, 5, 10, 5), Circle(), Circle(1, 1, 10)]

for i in shape_lst:
    i.info()
    print(f'面积 : {i.area(): .2f}')
    print(f'周长 : {i.perimeter(): .2f}')
    print()

类的继承是面向对象编程中的一种重要概念，指的是从一个已有的类（称为父类或基类）派生出一个新类（称为子类或派生类），使得新类具备父类的所有属性和方法，同时可以在新类中增加新的属性和方法。

在Python中，模块是一个包含Python代码的文件，可以定义变量、函数和类等。通过将相关的功能组织到模块中，可以提高代码的复用性，简化程序的管理和维护。同时，Python内置了许多标准库模块，在使用这些库功能时只需导入相应的模块即可。

task3.py

实验源码：

import math
m = 0
s = 2
def func(x):
    a = 1/(math.sqrt(2*math.pi)*s)
    b = math.exp((-0.5)*((x-m)/s)**2)
    return a*b
print(f'x = 1,f = {func(1):.8f}')
print(f'x = 3,f = {func(3):.8f}')
print(f'x = 5,f = {func(5):.8f}')
print(f'x = 7,f = {func(7):.8f}')
print(f'x = 9,f = {func(9):.8f}')

实验结果：