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

一、实验结论：

1. 实验任务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()

运行结果截图：

问题1：面向对象中类、对象、属性、方法、实例化的概念。

类：具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。

对象：对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。

方法：一种编程范式，它将程序中的数据和操作封装在一起，形成对象。

实例化：在面向对象的编程中，把用类创建对象的过程称为实例化。

 

问题2： 你对类的封装性的理解。

封装就是把抽象的数据(属性)和对数据的操作(方法)封装在一起，数据被保护在内部程序的其他部分只有通过被授权的操作，才能对数据进行操作。

 

2.实验任务2：task2.py

程序源码：

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()

运行结果截图：

问题1：你对类的继承、多态特性的理解。

继承性：一个类获取现有类的所有属性和行为的机制，创建基于现有类的新类，可以重用现有类的属性和方法，可以在新创建的子类中添加新属性和方法。

多态性：同一个引用类型，使用不同的实例而执行不同操作，同一种操作，由于条件不同，产生的结果也不同。

问题2：你对python中模块的理解：什么是模块。

一个模块就是包含了python定义和声明的文件。

3.实验任务3：task3.py

程序源码：

from math import pi,exp

def func(x):
    m=0
    s=2
    f=(exp(-0.5*((x-m)/s)**2))/(s*(2*pi)**0.5)
    return f

x=[1,3,5,7,9]
for i in x:
    f=func(i)
    print(f'x = {i}, f = {f:.8f}')

运行结果截图：

 

4.实验任务4*：模拟简单二维随机漫步

random_walk.py

程序源码：

'''
random_walk.py是一个模块
封装了一个简易版的二维随机游走类
'''

from random import choice

class RandomWalk():
    '''一个生成随机漫步数据的类'''

    def __init__(self, num_points = 5000):
        '''初始化随机漫步的属性'''
        self.num_points = num_points

        # 所有的随机漫步都始于(0,0)
        self.x_values = [0]
        self.y_values = [0]


    def fill_walk(self):
        '''计算随机漫步包含的所有点'''

        # 不断漫步，直到列表到达指定长度
        while len(self.x_values) < self.num_points:
            # 决定前进方向，以及，沿这个方向前进的距离
            x_direction = choice([1, -1])
            x_distance = choice([0, 1, 2, 3, 4])
            x_step = x_direction * x_distance

            y_direction = choice([1, -1])
            y_distance = choice([0, 1, 2, 3, 4])
            y_step = y_direction * y_distance

            # 据绝原地踏步
            if x_step == 0 and y_step == 0:
                continue

            # 计算下一个点的x和y值
            next_x = self.x_values[-1] + x_step
            next_y = self.y_values[-1] + y_step

            self.x_values.append(next_x)
            self.y_values.append(next_y)


def main():
    '''测试随机游走类'''

    rw = RandomWalk(5)
    rw.fill_walk()
    print(rw.x_values)
    print(rw.y_values)


if __name__ == '__main__':
    main()

运行结果截图：

task4.py

程序源码：

'''
模拟多次随机漫步
'''

from matplotlib import pyplot as plt
from random_walk import RandomWalk
from time import sleep


# 代码范例中，模拟两次随机漫步过程
n = 0
while n < 2:
    n += 1

    # 创建一个RandomWalk对象，调用其方法生成随机游走坐标
    rw = RandomWalk(50000)
    rw.fill_walk()

    # 用散点图进行可视化绘制
    plt.figure(figsize = (10, 6), dpi = 128)
    point_numbers = list(range(rw.num_points))
    plt.scatter(rw.x_values, rw.y_values, c=point_numbers,cmap=plt.cm.Blues,
edgecolor='none', s=1)

    # 终点和起点
    plt.scatter(0,0,c = 'grey',edgecolors='none',s=100)
    plt.scatter(rw.x_values[-1], rw.y_values[-1], c = 'red',edgecolors='none',
s=100)

    # 隐藏坐标轴
    plt.axis('off')

    plt.show()

运行结果截图：

 

二、实验总结：

1. 熟悉Python中面向对象编程的概念（类、对象、属性、方法）、特性（封装、继承、多态）、基础语法

2. 了解Python中模块、包的概念和常用操作 

3. 练习使用常用内置模块的常用方法：math, random, datetime, string