python中面向对象相关知识点（全面总结笔记）

面向对象

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

面向对象语法

类的定义：
class 类名:
内容
语法说明：
- 定义类需要使用关键字class
- 类名：原则上只要符合标识符命名规范即可，但是通常我们都使用大驼峰(每个单词首字母大写)风格命名
  - 如：UserName
- 类名后面的’:'不要忘记
- 类的内容要进行整体缩进
- 行为：通过方法体现，在类中定义相关的函数即可(第一个参数通常是self)
- 属性：通过变量体现，在需要时动态添加，很多时候定义类时没有体现
- 成员访问：
  - 属性：对象.属性名
  - 方法：对象.方法名()

示例：
# 定义类
class Person:
# 行为通过方法体现

    # 吃饭
    def eat(self):
        print('红烧鸡腿我喜欢吃')

    # 睡觉
    def sleep(self):
        print('睡觉也是一种生活态度')
        
# 定义对象
liang = Person()
# 调用方法
liang.eat()
liang.sleep()
# 属性时动态添加的
liang.name = '某某某'
# 获取属性
print(liang.name)

self使用
class Person:
def run(self):
# self表示当前对象：谁调用该方法就表示谁
print(’{}每天以2m/s的速度慢跑5km’.format(self.name))
```
    def introduce(self):
        # 不但可以访问成员属性
        print('我叫{}'.format(self.name))
        # 还可以调用成员方法
        self.run()
        
fei = Person()
fei.name = '路人甲'
fei.run()
fei.introduce()

long = Person()
long.name = '路人乙'
long.introduce() 
```
- 说明：
  1.类中的每个成员方法都有一个self参数，调用的时候不需要传递该参数
  2.该参数的名字可以不是self，只不过通常我们都使用这个
  3.self表示当前对象，对调用该方法self就代表谁，哪个对象调用就表示哪个对象
  4.通过self可以访问成员属性，也可以调用成员方法
__str__方法
class Person:
# 使用print方法打印对象，默认打印类名 + 地址
# 若想打印特定内容，重写该方法即可，要求返回一个字符串
def str(self):
return ‘我叫{}，今年{}’.format(self.name, self.age)
```
james = Person()
james.name = '路人丙'
james.age = 33
print(james)    
```

构造方法：创建对象后，初始化属性时，系统会自动调用该方法
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
        
# 这种形式比较繁琐
# tom = Cat()
# tom.name = 'Tom'
# tom.age = 3
# tom.color = '蓝色'

# 这种比较简洁
tom = Cat('Tom', 3, '蓝色')
print(tom)

析构方法：当对象释放时系统会自动调用，通常用于释放资源
class Pig:
# 析构方法：当对象释放时，系统会自动调用
# 若手动使用del删除，则会立即调用该方法
# 该方法一般做资源释放处理：数据库连接断开，文件关闭
def del(self):
print(‘大师兄，我不行了’)
```
bajie = Pig()
del bajie
print('八戒，一路走好！')        
```
示例：小明手里有两张牌，左右♥K，右手♠A，小明交换两手的牌后，手里分别是什么？
- 思路：
  - 先找到对象：左手、右手、♥K、♠A、小明
  - 根据对象抽象出对应的类：人、手、牌
  - 根据需要写出相应的逻辑，很可能反过来完善类的设计
  - 按照题目要求创建相关对象，调用相关方法，实现相关功能
- 代码：
  
  对象：小明、左手、右手、♥K、♠A
  
  类：人、手、牌
  
  设计相应的类
  
  扑克牌
  
  class Poker:
  def init(self, color, number):
  self.color = color
  self.number = number
```
  def __str__(self):
  	return '{}{}'.format(self.color, self.number) 
```
  创建两张牌
  
  p1 = Poker(‘♥’, ‘K’)
  p2 = Poker(‘♠’, ‘A’)
  
  手的类
  
  class Hand:
  def init(self, poker):
  self.poker = poker
```
  def hold_poker(self, poker):
      self.poker = poker
```
  创建左右两只手
  
  left_hand = Hand(p1)
  right_hand = Hand(p2)
  
  人的类
  
  class Person:
  def init(self, name, left_hand, right_hand):
  self.name = name
  self.left_hand = left_hand
  self.right_hand = right_hand
```
# 展示手里的牌
def show(self):
	print('{}张开手'.format(self.name), end=' ')
      print('左手:{}'.format(self.left_hand.poker), end=',')
      print('右手:{}'.format(self.right_hand.poker))

# 交换两手的牌
  def swap(self):
      self.left_hand.poker, self.right_hand.poker = self.right_hand.poker, self.left_hand.poker
      print('{}交换两手的牌'.format(self.name))   
```
  创建小明对象
  
  xiaoming = Person(‘小明’, left_hand, right_hand)
  
  展示手里的牌
  
  xiaoming.show()
  
  交换两手的牌
  
  xiaoming.swap()
  
  #再次展示
  xiaoming.show(）

常用内置函数

内置函数：在类的内部，特定时机自动触发的函数。

示例：setattr、getattr、delattr
class Person:
def init(self, name):
self.name = name

      def __str__(self):
          return '姓名:{}'.format(self.name)

      def __del__(self):
          print('对象即将销毁')
          
      # 当获取不存在的属性时，会自动触发该方法
      def __getattr__(self, item):
          if item == 'age':
              return 18
          else:
              return '你猜'

      # 当设置不存在的属性时，会自动触发该方法
      def __setattr__(self, key, value):
          print(key, value)
          self.__dict__[key] = value

      # 销毁对象成员属性时，会自动触发该方法
      def __delattr__(self, item):
          print(item, '即将销毁')
        
xiaoming = Person('小明')
xiaoming.age = 20
print(xiaoming.age)
# 存放对象的所有属性
# print(xiaoming.__dict__)
# print(xiaoming)
del xiaoming.age

将对象当做字典操作，特定时机会自动触发的方法
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):
        del self.__dict__[key]
        
xiaoming = Person()

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

print(xiaoming['name'])

del xiaoming['name']

将对象当做函数调用时，会自动触发下面方法
class Person:
# 将对象当做函数调用时，会自动触发该方法
def call(self, *args, **kwargs):
# print(‘call’)
return sum(args)
```
xiaoming = Person()

# 这样操作，需要提供call方法
ret = xiaoming(1, 2, 3, name='小明')
print(ret)   
```

函数判断
class A:
def call(self, *args, **kwargs):
pass

def test():
    pass

a = A()

# 判断是否可调用
print(callable(test))
print(callable(a))

# 判断是否拥有'__call__'属性
print(hasattr(test, '__call__'))
print(hasattr(a, '__call__'))

# 判断是否是函数
from inspect import isfunction
print(isfunction(test))
print(isfunction(a))

面向对象三大特点

封装：既可对数据结构进行封装，又可对处理数据的方法进行封装
继承：强调的父子类的关系
多态：不同对象调用相同的方法，会有不同的响应

类的继承

相关概念
- 继承：父类的属性和方法，子类直接拥有，称为继承
- 派生：子类在父类的基础上衍生出新的特征(属性和行为)
- 总结：其实他们是一回事，只是描述问题的侧重点不同(继承强调相同点，派生强调不同点)

继承语法
# class Animal(object):
# 当没有指定父类时，默认继承object
class Animal:
def init(self, name):
self.name = name

    def eat(self):
        print('小动物喜欢一天到晚吃个不停')

# 继承自Animal
class Dog(Animal):
    pass

d = Dog('旺财')
# 可以拥有父类的方法
d.eat()
# 也可以拥有父类的属性
print(d.name)

派生示例
class Animal:
def run(self):
print(‘小动物喜欢成天跑个不停’)

class Cat(Animal):
    def eat(self):
        print('猫喜欢吃老鼠')

tom = Cat()

tom.run()
# 多出来的行为
tom.eat()

# 多出来的属性
tom.color = '蓝色'
print(tom.color)

重写方法
- 若父类的方法完全不合适，可以进行覆盖重写
- 若父类的方法不够完善，可以添枝加叶进行完善
- 示例：
  class Animal:
  def eat(self):
  print(‘小动物一天到晚的出个不停’)
```
  def run(self):
      print('小动物一天到晚的四处连跑')
```
  class Cat(Animal):
  # 父类的方法完全不合适，覆盖重写
  def run(self):
  print(‘俺走的时猫步’)
```
  # 父类的方法部分合适，需要添加内容进行完善
  def eat(self):
      # 保留父类的内容，不建议使用此方式
      # Animal.eat(self)
      # super(Cat, self).eat()
      # 类名及self可以不传
      super().eat()
      print('不过俺喜欢吃鱼')
```
  jiafei = Cat()
  jiafei.run()
  jiafei.eat()

多继承：一个子类可以拥有多个父类
class A:
def eat(self):
print(‘eat func in class A’)

class B:
    def eat(self):
        print('eat func in class B')

class C(A, B):
    def eat(self):
        # 这种方案是默认的继承顺序进行选择的父类方法
        # super().eat()
        # 人为指定调用某个父类的方法
        B.eat(self)

c = C()
c.eat()

访问权限

权限
- 公有的：类中的普通的属性和方法，默认都是公有的；可以在类内、类外、子类中使用
- 私有的：定义时在前面添加两个’_’，就变成了私有的；只能在类内使用，不能在类外及子类中使用

示例：
class Person:
def init(self, name):
self.name = name
self.__age = 20

    def eat(self):
        print('民以食为天')

    def __test(self):
        print('__test')
xiaoming = Person('小明')
print(xiaoming.name)
xiaoming.eat()
#不能在类外使用
#print(xiaoming.__age)
xiaoming._Person__test()
print(xiaoming.dict)
#尽管可以这样访问私有属性，但是强烈建议不要这样使用
#print(xiaoming._Person__age)
class Man(Person):
 def introduce(self):
      # 不能在子类中使用
      # print(self.__age)
      print('我叫{}'.format(self.name))
      self.eat()
m = Man('亮亮')
m.introduce()

类属性

说明：定义类时，写在方法外的属性，通常会写在类的开头，这样的属性称为类属性

示例：
class Person:
# 类属性，通过类名访问，属于整个类，而不是某个对象
# nation = ‘中国’

    # 限制可以使用的属性，提高访问的效率
    # 也可以提高访问速度，减少内存使用
    __slots__ = ('name', 'age', 'nation')

    def __init__(self, name):
        self.name = name
        self.nation = 'china'
p1 = Person('小明')
p2 = Person('小红')
print(p1.name, p2.name)
print(Person.nation)
#p1.nation = 'china'
print(p1.nation)
print(p2.nation)
#print(Person.nation)
p1.age = 20
#p1.height = 180

#特殊的类属性
#表示类名的字符串

  print(Person.name)

#表示父类构成的元组

  print(Person.bases)

#存储类的相关信息

  print(Person.dict)

#限制可以使用的属性

  print(Person.slots)

类方法

说明：
- 定义时使用classmethod装饰器装饰的方法
- 使用时通过类名调用
作用：
- 可以创建对象或者简洁的创建对象
- 对外提供简单易用的接口

示例1：创建对象

class Person:
    def eat(self):
        print('我喜欢吃麻辣烫，不要麻椒和辣椒')

    @classmethod
    def test(cls):
        print(cls)
        print('类方法')

    # 创建对象，或者简洁的创建对象
    @classmethod
    def create(cls):
        p = cls()
        p.age = 1
        return p

p1 = Person()
p1.eat()

# 通过类名调用
Person.test()
# 创建或简洁的创建对象
p2 = Person.create()
print(type(p2))

示例2：提供接口
class Number:
def init(self, num1, num2):
self.num1 = num1
self.num2 = num2

    def add(self):
        return self.num1 + self.num2

    def sub(self):
        return self.num1 - self.num2

    def mul(self):
        return self.num1 * self.num2

    def div(self):
        if self.num2 == 0:
            return None
        return self.num1 / self.num2

    # 对外提供简单易用的接口
    @classmethod
    def pingfanghe(cls, num1, num2):
        n1 = cls(num1, num1)
        n12 = n1.mul()

        n2 = cls(num2, num2)
        n22 = n2.mul()

        n3 = cls(n12, n22)
        return n3.add()
he = Number.pingfanghe(3, 4)
print(he)

静态方法

说明：
- 使用staticmethod装饰器装饰的方法(方法没有cls参数)
- 通过类名进行调用
示例：
class Person:
@staticmethod
def test():
print(‘static method test’)
```
    # 创建对象
    @staticmethod
    def create():
        p = Person()
        return p
#Person.test()
#p = Person.create()
#print(p)
```
、 class Animal:
def run(self):
pass
class Dog(Animal):
def run(self):
print(‘狗通常走S型’)
class Cat(Animal):
def run(self):
print(‘猫平时走猫步，偶尔突然加速’)
def test(obj):
obj.run()
d = Dog()
c = Cat()
test(d)
test©

属性函数

说明：将成员方法当做属性一样进行访问
作用：保护特定属性，或者对特定属性进行处理

示例：

class User:
    def __init__(self, username, password):
        self.username = username
        self.__password = password

    # 该方法可以像成员属性一样访问
    @property
    def password(self):
        print('有人想查看密码')
        return '想偷看密码，没门'
        # return self.__password

    # 在设置密码时，会自动调用
    @password.setter
    def password(self, password):
        print('@password.setter', password)
        self.__password = '加密' + password + '加密'


u = User('xiaoming', '111111')
# print(u.password())
print(u.password)

# 设置密码，会自动调用setter方法
u.password = 'abcde'

面向对象及异常处理

内置函数

总结：init、del、str、attr系列、item系列、call
str__与__repr
- 使用print/str方法时会自动触发__str__方法，当__str__不存在，尝试__repr__
- 使用repr方法时会自动触发__repr__方法
- repr方法通常用于返回对象的字符串表示形式
- 这两个方法都只能返回字符串
- eval方法可以将一个字符串当做有效的代码执行

算术运算符重载

示例：
class Number:
def init(self, num):
self.num = num

  # 对象出现在'+'左边时会自动触发
  def __add__(self, other):
      print('__add__')
      return self.num + other

  # 对象出现在'+'右边是会自动触发
  def __radd__(self, other):
      print('__radd__')
      return self.num + other

  # +=运算时会自动触发，没有时会触发 __add__
  def __iadd__(self, other):
      print('__iadd__')
      return Number(self.num + other)

n = Number(100)
ret = n + 200
ret = 200 + n
print(ret)
n += 200 # n = n + 200
print(n)

自己测试
加法：add、radd、iadd
减法：sub、rsub、isub
乘法：mul、rmul、imul
除法：truediv、rtruediv、itruediv
求余：__mod、rmod、imod

关系运算符重载
>： gt
=： ge
<： lt
<=： le
==： eq
!=： ne

示例
class Number:
def init(self, num):
self.num = num

      def __gt__(self, other):
          print('__gt__')
          return self.num > 200

      def __lt__(self, other):
          print('__lt__')
          return self.num < other

      def __eq__(self, other):
          print('__eq__')
          return self.num == other

      # 当没有此方法时，使用!=也会触发__eq__方法
      def __ne__(self, other):
          print('__ne__')
          return self.num != other
    
n = Number(100)

# print(n > 200)
# print(200 > n)
# print(200 == n)
print(200 != n)

深浅拷贝

引用计数
- python中的所有变量都是对象，对象的管理采用的时引用计数的方式
- 当多一个变量指向对象计数值加1，当少一个变指向对象计数值减1，减到0是，释放对象(del)
函数传参
- 对于不可变的变量来说，函数中不可能改传递过来的变量
- 对于可变的容器对象及自定义对象，作为函数参数传递时，传递的是引用，可以修改该对象

深浅拷贝
class Person:
def del(self):
print(‘对象释放’)

p1 = Person()
p2 = p1

print(id(p1))
print(id(p2))

del p1
del p2
print('OVER')

def test(m):
	# m += 1
	m[0] = 300

# n = 100
n = [100, 200]

test(n)
print(n)

import copy

lt = [1, 2, [3, 4]]

# 浅拷贝，只拷贝对象本身，不拷贝对象中的元素
# lt2 = lt.copy()
# 浅拷贝
lt2 = copy.copy(lt)

# 深拷贝：不但拷贝对象本身，还拷贝对象中的元素
lt2 = copy.deepcopy(lt)
lt[0] = 100
lt2 = 300

print(id(lt))
print(id(lt2))
print(lt)
print(lt2)

数据持久化(pickle)

说明：数据持久化存储方案，普通文件、序列化、数据库

示例：
import pickle

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

    def __str__(self):
        return 'name:{},age:{}'.format(self.name, self.age)
    
xiaoming = Person('xiaoming', 20)
# 转换为bytes类型

# s = pickle.dumps(xiaoming)
# print(s)

# 从字节流中提取对象
# xm = pickle.loads(s)

# print(xm)
# 保存到文件中
# fp = open('data.txt', 'wb')

# pickle.dump(xiaoming, fp)
# 从文件中获取对象

fp = open('data.txt', 'rb')
xm = pickle.load(fp)
print(xm)

异常处理

相关概念
- 错误：程序运行之前的语法问题，如：关键字、缩进、括号不成对等
- 异常：在程序运行过程中出现的问题，如：未定义变量、除数为0、属性不存在等
异常处理
- 说明：异常处理可以理解为特殊的流程控制语句，可以提高代码的健壮性。
异常语法：
try:
print(‘正常代码’)
# print(a)
3/0
except Exception as e:
# Exception 是所有异常的基类，此处可以捕获所有的异常
print(‘出现异常’)
print(e)
```
  print('其他内容')
```
多个异常
# 分类捕获异常
‘’’
try:
# print(a)
# 3/0
d = {}
print(d[‘name’])
except NameError as e:
print(‘NameError:’, e)
except ZeroDivisionError as e:
print(‘ZeroDivisionError:’, e)
except Exception as e:
print(‘OtherError:’, e)
‘’’
```
try:
    # print(a)
    # 3/0
    fp = open('123.txt')
except (NameError, ZeroDivisionError) as e:
    # 将某些异常进行统一处理，写在一个元组中即可
    print(e)
except:
    print('其他异常')
```
完整结构(else-finally)
try:
print(‘正常代码’)
print(a)
except:
# 出现异常时执行
print(‘出现异常’)
else:
# 正常结束(没有异常)时会执行
print(‘正常结束’)
finally:
# 无论有无异常，都会执行
print(‘最后执行’)
else：正常结束时执行else中的代码
finally：无论有无异常，最后都执行
抛出异常：raise
try:
print(‘正常代码’)
# 根据业务逻辑的需要，手动抛出异常
raise Exception(‘手动抛出的异常’)
except Exception as e:
print(‘异常：’, e)
```
print('OVER')
```
异常嵌套(try-except结构中再次使用try-except结构)
print(‘我要去上班，什么事也阻止不了我上班的脚步’)
try:
print(‘我准备骑电动车’)
raise Exception(‘昨天晚上不知道哪个缺德的家伙把我充电器拔了’)
print(‘骑车提前到达公司’)
except Exception as e:
print(e)
try:
print(‘我准备做公交车’)
raise Exception(‘等了20分钟一直没有公交车，果断放弃’)
print(‘坐公交车准时到达公司’)
except Exception as e:
print(e)
print(‘我准备打车’)
print(‘打车还是快，一会就到达公司’)
```
print('热情满满的开始一天的工作')
```

自定义异常类(需要继承自官方的异常基类Exception)
# 自定义异常类
class MyException(Exception):
def init(self, msg):
self.msg = msg

    def __str__(self):
        return self.msg

    # 特定异常标准处理方案
    def deal(self):
        print('处理特定的自定义异常')
        
try:
    print('正常执行')
  	# 手动抛出自定义异常
  	raise MyException('出现了自定义异常')
except MyException as e:
    print(e)
  	# 调用方法，处理异常
  	e.deal()

特殊场景
- 当我们进行文件操作时，无论过程中是否有异常，最终我们一定得进行关闭操作
- 使用with语句，可以保证文件的关闭，无论中间过程是否出现异常
  fp = open(‘test.txt’, ‘r’)
```
# 中间无论有无异常，最后一定得关闭文件
# fp.close()

with open('test.txt', 'r') as fp:
    content = fp.read(5)
    print(content)
    # 此处不要考虑文件的关闭问题，也不用是否有异常
```

python中面向对象相关知识点（全面总结笔记）

对象：小明、左手、右手、♥K、♠A

类：人、手、牌

设计相应的类

扑克牌

创建两张牌

手的类

创建左右两只手

人的类

创建小明对象

展示手里的牌

交换两手的牌

fp = open(‘test.txt’, ‘r’)

猜你喜欢