文章目录（PS：觉得不错请点赞收藏支持一下）

一、面向对象

1.1 理解

  1. 官方语言
    面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。
  2. 生活举例

买电脑

  • 面向过程：查询电脑参数信息、货比三家比较机型、了解店铺活动售价打折信息、砍价、下单、收快递、开机验货、确认收货。
  • 面向对象：找秘书帮我买、收电脑。(是不是觉得很 easy 😀 ，当你敲代码时就会痛苦面具了😐)
  1. 总结
    面向对象将编程当成是一个事物，对外界来说，事物是直接使用，不管他内部的情况，而编程就是设置事物能够做什么事。

1.2 类和对象

  1. 类
  • 官方语言
    类是对一系列具有相同 特征 和 行为 的事物的统称，是一个抽象的概念，不是真实存在的事物。
    • 特征也叫属性，通俗的说就是静态的特点
    • 行为也叫方法，通俗的说就是动态的特点
  • 生活举例
    造大炮时设计师出的设计图，它就可以叫作成一个抽象的 类。
  1. 对象

  • 官方语言
    对象是类创建出来的真实存在的事物，这句话没啥毛病，通俗的说就是万物皆为对象。

    注意： 在开发中，先有类，再有对象。

二、定义类 和 创建对象

  1. 定义类
  • 语法格式 
class 类名():
	代码
  • 举例 
class Cat():
    def caatch_mouse(self):
        print('我是抓老鼠的小行家')
  1. 创建对象(又名实例)
  • 语法格式 
对象名 = 类名()
  • 举例 
class Cat():
    def caatch_mouse(self):
        print('我是抓老鼠的小行家')

# 创建对象
cat1 = Cat()
print(cat1)  # <__main__.Cat object at 0x000002397D090FD0>
# 对象调用实例方法
cat1.caatch_mouse()  # 我是抓老鼠的小行家
创建对象的过程也叫实例化对象
  1. self

self 指的是调用该函数的对象。

class Cat():
    def caatch_mouse(self):
        print(self)
# 创建对象
cat1 = Cat()
print(cat1)  # <__main__.Cat object at 0x000002397D090FD0>
# 对象调用实例方法
cat1.caatch_mouse()  # <__main__.Cat object at 0x00000178EFBE0FD0>
打印输出对象和 self 得到的结果一致的，说明对 self 的解释成立。

三、对象属性

开头讲了属性即是特征可还记得😋，比如： 猫的身长，重量，毛色…

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

  1. 类外面添加和获取对象属性
  • 语法格式 
对象名.属性名 = 值
  • 举例 
class Cat():
    def caatch_mouse(self):
        print(self)

# 创建对象
cat1 = Cat()
cat1.name = '小白'  # 添加对象属性
print(f'小猫的名字叫:{
     cat1.name}')  # 小猫的名字叫:小白
  1. 类里面获取对象属性
  • 语法格式 
self.属性名
  • 举例 
class Cat():
    def cat_name(self):
        print(f'小猫的名字叫:{
     self.name}')

# 创建对象
cat1 = Cat()

# 添加对象实例属性
cat1.name = '小白'

# 对象调用实例方法
cat1.cat_name()  # 小猫的名字叫:小白

四、魔术方法

在 Python 中， 指的是具有特殊功能的函数。

4.1 init()

作用： 初始化对象。

  1. 不带参数的 
class Cat(object):
    """ 1. __init__ 叫做魔术方法，此方法不需要通过对象调用，而是在创建对象时自动调用 2. __init__ 方法存在于每个类中，下面是对此方法重写 3. 创建对象时的 Cat() 代码其实就是对 __init__ 方法的调用 4. __init__ 方法可以让我们为类添加属性，而且通过参数，可以根据 Cat() 类，创建不同的对象 5. self 指的不是类，而是当前创建的对象 """
    def __init__(self):
        self.name = 'Tome'
        self.gender = '雌性'
        self.varieties = '美短'

# 创建对象
cat1 = Cat()
print(cat1.name,cat1.gender,cat1.varieties)  # Tome 雌性 美短
  1. 带参数的 
class Cat(object):
    def __init__(self,name,gender,varieties):
        self.name = name
        self.gender = gender
        self.varieties = varieties
        print(f'name:{
     name},gender:{
     gender},varieties:{
     varieties}')
        
cat1 = Cat('Tome','雌性','美短')  # name:Tome,gender:雌性,varieties:美短

4.2 str()

class Cat(object):
    """ 没有 __str__ 魔术方法时，当使用 print 输出对象时调用 默认情况下，会输出对象的内存地址 可以重写此方法,方法中必须有返回值，返回值的内容是 print 对象时输出的内容 """
    def __init__(self, name, gender, varieties):
        self.name = name
        self.gender = gender
        self.varieties = varieties
    def __str__(self):
        return f'猫咪的姓名:{
     self.name},性别:{
     self.gender},品种:{
     self.varieties}'

cat1 = Cat('Tome','雌性','美短') 
print(cat1)  # 猫咪的姓名:Tome,性别:雌性,品种:美短

4.3 del()

作用：删除对象时自动执行的魔术方法

class Cat(object):

    def __del__(self):
        print('删除了对象')

cat1 = Cat()
del cat1  #运行结果: 删除了对象

五、任务清单

  1. 创建 Computer 类 
""" 1) 类的成员 属性： 品牌 硬盘类型 操作系统 内存大小 CPU 显卡 屏幕大小 2) 方法： 开机 关机 注销 登录 """
class Computer():
    def __init__(self,brand,HddType,os,RAM,CPU,GPU,size):
        self.brand = brand
        self.HddType = HddType
        self.os = os
        self.RAM = RAM
        self.CPU = CPU
        self.GPU = GPU
        self.size = size
    def PowerOn(self):
        print('开机')
    def ShutDown(self):
        print('关机')
    def LogOff(self):
        print('注销')
    def SignIn(self):
        print('登录')
    def __str__(self):
        return f'品牌:{
     self.brand},硬盘类型:{
     self.HddType},操作系统:{
     self.os},内存大小:{
     self.RAM},CPU:{
     self.CPU},显卡:{
     self.GPU},屏幕大小:{
     self.size}'

computer1 = Computer('苹果','固态','ios','1T','Apple M1','Intel HD 5300','13英寸')
print(computer1)   # 品牌:苹果,硬盘类型:固态,操作系统:ios,内存大小:1T,CPU:Apple M1,显卡:Intel HD 5300,屏幕大小:13英寸
computer1.PowerOn()  # 开机
computer1.ShutDown() # 关机
computer1.LogOff()  # 注销
computer1.SignIn()  # 登录
  1. 运用面向对象的方法完成买手机的程序 
""" 不同的人根据不同需求购买不同手机 定义类 消费者类 属性 月收入 方法 购买：根据手机的价格、以及自己的收入，决定是否购买某款手机，符合要求输出“购 买”，不符合要求，输出“不购买“。是否购买的具体算法如下： 月收入10000以上，购买8000以内的手机 月收入6000-100000，购买4000-8000的手机 月收入3000-6000，购买2000-4000的手机 月收入4000一下，购买2000元一下的手机 手机类 属性：价格 实现购买手机过程 创建4个消费者，收入处于不同档次 创建4部手机，价格处于不同档次 将不同的手机对象传递给不同的消费者对象的”购买“方法，进行测试 """
class Phone():
    def __init__(self,price):
        self.price = price
class user():
    def __init__(self,income):
        self.income = income
    def buy(self,phone):
        if self.income > 10000 and phone < 8000:
            print('购买')
        elif 6000 < self.income <= 10000 and 4000 < phone <=8000:
            print('购买')
        elif 3000 < self.income <= 6000 and 2000 <= phone <= 4000:
            print('购买')
        elif self.income < 4000 and phone < 2000:
            print('购买')
        else:
            print('不购买')

u1 = user(20000)
u2 = user(5000)

p1 = Phone(8000)
p2 = Phone(5000)

u1.buy(p1.price)  # 不购买
u1.buy(p2.price)  # 购买
u2.buy(p1.price)  # 不购买
u2.buy(p2.price)  # 不购买
  1. 还记的以前写过的 猜拳 小游戏吗？现在将其改成 面向版本 
""" 定义类 三个类：玩家、电脑和规则类 电脑类 属性：name，值永远为”电脑“ 方法：出拳：包袱、锤子和剪刀随机出一个 玩家类 属性：name，玩家的名字，这个由用户通过控制台输入 方法：出拳：包袱、锤子和剪刀，由用户输入 规则类 方法：评判，作用是根据玩家和电脑出拳的结果判断输赢并将此结果输出 """
import random
class computer():
    def __init__(self):
        self.name = '电脑'
    def pk(self):
        return random.randint(1, 3)
class player():
    def __init__(self,name):
        self.name = name
    def pk(self,skill):
        return skill
class rule():
    def judge(self,res_computer,res_player):
        print(f'玩家出的是{
     res_player},电脑出的是{
     res_computer}')
        if (res_computer == 1 and res_player == 3) or (res_computer == 2 and res_player == 1) or (res_computer == 3 and res_player == 2):
            print(f'{
     computer().name}赢')
        elif res_computer == res_player:
            print('平局')
        else:
            print(f'{
     p1.name}赢')

while True:
    name = input('输入玩家姓名:')
    skill = int(input(""" 玩家请出拳: 1:石头 2:包袱 3:剪刀 """))
    p1 = player(name)
    res1 = p1.pk(skill)

    c1 = computer()
    res2 = c1.pk()

    r1 = rule()
    r1.judge(res2, res1)

# 运行结果:
输入玩家姓名:张三

    玩家请出拳:
    1:石头
    2:包袱
    3:剪刀
    2
玩家出的是2,电脑出的是3
电脑赢
输入玩家姓名:小明

    玩家请出拳:
    1:石头
    2:包袱
    3:剪刀
    3
玩家出的是3,电脑出的是3
平局
输入玩家姓名:小王

    玩家请出拳:
    1:石头
    2:包袱
    3:剪刀
    2
玩家出的是2,电脑出的是1
小王赢