nlp——python学习记录(10)

本文介绍了Python中的继承概念,包括单继承、多继承和多层继承,以及如何通过super()函数和父类名来调用父类方法。此外,还探讨了类和实例的属性、方法,包括公有、私有权限以及魔法方法。文章通过实例详细解释了多态性,并展示了如何利用多态性在父类方法参数中传入子类对象。最后,通过示例展示了类方法、静态方法的使用,以及类属性和实例属性的区别。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

今天是关于继承,权限,属性和方法,多态的知识,有点乱乱的,后期需要再复盘一下。

1.继承:描述类与类之间的所属关系。class 类 b(类a):pass,b可以使用a中的属性和方法。

b(子类,派生类),a(基类,父类)。

2.分类:单继承,多继承,多层继承。

3.重写:子类实现和父类名字相同的方法。

重写之后想要调用父类中的方法:1.父类名.方法名(self,其他参数)

                                                      2.super(类a.self).方法(参数)

                                                      3.super().方法名(参数)

4.权限:公有权限,私有权限(在属性和方法名钱前加两个下划线)

5.属性:实例属性,类属性

6.方法:实例方法(self),类方法(@classmethod)(cls),静态方法(@staticmethod)(参数无要求)

7.魔法属性:__dict__ :类型是字典,返回对象具有的属性

                     __mor__:查看继承顺序链

8.多态:在需要父类的时候也可以传入子类对象

# 继承:多个类之间的所属关系,基类(父类),派生类(子类)
# 基本语法  class 类B(类A):pass  称为类B继承了类A,B类的对象可以使用A类的属性和方法
# 优点:代码复用。

# 需求:1.定义一个动物类;2.在里面书写play方法;3.定义Dog类继承动物类;4.创建对象,调用
class Animal(object):  # 对于动物类和object类来说,单继承
    def paly(self):
        print('palying')


class Dog(Animal):  # 单继承,Dog--->Animal--->object 这种继承关系称为多层继承
    def bark(self):
        print('wangwang')


# 多层继承中,子类可以使用多有继承链中的方法和属性
class XTQ(Dog):  # XTQ-->Dog单继承,XTQ-->Dog-->Animal类,多层继承
    pass


xtq = XTQ()
xtq.bark()  #调用父类方法
xtq.paly()  #调用爷爷类方法

# dog = Dog()
# dog.paly()
# 继承分类:单继承和多层继承
# 单继承:如果一个类只有一个父类
# 多层继承:A-->B-->C
# 多继承:如果一个类有多个父类

# 重写:子类定义和父类重名的方法
# 重写原因:父类中的方法,不能满足子类对象的需求,所以要重写
# 特点:子类对象调用子类自己的方法,不再调用的方法,父类对象调用父类自己的方法
class Dog(object):
    def bark(self):
        print('wangwang')


class XTQ(Dog):
    def bark(self):
        print('aoaoao')


dog = Dog()
dog.bark()

xtq = XTQ()
xtq.bark()


# 重名之后子类调用父类的重名方法
class Dog(object):
    def bark(self):
        print('wangwang')


class XTQ(Dog):
    def bark(self):
        print('aoaoao')

    def see_host(self):
        print('see',end='')
        # elf.bark() 不行  # 想要在子类调用子类同名方法
        # 方法1:父类名.方法名(self,其他参数),通过此方法,不需要传递实参值,
        # 解释器会自动将对象作为实参值传递给self形参,如果是类名.方法()调用,不会自动传递实参值,需要手动给self形参传递实参值
        Dog.bark(self)  # 注意传参

        # 方法二:super(当前类,self).方法名(参数)
        # 会调用当前类的父类方法
        super(XTQ,self).bark()

        # 方法三:是方法二的简写,super().方法名(参数)
        super().bark()
        pass


xtq = XTQ()
xtq.see_host()

# 继承中的init
class Dog(object):
    def __init__(self,name):
        self.age = 0
        self.name = name

    def __str__(self):
        return f'name:{self.name},age:{self.age}'


class XTQ(Dog):
    # 子类重写了父类的init方法,默认不再调用父类的init方法,需要手动调用父类init方法
    def __init__(self,name,color):  # 先写父类
        super().__init__(name)
        self.color = color

    def __str__(self):
        return f'name:{self.name},age:{self.age},color:{self.color}'


xtq = XTQ('小红','red')
print(xtq)

# 多继承(理解):如果一个类有两个及以上的父类
class Dog(object):
    def bark(self):
        print('wangwanmgwang')

    def eat(self):
        print('kenkenken')


class God(object):
    def paly(self):
        print('wanwan')

    def eat(self):
        print('pantao')


class XTQ(God,Dog):  # 多继承
    def eat(self):
        print('重写eat,调用子类自己的方法')
        # 调用指定父类中的方法
        # Dog.eat(self)
        # super(XTQ,self).eat()  # 调用God,调用的是下一个类
        # super(God,self).eat()  # 调用的是Dog

    pass


xtq = XTQ()
xtq.bark()
xtq.paly()
xtq.eat()  # 若都存在相同方法,调用第一个父类中的方法
# 调用指定方法
# 类名.__mro__可以查看当前类的继承顺序连,也叫做调用顺序
# print(XTQ.__mro__)

# 权限:访问权限控制,使用范围
# 私有权限:在方法和属性前加上两个下划线,不能在类外部通过对象直接访问和使用,只能在内部
#         不能被子类继承,目的是保证数据的相对安全,想要访问和使用私有属性,定义一个公有的方法进行使用
# 公有:不是私有的就是公有的
class People(object):
    def __init__(self):
        # 钱不能随意被修改,定义成私有属性
        # python中的私有本质是修改属性的名字,在创建对象的时候,会自动的修改属性名
        # 在属性名的前面加上_类名前缀
        self.__ICBC_money = 0

    # 定义公有的方法,提供接口,修改余额
    def get_money(self):
        return self.__ICBC_money

    def set_money(self,money):
        self.__ICBC_money += money


xm = People()
# 实例对象:__dict__可以查看对象的属性信息,类型是字典
print('赋值之前',xm.__dict__)
xm.__ICB_money = 1000  # 添加了一个公有属性
print('赋值之后',xm.__dict__)
print('*'*30)

print(xm.get_money())
xm.set_money(1200)
print(xm.get_money())
xm.set_money(-200)
print(xm.__ICB_money)

# 私有方法:在方法的前边加上两个下划线,就为私有方法,不能在外部访问
# 作为类内部的方法使用,不让外部调用的时候去定义
class Dog(object):
    def born(self):
        print('生了一只')
        self.__sleep()

    def __sleep(self):  # 私有
        print('休息 30')


dog = Dog()
# dog.__sleep()   无法调用
dog.born()

# 类属性(理解)
# 对象(实例对象):通过class定义的类创建的,即通过类实例化来的
# 实例对象的属性称为实例属性,通过实例对象(self)定义的属性
# 实例属性:每个实例对象中都存在一份,并且值是可能是不一样的

# 类(类对象),是解释器在创建类的时候自动创建的
# 作用:通过类对象去定义实例对象,类对象可以保存一些属性信息,称为类属性
# 类属性的定义:在类内部,方法外部定义的变量就是类属性
# 类属性:内存中只有一份

# 怎么确认一个属性是该定义为实例属性还是类属性?
# 先假设为实例属性,查看这哥属性值对于不同的实例对象,属性值是否都一样,并且需要同时变化
# 如果是,就为类属性,不是就实例对象


class Dog(object):
    # 类属性
    class_name = '狗类'

    def __init__(self,name,age):
        # 实例属性
        self.name = name
        self.age = age


dog = Dog('huang',12)
print(dog.__dict__)
print(Dog.__dict__)  # 类对象的属性
# 访问类属性,类名.类属性
print(Dog.class_name)
Dog.class_name = 'cat'
print(Dog.class_name)
# 修改类属性:类名.类属性=属性值
# 如果不存在和实例属性名相同的类属性,可以使用实例对象访问类属性的值
print(dog.class_name)

# 类方法:使用@classmethod装饰的方法,第一个参数是cls,代表的是类对象自己
# 如果在方法中使用了实例属性,那么该方法必须定义为实例方法
# 不需要使用实例属性,需要使用类属性,可以将这个方法定义为类方法

# 静态方法@staticmethod装饰的方法,对参数没有特殊要求
# 不需要使用实例属性,同时也不需要使用类属性

class Dog(object):
    class_name = 'dog'

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

    def paly(self):  # 实例方法
        print(f'P{self.name}play')

    # def get_class(self): # 实例方法,因为没有使用实例属性,所以可以定义为类方法
    #     return Dog.class_name
    # @classmethod  #类方法标志
    # def get_name(cls):
    #     return cls.class_name

    @staticmethod
    def show_info():  # 静态方法有参数就必须传递实参值
        print('goggog')


dog = Dog('HUANG', 3)
dog.paly()
# print(dog.get_name())
# print(Dog.get_name())
dog.show_info()
Dog.show_info()

# 多态:在需要使用父类对象的地方,也可以传入子类对象,得到不同的结果
# 1.子类继承父类;2,子类重写父类中的同名方法;3.定义一个共同的方法,参数为父类,调用同名方法
class Dog(object):
    def __init__(self,name):
        self.name = name

    def play(self):
        print(f'{self.name}play')


class XTQ(Dog):
    def play(self):
        print(f'{self.name}paopao')


class Cat(object):
    def __init__(self,name):
        self.name = name

    def play(self):
        print(f'{self.name}lulu')


def play_with(obj_dog):  # 传入不同对象
    obj_dog.play()


dog = Dog('xiao')  #父类
play_with(dog)

xtq = XTQ('hei')
play_with(xtq)

# 鸭子类型的多态:可以没有继承关系
cat = Cat('miao')
play_with(cat)

测试题:

list = [11,22,33,44,55,66,77,88,99,90]
my_dict = {'key1':[],'key2':[]}
for i in list:
    if i > 66 :
        my_dict['key1'].append(i)
    else:
        my_dict['key2'].append(i)
print(my_dict)



# 统计字符串的出现次数
my_str = 'hello world'
my_dict = {}
for i in my_str:
    if i == ' ':
        continue
    my_dict[i] = my_str.count(i)
print(my_dict)
lass Person(object):
    __count = 0

    def __init__(self,name,age):
        self.name = name
        self.age = age
        Person.__count += 1

    @classmethod
    def get_count(cls):
        return cls.__count

    @staticmethod
    def show_info():
        print('这是person类')

    def study(self):
        print(f'我的名字是{self.name},我要好好学习')

    def __str__(self):
        return f'我的名字是{self.name},我的年龄是{self.age}'

    def __del__(self):
        Person.__count -= 1


Person.show_info()
print(Person.get_count())
p = Person('小红',15)
print(p,p.get_count())
w = Person('xiao',1)
print(w,w.get_count())

p.study()
w.study()

del p
print(Person.get_count())


最近开始学习吴恩达的机器学习,冲冲冲!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值