【Python爬虫与数据分析】面向对象设计

这篇具有很好参考价值的文章主要介绍了【Python爬虫与数据分析】面向对象设计。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、类的构建与继承

二、多继承

三、钻石继承

四、多态

五、鸭子类型

六、类的组合

七、类的私有属性和方法

八、魔法方法

九、单例模式


一、类的构建与继承

的属性包含成员变量成员函数(方法)

成员函数又分为静态方法魔法方法普通成员方法

静态方法可以直接被类调用,也可以被类对象调用

魔法方法是类的默认方法,我们可以自定义魔法方法

子类继承父类,可以对相同函数名的函数进行重写

class Person:       # Person(object)
    name = '没有名字'
    age = '未出生'
    sex = '不知道'          # 静态属性

    @staticmethod       # 静态方法
    def print_name():
        print(f'{Person.name}')

    # 实例属性方法(魔法方法)
    def __init__(self, name='无名氏', age=0, sex='未知'):    # 初始化无返回值
        self.name = name
        self.age = age
        self.sex = sex

    def printName(self):
        print(f'我的名字是: {self.name}')
    def printAge(self):
        print(f'我的年龄是: {self.age}')
    def printSex(self):
        print(f'我的性别是: {self.sex}')


# 继承与Person的子类
class Son(Person):
    def printName(self):        # 局部重写
        print(f'我有自己的名字, 叫做{self.name}:')
    def __init__(self, name='子女', age=1):   # 局部继承
        Person.__init__(self)
        self.name = name
        self.age = age


Person.print_name()         # 类直接调用静态方法

girl_friend = Person()
girl_friend.print_name()    # 类对象调用静态方法
print(girl_friend.name)
girl_friend.printName()
girl_friend.printAge()
girl_friend.printSex()

friend = Person('苏铭', 21, '男')
friend.print_name()
print(friend.name)
friend.printName()
friend.printAge()
friend.printSex()

print(Son.name)
me = Son()
me.printName()
me.printAge()
me.printSex()

二、多继承

一个子类可以继承于多个父类,谁排前面谁优先继承,重名方法的继承需要考虑优先级,不重名方法的继承不需要考虑优先级(都继承)。

class Master:
    def __init__(self):
        self.kongfu = '传统奶茶配方'
    def make_cake(self):
        print(f'[传统] 按照{self.kongfu}制作了一杯奶茶...')
    def smoke(self):
        print('抽个烟')

class School:
    def __init__(self):
        self.kongfu = '现代奶茶配方'
    def make_cake(self):
        print(f'[现代] 按照{self.kongfu}制作了一杯奶茶...')
    def drink(self):
        print('躲在厕所里喝酒')

# 多继承
class Prentice(Master, School):     # 谁排前面,谁优先继承
    pass

# 子类的魔法属性__mro__决定了属性和方法的优先级
print(Prentice.__mro__)

me = Prentice()
print(me.kongfu)
me.make_cake()
me.smoke()
me.drink()      # 不重名的不考虑顺序问题

三、钻石继承

如果子类继承自两个单独的超类,而那两个超类又继承自同一个公共基类,那么就构成了钻石继承体系。这种继承体系很像竖立的菱形,也称作菱形继承。

super()方法保证公共父类只被执行一次

class A:
    def __init__(self):
        print('进入A')
        print('离开A')

class B(A):
    def __init__(self):
        print('进入B')
        super().__init__()
        print('离开B')

class C(A):
    def __init__(self):
        print('进入C')
        super().__init__()
        print('离开C')

class D(B, C):
    def __init__(self):
        print('进入D')
        super().__init__()
        print('离开D')

D()

四、多态

多态: 不同对象在调用相同方法时, 呈现不同状态

isinstance()方法可以判断一个对象是否属于某一个类

class Animal():
    def eat(self):
        print('动物吃饭了')

class Dog(Animal):
    def eat(self):
        print('小狗吃饭了')

class Cat(Animal):
    def eat(self):
        print('小猫吃饭了')

a = Animal()
b = Dog()
c = Cat()

print(isinstance(a, Animal))    # True 判断 a 是否输入 Animal类
print(isinstance(b, Dog))       # True
print(isinstance(c, Cat))       # True
print()
print(isinstance(b, Animal))    # True
print(isinstance(c, Animal))    # True 同一个对象可以属于不同的类
print()
print(isinstance(a, Dog))       # False 父类对象不属于子类
print()

def eat_eat(animal):
    animal.eat()

_list = [Animal, Dog, Cat]
for animal in _list:
    animal().eat()

五、鸭子类型

鸭子类型(英语:duck typing)是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定。
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
我们并不关心对象是什么类型,到底是不是鸭子,只关心行为。

class Duck:
    def quack(self):
        print('嘎嘎嘎, 我是一只可达鸭')
    def feathers(self):
        print('我有黄色的羽毛')

class Person:
    def quack(self):
        print('我也会嘎嘎嘎, 但我是一个人')
    def feathers(self):
        print('我没有羽毛')

def in_the_poor(d):
    d.quack()
    d.feathers()

duck = Duck()
person = Person()
in_the_poor(duck)
in_the_poor(person)

六、类的组合

类的组合就是一个对象具有一个属性,这个属性的指是另外一个类的对象。

# 乌龟类
class Turtle:
    def __init__(self, x):
        self.num = x

# 鱼类
class Fish:
    def __init__(self, x):
        self.num = x

# 池塘类
class Pool:
    def __init__(self, x, y):
        #乌龟类进来
        self.turtle = Turtle(x)
        #鱼类进来
        self.fish = Fish(y)
    def print_num(self):
        print(f'池塘里有{self.turtle.num}只乌龟, 有{self.fish.num}只鱼')

p =  Pool(4, 10)
p.print_num()

七、类的私有属性和方法

私有权限:在属性名和方法名 前面 加上两个下划线 __ 类的私有属性 和 私有方法,都不能通过对象直接访问,但是可以在本类内部访问;

类的私有属性 和 私有方法,都不会被子类继承,子类也无法访问; 私有属性 和 私有方法 往往用来处理类的内部事情,不通过对象处理,起到安全作用。

class People(object):
    def __init__(self, password):
        self.__password = password      # 变量前面有两个下划线, 有私有属性, 外部不可直接访问

    def getPassword(self):
        return self.__password      # 类的内部可调用私有属性

    def setPassword(self, new_password):
        if len(new_password) >= 6:
            self.__password = new_password
        else:
            print('密码长度需大于等于5')

me = People('123456')
print(me.getPassword())
me.setPassword('654321')
print(me.getPassword())

八、魔法方法

      Python中的魔法方法(Magic Methods),也称为双下划线方法(Dunder Methods),是特殊方法,其名称以双下划线开头和结尾,例如 __init__、__str__、__add__ 等。这些方法提供了一种使Python对象能够使用内置函数和语言结构的方式。

class Obj(int):
    def __init__(self, num):
        self.num = num

    # 自定义类对象的基本计算方法
    def __add__(self, other):
        return self.num + other + 1    # 这里的运算符继承于父类
    def __sub__(self, other):
        return self.num - other + 1
    def __mul__(self, other):
        return self.num * other + 1
    def __truediv__(self, other):
        return self.num / other + 1
    def __floordiv__(self, other):
        return self.num // other + 1

    # __str__ 是一个显示对象信息的魔法方法
    # 这个方法需要return一个数据, 并且只有self一个参数
    # 当在类的外部print(对象), 则打印这个返回的数据
    def __str__(self):
        return (f'这个数是{self.num}')

    # __getattr__(self)当访问一个不存在的对象时, 不报错
    # 是一个防报错的异常捕获机制
    def __getattr__(self, name):
        return (f'{name}属性不存在')

a = Obj(3)
b = Obj(5)
print(a)
print(type(a))
print(a.x)
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)



class String(str):
    def __init__(self, name):
        self.name = name

    # __len__(self) 可自定义长度的计算方法
    def __len__(self):
        return len(self.name) - 1

    def __str__(self):
        return f'这个字符串是{self.name}'

s = String('hello')
print(s)
print(len('hello'))
print(len(s))

九、单例模式

单例模式(Singleton Pattern)是一种常用的软件设计模式,该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中,某个类只能出现一个实例时,单例对象就能派上用场。文章来源地址https://www.toymoban.com/news/detail-507385.html

class Single:
    #创建类的隐藏属性
    __instance = None   #父类new方法的返回值, None的bool值为False

    def __new__(cls):
        #如果__instance的值为None, 就创建一个对象并赋值
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance


a = Single()
b = Single()
print(id(a), id(b)) # 地址一样

a.name = '周周'
a.sex = '帅哥'
print(a.name, a.sex)
print(b.name, b.sex)

b.name = '提速狗'
b.sex = '美女'
print(a.name, a.sex)
print(b.name, b.sex)

到了这里,关于【Python爬虫与数据分析】面向对象设计的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包