面向对象

与面向过程对比
- 面向过程：数学逻辑的映射，学会做个好员工
- 面向对象：生活逻辑的映射，学会做个好领导
生活实例
- 类：人手机电脑
- 对象：小明、老王你的手机、我的手机我的电脑、你的电脑
官方定义
- 类：具有相同特征(属性和行为)事物的抽象
- 对象：某个类的具象
编程语言
- 类：是一种自定义的数据类型
- 对象：某个类类型的变量

基础语法

类的定义
```
class 类名:
	pass
```

使用说明：

定义类的关键字是class
类名：原则上符合标识符命名规范即可，但是通常都采用大驼峰风格命名，如：UserName
类名后不要忘记’:’
类的内容要进行整体缩进
属性可以通过变量体现，行为通过函数体现
成员访问：
- 属性：对象.属性名
- 方法：对象.方法名()
示例：

# 定义类
class Person:
    # 行为通过函数体现

    # 吃饭
    def eat(self):
        print('毛氏红烧肉，听说很好吃！')

    # 睡觉
    def sleep(self):
        print('喜欢睡觉也是生活态度！')
        
# 创建对象  
p = Person()
# print(p)

# 属性可以动态添加
p.name = 'ergou'
p.age = 22
print(p.name, p.age)

# 调用成员方法
p.eat()
p.sleep()

self使用

class Person:
    def run(self):
        # self表示当前对象，就是调用该方法的对象
        print('{}每天以2m/s的速度奔跑5km'.format(self.name))

	def introduce(self):
        # 访问成员属性
        print('我叫{}，今年18岁'.format(self.name))
        # 调用成员方法
        # self的名字可以修改，但是通常都不改，调用方法时该参数不传
        self.run()
            
lulu = Person()
lulu.name = '露露'
# lulu.run()
lulu.introduce()

yanbo = Person()
yanbo.name = '彦博'
# yanbo.run()
yanbo.introduce()

__str__方法

class Person:
    # 打印对象时默认打印：类名+地址
    # 重写该方法，打印对象时会打印该方法的返回值
    # 该方法必须返回一个字符串
    # 使用str方法强制类型转换时也会调用该方法
    def __str__(self):
        return '我是{}，今年{}岁'.format(self.name, self.age)
    
p = Person()
p.name = '勒布朗.詹姆斯'
p.age = 34
print(p)

s = str(p)
print(s)

__init__方法

class Cat:
      def __str__(self):
          return 'name:{},age:{},color:{}'.format(self.name, self.age, self.color)

      # 构造方法：创建对象后会自动调用，可以进行初始化设置
      def __init__(self, name, age, color):
          # print('__init__')
          self.name = name
          self.age = age
          self.color = color
        
# 这种方式比较繁琐
# jiafei = Cat()
# jiafei.name = '加菲'
# jiafei.age = 2
# jiafei.color = '橘黄色'
# print(jiafei)

jiafei = Cat('加菲', 2, '橘黄色')
print(jiafei)

__del__方法

class Pig:
    # 析构方法：当对象释放时，系统会自动调用
    # 该方法一般做资源释放操作，如：断开数据库连接、文件关闭
    def __del__(self):
        print('大师兄，我不行了')
        
bajie = Pig()
del bajie
print('八戒，一路走好！')

思考：小明手里有两张牌，左手♥K，右手♠A，小明交换两手的牌后，手里分别是什么？
- 先找到对象：♥K、♠A、左手、右手、小明
- 根据对象抽象类：人、手、牌
- 设计相关的类，需要根据功能反复完善

常用内置函数

内置函数：在类中，特定的时刻会自动触发的函数
__init__、__del__、__str__

__setattr__、__getattr__、__delattr__

class Person:
    def __init__(self, name):
        self.name = name
        # print('初始化对象')

    # 当设置属性时会自动调用
    def __setattr__(self, key, value):
        # print(key, value)
        self.__dict__[key] = value

    # 当获取不存在的属性时会自动触发
    def __getattr__(self, item):
        if item == 'age':
            return 18
        else:
            return '你猜'

    # 销毁对象的指定属性时会自动触发
    def __delattr__(self, item):
        print(item, '属性即将销毁')
        
        
xiaoming = Person('小明')
# xiaoming.name = '小明'

print(xiaoming.age)
print(xiaoming.height)

print(xiaoming.__dict__)

del xiaoming.name
print('over')

__setitem__、__getitem__、__delitem__

class Person:
      # 将对象当做字典操作，添加或设置属性时自动触发
      def __setitem__(self, key, value):
          # print(key, value)
          self.__dict__[key] = value

      # 将对象当做字典操作，根据键获取值时会自动触发
      def __getitem__(self, item):
          # print(item)
          return self.__dict__.get(item)

      # 将对象当做字典操作，根据键销毁属性时会自动触发
      def __delitem__(self, key):
          print(key, '属性即将销毁')
          del self.__dict__[key]
            
xiaoming = Person()
# xiaoming.name = '小明'
# print(xiaoming.name)

xiaoming['name'] = '小明'
print(xiaoming['name'])

del xiaoming['name']
print(xiaoming['name'])

__call__

class Person:
      # 将对象当做函数调用，该方法会自动触发
      def __call__(self, *args, **kwargs):
          # print('__call__', args)
          return sum(args)
        
p = Person()
# 将对象当做函数调用，必须重写类的call方法
ret = p(1, 2, 3)
print(ret)

def test():
	pass

# 判断一个对象是否可以调用
print(callable(p))
print(callable(test))

# 判断一个对象是否是函数
from inspect import isfunction
print(isfunction(p))
print(isfunction(test))

# 判断对象是否拥有指定属性，若对象可以调用，那么一定拥有__call__属性
print(hasattr(p, '__call__'))
print(hasattr(test, '__call__'))

10-python基础知识-面向对象

面向对象

面向对象

基础语法

常用内置函数

猜你喜欢