学习笔记：python面向对象

最新推荐文章于 2024-01-16 19:25:25 发布

779醒

最新推荐文章于 2024-01-16 19:25:25 发布

阅读量238

点赞数

分类专栏： Pyhton踩坑录

本文链接：https://blog.csdn.net/chenbaixing/article/details/106934629

版权

Pyhton踩坑录专栏收录该内容

43 篇文章 4 订阅

订阅专栏

第一章课程介绍
OOP
基本单元：对象
封装：数据，功能（function）

第二章面向对象概念
世界事物、分类抽象
两个基本概念：类，对象
基本要素：属性，方法
属性（信息）
方法（功能）
继承，对群体进行细分
子类有更详细的特性
多重继承，多个父类

多态
子类重写父类方法
同一类人对同一个事物不同的看法

第三章面向对象
3-1定义类

class ClassName:
	def __init__	# 构造函数
					# 析构函数

class OldStyle:
    def __init__(self, name, description):
        self.name = name
        self.description =description

class NewStyle(object): # 没有其他父类都从object继承
    def __init__(self, name, description):
        self.name = name
        self.description =description

在这里插入图片描述
3-2定义类的属性
方法1：直接在类里定义（被所有对象共享）
方法2：在构造函数定义（构造对象时传值，每个对象属性不一样）

Python没有访问控制，没有提供私有属性功能（public，private）
常用属性定义

class Program(object):
  	hobby = 'play'
    def __init__(self, name, age, weight):
        self.name = name    # 可以公开访问
        self._age = age    # 一个下划线，私有属性，编程规范约束，非语法约束
        self.__weight = weight  # 两个个下划线，部分实现私有属性，类里可以访问，对象直接访问不行，双下划线改名保存，可以用其他方法绕过

    def get_weight(self):
        return self.__weight


if __name__ == "__main__":

    prog = Program('A', 25, 80)
    print(dir(prog))        # 打印对象所有属性
    print(prog.__dict__)    # 看所有属性建值情况
    print(prog.get_weight())    # 通过方法获得weight属性
    print(prog._Program__weight)    # 双下划线无法直接通过__weight访问，是用_Program__weight名称保存的

3-3定义类的方法
概念：
函数：直接调用函数名，不依附于类
方法：和对象结合，是类的一部分
python一切皆对象
类的方法也是类的属性

class Test(object):
	def test(self):
		pass
if __name__ == "__main__":
a = Test()
a.test	# 打印显示返回一个方法
a.test = '123'	# 已定义的方法直接赋值改成属性
print(a.test)	# '123'

方法的访问控制
和属性一样，没有访问控制

常用方法定义

def add(self):
	pass
def _minus(self):	# 私有属性，不允许外部访问
	pass
def __multiply(self)	# 两个个下划线，部分实现私有属性

@classmethod # 类方法，调用时候用类名，不是对象名，
@property # 象访问属性一样调用方法

class Program(object):
    hobby = 'play'
    def __init__(self, name, age, weight):
        self.name = name    # 可以公开访问
        self._age = age    # 一个下划线，私有属性，编程规范约束，非语法约束
        self.__weight = weight  # 两个个下划线，部分实现私有属性，类里可以访问，对象直接访问不行，双下划线改名保存，可以用其他方法绕过

    def get_weight(self):
        return self.__weight

    @classmethod
    def get_hobby(cls):
        return cls.hobby

    @property
    def get_weight(self):
        return self.__weight

    def self_introduction(self):

        print(self.name, self._age)

if __name__ == "__main__":

    prog = Program('A', 25, 80)
    print(dir(prog))        # 打印对象所有属性
    print(Program.get_hobby())    # 类名调用类方法
    print(prog.get_weight)    # 象调用属性一样调用方法，不加（）
    print(prog.self_introduction())    # 正常调用,返回为None，会打印出来

3-4 类的继承
定义
class DerivedClassName(baseclassName）

继承的子类
会继承父类的属性和方法，也可以改写

用super()调用父类的方法
super(B,self).method(arg) # 参数子类名，子对象
直接用父类名称调用
A.method(arg) # 没体现继承

子类的类型半段
isinstance # 判断类型
issubclass #判断是否子类

多继承
class DerivedClassName(A,B,C)

class BackendProgram(Program):
    def __init__(self, name, age, weight, language):
        super(BackendProgram, self).__init__(name, age,weight)   # 调用父类函数,super两个参数
        self.language = language    # 子类属性


if __name__ == "__main__":

    prog = BackendProgram('A', 25, 80, 'Python')
    print(dir(prog))        # 打印对象所有属性
    print(prog.__dict__)    # 象调用属性一样调用方法
    print(type(prog))    # 属于哪个类
    print(isinstance(prog,Program,))    # 判断对象的父类是否时Program，参数：对象，父类

3-5 类的多态
一个对象同时属于多个类

多态的要素
继承
方法重写

class BackendProgram(Program):
    def __init__(self, name, age, weight, language):
        super(BackendProgram, self).__init__(name, age,weight)   # 调用父类函数,super两个参数
        self.language = language    # 子类属性

    def self_introduction(self):    # 子类重写方法

        print(self.name, self.language)

def introduce(prog):    
    if isinstance(prog, Program):   # 如果是继承Program的对象，都可以执行
        print(1111)
        prog.self_introduction()

if __name__ == "__main__":

    prog = Program('A', 25, 80)
    backend = BackendProgram('B', 25, 80, 'C')
    introduce(prog)
    introduce(backend)  # 也是从Program继承来

4-1 magic method
魔术方法
对象建立，属性访问，方法支持
作用：
给类添加魔法
方法名前后有2个下划线：def init(self):

4-2 对象的创建和初始化
def __init(self)
分2步
1、创建类对象
def new(cls) # 父类创建类方法默认调用
2、初始化类对象
def init(self) # new创建的对象给init初始化赋值

回收对象
python有垃圾回收机制
del() # 实际很少用到

class Program(object):
    def __new__(cls, *args, **kwargs):# 重新定义new
        print('call __new__')
        print(args)
        # return super(Program, cls).__new__(cls, *args, **kwargs)    # new要返回一个创建的对象
        # TypeError: object.__new__() takes exactly one argument (the type to instantiate)
        return super(Program, cls).__new__(cls)  # new只要1个参数，父类
prog = Program('A', 25, 80)
    print(prog.__dict__)

4-3 类与运算符
magic method的好处
优雅，被python标准语法支持

s = 'test'
s == s
print(dir(s))
# 字符串类有这么多魔法函数
# '__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
# 其中__eq__是字符串比较

比较运算符
cmp(self, other)# 大于小于
eq(self, other)# 等于
lt(self, other)# 小于
gt(self, other)# 大于
数字运算
add(self, other)# +
sub(self, other)# -
mul(self, other) # *
div(self, other) # /
逻辑运算 or and

 def __eq__(self, other):
        if isinstance(other, Program):
            if self.age == other.age:
                return True
            else:
                return False
        else:
            raise Exception('需要同一个类')

    def __add__(self, other):
        if isinstance(other, Program):

            return self.age + other.age

        else:
            raise Exception('需要同一个类')

if __name__ == "__main__":
    p1 = Program('A',25,80)
    p2 =Program('B','s',80)
    print(p1 == p2)
    print(p1 + p2)

4-4 类的展现
定义类，实现实例化，print打印
对象转换为字符串
str # 转成人识别字符串
repr # 转成机器识别字符串，可以由eval函数运行
unicode

展现对象属性
dir # 重写dir，可以把一些不想展示的属性隐藏

 def __str__(self):	# 负责定义打印对象时的显示， 默认是打印对象
        return self.name

 def __dir__(self):# 负责定义dir（）时的显示
     return self.__dict__.keys()
     p1 = Program('A',25,80)
 # p2 =Program('B','s',80)
 print(p1)
 print(dir(p1))

4-5 类的属性访问
访问控制，木有访问控制
设置对象属性
setattr(self, name, value)
可能无限递归
def setattr(self, name, value）：
setattr(self, name, value）# 导致递归，限制1000次，报错
def setattr(self, name, value）：
self.dict[name] = value
查询对象属性
getattr(self,name) # 属性默认没有调用时使用
getattribute(self, name)# 所有获取属性时候都调用，容易引起无限递归

删除对象属性
delattr()

class Program(object):
    hobby = 'play'

    def __init__(self, name, age, weight):
        self.name = name    # 可以公开访问
        self.age = age
        if isinstance(age, int):    # 确保age是int，从int类继承来
            self.age = age
        else:
            raise Exception('arg must be int')
        self.__weight = weight  # 两个个下划线，部分实现私有属性，类里可以访问，对象直接访问不行，双下划线改名保存，可以用其他方法绕过

    def __getattribute__(self, name):	# 定义getattr()函数返回结果
        # return getattr(self, name)  # 会无限递归
        # return self.__dict__[name]   # 会无限递归
        return super(Program, self).__getattribute__(name)  # 通过父类方法调用，不会无限递归

    def __setattr__(self,name, value):	# 定义setattr()函数返回结果
        # setattr(self, name, value)  # 错误方法，引起无限递归
        # RecursionError: maximum recursion depth exceeded while calling a Python object
        self.__dict__[name] = value # name属性赋值value

if __name__ == "__main__":
    p1 = Program('A',25,80)
    # p2 =Program('B','s',80)
    print(p1.name)

第六章课程总结

779醒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
学习笔记：python面向对象

第一章课程介绍OOP基本单元：对象封装：数据，功能（function）第二章面向对象概念世界事物、分类抽象两个基本概念：类，对象基本要素：属性，方法属性（信息）方法（功能）继承，对群体进行细分子类有更详细的特性多重继承，多个父类多态子类重写父类方法同一类人对同一个事物不同的看法第三章面向对象3-1定义类class ClassName: def __init__ # 构造函数 # 析构函数class OldStyle: def __init__
复制链接

扫一扫