Python的面向对象

类定义

class MyClass:
    a = 5
    def b(self):
        return f"a:{self.a}"

类对象

# 实例化
x = MyClass()

# 属性引用
x.a

5

# 会报错 没有 a
x.b()

'a:5'

构造方法

# 构造函数即为实例化时操作的函数


class MyClass2:
    a = 5
    def __init__(self):
        self.c = 3
    def b(self):
        return f"a:{a}"

y = MyClass2()
y.c

3

我们经常使用构造方法来初始化一些参数

class MyClass3:
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c
    def sum(self):
        return self.a+self.b+self.c

z = MyClass3(1,3,4)
# 这时会提示必须传入 'a', 'b', and 'c'
z.sum()

8

析构方法

析构函数就是对象释放时会执行的方法

def __del__(self):
    self.con.close()

继承

使用面向对象设计的核心就是能够继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __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,60,3)
s.speak()

ken 说: 我 10 岁了，我在读 3 年级

多继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __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))

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

重写是在子类中定义与父类相同的名称的方法 来覆盖掉原方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

调用子类方法

类的属性与方法

类似Java的 私有属性/方法、公开属性/方法

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

1
2
2



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

 in 
     12 counter.count()
     13 print (counter.publicCount)
---> 14 print (counter.__secretCount)  # 报错，实例不能访问私有变量


AttributeError: 'JustCounter' object has no attribute '__secretCount'

0
2
1



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

 in 
     11 print (counter._protectCountSon)
     12 print (counter._protectCount)
---> 13 print (counter.__secretCount)  # 报错，实例不能访问私有变量


AttributeError: 'JustCounterSon' object has no attribute '__secretCount'