Python 基础入门 6_1 类与对象

# 类：一种数据类型，本身并不占内存空间，跟所学过的number等类型，一个类由属性(变量)和方法(函数)组成
# 对象： 要使用类内部的属性和方法，就需要实例化类，这种实例化类就叫做对象

"""
定义类
类名：首字母大写，其他遵循驼峰原则
属性：其他遵循驼峰原则
行为(方法/功能)：其他遵循驼峰原则

创建一个类，格式如下：
class 类名()：
    定义属性(相当于定义变量)：属性名 = 值
    定义方法（相当于定义函数）：
        def 方法名(self[,paratmeters]):
            语句
            [return value]
    构造函数：__init__(self[,paratmeters])，当使用该类创建对象时会调用该类的构造函数，默认是程序自动创建一个无参数的构造函数
        一个类，有且仅有一个构造函数。作用：可以使对象创建出来时，给属性赋值
    虚构函数：__del__(self)  当释放对象时，调用该函数
    反写：__str__(self):   在调用print打印对象时自动调用,作用：可以打印对象时打印对象里的属性值
        是给用户用的一个描述对象的方法 注意：这个函数里不能有print语句
          __repr__(self):  跟__str__()很类似，区别在于，__str__()方法是在print方法打印对象时被调用，
                       __repr__()方法是在Python解释器里直接输入对象名在回车后被调用

self.__class__   代表类名
"""
class Person():
    name = "name"
    age = 0
    def eat(self):
        print("eat")
    def sleep(self):
        return 8
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        print("我被释放了",self)
    def __str__(self):
        return  self.name+"已经"+str(self.age)+"岁了"
    # def __repr__(self):
    #     return "在python解释器里输入了对象名"

"""
使用类实例化对象，格式如下：
    对象名(自定义)=类名([paratmeters])
使用类中的属性/方法（函数），格式如下：
    对象名.属性名/方法名
也可以将类中的属性/方法(函数)[若函数有返回值的话]赋值给变量：
    变量 = 对象名.属性名/方法名  
给对象的变量重新赋值，格式如下：
    对象名.属性名 = 新值
del 对象名   释放对象，释放后就不能调用方法
在函数里面创建对象，但这个函数运行完后释放对象
"""
person1 = Person("name",10)
print("name:%s age:%d" %(person1.name,person1.age))
person1.eat()
name1,age1,sleep1 = person1.name,person1.age,person1.sleep()
print("name1:%s age1:%d sleep:%d" %(name1,age1,sleep1))
print(person1)

"""
对象属性与类属性
类属性：在定义类时，就以及定义了属性并赋值，这种属性叫做类属性
对象属性：当创建一个对象时(即调用类的构造函数),创建的属性叫做对象属性
对象属性和类属性的区别：
    1.对象属性需要创建一个对象才能被调用，而类属性直接类名.属性名就可以被调用
    2.对象属性只针对当前的对象，类属性是针对所有的对象

当一个类实例化一个对象，若这个类是无参的构造函数，那么这个对象的没有对象属性，给对象添加对象属性格式如下：
    对象名.属性名 = 值 (当属性名存在的时候，赋值；当属性名不存在的时候，创建并赋值)

对象名.属性名  
对象属性的优先级高于类属性，即如果一个对象属性和类属性的属性名相同，先会调用对象属性的值；
当该属性名,对象属性没有，而类属性有，才会调用类属性的值；若两者都没有则报错

类方法与对象方法，跟类属性与对象属性很类似：
类方法：定义类时，就已经定义了方法，这种方法叫做类方法
对象方法：当创建一个对象，并对这个对象添加方法，这种方法叫做对象方法
区别：1.对方方法是需要创建一个对象并对这个对象添加方法才能被调用，而类方法可以直接调用
      2.对象方法只针对当前对象，类方法是针对所有的对象
      
给对象添加方法的形式如下：
1. 引入types模块的MethodType方法：from MethodType import types
2. 创建一个方法(函数)，参数第一位为self
3. 对象名.新方法名 = MethodType(定义的方法名(函数名),对象名)

对象方法的优先级高于类方法，即如果一个对象方法和类方法的方法名相同，先会调用对象方法；
当该方法名,对象方法没有，而类方法有，才会调用类方法；若两者都没有则报错

限制创建对象的对象属性以及对象方法，作用：不让对象随意创建对象属性，只能创建指定名的对象属性以及对象方法
定义类的时候，定义一个特殊的属性(__slots__),__slots__ = (命名元组)

当对象添加对象的属性名或方法名在命名元组中，则可以添加，否则报错
注意:__slots__命名元组 中的命名不能和类属性名或类方法名一致，否则报错
     当类创建__slots__属性时，该类的构造函数的参数除self之外的参数名，只能于命名元组中名字，否则创建对象时报错

del 对象名.属性名/方法名  删除对象的对象属性或者对象方法，若该对象的对象属性无该属性名或方法名，则报错 
"""
class Father():
    age = 0
    def run(self):
        print("run")

father1 = Father()
print("Father:%d , father:%d" %(Father.age,father1.age))
father1.age = 1
print("Father:%d , father:%d" %(Father.age,father1.age))
father1.name = "hjl"
print("father.name :",father1.name)

import types
def run(self):
    print("跑")
def eat(self):
    print("吃")
print("father1.run:") ,father1.run()
father1.run = types.MethodType(run,father1) #新添加对象方法run
print("Father.run:"),Father.run(Father)
print("father.run:"),father1.run()
father1.eat = types.MethodType(eat,father1)
print("father.eat"),father1.eat()
####################################################
class Father():
    age = 1
    __slots__ = ("name","eat")
    def run(self):
        print("run1")

father1 = Father()
print("Father:%d , father:%d" %(Father.age,father1.age))
# father1.age = 1     #报错，因为类属性名有age
#father1.work = "IT"  #报错，因为命名元组中没有work元素值
father1.name = "HJL"
print(father1.name)

class Father1():
    age = 2
    __slots__ = ("name","eat")
    def run(self):
        print("run1")
    def __init__(self,name):
        self.name = name
    # def __init__(self,age,work):
        # self.age = age
        # self.work = work
father2 = Father1("HJl")
# father2 = Father1(1,"it") #报错，因为age时类属性名，work不在命名元组中
print(father2.name)


import types
def run(self):
    print("跑1")
def eat(self):
    print("吃1")
def work(self):
    print("工作1")
print("Father.run"),Father.run(Father)
print("father.run"),father1.run()
# father1.run = types.MethodType(run,father1) #报错，因为类方法名有run
# father1.work = types.MethodType(work,father1) #报错，因为命名元组中没有work元素值
father1.eat = types.MethodType(eat,father1)
print("father.eat"),father1.eat()

del father1.eat,father1.name
# print("father.name",father1.name),father1.eat() #报错，因为对象里无该属性名以及方法名

"""
类的私有属性/方法：若一个类定义的类属性/类方法中，有部分类属性/类方法不想直接被外部访问，这不能被外部访问的属性/方法叫做私有属性/方法
定义一个私有属性： __属性名  （在属性名前加两个下划线）
注意： 对象属性没有私有属性，只有类属性才有私有属性

虽然私有属性/方法不能直接被外部访问，但可以通过类的方法返回私有属性或调用私有方法：
以下是对私有属性的调用和赋值其中一种方式：
"""
class Mether():
    __age = 0
    # __slots__ = ("name")  # 设定对象添加的属性名/方法名只能为name
    def __print(self):
        print("私有方法")
    #私有属性的调用与赋值 方法1
    def getAge(self):
        return self.__age
    def setAge(self,age):
        self.__age = age

    #私有属性的调用与赋值 方法2
    @property
    def age(self):
        return self.__age
    @age.setter
    def age(self,age):
        self.__age = age

mether = Mether()
# print(Mether.age)          #报错，因为age为类的私有属性
# Mether.print(Mether)     #报错，因为print为类的私有方法
# print(mether.age)     #报错，因为age为类的私有属性

Mether.setAge(Mether,1)
print("私有变量age访问1：",Mether.getAge(Mether))
#以下两行报错，self指向的是对象，而__age则为对象的对象属性，并且对象创建的属性名/方法名只能是name，所以报错
# mether.setAge(2)
# print("私有变量age访问：",mether.getAge(Mether))

# mether.age(10)
# print("私有变量age访问2：",mether.age())