面向过程和面向对象的对比？

面向对象

面向对象两个重要概念： => class（类）、实例

类：具有相同属性或方法的对象的集合

属性(变量)：编号、位置、余额

方法（函数）：查询余额，转帐功能，取钱，存钱

实例: 实实在在存在的东西（具体的某一个物品）

实例属性和类属性：

一、定义一个简单的ATM机系统的类（属性、方法、实例）

二、使用paramiko类来创建一个ssh连接（理解：类、实例、属性、方法）

类的使用：（类、实例、属性、方法的使用）

self是什么？

类的init方法（实例初始化）

init方法中的参数

ATM系统 - 面向对象实验

ATM系统代码一：

ATM系统代码二：

面向过程和面向对象的对比？

面向过程编程 => 如何实现这个功能，侧重点在过程（函数（关注：怎么做））

面向对象编程 => 谁在做这件事（类（关注：谁在做什么））

面向过程编程是一种以过程为中心的编程范式。它将程序组织为一系列的函数或过程，每个函数都对应一个特定的任务，通过依次调用这些函数来完成程序的执行。面向过程编程注重解决问题的步骤和流程，强调解决问题所需要的算法和数据结构。

面向对象编程是一种以对象为中心的编程范式。它将程序组织为一组相互作用的对象，每个对象都有自己的状态（属性）和行为（方法）。对象之间通过消息传递来实现交互和协作，通过定义类来创建对象的具体实例。面向对象编程注重将真实世界的概念和关系映射到代码结构中，强调封装、继承和多态等特性。

ATM为例 => 可以用来查询余额，转帐功能，取钱，存钱...

面向过程：查询余额，转帐功能，取钱，存钱 => 面向过程

面向对象： ATM能实现什么功能

面向对象

编程方式：面向过程 --》侧重点：如何做

面向对象 --》侧重点：谁来做（把多个属性(变量)和方法(函数)封装到一个对象中）

实例.属性 or 实例.方法() 来实现面向对象的编程

面向对象两个重要概念： => class（类）、实例

类：具有相同属性或方法的对象的集合

类是对具有相似特征和行为的对象进行抽象的模板。它定义了对象的属性（成员变量）和行为（方法）。可以将类看作是生成对象的蓝图或模板。

属性(变量)：编号、位置、余额

方法（函数）：查询余额，转帐功能，取钱，存钱

实例: 实实在在存在的东西（具体的某一个物品）

实例方法： def _init_(self): pass (初始化实例)

def save(self): pass

实例属性和类属性：

实例属性：每个实例独有的属性，每个实例的属性值都不一样

类属性：所有实例共用的一个属性（所有实例的这个属性如果都相同，可以定义成类属性）

一、定义一个简单的ATM机系统的类（属性、方法、实例）

class ATM():
    # 类属性（所有实例都共用的）
    bank = "中国银行"

    # 初始化函数（每个实例的数据）
    # 初始化了三个数据 balance, no, location => 形式参数
    # self => 创建的这个实例
    def __init__(self, balance, no, location):
        # 实例属性（每个实例都有属性自己的值）
        self.balance = balance
        self.NO = no
        self.location = location

     # 实例方法
    def store_money(self, money):
        pass

# 生成一台ATM机 --》实例化 --》生成实例（某一个具体的对象）
atm1 = ATM(10000, "No.0001", "湖南长沙农大路农大支行")
atm2 = ATM(10000, "No.0002", "湖南长沙农大路农大支行")
# 打印实例的属性
print(atm1.NO)
print(atm1.location)

二、使用paramiko类来创建一个ssh连接（理解：类、实例、属性、方法）

#安装paramiko类 >pip install paramiko
import paramiko
# 实例化SSH连接
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname="192.168.2.198", port="22", username="root", password="123456")
stdin, stdout, sdterr = ssh_client.exec_command("cd /bin;pwd")
# 这些返回的信息，只能read一次
print(stdout.read().decode("utf-8"))
print(dir(ssh_client))
ssh_client.close()

# with => 退出with语句块的时候，做一些清理工作
with paramiko.SSHClient() as ssh_client:
    ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh_client.connect(hostname="192.168.2.198", port="22", username="root", password="123456")
    stdin, stdout, sdterr = ssh_client.exec_command("cd /bin;pwd")
    # 这些返回的信息，只能read一次
    print(stdout.read().decode("utf-8"))

类的使用：（类、实例、属性、方法的使用）

实例化：atm1 = ATM(参数列表)

属性/方法的查找过程：1、先查找自身实例是否有这个属性

2、如果没有，再去类中查找

3、如果类中没有、去父类中查找

类/实例：可以给他动态的添加和删除属性的方法

类属性的使用：atm1.bank = "newdata" -->给实例添加了一个bank属性

user1.user_dict[username][balance] = "newdata" 修改类属性user_dict字典的balance的值

# 封装性
class ATM():
    #类属性(所有的实例都共有)
    bank = "中国银行"

    # 定义初始化函数(里面定义的是每个实例的数据)
    # self--> 创建这个实例
    def __init__(self, balance, no, location):
        #初始化了三个数据 --> 形式参数
        #实例属性（每个实例都有属性自己的值） 着三个属性都是实例属性
        self.balance = balance
        self.NO = no
        self.location = location

    #定义的实例方法
    def store_money(self, money):
        pass

atm1 = ATM(1000, "NO.0001", "湖南长沙...")
atm1.store_money(money=1000)
atm2 = ATM(10000, "NO.0002", "湖南长沙...")

# 查看已经有的属性，调用存在的方法
print(atm1.location)
# 属性和方法查找的过程
# 1.去查找实例本身是否有这个属性
# 2.去类上查找属性
# 3.去父类上查找
print(atm1.bank)

# 修改属性(修改的是实例上的location属性)
# 修改实例属性，只影响实例的本身
atm1.location = "湖南农业大学"

print(atm1.location)  #湖南农业大学
print(atm2.location)  #湖南长沙...

# 用实例修改类属性
# 打印：实例
atm1.bank = "中国银行长沙分行"
print(atm1.bank)   #中国银行长沙分行   #atm1是自己创建了一个新的bank类属性，并给他赋值
print(atm2.bank)   #中国银行     #atm2是调用了ATM类中的bank类属性

#实例/类可以动态添加属性或方法
atm1.test = "这是一个测试数据"
print(atm1.test)  #这是一个测试数据
# print(atm2.test)  #报错，因为ATM类中不存在test类属性

ATM.bank = "new中国银行长沙分行"
print(atm1.bank)  #中国银行长沙分行
print(atm2.bank)  #new中国银行长沙分行

# 实例化一个atm3
# 创建atm3.bank
# atm3.bank
atm3 = ATM(1000,"N0.0003", "湖南农业大学")
print(atm3.bank)
print(dir(atm3))       #可以查看实例的选项
print(atm1.__dict__)   #可以查看到实例里面的值
print(atm2.__dict__)

self是什么？

self => 表示的是实例本身（用于表示当前对象的引用），通过 self，你可以访问对象的属性和调用对象的方法。

谁调用这个方法，self表示的就是谁。

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

    # self参数名可以改成其他的名字，一般会约定俗成的给self
    def info(this):
        print("this is ", this.name)

    def count(self, num):
        print("this is ", num)

# 为什么这里会多一个self参数
# self => 表示的是实例本身
a1 = A("a1_instance")
a1.info()   # A.info(a1)  # a1 => self
a1.count(1) # A.count(a1, 1)

类的init方法（实例初始化）

__init__函数的使用:可有可无
__init__函数什么情况下需要？
1. 实例化对象的时候，不需要为这个实例赋单独的值，可以省略__init__函数
2. 如果需要单独赋值，就将参数传递给__init__函数
3. self.实例属性 = 形参的名字

4. 实例化的时候：类名(init函数中对应的参数) -> 不包含self

init方法中的参数

如 ATM（1000, "NO.0001", "nongda"） -->就是将参数传递给初始函数

用于创建实例的方法会将参数传递给_init_函数

"""
@author: wy
@file: 三创购物系统-面向对象.py
@time: 2023/7/24 11:35
加载用户信息、加载商品信息、登录、注册、展示商品信息...
"""

class A():
    pass

# __init__函数的使用:可有可无
# __init__函数什么情况下需要？
# 1. 实例化对象的时候，不需要为这个实例赋单独的值，可以省略__init__函数
# 2. 如果需要单独赋值，就将参数传递给__init__函数
# 3. self.实例属性 = 形参的名字
# 4. 实例化的时候： 类名(init函数中对应的参数) -> 不包含self
class User():pass


class ShoppingSystem():
    LOGIN_MAX = 3

    def __init__(self, goods_dict, user_dict):
        # 根据传递过来的参数，赋值给实例
        self.goods_dict = goods_dict
        self.user_dict = user_dict

    def login(self, username, password):
        if username in self.user_dict and \
            password == self.user_dict[username]["password"]:
            print("登录成功")
        else:
            print("登录失败")

    def regist(self, username, password, re_password):
        pass

    def get_carts_list(self):
        # 如果用户登录了才能展示
        pass

user_dict = {
    "root":{"password":"123456", "balance":"100"},
}
goods_dict = {}
sc_shoopingsystem = ShoppingSystem(goods_dict,user_dict)
print(sc_shoopingsystem.user_dict)
print(sc_shoopingsystem.goods_dict)
sc_shoopingsystem.login("root", "123456")

ATM系统 - 面向对象实验

ATM => 查询余额，取钱，存钱...

ATM系统代码一：

class User():
    user_dict = {
        "root": {"password": "123456", "balance": "100"},
    }

    def __init__(self, username, password):
        # auth => 当前登录状态False未登录
        self.auth = False
        self.login(username, password)

    def login(self, username, password):
        # self.user_dict 通过实例查询类属性 => ok .注意！如果是修改的话就不行了
        if username in self.user_dict and \
                password == self.user_dict[username]["password"]:
            self.auth = True
            self.username = username
            self.password = password
            self.balance = int(self.user_dict[username]["balance"])
            print(f"欢迎您！{self.username}")

    # 数据必须需要回收否则会导致数据无法更新，而写入数据库的数据就还是原数据
    def logout(self):
        self.auth = False
        self.user_dict[self.username]["balance"] = self.balance
        del self.username
        del self.password
        del self.balance


# 定义一个`中国银行ATM`的类
class ATM():
    # 类属性（所有实例都共用的）
    bank = "中国银行"

    # 初始化函数（每个实例的数据）
    # 初始化了三个数据 balance, no, location => 形式参数
    # self => 创建的这个实例
    def __init__(self, balance, no, location):
        # 实例属性（每个实例都有属性自己的值）
        self.balance = balance
        self.NO = no
        self.location = location

    #存钱
    def store_money(self):
        money = int(input("请输入需要存取的数额:"))
        self.balance += money
        print(f"存钱成功，您当前的余额为:{self.balance}")

    #取钱
    def draw_money(self):
        money = int(input("请输入需要取走的数额:"))
        if self.balance >= money:
            self.balance -= money
            print(f"取钱成功，余额为{self.balance}")
        else:
            print("您的余额不足")

    # 查看余额
    def get_balance(self):
        print(f"您当前的余额为:{self.balance}")

    def login(self):
        """登录"""
        username = input("请输入用户名：")
        password = input("请输入密码：")
        # 实例化一个用户
        user = User(username, password)
        if user.auth:
            self.current_user = user

    def logout(self):
        """退出"""
        self.current_user.logout()
        self.current_user = None


    def start(self):
        choice_func = {"1": self.get_balance,
                     "2": self.store_money,
                     "3": self.draw_money,
                     "4": self.logout}
        # 当前没有用户登录 ：None，登录了，就是当前用户实例
        self.current_user = None
        while True:
            if self.current_user:
                choice = input("请输入您的操作(1、查询余额 2、存钱 3、取钱 4、退出系统):\n")
                choice_func[choice]()
                if choice == "4":
                    print("退出系统！")
                    break
            else:
                print("请登录ATM系统！")
                self.login()

atm = ATM(1000, "NO.0001", "湖南长沙...")
atm.start()

ATM系统代码二：


class ATM():
    #类属性(所有的实例都共有)
    bank = "中国银行"
    user_dict = {
        "root": {"password": "123456", "balance": "1000"}
    }

    # 定义初始化函数(里面定义的是每个实例的数据)
    # self--> 创建这个实例
    def __init__(self, balance, no, location):
        #初始化了三个数据 --> 形式参数
        #实例属性（每个实例都有属性自己的值） 着三个属性都是实例属性
        self.balance = balance
        self.NO = no
        self.location = location
        # auth => 当前登录状态False未登录
        #self.auth = False


    def login(self, username, password):
        if username in self.user_dict and \
            password == self.user_dict[username]["password"]:
            print("登录成功！")
            return True
        else:
            print("登录失败,请重新输入账号密码！")

    #定义的实例方法
    #查看余额
    def get_balance(self):
        print(f"您当前的余额为:{self.balance}")

    #存钱
    def store_money(self, money):
        self.balance += money
        print(f"存钱成功，您当前的余额为:{self.balance}")

    #取钱
    def draw_money(self, money):
        if self.balance >= money:
            self.balance -= money
            print(f"取钱成功，余额为{self.balance}")
        else:
            print("您的余额不足")


atm1 = ATM(1000, "NO.0001", "湖南长沙...")

# 操作系统
def system_op():
    while True:
        flag = input("请输入您的操作(1、存钱 2、取钱 3、查询余额 4、退出系统):")
        if flag == "1":
            money = input("请输入需要存取的数额:")
            atm1.store_money(int(money))
        elif flag == "2":
            money = input("请输入需要去出的数额:")
            atm1.draw_money(int(money))
        elif flag == "3":
            atm1.get_balance()
        else:
            print("退出系统！")
            break

#设置变量用于判断使用
judge = False

while True:
    #登录界面
    option = input("请输入你的选择（1、登录 2、注册 3、退出系统）:\n")
    if option == "1":
        username = input("请输入用户名：")
        password = input("请输入密码：")
        judge = atm1.login(username, password)
    elif option == "2":
        pass
    else:
        print("退出系统！")
        break

    if judge:
        system_op()
        break