Python编程的面向对象
面向对象的概述
Python是一种面向对象的编程语言，它支持面向对象编程（OOP）范例。以下是 Python 面向对象编程的一些关键概念和特点：
类（Class）和对象（Object）：
- 类：类是用于创建对象的蓝图或模板，定义了对象的属性和方法。
- 对象：对象是类的实例，具有类定义的属性和行为。
封装（Encapsulation）：
- 封装：封装是将数据和操作封装在类中，并通过公共接口进行访问。这样可以隐藏内部实现细节，提高安全性和可维护性。
继承（Inheritance）：
- 继承：继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而促进代码重用和扩展现有功能。
多态（Polymorphism）：
- 多态：多态性允许不同类的对象对同一方法作出响应，即使用相同的方法名称但具有不同的行为。这提高了代码的灵活性和可扩展性。
类与对象示例：
# 定义一个简单的类
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years old."
# 创建对象
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
# 调用对象的方法
print(person1.greet()) # 输出: Hello, my name is Alice and I am 30 years old.
print(person2.greet()) # 输出: Hello, my name is Bob and I am 25 years old.
以上是 Python 的面向对象编程概述及代码示例。面向对象编程提供了一种结构化的方式来组织代码，提高了代码的可重用性、灵活性和可维护性。
类的定义和对象的创建
类的定义
在Python中，类定义的语法具体如下：
class 类名：
零个到多个类变量
零个到多个方法
Python的类定义与函数定义相似，都是以冒号（：）作为类体的开始，以统一缩进的部分作为类体。区别只是函数定义使用del关键字，而类定义则使用class关键字。类名只要是一个合法的标识符即可。
类中各成员之间的定义顺序没有任何影响，各成员之间可以相互调用。Python类所包含的最重要的两个成员就是变量和方法，变量用于定义该类本身所包含的状态数据，方法则用于定义该类的对象的行为或功能实现。
class MyClass:
age = 36 # 定义类变量
name = "赵月敏"
love = ["跳舞", "唱歌", "运动"]
def myfun(self):
return "hello world!" # 定义类方法
对象的创建
类定义成功后，就可以创建对象。示例代码如下：
class MyClass:
age = 36 # 定义类变量
name = "赵月敏"
love = ["跳舞", "唱歌", "运动"]
def myfun(self):
return "hello world!" # 定义类方法
# 创建对象
myc = MyClass()
# 访问类的属性和方法
print('MyClass 类的属性age, 即年龄为:', myc.age)
print('MyClass 类的属性name, 即姓名为：:', myc.name)
print('MyClass 类的属性love，即爱好为：:', myc.love)
print('\nMyClass 类的方法myfun输出为：:', myc.myfun())
这段代码定义了一个名为 MyClass 的类，具有以下特点：
- 类变量：
age,name,love分别赋予了整数、字符串和列表的值。 - 类方法：
myfun(self)方法返回字符串 "hello world!"。 - 创建了一个名为
myc的MyClass类的对象。 - 访问了类的属性（
age,name,love）和方法(myfun)。
运行结果如下：
MyClass 类的属性age, 即年龄为: 36
MyClass 类的属性name, 即姓名为：: 赵月敏
MyClass 类的属性love，即爱好为: ['跳舞', '唱歌', '运动']
MyClass 类的方法myfun输出为：: hello world!
类的构造方法和self参数
在 Python 中，构造方法是一种特殊的方法，在创建类的实例时自动调用。构造方法通常被称为 __init__() 方法。self 参数代表类的实例本身，它必须作为第一个参数传递给类的所有方法，包括构造方法和其他实例方法。
构造方法和self参数的说明：
-
构造方法：构造方法用于初始化类的实例变量，通常用来设置对象的初始状态。
class MyClass: def __init__(self, param1, param2): self.param1 = param1 self.param2 = param2 -
self参数：
self是指向类的实例本身的引用，通过self可以访问类的属性和方法。- 在定义方法时需要将
self作为第一个参数，Python 解释器会自动传入该参数。 - 当调用实例方法时，不需要显式传递
self，Python 自动传递当前对象作为self。
- 在定义方法时需要将
示例：
下面是一个示例代码，演示了构造方法和self参数的使用：
class Person:
# 定义类的特殊方法，即构造方法
def __init__(self, name, age):
self.name = name
self.age = age
# 定义类的方法
def prt(self):
print("self代表的是类的实例，代表当前对象的地址：", self)
print("self.class指向类：", self.__class__)
# 定义类的方法
def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years old."
# 创建对象并访问属性
person1 = Person("Alice", 30)
print(person1.greet())
Hello, my name is Alice and I am 30 years old.
self代表的是类的实例，代表当前对象的地址： <__main__.Person object at 0x1028ecf50>
self.class指向类： <class '__main__.Person'>
在这个示例中：
__init__构造方法初始化了Person类的实例变量name和age。- 在
greet方法中，通过self.name和self.age访问了对象的属性。 - 创建
person1对象时，传入相应的参数，构造方法自动被调用进行初始化。
构造方法和 self 参数是 Python 面向对象编程中非常重要的概念，在创建类和操作实例时经常会用到。
类的继承
在面向对象编程中，类的继承是一种重要的概念，允许一个类（子类）从另一个类（父类）派生而来，并继承父类的属性和方法。子类可以在不改变父类的情况下，添加新的属性和方法，或者修改现有的方法实现。
类的继承特点：
- 父类（基类）：被继承的类称为父类或基类。
- 子类（派生类）：继承父类属性和方法的类称为子类或派生类。
继承语法示例：
class ParentClass:
def __init__(self, name):
self.name = name
def greet(self):
return f"Hello from {self.name}!"
class ChildClass(ParentClass): # 子类继承自父类
def goodbye(self):
return f"Goodbye from {self.name}!"
# 创建子类对象
child_obj = ChildClass("Alice")
# 访问继承的方法
print(child_obj.greet()) # 调用父类方法
print(child_obj.goodbye()) # 调用子类方法
继承的优点：
- 代码重用：通过继承，子类可以重用父类的属性和方法，减少重复代码量。
- 封装性：可以隐藏细节或实现细节，使代码更易维护。
- 可扩展性：子类可以添加新的功能或修改现有方法，扩展父类的功能。
总之，类的继承是面向对象编程中重要的概念，提供了一种有效的方式来组织和管理代码，并实现代码的重用、可扩展性和灵活性。
示例代码如下：
# 定义父类 Person
class Person:
# 定义基本属性
name = ''
age = 0
# 定义私有属性，私有属性在类外部无法直接进行访问
__weight = 0
# 定义构造方法
def __init__(self, name, age, w):
self.name = name
self.age = age
self.__weight = w
# 定义greet方法
def greet(self):
return f"Hello, 我的名字是{self.name}，我 {self.age} 岁。"
# 定义子类 Student 继承自 Person
class Student(Person):
grade = ''
def __init__(self, name, age, w, grade):
# 调用父类的构造方法以初始化 name 和 age 属性，weight属性
super().__init__(name, age, w)
self.grade = grade
# 覆写父类的构造函数
def greet(self):
print(f"Hello, 我的名字是{self.name}，我{self.age} 岁, 我上 {self.grade} 年级。")
def study(self):
return f"{self.name} 正在读 {self.grade}年级。"
# 利用input()函数动态输入学生的信息
sname = input('请输入学生的姓名：')
sage = int(input('请输入学生的年龄：'))
sweight = int(input('请输入学生的体重：'))
sgrade = int(input('请输入学生所在的年级：'))
s = Student(sname, sage, sweight, sgrade) # 类的实例化
s.greet() # 调用类的方法
运行结果如下：
请输入学生的姓名：赵杰
请输入学生的年龄：10
请输入学生的体重：35
请输入学生所在的年级：3
Hello, 我的名字是赵杰，我10 岁, 我上 3 年级。
类的多继承
Python同样有限地支持多继承形式。
class 子类名(父类1，父类2...):
# 子类定义部分
示例代码如下：
# 类定义
class people:
# 定义基本属性
name = ''
age = 0
# 定义私有属性，私有属性在类外部无法直接进行访问
__weight = 0
# 定义构造方法
def __init__(self, name, age, weight):
self.name = name
self.age = age
self.__weight = weight
def speak(self):
print('%s 说：我%d岁。' % (self.name, self.age))
# 单继承
class student(people):
grade = ''
def __init__(self, name, age, weight, grade):
# 调用父类的构造函数
people.__init__(self, name, age, weight)
self.grade = grade
# 覆写父类的方法
def speak(self):
print('%s说：我%d岁了，我在读%d年级‘' % (self.name, self.age, self.grade))
# 另一个类，多重继承之前的准备
class speaker():
topic = ''
name = ''
def __init__(self, name, topic):
self.name = name
self.topic = topic
def speak(self):
print('我叫 %s，我是一个演说家，我演讲的主题是%s' % (self.name, self.topic))
# 多重继承
class sample(speaker, student):
a = ''
def __init__(self, name, age, weight, grade, topic):
student.__init__(self, name, age, weight, grade)
speaker.__init__(self, name, topic)
test = sample('周大福', 15, 70, 7, "python编程！")
test.speak() # 方法同名，默认调用的是在括号中排前的父类的方法
在这里，首先定义3个类，分别是people类、student类和speaker类。其中，student类是people类的子类。注意，3个类中，都有speak()方法。然后定义sample类，sample类是多重继承，既是student类的子类，同时也是speaker类的子类。sample类定义类一个类变量，即a；定义了一个构造方法，在构造方法中调用了父类student的构造方法和父类speaker的构造方法。
最后，sample类实例化，再调用speak()方法。需要注意的是，由于people类、student类和speaker类中都有speak()方法，默认情况下，调用的是在括号中排前的父类的方法，即speaker类中的speak()方法。
运行结果如下：
我叫 周大福，我是一个演说家，我演讲的主题是python编程！
