定义类:
在python中定义类使用关键字class,
class 类名:
#在class的缩进中定义类的属性和方法
def 方法名(self): #方法的本质是函数
pass
创建对象(实例化对象)
在代码中,对象是由类创建的.
类名() #就是创建对象
# 一般使用变量将创建的对象保存起来
变量 = 类名() #一般将这个变量称为是对象,本质,变量中保存的是对象的引用地址.
调用类中的方法
由类创建的对象,可以调用类中的方法
--语法
对象.方法名()

class Cat:

    def eat(self):
        """吃鱼的方法"""
        print('小猫爱吃鱼')

    def drink(self):
        """喝水的方法"""
        print('小猫要喝水')


# 创建对象
tom = Cat()
# 通过对象 调用类中的方法
tom.eat()
tom.drink()

self参数:

从函数的语法上来看,self是形参,名字可以是任意的变量名,只是我们习惯性叫self;
特殊点:self是一个普通的参数,按照函数的语法,在调用的时候,必须传递实参值,原因是python解释器自动的将调用这个方法的对象作为参数传递给self,所以self就是调用这个对象.

属性:

属性表示事物的特征.

可以给对象添加属性或者获取对象的属性值.

给对象添加属性: 对象.属性名 = 属性值 #添加或者修改

获取对象的属性值: 对象.属性名

在方法中操作属性(self是对象):self.属性名 = 属性值 self.属性名

初始化方法init(添加属性):

调用时机
在创建对象之后,会自动调用;
应用场景
初始化对象,给对象添加属性;
注意事项:
不要写错;
如果属性是会变化的,则可以将这个属性的值作为参数传递,在创建对象的时候,必须传递实参值.

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

    def eat(self):
        print(f'小猫{self.name}爱吃鱼')


blue_cat = Cat('蓝猫')
blue_cat.eat()

blue_cat = Cat('黑猫')
blue_cat.eat()

str方法(打印属性):

调用时机
使用print(对象)打印对象的时候,会自动调用
如果没有定义__str__方法,默认打印的是对象的引用地址
如果定义__str__方法.打印的是方法的返回值
应用场景
使用print(对象)打印输出对象的属性信息
注意事项
必须返回一个字符串

# 定义Cat类,包含属性name和age,打印对象的时候,可以输出对象的姓名和年龄
# 类型:Cat
# 属性:name,age
# 方法:__init__,__str__

class Cat:
    def __init__(self,name,age):
        self.name = name  #添加name属性
        self.age = age   #添加age属性

    def __str__(self):  #一般不适用print,直接返回
        return f"姓名:{self.name},年龄:{self.age}"
#创建对象
tom = Cat('汤姆',3)
print(tom)

dir()函数:

作用:可以查看对象内的所有属性及方法,不具备输出功能,需要和print()函数配合使用

继承:

继承描述的是类与类之间的关系;
继承的好处:减少代码冗余,重复代码不需要多次书写,提高编程效率.
语法:
class 类A: #默认继承object类,object类是python中最原始的类
pass
class 类B(类A): #类B继承类A
pass

#类A:父类或基类
#类B:子类或派生类
子类继承父类后,子类对象可以直接使用父类中的属性和方法

继承具有传递性: C 继承 B, B 继承 A, C 可以使用 A 类中的属性和方法

对象调用方法的顺序: 对象.方法名()

会现在自己的类中查找, 找到直接使用
没有找到去父类中查找, 找到直接使用
没有找到, 在父类的父类中查找, 找到直接使用
没有找到, ...
直到 object 类, 找到直接使用, 没有找到,报错

重写(override):

什么是重写:重写是在子类中重新定义和父类中名字一样的方法;
重写的原因:父类中的代码不能满足子类对象的需要;
重写的方式:
覆盖式重写 :父类中的功能全部不要,直接在子类中定义和父类中方法名字一样的方法接口,直接书写新的代码
扩展式重写.父类中的功能还需要,只是添加了新的功能
方法:1.先在子类中定义和父类中名字相同的方法;2.在子类的代码中,使用super().方法名()调用父类中的功能;3.书写新的功能

# 覆盖式重写
class Dog:
    def bark(self):
        print('汪汪叫...')


class Xtq(Dog):
    # 需要哮天犬嗷嗷叫,父类中的bark方法,不能满足子类对象的要求,覆盖式重写
    def bark(self):
        print('嗷嗷叫...')


if __name__ == '__main__':
    xtq = Xtq()
    xtq.bark()

# 扩展式重写
class Dog:
    def bark(self):
        print('汪汪叫...')


class Xtq(Dog):
    # 需要哮天犬汪汪叫和嗷嗷叫
    def bark(self):
        super().bark()
        print('嗷嗷叫...')


if __name__ == '__main__':
    xtq = Xtq()
    xtq.bark()

多态:

多态:调用代码的技巧.不同的子类对象调用相同的方法,产生不同的执行结果.

class Dog:
    def game(self):
        print('普通狗在玩耍')


class Xtq(Dog):
    def game(self):
        print('哮天犬在玩耍')


class Person:
    def play_with_dog(self, dog):
        print('人和狗在玩耍...', end='')  #使用end可以不换行输出
        dog.game()


if __name__ == '__main__':
    dog1 = Dog()
    xtq = Xtq()
    xiwang = Person()
    xiwang.play_with_dog(dog1)
    xiwang.play_with_dog(xtq)

公有和私有:

在python中,定义类的时候,可以给属性和方法设置访问权限,即规定在什么地方可以使用.权限一般分为两种:公有权限私有权限

公有权限:直接定义的属性和方法就是公有的,可以在任何地方访问和使用,只要有对象就可以访问和使用;
私有权限:
定义:1.只能在类内部(class关键字的缩进中)使用;
2.只需要在属性名或者方法名前边加上两个下划线,这个方法或者属性就变为私有的;
特点:私有只能在当前类的内部使用,不能在类外部和子类直接使用
应用场景:一般来说,定义的属性和方法都为公有,某个属性不想在外部直接使用,定义为私有,
某个方法是内部的方法(不想在外部使用),定义为私有

class Person:
    def __init__(self,name,age):
        self.name = name #公有
        self.__age = age #私有,在属性名前加两个下划线

    def __str__(self):
        return f'{self.name},{self.__age}'

if __name__ == '__main__':
    xiaowang = Person('小王',18)
    print(xiaowang)
    xiaowang.__age = 20  #不是私有变量,私有变量只有在类缩进中才可以使用
    print(xiaowang)

对象分类：

Python中一切皆对象

类对象
类对象就是类,就是使用class定义的类,在代码执行的时候,解释器会自动的创建.
作用:1.使用类对象创建实例对象;
２.存储一些类的特征值(类属性)
实例对象.
1.创建对象也称为实例化,所以由类对象(类)创建的对象称为是实力对象,简称实例:
2.一般来说,没有特殊强调,我们所说的对象都是指实例对象(实例);
3.实例对象可以保存实例的特征值(实例属性).

属性的分类:

使用实例对象.属性,访问属性的时候,会先在实例属性中查找,如果找不到,去类属性中查找,找到就使用,找不到就报错.即每个实例对象,都有可能访问类属性值(前提:实例属性喝类属性不重名).

实例属性:
1.概念:是每个实例对象具有的特征(属性),每个实例对象的特征;
2.定义:一般都是在init方法中,使用self.属性名 = 属性值来定义;
3.特征(内存):每个实例对象都会保存自己的实例属性,即内存中存在多份;
4.访问和修改:可以认为是通过self.实例对象.属性=属性值 #修改
实例对象.属性 #访问
类属性
1.概念:是类对象具有的特征,是整个类的特征;
2.定义:一般在类的内部(class缩进中),方法的外部(def的缩进外部)定义的变量;
3.特征(内存):只有类对象保存一份,即在内存中只有一个;
4.访问和修改:
# 即通过类名
类对象.属性 = 属性值
类对象.属性

# 1.定义一个工具类
# 2.每件工具都有自己的name
# 3.需求--知道使用这个类创建了多少个工具对象

# 需求--知道使用这个类创建了多少个工具对象类名:Tool
# 属性:name(实例属性),count(类属性)
# 方法:init方法

class Tool:
    #定义类属性count,记录创建对象的个数
    count = 0

    def __init__(self,name):
        self.name = name #实例属性,工具的名字
        #修改类属性的值
        Tool.count += 1

if __name__ == '__main__':
    #查看创建对象的个数
    print(Tool.count)  #查看类属性
    tool1 = Tool('香蕉')
    print(Tool.count)
    tool2 = Tool('苹果')
    print(tool2.count)

方法的划分:

实例方法
1.定义时机:如果方法中,需要使用实例属性,则这个方法必须定义为实例方法;
2.定义:直接定义的方法就是实例方法
class 类名:
def 方法名(self)
pass
3.参数:参数一般写作self,表示的是实例对象
4.调用:实例对象.方法名()
类方法
1.定义时机:如果方法中不需要使用实例属性,但需要使用类属性,则这个方法可以定义为类方法
2.定义:#定义类方法,需要在方法名上方书写@classmethod,即使用@classmethon装饰器装饰
class 类名:
@classmethon
def 方法名(cls):
pass
3.参数:参数一般写作cls,表示类对象,即类名,同样不需要手动传递,Python解释器会自动传递
4.调用:#方法一类名.方法名()
#方法二实例对象.方法名()
静态方法
1.定义时机:方法中既不需要使用实例属性,也不需要使用类属性,可以将这个方法定义为静态方法.
2.定义:#定义静态方法,需要使用装饰器@staticmethod装饰方法
class 类名:
@staticmethod
def 方法名():
pass
3.参数:静态方法,对参数一般没有要求
4.调用:#方法一类名.方法名()
#方法二实例对象.方法名()

标签

#开发语言 #python