# 类：一种数据类型，本身并不占内存空间，跟所学过的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())
