Python类、实例、方法、继承与模块引用

已于 2023-02-16 15:27:42 修改
阅读量718 收藏 8
点赞数
分类专栏： Python 学习 文章标签： python 开发语言
于 2023-02-16 09:44:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42372031/article/details/129054777
版权
本文介绍了Python中的类和实例的概念，包括属性、方法、初始化方法`__init__`，以及如何调用方法和修改属性。讨论了类的继承，多态，以及私有属性和保护属性的使用。还提到了模块引用和特殊方法，如`__str__`和`__repr__`。此外，文章还涵盖了类方法、实例方法和多态的概念，以及如何通过`super()`函数处理继承关系。
摘要由CSDN通过智能技术生成

Python类、实例、方法、继承与模块引用

原创：丶无殇  2023-02-16

Python类

包含：属性 attribute、方法 method

一个人的身高、体重和年龄，这些都是属性，而吃饭、说话和洗澡都是方法

类和实例对象是有区别的，类是抽象，是模板，而实例则是根据类创建的对象

比如类：动物，只是一个抽象，并没有动物的详细信息，而猫、狗等，则是具体的动物，是类的对象。

在class外部定义的可执行函数叫做function，类内部的函数叫做方法method

格式

类名开头大写，无括号，在Python3中Person、Person()、Person(object)，效果一样，但在Python2中需要写成Person(object)

class Person: # Person/Person()/Person(object)

换行缩进后定义属性和方法，属性为变量；方法的定义和函数一样（def开头）

class Person:
    # 属性
    name='zhangsan'
    age=29
    height=1.82

    # 方法
    def greet(self):# 打招呼方法
        print(f"你好，我叫{self.name}，我今年{self.age}岁")

# 创建实例
p1=Person()

# 调用方法
p1.greet()

输出：

你好，我叫zhangsan，我今年29岁

类的定义是一个具体实例（instance）的设计蓝图，在创建实例的时候，只需要调用类名()就可以了

p1.greet()是方法调用的示范，在实例后面加上.可以调用方法和属性，如p1.name

类的编写规范

类名使用：大骆驼命名法（UpperCamelCase）

实例和模块名：蛇形命名法（snake_case）

特殊参数self

特殊参数self会指向实例本身

self.name—>当前被创建实例的name属性

字符串格式化输出

方法一：%s/%d/%f

print时候用格式化符号%s/%d/%f占位，字符串后面紧接%()，括号中为对应的参数名称

class Person:
    # 属性
    name='zhangsan'
    age=29
    height=1.82

    # 方法
    def greet(self):# 打招呼方法
        print("你好，我叫%s，我今年%d岁,身高是%.2f米"%(self.name,self.age,self.height))

# 创建实例
p1=Person()

# 调用方法
p1.greet()

输出：

你好，我叫zhangsan，我今年29岁,身高是1.82米

方法二：f'{表达式:格式化}'[Python3.6新增]

在输出内容的前面加上f，内容中需要变量的地方使用{}即可

参数为浮点数时候可以使用:.2f来设置浮点数的格式

class Person:
    # 属性
    name='zhangsan'
    age=29
    height=1.823

    # 方法
    def greet(self):# 打招呼方法
        print(f"你好，我叫{self.name}，我今年{self.age}岁，身高是{self.height:.2f}米")

# 创建实例
p1=Person()

# 调用方法
p1.greet()

输出：

你好，我叫zhangsan，我今年29岁,身高是1.82米

方法三：.format语法

使用{}占位，字符串后接.format()，括号中为对应的参数名称

参数为浮点数时候使用{:.2f}设置浮点数的格式

class Person:
    # 属性
    name='zhangsan'
    age=29
    height=1.823

    # 方法
    def greet(self):# 打招呼方法
        print("你好，我叫{}，我今年{}岁，身高是{:.2f}米".format(self.name,self.age,self.height))

# 创建实例
p1=Person()

# 调用方法
p1.greet()

输出：

你好，我叫zhangsan，我今年29岁,身高是1.82米

初始化方法__init__()

__init__(self)方法

__init__ 是 Python 中的特殊方法（special method），它用于初始化对象，在实例别创建后最先调用的函数，第一参数永远是self

class Person:
    # 初始化方法
    def __init__(self):
        self.name = '张三'

    # 自定义方法
    def greet(self):
        print('你好，我是'+self.name)

p1=Person()
p1.greet()

输出：

你好，我是张三

__init__方法添加参数

在初始化方法中的参数，为必填参数，创建实例的时候不填写会报错

class Person:
    # 初始化方法
    def __init__(self,init_name):
        self.name = init_name

    # 自定义方法
    def greet(self):
        print('你好，我是'+self.name)

p1=Person('李四')
p1.greet()

输出：

你好，我是李四

__init__方法添加任意参数

目前的方法只能传递固定个数的参数，如果想要传递任意参数，如：自定义求平均数的average()方法，使用时候可以是average(22,33,45)，也可以是average(2,6,8,5,6,9,10)

详情见：可变参数

属性修改

修改类属性

创建好Person类后，设置类属性count，每创建一个实例count+1

class Person:
    # 类属性
    count=0
    
    # 初始化方法
    def __init__(self):
        Person.count+=1

# 实例化对象
p1=Person()
p2=Person()
p3=Person()
print(Person.count)

输出：

3

修改实例属性

在创建好实例p1后，修改它的属性

# 修改实例属性
p1.age=21
print(p1.age)

# 删除实例属性
del Person.height
print(Person.height)

# 删除实例
del p1
print(p1)

删除只能通过删除类属性实现，不能直接删除实例属性

删除方法除了del还可以使用delattr()函数

delattr(ClassName,Attribute) 相等于 del ClassName.Attribute

输出：

# 删除属性，报错内容
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'height'
# 表示已经删除了'Person.height'属性

# 删除实例，报错内容
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'p1' is not defined
#表示已经删除了'p1'实例对象

类属性和实例属性的优先级

类属性优先级高于实例属性，无法通过实例修改类属性，修改的只是对应的实例属性

class Animal:
    localtion = 'Asia'
    def __init__(self,localtion):
        self.localtion = localtion

dog = Animal('GuangDong')
cat = Animal('Africa')
print(dog.localtion)		# ==> GuangDong
print(cat.localtion)		# ==> Africa

cat.localtion='ChongQing'
print(cat.localtion)		# ==> ChongQing
print(Animal.localtion)		# ==> Asia

输出：

GuangDong
Africa
ChongQing
Asia

保护属性与私有属性

保护属性：_xxx

单下划线开头的属性，只有类实例和子类实例可以访问，不能通过from module import *导入，保护属性，不建议调用访问，不会被代码提示工具显示，但是可以直接访问

私有属性：__xxx

双下划线开头的属性/方法，只有类对象自己能访问，子类对象无法访问

#-*- coding:utf-8 -*-

class A(object):
    def __init__(self):# 系统定义方法
        self.string='A string'			# 公有属性
        self._string='A _string'		# 保护属性
        self.__string='A __string'		# 私有属性

    def fun(self):
        return self.string + ' fun-A'

    def _fun(self):
        return self._string+'  _fun-A'

    def __fun(self):# 私有方法
        return self.__string+' __fun-A'

    def for__fun(self):# 内部调用私有方法
        return self.__fun()

class B(A):# A的子类
    def __init__(self):# 系统定义方法
        self.string = 'B string'

a=A()
print(a.string)
print(a._string)
# print(a.__string)# 不可访问

print(a.fun())
print(a._fun())
# print(a.__fun())# 不可访问
print(a.for__fun())

b=B()
print(b.fun())
print(b.fun().__len__())# 系统定义函数

输出：

A string
A _string
A string fun-A
A _string  _fun-A
A __string __fun-A
B string fun-A
14

访问操作私有属性

通过实例方法调用私有属性，可以实现访问和修改等操作

在外部调用实例方法时，是不需要显式传递self参数的

class Animal:
    # 初始化方法
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    # 获取信息
    def get_info(self):
        return 'name={},age={}'.format(self.__name,self.__age)

    # 修改信息
    def set_info(self,name,age):
        self.__name=name
        self.__age=age
        
# 实例化对象
dog=Animal('wc',2)
print(dog.get_info())

# 调用实例方法修改私有属性
dog.set_info('nidie',3)
print(dog.get_info())

输出：

name=wc,age=2
name=nidie,age=3

强制访问私有属性

通过实例强制访问私有属性：实例名._类名__属性名

class Animal:
    # 初始化方法
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
        
# 实例化对象
dog=Animal('wangwang',2)

# 强制访问私有属性
print(dog._Animal__name)
print(dog._Animal__age)

输出：

wangwang
2

类方法

类方法和实例方法的区别

操作实例对象的属性可以使用实例方法，如果需要操作类的属性，就需要使用类方法

类方法需要使用装饰器@classmethod

与实例方法不同的是：

  1. 类方法需要使用@classmethod来标记为类方法，否则定义的还是实例方法
  2. 类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.__localtion 实际上相当于Animal.__localtion
  3. 类方法无法获得任何实例属性，只能获得类的引用

实例方法

在类Animal中，创建实例dog,cat，可以通过该实例调用的方法，如dog.get_info等

# -*- coding=utf-8 -*-
class Animal:
    # 私有属性
    __count=0
    
    # 初始化方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
        Animal.__count+=1
    
    # 实例方法
    def get_info(self):
        return '我是{}，今年{}岁了。总计数：{}个'.format(self.name,self.age,self.__count)
    
    # 类方法
    @classmethod
    def get_cnt(cls):
        return cls.__count
        
dog=Animal('汪汪',2)
cat=Animal('喵喵',3)
print(dog.get_info())
print(cat.get_info())

输出：

我是汪汪，今年2岁了。总计数：2个
我是喵喵，今年3岁了。总计数：2个

类方法

类方法不能直接操作实例属性，必须通过类实例才能操作。

类方法推荐使用类名直接调用，当然也可以使用实例对象调用（不推荐）。

如Animal.get_cnt可以调用，使用dog.get_cnt也可以调用，但是不推荐这样使用

dog=Animal('汪汪',2)
cat=Animal('喵喵',3)
print(dog.get_cnt())
print(Animal.get_cnt())

输出：

2
2

继承类

当已经创建了一个类Person后，还可以再细分为其他类，这些类和Person类相似，比如添加几个属性，修改几个方法

此时，不需要重新新建一个类，可以从原来的类中派生一个新的类，原来的称为父类或者基类/超类，派生出的称为子类，子类继承了父类的所有数据和方法

# 父类
class Animal:
    def __init__(self,name):
        self.name=name
    
    def greet(self):
        print(f'我是{self.name}')

# 子类继承父类
class Dog(Animal):
    def greet(self):
        print(f'汪汪，我是{self.name}')

Dog 类是从 Animal 类继承而来的，Dog 类自动获得了 Animal 类的所有数据和方法，而且还可以对从父类继承来的方法进行修改，调用的方式是一样的

animal = Animal('animal')
animal.greet()
dog = Dog('dog')
dog.greet()

输出：

我是animal
汪汪，我是dog

子类添加方法

给子类Dog添加一个run的方法

# 子类
class Dog(Animal):
    def greet(self):
        return (f'汪汪，我是{self.name}')

    # 跑的方法
    def run(self):
    	return ('撒丫子')

dog=Dog('dog')
print(dog.greet()+'，我在'+dog.run())

输出：

汪汪，我是dog，我在撒丫子

super()函数

super() 函数是用于调用父类的一个方法

是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到MRO【方法解析顺序(Method Resolution Order)】、重复调用（钻石继承）等种种问题

语法[Python2]
super(class[,self]).method(param1...)
super(class[,self]).__init__(param1...)

此处的class为当前的子类名，如class Person中，子类class Student(Person)，super语句为super(Student,self).__init__(name,age)...

语法[Python3]
super().method(param1...)
super().__init__(param1...)
示例

继承父类的属性和方法，使用spuer方法，新增的属性单独添加

# 父类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        print(f'我是{self.name}，我{self.age}了')

# 子类
class Teacher(Person):
    def __init__(self,name,age,score):
        # 继承父类的属性，使用super继承name,age
        super(Teacher,self).__init__(name,age) # super(Teacher,self).__init__(name,age)
        # 新增的属性单独添加
        self.score=score
    
    def greet(self):
        # 继承父类的方法，输出内容为父类的print内容
        super(Teacher,self).greet() # super(Teacher,self).greet()
        print(f'我是{self.name}，我{self.age}了，综合评分{self.score}')

t=Teacher('张三',29,87.5)
t.greet()

输出：

我是张三，我29了
我是张三，我29了，综合评分87.5

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent(object):
    def __init__(self):
        self.parent = '我是父类'
        print ('Parent')

    def info(self,message):
        print ("%s 来自父类" % message)

class Child(Parent):
    def __init__(self):
        # super(Child,self)首先找到Child的父类Parent，然后把类Child的对象转换为类Parent的对象
        super(Child,self).__init__()
        print ('子类')

    def info(self,message):
        super(Child, self).info(message)
        print ('子类的 info 方法')
        print (self.parent)

# 主函数
if __name__ == '__main__':
    child = Child()
    child.info('Hello World')

输出：

Parent
子类
Hello World 来自父类
子类的 info 方法
我是父类

isinstance()函数类型判断

通过isinstance()函数可以判断一个变量的类型

语法

isinstance(type,class)# 判断type是不是class类型

实例

定义类

现有父类Person(name,gender)，子类Student(name,gender,score)、Teacher(name,gender,course)

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

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
实例化对象
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
判断父类

判断p,s,t这几个变量的时候可以使用isinstance()判断类型

isinstance(p,Person)	# ==> True
isinstance(p,Student)	# ==> False
isinstance(p,Teacher)	# ==> False

这说明在继承链上，一个父类的实例不能是子类类型，因为子类比父类多了一些属性和方法

判断子类
isinstance(s,Person)	# ==> True
isinstance(s,Student)	# ==> True
isinstance(s,Teacher)	# ==> False

因为Student继承自Person，所以s也是Person类型

多态

它是指对不同类型的参数进行相同的操作，根据对象类型不同做出不同的行为，继承拿到父类的数据和方法，子类可以重新父类的方法，可以自己添加新的方法，有了继承才有多态，实现为不同数据提供一个统一的接口

实例

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def who(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def who(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def who(self):
        return 'I am a Teacher, my name is %s' % self.name
    
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

print(p.who())
print(s.who())
print(t.who())

输出：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

这种行为别成为多态，一般调用的时候先从子类自身查找方法，如果自身没有，再按照继承链向上找

多重继承

多种继承主要在出现组合情况的时候使用，如果没有多重继承，那么使用组合情况可能需要更多的子类

例如python的网络服务器有：TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer

服务器运行模式有：多线程ThreadingMixin和多进程ForkingMixin

要创建多线程的TCPServer

class MyServer(TCPServer,ThreadingMixin)

要创建多进程的UPDServer

class MyServer(UPDServer,ForkingMixin)

实例

已知类Student、Teacher继承Person类，技能类BasketballMixin、FootballMixin继承SkillMixin类，请通过多重继承，分别定义“会打篮球的学生”和“会踢足球的老师”

# -*- coding=utf-8 -*-
# 人员
class Person(object):
    def __init__(self):
        print("Person")
    
class Student(Person):
    def __init__(self):
        super(Student,self).__init__()
        print("Student")

class Teacher(Person):
    def __init__(self):
        super(Teacher,self).__init__()
        print("Teacher")

# 技能
class SkillMixin(object):
    def __init__(self):
        print("SkillMixin")

class BasketballMixin(SkillMixin):
    def __init__(self):
        super(BasketballMixin,self).__init__()
        print("BasketballMixin")

class FootballMixin(SkillMixin):
    def __init__(self):
        super(FootballMixin,self).__init__()
        print("FootballMixin")

# 会打篮球的学生
class BasketballStudent(BasketballMixin,Student):
    def __init__(self):
        super(BasketballStudent,self).__init__()
        print('会打篮球的学生')

# 会踢足球的老师
class FootballTeacher(FootballMixin,Teacher):
    def __init__(self):
        super(FootballTeacher,self).__init__()
        print('会踢足球的老师')

s=BasketballStudent()
t=FootballTeacher()

输出：

SkillMixin
BasketballMixin
会打篮球的学生
SkillMixin
FootballMixin
会踢足球的老师

获取对象信息

前文中，可以通过isinstance()方法来判断是否是某个类型，现在需要获取更多的信息

获取类型type()

通过type()方法可以获取变量的类型

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

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

p = Person('Alice', 'Female')
s = Student('Bob', 'Male', 100)
type(p) # ==> <class '__main__.Person'>
type(s) # ==> <class '__main__.Student'>

输出：

<class '__main__.Person'>
<class '__main__.Student'>

获取属性dir()

通过dir()方法可以获取变量的所有属性

dir(p)

输出：

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'gender', 'name']

dir()返回的属性是字符串列表，其中__xxx__为特殊属性和方法，可以直接访问

如果其中存在私有属性，如：初始化属性中的gender改为self.__gender=gender，则输出：

['_Person__gender', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']

获取设置对象属性

dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr()函数

如上例中的：

p = Person('Alice', 'Female')
s = Student('Bob', 'Male', 100)

获取p的name属性

getattr(p,'name')				# ==> 'Alice'

如果有私有属性，需要强制访问，方式为_类名__属性名（详情见：强制访问私有属性）

getattr(p,'_Person__gender')	# ==> 'Female'

如果获取的属性不存在，则会报错

getattr(p,'age')	# ==> AttributeError: 'Person' object has no attribute 'age'

如果获取的属性不存在，指定默认返回值

getattr(p,'age',20)				# ==> 'Female'

设置属性值

setattr(p,'name','Mike')		# 'Alice' ==> 'Mike'

可变参数

可以用setattr()方法来设置属性值，可变参数，可以用来添加任意关键字参数，以键值对的方式设置值

class Person(object):
    def __init__(self, name, gender, **agrv):
        self.name = name
        self.gender = gender
        for k,v in agrv.items():
            setattr(self,k,v)
            
p = Person('Bob', 'Male', age=18, course='Python')
print(p.age)
print(p.course)

输出：

18
Python

如果不使用setattr()方式来添加参数，可以使用for循环遍历，例如设计一个求平均数的函数

def average(*agrv):
    sum = 0
    if len(agrv) == 0:
        print(sum)
    for i in agrv:
        sum += i
    avg = sum / len(agrv)
    print(avg)

average(1,5,6,24)

输出：

9.0

类的特殊方法

__str__()方法

通常变量可以通过str()函数转换为字符串类型输出，但是自定义的类无法转换成字符串

class Person:
    # 初始化方法
    def __init__(self):
        self.name = '张三'

    # 自定义方法
    def greet(self):
        print('你好，我是'+self.name)

p1=Person()
p1.greet()
str(p1)

输出：

你好，我是张三
'<__main__.Person object at 0x00000257907AD760>'

输出发现str()返回的是这个实例的地址，这是因为使用的是对象的内建方法__str__返回的

如果自定义的类也实现__str__()方法，便可以转换为字符串输出

class Person:
    # 初始化方法
    def __init__(self):
        self.name = '张三'

    # 自定义方法
    def greet(self):
        print('你好，我是'+self.name)
        
    def __str__(self):
        return '你好，我是'+self.name	# return str(self.name)

p1=Person()
p1.greet()
str(p1)

输出：

你好，我是张三
'你好，我是张三'

此时发现，如果只输入p1，显示的仍然是地址

<__main__.Person object at 0x00000257907A4E50>

__repr__()方法

上述情况是因为Python定义了__str__()和__repr__()两种方法，__str__()显示给用户，而__repr__()显示给开发人员，当使用str()时候，实际调用的是__str__()方法，而直接输入变量，调用的是__repr__()方法，所以需要再实现__repr__()方法

class Person:
    # 初始化方法
    def __init__(self):
        self.name = '张三'

    # 自定义方法
    def greet(self):
        print('你好，我是'+self.name)
        
    def __str__(self):
        return '你好，我是'+self.name
    
    def __repr__(self):
        return '你好，我是'+self.name

p1=Person()
p1.greet()
str(p1)

输出：

你好，我是张三
'你好，我是张三'
你好，我是张三

__len__()方法

对于列表List和元组Tuple，都可以使用内建方法len()来获取元素个数，如果需要达到这个效果，就需要实现__len__()方法

例如有个班级Class类，初始化把学生列表传进去，通过len()函数可以返回学生个数

class Class:
    def __init__(self,students):
        self.students=students
        
    def __len__(self):
        return len(self.students)

stu=['Mike','James','Alice']
cls=Class(stu)
print(f'此班级有 {len(cls)} 名学生')

输出：

此班级有 3 名学生
实例

实现一个斐波那契数列：0,1,1,2,3,5,8…，创建一个Fib类，Fib(10)表示数列前十个元素，print(Fib(10))可以打印输出，len(Fib(10))可以返回数列个数10

class Fib(object):
    def __init__(self,num):
        self.res=[]
        self.num=num
        a,b=0,1
        for i in range(num):
            self.res.append(a)
            a,b=b,a+b
    def __str__(self):
        return str(self.res)
        
    def __len__(self):
        return len(self.res)
        
f=Fib(10)
print(f)
print(str(f))
print(len(f))

输出：

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
10

__slots__()方法

用来限制可添加的属性，如此时有一个Student类，包含name,gender,score这几个属性

class Student:
    def __init__(self,name,gender,score):
        self.name = name
        self.gender = gender
        self.score = score

类中的参数都可以动态的添加，如此时再添加一个age属性

s=Student('Mike','Male',87)
s.age=25	# 动态添加属性age

如果不做限制，会有很多属性，不便于后期管理，所以需要使用__slots__()方法来限制添加的属性

class Student:
    __slots__ = ('name', 'gender', 'score','total')
    def __init__(self,name,gender,score):
        self.name = name
        self.gender = gender
        self.score = score

此时执行动态添加属性age的语句，会报错，如果添加total则不会报错

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

假设Person类通过__slots__定义了name和gender，请在派生类Student中通过__slots__继续添加score的定义，使Student类可以实现name、gender和score3个属性。

class Person(object):
    __slots__=['name','gender']
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender

class Student(Person):
    __slots__=['score']
    def __init__(self,name,gender,score):
        super(Student,self).__init__(name,gender)
        self.score=score

s=Student('Alice','Female',96)
s.name='Bob'
s.score=87
print(s.score)

__call__()方法

Python中，函数是一个对象，可以将一个函数赋值给一个变量，且不改变函数的功能

>>> f=abs
>>> f
<built-in function abs>
>>> f.__name__
'abs'
>>> f(-123)
123

此时，f被称为可调用的对象，其实所有的函数都是可调用对象

如果把一个类实例也变成一个可调用对象(函数)，需要实现一个__call__()方法

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    def __call__(self,friend):
        print('My name is {}.'.format(self.name))
        print('My friend is {}.'.format(friend))
      
p=Person('Bob',25)
p('Mike')		# ==> 用函数的方式调用Person类的实例p

输出：

My name is Bob.
My friend is Mike.
实例

对前面的斐波那契数列类Fib，加入__call__方法

class Fib(object):
    def __init__(self):
        self.res=[]
        
    def __call__(self,num):
        self.num=num
        a,b=0,1
        for i in range(num):
            self.res.append(a)
            a,b=b,a+b
        return self.res
f=Fib()
print(f(10))	# 可以像函数一样调用

输出：

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

模块和包

为了便于管理自定义的内容，可以将模块根据特定规则划分到包中

导入格式：from 包 import 模块

包必须包含__init__.py文件，模块文件没有__init__.py文件

自定义模块

定义一个叫tools的模块，模块名：tools.py

# tools.py
def say_hello(name):
    print('你好啊{}'.format(name))

def say_goodbye(name):
    print('拜拜{}'.format(name))

格式

import 模块名1 [as 别名1], 模块名2 [as 别名2]，…

from 模块名 import 成员名1 [as 别名1]，成员名2 [as 别名2]，…

导入模块

导入官方模块不需要考虑路径问题，导入自定义模块需要考虑路径（详情见：导入模块的路径)

导入整个模块

import MODULE

导入模块的部分属性或函数

from PACKAGE import MODULE

导入模块中的所有内容

from PACKAGE import *

为了防止导入的函数与本文件的函数冲突，有两种方法解决：

  1. 直接导入模块，不指定具体内容
  2. 使用from PACKAGE import MODULE as NAME把导入的内容进行重命名

如使用两种方法导入math模块的sin(),cos()函数

# 从模块导入所有类
from math import sin,cos,pi
sin(pi/2)
cos(pi/3)

# 导入整个模块
import math
math.sin(pi/2)
math.cos(pi/3)

# 使用别名
from math import sin as s,pi
s(pi/2)

导入模块的路径

使用sys模块中的path变量，可以得到一个路径列表，导入模块的时候会搜索这个路径列表，如果想要添加路径，可以给sys.path赋值

import sys					# 或from sys import path
sys.path.append('../')		#   path.append('../')
丶无殇
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python：类基础
不怕猫的耗子A
06-17 11万+
1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元，一个对象包含数据和操作数据的函数2、在python中，所有数据类型都被视为对象，也可以自定义对象。自定义对象数据类型就是面向对象中类的概念1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例2、方法：类中定义的函数3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性4、数
python类实例化_python类实例化
weixin_39975744的博客
11-24 1066
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！在前面的代码中总是看到 __init__ 方法，__init__ 方法是类的一个特殊方法，它有一个名字叫初始化函数，它在类被实例化时立即运行，它可以对任何你需要操作的目标对象进行初始化操作。 就像前面的示例中所使用的，你不必显式调用该函数，在类的实例化过程中 python 会自动调用...
第7.14节 Python类中的实例方法详析
老猿Python
06-16 5416
第7.14节 Python类中的实例方法详析 一、 实例方法的定义 在本章前面章节已经介绍了类的实例方法，实例方法的定义有三种方式： 1. 类体中定义实例方法 第一种方式很简单，就是在类体中定义，所有在类中定义的方法默认是实例方法。定义实例方法与定义函数基本相同，只是Python要求实例方法的第一个形参必须为self，也就是实例对象本身，因此实例方法至少应该有一个self参数。关于s...
深入理解Python类中的各种方法，非常实用！
最新发布
Python_Alex的博客
06-19 1215
实例方法：绑定到实例，通过self访问实例属性和方法。类方法：绑定到类，通过cls访问和修改类属性。静态方法：不绑定到实例或类，通常用于逻辑上属于类但不依赖实例或类属性的方法。特殊方法：以双下划线包围，由 Python 在特定情况下自动调用。属性方法：将方法转换为属性，提供定制的 getter、setter 和 deleter。__new__方法：用于创建实例，在__init__之前调用。__call__方法：使实例可以像函数一样被调用。__del__方法：在对象被垃圾回收时调用。和方法。
深入理解Python中的类方法、类实例方法和静态方法
qq_41586251的博客
12-18 3216
类方法是定义在类中的方法，通过装饰器​​来标识。它的第一个参数是​​cls​​（表示类本身），而不是实例对象。类方法可以访问类的属性，并且可以在没有实例的情况下被调用。# 在类方法中可以访问类的属性在类方法中，参数 ​​cls​​​ 是一个约定的命名，它指向类本身，允许我们在方法中操作类的属性或调用其他类方法。通过 ​​ 装饰器，Python知道这是一个类方法。类实例方法是最常用的方法类型，它操作特定类的实例。在定义时不需要额外的装饰器，第一个参数通常是​​self​​，表示实例本身，通过实例对象调用。
Python:类的继承，调用父类的属性和方法基础详解
热门推荐
yilulvxing的博客
12-30 9万+
备注：这里省略了关于继承含义的解释，直接上代码了，更直观点 子类：Son类 父类：Father类 以下案例均表示Son类继承父类的一些属性和初始化参数构造等。 5个模块： （1）：直接调用父类属性方法； （2）：重写父类属性方法； （3）：强制调用父类私有属性方法； （4）：调用父类的__init__方法 （5）：继承父类初始化过程中的参数 （1）调用父类属性方法 代码1.1：...
Python中类-继承和方法的重写
Python编程学习的博客
11-01 999
Python中类-继承和方法的重写
python-类与模块
suwuzs的博客
11-12 1804
文章目录类的概念如何创建一个类方法和特殊方法静态数据、静态方法和装饰器继承和多态继承多态模块调用和多文件应用程序 类的概念 python完全支持过程化编程和面向对象编程。面对对象编程是一种设计思想，意味着我们把对象作为程序的基本单元，而每个对象包含了自己的属性和方法。面向对象编程主要有以下特点： 封装（Encapsulation）：对外部世界隐藏对象的工作细节。 继承（Inheritance）：继承使子类具有父类的各种属性和方法，而不需要编写相同的代码。 多态（Polymorphism）：为不同的数据类型
Python类的实例化，封装，继承，私有变量和私有方法
yilulvxing的博客
01-01 8271
1：定义一个类 首先在python中，定义一个类，作为例子，然后引出相关知识点 class Example(object): def __init__(self,data1,data2): self.__data1=data1 self.data2=data2 def __func1(self): pri...
python类的实例方法必须创建对象前还是后可以调用_第7.14节 Python类中的实例方法详析...
weixin_39603622的博客
12-19 5868
第7.14节 Python类中的实例方法详析一、 实例方法的定义在本章前面章节已经介绍了类的实例方法，实例方法的定义有三种方式：1. 类体中定义实例方法第一种方式很简单，就是在类体中定义，所有在类中定义的方法默认是实例方法。定义实例方法与定义函数基本相同，只是Python要求实例方法的第一个形参必须为self，也就是实例对象本身，因此实例方法至少应该有一个self参数。关于self的说...
python模块实例化_在Python中动态导入模块并实例化类
weixin_36289211的博客
02-04 791
我的问题与this one相似，不过我想更进一步。我正在分析一个配置文件，该文件按名称调用多个操作(带参数)。例如："on_click": "action1", "args": {"rate": 1.5}action是python类，继承自基Action类，可以采用命名参数。它们存储在项目的“actions”子目录中，前缀为a_。我只需添加新的文件就可以了。项目结构如下：^{pr2}$所有的act...
python 类的继承 实例方法.静态方法.类方法的代码解析
09-18
实例方法是与类的实例关联的方法，通常第一个参数是 `self`，它引用调用该方法的对象。例如，在 `Denglu` 类中，`register`, `login`, 和 `modify` 方法都是实例方法。这些方法都需要通过类的实例（如 `temp`）来...
python类继承与子类实例初始化用法分析
09-22
总的来说，Python的类继承和子类实例初始化提供了强大的工具，使我们能够构建灵活且模块化的代码。正确理解和使用这些机制可以帮助我们编写更加高效、易于理解和维护的Python程序。通过实践和理解这些原则，开发者...
python继承和抽象类的实现方法
12-24
虽然在这个例子中没有明确地使用 `abc` 模块，但 `Employee` 类的行为表现得像一个抽象类，因为它包含了一个未实现的方法 `earnings`，并且在尝试直接实例化 `Employee` 类时会抛出 `NotImplementedError`。...
Python 类的继承实例详解
09-21
Python 类的继承是面向对象编程中的一个核心概念，它允许我们创建新的类（子类）并从现有的类（父类）中继承属性和方法。这种机制使得代码复用变得更为简单，同时也使得程序设计更加模块化。下面我们将深入探讨...
Python面向对象类的继承实例详解
09-20
7. **接口继承与实现继承**：Python不直接支持接口，但通过定义抽象基类（ABCs）和使用`abc`模块，可以模拟接口继承。实现继承则涉及到子类直接继承父类的实现，如上述例子所示。 8. **继承的深度**：Python支持...
C语言判断完数（完整版）
丶无殇的博客
12-15 8万+
C语言判断完数（完整版） 原创：丶无殇              2018-12-15 简介： 大二了，作为大一新生的学长的我，总会有小迷妹小迷弟…（咳咳…小学妹小学弟）来问我问题，其中一类题目就是关于如何判断完数的。那么什么叫完数？  完数定义： 完数就是：它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。如果一个数恰好等于它的因子之和，则称该数为“完全数”。第...
解决MySQL8.0报错Client does not support authentication protocol requested by server...问题
丶无殇的博客
10-07 1万+
客户端不支持服务器请求的身份验证协议；考虑升级MySQL客户端；使用node.js连接数据库MySQL 8时候，报错。最新的MySQL模块并未完全支持MySQL 8.0的。加密方式，而MySQL 8.0中默认仍然是。这里的“123456”是你自己的密码。数据库连接和关闭都成功，连接问题解决。加密方式，因此用户认证不通过了。
自学SQL网习题题解：0-12（带内容解析！）
丶无殇的博客
07-17 1万+
1.【初体验】这是第一题,请你先将左侧的输入框里的内容清空，然后请输入下面的SQL，您将看到所有电影标题。解释select（要显示的列名1,列名2,……）from（要查找的表名）【关键字前后可以换行，select后可以是列名、计算式、函数等】2.【初体验】请输入如下SQL你将看到4条电影（切记先清空数据框且出错要耐心比对）解释select（要显示的列名1,列名2,……）from（要查找的表名）where（筛选的条件，如id小于5）解释计算movies表中的记录数量解释。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值