Python 面向对象编程

标签：__ Python self 面向对象编程 print class def 属性

一、面向对象编程

1.1 面向过程与面向对象

在理解面向对象编程（OOP）之前，我们先要了解 面向过程（POP） 和 面向对象（OOP） 的区别。

1.1.1 面向过程（POP）

-面向过程的编程思想将一个功能分解为一个一个小的步骤，我们通过完成一个一个的小的步骤来完成一个程序

- 这种编程方式，符合我们人类的思维，编写起来相对比较简单

- 但是这种方式编写代码的往往只适用于一个功能，如果要在实现别的功能，即使功能相差极小，也往往要重新编写代码，所以它可复用性比较低，并且难于维护

优点：简单直观、性能高效、代码简洁。

缺点：不易维护、不易扩展、代码重用性低。

例如：

# 面向过程编程示例
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

result = add(5, 3)
print(result)

1.1.2 面向对象（OOP）

- 面向对象的编程思想，将所有的功能统一保存到对应的对象中比如，妈妈功能保存到妈妈的对象中，孩子的功能保存到孩子对象中。要使用某个功能，直接找到对应的对象即可

- 这种方式编写的代码，比较容易阅读，并且比较易于维护，容易复用。

- 但是这种方式编写，不太符合常规的思维，编写起来稍微麻烦一点

优点：模块化、安全性高、代码重用性高。

缺点：学习难度大、性能开销大、调试困难。

例如：

# 面向对象编程示例
class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(5, 3))

1.2 类和对象

目前我们所学的python中的内置类型都是对象——内置对象，内置对象有时候不能满足我们的需求，需要自定义一些对象。

10， 20， 30， -40， a=10, b=20等等等，都是整数，对其进行抽象——int类。

python 中一切都是对象。

类也是一个对象。

1.2.1 类的定义与实例化对象

在面向对象编程中，类是对象的蓝图，它定义了对象的属性和方法。通过类创建对象（即实例化类），每个对象都有自己的属性和方法。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        print(f"{self.name} says woof!")
        
# 实例化对象
dog = Dog("Buddy", 3)
dog.bark()  # 输出: Buddy says woof!

1.2.2 访问属性/方法

使用符号 . 进行访问

# 访问属性
对象名.属性
# 访问方法
对象名.方法名()

1.2.3 对象与类的关系【1】

对象拥有类的所有属性和方法
对象的属性和方法可以单独添加、删除、修改
对象与对象之间的属性和方法不可共享
对象不能独自创建，必须依托于类，类可以实例化N个对象

类是对象的模板。对象是类的实例化，每个对象都有自己独立的属性，但方法是共享的。

# 类与对象的关系
class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")

1.2.3 对象与类的关系【2】

类定义了对象的结构和行为，而对象是类的具体实例。类中定义的变量叫做实例变量，每个对象拥有独立的实例变量，而类变量是所有对象共享的。

class Animal:
    species = "Unknown"  # 类变量
    
    def __init__(self, name):
        self.name = name  # 实例变量

cat = Animal("Whiskers")
print(cat.species)  # 输出: Unknown

还可以使用以下函数的方式来访问属性：

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

1.2.5 魔方方法——构造函数与析构函数

构造函数（__init__）：在创建对象时自动调用，用来初始化对象。
析构函数（__del__）：当对象销毁时自动调用，用于清理资源。
__str__ 打印方法：输出执行信息，自动执行。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model
        print(f"{self.make} {self.model} created.")
    
    def __del__(self):
        print(f"{self.make} {self.model} destroyed.")

car = Car("Toyota", "Corolla")
del car

1.2.6 类属性/方法与实例对象属性/方法与静态方法

class MyClass:
    class_variable = 10
    

    #实例方法中能调用类属性、实例属性
    def instance_method(self):
        print(f"Instance method: {self.class_variable}")
    

    #类方法中只能调用类属性和类方法
    @classmethod
    def class_method(cls):
        print(f"Class method: {cls.class_variable}")
    

    #静态方法
    @staticmethod
    def static_method(x):
        print(f"{x}Static method: This doesn't access instance or class.")

obj = MyClass()
#调用实例方法
obj.instance_method()
MyClass.instance_method(obj)
#调用类方法
obj.class_method()
MyClass.instance_method()
# 调用静态方法
MyClass.instance_method(x)
obj.static_method(x)

1.2.7 Python的内置类属性

Python 中的类有一些内置的属性，比如 :

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

print(MyClass.__name__)  # 输出: MyClass
print(MyClass.__dict__)  # 输出类的属性和方法字典

1.3 类的封装【私有属性与方法】

封装是类的三大特性之一。

封装指的是隐藏对象中一些不希望让外部所访问的属性或方法。

python中封装其实是通过设置访问权限来体现的，私有属性和私有方法是控制访问权限的组成部分。

1.3.1 私有属性

私有属性以双下划线开头，表示该属性不可从类外直接访问。

class MyClass:
    def __init__(self):
        self.__private = "I am private"
    
    def __private_method(self):
        print("Private method")

obj = MyClass()
# print(obj.__private)  # 会抛出 AttributeError

1.3.2 私有方法

私有方法也以双下划线开头，只能在类的内部调用。

class MyClass:
    def __private_method(self):
        print("This is a private method.")

    def call_private(self):
        self.__private_method()

obj = MyClass()
obj.call_private()  # 允许调用类内私有方法

1.3.3 属性装饰器

属性装饰器是实现把方法转为属性的装饰器。

作用：

把方法转为属性，便于操作属性
实现对属性的更改（验证）、查看、删除

@property 用于将实例方法转换为属性访问。

语法格式：

class 类名(object):
    def __init__(self):
        self.__名字 = xxx
    
    @property
    def 函数名(self):
        return self.__名字
    
    @函数名.setter
    def 函数名(self, m):
        self.__名字 += m

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value > 0:
            self._radius = value
        else:
            raise ValueError("Radius must be positive.")

1.4 类的继承

面向对象的编程带来的主要好处之一就是代码的重用，实现这种重用的方法之一就是通过继承机制。

通过继承创建的新类称之为【子类】或者【派生类】，被继承的类称之为【父类】、【基类】、【超类】。

1.4.1 继承语法格式

子类通过继承父类来扩展或修改父类的功能。

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

1.4.2 多继承语法【明白即可，不建议乱用】

Python 支持多继承，即一个子类可以继承多个父类。

class A:
    def method_a(self):
        print("Method A")
        
class B:
    def method_b(self):
        print("Method B")

class C(A, B):
    def method_c(self):
        print("Method C")

1.4.3 继承重写父类方法

子类可以重写父类的方法，以实现不同的行为。

class Animal:
    def sound(self):
        print("Animal makes sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

这里列出了一些通用的功能，可以在自己的类重写：

__init__ ( self [,args...] ) 构造函数简单的调用方法: obj = className(args)
__del__( self ) 析构方法, 删除一个对象简单的调用方法 : del obj
__repr__( self ) 转化为供解释器读取的形式简单的调用方法 : repr(obj)
__str__( self ) 用于将值转化为适于人阅读的形式简单的调用方法 : str(obj)
__cmp__ ( self, x ) 对象比较简单的调用方法 : cmp(obj, x)

1.4.4 Python继承特点

在子类中如果需要父类的构造方法，需要显式调用父类的构造方法，或者不重写父类的构造方法。__init__()
在子类中调用父类的方法，需要显式调用，且第一个参数self不能省略。

class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def fun1(self):
        print(self.x , self.y)
# 不重写父类构造方法
c = Child(1, 2)
c.fun1()

class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def __init__(self, x, y, z):
        Parent.__init__(self, x, y)
        self.z = z

    def fun1(self):
        print(self.x , self.y, self.z)

# 重写父类构造方法、里面显式调用父类构造方法
c = Child(1, 2, 33)
c.fun1()

1.4.5 运算符重载

在Python中，并没有像其他语言（如C++）中那样的内置机制来重载运算符。但是，你可以通过定义特定的方法来模拟运算符重载的行为。

以下是一些常见运算符以及它们对应的特殊方法：

加法：+ 对应 __add__

减法：- 对应 __sub__

乘法：* 对应 __mul__

除法：/ 对应 __truediv__

取模：% 对应 __mod__

幂运算：** 对应 __pow__

位运算：<< 对于__lshift__

位运算：>> 对应 __rshift__

位运算：& 对应 __and__

位运算：| 对应 __or__

位运算：^ 对应 __xor__

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

1.5 类的多态

多态允许不同类的对象通过相同的接口调用不同的实现，通常通过继承和方法重写来实现。

class Animal(object):
    name = '动物'
    age = 0
    def speak(self):
        print("动物的声音")

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

a = Animal()
d = Dog()
c = Cat()

a.speak()
d.speak()
c.speak()

1.6 关于下划线说明

__foo__: 以双下划线开头双下划线结尾，定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的，自动。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import ···
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

标签：__,Python,self,面向对象编程,print,class,def,属性
From： https://blog.csdn.net/qwe352/article/details/143750287

一、面向对象编程

1.1 面向过程与面向对象

1.1.1 面向过程（POP）

1.1.2 面向对象（OOP）

1.2 类和对象

1.2.1 类的定义与实例化对象

1.2.2 访问属性/方法

1.2.3 对象与类的关系【1】

1.2.3 对象与类的关系【2】

1.2.5 魔方方法——构造函数与析构函数

1.2.6 类属性/方法与实例对象属性/方法与静态方法

1.2.7 Python的内置类属性

1.3 类的封装【私有属性与方法】

1.3.1 私有属性

1.3.2 私有方法

1.3.3 属性装饰器

1.4 类的继承

1.4.1 继承语法格式

1.4.2 多继承语法【明白即可，不建议乱用】

1.4.3 继承重写父类方法

1.4.4 Python继承特点

1.4.5 运算符重载

1.5 类的多态

1.6 关于下划线说明

相关文章

赞助商

阅读排行

Python 面向对象编程

一、面向对象编程

1.1 面向过程与面向对象

1.1.1 面向过程（POP）

1.1.2 面向对象（OOP）

1.2 类和对象

1.2.1 类的定义与实例化对象

1.2.2 访问属性/方法

1.2.3 对象与类的关系【1】

1.2.3 对象与类的关系【2】

1.2.5 魔方方法——构造函数与析构函数

1.2.6 类属性/方法 与 实例对象属性/方法 与 静态方法

1.2.7 Python的内置类属性

1.3 类的封装【私有属性与方法】

1.3.1 私有属性

1.3.2 私有方法

1.3.3 属性装饰器

1.4 类的继承

1.4.1 继承语法格式

1.4.2 多继承语法【明白即可，不建议乱用】

1.4.3 继承重写父类方法

1.4.4 Python继承特点

1.4.5 运算符重载

1.5 类的多态

1.6 关于下划线说明

相关文章

赞助商

阅读排行

1.2.6 类属性/方法与实例对象属性/方法与静态方法