Python面向对象一、面向对象的程序开发二、面向对象封装–对象相关操作三、面向对象封装 – 类相关操作四、面向对象删除操作

面向过程：
优点：效率高，执行效率快
缺点：维护性，移植性差，表达不出一类的语意

面向对象：
优点：可读性，可移植性，可维护性高
缺点：执行效率慢

一、面向对象的程序开发

什么是类、对象、属性、方法？
我们可以做这样一种比喻，有一个工厂，生产轮船、手表、汽车、飞机，一个类就代表一个生产车间，对象是指车间生产出的一件件实例，如汽车车间生产出的一辆汽车就是一个对象，属性是指车的一些外观定义，如颜色、车型等，方法代表车可实现的功能，如跑、鸣笛等。

1、类的定义

类有三种定义方式：

1）

class MyCar:
	pass

2）

class MyCar():
	pass

3）

class MyCar(object):
	pass

三种写法表达效果相同，推荐第二种写法

2、类的实例化

class MyCar():
	color = "车颜色为白色"
	def func(self):
		print("鸣笛功能")
#实例化对象(类的实例化)
obj = MyCar()
print(obj.color)

运行结果：

3、类的基本结构

在类的基本结构中，只有成员属性和成员方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	# 成员方法
	def func(self):
		print("鸣笛功能")
obj = MyCar()
print(obj.color)

4、类的命名

驼峰式命名法：推荐起类名的时候，使用大驼峰命名法
mycar -> MyCar
mymouse => MyMouse

二、面向对象封装–对象相关操作

封装等级：
(1) 私有：在类的内部可以访问，在类外不可以
(2) 公有：在类的内部可以访问，在类外也可以访问

封装成员：
(1) 成员属性
(2) 成员方法

调用成员：
(1) 对象.成员属性
(2) 对象.成员方法

绑定方法：
(1) 绑定到对象：对象调用方法时，系统自己默认传递该对象，作为一个参数传递到当前方法中
(2) 绑定到类：对象或者类调用方法时，系统自己默认传递该类，作为一个参数传递到当前方法中

1、实例化对象访问公有及私有成员属性和方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")

访问公有成员方法：

# 实例化对象
obj = MyCar()
# 调用公有成员方法
obj.func1()

运行结果：

访问私有成员方法：

# 实例化对象
obj = MyCar()
# 调用私有成员方法
obj.__func2()

结果报错：

结论：私有成员方法及属性不能在类外调用

2、实例化对象动态添加公有属性和方法

1）在类外动态添加成员属性 -> obj对象

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
添加成员属性
obj.appearance = "SUV"
print(obj.appearance)

运行结果：

__dict__:获取类对象中的成员

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
obj.appearance = "SUV"
print(obj.__dict__)

运行结果：

2）在类外动态添加成员方法

无参方法：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
def run():
	print("百公里1.5小时")
obj.run = run
obj.run()

运行结果：

有参方法：
(1) 基础版

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
def run(speed):
	print("百公里{}小时".format(speed))
obj.run = run
obj.run(1.5)

运行结果：

(2) 升级版

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
def run(obj,speed):
	print("百公里{}小时,{}".format(speed,obj.color))
obj.run = run
obj.run(obj,1.5)

运行结果：

(3) 终极版
在类外调用自定义方法时,系统不会自动传递obj对象参数
即使调用类外动态创建的方法,也让系统自己传递obj对象本身

import types
class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
def run(obj,speed):
	print("百公里{}小时,{}".format(speed,obj.color))
obj.run=types.MethodType(run,obj)
obj.run(1.5)

运行结果：

3）lambda表达式

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj = MyCar()
logoname=lambda logo : print("车标:{}".format(logo))
obj.logoname = logoname
obj.logoname("特斯拉")

运行结果：

三、面向对象封装 – 类相关操作

类调用的方式：
类.成员属性
类.成员方法
类中的无参方法只能类来调用，对象不能调用类中无参的方法

1、定义的类访问公有成员属性和方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
print(MyCar.color)
MyCar.func1()

运行结果：

2、定义的类动态添加公有成员属性和方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
MyCar.appearance = "SUV"
print(MyCar.appearance)

运行结果：

动态添加公有成员方法：
1）无参方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
def run():
	print("百公里1.5小时")
MyCar.run = run
MyCar.run()

运行结果：

2）有参方法

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
def run(speed):
	print("百公里{}小时".format(speed))
MyCar.run = run
MyCar.run(1.5)

运行结果：

3）lambda表达式

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
MyCar.run=lambda speed : print("百公里{}小时".format(speed))
MyCar.run(1.5)

运行结果：

类和对象之间的区别：
1、对象可以调用类中的成员属性及方法，反过来，类不能调用对象中的成员
2、类中的成员方法和属性归属于类本身，对象可以使用，但没有修改和删除的权利
3、对象在调用相应成员时，先看看自己有没有
如果有，调用自己的
如果没有，直接调用类中的成员
如果类中成员也没有，直接报错

四、面向对象删除操作

1、如何访问类中的私有成员

方法一：改名策略(不推荐)
__类名 + 私有成员

对象访问类中私有成员：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
obj=MyCar()
print(obj._MyCar__price)
obj._MyCar__func2()

运行结果：

类访问私有成员：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2():
		print("百公里提速")
MyCar._MyCar__func2()
print(MyCar._MyCar__price)

运行结果：

方法二：类或对象利用公有方法，间接找到私有成员(推荐)

对象：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
	def public(self):
		print(self.__price)
		self.__func2()
obj=MyCar()
obj.public()

运行结果：

类：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1():
		print("鸣笛功能")
	def __func2():
		print("百公里提速")
	def public():
		print(MyCar.__price)
		MyCar.__func2()
MyCar.public()

运行结果：

2、实例化的对象/定义的类 删除公有成员属性和公有成员方法

删除对象中定义的属性：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
car=MyCar()
car.color= "车颜色为黑色"
print(car.__dict__)
del car.color
print(car.color)

运行结果：

如图，删除了对象中自定义属性，之后自动调用了类中的属性
接着删除类中属性：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
car=MyCar()
car.color= "车颜色为黑色"
print(car.__dict__)
del car.color
print(car.color)
del MyCar.color
print(car.color)

运行结果：

如图，删除类中的color属性后，对象找不到对应属性，程序报错

删除方法和删除属性的操作基本一致：

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
car=MyCar()
car.func1()
del MyCar.func1
car.func1()

运行结果：

如上图，删除类中方法后再调用会报错

class MyCar():
	# 成员属性
	color = "车颜色为白色"
	__price = "价格:30万"
	# 成员方法
	def func1(self):
		print("鸣笛功能")
	def __func2(self):
		print("百公里提速")
car=MyCar()
car.logoname=lambda logo : print("车标：{}".format(logo))
car.logoname("特斯拉")
del car.logoname
car.logoname("特斯拉")

运行结果：

如上图，删除对象中方法后再调用会报错

最后

以上就是呆萌芝麻为你收集整理的Python面向对象一、面向对象的程序开发二、面向对象封装–对象相关操作三、面向对象封装 – 类相关操作四、面向对象删除操作的全部内容，希望文章能够帮你解决Python面向对象一、面向对象的程序开发二、面向对象封装–对象相关操作三、面向对象封装 – 类相关操作四、面向对象删除操作所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。