python基础--面向对象

面向对象技术简介

• 面向对象编程：（OOP）
  • 类（Class）：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 实例（Instance）：实例是根据类创建出来的一个个具体的“对象”，每个对象 都拥有相同的方法，但各自数据可能不同。
  • 数据封装：直接在类的内部定义访问数据的函数，这样就把数据封装起来了。
  • 继承：定义一个Class时，可以从某个现有的Class继承，新的Class称为基子类|派生类，而被继承的Class称为父类|基类|超类，即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 局部变量：定义在方法中的变量，只作用于当前实例的类。
  • 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
  • 方法：类中定义的函数。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

创建类

• 用 class 语句来创建一个新类

• class 之后为类的名称，类名使用驼峰命名法

• 以 : 结尾

#语法：
class ClassName:
    '类的帮助信息' #类文字字符串
    class_suite  #类体

• 类的帮助信息可以通过 ClassName.__doc__查看

• Class_suite由 类成员，方法，数据属性组成

#简单类的实例：
#创建一个员工的基类：
class Employee:
    '所有员工的基类'
    empCount = 0 #类变量：值会在所有的实例中共享
    
    #重写构造函数
    def __init__(self,name,salary):
        self.name = name 
        self.salary = salary
        Employee.empCount += 1
    
    def displayCount(self):
        print(f"Total Employee {Employee.empCount}")
        
	def displayEmployee(self):
        print(f"Name:{self.name},Salary:{self.salary}")

self关键字

• 类的方法与普通的函数只有一个特别的区别：它们必须有一个额外的第一个参数名称，按照惯例它的名称是self

• self代表的是类的实例本身，代表当前对象的地址，而self.__calss__代表类

• self在定义类的时候是必须有的，在调用时不必传入相应的参数，即传入的参数数量为定义的参数-1

创建对象

①实例化类，其他的编程语言一般使用new关键字，但是python中并没有这个关键字，类的实例化类似函数调用方式：

• 创建类实例：类名 + ()

#假设创建了一个 Employee 类
#则创建Employee的对象方法是：
e = Employe("na",22) #括号中的参数是“__init__()”方法的参数

访问属性

• 可以使用 . 来访问对象的属性。

#语法：
e.displayCount()

• 也可以使用函数访问：

getattr():访问对象的属性

#语法：
getattr(obj,name[,default])
#参数：
obj：对象
name：要访问的属性名称
default：属性不存在时，返回的默认值

hasattr():检查是否存在一个属性

#语法：
hasattr(obj,name)

setattr():设置一个属性。如果属性不存在，会创建一个新属性

#语法：
setattr(obj,name,value)
#参数：
value：属性值

delattr():删除属性

#语法：
delattr(obj,name)

__init__()

• init() 用于初始化实例，所以该方法是在实例对象创建后被调用，它是实例级别的方法，用于设置对象属性的一些初始值。
• init()至少有一个参数self，就是这个new()返回的实例（即当前对象本身），init()在new()的基础上完成一些初始化的操作。
• init()不需要返回值
• 该方法的第一个参数永远是 self，表示实例本身，因此，在该方法内部，就可以把各种属性绑定到 self，因为 self就是指向创建的实例本身。
• 有了该方法后，在创建实例的时候，就不能传递空的参数了，就必须传入与该方法匹配的参数，但 self不用传递参数，Python解释器自己会把实例变量传递进去。

__new__()

• 该方法不是一定要有，只有继承自object的类才有，该方法可以return父类（通过super(当前类名, cls).new())出来的实例，或者直接是object的__new__出来的实例）。
• 值得注意的是，在定义子类时没有重新定义__new__()时，Python默认调用该类父类的__new__()方法来构造该类实例，如果该类父类也没有重写__new__()，那么将一直追溯至object的__new__()方法，因为object是所有新式类的基类。如果子类中重写了__new__()方法，那么可以自由选择任意一个其他的新式类。
• new()用于创建实例，所以该方法是在实例创建之前被调用，它是类级别的方法，是个静态方法；
• new()至少有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别；
• new()必须有返回值，返回实例对象；

内置类属性

__dict__:类的属性；（字典）

__doc__:类的文档字符串；

__name__:类名称

__module__:类定义所在的模块（类的全名是："__main__.className"；如果一个类位于导入模块mymod中，那么"__main__.className<==>mymod"）

__bases__:类的所有父类构成元素（元组）

python对象销毁（垃圾回收）

①python使用引用计数来跟踪和回收垃圾

②在python内部记录着所有使用中的对象各有多少引用。

③一个内部跟踪变量，称为一个引用计数器

④当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，也就是说，此对象的引用计数变为0时，该对象被垃圾回收。但是回收不是立即进行的，由解释器在适当的时期，将垃圾对象占用的内存空间回收。

类的继承

①面向对象编程实现代码的重用采取的是继承机制

②通过继承创建的新类称为 子类或者派生类，被继承的类称为 基类或者父类，超类

#语法：
class 派生类名称(基类名称):
	...

③python继承的特点：

1. 如果在子类中需要父类的构造方法就显示的调用父类的构造方法，或者不重写父类的构造方法。

#使用super()调用父类构造方法，传入所需参数
super().__init__(arg)

1. 在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
2. Python总是首先查找对应的方法，如果它不能再派生类中找到对应的方法，它才会到基类中逐个查找

④多继承：

如果继承元组中列了多个类，那么就是多继承

#语法：
class SubClassName(ParentClass1[,parentClass2][,...][,parentCalssN]):
    ...

判断类的方法

type()：返回对象的类型

#语法：
type(obj)

issubclass():布尔函数判断一个类是另一个类的子类或者子孙类

#语法：
issubclass(sub,sup)

isinstance():布尔函数判断obj是Class类的实例对象或者是一个Class子类的实例对象，就返回True。

#语法：
isinstance(obj,Class)

类属性和类方法

1. __private_attr：两个下划线开头，声明该属性是私有的，不能在类的外部被使用或者直接访问。在类内部的方法中使用时 self.__private_attrs
2. 在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数
3. __private_method：两个下划线开头，声明该方法是私有的，不能在类的外部调用。在类内部的方法中使用时 self.__private_mdthod

python不允许实例化的类访问私有数据，但可以使用 object._className__attrName（对象名称._类名__私有属性名称）访问属性

①	__foo__	定义的是特殊方法，一般是系统定义的名字，类似__init__()
②	__foo	双下划线表示的是私有类型的变量，只能允许此类本身进行访问
③	_foo	单下划线表示的是保护类型的变量，只能允许此类本身和其子类访问，不能用于 from module import *

dir()：获得一个对象的所有属性和方法

面对对象高级

动态绑定

• 动态绑定：就是在类外通过 实例.属性|方法动态绑定实例的属性和方法

使用 __slots__

• __slots__：限制实例的属性。
• 使用：在类定义时，定义该变量。
• 语法：__slots__ = ('属性1','属性2')
• 解释：元组中的就是允许绑定的属性名称

class Student(object):
	__slots__ = ('name','age')

s = Student()
s.sex = 'a'
print(s.sex)

>>>AttributeError:'Student' object has no attribute 'sex'

注意：

• 使用 __slots__定义的属性仅对当前类的实例起作用，对继承的子类不起作用。

class Student(object):
	"""docstring for Student"""
	__slots__ = ('name','age')

class GraduateStudent(Student):
	pass

g =GraduateStudent()
g.sex = 'a'
print(g.sex)

>>>a

使用 @property

class Student(object):
	"""docstring for Student"""
	
    
	@property
	def score(self):	<==>    getter()
		return self._score

	@score.setter		<==>	setter()
	def score(self,value):
		if not isinstance(value,int):
			raise ValueError('score must be an integer!')
		if value < 0 or value >100:
			raise ValueError('score must between 0 and 100!')

		self._score = value

s = Student()
s.score = 12 #实际转换为：s.set_score(12)
print(s.score) #实际转换为：s.get_score()

• @property：负责把一个方法变成获取属性的方法。
• 把一个 getter方法变成属性，只需要在方法上添加 @property即可，此时，@property本身又创建了另一个装饰器 @score.setter，负责把一个setter 方法变成属性赋值。
• 定义只读属性，只定义getter方法

魔术方法

• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法

__str__(self)：只有在脚本模式打印变量，才会调用此方法。返回用户看到的字符串

__repr__(self)：当在交互模式（>>>），或者脚本模式打印变量，就会调用此方法。返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。

由于，通常__str__()和__repr__()代码都是一样的，所以，有个偷懒的写法：

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name # 自定义格式
    __repr__ = __str__

__iter__(self)：如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值
# 只要一做迭代运算，就会调用__iter__(self)方法      

__getitem__()：方法把对象视为list或dict来对集合取值，即使用下标取值就会调用此方法

__setitem__()：方法把对象视作list或dict来对集合赋值。即使用下标更改值就会调用此方法

class Person:
    def __init__(self,name,sex,age,data):
        self.name = name
        self.age = age
        self.sex =sex
        self.data = data

    def __getitem__(self,sex):
        return self.sex

p = Person('jack','nan',22,[12,3,4,5,6])
print(p['age'])
# 只要一使用[]取值，就会调用__getitem__(self,item)方法

__getattr__(self)：只有在没有找到属性的情况下，才调用__getattr__，已有的属性，不会在__getattr__中查找。

class Person:
    def __getattr__(self, item):
        if item == "name":
            return '123'
p = Person()
print(p.name)
# p.name没有找到,调用__getattr__方法

__call__(self)：任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。

class Person:
    def __call__(self):
        msg = "hello"
        return msg

p = Person()
print(p())
# 只要对实例调用，就会调用call方法
# 通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

使用枚举类

• 导包：import enum from Enum
• 创建枚举类：Enum_name = Enum("前缀","元组")
• 注意：
  • 元组必须是字符串表示元素
  • 元素必须是不能代表数字的字符串。如 '1'就不行

from enum import Enum

Month = Enum('Mon',('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'))

print(Month.Jan)