Python-面向对象 一

1.类

"""
    类

    声明一个类
        class 类名:
            类的内容

    创建类的实例
        实例名 = 类名()

    添加实例的动态属性
        类的实例.属性名 = xxx
"""

# 声明一个类
class Student:

    # 类中方法默认有self参数,self代表实例本身
    def study(self):  # 成员方法
        print("学习")

    def sleep(self):
        print("睡觉")


# 创建类的实例
s = Student()
# 给实例动态添加一个属性
s.name = "tony"
# 调用实例的方法
s.study()
s.sleep()
# 打印实例动态添加的属性
print(s.name)

2.构造方法

"""
    初始化方法__init__
    self:指的是实例(对象)本身
"""

class Person:
    def __init__(self, name, age):  # 构造方法(又叫魔法方法、初始化方法) 在创建对象的时候自动执行
        print("init")
        # 在构造方法中添加参数，使用self给实例添加属性指定为构造方法的参数，使得每个实例都拥有该属性，并在创建实例的时候可以赋值
        self.name = name
        self.age = age

    # def __str__(self):  # 该方法返回什么打印对象的时候就打印什么，不写该方法打印对象的时候输出的是对象在内存中的地址
    #     return "Person类"

    def eat(self):
        print("吃")

    def sleep(self):
        print("睡觉")


tony = Person("tony", 20)
print(tony.name)
print(tony)

3.私有属性、私有方法

"""
    类的私有属性

        声明方式
            self.__属性名

    类的私有方法
        声明方法
            def __方法名
"""


class Person:
    def __init__(self):
        self.name = "tony"
        self.__age = 20  # 使用__属性名的方式声明一个私有属性，只有类的内部可以访问

    def printInfo(self):
        print(self.name, self.__age)


p = Person()
p.printInfo()  # tony 20
p.__age = "21"  # 该处修改的是共有属性，整个实例都可以进行访问
p.printInfo()  # tony 20 该处打印的__age是私有属性，私有属性没有被影响到，与上一行代码中的__age仅仅是属性名相同
print(p.__age)  # 21

4.类属性

"""
    类属性
        声明方式
        class Person:
            name = "tony" # 类属性，每一个该类的实例都可以对这个属性进行访问
            __age = "20" # 私有类属性 如何访问：在类中使用类名.属性名进行访问

            def __init__(self):
                xxx

            def xxx(self):
                pass
"""

class Person:
    name = "tony"
    __age = 18

    def printInfo(self):
        print(Person.name, Person.__age)


print(Person.name)  # tony
# print(Person.__age)  # 报错，找不到该属性
p = Person()
p.printInfo()  # tony 18
print(p.name)

5.静态方法

"""
    静态方法:不引用实例属性，实例方法，可以使用类属性(不推荐使用类属性)，是一个独立的个体。使用@staticmethod修饰
"""


class Person:
    info = "HalloPython"

    @staticmethod
    def staticPrint():
        print("我是静态方法")


Person.staticPrint()  # 静态方法可以不使用实例进行调用，直接用类名.方法名的方式就可以进行访问

6.类方法

"""
    类方法
	使用@classmethod修饰
	可以访问类属性，也可以间接的创建对象，来访问实例属性
"""

class Person:

    age = 20

    # 构造方法
    def __init__(self):
        self.name = "tony"
        print("init")

    @classmethod
    def get_name(cls): 
        print(cls.age) # 类属性
        print(Person().name)  # 间接访问


Person.get_name()

7.属性方法

"""
    把方法作为一个属性来访问
"""

# class Person:
#     def __init__(self):
#         self.__age = 0
#         self.__height = 0
#
#     def setPersonInfo(self, age, height):
#         self.__age = age
#         self.__height = height
#
#     def getPersonInfo(self):
#         return self.__age, self.__height
#
#
#使用属性方法之前对实例属性进行set,get
# p = Person()
# p.setPersonInfo(10, 170)
# print(p.getPersonInfo())


class Person:
    def __init__(self):
        self.__info = 0

    @property
    def PersonInfo(self):
        return self.__info

    @PersonInfo.setter
    def setPersonInfo(self, info):
        self.__info = info

#使用属性方法之后对实例属性进行set,get
p = Person()
p.setPersonInfo = 20, 170
print(p.PersonInfo)