Python面向对象编程

最新推荐文章于 2025-05-27 20:07:06 发布

MoonLord0525

最新推荐文章于 2025-05-27 20:07:06 发布

阅读量181

点赞数

分类专栏： Python基础篇文章标签： python

本文链接：https://blog.youkuaiyun.com/qq_40459859/article/details/106689545

版权

Python基础篇专栏收录该内容

10 篇文章

订阅专栏

面向对象

编程的方式

面向过程：根据业务逻辑从上到下写代码。

函数式：将某功能代码封装到函数中，日后无需重复编写，仅调用函数即可。

面向对象：对函数进行分类和封装，让开发更快更好更强

什么是面向对象

面向对象就不像面向过程那样按照功能模块划分模块了，它所关注的是软件系统有哪些参与者，把这些参与者称为对象，找出这些软件系统的参与者也就是对象之后，分析这些对象有哪些特征、哪些行为，以及对象之间的关系，所以说面向对象的开发核心是对象。

什么是类

面向对象编程的两个非常重要的概念：类和对象

类是对象的类型，具有相同属性和行为事物的统称。类是抽象的（不存在的），在使用的时候通常会找到这个类的一个具体存在。

什么是对象

万物皆对象，对象拥有自己的特征和行为。

类和对象的关系

类是对象的类型，对象是类的实例。类是抽象的概念，而对象是一个你能够摸得着，看得到的实体。二者相辅相成，谁也离不开谁。

定义类

类的构成

类由三个部分构成

类的名称：类型
属性：对象的属性
方法：对象的方法

创建和使用类

类定义

class 类名():
	#类文档说明
属性列表
	方法列表

实例

class Person():
	country = ’中国’#声明类属性，并且赋值
#实例属性通过构造方法来声明
	#self不是关键字，代表的是当前的对象
	def __init__(self,name,age,sex):#构造方法
		#构造方法不需要调用，在实例化的时候自动调用
		print(’我是构造方法，在实例化的时候调用’)
		self.name = name #通过self创建实例属性并且赋值
		self.age = age
		self.sex = sex
	#创建普通方法
	def getName(self):
		print(’我的名字叫:%s’%self.name)#在方法里面使用实例属性
#实例化对象
people = person(’joe’,19,’男’)#在实例化的时候传递参数
#这个people就要具有三个属性，并且可以使用getName方法

init()构造方法和self

__init__()是一个特殊的方法，属于类的专有方法，被称为类的构造函数或初始化方法，方法的前面和后面都有两个下划线。

这是为了避免Python默认方法和普通方法发生名称的冲突。每当创建类的实例化对象的时候__init__()方法都很默认被运行。作用就是初始化已实例化后的对象。

在方法定义中，第一个参数self是必不可少的。类的方法和普通的函数的区别就是self,self并不是Python的关键字，你完全可以用其他单词取代他，只是按照惯例和标准的规定，推荐使用self。

类的属性分类

类属性就是类变量

实例属性就是实例变量

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。如果需要用在函数中使用类名.类属性

实例变量：定义在方法中的变量，只作用于当前实例的类。

针对类的属性的一些方法

可以使用实例化对象名+.来访问对象的属性

#访问属性
print(people.name)#通过对象名.属性名 访问实例属性（对象属性）
print(people.age)
print(people.sex)
也可以使用以下函数的方式来访问属性
#通过内置方法访问属性
print(getattr(people,’name’))
print(hasattr(people,’name’))
setattr(people,’name’,’susan’)
delattr(people,’name’)
#通过对象调用实例方法
people.getName()

内置类属性

#__dict__:类的属性（包含一个字典，由类的属性名：值组成） 实例化类名. __dict__
print(people. __dict__)#会将实例对象的属性和值通过字典的形式返回
#__doc__：类的文档字符串 （类名.）实例化类名. __doc__
print(people. __doc__)
print(person. __name__) #返回类名
print(person. __bases__)#返回父类构成的元素

创建和使用类小结

类（Class）：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量不作为实例变量使用。

数据成员：类变量或者实例变量（方法中的变量）用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override）,也称为方法的重写。

实例变量：定义在方法中的变量，只作用于当前实例的类。

实例化：创建一个类的实例，类的具体对象。

方法：类中定义的函数。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

name

#name.py
def a():
	print(’我是a方法’)
print(__name__) #在当前脚本运行输出__main__
if __name__==’ __main__’:
	a()#在当前脚本运行是才调用a方法
#test.py
#引入name.py文件
import name #输出name(文件的名字)
#在引入文件时不会调用a方法

继承和多态

继承的概念

在现实生活中，继承一般指的时子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中可以描述为猫和狗都继承自动物。程序中当我们定义一个class的时候，可以从某个现在有的class继承，新的class称之为子类（Subclass）,而被继承的class称之为基类、父类或超类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

class Animal():
	def __init__(self,name,food):
		self.name=name
		self.food=food
	def eat(self):
			print(’%s爱吃%s’%(self.name,self.food))
#声明一个子类继承Animal
class Dog(Animal):
	def __init__(self,name,food,drink):
		#加载父类构造方法
super.__init__(name,food)
self.drink = drink#子类自己的属性
		#子类自己的方法
		def drinks(self):
			print(’%s爱喝%s’%(self.name,self.drink))
		#重新父类的eat（多态）
		def eat(self):
			print(’%s特别爱吃%s’%(self.name,self.food))
	dog = Dog(’金毛’,’骨头’,’可乐’)
dog.eat()
dog.drinks()

多继承

class A():
	def a(self):
		print(’我是A里面的a方法’)

class B():
	def b(self):
		print(’我是B里面的b方法’)
	def a(self):
		print(’我是B里面的a方法’)

class C(A,B):
	def c(self):
		print(’我是C里面的c方法’)
c = C()
c.c()#调用自己的方法
c.b()
c.a()

类属性和实例属性

属性

尽量把需要用户传入的属性作为实例属性，而把同类都一样的属性作为类属性。实例属性在每创造一个类时都会初始化一遍，不同的实例的实例属性可能不同，不同实例的类属性都相同。

实例属性

在__init__(self,…)中初始化

内部调用时都需加上self.

外部调用时用“对象名.属性名”调用

类属性

在__init__()里初始化

在内部用classname.类属性名调用

外部既可以用classname.类属性名又可以用instancename.类属性名来调用。

私有属性

双下划线__开头：外部不可通过“对象名.属性名”来访问或者更改

Class person():
	def __init__(self,name,address)
		self.name = name
		self.__address = address #双下划线开头的就是私有属性
	def getName(self):
		#私有属性在类里面使用正常使用
		print(’我住在%s’%(self.__address))
	#外部要修改私有属性 预留一个接口去访问或者修改私有属性
	#这个就是正确的打开方式
	def getAddre(self):
		return self.__address
people = person(’joe’,’上海’)
print(people.__address) #外部无法使用这种方式访问
print.getName()#我住在上海
print(people.getAddre())

访问限制——私有属性

私有对象属性

为了保护属性不被随意修改和访问，可以将属性定义为私有属性。

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

#强制访问
print(people._person.__address)#不赞成这样使用

注意事项

设置为私有属性不能通过对象访问属性，但是可以通过“实例化对象名._类名_属性名”直接进行访问。但是不建议这样操作，不同版本的Python解释器可能会把“_属性名”改成不同的变量名。总的来说就是，Python本身没有任何机制组织你干坏事，一切全靠自觉。
通过“对象名._属性名”直接修改私有属性。表面上看好像修改了其实并没有，因为Python解释器已经将对象内部的属性名解释成“_类名_属性名”。如果在外部修改相当于另外声明一个属性。

类方法和静态方法

普通方法

def fun_name(self,…):
	pass
外部用实例调用

静态方法

通过装饰器@staticmethod 装饰

不能访问实例属性

参数不能传入self

与类相关但是不依赖类与实例的方法

类方法

@classmathod

不能访问实例属性

参数必须传入cls

必须传入cls参数（即代表了此类对象——区别——self代表实例对象）用此来调用类属性：cls.类属性名

静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

实例

class person():
	country=’中国’
#创建一个静态方法
@staticmethod
def aa(): #不需要传递实例
		#静态方法不能访问实例属性
		print(’我的名字叫：%s’%person.country)#静态方法只能访问类属性
#创建一个普通方法
def a(self):
	pass
#类方法
@classmethod
def bb(cls): #class简写cls    也不是关键字
	#类方法不能访问实例属性
print(’我的名字叫：%s’%cls.name)
		print(’我的名字叫：%s’%cls.country)#类方法中就用cls.类属性访问类属性，其他地方用类名. 类属性访问类属性
people = person(…)
people.aa()#通过对象来调用静态方法
people.bb()#通过对象来调用类方法
person.aa()#通过类名来调用静态方法
person.bb()#通过类名来调用类方法
#静态方法和类方法的调用，推荐使用类面的方式去调用