python--动态绑定属性和方法、封装、继承、多态、object类、特殊的属性和方法（下划线开始）

最新推荐文章于 2023-09-23 12:13:47 发布

¡Venceremo

最新推荐文章于 2023-09-23 12:13:47 发布

阅读量416

点赞数 1

分类专栏： pycharm 文章标签： python

本文链接：https://blog.csdn.net/weixin_47295886/article/details/125173180

版权

pycharm 专栏收录该内容

88 篇文章 8 订阅

订阅专栏

动态绑定属性和方法

class Student: # Student 是类名，由一个或多个单词组成、每个单词的首字母大写 其余小写

    place='北京' #直接写在类里面的变量---------称为类属性

    def __init__(self,name,age):#初始化方法 #这里面的是局部变量
        self.name=name #self.name称为实例属性，进行了一个赋值操作 将局部变量Name的值赋给实例属性
        self.age=age #self.name self.age对象是所有都有的属性

    # 实例方法 self
    def ext(self):  #函数在类之外定义的称为函数、在类之内的称为方法
        print(self.name+'在吃饭.....')



print('------创建对象------')
stu1=Student('王',78)
stu2=Student('后',78)
print(id(stu2))
print(id(stu1))
print('------为stu1动态绑定性别属性------')
stu1.gender='男'  #单独绑定的属性 stu2没有
print(stu1.name,stu1.age,stu1.gender)
print(stu2.name,stu2.age)

print('------类方法------')
stu1.ext()
stu2.ext()
print('------stu1单独绑定类方法------')
def show():
    print('定义在类之外，成为函数')
stu1.show=show

stu1.show()

只针对当前的类型和读一下

面向对象的三大特征（封装、继承、多态）------

class Car: # Car是类对象
    def __init__(self,brand,value):
        self.brand=brand #self.brand实例属性
        self.__value=value #不希望被类的外部使用 所以加了__ 但是可以在类里面被使用
    def start(self):
        print('汽车已经启动')
    def price(self):
        print(self.__value)

car=Car('奔驰',50000000)
car.start() # 使用到了类封装的方法
print(car.brand) # 使用到了类封装的属性
car.price()
# print(car.__value) 类外用不了
#使用方法
print('-------------------')
print(dir(car)) #查看所有属性和方法
print(car._Car__value) #在类的外部可以通过_类名+实例属性

继承（

具有继承关系、python支持多继承可以有多个父类、如果一个类没有继承任何类默认继承object、定义子类时，必须在其构造函数中调用父类的构造函数

）

class 子类类名(父类1,父类2)
    pass

#定义Person类
class Person(object): #里面的Object可以不写
    def __init__(self,name,age):#调用__init__方法
        self.name=name
        self.age=age #赋值
    def info(self):
        print(self.name,self.age)


#定义Student类的子类继承Person
class Student(Person):
    def __init__(self,name,age,stu_nu):
        super().__init__(name,age) #使用super去调用父类的方法 传入父类的name age
        self.stu_nu=stu_nu #调用自己的去赋值 学号

class Teacther(Person):
    def __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self.teach_year=teach_year#教龄

#创建学生类的对象
stu=Student('张三',20,'1001')
#创建教师类的对象
teacher=Teacther('李四',50,30)

#调用方法
stu.info()
teacher.info()

可以继承多类

class A(object):
    pass
class B(object):
    pass

class C(A,B):
    pass

方法重写（子类写自己独有的方法--父类中有的子类可以继承--父类提供的方法已经满足不了需求）

# cyy python study
# 开发时间：2022/6/3 11:44

#定义Person类
class Person(object): #里面的Object可以不写
    def __init__(self,name,age):#调用__init__方法
        self.name=name
        self.age=age #赋值
    def info(self):
        print(self.name,self.age)


#定义Student类的子类继承Person
class Student(Person):
    def __init__(self,name,age,stu_nu):
        super().__init__(name,age) #使用super去调用父类的方法 传入父类的name age
        self.stu_nu=stu_nu #调用自己的去赋值 学号
    def info(self): #重写父类方法
        super().info() #执行父类的输出
        print(self.stu_nu)


class Teacther(Person):
    def __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self.teach_year=teach_year#教龄

    def info(self):
        super().info()
        print(self.teach_year)

#创建学生类的对象
stu=Student('张三',20,'1001')
#创建教师类的对象
teacher=Teacther('李四',50,30)

#调用方法
stu.info()
print('--------------')
teacher.info()

object类（是所有类的父类）

使用内置函数dir查看属性和方法

__str__这个方法用于返回一个对象的描述

class Stuednt:
    def __init__(self,name,age): #这个方法是object继承的方法
        self.name=name
        self.age=age


#创建对象
stu=Stuednt('张三',20)

print(dir(stu)) #是从父类继承的

print(stu) #输出对象的描述 默认调用__str__方法

重写str方法

class Stuednt:
    def __init__(self,name,age): #这个方法是object继承的方法
        self.name=name
        self.age=age
    #重写父类的方法
    def __str__(self):
        return '我的名字是{0},今年{1}岁'.format(self.name,self.age)

#创建对象
stu=Stuednt('张三',20)

print(dir(stu)) #是从父类继承的

print(stu) #输出对象的描述 默认调用__str__方法

多态（具体多种形态---不知变量的类型）

静态语言实现多态的三个条件：（JAVA）

继承、方法重写、父类引用指向子类对象

动态语言（python）:与是否继承无关，只需要查看是否有方法

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):
    obj.eat()


#调用函数
fun(Cat()) #重写了父类的方法会重写
fun(Dog())
fun(Animal())
print('-------------------------')
fun(Person()) #与上面的没有继承关系  只关心有没有eat方法

特殊的属性和方法

print(dir(object))

__dict__获得类对象或实例对象所绑定的所有属性和方法的字典

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age = age
#创建c类对象
x=C('Jack',38)
print(x.__dict__) #实例对象的属性的字典
print(C.__dict__) #类对象  查看到了属性和方法
print('---------------------')
print(x.__class__) # 输出对象所属的类
print(C.__bases__) #输出的是父类元组
print(C.__base__) #class C(A,B): 由于该位置A离得近
print(C.__mro__)#查看类的层次结构 类的继承关系
print(A.__subclasses__())#查看子类 子类的列表

add

a=20
b=100
c=a+b #两个整数类型的对象的相加的操作
d=a.__add__(b)
print(c)
print(d)

class Student:
    def __init__(self,name):
        self.name=name

    def __add__(self, other):
        return self.name+other.name
#创建对象
stu1=Student('张三')
stu2=Student('李四')

s=stu1+stu2 #实现两个对象的加法运算（在Student中编写了特殊的__add__方法）
print(s)
s1=stu1.__add__(stu2)
print(s1)

len

lst=[20,30,520,52]
print(len(lst)) #len是内置函数 可以计算列表的长度
print(lst.__len__())#如果需要输出对象的长度 就需要编写len的内置函数

class A:
    def __init__(self,name):
        self.name=name
    def __len__(self):
        return len(self.name)
stu1=A('Jack')#4个字符
stu2=A('李四')
print(len(stu1))
print(len(stu2))

创建对象 new ()先进行

初始化init后进行

class A(object):
    def __init__(self,name,age):#对对象的属性进行初始化使用
        print('__init__被调用执行了,self的id值为:{0}'.format(id(self)))
        self.name=name
        self.age=age

    def __new__(cls, *args, **kwargs): #用来创建对象
        print('__new__被调用执行了，cls的id值为:{0}'.format(id(cls)))
        obj=super().__new__(cls) #调用父类的new方法
        print('创建的对象id为：{0}'.format(id(obj)))
        return obj


print('object这个类的id：{0}'.format(id(object)))
print('A这个类的id：{0}'.format(id(A)))

#A类的实例对象为
p1= A('张三',20)
print('p1这个A类的实例对象id：{0}'.format(id(p1)))