手把手教你从零开始学python 第八章--面向对象2

于 2022-11-08 11:36:35 发布
阅读量3.5k 收藏 7
点赞数 4
CC 4.0 BY-SA版权
分类专栏： python基础 文章标签： python 开发语言 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/SUEJESDA/article/details/127684103

从零开始学python持续更新中 🚀 🚀 🚀

写作辛苦点点关注✔️

💯一、私有属性和方法的使用

私有属性的一些使用方法，还有如果使用，什么时候可以使用

如下：

class Person(object):

    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__money = 1000 # 2个下划线表示的是私有变量


    def test(self):
        self.__money += 10


    def get_money(self):
        print('查询余额')
        return self.__money


    def set_money(self,qian):
        if type(qian) != int:
            print('修改的语法不合法')
            return
        print('修改余额')
        self.__money = qian


    def __t(self): # 以2个下划线开始的函数 是私有函数 外部无法使用   当然 p._Person__t 是可以强行调用
        print('我是t')


p = Person('张三',18)
p2 = Person('李四',19)

# 私有变量是没办法直接获取 print(p.__money) 这样是不行的

# 获取私有变量的方式
# 1. 使用对象._类名__私有变量获取
print(p._Person__money)

# 外部不能使用 内部是可以使用的
p.test()
print(p._Person__money)

# 2. 定义get和set方法来获取
print(p.get_money())
p.set_money(100)
print(p._Person__money)

# 结果是
# 1000
# 1010
# 查询余额
# 1010
# 修改余额
# 100

💯二、类方法和静态方法

静态类的方便使用

class Calculator(object):
    @staticmethod
    def add(a,b):
        return a + b

# c = Calculator()
# c.add(1,2)
# 平常需要像这样去使用 类 先让一个值去等于 类来创建对象 在使用对象调用方法

# 但是这个静态类 可以直接这样用就很方便
print(Calculator.add(1,4))

静态方法的调用与类方法的调用

class Person(object):

    type = 'human'

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

    # 默认的方法都是对象方法
    def eat(self,food):  # 对象方法有一个参数self 指的是实例对象
        print(self.name + '在吃' + food)

    # 这个eat是对象方法 可以直接使用实例对象 方法名（）调用


# 如果一个方法 没有用到任何一个实例对象的任何属性 也就是指 self  函数里面没有用到任何的self ， 可以将这个方法定义成 static
    @staticmethod
    def say():
        print('hello')


# 如果这个函数只用到了类属性 我们可以定义成为一个类方法
    @classmethod
    def cls_test(cls):
        # 这个参数cls 也不需要手动传参 会自动传参
        # cls 指的是类对象   cls == Person  => True
        print(cls.type)
        print('yes')



p = Person('张三',18)
# 实例对象在调用方法的时候  不需要给形参self传参  会自动的把实例对象传递给self
p.eat('梅菜扣肉')

p2 = Person('李四',19)


# 对象方法还可以使用 类对象来调用
# 使用方法就是   类名.方法名（）
# 这种方式 不会自动给self传参 需要手动指定self
Person.eat(p2,'牛肉盖饭')


# 静态方法的调用  : 没有用到实例对象的任何属性
Person.say()
p.say()


# 类方法：可以使用实例对象和类对象 调用
p.cls_test()
Person.cls_test()

# 结果是
"""
张三在吃梅菜扣肉
李四在吃牛肉盖饭
hello
hello
human
yes
human
yes
"""

静态方法的实际用法

class calculate(object):
    @staticmethod
    def add(a,b):
        return a + b

    @staticmethod
    def jianfa(a,b):
        return a - b

print(calculate.add(1,2))

# 结果是 3
# 定义一个类属性，记录通过这个类创建了多少个对象

class Person(object):
    count = 0

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

# 因为每创建一个实例对象 就会自动调用 __new__ 和 __init__方法 所以可以用这个来统计

# 调用__new__方法，用来申请内存
# 如果不重写 __new__ 方法 它会自动找object的 __new__
# object的 __new__方法 默认是创建一个对象申请一段内存

p1 = Person('z',20)
p2 = Person('b',20)
p3 = Person('r',20)

print(Person.count)

"""
在python里面  __new__方法里面  x = object.__new__(cls) 就是申请内存空间的 
"""


💯三、继承的基本使用

面向对象3大特征  封装 继承 多态

封装:函数是对语句的封装;类是对函数和变量的封装

继承:类和类之间可以认为手动的建立父子关系，父类的属性和方法，子类可以使用

多态:是一种技巧，提高代码的灵活度
# 封装
#一个一个的语句
def test():
    a=23#赋值语句
    a+=3#算数运算符表达式语句
    print('hello')
    print('good')

class Person(object):
    type ='人类'

    def __init__(self):
        pass

    def eat(self):
        pass

test()

# 结果
# hello
# good

继承的使用 括号里面加 要继承的类名就可以

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

    def sleep(self):
        print(self.name+'进入睡梦中')


class Dog(Animal):
    def bark(self):
        print(self.name+'正在大叫')


class Student(Animal):
    def study(self):
        print(self.name + '进入学习的世界')


d1 = Dog('z',13)
d1.sleep()
d1.bark()

# 结果
# z进入睡梦中
# z正在大叫

继承的特点

class test_A(object):
    def a(self):
        print('我是A类里的方法demo_a')

    def test(self):
        print('我是A类的test')


class test_B(object):
    def b(self):
        print('我是B类里的方法demo_b')

    def test(self):
        print('我是B类的test')

#Python允许多继
# 他既继承了A 也继承了B
class C(test_A,test_B):
    pass

c=C()
c.a()
c.b()

# 如果两个不同的父类有同名方法,先调用前面的一个
c.test()

# 结果是
# 我是A类里的方法demo_a
# 我是B类里的方法demo_b
# 我是A类的test

私有属性的继承特点



class Animal(object):
        def __init__(self,name,age):
                self.name=name
                self.age=age
                self.__money = 1000

        def sleep(self):
                print(self.name+'开始入睡')


        def __test(self):
                print('我是Animal类里的test方法')


class Person(Animal):
        def __demo(self):
                print('我是Person里面的私有方法')



p = Person('张三',18)
p.sleep()

# 私有的方法不能被继承
p._Person__demo() # 调用自己的可以
# p._Person__test() # 调用父类的不行 没法继承



# 私有属性也无法继承
# print(p._Person__money)
# 自己调用是没问题
print(p._Animal__money)



# 输出结果是
# 张三开始入睡
# 我是Person里面的私有方法
# 1000

💯四、is和isinstance 面向对象的相关使用方法

is 运算符用来比较是否是同一个对象

isinstance 用来判断一个对象是否是由指定的类（或者父类）实例化出来的

issubclass 用来判断一个类是否是另一个类的子类

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


class Student(Person):
    pass


p1 = Person('张三',18)
p2 = Person('张三',18)

s = Student('jack',18)

# 获取两个对象的内存地址   id(p1) == id(p2)
# is 运算符用来比较是否是同一个对象
print(p1 is p2)  # False


#type（p1）#其实获取的就是类对象
a=1
if type(a) == int:
    print('a是整数类型')
if type(p1)==Person:
    print('p1是Person类创建的实例对象')


# isinstance 用来判断一个对象是否是由指定的类（或者父类）实例化出来的
print(isinstance(s,Student)) # True
print(isinstance(s,Person)) # True

print(isinstance(p1,Student)) # False
print(isinstance(p1,Person)) # True



# issubclass 用来判断一个类是否是另一个类的子类
print(issubclass(Student,Person)) # True
print(issubclass(Person,Student)) # False

💯五、多态子类重写父类方法

继承特点：想果一个类A继承自类B，由类A创建出来的实例对全部能直接使用类B里定义的方法

1.子类的实现和父类的实现完全不一样，子类可以选择重写父类的方法。

2.子类科父类的基础上又有更多的实现 可以选择重写


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

    def sleep(self):
        print(self.name + '入睡')


class Student(Person):

    # 重写方法
    def __init__(self, name, age, school):
        # self.name = name
        # self.age = age
        # 子类在父类实现的基础上，又添加了自己的新的功能
        # 调用父类方法的两种方式

        # 1.父类名.方法名（self,参数列表）
        # Person.__init__(self,name,age)

        # 2.使用super直接调用父类方法(建议使用这个)
        super(Student, self).__init__(name, age)
        self.school = school

    # 重写方法
    def sleep(self):
        print(self.name + '正在床上呼呼大睡')

    def study(self):
        print(self.name + '正在学习')


s = Student('jerry', 20, '幼稚园')
s.sleep()

# 然后介绍一个方法 __mro__ 就是可以看 使用函数对象的时候 他会找谁
print(Student.__mro__)
# (<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)
#  意思就是先找自己 然后找Person 然后找 object

Python持续更新

有任何疑问可以随便在评论区问我✔️✔️✔️

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZTLJQ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值