python基础——面向对象

最新推荐文章于 2024-09-10 19:34:17 发布
最新推荐文章于 2024-09-10 19:34:17 发布
阅读量577 收藏 4
点赞数 3
分类专栏： python基础 文章标签： python 面向对象
原文链接：https://zhuanlan.zhihu.com/p/592402274
版权
本文介绍了Python中的面向对象编程基础，包括类和对象的概念，如何创建和使用类，面向对象的三大特性——封装、继承和多态，以及类属性、实例属性、类方法和静态方法。通过实例详细讲解了这些概念和语法，帮助读者理解面向对象编程的核心思想。
摘要由CSDN通过智能技术生成

        最近看到一篇非常深奥的算法源码，发现它的底层逻辑全部都是由类实现的，而这种实现方式有非常大的好处，同样对于编程人员来讲，这种实现方式无疑增加了难度和挑战。没有受过系统训练的编程人员，常规的思路与编程习惯基本上都会是面向过程编程，很明显这种方式较为简单，但问题是这种思维方式，一旦遇到变换后其后期维护比较困难。好了转入正题，下面的内容也是自己在网上学习别人总结的资料，为方便后续学习与理解，全文内容属于转载【来源--知乎：纳西】，如对作者造成侵权，请及时联系我，我可及时删除，在此表示感谢。（大家可以跳转到原作者链接上进行系统学习）

1 面向对象(OOP)基本概念

1.1 过程和函数

  • 过程是早期的一个编程概念
  • 过程类似于函数，但只能执行，没有返回值
  • 函数不仅能执行，还可以返回结果

1.2 面向过程和面向对象

1.2.1 面向过程

  • 把某一个需求的所有步骤，从头到尾逐步实现
  • 根据开发需求，将某些功能独立的代码封装成一个又一个函数
  • 最后顺序地调用不同的函数，完成代码

特点：

  • 注重步骤和过程，不注重职责分工
  • 开发复杂项目，没有固定的套路，开发难度很大

之前的名片管理系统：

复杂的情况：一旦修改其中一个函数的参数，调用它的地方也要修改

只封装功能在函数中
函数之间会彼此调用，关系复杂

1.2.2 面向对象——谁来做

  • 在完成某一个需求前，首先确定职责——要做的事情（方法）
  • 根据职责确定不同的对象，但对象内部封装不同的方法（多个）
  • 最后，顺序地让不同的对象调用不同的方法

特点：

  • 注重对象和职责
不仅将功能封装在方法中，还将方法封装在对象中。
不同对象不会调用对方的方法，关系简单

2 类和对象

2.1 概念

1、类

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用

  • 特征被称为 属性
  • 行为被称为 方法

2、对象

对象是由类创建出来的一个具体存在，可以直接使用

由哪一个类创建出来的对象，就拥有哪一个类中定义的：属性、方法

在程序开发中，先有类，再有对象（类似于先有图纸，再有实物）

2.2 类和对象的关系

类只有一个，对象可以有多个

不同对象之间属性可能会各不相同
类中定义有什么属性和方法，对象也一样，不多不少

2.3 类的设计

在使用面向对象开发前，应该首先分析需求，确定程序中需要哪些类：

设计一个类，通常要满足三个要素：

  • 类名：大驼峰命名法（例如GapWords），提炼需求中的名词
  • 属性：这个类的特征
  • 方法：这个类的行为

练习：

1、需求：

  • 小明今年18岁，身高1.75，每天早上跑完步，会去吃东西
  • 小美今年17岁，身高1.65，小美不跑步，小美喜欢吃东西

2、提炼：创建类
Person：name、age、height；run()、eat()

3 面向对象基本语法

3.1 dir()

变量、数据、函数都是对象

在python中可以用两个方法验证：

  1. 在ipython中，在标识符/数据后面输入.，然后按下tab键，可以查看对象内的属性和方法
  2. 使用内置函数dir传入标识符/数据，可以查看对象内所有属性及方法
def sum_number(num):
    # 递归的出口
    if num == 1:  # 累加的最小数字
        return 1
    # 【假设sum_number(num-1)能够得到(1+2+...+num-1)】
    temp = sum_number(num-1)
    return temp + num
​
​
print(dir(sum_number))

__方法名__格式的方法是python提供的内置方法/属性：

序号方法名类型作用
01__new__方法创建对象时，会被自动调用
02__init__方法对象被初始化时，会被自动调用
03__del__方法对象被从内存中销毁前，会被自动调用
04__str__方法返回对象的描述信息，print函数输出使用

利用好dir函数，很多方法不用死记硬背

3.2 定义简单的类（只包含方法）

3.2.1 定义类

class 类名:
    def 方法1(self, 参数列表):
        pass
    def 方法1(self, 参数列表):
        pass
方法定义的格式和之前类似，区别在于 第一个参数必须是self

3.2.2 创建对象

对象变量 = 类名()

3.2.3 练习——第一个面向对象程序

需求：小猫爱吃鱼，小猫要喝水

分析：Cat：eat()、 drink()

class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象
tom = Cat()
​
tom.eat()
tom.drink()
引用：在python中使用类创建对象之后，tom变量中 记录的是对象在内存中的地址
使用 print输出对象变量，默认情况下输出变量引用的对象 是由哪一个类创建的，以及 在内存中的地址（十六进制） 
class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象
tom = Cat()
print(tom)  # <__main__.Cat object at 0x000001EAFAB264C0>
< main.Cat object at 0x000001EAFAB264C0>：
Cat类名，object对象，地址0x000001EAFAB264C0
意思：Cat对象在0x000001EAFAB264C0的地址
print(id(tom)) # 3049420584128
用 id()打印出来的地址是十进制的

%d %x：

%d：以十进制输出数字

%x：以十六进制输出数字

3.2.4 创建多个对象

class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象：不是同一只猫
tom = Cat()
lazy_cat = Cat()
print(tom) 
print(lazy_cat)
"""
<__main__.Cat object at 0x000002CD9CE874C0>
<__main__.Cat object at 0x000002CD9CE969A0>
"""
class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象：是同一只猫
lazy_cat = Cat()
lazy_cat2 = lazy_cat
print(lazy_cat)
print(lazy_cat2)
"""
<__main__.Cat object at 0x00000208E64E74C0>
<__main__.Cat object at 0x00000208E64E74C0>
"""

3.3 在类的外部给对象增加属性

class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
tom = Cat()
# 增加属性
tom.name = "Tom"
lazy_cat = Cat()

3.4 self

class Cat:
​
    def eat(self):
        print("小猫爱吃鱼")
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象
tom = Cat()
tom.name = "Tom"
tom.drink()
tom.eat()
print(tom.name)

self和tom的地址是一样的，且属性相同

⏬

哪一个对象调用的方法，self就是哪一个对象的引用

class Cat:
​
    def eat(self):
        print("%s 爱吃鱼" % self.name)
​
    def drink(self):
        print("小猫要喝水")
​
​
# 创建对象
tom = Cat()
tom.name = "Tom"
tom.drink()
tom.eat()  # Tom 爱吃鱼
print(tom.name)

在方法内部：

  • 可以通过self.访问对象的属性
  • 可以通过self.调用其他的对象方法

不建议在方法外部增加对象的属性：

# 会出错
class Cat:
​
    def eat(self):
        print("%s 爱吃鱼" % self.name)
​
​
# 创建对象
tom = Cat()
tom.eat()  
tom.name = "Tom"

3.5 初始化方法

3.5.1 概念

当使用类名()创建对象时，会自动执行以下操作：

  1. 为对象在内存分配空间——创建对象
  2. 为对象的属性设置初始值——初始化方法(init)
    这个初始化方法就是__init__方法
    __init__方法是专门用来定义一个类具有哪些属性的方法
# 验证创建对象时，会自动调用初始化方法
class Cat:
​
    def __init__(self):
        print("这是一个初始化方法")
​
​
# 创建对象
tom = Cat()
"""
这是一个初始化方法
"""

3.5.2 在初始化方法内部定义属性

定义属性，在__init__内部使用self.属性名 = 属性的初始值

定义属性之后，再使用类名()创建对象，该对象就拥有这个属性

class Cat:
​
    def __init__(self):
        print("这是一个初始化方法")
        self.name = "Tom"
​
​
# 创建对象
tom = Cat()
print(tom.name)
"""
这是一个初始化方法
Tom
"""

3.5.3 使用形参对初始化方法进行改造

之前的代码，name属性的值一直是"Tom"

要修改name，可以给__init__方法传入一个形参

class Cat:
​
    def __init__(self, new_name):
        print("这是一个初始化方法")
        self.name = new_name
​
​
# 创建对象
tom = Cat("Tom")
print(tom.name)
lazy_cat = Cat("大懒猫")
print(lazy_cat.name)
"""
这是一个初始化方法
Tom
这是一个初始化方法
大懒猫
"""

3.6 __del__方法

一个对象被从内存中销毁前，会自动调用__del__方法

应用场景：

如果希望在对象被销毁前，再做一些事情，可以考虑 __del__方法

生命周期：

一个对象调用 类名()创建，生命周期开始
一个对象的 __del__方法一旦被调用，生命周期结束 
class Cat:
​
    def __init__(self, new_name):
        self.name = new_name
        print("%s 来了" % self.name)
​
    def __del__(self):
        print("%s 去了" % self.name)
​
​
# 创建对象
tom = Cat("Tom")
print(tom.name)
lazy_cat = Cat("大懒猫")
print(lazy_cat.name)
print("-" * 50)
"""
Tom 来了
Tom
大懒猫 来了
大懒猫
--------------------------------------------------
Tom 去了
大懒猫 去了
"""
class Cat:

    def __init__(self, new_name):
        self.name = new_name
        print("%s 来了" % self.name)

    def __del__(self):
        print("%s 去了" % self.name)


# 创建对象
tom = Cat("Tom")
print(tom.name)
del tom  # 删除对象
print("-" * 50)
"""
Tom 来了
Tom
Tom 去了
--------------------------------------------------
"""

3.7 __str__方法

使用print输出对象变量，默认输出：变量引用的对象是由哪一个类创建的、对象在内存中的地址

如果希望使用print输出对象变量时，能够打印自定义内容，就可以利用__str__方法

注意： __str__方法 必须返回一个字符串 
class Cat:

    def __init__(self, new_name):
        self.name = new_name
        print("%s 来了" % self.name)

    def __del__(self):
        print("%s 去了" % self.name)

    def __str__(self):
        # 必须返回一个字符串
        return "我是小猫[%s]" % self.name


# 创建对象
tom = Cat("Tom")
print(tom)
print("-" * 50)
"""
Tom 来了
我是小猫[Tom]
--------------------------------------------------
Tom 去了
"""

4 面对对象的三大特性之一——封装

4.1 封装

封装——将 属性 和 方法 封装到一个抽象的类中

面向对象编程的第一步，将 属性和 方法封装到一个 抽象的类中
外界使用类创建 对象，然后让对象 调用方法

4.2 案例

4.2.1 小明爱跑步

小明体重75.0公斤

小明每次跑步会减肥0.5公斤

小明每次吃东西体重增加1公斤

class Person:

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

    def __str__(self):
        return "%s的体重是%.2f 公斤" % (self.name, self.weight)

    def eat(self):
        print("吃东西")
        self.weight += 1.0

    def run(self):
        print("跑步")
        self.weight -= 0.5


xiaoMing = Person("小明", 76.0)
print(xiaoMing)
xiaoMing.eat()
print(xiaoMing)
xiaoMing.run()
print(xiaoMing)
"""
小明的体重是76.00 公斤
吃东西
小明的体重是77.00 公斤
跑步
小明的体重是76.50 公斤
"""

4.2.2 小明爱跑步扩展——小美也爱跑步

class Person:

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

    def __str__(self):
        return "%s的体重是%.2f 公斤" % (self.name, self.weight)

    def eat(self):
        print("吃东西")
        self.weight += 1.0

    def run(self):
        print("跑步")
        self.weight -= 0.5


xiaoMing = Person("小明", 76.0)
xiaoMei = Person("小美", 45.0)
print(xiaoMing)
print(xiaoMei)

4.2.3 摆放家具

  1. 房子有户型、总面积、家具名称列表
  • 新房子没有任何的家具

2. 家具有名字和占地面积，其中

  • bed 4平米
  • chest 2平米
  • table 1.5平米

3. 将以上三件家具添加到房子中

4. 打印房子时，要求输出户型、总面积、剩余面积、家具名称列表

class HouseItem:

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

    def __str__(self):
        return "[%s]占地 %.2f 平米" % (self.name, self.area)


class House:

    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []

    def __str__(self):
        # 【python能够将一对括号内的内容连接在一起，所以可以换行】
        return ("户型是[%s]，\n总面积[%.2f]平米，\n剩余面积[%.2f]平米，\n家具有[%s]"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))

    def add_item(self, item):
        print("要添加[%s]" % item) # 【输出的是HouseItem的__str__()方法定义的输出】
        if item.area > self.free_area:
            print("房子剩余面积不够，无法添加 %s " % item.name)
            return
        self.free_area = self.free_area - item.area
        self.item_list.append(item.name)


# 1、创建家具
bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

# 2、创建房子对象
my_home = House("两室一厅", 70)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

# 3、输出房子
print("-" * 50)
print(my_home)

4.3 一个对象的属性可以是另一个类创建的对象

案例：士兵突击

  • 士兵许三多有一把AK47
  • 士兵可以开火
  • 枪可以发射子弹
  • 枪装填子弹——增加子弹数量
# - 士兵许三多有一把AK47
# - 士兵可以开火

# - 枪可以发射子弹
# - 枪装填子弹——增加子弹数量
class Gun:
    def __init__(self, cartridge_name):
        self.cartridge_name = cartridge_name
        # 【子弹数量初始为0，不需要传递参数】
        self.cartridge_num = 0

    def __str__(self):
        return "%s 中还有 %d 颗子弹" % (self.cartridge_name, self.cartridge_num)

    def play(self):
        if self.cartridge_num == 0:
            print("子弹数量不够，无法开枪")
            return
        self.cartridge_num -= 1
        print("【发射子弹】... %d" % self.cartridge_num)

    def add(self, count):
        self.cartridge_num += count
        print("【装填子弹】... %d" % self.cartridge_num)


class Soldier:
    def __init__(self, name):
        self.name = name
        # 新兵没有枪【可以用None赋值给属性】
        self.gun = None

    def __str__(self):
        if self.gun is None:
            return "士兵 [%s] 没有枪" % self.name
        else:
            return "士兵 [%s] 有一把 [%s]" % (self.name, self.gun.cartridge_name)

    def shoot(self):
        # 1、判断士兵有没有枪
        if self.gun is None:
            print("士兵[%s]没有枪..." % self.name)
            return
        # 2、高喊口号
        print("【士兵开枪】")
        # 3、让枪装填子弹
        self.gun.add(50)
        self.gun.play()


AK47 = Gun("AK47")
print(AK47)
xuSanDuo = Soldier("许三多")
print(xuSanDuo)
xuSanDuo.gun = AK47
print(xuSanDuo)
xuSanDuo.shoot()
xuSanDuo.shoot()

4.4 身份运算符 is、is not

用于比较两个对象的内存地址是否一致（是否是对同一个对象的引用）

运算符描述实例
isis是判断两个标识符是否引用同一个对象x is y类似id(x)==id(y)
is not判断两个标识符引用不同对象x is not y类似id(x)!=id(y)

is和==的区别：

==判断变量的值

is判断变量的地址

a = [1, 2, 3]
b = [1, 2]
b.append(3)
print("a的地址%d" % id(a))
print("b的地址%d" % id(b))
print(a == b)  # True
print(a is b)  # False

None：

对于None的比较，建议使用is判断

4.5 私有属性和私有方法

4.5.1 应用场景

对象的某些属性或方法只希望在对象的内部被使用，而不希望在外部被访问到

4.5.2 定义方法

在属性名或者方法名前增加两个下划线

class Women:

    def __init__(self, name):
        self.name = name
        self.__age = 18

    def secret(self):
        print("%s 的年龄是 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
# print(xiaofang.__age)  # 报错：在外界私有属性不能被访问
xiaofang.secret()  # 可以执行：私有属性在方法内部可以被访问

class Women:

    def __init__(self, name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print("%s 的年龄是 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
# print(xiaofang.__age)  # 报错：在外界私有属性不能被访问
xiaofang.__secret()  # 报错

4.5.3 python中没有真正意义的私有

在给属性、方法命名时，实际是对名称做了一些特殊处理，使得外界无法访问到

访问方法：在名称前面加上 _类名 
class Women:

    def __init__(self, name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print("%s 的年龄是 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
print(xiaofang._Women__age)  # 18
xiaofang._Women__secret()  # 小芳 的年龄是 18

在开发中，不要使用这种方法去访问对象的私有属性或私有方法（既然设置为隐私，就不要访问）

5 面向对象的三大特性之一——继承

5.1 概念

继承：实现代码的重用

子类继承自父类，可以使用父类所有的属性和方法
子类中应该根据职责，封装子类特有的属性和方法

5.2 语法

class 类名(父类名):

pass

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


# 子类拥有父类所有的属性和方法
class Dog(Animal):
    def bark(self):
        print("汪汪叫")


wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()

5.3 专业术语

Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承

Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生

5.4 继承的传递性

C类从B类继承，B类从A类继承。那么C类具有B类和A类的所有属性和方法

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


# 子类拥有父类所有的属性和方法
class Dog(Animal):
    def bark(self):
        print("汪汪叫")


# 继承具有传递性
class XiaoTian(Dog):
    def fly(self):
        print("哮天犬会飞")


wangcai = XiaoTian()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()
wangcai.fly()

可以看出Animal类的被Dog和XiaoTian继承

5.5 注意事项

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


# 子类拥有父类所有的属性和方法
class Dog(Animal):
    def bark(self):
        print("汪汪叫")


class Cat(Animal):
    def bark(self):
        print("喵喵叫")


class XiaoTian(Dog):
    def fly(self):
        print("哮天犬会飞")


wangcai = XiaoTian()
wangcai.bark()  # 汪汪叫
# XiaoTian类不能使用Cat类的方法和属性，他们没有继承关系
XiaoTian类不能使用Cat类的方法和属性，他们没有继承关系

5.6 方法的重写

5.6.1 覆盖父类的方法

当父类中的方法不能满足子类需求时，可以对方法进行重写

实现方法：在子类中定义一个同名方法

class Dog(Animal):
    def bark(self):
        print("汪汪叫")


class XiaoTian(Dog):
    # 方法重写
    def bark(self):
        print("嗷嗷嗷~")

    def fly(self):
        print("哮天犬会飞")


wangcai = XiaoTian()
wangcai.bark() # 嗷嗷嗷~

5.6.2 对父类方法进行扩展

方法：

  1. 在子类重写父类方法
  2. 在需要的位置使用super().父类方法来调用父类方法
class Dog(Animal):
    def bark(self):
        print("汪汪叫")


class XiaoTian(Dog):
    # 方法重写
    def bark(self):
        # 1.针对子类特有的需求，编写代码
        print("嗷嗷嗷~")
        # 2.使用super().调用父类中的方法
        super().bark()
        # 3.增加其他代码
        print("吼吼吼~")

    def fly(self):
        print("哮天犬会飞")


wangcai = XiaoTian()
wangcai.bark()

"""
嗷嗷嗷~
汪汪叫
吼吼吼~
"""

super:

  1. super是一个特殊的类
  2. super()是使用super类创建出来的对象
  3. 最常使用的场景是重写父类方法时，调用在父类中封装的方法

调用父类方法的另一种方式：

在python2.x时，使用方法：

父类名.方法(self)

在python3.x中不推荐使用（能用），因为一旦父类发生变化，调用位置的父类名同样需要修改

class Dog(Animal):
    def bark(self):
        print("汪汪叫")


class XiaoTian(Dog):
    # 方法重写
    def bark(self):
        # 1.针对子类特有的需求，编写代码
        print("嗷嗷嗷~")
        # 2.使用super().调用父类中的方法
        Dog.bark(self)
        # 3.增加其他代码
        print("吼吼吼~")

    def fly(self):
        print("哮天犬会飞")


wangcai = XiaoTian()
wangcai.bark()

"""
嗷嗷嗷~
汪汪叫
吼吼吼~
"""

5.7 父类的私有属性和私有方法

  1. 子类对象 不能在自己的方法内部，直接访问父类的私有属性或私有方法
  2. 子类对象 可以通过父类的公有方法 间接访问到私有属性或私有方法
class A:
    def __init__(self):
        self.__name = "A"

    def __test1(self):
        print("父类的私有方法")

    def test(self):
        print("父类的公有方法:")
        print("父类中的私有属性 %s" % self.__name)
        self.__test1()


class B(A):
    pass


b = B()
b.test()
"""
父类的公有方法:
父类中的私有属性 A
父类的私有方法
"""

5.8 多继承

5.8.1 语法

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

pass

class A:

    def test(self):
        print("test方法")


class B:

    def demo(self):
        print("demo方法")


class C(A, B):
    pass


c = C()
c.test()
c.demo()

5.8.2 注意事项

不同的父类中有同名的方法，应该避免使用多继承

class A:

    def test(self):
        print("A---test方法")

    def demo(self):
        print("A---demo方法")


class B:

    def test(self):
        print("B---test方法")

    def demo(self):
        print("B---demo方法")


class C(A, B):
    pass


c = C()
c.test()
c.demo()
"""
A---test方法
A---demo方法
"""

5.8.3 MRO——方法搜索顺序

python针对类提供了一个内置属性__mro__，可以查看方法搜索顺序

主要用于多继承时判断方法、属性的调用路径

语法：

对象.__mro__
class A:

    def test(self):
        print("A---test方法")

    def demo(self):
        print("A---demo方法")


class B:

    def test(self):
        print("B---test方法")

    def demo(self):
        print("B---demo方法")


class C(A, B):
    pass


c = C()

# 确定C类对象调用方法的顺序
print(C.__mro__)
"""
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
顺序：C-A-B-object 【object是所有类的基类】
"""

5.8.4 新式类、旧式（经典）类

object是python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看

新式类：以object为基类的类

经典类：不以object为基类的类，不推荐使用

在 python3.x中，默认 object是基类
在 python2.x中，如果没有指定父类，则不会以object作为基类

为了保证代码在python2.x和python3.x中都可以运行，在定义类时，如果没有父类，建议统一继承自object：

class 类名(object):
	pass

6 面向对象的三大特性之一——多态

多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

前提：继承、重写父类方法

class Dog(object):

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

    def game(self):
        print("%s 蹦蹦跳跳地玩耍" % self.name)


class XiaoTianDog(Dog):

    def game(self):
        print("%s 飞到天上玩耍" % self.name)


class Person(object):

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

    def game_with_dog(self, dog):
        print("%s 和 %s 快乐地玩耍" % (self.name, dog.name))
        dog.game()


wangCai = Dog("旺财")
xiaoMing = Person("小明")
xiaoMing.game_with_dog(wangCai)
"""
小明 和 旺财 快乐地玩耍
旺财 蹦蹦跳跳地玩耍
"""
wangCai = XiaoTianDog("飞天旺财")
xiaoMing = Person("小明")
xiaoMing.game_with_dog(wangCai)
"""
小明 和 飞天旺财 快乐地玩耍
飞天旺财 飞到天上玩耍
"""

7 类属性

7.1 术语

  1. 使用面向对象开发，第一步是设计类
  2. 使用类名()创建对象，创建对象有两步：
    1）在内存为对象分配空间
    2）调用初始化方法__init__为对象初始化
  3. 对象创建后，内存中就有了一个对象的存在——实例

创建了三个对象，它们的内存位置不同，保存各自不同的属性
对象的方法只保存在一个位置，不同对象使用方法时，通过传递参数调用

因此：

  1. 创建出来的对象叫做类的实例
  2. 创建对象的动作叫做实例化
  3. 对象的属性叫做实例属性
  4. 对象调用的方法叫做实例方法

7.2 类是一个特殊的对象

python中一切皆对象，

class AAA:定义的类属于 类对象
obj1 = AAA()属于 实例对象

类对象可以拥有自己的属性和方法：

  1. 类属性
  2. 类方法
通过 类名.的方式可以访问类的属性或者调用类的方法

7.3 类属性和实例属性

  1. 类属性就是给类对象中定义的属性
  2. 通常用来记录与这个类相关的特征
  3. 类属性不会用于记录具体对象的特征

语法：

使用赋值语句定义

使用类.类属性调用

示例：

  • 定义一个工具类
  • 每件工具都有自己的name
  • 需求——知道使用这个类，创建了多少个工具对象
class Tool(object):

    # 定义类属性
    count = 0

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

        # 让类属性的值+1
        Tool.count += 1

tool1 = Tool("斧头")
print(Tool.count)
tool2 = Tool("榔头")
print(Tool.count)
tool3 = Tool("水桶")
print(Tool.count)

属性的获取——向上查找机制

在python中属性的获取存在一个向上查找机制

因此，要访问类属性有两种方式：

  1. 类名.类属性
  2. 对象.类属性（不推荐：读取时没有问题；设置值时不可以）
class Tool(object):

    # 定义类属性
    count = 0

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

        # 让类属性的值+1
        Tool.count += 1

tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
# 方式一
print(Tool.count)
# 方式二
print(tool1.count)
print(tool3.count)

注意：

  • 使用对象.类属性 = 值，只会给对象添加属性，不会影响到类属性的值
  • tool3.count = 100
    在tool3内存空间查找是否有count属性，没有就添加；有就修改值
class Tool(object):

    # 定义类属性
    count = 0

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

        # 让类属性的值+1
        Tool.count += 1

tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
tool1.count = 100
# 方式一
print(Tool.count)  # 3
# 方式二
print(tool1.count)  # 100
print(tool3.count)  # 3

8 类方法

访问到类属性

8.1 语法

@classmethod
def 类方法名(cls):
    pass
需要用 修饰器 @classmethod来标识， 告诉解释器这是一个类方法
类方法的 第一个参数应该是 cls
  • 由哪一个类调用的方法，cls就是哪一个类的引用
  • 和实例方法中的self类似
  • 提示：使用其他名称也可，不过习惯用cls

8.2 案例

  • 定义一个工具类
  • 每件工具都有自己的name
  • 需求——在类封装一个show_tool_count的类方法，输出使用当前这个类创建的对象个数
class Tool(object):

    # 定义类属性
    count = 0

    @classmethod
    def show_tool_count(cls):
        print("工具对象的个数 %d" % cls.count)  # 使用【cls.count】

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

        # 让类属性的值+1
        Tool.count += 1


tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")

Tool.show_tool_count()

9 静态方法

9.1 应用场景

  • 既不需要访问实例属性或者调用实例方法
  • 也不需要访问类属性或者调用类方法

9.2 语法

@staticmethod
def 静态方法名():  # 不需要self
    pass
需要修饰器 @staticmethod告诉解释器，这是一个静态方法
通过 类名. 调用静态方法 
class Dog(object):

    @staticmethod
    def run():
        print("小狗要跑")


# 不创建对象，直接调用静态方法
Dog.run()

9.3 案例

  1. 设计一个Game类
  2. 属性：
  • 定义一个类属性top_score记录游戏的历史最高分
  • 定义一个实例属性player_name记录当前游戏的玩家姓名

3. 方法：

    • 静态方法show_help显示游戏帮助信息
    • 类方法show_top_score显示历史最高分
    • 实例方法start_game开始当前玩家的游戏

4. 主程序步骤

    • 查看帮助信息
    • 查看历史最高分
    • 创建游戏对象，开始游戏
class Game(object):

    # 历史最高分
    top_score = 0

    def __init__(self, name):
        # 玩家姓名
        self.player_name = name

    @staticmethod
    def show_help():
        print("游戏帮助信息...")

    @classmethod
    def show_top_score(cls):
        print("游戏最高分为 %d" % cls.top_score)

    def start_game(self):
        print("【%s】开始游戏" % self.player_name)


# - 查看帮助信息
Game.show_help()
# - 查看历史最高分
Game.show_top_score()
# - 创建游戏对象，开始游戏
xiaoMing = Game("小明")
xiaoMing.start_game()

小结

  1. 实例方法——方法内部需要访问 实例属性
  • 实例方法内部可以使用 类名. 访问类属性

2. 类方法——方法内部只需要访问 类属性

3. 静态方法——方法内部不需要访问类属性和实例属性

且行且安~
关注
专栏目录
Python面向对象
Amo Xiang的博客
12-24 2972
Python面向对象1. 面向对象基础语法2. 初始化方法__init__3. 属性查找与绑定方法4. 跑步案例5. 家具案例6. 私有属性7. 继承7.1 面向对象的三大特性7.2 单继承7.2.1 继承的概念7.2.2 继承的语法7.2.3 方法的重写 1. 面向对象基础语法 # -*- coding: utf-8 -*- # @Time : 2019/12/9 14:33 # @Aut...
面向对象与面向过程
zhangxuelong461的博客
08-29 297
面向过程 VS 面向对象 面向过程： 面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。 优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。 缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。 应用场景：一旦完成基本很少改变的场景，著名的例子有Linu...
Python基础08 面向对象的基本概念
anwangtun3623的博客
12-02 283
Python基础 面向对象的基本概念 作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！ 谢谢逆水寒龙,topmad和Liqing纠错 Python使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程。 面向对象的最...
Python基础（五）——面向对象
最新发布
m0_74556076的博客
09-10 763
关于Python中面向对象的知识，包括类、对象、构造方法、魔术方法、类型注解、封装、继承和多态的理解。
python面向对象
09-13
python面向对象精彩讲解视频，详细讲解了python在面向对象中的用途。
Python基础——面向对象基础（练习）
Alice
09-05 1977
文章目录一、二、 一、 面向对象编程：OOP 面向对象编程的关注点在于谁来做，相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法 二、
Python基础学习——面向对象的基本编程
01-21
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。 一、面向对象技术简介 类(Class) : 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有...
Python——面向对象思想编程（一）
12-22
在Python中，类（Class）是实现面向对象编程的基础，它定义了一组特性和行为，这些特性和行为共同构成了对象（Object）。 类的设计遵循一定的规范。类名应见名知意，首字母大写，其他部分遵循驼峰命名法。属性是类...
从零开始python——面向对象开发2
12-22
从零开始python——面向对象开发2 太原理工大学机器人团队20日打卡day10 1、内置方法和属性 2、私有属性和私有方法 3、继承 ​ 昨天晚上躺在床上时候还在想有没有用于arduino的python编译器，好像是没有的，不过...
python3基础篇（八）——面向对象
01-20
python3基础篇（八）——面向对象 前言 1 阅读这篇文章我能学到什么？   这篇文章将为你详细介绍python3中的面向对象程序设计，你将学会如何定义一个类和使用一个对象。 ——如果你觉得这是一篇不错的文章，希望你...
python-面向对象
yangliu_w的博客
04-05 218
对象概念 万物皆对象 对象是具体物体：拥有属性 拥有行为 把很多零散的东西，封装成为一个整体 python是一门特别彻底的面向对象的语言 OOP在解决问题的时候关注解决问题的所需要的对象（划分对象） 面向对象在解决问题的时候关注解决问题的过程（步骤），把一个任务，分解成具体的一个步骤 面向过程——>面向对象：列出任务具体现实步骤、试图分离这些步骤的功能代码块、将这些功能代码块划分到某个对象...
Python学习：面向对象基础——类与面向过程区别
在Python编程中，第十三天的学习重点转向了面向对象编程的概念，特别是关于类的理解。类是面向对象编程的核心概念，它是一个抽象的数据类型，用来描述具有相似特性和行为的对象集合。 首先，让我们回顾一下面向过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值