Python快速编程入门#学习笔记08# |第8章 ：面向对象

1. 面向对象概述

面向对象 是程序开发领域的重要思想，这种思想 模拟 了人类认识客观世界的 思维方式，将开发中遇到的 事物 皆看作 对象

面向过程：

• 分析解决问题的步骤
• 使用函数实现每个步骤的功能
• 按步骤依次调用函数

面向对象:

• 分析问题，从中提炼各个对象
• 将不同对象各自的 特征 和 行为 进行封装
• 通过控制对象的行为来解决问题

向对象程序设计（英语：Object-oriented programming，缩写：OOP）

面向对象是一种抽象画的编程思想，很多编程语言中都有的一种思想。

例如：洗衣服

思考：几种途径可以完成洗衣服？

答：手洗 和 机洗

手洗： 找盆 - 放水 - 加洗衣粉 - 浸泡 - 搓洗 - 倒水 - 漂洗N次 - 拧干 - 晾晒

机洗： 打开洗衣机 - 放衣服 - 加洗衣粉 - 按下按钮 - 晾晒

思考：对比两种洗衣服方式，你发现了什么？

答：机洗更简单

思考：机洗，只需要有一台洗衣机，加入简单操作就可以完成洗衣服的工作，而不需要关系洗衣机内部发生了什么事情。

总结：面向对象就是将程序当成一个事物，对外界来说，事物是(用户)直接使用的，不用管它内部的情况(厂商创建洗衣机的功能)。而编程就是设置事物能够做什么事。

优点： 面向对象，化简代码，化简逻辑。

2. 类的定义

面向对象编程有两个非常重要的概念：类 和 对象 。对象 映射现实中真实存在的事物，如一本书。具有相同的特征 和 行为 的事物的集合统称为 类 。对象时根据类创建的，一个类可以对应多个对象。类是对象的抽象，对是类的实例。

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。

• 类的名称：大驼峰命名法(首字母一般大写 ，比如Person)
• 类的属性：描述事物的特征 ,比如 性别。
• 类的方法：描述事物的行为，比如 抬腿。

类比如是制造洗衣机时要用到的图纸，也就是类是用来创建对象。

洗衣机的尺寸 – 变量

洗衣机的功能（排水、烘干）-- 函数

注意： 先有类，再有对象

1.定义类

Python2 中有 经典类 和 新式类

语法格式：

class 类名():
	属性名 = 属性值
	def 方法名(self)：
		方法体
	.......

注意：类名要瞒住标识符命名规则，同事遵循大驼峰命名习惯 MyName

# 类是对一系列具有相同**特征**和**行为**的事物的统称，是一个抽象的概念，不是真实存在的事物。
# 特征即是属性
# 行为即是方法

# 类比如是制造洗衣机时要用到的图纸，也就是类是用来创建对象。
# 洗衣机的尺寸 -- 变量
# 洗衣机的功能（排水、烘干）-- 函数

# 注意：先有类，再有对象

# 1.定义类

# Python2 中有 经典类 和 新式类
# 语法：
'''
class 类名():
    代码
    ......
'''
# 注意：类名要瞒住标识符命名规则，同事遵循**大驼峰命名习惯** MyName
# 需求：洗衣机  功能：能洗衣服

class Washer():
    def wash(self):    # 注意：self
        print('洗衣机：能洗衣服')


# 2.创建对象  （对象又叫实例）
# 语法  对象名 = 类名()
haier = Washer()   # 创建对象


haier.wash()        #对象（实例）方法 调用函数        

3.对象的创建与使用

对象又叫实例

语法：对象名 = 类名()

# 类是对一系列具有相同**特征**和**行为**的事物的统称，是一个抽象的概念，不是真实存在的事物。
# 特征即是属性
# 行为即是方法

# 类比如是制造洗衣机时要用到的图纸，也就是类是用来创建对象。
# 洗衣机的尺寸 -- 变量
# 洗衣机的功能（排水、烘干）-- 函数

# 注意：先有类，再有对象

# 1.定义类

# Python2 中有 经典类 和 新式类
# 语法：
'''
class 类名():
    代码
    ......
'''
# 注意：类名要瞒住标识符命名规则，同事遵循**大驼峰命名习惯** MyName
# 需求：洗衣机  功能：能洗衣服

class Washer():
    def wash(self):    # 注意：self
        print('洗衣机：能洗衣服')


# 2.创建对象  （对象又叫实例）
# 语法  对象名 = 类名()
haier = Washer()   # 创建对象

# 实例方法格式：对象名.实例方法名（）
haier.wash()        #对象（实例）方法 调用函数        

类的成员

4.属性

Q: 什么是属性？

A: 属性即是特征，比如：洗衣机的宽度、高度、重量……； 男性、女性……

对象属性既可以在类外面添加和获取，也可以在类里面添加和获取。

1、类属性

2、实例属性

---

1、 类外面

添加对象属性

语法：对象名.属性(变量)名 = 值

haier1.width = 400                          # 添加对象属性
haier1.height = 800

获取对象属性

语法：对象名.属性名

print(f'haier1洗衣机的宽度是：{haier1.width};haier1洗衣机的高度是：{haier1.height}')            # 获取对象属性

完整实例如下：

# 3. 添加和获取对象属性
# 类外面添加对象属性
# 语法：对象名.属性(变量)名 = 值
# 体验：
class Washer():
    def wash(self):
        print('洗衣机：能洗衣服')



haier1 = Washer()                           # 创建对象
haier1.wash()                               # 实例方式

haier1.width = 400                          # 添加对象属性
haier1.height = 800

# 类外面获取对象属性
# 语法：对象名.属性名

print(f'haier1洗衣机的宽度是：{haier1.width};haier1洗衣机的高度是：{haier1.height}')            # 获取对象属性

# 类里面获取对象属性
# 语法： self.属性名

2、类里面

类里面添加属性

# 类里面获取对象属性
# 语法： self.属性名

# 定义类
class Washer():
    # 类里面添加实例（对象）属性
    width = 400
    height = 800

    def print_info(self):

        # 类里面获取实例（对象）属性
        print(f'haier1洗衣机的宽度是：{self.width}；高度是{self.height}')

# 创建对象
haier1 = Washer()
haier1.print_info()  # 调用类里面的函数（实例方法）

输出结果如下：

获取对象属性

语法： self.属性名

# 类里面获取对象属性
# 语法： self.属性名

# 定义类
class Washer():
	# 添加实例（对象）属性
	haier1.width = 400
	haier1.height = 800
    def print_info(self):
        # 类里面获取实例（对象）属性
        print(f'haier1洗衣机的宽度是：{self.width}；高度是{self.height}')

# 创建对象
haier1 = Washer()



haier1.print_info()  # 调用类里面的函数（实例方法）

运行程序，输出结果如下：

5.方法

Python 中的方法按定义方式和用途可以分为三类：

• 实例方法
• 类方法
• 静态方法

1、实例方法

• 实例方法 定义在类内部，形似函数定义
• 以self 为第一个形式参数，self参数代表对象本身
• 只能通过对象调用

2、类方法

类方法的特点：

• 类方法是定义在类内部
• 需要用 装饰器 @classmethod 来表示其为类方法
• 第一个参数cls,代表类本身
• 可以通过类和对象调用

类方法的使用场景

# 定义类
class Dog(object):
    __tooth = 10    # 私有类属性 __   前面加两个下划线'__'

    @classmethod
    def get__tooth(cls):
        return cls.__tooth
wangcai = Dog() # 创建对象
result = wangcai.get__tooth()
print(result)

运行程序，输出结果如下：

3、静态方法

静态方法的特点：

• 需要用 修饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象，也不需要传递实例对象（形参没有self /cls）
• 没有任何参数
• 静态方法也能够通过 对象 和 类 去调用

静态方法的使用场景:

• 当方法中 既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性、类方法、创建实例等）时，定义静态方法。
• 取消不需要的参数传递，有利于 减少不必要的内存占用和性能消耗

class Dog(object):
    @staticmethod   # 修饰器
    def info_print():
        print('这是一个静态方法……')

# 2.2 创建对象
wangcai = Dog()
# 2.3 调用静态方法：类 和 对象
wangcai.info_print()     # 用对象调用静态方法
Dog.info_print()         # 用类调用静态方法

6.私有成员

类的成员默认是公有成员，可以在类的外部通过类或对象随意地访问，这样显然不够安全。

为了保证类中数据的安全，Python 支持将公有成员改为私有成员，在一定程度上限制在类的外部对类成员的访问。

特殊方法

类中还包括两个特殊方法：构造方法 和 析构方法，这两个方法都是系统内置方法。

7.构造方法

在Python 中 __xx__ 的函数叫做魔法方法，指的是具有特殊功能的函数。

无参数构造方法

有参数构造方法

8.析构方法

多学一招：

9.封装

继承

10.单继承

• 参数 object : 是继承的意思，面向对象语言中都有这样一种特性。继承，指一个对象直接使用另一对象的属性和方法。

注意： 子类不会拥有父类的私有成员，也不能访问父类的私有成员。

11.多继承

答案： 默认第一个

12.重写

13.多态

14.运算符重载

---

实训案例

好友管理系统

"""
好友管理程序
增加
删除
备注
展示
分组
数据存储结构：['王五', '张三', '赵柳', {'家人': ['李四','刘备']},{'同事': ['李龙','张飞']}]
"""
"""
好友管理程序
增加
删除
备注
展示
分组
数据存储结构：['王五', '张三', '赵柳', {'家人': ['李四','刘备']},{'同事': ['李龙','张飞']}]
"""


class Friend:
    def __init__(self):
        self.friend_li = []

    def welcome(self):
        print("* * 欢迎使用好友管理系统 * * ")
        print("1：添加好友")
        print("2：删除好友")
        print("3：备注好友")
        print("4：展示好友")
        print("5：好友分组")
        print("6：退出")
        while True:
            option = input("请选择功能\n")
            # 添加好友
            if option == '1':
                self.add_friend()
            # 删除好友
            elif option == '2':
                self.del_friend()
            # 备注好友
            elif option == '3':
                self.modify_friend()
            # 展示好友
            elif option == '4':
                self.show_friend()
            # 分组好友
            elif option == '5':
                self.group_friend()
            elif option == '6':
                break

    #  添加好友
    def add_friend(self):
        add_friend = input("请输入要添加的好友：")
        self.friend_li.append(add_friend)
        print('好友添加成功')

    # 获取所有好友
    def get_all_friends(self):
        new_li = []
        for friend_li_elem in self.friend_li:
            # 判断元素类型
            if type(friend_li_elem) == dict:
                # 遍历字典
                [new_li.append(dict_elem_name) for dict_elem in friend_li_elem.values()
                 for dict_elem_name in dict_elem]
            else:
                new_li.append(friend_li_elem)
        return new_li

    # 获取所有分组及其好友
    def get_all_groups(self):
        groups = []
        for friend_li_elem in self.friend_li:
            if type(friend_li_elem) == dict:
                groups.append(friend_li_elem)
        return groups

    # 获取所有分组名称
    def get_all_groups_name(self):
        groups_name = []
        for dict_elem in self.get_all_groups():
            for j in dict_elem:
                groups_name.append(j)
        return groups_name

    #  删除好友（在分组中，不在分组中）
    def del_friend(self):
        if len(self.friend_li) != 0:
            del_name = input("请输入删除好友姓名：")
            # 删除的好友未分组
            if del_name in self.friend_li:
                self.friend_li.remove(del_name)
                print('删除成功')
            else:
                # 删除的好友在分组内
                if del_name in self.get_all_friends():
                    for group_data in self.get_all_groups():
                        for group_friend_li in group_data.values():
                            if del_name in group_friend_li:
                                group_friend_li.remove(del_name)
                                continue
                            print('删除成功')
        else:
            print('好友列表为空')

    #  备注好友
    def modify_friend(self):
        friends = self.get_all_friends()
        if len(friends) == 0:
            print('好友列表为空')
        else:
            before_name = input("请输入要修改的好友姓名：")
            after_name = input("请输入修改后的好友姓名：")
            if before_name in self.friend_li:
                friend_index = self.friend_li.index(before_name)
                self.friend_li[friend_index] = after_name
                print("备注成功")
            elif before_name not in self.friend_li:
                for friend_li_elem in self.friend_li:
                    if type(friend_li_elem) == dict:
                        for dict_elem in friend_li_elem.values():
                            if before_name in dict_elem:
                                modify_index = dict_elem.index(before_name)
                                dict_elem[modify_index] = after_name
                print('备注成功')
            # print('备注成功')

    #  展示好友 （选择展示所有好友，或分组）
    def show_friend(self):
        print("1.展示所有好友")
        print("2.展示分组名称")
        option_show = input("请输入选项：")
        groups = self.get_all_groups()
        friends = self.get_all_friends()
        if option_show == '1':
            # 展示所有好友
            if len(friends) == 0:
                print("当前没有任何好友")
            else:
                print(friends)
        elif option_show == '2':
            if len(friends) == 0:
                print("当前没有任何好友")
            else:
                if len(groups) == 0:
                    print("当前没有任何分组")
                else:
                    # 展示分组
                    for dict_groups in groups:
                        for group_name in dict_groups:
                            print(group_name)
                    is_show_group = input("是否展示组内好友：y/n\n")
                    if is_show_group == 'y':
                        show_group_name = input("请输入查看的分组名称")
                        for i in groups:
                            if show_group_name in i:
                                show_index = groups.index(i)
                                print(groups[show_index][show_group_name])

    #  分组好友
    def group_friend(self):
        create_group = input("是否创建新的分组y/n\n")
        friends = self.get_all_friends()
        if create_group == 'y':
            if len(friends) == 0:
                print("当前没有任何好友")
            else:
                # 请创建分组
                group_name = input("请输入分组名称：\n")
                group_name_li = list()
                # 展示当前好友
                print(friends)
                # 移动联系人到哪个组
                friend_name = input("请输入好友名称：\n")
                if friend_name in friends:
                    all_friend = []
                    for friend_li_elem in self.friend_li:
                        if type(friend_li_elem) == dict:
                            [all_friend.append(dict_friends) for dict_elem in friend_li_elem.values()
                             for dict_friends in dict_elem]
                        else:
                            all_friend.append(friend_li_elem)
                    if friend_name in all_friend:
                        group_name_li.append(friend_name)
                        self.friend_li.remove(friend_name)
                        # 构建字典： {组名称：分组列表}
                        friend_dict = dict()
                        friend_dict[group_name] = group_name_li
                        self.friend_li.append(friend_dict)
                    else:
                        print("请输入正确的名称")
                else:
                    print('请输入正确好友名称')
        elif create_group == 'n':
            # 显示当前的分组，将用户添加到指定的组
            current_groups = self.get_all_groups()
            print('当前分组:')
            for current_group in current_groups:
                for group_name in current_group:
                    print(group_name)
            add_group = input('请选择添加的组:\n')
            # 判断用户输入的组名是否在当前已存在的分组名中
            if add_group in self.get_all_groups_name():
                # 添加好友到指定的组
                add_name = input('请选择添加的好友名称：\n')
                # 判断用户输入的好友是否存在好友列表中
                if add_name in self.friend_li:
                    # 判断用户是否在其他组中
                    if add_name not in current_groups:
                        # 将好友添加到指定的组内
                        add_group_index = self.get_all_groups_name().index(add_group)
                        current_groups[add_group_index][add_group].append(add_name)
                else:
                    print('该好友已在其他分组中')
            else:
                print('请输入正确的组名')


if __name__ == '__main__':
    friend = Friend()
    friend.welcome()

生词本

程序设计思路：

login.py

import os

class User:
    # 功能展示
    def welcome(self):
        print("欢迎使用生词本")
        print("1.用户注册")
        print("2.用户登录")
        print("3.用户注销")
        print("4.修改密码")
        print("5.退出")
        while True:
            option = input("请选择功能（登录）\n")
            # 用户注册
            if option == '1':
                self.register()
            # 用户登录
            elif option == '2':
                self.login()
            # 注销
            elif option == '3':
                self.cancel()
            # 修改密码
            elif option == '4':
                self.modify()
            elif option == '5':
                print('谢谢使用')
                break

    # 将文件中的数据转换为字典
    def convert_data(self):
        info_li = []
        with open('./info.txt', mode='r+', encoding='utf8') as f:
            info_data = f.readlines()
            for i in info_data:
                info_dict = dict()
                # 替换{ 和 } 并去掉空格
                step_one = i.replace('{', '').replace('}', '')
                # 以冒号进行分隔
                step_two = step_one.split(':')
                # 拼接字典
                info_dict["姓名"] = step_two[1].split(',')[0].replace("'", '').strip()
                info_dict["密码"] = step_two[2].split(',')[0].replace("'", '').strip()
                # 保存到列表中
                info_li.append(info_dict)
        return info_li

    # 注册
    def register(self):
        if os.path.exists('./info.txt') is not True:
            with open('./info.txt', mode='w', encoding='utf8') as f:
                f.write('')
        # 用户名列表
        name_li = []
        info_li = self.convert_data()
        # 接收注册信息
        person_info = {}
        name = input("请输入注册用户名：\n")
        # 获取用户列名列表
        for i in info_li:
            name_li.append(i['姓名'])
        # 判断用户是否存在
        if name in name_li:
            print('用户已注册')
        else:
            password = input("请输入注册密码：\n")
            person_info['姓名'] = name
            person_info['密码'] = password
            # 写入注册信息
            with open('./info.txt', mode='a+', encoding='utf8') as info_data:
                info_data.write(str(person_info) + '\n')

    # 登录
    def login(self):
        from 第8章.生词本.recite import ReciteLogic
        if os.path.exists('./info.txt') is not True:
            print('当前无数据，请先注册')
        else:
            # 用户名列表
            name_li = []
            info_li = self.convert_data()
            name = input("请输入登录用户名：\n")
            password = input("请输入登录密码：\n")
            # 获取用户列名列表
            for i in info_li:
                name_li.append(i['姓名'])
            # 判断用户是否存在
            if name in name_li:
                # 获取修改用户的索引
                modify_index = name_li.index(name)
                # 判断密码是否正确
                if password == info_li[modify_index]['密码']:
                    print('登录成功')
                    ReciteLogic().welcome(name)
                else:
                    print('用户名或密码不正确')
            else:
                print('用户名或密码不正确')

    # 注销
    def cancel(self):
        if os.path.exists('./info.txt') is not True:
            print('当前无数据，请先注册')
        else:
            cancel_name = input("请输入注销的用户\n")
            cancel_password = input("请输入密码\n")
            # 用户名列表
            name_li = []
            info_li = self.convert_data()
            for i in info_li:
                name_li.append(i['姓名'])
            if cancel_name in name_li:
                # 获取注销用户的索引
                cancel_index = name_li.index(cancel_name)
                # 判断输入的密码是否正确
                if cancel_password == info_li[cancel_index]['密码']:
                    info_li.pop(cancel_index)
                    # 写入空数据
                    with open('./info.txt', mode='w+', encoding='utf8') as f:
                        f.write('')
                    for i in info_li:
                        with open('./info.txt', mode='a+', encoding='utf8') as info_data:
                            info_data.write(str(i) + '\n')
                    print('用户注销成功')
                else:
                    print('用户名或密码不正确')
            else:
                print('注销的用户不存在')

    # 修改密码
    def modify(self):
        if os.path.exists('./info.txt') is not True:
            print('当前无数据，请先注册')
        else:
            # 用户名列表
            name_li = []
            info_li = self.convert_data()
            modify_name = input("请输入用户名：\n")
            password = input("请输入旧密码：\n")
            # 获取用户列名列表
            for i in info_li:
                name_li.append(i['姓名'])
            # 判断用户是否存在
            if modify_name in name_li:
                # 获取修改密码用户的索引
                modify_index = name_li.index(modify_name)
                # 判断密码是否正确
                if password == info_li[modify_index]['密码']:
                    # 修改密码
                    new_password = input("请输入新密码\n")
                    info_li[modify_index]['密码'] = new_password
                    with open('./info.txt', mode='w+', encoding='utf8') as f:
                        f.write('')
                    for i in info_li:
                        with open('./info.txt', mode='a+', encoding='utf8') as info_data:
                            info_data.write(str(i) + '\n')
                else:
                    print("用户名或密码不正确")
            else:
                print("用户名或密码不正确")

if __name__ == '__main__':
    p = User()
    p.welcome()

recite.py 背诵

import os
class ReciteLogic:
    def __init__(self):
        self.user_name =''

    # 首页
    def welcome(self, name):
        self.user_name = name
        print('=' * 20)
        print(name + '的生词记录本')
        print('1.查看单词')
        print('2.背单词')
        print('3.添加新单词')
        print('4.删除单词')
        print('5.清空单词')
        print('6.退出')
        print('=' * 20)
        while True:
            option = input("请输入功能选项（生词本）：\n")
            if option == '1':
                self.see_words()
            elif option == '2':
                self.recite_words()
            elif option == '3':
                self.add_words()
            elif option == '4':
                self.del_words()
            elif option == '5':
                self.clear_words()
            elif option == '6':
                break

    # 文件中的数据转换为字典
    def convert_data(self):
        info_li = []
        with open('./' + self.user_name + '.txt', mode='r+', encoding='utf8') as f:
            info_data = f.readlines()
            for i in info_data:
                info_dict = dict()
                # 替换{ 和 } 并去掉空格
                step_one = i.replace('{', '').replace('}', '')
                # 以冒号进行分隔
                step_two = step_one.split(':')
                en = step_two[0].split(',')[0].replace("'", '').strip()
                zh = step_two[1].split(',')[0].replace("'", '').strip()
                info_dict[en] = zh
                # 保存到列表中
                info_li.append(info_dict)
        return info_li

    # 查看单词
    def see_words(self):
        if os.path.exists('./' + self.user_name + '.txt') is not True:
            print('当前无数据，请先添加单词')
        else:
            words_data = self.convert_data()
            if len(words_data)==0:
                print("生词本内容为空")
            else:
                #  读取文件数据
                with open('./' + self.user_name + '.txt', mode='r+', encoding='utf8') as f:
                    info_data = f.readlines()
                for i in info_data:
                    print(i.replace('{', '').replace('}', '').strip())

    # 背单词
    def recite_words(self):
        if os.path.exists('./' + self.user_name + '.txt') is not True:
            print('当前无数据，请先添加单词')
        else:
            words_data = self.convert_data()
            if len(words_data) == 0:
                print("生词本内容为空")
            else:
                words_li = self.convert_data()
                # 所有英文单词
                en_li = []
                for i in words_li:
                    for j in i.keys():
                        en_li.append(j)
                # 随机产生的英语单词
                for random_word in set(en_li):
                    # 获取该单词在en_li中的索引
                    random_word_index = en_li.index(random_word)
                    # 获取该单词所对应的中文
                    words_zh = words_li[random_word_index][random_word]
                    in_words = input("请输入" + random_word + '翻译' + '：\n')
                    # 判断翻译是否正确
                    if in_words ==words_zh:
                        print('太棒了')
                    else:
                        print('再想想')

    # 添加新单词
    def add_words(self):
        if os.path.exists('./' + self.user_name + '.txt') is not True:
            with open('./' + self.user_name + '.txt', mode='w+', encoding='utf8') as f:
                f.write('')
        word_data_dict = dict()
        new_words = input('请输入新单词：')
        # 判断输入的单词是否已存在
        words_li = self.convert_data()
        # 所有英文单词
        en_li = []
        for i in words_li:
            for j in i.keys():
                en_li.append(j)

        if new_words in en_li:
            print('添加的单词已存在')
        else:
            translate = input('请输入单词翻译：')
            if os.path.exists('./' + self.user_name + '.txt') is not True:
                with open('./' + self.user_name + '.txt', mode='w', encoding='utf8') as f:
                    f.write('')
            word_data_dict[new_words] = translate
            with open('./' + self.user_name + '.txt', mode='a+', encoding='utf8') as info_data:
                info_data.write(str(word_data_dict) + "\n")

    # 删除单词
    def del_words(self):
        if os.path.exists('./' + self.user_name + '.txt') is not True:
            print('当前无数据，请先添加单词')
        else:
            words_data = self.convert_data()
            if len(words_data) == 0:
                print("生词本内容为空")
            else:
                words_li = self.convert_data()
                # 所有英文单词
                en_li = []
                for i in words_li:
                    for j in i.keys():
                        en_li.append(j)
                del_words = input("请输入要删除的单词：\n")
                if del_words not in en_li:
                    print('删除的单词不存在')
                else:
                    # 获取要删除单词的索引
                    del_words_index = en_li.index(del_words)
                    # 删除单词
                    words_li.pop(del_words_index)
                    print('单词删除成功')
                    # 重新写入数据
                    with open('./' + self.user_name + '.txt', mode='w+', encoding='utf8') as f:
                        f.write('')
                    for i in words_li:
                        with open('./' + self.user_name + '.txt', mode='a+', encoding='utf8') as info_data:
                            info_data.write(str(i) + '\n')

    # 清空单词
    def clear_words(self):
        if os.path.exists('./' + self.user_name + '.txt') is not True:
            print('当前无数据，请先添加单词')
        else:
            with open('./' + self.user_name + '.txt', mode='w+', encoding='utf8') as f:
                f.write('')

人机猜拳游戏

思路：

guess_game.py

import random

class Player:
    def __init__(self):
        self.dict = {0: '剪刀', 1: '石头', 2: '布'}
    # 手势
    def gesture(self):
        player_input = int(input("请输入(0剪刀、1石头、2布:)"))
        return self.dict[player_input]
class AIPlayer(Player):
    play_data = []
    def ai_gesture(self):
        while True:
            computer = random.randint(0, 2)
            if len(self.play_data) >= 4:
                # 获取玩家出拳的最大概率
                max_prob = max(self.play_data, key=self.play_data.count)
                if max_prob == '剪刀':
                    return '石头'
                elif max_prob == '石头':
                    return '布'
                else:
                    return '剪刀'
            else:
                return self.dict[computer]

class Game:

    def game_judge(self):
        player = Player().gesture()
        AIPlayer().play_data.append(player)
        aiplayer = AIPlayer().ai_gesture()
        if (player == '剪刀' and aiplayer == '布') or \
                (player == '石头' and aiplayer == '剪刀') \
                or (player == '布' and aiplayer == '石头'):
            print(f"电脑出的手势是{aiplayer},恭喜，你赢了!")
        elif (player == '剪刀' and aiplayer == '剪刀') or \
                (player == '石头' and aiplayer == '石头') \
                or (player == '布' and aiplayer == '布'):
            print(f"电脑出的手势是{aiplayer},打成平局了！")
        else:
            print(f"电脑出的手势是{aiplayer},你输了，再接再厉！")
    def game_start(self):
        self.game_judge()
        while True:
            option = input("是否继续:y/n\n")
            if option=='y':
                self.game_judge()
            else:
                break

if __name__ == '__main__':
    g = Game()
    g.game_start()

自定义列表

custom_list.py

"""
from custom_list import MyList
add_demo = MyList(1,2,3,4,5)
print(add_demo+5)   每个元素都加5，并返回新的列表
"""

class MyList:
    def __isnumber(self, n):
        if not isinstance(n, (int, float, complex)):
            return False
        return True
    # 构造函数，进行必要的初始化
    def __init__(self, *args):
        for arg in args:
            if not self.__isnumber(arg):
                print('所有的元素必须是数字类型')
                return
        self.__value = list(args)
    def __str__(self):
        return str(self.__value)
    def __del__(self):
        del self.__value
    # 重载运算符+
    def __add__(self, num):
        if self.__isnumber(num):
            # 数组中所有元素都与数字num相加
            my_list = MyList()
            my_list.__value = [elem + num for elem in self.__value]
            return my_list
    # 重载运算符-
    # 数组中每个元素都与数字num相减，返回新数组
    def __sub__(self, num):
        if not self.__isnumber(num):
            print('所有的元素必须是数字类型')
            return
        my_list = MyList()
        my_list.__value = [elem - num for elem in self.__value]
        return my_list
    # 重载运算符*
    # 数组中每个元素都与数字num相乘，返回新数组
    def __mul__(self, num):
        if not self.__isnumber(num):
            print('所有的元素必须是数字类型')
            return
        my_list = MyList()
        my_list.__value = [elem * num for elem in self.__value]
        return my_list
    # 重载运算符/
    # 数组中每个元素都与数字num相除，返回新数组
    def __truediv__(self, num):
        if not self.__isnumber(num):
            print('所有的元素必须是数字类型')
            return
        my_list = MyList()
        my_list.__value = [elem / num for elem in self.__value]
        return my_list

demo.py

from . custom_list import MyList
add_demo = MyList(1,2,3,4,5)
print(add_demo+5)

阶段案例—银行管理系统

admin.py

class Admin:
    adminU = '1'  # 管理员的账号
    adpwd = '1'  # 管理员的密码

    def printAdminView(self):
        print("******************************************")
        print("***                                    ***")
        print("***                                    ***")
        print("***         欢迎登录银行系统            ***")
        print("***                                    ***")
        print("***                                    ***")
        print("******************************************")

    def printsysFunctionView(self):
        print("***********************************************")
        print("***                                         ***")
        print("***    1.开户(1)                2.查询(2)   ***")
        print("***    3.取款(3)                4.存款(4)   ***")
        print("***    5.转账(5)                6.锁定(6)   ***")
        print("***    7.解锁(7)                            ***")
        print("***                                         ***")
        print("***    退出(Q)                              ***")
        print("***                                         ***")
        print("***********************************************")

    def adminOption(self):
        adminInput = input("请输入管理员账户：")
        if self.adminU != adminInput:
            print("管理员账户输入错误......")
            return -1
        passwordInput = input("请输入密码：")
        if self.adpwd != passwordInput:
            print("输入密码有误......")
            return -1
        else:
            print("操作成功，请稍后......")
            return 0

atm.py

from user import User
from card import Card
import random


class ATM:
    def __init__(self, alluser):
        self.alluser = alluser

    def randomiCardId(self):  # 随机生成开户卡号
        while True:
            str_data = ''  # 存储卡号
            for i in range(6):  # 随机生成6位卡号
                ch = chr(random.randrange(ord('0'), ord('9') + 1))
                str_data += ch
            if not self.alluser.get(str):  # 判断卡号是否重复
                return str_data

    def creatUser(self):
        # 目标向用户字典中添加一个键值对（卡号、用户对象）
        name = input("请输入姓名:")
        Uid = input("请输入身份证号:")
        phone = input("请输入手机号:")
        prestMoney = float(input("请输入预存金额:"))
        if prestMoney <= 0:
            print("预存款输入有误，开户失败")
            return -1
        oncePwd = input("请输入密码：")
        passWord = input("请再次输入密码：")
        if passWord != oncePwd:
            print("两次密码输入不同......")
            return -1
        print("密码设置成功，请牢记密码:  %s " % passWord)
        cardId = self.randomiCardId()
        card = Card(cardId, oncePwd, prestMoney)  # 创建卡
        user = User(name, Uid, phone, card)  # 创建用户
        self.alluser[cardId] = user  # 存入用户字典
        print("您的开户已完成，请牢记开户账号: %s" % cardId)

    def checkpwg(self, realPwd):
        for i in range(3):
            psd2 = input("请输入密码：")
            if realPwd == psd2:
                return True
        print("密码输错三次，系统自动退出......")
        return False

    def lockCard(self):
        inptcardId = input("请输入您的卡号：")
        user = self.alluser.get(inptcardId)
        if not self.alluser.get(inptcardId):
            print("此卡号不存在...锁定失败！")
            return -1
        if user.card.cardLock:
            print("该卡已经被锁定，无需再次锁定！")
            return -1
        if not self.checkpwg(user.card.cardPwd):  # 验证密码
            print("密码错误...锁定失败！！")
            return -1
        user.card.cardLock = True
        print("该卡被锁定成功！")

    def searchUser(self, base=1):
        if base == 2:
            inptcardId = input("请输入转出主卡号：")
        elif base == 3:
            inptcardId = input("请输入转入卡号：")
        elif base == 1:
            inptcardId = input("请输入您的卡号：")
        user = self.alluser.get(inptcardId)
        # 如果卡号不存在，下面代码就会执行
        if not self.alluser.get(inptcardId):
            print("此卡号不存在...查询失败！")
            return -1
        if user.card.cardLock:
            print("该用户已经被锁定...请解卡后使用！")
            return -1
        if not self.checkpwg(user.card.cardPwd):  # 验证密码
            print("密码错误过多...卡已经被锁定，请解卡后使用！")
            user.card.cardLock = True
            return -1

        if not base == 3:  # 查询转入账户   不打印余额
            print("账户: %s   余额: %.2f  " %
                  (user.card.cardId, user.card.money))
        return user

    def getMoney(self):
        userTF = self.searchUser()
        if userTF != -1:
            if userTF.card.cardId != '':
                inptMoney = float(input("请输入取款金额:"))
                if inptMoney > int(userTF.card.money):
                    print("输入的金额大于余额，请先查询余额！")
                    return -1
                userTF.card.money = \
                    float(userTF.card.money) - inptMoney
                print("取款成功！  账户: %s   余额: %.2f  " %
                      (userTF.card.cardId, userTF.card.money))
        else:
            return -1

    def saveMoney(self):
        userTF = self.searchUser()
        if userTF != -1:
            if not userTF.card.cardLock == True:
                if userTF.card.cardId != '':
                    inptMoney = float(input("请输入要存入得金额:"))
                    if inptMoney < 0:
                        print("请输入正确金额")
                    else:
                        userTF.card.money += inptMoney
                        print("存款成功！  账户: %s   余额: %.2f  " %
                              (userTF.card.cardId, userTF.card.money))
        else:
            return -1

    def transferMoney(self):
        MasterTF = self.searchUser(base=2)
        if (MasterTF == -1):
            return -1
        userTF = self.searchUser(base=3)
        if (userTF == -1):
            return -1
        in_tr_Money = float(input("请输入转账金额："))
        if MasterTF.card.money >= in_tr_Money:
            str = input("您确认要继续转账操作吗（y/n）？：")
            if str.upper() == "Y":
                MasterTF.card.money -= in_tr_Money
                userTF.card.money += in_tr_Money
                print("转账成功！  账户: %s   余额: %.2f  " %
                      (MasterTF.card.cardId, MasterTF.card.money))
            else:
                print("转账失败，中止了操作")
        else:
            print("转账失败,余额不足！  账户: %s   余额: %.2f  " %
                  (MasterTF.card.cardId, MasterTF.card.money))

    def unlockCard(self):
        inptcardId = input("请输入您的卡号：")
        user = self.alluser.get(inptcardId)
        while 1:
            if not self.alluser.get(inptcardId):
                print("此卡号不存在...解锁失败！")
                return -1
            elif not user.card.cardLock:
                print("该卡未被锁定，无需解锁！")
                break
            elif not self.checkpwg(user.card.cardPwd):
                print("密码错误...解锁失败！！")
                return -1
                user.card.cardLock = False  # 解锁

            print("该卡 解锁 成功！")
            break

card.py

class Card:
    def __init__(self,cardId,cardPwd,money):
        self.cardId = cardId
        self.cardPwd = cardPwd
        self.money = money
        self.cardLock = False

user.py

class User:
    def __init__(self, name, id, phone, card):
        self.name = name
        self.id = id
        self.phone = phone
        self.card = card

银行系统.py

from admin import Admin
from atm import ATM
import time


class HomePage:
    def __init__(self):
        self.allUserD = {}  # 使用字典存储数据
        self.atm = ATM(self.allUserD)
        self.admin = Admin()  # 管理员开机界面

    def saveUser(self):
        self.allUserD.update(self.atm.alluser)
        print("数据存盘成功")

    def main(self):
        self.admin.printAdminView()
        resL = self.admin.adminOption()
        if not resL:
            while True:
                self.admin.printsysFunctionView()
                option = input("请输入您的操作：")
                if option not in ("1", "2", "3", "4", "5",
                                  "6", "7", "S", "Q", "q"):
                    print("输入操作项有误,请仔细确认！")
                    time.sleep(1)
                if option == "1":  # 开户
                    self.atm.creatUser()
                elif option == "2":  # 查询
                    self.atm.searchUser()
                elif option == "3":  # 取款
                    self.atm.getMoney()
                elif option == "4":  # 存储
                    self.atm.saveMoney()
                elif option == "5":  # 转账
                    self.atm.transferMoney()
                elif option == "6":  # 锁定
                    self.atm.lockCard()
                elif option == "7":  # 解锁
                    self.atm.unlockCard()
                elif option.upper() == "Q":
                    if not (self.admin.adminOption()):
                        self.saveUser()
                        print('退出系统')
                        return -1


if __name__ == "__main__":
    homepage = HomePage()
    homepage.main()