python面向对象

湫不啾啾捏

已于 2023-10-08 20:16:44 修改

阅读量51

点赞数

文章标签： python 开发语言

于 2023-10-07 20:05:27 首次发布

本文链接：https://blog.csdn.net/weixin_49210718/article/details/133647877

版权

一.面向对象

1. 对象的定义

什么是对象：

面向对象中的对象是指在程序中描述现实世界中的实体或概念的实体，它是类的一个实例。对象具有属性和行为，可以接收消息并执行相应的操作。

在生活中:
对象就是'特征'与'技能'的集合体
在程序中：
对象就是盛放'数据属性'和'功能'的容器

例如，我们可以创建一个名为“汽车”的类，它有属性如“车牌号码”、“品牌”、“型号”等，行为如“加速”、“刹车”、“转弯”等。在程序中，我们可以创建多个“汽车”对象，每个对象都有自己的车牌号码、品牌、型号等属性，并且可以执行加速、刹车、转弯等行为。

对象是面向对象编程的核心概念之一，它具有封装、继承和多态等特性，能够提高程序的可读性、可维护性和可扩展性。

什么是面向过程:

面向过程中核心是过程二字，过程就是先干什么、在干什么、最后干什么，就是机械式的思维方式

面向过程的优点：复杂的问题简单化，缺点：扩展性差

面向对象的优点：扩展性强，缺点：简单的问题复杂化

2. 面向对象编程

例：宝可梦之间的战斗：

def hero_date(name, lv, career, atk, hp):
    hero_dict={'name': name,
                    'lv': lv,
                    'career':career,
                   'atk': atk,
                   'hp': hp}

    return hero_dict



def hero1_date(name, lv, career, atk, hp):
    hero_dict1 = {'name': name,
                     'lv': lv,
                     'career': career,
                     'atk': atk,
                     'hp': hp}
    return hero_dict1


p1 = hero_date('沙奈朵', 100, 'evil spirit', 1900, 2000)
d1 = hero1_date('莱希拉姆', 100, 'dragon-fire', 1500, 2800)


def attack(hero_dict, hero_dict1):
    print(f"{hero_dict.get('name')}使用了月亮之力攻击了{hero_dict1.get('name')}！")
    if hero_dict1['career'] == 'dragon-fire':

        hero_dict1['hp'] -= hero_dict['atk']*2
        print(f"沙奈朵攻击了莱希拉姆！造成了{hero_dict.get('atk') *2}点伤害！效果拔群！ 莱希拉姆剩余血量:{hero_dict1.get('hp')}")
        if hero_dict1.get('hp') < 0:

            print(f"恭喜{hero_dict.get('name')}获得冠军！")
    else:
        print(f"沙奈朵攻击了莱希拉姆！造成了{hero_dict.get('atk')}点伤害!莱希拉姆剩余血量:{hero_dict1.get('hp')}")
        if hero_dict1.get('hp') < 0:
            print(f"恭喜{hero_dict.get('name')}获得冠军！")

        else:
            print(f"{hero_dict1.get('name')}使用了龙星群攻击了{hero_dict.get('name')}！")
            if hero_dict['career'] == 'evil spirit':
                hero_dict['hp'] -= 0
                print(f"{hero_dict1.get('name')}的攻击好像没什么效果......{hero_dict.get('name')}的血量剩余{hero_dict.get('hp')}")

            else:
                hero_dict['hp'] -= hero_dict1['atk']
                print(f"莱希拉姆攻击了沙奈朵！造成了{hero_dict1.get('atk')}点伤害！效果拔群！ {hero_dict.get('name')}剩余血量:{hero_dict.get('hp')}")

            if hero_dict.get('hp') > hero_dict1.get('hp'):
                print(f"恭喜{hero_dict1.get('name')}获得冠军！")
attack(p1, d1)

2. 类的定义与对象的产生

对象就是特征与技能的结合体，类就是一系相似功能的结合体。

在程序中，先有类，才能调用

语法格式：class+类名

命名遵循变量名的命名方式

定义类：
class Hero（）：##（类名）
"""在定义对象时，可以不用添加括号，但是建议加上"""

3. 定制属性

class Hero():
    hero = 'k1999'

    def __init__(self, name, age, gender, atk):
        self.name = name
        self.age = age
        self.gender = gender
        self.atk = atk
        return

hero1 = Hero('kiki', 19, 'male', 20000)
hero2 = Hero('coco', 22, 'female', 19000)
print(hero2.__dict__)
print(hero1.__dict__)

4.属性的查找顺序

1. 类属性的查找

class Hero:
    hero = 'k1999'

    def __init__(self, name, age, gender, atk):
        self.name = name
        self.age = age
        self.gender = gender
        self.atk = atk
        return

hero1 = Hero('kiki', 19, 'male', 20000)
hero2 = Hero('coco', 22, 'female', 19000)
print(hero2.__dict__)
print(hero1.__dict__)

print(Hero.hero)    #k1999

2.增加

Hero.hero = 'k2000'
print(Hero.hero)  

："""打印结果为：{'__module__': '__main__', 'hero': 'k1999', '__init__': <function Hero.__init__ at 0x000001838237B550>, '__dict__': <attribute '__dict__' of 'Hero' objects>, '__weakref__': <attribute '__weakref__' of 'Hero' objects>, '__doc__': None, 'L1': 'k2000'}"""

3.修改

Hero.hero = 'k2111'
print(Hero.hero)    #k2111

4.删除

del Hero.L1
print(Hero.__dict__)# {'__module__': '__main__', 'hero': 'k2111', '__init__': <function Hero.__init__ at 0x000001C6C099B1F0>, '__dict__': <attribute '__dict__' of 'Hero' objects>, '__weakref__': <attribute '__weakref__' of 'Hero' objects>, '__doc__': None}

对象的查添改删

1. 查看：

如果你使用的是点语法，那么，对象查找属性的时候，先从对象自己的名称空间中查找，如果找不到，就去产生这个对象的类中查找

class Hero:
    hero = 'k1999'

    def __init__(self, name, age, gender, atk):
        self.name = name
        self.age = age
        self.gender = gender
        self.atk = atk
        return

hero1 = Hero('kiki', 19, 'male', 20000)
hero2 = Hero('coco', 22, 'female', 19000)

print(hero1.atk)    #20000

print(hero1.name)   #kiki

2. 添加：

class Hero:
    hero = 'k1999'

    def __init__(self, name, age, gender, atk):
        self.name = name
        self.age = age
        self.gender = gender
        self.atk = atk
        return

hero1 = Hero('kiki', 19, 'male', 20000)
hero2 = Hero('coco', 22, 'female', 19000)
hero3 = 9
print(hero1.atk)    #20000

print(hero1.name)   #kiki

print(hero3)

3. 修改和添加一样，如果没有则添加，如果有则修改

4. 删除

class Hero:
    hero = 'k1999'

    def __init__(self, name, age, gender, atk):
        self.name = name
        self.age = age
        self.gender = gender
        self.atk = atk
        return

hero1 = Hero('kiki', 19, 'male', 20000)
hero2 = Hero('coco', 22, 'female', 19000)
hero3 = 9
del hero2.name
print(hero1.atk)    #20000

print(hero2.__dict__)   #{'age': 22, 'gender': 'female', 'atk': 19000}

5. 绑定方法

当我们定义完类之后就可以在类里面去写一些方法，在外部直接调用内部的话是不能调用的，所以我们需要看绑定给谁，谁绑定就是谁调用

class Student:
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def type_info(self, username, password):
        print("name:%s,age:%s,gender:%s,username:%s,password:%s" % (self.name, self.age,
                                                                  self.gender, username, password))

stu = Student('kiki', 19, 'male')
Student.type_info(stu, 'kiki', 123)

6.非绑定方法（静态方法static）

当函数不需要对象和不需要类时，就可以使用静态方法，这样的话使用类可以调用，对象也可以调用，而且不需要传参数。

class Student:
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        self.id = id


    @staticmethod
    def check_id():
        import uuid
        return uuid.uuid4()

    def func(self,):
        pass

stu = Student('kiki', 18, 'male')
print(stu.id)
print(stu.check_id())

6. 隐藏属性

隐藏属性的目的：当我们做修改时，我们可以修改对内的属性，从而更好地去限制操作，然后再类的内部做个开放的公共接口，对外部返回内部的隐藏值。

"""修改学习名称示例"""

class Student:
    __school = 'SH'

    def __init__(self, name, age, gender):
        self.__name = name
        self.age = age
        self.gender = gender

    def __func(self):
        print('from func')

    def get__school(self):
        return self.__school


    def set_school(self, n):

        if type(n) is str:
            Student.__school = n
        else:
            print('请输入字符串类型')


stu = Student('kiki', 18, 'male')
stu.set_school('n')
res = stu.get__school()
print(res)

7. propert装饰器

它是内置的一个装饰器，用来伪装属性:

"""修改学习名称示例"""
class Student:
    __school = 'SH'
    __hero = 'co'

    def __init__(self, name, age, gender):
        self.__name = name
        self.age = age
        self.gender = gender

    def __func(self):
        print('from func')

    @property
    def school(self):
        return self.__school
    # 对内进行修改

    @school.setter
    def school(self, n):

        if type(n) is str:
            Student.__school = n
        else:
            print('请输入字符串类型')
    # 对内进行删除

    @school.deleter
    def school(self):
        print('删除执行')
        del Student.__school

stu = Student('kiki', 19, 'male')
stu.school = 'BJ'
print(stu.school)

练习题：计算人体的bim值，已知计算公式为体重/（身高平方）

class people:

    def __init__(self,height, wight):

        self.height = height
        self.wight = wight

    @property
    def bim(self)
        return self.wight / (self.height**2)

stu = people(1.7, 60)
print(stu.bim)

湫不啾啾捏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
python面向对象

什么是对象：面向对象中的对象是指在程序中描述现实世界中的实体或概念的实体，它是类的一个实例。对象具有属性和行为，可以接收消息并执行相应的操作。在生活中:对象就是'特征'与'技能'的集合体在程序中：对象就是盛放'数据属性'和'功能'的容器例如，我们可以创建一个名为“汽车”的类，它有属性如“车牌号码”、“品牌”、“型号”等，行为如“加速”、“刹车”、“转弯”等。在程序中，我们可以创建多个“汽车”对象，每个对象都有自己的车牌号码、品牌、型号等属性，并且可以执行加速、刹车、转弯等行为。
复制链接

扫一扫