22 python 初学（类，面向对象）
python： 函数式 + 面向对象
函数式可以做所有的事，是否合适？
面向对象：
一、定义：
函数： def + 函数名（参数）
面向对象： class -》 名字叫 Bar 类
def -> 名字叫 foo 的方法。第一个参数是 self
class Bar():
def __init__(self, name, age):
'''
构造方法,构造方法的特性，类名（）自动执行构造方法
'''
# 字段
self.name = name
self.age = age
print('123')
def foo(self):
print('foo')
print(self.name)
print(self.age)
obj = Bar('lily', 18)
obj.foo()
二、执行：
函数：函数名（参数）
面向对象： obj = Bar（）# 创建中间人，对象
obj.foo（）
# self：代指调用方法的对象（中间人）
中间人里面可以存值：obj.name = ‘lily’
self 永远指调用此方法的调用者
封装：将属性封装到对象里
# 构造方法：
特殊作用：
obj = 类名（）：完成两件事（1. 创建对象 2. 通过对象执行类中的一个特殊方法 __init__）
小结1：
创建类： class 类名
创建方法： 构造方法： __init__ 创建对象时自动调用此构建方法
普通方法：先创建对象，然后用对象调用普通方法
面向对象三大特性之一：封装
class Bar():
def __init__(self, name, age):
'''
构造方法,构造方法的特性，类名（）自动执行构造方法
'''
self.name = name
self.age = age
print('123')
obj = Bar('lily', 18)
适用场景：如果多个函数中有一些相同参数时，转换成面向对象
面向对象三大特性之二：继承
重写：防止执行父类中的方法
主动调用父类方法有两种方式： super(son, self).football() 和 father.football(self)
推荐使用 super 方法
python中支持多继承： a. 左侧优先 b. 一条道走到黑 c. 同一个根时，根最后执行
# ---------------继承-----------------------class father: # 父类，基类
def basketball(self):
print('father.basketball')
def football(self):
print('father.football')
class father1: # 父类，基类
def basketball(self):
print('father1.basketball')
class son(father, father1): # 子类、派生类
gender = 'male'
def cooking(self):
print('cooking')
# 重写
def football(self):
# # super 可以实现执行父类中的方法，传的参数： 子类名， self， 以及调用的父类方法
# super(son, self).football()
# 方法2：实现调用父类中的方法,传入参数：self
father.football(self)
print('son.football')
s = son()
s.cooking()
s.basketball()
# s.football()
面向对象三大特性之三：多态（python原生多态）
面向对象中高级：
成员：
字段：普通字段（保存在对象中）、 静态字段
普通字段属于对象，保存在对象中，只能通过对象访问；
静态字段属于类，内存中只保存一份，执行时可以通过对象访问，也可以通过类访问
方法：- 普通方法：保存在类中，由对象来调用 self - > 调用对象
- 静态方法：@staticmethod； self 不是必须的；保存在类中，通过类直接调用
- 类方法： @classmethod ；保存在类中，由类直接调用； cls -> 当前类
应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值 -》 普通方法
不需要任何对象中的值 -》 用静态方法
属性：定义像方法，调用像字段
class Foo:name = 'foo'
def __init__(self):
print('init')
def bar(self):
print('bar')
@staticmethod
def static_bar():
print('static bar')
@classmethod
def cls_bar(cls):
print('class_bar')
# 用于执行 obj.per
@property
def per(self):
print('per')
return 1
# 用于执行 obj.per = 123，此处内部实现并没有实现赋值功能，而是实现了一个打印的功能。 当 执行此赋值语句时就会执行此方法
@per.setter
def per(self, val):
print(val)
@per.deleter
def per(self):
print('del')
obj = Foo()
print(obj.name) # foo
obj.bar() # bar
Foo.static_bar() # static bar
Foo.cls_bar() # class_bar
r = obj.per # per
print(r) # 1
obj.per = 123
del obj.per
一、成员修饰符：
公有成员：
私有成员：__字段名，无法直接访问，只能间接访问
二、特殊成员（参考博客：http://www.cnblogs.com/duanv/p/5947525.html）
__init__
__call__
__int__
__str__
__add__
__dict__：打印出对象的属性。（如果是类的属性，且对象没有对该属性进行单独更改，那么就不会保存在对象中，要使用的时候会去上一级找）
__getitem__(self, item): # 切片或索引
__setitem__(self, key, value): 相当于中括号赋值
__delitem__(self, key): 删除 del list[100]
__iter__:
class Foo:__v = '123'
def __init__(self, name, age):
self.name = name
# self.age = age
self.__age = age # 私有对象，外部无法直接访问
def __call__(self, *args, **kwargs):
print('call')
def __int__(self):
return 1
def __iter__(self):
# 如果类中有 __iter__方法，对象 -》 可迭代对象
# 对象, __iter__()的返回值，迭代器
# for 循环: 迭代器， next
# for 循环: 可迭代对象，对象 __iter__(),迭代器，next
return iter([11, 22, 33, 44])
# return [11, 22, 33, 44]
def show(self):
return self.__age
@staticmethod
def stat():
return Foo.__v
@staticmethod
def __f1():
return 111
def f2(self):
r = self.__f1()
return r
obj = Foo('lily', 18)
print(obj.name) # lily
# print(obj.age)
r1 = obj.show()
print(r1) # 18
r2 = Foo.stat()
print(r2) # 123
r3 = obj.f2()
print(r3) # 111
# 相当于 Foo（）（），对象后面加（）会调用 call（）方法
obj() # call
# int(对象)，自动执行对象的 __int__方法，并将返回值赋给int对象
r4 = int(obj)
print(r4) # 1
d = obj.__dict__
print(d)
li = Foo('su', 18)
# 执行 li 对象的类Foo类中的 __iter__方法，并获取其返回值
# 循环上一步返回的对象
for i in li:
print(i)
三、metaclass：类的祖宗
- python中一切事物都是对象
- class Foo：
pass
obj = Foo()
# obj是 Foo的对象
# Foo 类是一个对象，type的对象，type 是 metaclass
类都是 type 类的对象
class Mytype(type):def __init__(self, *args, **kwargs):
print('mytype')
pass
def __call__(self, *args, **kwargs):
obj = self.__new__(self, *args, **kwargs)
self.__init__(obj)
class Myfoo(object, metaclass=Mytype):
def __init__(self):
pass
def __new__(cls, *args, **kwargs):
return object.__new__(cls, *args, **kwargs)
def myfunc(self):
print('hello')
obj_of_foo = Myfoo()
#####
首先会创建一个 Myfoo 类对象，会去调用 Mytype 中的 __init__ 方法。
接下来，Myfoo()会去调用 Mytype 中的 __call__方法，执行里面的内容：1. 调用 self，也就是 Myfoo 的 __new__ 方法，生成了一个 Myfoo 类的对象返回赋值给 obj。
2. 调用 Myfoo 里面的 __init__ 方法，并传入 obj 对象，初始化完成。
四、异常处理
# Exception
# 主动抛出异常
# 断言：强制用户服从，不服从报错。可捕获异常，但一般不捕获。
assert + 条件，如果不满足直接报错
五、反射
getattr
setattr
delattr
# _author: lily# _date: 2019/1/21
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
obj = Foo('lily', 18)
obj1 = Foo('su', 18)
b = 'name'
print(obj.__dict__[b])
# 去什么东西里面获取什么内容
v = getattr(obj, 'name')
print('v = ', v)
# func = getattr(Foo, 'show') # 找到 show 函数
# print(func())
# hasattr(obj, 'name') # 判断有无某种属性
# setattr(obj, 'k1', 'v1') # 设置属性
# print(obj.k1) # v1
delattr(obj, 'name')
# print(obj.name) # 会报错
print(obj1.name) # su
六、单例模式
好处：省内存，对象之创建一份
应用：数据库连接
__init__ __call__ __new__:
init 方法是将 对象 初始化的时候调用（比如说： 解释器遇到一个类的定义时，会调用 type 的 init 方法）
call 方法是 对象 被调用的时候调用（比如说：解释器遇到 Foo（）、obj（） 的时候会调用 call 方法）。
如：1. Foo 类被调用，会去执行 type的call 方法，在 call 方法的实现里，去调用self.new 和 slef.init，此处self 指的是对象Foo。
2. self.new 去实现Foo里面的 new方法（Foo里面的new 默认去调用object的new方法），并返回一个对象。
3. self.init（obj）去实现Foo里面的init 方法，将对象进行初始化。
new 方法才是真正创建一个对象
# _author: lily# _date: 2019/1/21
# 单例模式，永远使用同一份实例（对象）
class Foo:
__instance = None
def __init__(self, name, age):
self.name = name
self.age = age
@classmethod
def get_instance(cls, name, age):
print(cls)
if cls.__instance:
return cls.__instance
else:
cls.__instance = Foo(name, age)
return cls.__instance
obj1 = Foo.get_instance('lily', 18)
print(obj1)
del obj1
#
# obj2 = Foo.get_instance('su', 18)
# print(obj2)
# print(obj2.name)
以上是 22 python 初学（类，面向对象） 的全部内容， 来源链接： utcz.com/z/387283.html
