python ====面向对象=== 16
面向对象
什么时候使用面向对象?
代码量大, 功能多的时候
处理比较复杂的角色之间的关系的时候
代码的清晰度更高:
可读性 : 无论是开发者还是调用者都能明确 的分辨出每个角色拥有的方法
增加了代码的可扩展性
更加规范
类: 具有相同属性和技能的一类事物 比如 : 人类
类和类型 是一个东西 每个类型都是一个类
type( obj ) obj是一个对象, 那么它的type 就是它的类型
创建一个类 :
class 类名 类也是被创建出来的, 被 type创建出来的类
type ( 对象 ) ===> 对象所在的类名
type( 类名 ) ===> type类型 除非制定class 类名(metaclass=***) 那么type就是这个类的元类
class A( metaclass=ABCMeta):
那么 ABCMeta 创建了 A类 那么ABCMeta 就是A的元类
其他的 type 是所有类的元类
对象 : python中 一切皆为对象 基础的数据类型 都是对象
具体的某一个事物 , 具体的类的表现
,具体到类中的某一个东西,某个实例 , 例如 : 张杰
类创造对象的过程就是实例化的过程 先new开辟空间 再init初始化
可以通过指针类找到类的空间中的内容
对象本身内部也储存了一些只属于对象的属性
定义一个人类: 类名首字母必须大写
class Person: # 定义一个类 人类(类名)
mind = " 有思想的 " ====>
animal = " 高级动物 " ===> 静态变量 部分 静态字段 变量
faith = " 有信仰的 " =====
def _ _init_ _(self): # 构造方法
print(666)
def work(self) :
print("会工作...")
def shop(self) :
print("可以消费")
从类名的角度调用类中的静态变量
print(Person. _ _dict_ _) # 查询 类中所有的内容, 查出来形式是 字典的形式
print( Person . _ _dict_ _[ faith ] ) ===> 有信仰的 # 类名的角度调用静态变量,但是 一般查询单个内容不用_ _dict_ _查询
Person._ _dict_ _不能进行增删改 只能查
从类名的角度对 类中的单个变量进行 增删改查
用 万能的 点 . 类名 . 属性
print( Person.mind ) ===> 有思想的 # 查询静态变量
print( Person. animal ) ===> 高级动物
Person . money = " 运用货币 " # 增加一个 静态变量
print(Person._ _dict_ _) 打印可以看到其中多了 money: 运用货币
Person . mind = " 无脑的 " # 修改 静态变量
print(Person._ _dict_ _) 打印可以看到 其中 有思想的 改为了 无脑的
del Person.mind # 删除 静态变量
print(Person._ _dict_ _) 打印可以看到 mind= " 无脑的 " 被删除了
从类名的角度 操作类中的方法 (工作中基本不用)
Person . work( 111 ) ==> 都会工作...
从对象的角度 操作
类名 + ( ) : 过程 : 实例化过程 , 相当于创建了一个 实例的 对象
Person( )
1. 只要有 一个 类名+ () 就会产生一个对象 自动执行 _ _init_ _ 函数方法
ret=Person() # 看似没有对象实际上是将 对象传给 self 自动传给第一个位置参数 self
print(ret) ===> 666
def _ _init_ _(self,name,age,hobby): # 构造方法
self.name=name
self.age=age
self.hobby=hobby
print(name,age,hobby)
ret=person("alex",28,"IT")
print(ret)===> alex,28,IT
实例化过程
: 1. 类名+() 产生一个实实例 ( 对象 ) (对象空间)
2. 自动执行类中的 _ _ init_ _方法 并将对象空间传给 _ _init_ _中的 self
3. 执行具体的 _ _init _ _中的代码 ., 给对象 封装相应的 属性
_ _iniit_ -中的self 后边的参数 就是封装的 属性 例如:
self.name=name
self.age=age
self.hobby=hobby
对象的角度 操纵类中的静态变量
print(ret.mind) ===> 有思想 # 只能查
1. 对象名 . _ _dict_ _ #查询 对象中 所有的内容
p1=Person("alex", 28, "IT")
print(p1._ _dict_ _)====> {'name': 'alex', 'age': 28, 'hobby': "IT"}
2. 万能的 . 对象名. 属性
print( p1.name )====> alex # 查询
p1.hight = 175 # 增加
print( p1._ _dict_ _) 可以看出 {'name': 'alex', 'age': 28, 'hobby': "IT" , "hight" : 175 }
del p1. name # 删除
print( p1._ _dict_ _) 可以看出 { 'age': 28, 'hobby': "IT" , "hight" : 175 }
p1.age=73
print( p1._ _dict_ _) 可以看出 { 'age': 73, 'hobby': "IT" , "hight" : 175 }
对象的角度 调用类中的方法 :
第一个参数不用传 ,
工作中常用 ,通过对象 执行类中的方法 ,而不是通过类名
p1.shop()
操作类中的方法 除了类方法. 静态方法 需要用类名调用之外, 剩下的方法, 都要用对象名调用
在类中添加属性
def func(self):
self.hight=175
为什么要在 _ _init_ -中封装属性?
因为 ,在他里边封装. 只要有 类名 +( ) 它就可以自动执行 方便
计算实例化次数
class Count:
count=0
def _ _init_ _(self):
Count.count=Count.count +1 # Count.count 指的是静态变量的 count
,因此 最终结果只能用 Count.count 来表示
或者 Count.count= self.count +1 # self.count 这时传进去的count 和外边的是一样的,但是结果必须用
Cont.count表示
odj=count()
obj1=count()
print(Count.ount) ===>2
查询顺序
通过 类名 查询
类名 . 属性 先从本类 空间中找 ,如果找不到 再从父类中找 ,
通过 对象查询
对象 . 属性 先从对象所在空间 找, 若找不到 再从所在类的空间找, 再找不到, 再去父类中找...
通过类名 可以改变 类中的静态变量的值
但是 通过对象 不能改变, 只能引用类中的静态变量 , 因为 通过对象一改 就相当于 新增了 一个属性
