什么是面向对象编程
利用(面向)对象(属性与方法)去进行编码的过程
自定义对象数据类型就是面向对象中的类(class)的概念
类的关键字class
class Person(object):
name = ‘ckk‘
def add(self, a, b):
return a + b
ckk = Person() #类的实例化
print(ckk.name) #通过实例化进行属性调用， 控制台输出：ckk
print(ckk.add(1, 2)) #通过实例化进行函数调用 控制台输出：3
def __init__(self,a,b):
self.a=a
self.b=b
示例代码：
class Person(object):
def __init__(self, name):
self.name = name
def run(self):
print(f‘我叫{self.name}‘)
p = Person(‘ckk‘)
p.run()#我叫ckk
什么是私有函数和私有变量
私有函数与私有变量的定义方法
示例代码：
class Person(object):
def __init__(self, name):
self.name = name
def run(self):
print(f"我叫{self.name}.")
def __run(self):
print("我是Person类的，私有函数__run()")
ckk = Person(‘ckk‘)
ckk.run() # 我叫ckk.
# ckk.__run()# ‘Person‘ object has no attribute ‘__run‘ 报错 无法直接调用私有函数
# 通过dir()内置函数 可以找到调用私有函数和属性的办法，但是既然是私有的，不推荐调用
print(dir(ckk)) # ‘_Person__run‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__.....
ckk._Person__run() # 我是Person类的，私有函数__run()
将不对外的私有属性或方法通过可以对外使用的函数而使用(类中定义私有的，只有类内部使用，外部无法访问)
这样做的主要原因:保护隐私，明确区分内外
示例代码：
class Person(object):
def __init__(self, name):
self.name = name
def run(self):
print(f"我叫{self.name}.")
def __run(self):
print("我是Person类的，私有函数__run()")
ckk = Person(‘ckk‘)
ckk.run() # 我叫ckk.
# ckk.__run()# ‘Person‘ object has no attribute ‘__run‘ 报错 无法直接调用私有函数
# 通过dir()内置函数 可以找到调用私有函数和属性的办法，但是既然是私有的，不推荐调用
print(dir(ckk)) # ‘_Person__run‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__.....
ckk._Person__run() # 我是Person类的，私有函数__run()
什么是装饰器
也是一种函数
可以接受函数作为参数
可以返回函数
接收一个函数，内部对其处理，然后返回一个新的函数，动态的增强函数的功能。
将b函数在a函数中执行，在a函数中可以选择执行或不执行b函数，也可以对b函数的结果进行二次加工处理。
def a():
def b():
print(‘hello‘)
b()
a()
装饰器的定义
def out(func_args): # 外围函数
def inter(*args, **kwargs): # 内嵌函数
return func_args(*args, **kwargs)
return inter # 外围函数返回内嵌函数
装饰器的用法
将被调用的函数直接作为参数传入装饰器的外围函数括弧
将装饰器与被调用函数绑定在一起
@符号+装饰器函数放在被调用函数的上一行，下一行创建函数，只需要直接调用被执行函数即可
示例代码：
def check_str(func):
def inner(*args, **kwargs):
result = func(*args, **kwargs)
if result == ‘ok‘:
return ‘ok‘
else:
return ‘no‘
return inner
@check_str
def test(data):
return data
print(test(‘no‘))#no
classmethod
将类函数可以不经过实例化而直接被调用
用法：
@classmethod
def func(cls,....):
do
参数介绍：
示例代码：
class Person(object):
@classmethod
def add(cls, a, b):
return a + b
print(Person.add(1, 2)) # 3
staticmethod
将类函数可以不经过实例化而直接被调用，被该装饰器调用的函数不许传递self或cls参数，且无法再该函数内调用其它类函数或类变量。
用法：
@staticmethod
def func(..):
do
参数介绍
示例代码：
class Person(object):
@staticmethod
def add(a, b):
return a + b
print(Person.add(1, 2)) # 3
Preperty
将类函数的执行免去括弧，类似于调用属性(变量),只适用于无参数的类函数(self与cls除外)
用法：
@perperty
def func(self):
do
参数介绍:
无重要函数说明
示例代码：
class Person(object):
def __init__(self, name):
self.name = name
@property
def say(self):
print(f‘你好，{self.name}‘)
ckk = Person(‘ckk‘)
ckk.say # 你好，ckk
什么是继承
父(基)类与子类
继承的用法
定义子类时，将父类传入子类参数内
子类实例化可以调用自己与父类的函数与变量
父类无法调用子类的函数与变量
示例代码：
class Person(object):
def say(self):
print("我是父类的say方法")
class Chinese(Person):
def prints(self):
pass
c = Chinese()
c.say() # 我是父类的say方法
super函数的作用
super函数的用法
class Person(object):
def add(self, a, b):
return a + b
class Chinese(Person):
def add(self):
result = super().add(1, 2)
print(result)
c = Chinese()
c.add() # 3
什么是类的多态
多态与多态性是两种概念
多态的用法
示例代码：
import abc
class Animal(metaclass=abc.ABCMeta): # 同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class Cat(Animal): # 动物的形态之一:猫
def talk(self):
print(‘say miaomiao‘)
class Dog(Animal): # 动物的形态之二:狗
def talk(self):
print(‘say wangwang‘)
class Pig(Animal): # 动物的形态之三:猪
def talk(self):
print(‘say aoao‘)
c = Cat()
d = Dog()
p = Pig()
def func(obj):
obj.talk()
func(c)#say miaomiao
func(d)#say wangwang
func(p)#say aoao
什么是多重继承
多重继承的方法
示例代码：
class A:
def aa(self):
print("aa")
class B:
def bb(self):
print("bb")
class C(B, A):
def cc(self):
print("cc")
c = C()
c.cc() # cc
c.bb() # bb
c.aa() # aa
str
如果定义了该函数，当print当前实例化对象的时候，会返回该函数的return信息
用法：
def __str__(self):
return str_type
参数：
返回值：
示例代码：
class Person(object):
def __str__(self):
return ‘这是个测试类‘
ckk = Person()
print(ckk) # 这是个测试类
getattr
当调用的属性或者方法不存在时，会返回该方法定义的信息
方法：
def __getattr__(self,key):
print(something..)
参数：
返回值：
示例代码：
class Person(object):
def __getattr__(self, item):
print(f‘这个{item},不存在‘)
ckk = Person()
ckk.name#这个name,不存在
setattr
拦截当前类中不存在的属性与值
用法：
def __setattr__(self,key,value):
self.__dict__[key]=value
参数：
返回值：
示例代码：
class Person(object):
def __setattr__(self, key, value):
if key not in self.__dict__:
self.__dict__[key] = value
t = Person()
t.name = ‘ckk‘
print(t.name) # ckk
call
本质是将一个类编程一个函数
用法：
def __call__(self,*args,**kwargs):
print(‘call will start‘)
参数：
返回值：
示例代码：
class Person(object):
def __call__(self, **kwargs):
print(‘args is {}‘.format(kwargs))
t = Person()
t(name=‘ckk‘) # args is {‘name‘: ‘ckk‘}
原文：https://www.cnblogs.com/gockk/p/15247276.html