Python面向对象

        Python是一种面向对象编程的语言，它支持多种面向对象程序设计范式。面向对象程序设计的核心是类和对象。类是一种自定义类型，用于表示某些事物的属性和行为。而对象则是类的实例，表示该类所描述的事物的一个具体实例。

以下是Python面向对象编程的基本术语和概念：

1.类（class）：用于封装数据属性和操作这些属性的方法的一个模板。

2.对象（object）：类的实例，具有类定义的属性和方法。

3.属性（attribute）：类和对象拥有的数据。

4.方法（method）：类和对象拥有的函数。

5.继承（inheritance）：一个类可以从另一个类继承数据属性和方法。

6.多态（polymorphism）：同一操作作用于不同的对象，产生不同的行为。

7.封装（encapsulation）：将对象的属性和方法封装到一个类中，避免外界的直接访问。

 

注意：由于面向对象内容过多分两次发布，本次内容到方法

1.类（class）

类的定义：

在Python中，我们使用class关键字来定义一个类。在定义类时，一般包括以下几个方面：

1.类的名称：要代表类的名称。

2.类的属性：要定义类的属性和属性的默认值。

3.构造方法（init）：用于初始化类的属性。

4.类的方法：要定义类的方法，这些方法可以操作类的属性或执行类的行为。

以下是一个简单的类定义示例：

class 类名：
    属性名 = 属性值
    def 方法名(self):
        方法体

class Person:    # 定义一个Person类
    name = "John"
    age = 30

用构造方法定义类：

1.构造方法__init__()

构造方法一般用于类的初始化操作，在创建实例对象时被自动调用和执行。

2.self的作用

self的作用是代表将来要创建的实例对象本身，让实例能够访问类中的属性和对象。

3.实例方法

最少含有一个self参数，用于绑定实例对象的方法称为实例方法，可以被实例对象直接调用

以下是一个简单的用构造方法定义类的示例：

class Person:
    # 这个构造方法将在创建对象时自动调用
    def __init__(self, name):
        """初始化属性name"""
        self.name = name
    def fangfa(self):
        """实例方法1"""
        print(f"{self.name}喜欢学习python程序设计")

    def fangfa2(self):
        """实例方法2"""
        print(f"{self.name}也喜欢学习python程序设计")


# 创建一个实例对象
a1 = Person("张三")
# 在创建一个实例对象
a2 = Person("李四")
# 调用方法
a1.fangfa()    # 输出结果：张三喜欢学习python程序设计
a2.fangfa2()    # 输出结果：李四也喜欢学习python程序设计

类的使用与函数类似，当定义了一个类时，其中的代码不会被执行，当调用类来创建对象时，类中的代码才真正起作用。

类的属性：

在Python中，属性分为类属性和实例属性。类属性属于类，实例属性属于实例对象。类属性是所有实例共享的，而实例属性属于特定实例对象。

以下是几个关于类属性和实例属性的规则：

1.类属性定义在类的顶层，所有实例对象共享这些属性。

2.实例属性在创建对象之后被赋值，每个实例对象都有自己的一份属性。

3.实例属性可以使用 self 关键字在 init() 方法内进行定义和赋值。

4.实例属性和类属性的同名冲突时，实例属性会覆盖类属性。

以下是一个示例，演示如何在Python中定义和使用类属性和实例属性：

class Person:
    name = "Tom"   # 类属性

    def __init__(self, age):
        self.age = age   # 实例属性

    def print_info(self):
        print("姓名：%s，年龄：%d" % (self.name, self.age))

# 创建两个Person对象
p1 = Person(20)
p2 = Person(25)

# 打印对象的属性
print("p1.name:", p1.name)
print("p1.age:", p1.age)
print("p2.name:", p2.name)
print("p2.age:", p2.age)

# 修改类属性
Person.name = "Lucy"

# 打印对象的属性
print("p1.name:", p1.name)
print("p1.age:", p1.age)
print("p2.name:", p2.name)
print("p2.age:", p2.age)

# 修改实例属性
p1.name = "Jack"
p1.age = 30

# 打印对象的属性
print("p1.name:", p1.name)
print("p1.age:", p1.age)
print("p2.name:", p2.name)
print("p2.age:", p2.age)

# 执行对象方法
p1.print_info()
p2.print_info()

在这个示例中，我们定义了一个名为Person的类，并定义了一个类属性 name 和一个实例属性 age。然后我们创建了两个Person对象 p1 和 p2，并打印了对象的属性。我们发现，p1 和 p2 的 name 属性都是类属性的初始值，而 age 属性则是用构造方法 init() 定义的实例属性的初始值。

接着，我们修改了类属性的值，再次打印对象的属性，可以发现 p1 和 p2 的 name 属性都被成功更新了。然后，我们修改了 p1 的 name 和 age 属性，再次打印对象的属性，发现只有 p1 的属性被更新了，而 p2 的属性没有变化。这证明了实例属性只属于特定的实例对象，不会影响到其他实例。

最后，我们执行了对象方法 print_info，该方法打印了对象的信息。这表明了对象方法可以访问类的属性和实例属性。

类的方法：

在Python中，方法是定义在类中的函数，用于执行与类相关的操作。方法可以访问类中的属性，并且可以被对象调用来执行该类的特定行为。

以下是一些关于Python类方法的规则：

1.类方法使用 @classmethod 装饰器来定义，第一个参数为 cls，表示类本身。

2.静态方法使用 @staticmethod 装饰器来定义，它没有任何特定的参数。

3.对象方法的第一个参数是 self，它表示对象本身。

4.所有三种方法都可以被类和对象调用，但是类方法和静态方法更适合在类级别上执行，而对象方法更适合具体某个对象的实例上执行。

以下是一个示例，演示如何在Python中定义和使用类方法，静态方法和对象方法：

class Person:
    name = "John"
    age = 30

    def say_hello(self):
        print("Hello, my name is", self.name, "and I am", self.age, "years old.")

    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2023 - birth_year
        return cls(name, age)

    @staticmethod
    def get_older_age(age):
        return age + 10

# 调用对象方法
p1 = Person()
p1.say_hello()

# 调用类方法
p2 = Person.from_birth_year("Alice", 1995)
print("p2.name:", p2.name)
print("p2.age:", p2.age)

# 调用静态方法
older_age = Person.get_older_age(30)
print("older age:", older_age)

在这个示例中，我们定义了一个名为Person的类，并定义了一个对象方法 say_hello，一个类方法 from_birth_year 和一个静态方法 get_older_age。

我们创建了一个Person对象 p1，并使用对象方法 say_hello 来打印对象的信息。

然后我们使用类方法 from_birth_year 来创建了一个新的Person对象 p2，该方法接受两个参数，分别是名字和出生年份，然后计算出年龄并返回一个Person对象。

最后，我们使用静态方法 get_older_age 来计算某个年龄的人在 10 年后的年龄。由于静态方法不需要访问类或对象的任何属性，因此它可以独立于类或对象调用，并且可以被多次调用。

私有成员：

Python中，使用 __ 双下划线前缀可以定义私有成员，私有成员只能在类内部访问，不能在类外部访问。使用 __ 双下划线前缀定义的成员称为私有成员。

以下是一些关于Python私有成员的规则：

1.使用 __ 双下划线前缀定义私有成员，例如 __name。

2.私有成员只能在类内部访问，不能在类外部访问。

3.在类的内部，可以使用 self.__name 的方式来访问私有成员。

4.不能在类的外部使用对象名来直接访问私有成员，但是可以通过 _类名__name 的方式来访问私有成员。

以下是一个示例，演示如何在Python中定义和使用私有成员：

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def say_hello(self):
        print("Hello, my name is", self.__name, "and I am", self.__age, "years old.")

# 创建一个Person对象
p1 = Person("John", 30)

# 无法访问私有成员
#print(p1.__name)
#print(p1.__age)

# 在类内部访问私有成员
p1.say_hello()

# 通过 _类名__name 的方式访问私有成员
print(p1._Person__name)
print(p1._Person__age)

在这个示例中，我们定义了一个名为Person的类，类中包含了私有成员 __name 和 __age。我们在 init() 方法中使用双下划线前缀定义私有成员。

在类的内部，我们可以使用 self.__name 和 self.__age 的方式来访问私有成员。

在类的外部，我们不能直接访问私有成员，但是可以通过 _类名__name 的方式来访问私有成员。

尽管Python没有提供真正的私有性，但是使用 __ 双下划线前缀定义成员是一种常用的方式来实现数据封装，并防止外部修改数据。