面向对象编程

1.面向对象编程介绍

1. 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
2. 方法：类中定义的函数。
3. 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
4. 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
5. 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
6. 局部变量：定义在方法中的变量，只作用于当前实例的类。
7. 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
8. 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
9. 实例化：创建一个类的实例，类的具体对象。
10. 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。

2.定义类

定义类的基本形式为：
Class <类名><父类名>:
Pass

Class:定义类的关键字
类名:符合标志符规范的名称
父类名:该类继承的父类名称
Pass: 空语句

3.使用类

类在定义后必须先实例化才能使用，一个类可以实例化成多个实例，实例与实例之间互不影响。
[root@python python]# cat 01.py

#!/usr/bin/python
class MyClass:
	"""类的实例"""
	i = 12345
	def f(self):
             return 'hello world'
#实例化类
x = MyClass()
#访问类的属性和方法
print ("MyClass 类的属性 i 为: ",x.i)
print ("MyClass 类的方法 f 为: ",x.f())

[root@python python]# python 01.py
MyClass 类的属性 i 为: 12345
MyClass 类的方法 f 为: hello world

4.类的属性和方法

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

4.1 类的方法

1.方法的第一个参数必须是self，而且不能省略;
2.方法的调用必须实例化类，并以实例名.方法名(参数列表)形式调用；
3.整体运行一个单位的缩进，表示其属于类体中的内容；
[root@python python]# cat 02.py

#!/usr/bin/python
class SmpClass:

	def info(self):
		return "我定义的类!"
	
	def mycacl(self,x,y):
		return x + y
sc = SmpClass()
print ("调用info方法的结果: ",sc.info())
print("调用mycacl方法的结果: ",sc.mycacl(3,4))

[root@python python]# python 02.py
调用info方法的结果: 我定义的类!
调用mycacl方法的结果: 7

4.2 类的属性

类的属性有两类:
1.实例属性
2.类属性
实例属性即同一个类的不同实例，其值是互不关联的，也不会相互影响的，定义时使用”self.属性名”,调用时也使用它；类属性则是同一个类的所有实例所共有的，直接在类中对立定义，引用时使用”类名.类变量名”来引用,只要是某个实例对其进行修改，就会影响其他的所有这个类的实例。
[root@python python]# cat 03.py

#!/bin/usr/python
class demo_pro():
	class_name="demo_pro" #类属性
	def __init__(self,x=0):
		self.x=x      #实例属性
	def class_info(self):
		print('类变量值:', demo_pro.class_name)
		print('实例变量值:',self.x)
	def chng(self,x):
		self.x=x
	def chng_cn(self,name):
		demo_pro.class_name=name
dpa=demo_pro()
dpb=demo_pro()
print('初始化两个实例')
dpa.class_info()
dpb.class_info()
print('修改实例变量')
print('修改dpa实例变量')
dpa.chng(3)
dpa.class_info()
print('修改dpb实例变量')
dpb.chng(10)
dpa.class_info()
dpb.class_info()
print('修改类变量')
print('修改dpa类变量')
dpa.chng_cn('dpa')
dpa.class_info()
dpb.class_info()
print('修改dpb实例变量')
dpb.chng_cn('dpb')
dpa.class_info()
dpb.class_info()

5.定义构造方法

类定义了 init() 方法，类的实例化操作会自动调用 init() 方法。init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。
[root@python python]# cat 03.py

#!/usr/bin/python

class Demoint:
	def __init__(self,x=2,y=1):
		self.x01 = x
		self.y01 = y
	def mycacl(self):
		return self.x01 + self.y01

dia = Demoint(1)

print("调用mycacl方法的结果1:")
print(dia.mycacl())

dib = Demoint(3,7)
print("调用mycacl方法的结果2:")
print(dib.mycacl())

[root@python python]# python 03.py
调用mycacl方法的结果1:
2
调用mycacl方法的结果2:
10

6.静态方法

静态方法定义时应使用装饰器@staticmethod 进行修饰，它是没有默认参数的。类方法定义时应使用装饰器@classmethod进行修饰，必须有默认参数“cls”。它们的调用方式可以直接由类名进行调用，调用前可不用实例化类。
[root@localhost 6]# cat 6.6.python

#!/usr/bin/python
class demo():
	@staticmethod    #静态方法的装饰器
	def static_mthd():  #静态类的定义
		print('调用了静态方法!')
	@classmethod     #类方法的装饰器             
	def class_mthd(cls): #类方法定义，带默认参数cls
		print('调用了类方法!')
demo.static_mthd()
demo.class_mthd()
dm=demo()
dm.static_mthd()
dm.class_mthd()

7.类的继承

[root@python python]# cat 04.py

#!/usr/bin/python
class people:
	name = ''
	age = 0
	#定义私有属性，私有属性在lei 外部无法直接进行访问
	__weight = 0
	def __init__(self,n,a,w):
		self.name = n
		self.age = a
		self.__weight = w
	def speak(self):
		print("%s 说: 我 %d 岁。" %(self.name,self.age))
class student(people):
	grade = ''
	def __init__(self,n,a,w,g):
		#调用父类的构函
		people.__init__(self,n,a,w)
		self.grade = g
	#覆写父类的方法
	def speak(self):
		print("%s 说: 我 %d 岁了，我在读 %d 年级" %(self.name,self.age,self.grade))
s = student('ken',10,6,3)
s.speak()

[root@python python]# python 04.py
ken 说: 我 10 岁了，我在读 3 年级

8.多继承

class PrntA:
    namea = 'PrntA'
    def set_value(self,a):
        self.a = a
    def set_namea(self,namea):
        PrntA.namea = namea
    def info(self):
        print('PrntA:%s,%s' % (PrntA.namea,self.a))
class PrntB:
    nameb = 'PrntB'
    def set_nameb(self,nameb):
        PrntB.nameb = nameb
    def info(self):
        print('PrntB:%s' % (PrntB.nameb,))
class Sub(PrntA,PrntB):
    pass
class Sub2(PrntB,PrntA):
    pass
class Sub3(PrntA,PrntB):
    def info(self):
        PrntA.info(self)
        PrntB.info(self)
print('使用第一个子类：')
sub = Sub()
sub.set_value('aaaa')
sub.info()
sub.set_nameb('BBBB')
sub.info()
print('使用第二个子类：')
sub2= Sub2()
sub2.set_value('aaaa')
sub2.info()
sub2.set_nameb('BBBB')
sub2.info()
print('使用第三个子类：')
sub3= Sub3()
sub3.set_value('aaaa')
sub3.info()
sub3.set_nameb('BBBB')
sub3.info()

9.方法重写

[root@python python]# cat 05.py

#!/usr/bin/python
class A():
	def myMethod(self):
		return 'AAA'
class B(A):
	def myMethod(self):
		return 'BBB'
b=B()
print(b.myMethod())

[root@python python]# python 05.py
BBB