【python】python面向对象基础（1）

Python是一种面向对象的编程语言，它允许开发者使用类和对象来组织代码。下面是一个Python面向对象编程的全攻略：

面向对象概念

1. 类和对象的概念：

   • 类是一个抽象的概念，它定义了一组属性和方法。通过类，可以创建对象。
   • 对象是类的具体实例，它具有类定义的属性和方法。

2. 定义类：

   • 使用class关键字来定义类。类名应该遵循大驼峰命名法的约定。
   • 在类中定义属性和方法。属性是类的状态，方法是类的行为。

class MyClass:
    def __init__(self, name):
        self.name = name
    
    def say_hello(self):
        print("Hello, " + self.name)

# 创建对象
obj = MyClass("World")
obj.say_hello()  # 输出：Hello, World

3. 实例属性和类属性：
   • 实例属性是每个对象独有的属性。可以在__init__方法中初始化实例属性。
   • 类属性是所有对象共享的属性。可以在类定义之外直接定义类属性。

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

    def get_area(self):
        return self.pi * self.radius * self.radius

# 创建对象
c1 = Circle(5)
c2 = Circle(3)

print(c1.get_area())  # 输出：78.53975
print(c2.get_area())  # 输出：28.27431

4. 方法：
   • 方法是类的函数。可以在方法的第一个参数中使用self来引用对象自身。
   • 可以定义特殊的方法，如__init__（构造函数）、__str__（字符串表示）等。

魔法方法

魔法方法（Magic methods）也称为特殊方法（special methods）或双下划线方法（dunder methods），它们在 Python 中有特殊的使用方式和行为。这些方法使用双下划线（__）作为前缀和后缀，用于定义类的一些特殊行为和操作。

一些常用的魔法方法包括：

• __init__：初始化方法，用于创建和初始化对象。
• __str__：返回对象的字符串表示形式，通常用于打印或显示对象。
• __repr__：返回对象的“官方”字符串表示形式，通常用于调试和对象的重建。
• __len__：返回对象的长度（元素个数），通常用于支持内置函数 len()。
• __add__、__sub__、__mul__、__div__ 等：定义对象的加法、减法、乘法、除法等运算。
• __eq__、__ne__、__lt__、__gt__ 等：定义对象的相等、不相等、小于、大于等比较操作。

通过定义这些魔法方法，我们可以自定义对象在不同上下文中的行为，使其具有类似内置类型的功能和特性。

self关键字

self是一个特殊的关键字，在Python中常用来表示当前对象的引用。在类定义中，self用于访问该类的实例变量和实例方法。

在类的方法中，self作为第一个参数传递，用于引用该方法所属的实例对象。通过self可以访问该实例对象的属性和其他方法。

例如：

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

    def say_hello(self):
        print("Hello, my name is", self.name)

person1 = Person("John")
person1.say_hello()  # 输出：Hello, my name is John

在上面的例子中，self.name引用了该实例对象的name属性。在say_hello方法中，通过self.name访问了实例对象的name属性。

内置属性

__slots__是Python中的一个特殊属性，用于限制类的实例只能拥有特定的属性。它是一个包含字符串的元组，每个字符串表示一个允许的属性名。

使用__slots__可以节省内存空间，因为它会告诉解释器不需要为实例中的每个属性创建一个字典。另外，由于属性被限制在__slots__中指定的名字中，所以可以提高属性名字的访问速度。

class MyClass:
    __slots__ = ('name', 'age')

    def __init__(self, name, age):
        self.name = name
        self.age = age

my_obj = MyClass('John', 25)
print(my_obj.name)  # 输出: John
print(my_obj.age)  # 输出: 25
my_obj.address = '123 Main St'  # 报错，__slots__中没有包含address属性

module: 返回对象所在的模块的名称。可以用来获取对象所在的模块的名称。

class: 返回对象所属的类。可以用来获取对象所属的类。

dict: 返回一个字典，包含对象的所有属性和方法。字典的键是属性和方法的名称，值是属性和方法的值。可以用来获取对象的所有属性和方法。

例如，假设有一个对象obj，可以通过以下方式访问这些特殊属性：

obj.__module__  # 获取对象所在的模块的名称
obj.__class__  # 获取对象所属的类
obj.__dict__  # 获取对象的所有属性和方法

需要注意的是，一般情况下，我们不需要直接使用这些特殊属性，而是通过常规的方式来访问对象的属性和方法。这些特殊属性主要用于内省（introspection）和调试的目的。

getitem、setitem和delitem方法

class Foo(object):
	def __getitem__(self, key):
		print('__getitem__', key)

	def __setitem__(self, key, value):
		print('__setitem__', key, value)
	
	def __delitem__(self, key):
		print('__delitem__', key)
		
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'laowang' # 自动触发执行 __setitem__
del obj['k1'] # 自动触发执行 __delitem__

练习：

1. 创建一个类来表示一个简单的银行账户，包括存款和取款的方法，并对账户余额进行管理。

class BankAccount(object):
    def __init__(self, balance=0):
        self.balance = balance

    # 方法名：deposit-存款
    # 参数：amount-存款金额
    # 返回值：无
    def deposit(self, amount):
        self.balance += amount

    # 方法名：withdraw-取款
    # 参数：amount-取款金额
    # 返回值：无
    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
        else:
            print("Insufficient funds")

    # 方法名：get_balance-获取余额
    # 参数：无
    # 返回值：余额
    def get_balance(self):
        return self.balance


user1 = BankAccount(1000)
print(user1.get_balance())
user1.deposit(500)
print(user1.get_balance())
user1.withdraw(200)
print(user1.get_balance())

1000
1500
1300

2.创建一个类来表示一个简单的学生，包括姓名、年龄和成绩，并添加方法来计算学生的平均成绩。

class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.score = []

    # 添加成绩信息
    def add_score(self, score):
        self.score.append(score)

    # 获取平均成绩
    def get_average_score(self):
        return sum(self.score) / len(self.score) if self.score else 0


stu1 = Student("张三", 18)
stu1.add_score(90)
stu1.add_score(85)
stu1.add_score(75)
stu1.get_average_score()
print(f"{stu1.name}的平均成绩是{stu1.get_average_score():.2f}")

张三的平均成绩是83.33

3. 创建一个类来表示一个简单的汽车，包括属性如品牌、型号、颜色，并添加方法来启动和停止汽车。

class Car(object):
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color
        self.is_running = False

    def start(self):
        if self.is_running == False:
            self.is_running = True
            print(f"The {self.brand} {self.model} {self.color} car is starting.")
        else:
            print(f"The {self.brand} {self.model} {self.color} car is already running.")

    def stop(self):
        if self.is_running == True:
            self.is_running = False
            print(f"The {self.brand} {self.model} {self.color} car is stopping.")
        else:
            print(f"The {self.brand} {self.model} {self.color} car is already stopped.")


car1 = Car("Volkswagen", "Polo", "black")
car1.start()
car1.stop()

The Volkswagen Polo black car is starting.
The Volkswagen Polo black car is stopping.

4. 创建矩形类，包括面积和周长的计算方法，并添加展示信息的方法

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        if self.length > 0 and self.width > 0:
            return self.length * self.width
        else:
            return "Invalid dimensions"

    def perimeter(self):
        if self.length > 0 and self.width > 0:
            return 2 * (self.length + self.width)
        else:
            return "Invalid dimensions"

    def display(self):
        print(
            f"这是一个长{self.length}宽{self.width}的矩形，面积{self.area()}周长{self.perimeter()}。"
        )


rectangle = Rectangle(5, 3)
rectangle.display()

这是一个长5宽3的矩形，面积15周长16。

5. 创建一个Car，包括品牌和速度属性，并添加加速和减速的方法。

class Car:
    # 属性初始化：brand-品牌和velocity-速度
    def __init__(self, brand, velocity=0):
        self.brand = brand
        self.velocity = velocity

    # 方法：加速
    # 参数：加速速度
    def accelerate(self, acceleration):
        self.velocity += acceleration

    # 方法：刹车
    # 参数：刹车速度
    def brake(self, brake):
        if self.velocity - brake >= 0:
            self.velocity -= brake
        else:
            self.velocity = 0

    # 方法：获取当前速度
    # 返回：当前速度
    def get_velocity(self):
        return self.velocity
    
my_car=Car("BMW")
my_car.accelerate(100)
print(my_car.get_velocity())
my_car.brake(50)
print(my_car.get_velocity())
my_car.brake(100)
print(my_car.get_velocity())

100
50
0