# 对象的基本理论
# 什么事对象？
# 万物皆对象
# 对象是具体物体
# 拥有属性
# 拥有行为
# 把很多零散的东西，封装成为一个整体
# 举例：王二小
# 属性
# 姓名
# 年龄
# 身高
# 体重
# 行为
# 走路
# 吃饭
# 放羊
# Python中的体现
# 是一门特别彻底的面向对象编程(OOP)的语言
# 其他语言:基本数据类型，对象类型
# python全部类型都是对象类型
# 面向对象是面向过程的封装
# 对象和类的关系：对象 可以抽象为类 类可以实例化为对象 class Money:
pass print(Money) #<class '__main__.Money'>
one = Money()
print(one, type(one)) #<__main__.Money object at 0x030CFBB0> <class '__main__.Money'> class Person:
pass # 对象的操作：增
p = Person()
# 查看对象的所有属性
print(p.__dict__) #{}
p.age = 18
p.height = 180
print(p.__dict__) #{'age': 18, 'height': 180} # 对象的操作：删
del p.age # 对象的操作：改
p.height = 185 # 对象里面如果有这个属性，就是修改，否则就是增加这个属性 # 类里面的 __dict__ 不可以修改，只读的
# 对象里的 __dict__ 可以修改
class Test:
age = 18 #Test.__dict__["age"] = 20 #TypeError: 'mappingproxy' object does not support item assignment one = Test() one.__dict__ = {"name":"abc", "height":180} #就是说__dict__字典里面生存储属性的变量
print(one.__dict__) #{'name': 'abc', 'height': 180} # 理解下面的内容
class Person:
age = 10 p = Person() print(Person.age) #
print(p.age) # p.age += 5 # p.age = p.age + 5
# 要理解这个在对象和类的操作方法：首先是计算右边的值，p.age 在对象p中没有，所以他要到类中去取age = 10
# 然后变成10+5 = 15, 然后在p对象中新增加个age属性（以前说过，对象没有就是新增，有的话就是修改) print(Person.age) #
print(p.age) # # __slot__
class Person:
__slots__ = {"age"} #只可以加入age的属性 p1 = Person()
p1.age = 18
print(p1.age) # 方法：实例方法，类方法，静态方法 class Person:
def eat(self):
print("这是个实例方法", self) @classmethod
def eat2(cls):
print("这是个类方法", cls) @staticmethod
def eat3():
print("这是个静态方法") p = Person()
print(p)
p.eat()
p.eat2()
p.eat3()
# <__main__.Person object at 0x032F54F0>
# 这是个实例方法 <__main__.Person object at 0x032F54F0>
# 这是个类方法 <class '__main__.Person'>
# 这是个静态方法
print("-" * 30)
#另外的调用方式：
Person.eat("") #这里必须要有个参数，才能调用成功
Person.eat2()
Person.eat3() print("-" * 30)
# 实例方法，类方法，静态方法的访问权限问题（包括类属性，实例属性）
class Person:
age = 10
# 实例方法
def shilie(self):
print(self)
print(self.age)
print(self.num) # 类方法
@classmethod
def leifangfa(cls):
print(cls)
print(cls.age)
print(cls.num) # 不可以使用实例属性 # 静态方法
@staticmethod
def jingtai():
print(Person.age) # 能使用类里面的属性，但很少这样去调用的 p = Person()
p.num = 11 p.shilie() # 实例方法：可以调用实例属性和类属性
#p.leifangfa() # 类方法：不可以使用实例属性
p.jingtai() # 静态方法：可以使用类属性，不可以使用实例属性 # 元类
num = 123
str = "abc"
print(num.__class__.__class__) # <class 'type'>
print(str.__class__.__class__) # <class 'type'>
print(Person.__class__) # <class 'type'>
print(Person.__class__.__class__)# <class 'type'>
print(p.__class__.__class__) # <class 'type'> # ----------------------------另外一种创建类的方式-------------------------
def run(self):
print(self) dog = type("Dog",(),{"name":"abc","run":run}) #字典里面可以是类属性，或者类方法
print(dog.name) #abc
print(dog.run) #<function run at 0x02B56C90> # ---------------------------类的创建流程---------------------------------- class Animal:
# __metaclass__ = xxx
pass class Person(Animal):
# __metaclass__ = xxx
pass # -------------------------类的描述, pydoc 模块---------------------------------------
class Person:
"""
关于类的描述，类的左右，类的构造函数
Attribute:
属性的描述
"""
def run(self, distence, step):
"""
函数的作用
:param distence:参数含义，数据类型，默认值
:param step:
:return: 返回值类型
"""
return distence / step # help(Person) # 可以这样看帮助文档 # ------------------------ 私有化属性（类的内部，子类内部，模块内部，模块外部）4大块 ------- class Animal:
x = 10
_y = 20
__z = 30
def test(self):
print(Animal.x)
print(self.x)
print(Animal._y)
print(self._y)
print(Animal.__z)
print(self.__z)
print("-" * 30) class Dog(Animal):
def test2(self):
print(Dog.x)
print(self.x)
print(Dog._y)
print(self._y)
# print(Dog.__z) # 错误
# print(self.__z) # 错误
print("-" * 30) # 类的内部访问
a = Animal()
a.test() # 成功打印x # 子类的内部访问
d = Dog()
d.test2() # 成功打印x # 模块内部访问
# print(Animal.x) # 成功打印x
# print(Dog.x) # 成功打印x
# print(a.x) # 成功打印x
# print(d.x) # 成功打印x
# print(a.__z) # 有错误
#
# print(Animal._y) # 成功打印_y，但有警告
# print(Dog._y) # 成功打印_y，但有警告
# print(a._y) # 成功打印_y，但有警告
# print(d._y) # 成功打印_y，但有警告
# print(a.__z) # 有错误
# print(d.__z) # 有错误 print(Animal.__dict__)
print(Animal._Animal__z) # 伪私有 30
# 模块外的访问
import public
print(public.num) # 成功打印num
print(public._num2) # 另外一种模块导入方法
from public import *
# 直接写public 模块中的变量
print(num) # 成功打印num
# print(_num2) # 有错误