学习Python语法--面向对象基础

基本定义

• 创建类的语法：class 类名:

• 类的名称命名首字母大写&驼峰式命名；

例子：

class Message:

    def __init__(self,content):
        self.data=content
    
    def send_email(self,mail):
        data="给{}发邮件，内容是：{}".format(email,self.data)
        print(data)
    
    #对象名=类名() 
    msg_object = Message("注册成功")

• 创建对象，会自动执行类中的初始化方法_init_方法；

• 面向对象的思想： 将一些数据封装到对象中，在执行方法时，再去对象中获取；函数式思想：
  函数内部需要的数据均通过参数的形式传递；

• self，本质上就是一个参数。这个参数是Python内部会提供，其实质是“调用当前方法的那个对象”；

• 对象，基于类实例化出来的“一块内存”，默认里面没有数据；经过类的_init_方法，可以在内存中初始化一些数据。

• 实例变量，属于对象，每个对象中各自维护自己的数据。

• 类变量，属于类，可以被所有对象共享，一般用于给对象提供公共数据（类似于全局变量）。

两个例子用于演示两种变量的区别

例子1：

class Person(object):
    country='中国'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        message="{}-{}-{}".format(self.country,self.name,self.age)
        print(message)

print(Person.country) #中国
p1=person("pmt",20)
print(p1.country) #中国
p1.country="China"#在对象p1中新增实例变量 country="China"
print(p1.country) #China
print(Person.country) #中国
Person.country="法国"
print(Person.country) #法国

例子2：

class Parent(object):
    x=1
class Child1(Parent):
    pass
class Child2(Parent):
    pass

print(Parent.x,Child1.x,Child2.x) #1 1 1
Child1.x=2
print(Parent.x,Child1.x,Child2.x) #1 2 1
Parent.x=3
print(Parent.x,Child1.x,Child2.x) #3 2 3

方法

• 绑定方法
• 类方法
• 静态方法：静态方法是一种特殊的方法，它不需要访问类的实例，也不需要访问类的属性或其他方法。它是属于类本身的方法，但在方法体内不会涉及实例 (self) 或类对象 (cls)。静态方法通常用于一些逻辑上与类相关但不依赖于类或实例本身的功能。

例子：

class Foo(object):
    
    def __init__(self,name,age):
        self.name=name
        self.age=age
    
    def f1(self):
        print("绑定方法"，self.name)
    
    @classmethod
    def f2(cls):
        print("类方法"，cls)
    
    @staticmethod
    def f3():
        print("静态方法")

# 绑定方法（对象）
obj = Foo("pmt",20)
obj.f1()

#类方法
Foo.f2()# cls就是当前调用这个方法的类
obj.f2()# cls就是当前调用这个方法的对象的类

#静态方法
#不管是通过类名还是通过实例调用，静态方法的行为是相同的，因为它与实例和类无关。
Foo.f3() #通过类调用
obj.f3() #通过实例调用
#在Python中比较灵活，方法都可以通过对象和类进行调用；而在Java、c#等语言中，绑定方法只能由对象调用；类方法或静态方法只能由类调用

属性

属性其实是由绑定方法+特殊装饰器组合创造出来的，让我们以后在调用方法是可以不加括号，属性（attributes）是对象中与数据相关的命名属性。属性可以是用于存储数据的变量，也可以是通过方法或函数计算得到的值。

例子：

基础属性

class Dog:
    def __init__(self, name, age):
        self.name = name  # Public attribute（公有属性）
        self.__age = age  # Private attribute（私有属性）

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age >= 0:
            self.__age = age
        else:
            print("Age cannot be negative")

# 使用类
dog = Dog("Buddy", 5)
print(dog.name)  # 输出: Buddy

# 访问私有属性需要通过方法
print(dog.get_age())  # 输出: 5
dog.set_age(6)
print(dog.get_age())  # 输出: 6

• self.name 是一个公有属性，可以直接在类外部访问。
• self.__age 是一个私有属性，外部不能直接访问，需要通过 get_age 和 set_age 方法访问和修改。
• 插一嘴成员修饰符：Python中的成员修饰符就是指公有、私有（只有在类的内部才可以调用该成员，私有成员是以两个下划线开头，则表示该成员为私有，可以是变量，也可以是方法）。

例子：
私有方法

class Foo(object):
    def get_age(self):
        print("公有的get_age")
    def __get_data(self):
        print("私有的__get_data方法")
    def proxy(self):
        print("公有的proxy")
        self.__get_data()
obj=Foo()
obj.get_age()
obj.proxy()

属性方法（@property）

属性方法是使用 @property 装饰器定义的，它使得方法像访问属性一样进行调用，并能够实现动态值计算和控制对属性的访问。

例子：

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    @property
    def radius(self):
        return self.__radius

    @radius.setter
    def radius(self, radius):
        if radius >= 0:
            self.__radius = radius
        else:
            raise ValueError("Radius cannot be negative")

    @property
    def area(self):
        import math
        return math.pi * (self.__radius ** 2)

# 使用类
circle = Circle(5)
print(circle.radius)  # 输出: 5
print(circle.area)    # 输出: 78.53981633974483

# 修改半径
circle.radius = 7
print(circle.radius)  # 输出: 7
print(circle.area)    # 输出: 153.93804002589985

# 试图设置负值会引发错误
try:
    circle.radius = -2
except ValueError as e:
    print(e)  # 输出: Radius cannot be negative

解释

• @property 定义了只读属性 radius 和 area。属性方法 radius 当作属性来访问时，调用 radius 方法。
• @radius.setter 定义了 radius 的赋值方法，允许在外部修改 radius。通过检查 radius 的值，防止设置负值。
• area 属性通过计算获取圆的面积，不需要显式方法调用
• 在Python中， raise 关键字用于显式地引发（或抛出）一个异常。 当程序中的某个条件不符合预期或者需要中断当前执行流程时，可以使用 raise 来触发一个异常。 当 raise 语句被执行时，它会停止当前的代码执行，并立即跳转到相应的 except 块去处理异常。