025.Python面向对象以及对对象的操作

目录

• 一 面向对象基本概念
  • 1.1 OOP面向对象的程序开发
  • 1.2 类的定义
  • 1.3 类的实例化
  • 1.3 类的基本结构
  • 1.4 类的命名
  • 1.5 面向对象的三大特征
  • 1.6 成员等级
• 二 对象的相关操作
  • 2.1 定义一个基本的类
  • 2.2 类的封装特性
  • 2.3 实例化的对象动态添加共有成员的属性和方法
  • 2.4 使用__dict__查看成员属性
  • 2.5 实例化的对象动态添加公有成员方法

---

回到顶部

一 面向对象基本概念

1.1 OOP面向对象的程序开发

1. 用几大特征表达一类事物称为一个类，类更像是一张图纸，表达只是一个抽象概念
2. 对象是类的具体实现，更像是由这图纸产出的具体物品，类只有一个，但是对象可以同伙类实例化多个
3. 对象是类的示例，类是对象的模板
4. 类的成员只有方法和属性，不要裸露的吧判断和循环直接写在类中，而是用方法包起来

1.2 类的定义

class MyClass:
    pass

class MyClass():  #推荐使用
    pass

class MyClass(object):
    pass

1.3 类的实例化

class MyClass():
    pass
    
# 类的实例化  也可以叫做 实例化对象 obj就是对象
obj = MyClass()

1.3 类的基本结构

定义：

• 成员属性
• 成员方法

调用

• 对象.成员属性
• 对象.成员方法

class MyClass():
    # 成员属性
    color = "小汽车的颜色是蓝色的"
    # 成员方法
    def run(self):
        print("小汽车会pao")

# 实例化对象
obj = MyClass()
# 利用对象obj,调用类中的成员属性
print(obj.color)
# 利用对象obj 调用类中的成员方法
obj.run()
##反面示例
class  MyClass():      #这种方式，语法允许，而且可以被执行，但是严禁使用，类中只有成员属性和成员方法，不允许其他存在
    if 5==5:
        print("条件成立")#类中的代码，不需要实例化，就可以从上到下依次执行

1.4 类的命名

• 让别人看代码时,更加读懂语意.
• 大驼峰命名法: 每个单词首字符都大写 MyCar
• 小驼峰命名法: 只有第一个单词首字符小写,剩下都大写 myCar
• 命名一个类名的时,推荐使用大驼峰命名法

1.5 面向对象的三大特征

1. 封装：对类中成员的属性和方法的保护，控制外界对内部成员的访问，修改和删除等操作
2. 继承：一个类除了自身拥有的属性方法外，还获取了另一个类的成员和属性的方法
3. 多态：不同的子类对象，调用相同的父类方法，产生不同的执行结果

1.6 成员等级

python对成员的保护分为两个等级

1 私有的private

• 在本内部可以访问，类的外部不可以访问（python中，属性或者方法前面加上两个下划线__）

2 共有的：public

• 在本类的内部和外部都可以访问

在其他高级语言中，如java，php，c++语言，有三个等级，private public  protect

私有成员的改名策略[__类名__成员名]

回到顶部

二 对象的相关操作

1. 实例化的对象访问共有成员属性和方法
2. 实例化的对象动态添加共有成员的属性和方法
3. 实例化的对象删除公有成员属性和方法

2.1 定义一个基本的类

# 类的封装
class Car():
　　　　　　#共有成员属性
        price = "120万"
　　　　　　#私有成员属性
        __oil = "保密"
        def run(self):        #共有成员方法
                print ("性能好，跑得快")
        def __oil_info():     #私有成员方法
                print ("油耗寿命保密")
obj = Car()       #实例化一个对象
res = obj.price    #实例化的对象访问公有成员的属性和方法
print (res)
obj.run()

执行

[root@node10 python]# python3 test.py
120万
性能好，跑得快

• 普通方法：没有任何参数传递，只能类调用
• 绑定方法：把默认传参的方法叫做绑定方法，绑定到对象（默认传对象），绑定到类（默认传类）
• 非绑定方法：静态方法（无需任何参数，对象和类都能调用）

self就是被对象约定俗成的写法，可以自动将对象传递给方法

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):   #定义另一个num
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2()    #调用报错

执行

修改

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2(109)

执行

[root@node10 python]# python3 test.py
120万
性能好，跑得快
109

2.2 类的封装特性

obj.__oil体现了类的封装性

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2(109)
obj.__oil

执行

2.3 实例化的对象动态添加共有成员的属性和方法

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2(109)
#实例化的对象动态添加共有成员的属性和方法
obj.color = "黄色"
print (obj.color)

执行

[root@node10 python]# python3 test.py
120万
性能好，跑得快
109
黄色

2.4 使用__dict__查看成员属性

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2(109)
obj.color = "黄色"
print (obj.color)

执行

在这里发现，没有price,__oil的属性，也没有run的方法，是因为这些属于类，他的归属是类，而非对象，只可以用

120万
性能好，跑得快
109
黄色
{'color': '黄色'}

2.5 实例化的对象动态添加公有成员方法

1. 添加无参方法
2. 添加有参方法
3. 通过lambda表达式来进行动态添加

class Car():
        price = "120万"
        __oil = "保密"
        def run(self):
                print ("性能好，跑得快")
        def run2(self,num):
                print (num)
        def __oil_info():
                print ("油耗寿命保密")
obj = Car()
res = obj.price
print (res)
obj.run()
obj.run2(109)
obj.color = "黄色"
print (obj.color)
# __dict__ 用dict魔术属性来查看对象的内部成员
print(obj.__dict__)
#添加无参方法
def fangxiangpan():
        print("这是制造方向盘的方法")
# obj.fangxiangpan fangxiangpan是自定义的一个名字,是obj动态添加的成员方法
obj.fangxiangpan = fangxiangpan
obj.fangxiangpan()
print(obj.__dict__)

#添加有参方法
def huibianxing(obj,name):
        print("我的小车,可以变成"+name,"价格是:"+obj.price)
obj.bianxing = huibianxing
# obj.bianxing("hello kitty")
obj.bianxing(obj,"hello kitty")

#上面的方式，需要定义两个参数，一个是对象obj，另一个是那么，可以使用types动态添加方法
import types
#MethodType(函数,对象) 把函数绑定到哪个对象上
#绑定成功之后,在调用,系统会自动把这个对象当成参数进行传递
obj.bianxing = types.MethodType(huibianxing,obj)
# obj.bianxing = bianxing
obj.bianxing("hello ketty")


#通过lambda表达式来进行动态添加
func = lambda : print("我是汽车人大黄蜂")
obj.dahuangfeng = func
obj.dahuangfeng()

print(obj.__dict__)

执行

[root@node10 python]# python3 test.py
120万
性能好，跑得快
109
黄色
{'color': '黄色'}
这是制造方向盘的方法
{'color': '黄色', 'fangxiangpan': <function fangxiangpan at 0x7f79deb18e18>}
我的小车,可以变成hello kitty 价格是:120万
我的小车,可以变成hello ketty 价格是:120万
我是汽车人大黄蜂
{'color': '黄色', 'fangxiangpan': <function fangxiangpan at 0x7f79deb18e18>, 'bianxing': <bound method huibianxing of <__main__.Car object at 0x7f79dea45668>>, 'dahuangfeng': <function <lambda> at 0x7f79dea382f0>}