提供了Python编程的基础技术教程

Python程序教程

您现在的位置是：首页 >  python编程

当前栏目

Python 编程 | 连载 15 - Python 的类

Python,编程,连载,15
2025-03-13 21:27:22 时间

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第8天，点击查看活动详情。

一、类与面向对象

利用对象的属性和方法去编程的过程就是面向对象编程，其中自定义对象数据类型就是面向对象中类的概念

定义类的关键字class，class用来声明类，类的名称首字母大写，包含多个单词的情况下每个单词的首字母大写

# 定义一个类
class Hero(object):
    name = 'Stark'

    def fight(self):
        print('IronMan fighting with thanos')


# 实例化一个对象
stark = Hero()
# 调用对象属性
print(stark.name)
# 调用对象的方法
stark.fight()

类的参数self：

  • self是类函数中的必传参数，且必须放在第一个参数位置
  • self是一个对象，代表了实例化的对象本身
  • self可以直接通过打点来定义一个类变量
  • self中的变量与含有self参数的函数可以在类中任何一个函数内随意调用
  • 非函数中定义的变量在定义的时候不用self
class Hero(object):
    name = None
    address = None

    def fight(self):
        print('%s fight with thanos' % self.name)

    def rescue(self):
        print('%s helping people' % self.name)


steve = Hero()
steve.fight()
steve.rescue()

# 给属性赋值
stark = Hero()
stark.name = 'IronMan'
stark.fight()
stark.rescue()

# 定义新的属性
stark.suit = 'Mark 85'
print(stark.suit)

print(steve.suit)

实例化对象可以自定义属性，实例化对象自定义的属性是独立的

Hero类中定义新的函数work

class Hero(object):

    # 其余内容保持不变
    def work(self):
        self.fight()
        self.rescue()

# 调用work函数
stark.work()

self表示当前类的实例化对象，可以通过打点的方式调用类中定义的函数

Hero类新增一个普通函数，既不带self参数的函数，并用实例化的对象调用该函数

class Hero(object):
    # 其他函数保持不变
    def walk():
        print('walking')

# 其余代码保持不变
stark.walk()

walk()函数本身没有参数，但是通过实例化对象调用时会自动传入self参数，因此出现了控制台打印出来的报错信息

在类中定义的函数不添加self参数，就无法通过实例化对象调用

在类函数中定义的函数，只能在当前函数体内调用

class Hero(object):

    # 类中其他属性和函数保持不变
    def work(self):
        def walk(name):
            return name
        res = walk(self.name)
        print('{} is walking'.format(res))
        self.fight()
        self.rescue()
        

# 其余代码保持不变
stark.work()   

# 在定义的函数体外调用会报错
walk()

将walk定义在Heros类的上面，这样walk函数就变成了一个全局函数，就可以随意调用

二、类的构造函数

累的构造函数是类中的一种默认函数，用来将类实例化的同时，对属性进行赋值

# 构造函数名必须为__init__，必须包含self参数
def __init__(self, name, address):
    self.name = name
    self.address = address

给Hero类增加构造函数

class Hero(object):
    name = None
    address = None

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


    def fight(self):
        print('%s fight with thanos' % self.name)

    def rescue(self):
        print('%s helping people' % self.name)


# 有了构造函数后，实例化对象一定要传递对象属性
stark = Hero('IronMan', 'NY')
print(stark.name)
print(stark.address)
stark.fight()
stark.rescue()

三、对象的生命周期

四、私有函数与私有变量

私有函数和私有变量：

  • 无法被实例化后的对象调用的类中的函数与变量
  • 类内部可以调用私有的函数和变量
  • 只希望在类内部使用，不希望被实例化的对象使用

只要在变量和函数前添加__既连续两个下划线，就定义了私有函数和变量

class Cat(object):

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

    def run(self):
        result = self.__run()
        print(result)


    def __run(self):
        return f'小猫{self.name}开心的奔跑着'



    def dump(self):
        result = self.__dump()
        print(result)


    def __dump(self):
        return f'小猫{self.name}开心的跳着'


cat = Cat(name = 'pipi')
cat.run()
cat.dump()
cat.__run()

私有函数不可以通过实例化对象调用的

print(cat.__dir__())

打印出所有的函数 

print(cat._Cat__run())

成功调用私有函数

私有属性

添加私有属性

class Cat(object):

    __cat_type = 'cat'


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

    def run(self):
        result = self.__run()
        print(result)


    def __run(self):
        return f'{self.__cat_type}小猫{self.name}{self.__sex}开心的奔跑着'



    def dump(self):
        result = self.__dump()
        print(result)


    def __dump(self):
        return f'{self.__cat_type}小猫{self.name}{self.__sex}开心的跳着'


cat = Cat(name = 'pipi', sex='boy')
cat.run()
cat.dump()
print(cat.__sex)
print(cat.__cat_type)
print(cat.__dir__())
print(cat._Cat__sex)
print(cat._Cat__cat_type)

尽量不要在实例化对象中调用私有化内容

Python中的封装

将不对外的私有属性或者方法通过可对外使用的函数而使用（类中定义私有的，只有类的内部可以使用，外部无法访问，可以保护隐私，明确区分内外

class Parent(object):
    def __hello(self, data):
        print('hello %s' % data)

    def helloworld(self):
        self.__hello('world')


if __name__ == '__main__':
    p = Parent()
    p.helloworld()

通过访问对外的函数hello可以实现对私有函数__hello的调用，这就是对私有函数的封装

相关文章