【python基础】类&对象

一、类

　　1、对同一类事物抽象的描述，抽象的概念。归类所有，只有一份，所有对象共享这一份类属性。
　　2、定义类的语法：
　　　　class 关键字——命名规则：大驼峰StudentInfo; (小驼峰studentInfo)

　　　　class 类名：
　　　　　　pass
　　3、属性: 理解为用于描述类名词 (名字, 年龄, 颜色, 身高,...)
　　4、方法: 也叫做函数, 理解为类能够实现的行为功能(吃饭, 睡觉, 打豆豆,...)

二、对象: 真实存在的，类的具体的一个实例

　　1、对象 : 也叫做实例 　　

　　2、创建对象的过程：叫做类的实例化

　　3、属性：归对象所有,每个对象都有一份,对象之间的实例属性互不影响
　　　　获取对象的属性值：对象.属性
　　　　给属性赋值：对象.属性 = 新值

　　4、方法：对象.方法()

　　5、动态的给对象的属性赋值
　　　　类中没有定义该属性，则在对象中给哪个对象的属性动态赋值，只有该对象能使用此属性

　　6、self 自己，本身
　　　　谁调用谁就是self，self指的是当前调用的对象

三、创建对象

　　1、创建对象的过程：p1 = Person()
　　　　（1）开辟内存,存储对象
　　　　（2）自动调用了init方法

　　2、实例变量
　　　　初始化实例变量, 初始化对象的属性
　　　　实例变量：对象的变量 ——> 对象属性

　　　　实例变量归对象所有, 每个对象都有一份, 对象之间互不影响
　　　　self.变量名 ——> 表示实例变量(实例属性)

　　3、init
　　　　一般情况下会在init方法中初始化实例变量(对象的属性)

# 2. 公路和汽车类, 计算车在公路上行走完的时间
# 分析: 时间 = 路程 / 速度
# 路程: 公路的长度  --->  长度(名词)
# 速度: 汽车的速度  --->  速度(名词)
#           功能: 计算车在公路上行走完的时间
class Road:
    def __init__(self, length, name):
        self.name = name
        self.length = length
 
    def get_time(self, car_obj):  # 形参:本质变量  car_obj 小汽车对象
         t = self.length / car_obj.v
        print("%s小汽车在%s公路上行驶完全程的时间是%.2f" % (car_obj.brand, self.name, t))

class Car:
    def __init__(self, v, brand):  # 属性v, 代表速度
        self.v = v
        self.brand = brand  # 汽车品牌

    def get_time(self, road_obj):  # 形参: 公路对象
        t = road_obj.length / self.v
        print("%s小汽车在%s公路上行驶完全程的时间是%.2f" % (self.brand, road_obj.name, t))


road1 = Road(100, "康庄大道")
car1 = Car(300, "奥拓")

road1.get_time(car1)  # 奥拓小汽车在康庄大道公路上行驶完全程的时间是0.33
car1.get_time(road1)  # 奥拓小汽车在康庄大道公路上行驶完全程的时间是0.33

四、实例方法&类方法&静态方法

　　1、实例方法：
　　　　第一个参数，都是self，self 指的是当前调用的对象;
　　　　可以访问：
　　　　　　self.实例属性
　　　　　　类名.类属性

　　2、类方法：
　　　　第一个参数，都是cls，cls 指的是当前的类
　　　　可以访问：
　　　　　　类名.类属性；cls.类属性
　　　　　　 　　默认不能访问实例属性

#语法规则：

class 类名:

@classmethod
　　def 类方法名(cls, 参数,...)：
　　　　 pass

　　　　（1）类方法可以由类调用，也可以由实例调用
　　　　（2）类方法中可以通过传递实例作为参数，从而访问到实例方法和实例属性

　　3、静态方法：
　　　　如果类中一个方法既不操作类, 也不操作实例, 那么定义为静态方法
　　　　没有默认的参数

#语法规则：

class 类名:

@staticmethod
　　def 静态方法名()：
　　　　pass

　　综上：
　　　　1、如果需要定义一个方法，操作实例——> 实例方法
　　　　2、如果需要定义一个方法，操作类——> 类方法
　　　　3、如果需要定义一个方法，既不操作实例也不操作类 ——> 静态方法

class Person:
    country = "中国"
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 定义一个实例方法, self, 访问实例属性, 访问类属性
    def show_info(self):
        print("实例方法:show_info, {}, {}, {}".format(self.name, self.age, self.country))

    # 定义一个类方法, cls当前类, 可以访问类属性, 不能访问实例属性
    @classmethod
    def test(cls):
        print("类方法:test--国籍:{}".format(cls.country))  # Person.country,

    # 定义一个类方法, 传入一个实例作为参数, 函数体中即可操作该实例(属性,方法)
    @classmethod
    def test2(cls, p_obj):
        print("类方法操作实例:test2--{}, {}".format(cls.country, p_obj.name))

    @staticmethod
    def introduce():
        print("我是一个静态方法, 我既不操作类, 也不操作实例")


p1 = Person("xixi", 8)
p2 = Person("haha", 7)

p1.show_info()  # 使用对象调用实例方法
Person.show_info(p2)  # 不建议

"""
实例方法:show_info, xixi, 8, 中国
实例方法:show_info, haha, 7, 中国
"""
Person.test()  # 可以用类调用类方法
p1.test()  # 也可以用实例调用类方法
p2.test()

p1.test2(p1)  # 类方法操作实例:test2--中国, xixi
Person.test2(p2)  # 类方法操作实例:test2--中国, haha

Person.introduce()  # 我是一个静态方法, 我既不操作类, 也不操作实例
p1.introduce()  # 我是一个静态方法, 我既不操作类, 也不操作实例

五、抽象类

　　抽象类是一个特殊的类，这个类只能被继承，不能被实例化
　　python中使用抽象类是通过一个模块实现的

 

　　* 子类必须要实现父类中规定好的方法

 

 

　　为什么要有抽象类
　　　　类：对同一类事物抽象的描述
　　　　　　类是从一堆对象中抽取的相同的内容
　　　　　　抽象类是从一堆类中抽取的相同的内容

 

　　　　苹果类, 橘子类, 葡萄类，继承自水果类（抽象类）

 

　　　　抽象类，只能有抽象的方法，没有实现的功能

from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):  # 抽象类需要继承自abc.ABCMeta   元
    @abstractmethod
    def pay(self):
        pass

class WeChat(Payment):
    def pay(self):
        print("微信支付的功能")

class Bank(Payment):
    def pay(self):
        print("银联支付的功能")

# p = Payment()   # TypeError: Can't instantiate abstract class Payment with abstract methods pay

b = Bank()
b.pay()  # 银联支付的功能

w = WeChat()
w.pay()  # 微信支付的功能

六、私有属性&私有方法

　　起到保护核心代码的作用，通过__dict__属性查看所有属性值(包括私有)

　　python中关于私有，是通过改名实现的，所以在类外访问私有，可以通过对象._类名__私有名实现，但是强烈不建议这么做

　　1、私有属性：

　　　　__属性名，只能在本类中使用
　　　　类外不能使用，但是可以通过公有方法, 修改或者获取私有属性的值

class Girl:
    def __init__(self, name):
        self.name = name
        self.__age = 18  # 私有属性

    def show_me(self):  # 通过公有方法获取私有属性值
        print("我的名字:{}, 我偷偷的告诉你我的年龄:{}".format(self.name, self.__age))

    def set_age(self, age):  # 通过公有方法修改私有属性的值, 参数为修改后的值
        self.__age = age
        print("我偷偷告诉你一声,我的年龄改变了,现在是:{}".format(self.__age))


g1 = Girl("xixi")
print(g1.name)
# print(g1.__age)   # AttributeError: 'Girl' object has no attribute '__age'

g1.show_me()

# 可以在类中定义一个公有方法set_age, 用于更改私有属性__age的值;
g1.set_age(8)  # 年龄更改为8

　　2、私有方法

　　　　__方法名，类中能够使用，类外不能使用
　　　　但是可以通过公有方法访问到类的私有方法　　　

class Person:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    # 实现了某个具体的功能,
    def __secret(self):
        print("秘密")

    # 提供公有方法作为接口
    def get_secret(self):
        self.__secret()  # 类中调用该方法


p1 = Person("xixi")
# p1.__secret()  AttributeError: 'Person' object has no attribute '__secret'

p1.get_secret()  # 秘密

print(p1.__dict__)  # {'name': 'xixi', '_Person__age': 18}
# print(p1.__age)
print(p1._Person__age)  # 18