python面向对象学习

面向对象

基本概念

基本概念：

类：相同属性和方法的对象的集合。定义每个对象共有的属性和方法。对象是类的实例

类变量：在类中，但在方法之外，修改后，所有实例的都会跟着改变

实例变量：简单来说就是带有self的变量，每个实例都不同

局部变量：在函数里面的变量

class MyClass:
    class_var = 0 # 类变量

    def __init__(self, instance_var):
        self.instance_var = instance_var # 实例变量

    def my_method(self, local_var):# local_var为局部变量
        print('class_var:', MyClass.class_var)
        print('instance_var:', self.instance_var)
        print('local_var:', local_var)
        
        MyClass.class_var += 1
        self.instance_var += 1
        local_var += 1
        
        print('modified class_var:', MyClass.class_var)
        print('modified instance_var:', self.instance_var)
        print('modified local_var:', local_var)

obj1 = MyClass(10)
obj1.my_method(30)

class_var: 0

instance_var: 10

local_var: 30

modified class_var: 1

modified instance_var: 11

modified local_var: 31

obj2 = MyClass(20)
obj2.my_method(40)

class_var: 1

instance_var: 20

local_var: 40

modified class_var: 2

modified instance_var: 21

modified local_var: 41

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -12)
print(x.i, x.r)

-12 3.0

类方法与普通方法的不同在于需要有一个self的参数

class Test:
    def prt(self):
        print(self) # self指实例对象
        print(self.__class__) # self.__class__指类
t = Test()
t.prt()

<main.Test object at 0x000001EBA6144B48>

<class 'main.Test'>

class MyClass:
    # 双下划线为类私有属性，类中的其他方法和属性可以使用它，但它不能从外部直接访问或修改。
    # 单下划线的类变量，只是一个惯例，依旧可以从外部直接访问和修改
    class_var1 = 1   # 定义单下划线的类变量
    __class_var2 = 2 # 定义双下划线的类变量

    def __init__(self):
        # __private_inst_var 也以双下划线开头，所以它被视为私有的实例变量。同样，它不能从类外部直接访问或修改。
        self.__instance_var = 3  # 定义双下划线的实例变量

    def modify_vars(self):
        MyClass.class_var1 = 4  # 修改单下划线的类变量
        MyClass.__class_var2 = 5 # 修改双下划线的类变量
        self.__instance_var = 6  # 修改双下划线的实例变量

    def print_vars(self):
        print(MyClass.class_var1)  # 打印单下划线的类变量
        print(MyClass.__class_var2) # 打印双下划线的类变量 类名.类变量
        print(self.__instance_var)  # 打印双下划线的实例变量 self通常指类

# 创建类的实例
obj = MyClass()

# 打印变量值
obj.print_vars()   # 输出 1, 2, 3

# 修改变量值
obj.modify_vars()

# 打印变量值
obj.print_vars()   # 输出 4, 5, 6

1

2

3

4

5

6

继承

子类也即派生类，父类也即基类

单继承

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 说：我 %的岁。" %(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岁,我在读%s " %(self.name, self.age, self.grade))

s = student('luyu', 23, 57.6, '研一')
s.speak()

luyu说:我23岁,我在读研一

多继承

注意：若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

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):
    def __init__(self, n, a, w, g, t):
        student.__init__(self, n, a, w, g)
        speaker.__init__(self, n, t)
test = sample("luyu", 23, 56.6, "研一",'Python')
test.speak()

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

方法重写

super()方法用来调用被覆盖的父类方法

class Parent:
    def myMethod(self):
        print("调用父类方法")

class Child(Parent):
    def myMethod(self):
        print("调用子类方法")
c = Child()
c.myMethod()
super(Child, c).myMethod()

调用子类方法

调用父类方法

子类是否继承父类__init__()构造函数

需要自动继承，则在子类中不需要重写__init__()

class Father:
    def __init__(self, name):
        self.name = name
        print("name:%s" %(self.name))
    def getName(self):
        return 'Father' + self.name

class Son1(Father):
    def getName(self):
        return 'Son1 ' + self.name
son1 = Son1('luyu')
print(son1.getName())
        

name:luyu

Son1 luyu

不需要自动调用父类的方法，需要重写__init__()方法

class Son2(Father):
    def __init__(self, name):
        self.name = name
        print ( "hi" )
    def getName(self):
        return 'Son2 ' + self.name
son2 = Son2('luyu')
print(son2.getName())

hi

Son2 luyu

重写但是又需要调用父类方法

这种方式依次执行子类__init__()函数

例如本例中会先调用父类方法，再继续执行子类方法

class Son3(Father):
    def __init__(self, name):
        super(Son3, self).__init__(name) # 或者也可以写   Father.__init__(self, name)
        print ("hi")
        self.name =  name + " is beautiful"
    def getName(self):
        return 'Son3 ' + self.name
    
son3 = Son3('luyu')
print(son3.getName())

hi

name:luyu is beautiful

Son3 luyu is beautiful

类的私有属性与方法

在变量前或者方法前加双引号就可以把变量与方法变为私有属性与私有方法了

私有属性

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

私有方法

class Site:
    def __init__(self, name, url):
        self.name = name
        self.__url = url
    def who(self):
        print('name: ',self.name)
        print('url: ', self.__url)
    def __foo(self):
        print("这是私有方法")
    def foo(self):
        print("这是公共方法")
        self.__foo()
x = Site('菜鸟教程', 'www.runoob.com')
x.who()
x.foo()
# x.__foo() 报错，不能访问
        

name: 菜鸟教程

url: www.runoob.com

这是公共方法

这是私有方法

类的专有方法

重载函数

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector(%d, %d)' % (self.a, self.b)
    def __add__(self,other):
        return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

Vector(7, 8)