python基础篇 —— 类

Posted wakeyo_J

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python基础篇 —— 类相关的知识，希望对你有一定的参考价值。

python基础篇 —— 类

  hello！我是wakeyo_J，每天一个konwledge point，一起学python，让技术无限发散。

类

1. 面向过程的编程

面向过程：是一种以过程为中心的编程方法。
面向过程编程思路的核心是一个个实现相关功能的过程，将整个过程拆分为数个小的过程，逐一实现每个过程的编程，最后组装为一个完整的过程。
如：每天钓鱼记录统计代码的实现过程。

当利用面向过程方法处理的问题越来越复杂时，面向过程的编程方法就会暴露出它的不足之处，具体如下：

  • 数据变量代码重复现象会再次出现
  • 当自定义函数变多，将产生新的管理和使用混乱
  • 变量和函数的相关联性不强

2. 面向对象的编程

面向对象：是一种对现实世界理解和抽象的方法，把现实世界里的任何事物都看作一个相对独立的对象。将现实世界的事物进行抽象，就出现一种新的可以高效利用的数据类型——类。

类（class）：把具有相同特性（数据）和行为（函数）的对象抽象为类。类的特性通过数据来体现，类的行为通过函数来操作，现实世界对象都可以抽象为数据和函数相结合的一种特殊结构的新数据类型。

如：抽象盒子
盒子是个长方体，由长、宽、高构成，盒子由不同的颜色、材质、类型，这些长、宽、高、材质、类型构成了一个盒子类的特性。可以统计盒子存放物品的数量、重量、金额，也可以计算有多少物品可以放到盒子里，计算盒子的体积、表面积等。这些统计、计算就是针对盒子的各种行为。

抽象成类过程的步骤：

  • 归类。把所有的大大小小的立方体盒子都归为一类
  • 提取事物特征。把盒子的长、宽、高、颜色、材质、类型作为基本的特性，进行了提炼（事物的特性是静态的，相对固定不变的）
  • 确定事物相关的操作行为，如统计、计算、查找、修改等操作动作。

3. 编写一个类

#语法
class 类名([父类]):
  pass

  1. 案例：一个求体积函数的Box1类

    结果：
  2. 类的相关知识分析
  • class关键字
    所有类定义必须以class开始
  • 类名
    python语言建议性约定类名首字母需要大写，如Box（实质上小写开头也不影响代码执行效果，只是为了代码更加容易阅读，做了同一约定）
  • 类开始第一行格式，class关键字空一格后跟类名，在跟小括号加冒号。
class 类名():

  • 类文档说明
    用三引号(’’’)成对引用说明内容，使用方法和函数的文档说明一样。

  • 类函数
    类函数在类或实例里又叫方法。这里的方法必须依赖于类或实例存在。
    说明
    （1）在实际独立引用对象名称时，为了区分函数与方法，将带小括号的统一认为是方法，不带小括号的为函数。如volume叫函数，volume()叫方法。
    （2）__init__()叫做构造方法，这种特殊方法不对实例显示，其他自定义方法都可被实例调用。

  • 保留函数__init__和self关键字
    保留函数就是不能用其他函数代替该函数的作用，包括函数名的的写法，严格按照__init__格式输入
    （1）所有类需要实例化，必须在类里声明__init__函数，不然类的实例无法使用。self关键字，在实例使用时，用于传输实例对象，所有的实例可以调用的属性（Property），必须在__init__定义并初始化，然后通过self传递。
    最简约的使用格式

def __init__(self)

  传递多个参数

def __init__(self,length,width,height)

  （2）__init__初始化实例相关参数作用，类在实例化的同时，会自动调用__init__函数，可以通过它来初始化属性值。

4. 类的定义

  • 类和对象都是对现实生活中事物的抽象
  • 包含两部分：
    。1.数据（属性）
    。2.操作（方法）
  • 调用方法 对象.方法名（）
  • 方法调用和函数调用的区别：
    1.如果是函数调用，调用时有几个形参，就会传递几个实参。
    2.如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参
# 在python中，你想使用一个东西，你必须先创建一个这样的对象
# 自定义类  如：图纸  通过图纸创造出来的汽车  汽车就是通过图纸创建出来的实例对象
# 定义类的语法
# class 类名([父类]):
#     pass

class MyClass():   #定义类，给它命名为MyClass  类相当于图纸  类对象 只是用于存储的功能
    pass

mc = MyClass()   #创建实例对象（类的实例化）实例对象  实现效果的功能

#类对象 （存储属性、功能）    实例对象（实现效果的功能）
mc1 = MyClass()
print(id(mc),id(mc1))

#类可以创建多个实例，每个实例各不相同，这一些实例我们称呼为一类实例

#isinstance()  用来检测这个实例是否是这个类创建出来的
print(isinstance(mc,MyClass))
  • 在类代码块中，我们可以定义变量和函数
  • 变量会成为该类实例的公共属性，所有的该实例都可以通过 对象.属性名的形式访问
  • 函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名的形式访问
    类的使用
class Person():   #定义一个类
    name = '邓紫棋'   #属性

    def speak(self):   #方法 类中的函数不叫做函数了，叫做方法
        print('你好')

p1 = Person()    #类的实例化
print(p1.name)   #实列.属性   就可以获取到这个属性值
p1.speak()       #实例.方法

p1.name = '刘亦菲'   #更改类的属性的值
print(p1.name)

p2 = Person()
print(p2.name)

在类的代码中，我们可以定义变量和函数

  1. 定义在类中的变量会成为该类实例的公共属性，所有的实例都可以通过 “对象.属性名” 的形式来访问
  2. 定义在类中的函数会成为该类实例的公共方法，所有的实例都可以通过 “对象.方法名（）” 的形式来访问

5. 参数self

5.1 属性和方法

  • 类中定义的属性和方法都是公共的，任何该类实例都可以访问
    属性和方法的查找流程
  • 当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
  • 类对象和实例对象中都可以保存属性(方法)
    • 如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中
    • 如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中
    • 一般情况下，属性保存到实例对象中 而方法需要保存到类对象中

5.2 self

  • self在定义时需要定义，但是在调用时会自动传入。
  • self的名字并不是规定死的，但是最好还是按照约定是用self
  • self总是指调用时的类的实例
class Presion():
    #name = '刘亦菲'

    #哪个对象调用类的speak方法，那个s就是这个对象，类里通常使用self
    def speak(s):
        print('你好，我是%s'%s.name)

    def run(self):   #self就等于任何调用这个方法的对象本身
        pass

p1 = Presion()
p1.name = '周慧敏'
p1.speak()

p2 = Presion()
p2.name = '刘亦菲'
p2.speak()

6. 初始化方法

  • 在类中形如__xxx__()这种形式的方法，被称之为模塑方法（特殊方法 或 初始化方法），这种初始化方法不需要我们调用，它会在特定的时候自动调用。
class MyClass():    #定义一个类
    # name = '刘亦菲'

    def speak(self):   #定义方法
        print('大家好，我是%s'%self.name)

p1 = MyClass()   #类的实例化
p1.name = '刘亦菲'
p1.speak()     #在没有定义类的公共属性的情况下会报错，
# 两种的定义公共属性的方法:
# 1.通过 对象.属性    如：p1.name = '刘亦菲'
# 2.在类里面定义      如：类里面的 name = '刘亦菲'


#'使用初始化方法解决的问题：'
#问题： 1.手动添加容易忘记，查看代码需要那些参数比较麻烦
#      2.没有提示，可以创建成功实例，会导致后面的代码运行出错

class Preson():       #定义一个类

    #初始化方法
    def __init__(self,name,age):       #实例化创建的时候，init方法就会报错
        self.name = name
        self.age = age

    def speak(self):
        print('大家好，我是{},永远{}'.format(self.name,self.age))

name = input('请输入姓名:')
age = input('请输入年龄：')
p1 = Preson(name,age)       #类的实例化
p1.speak()

7. 类的封装

  • 出现封装的原因:是为了数据的安全，形成了一个默认的规则。告诉你的协同开发者这个属性很重要，不要随意修改
class Car():                              #定义一个类
    #初始化方法
    def __init__(self,name,color):  
        self.hidden_name = name
        self.color = color

    def run(self):
        print('汽车开始跑起来了')

    def dida(self):
        print('汽车鸣笛')


car = Car('兰博基尼','红色')    #类的实例化
car.name = '中华田园犬'   
car.run()    #调用方法
car.dida()

封装是面向对象的三大特性之一

  • 封装是指将对象内部的一些属性和方法进行隐藏，不被别人轻易的访问或修改。
# 封装：私有属性
class Car():
    def __init__(self,name,color):
        self._name = name     #私有属性,一般使用这个私有属性，属于商议协定
        self.color = color

    def run(self):
        print('汽车开始跑起来了')

    def dida(self):
        print('汽车鸣笛')


car = Car('法拉利','红色')
car._name = '中华田园犬'
car.run()
car.dida()
  • 类也提供了getter()和setter()方法实现外部可以访问到封装类的属性。
    • getter() 获取对象中指定的属性
    • setter() 用来设置对象指定的属性
class Car():
    def __init__(self,name,color):
        self._name = name     #私有属性,一般使用这个私有属性，属于商议协定
        self.color = color

    #getter方法:提供访问这个属性的方法
    def get_name(self):
        return self._name

    #setter方法：提供修改属性的方法
    def set_name(self,name):
        self._name = name

    def run(self):
        print('汽车开始跑起来了')

    def dida(self):
        print('汽车鸣笛')


car = Car('兰博基尼','红色')
# car._name = '中华田园犬'
car.run()
car.dida()
# print(car._Car__name)
print(car.get_name())
car.set_name('玛莎拉蒂')
print(car.get_name())

'''
- 使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
• 1. 隐藏属性名，使调用者无法随意的修改对象中的属性
• 2. 增加了getter()和setter()方法，很好控制属性是否是只读的
• 3. 使用setter()设置属性，可以在做一个数据的验证
• 4. 使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
'''
  • 对象的属性使用 self.___xxx这种双下划线开头的属性，表示对象的隐形属性，隐形属性只提供类的内部访问，无法通过外部访问。（其实隐藏属性知识python为属性改了一个名字——》_类名__属性名 如：__name ——》_Class__name）
#封装：隐藏属性
class Car():
    def __init__(self,name,color):
        self.__name = name   #隐藏属性,不可读的属性
        self.color = color

    def run(self):
        print('汽车开始跑起来了')

    def dida(self):
        print('汽车鸣笛')


car = Car('兰博基尼','红色')
car.__name = '中华田园犬'
car.run()
car.dida()
print(car._Car__name)
  • 实际上隐藏属性这种方法还是会被外部访问，所以很少使用，开发中，一般使用以_name这种单下划线开头的私有属性，没有特殊情况一般不会修改私有属性。

8. 装饰器（property ）

  • 使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改
# 封装：私有属性


class Car():
    def __init__(self,name,color):
        self._name = name     #私有属性,一般使用这个私有属性，属于商议协定
        self.color = color

    #getter方法:提供访问这个属性的方法
    @property
    # def get_name(self):
    #     return self._name
    def name(self):
        return self._name

    #setter方法：提供修改属性的方法
    @name.setter
    # def set_name(self,name):
    #     self._name = name
    def name(self,name):
        self._name = name

    def run(self):
        print('汽车开始跑起来了')

    def dida(self):
        print('汽车鸣笛')


car = Car('兰博基尼','红色')
# car._name = '中华田园犬'     #访问属性
car.run()        #调用方法
car.dida()
# print(car._Car__name)
print(car.name)
car.name = '玛莎拉蒂'
print(car._name)

9. 类的继承

  • 继承是面向对象的三大特性之一
  • 通过继承可以轻松在一个新类里获取旧的或其他类的属性和方法
  • 通常将当前类的父类（超类、基类）写在定义类时类名后的括号里，如 class Any(father_class)： 中的father_class就是父类。
  • 类的继承提高了代码的复用性，让类与类之间产生了妙不可言的关系，才有了多态的特性。
#基类
class Father():
	def __init__(self):
		pass

#继承
class Son(Father):
	def __init__(self):
		pass

10. 方法重写

  • 在子类中如果存在和父类同名的方法，在子类实例化调用方法时，调用的是子类里的方法而不是父类的，这种被叫做方法的重写。（必须建立在继承的基础上）
#基类
class Father():
    def __init__(self):
        pass
    def run(self):
        print("这是父类")

#继承
class Son(Father):
    def __init__(self):
        pass
    def run(self):
        print('这是子类')
#类的实例化
mc = Son()
mc.run()

结果：

  • 在调用一个类的方法时，程序会先去当前类中寻找是否具有该方法，如果没有，程序才会去父类中寻找，如果有这个方法就调用，如果还没有，程序就会去父类的父类中寻找，不断往更高的类去寻找，直到object，如果仍然没有，程序就会报错。（object时所有类的父类，处于最高级，括号里默认为object）
  • super（）
    。super()可以获取当前类的父类，并通过super()返回对象调用父类方法时，不需要传递self。（只能调用当前类的父类里面的方法）
#super这个方法在使用时建立在两个基础之上
# 1.必须要有父类的基础
# 2.必须要有方法的重写
class Star:
    def sing(self):
        print('明星在唱歌')
    def run(self):
        print('明星在跑步')

class Music(Star):
    def sing(self):    #方法的重写
        print('歌曲唱作')
        #super的作用：将被覆盖的父类方法，重新调用
        super().sing()

#实例化对象
mc = Music()
# mc.run()
mc.sing()

11. 多重继承和多层继承

  • 如 class Son(Father,Mother,…): 这样在一个类中含有多个父类的就是多重继承，多重继承会使子类拥有国歌父类，并且获得所有父类中的方法；
  def run(self):
        print("这是父类")
        
        
class Mother():
    def __init__(self):
        pass
    
    
#继承
class Son(Father,Mother):
    def __init__(self):
        pass
    def run(self):
        print('这是子类')
        
#类的实例化
mc = Son()
mc.run()
  • 但是在开发中没有特殊情况，应尽量避免使用多重继承，多重继承会让开发的代码更加复杂，如果多个父类中有同名的方法，子类的实例化调用方法会先在第一个父类中寻找，然后是第二个，以此类推，前面会覆盖后面的
    。解耦合原则：不希望太多的代码成为彼此相牵连的代码（高内聚低耦合）
    。解耦合的作用：方便维护，提高解决问题的效率
class A(object):
    def text(self):
        print('爱读书')

    def name(self):
        print('貌似潘安')

class B(object):
    def pai(self):
        print('看电影')

    def name(self):
        print('大漂亮')

class C(A,B):
    pass

sun = C()
sun.text()
sun.pai()
sun.name()
  • 如 class Father(Grandpa):——》 class Son(Father): 这样形式的就是多层继承。也就是说，子类不仅仅可以继承父类， 还可以继承父类的父类、父类的父类的父类……
#明星类
class Star:
    glasses = "太阳镜"

#音乐人继承了明星类
class Musician(Star):
    loveMusic = True

# Rapper继承了音乐人类
class Rapper(Musician):
    pass

12. 多态

  • 面向对象的三大特点：
    。封装（确保对象中数据的安全）
    。继承（保证对象的扩展性）
    。 多态（给与了程序更多的灵活性）

  • 多态是面向对象的三大特性之一。说白了就是一个对象可以由不同形态去呈现。python多态有以下特点：

    1. 只关心对象实例方法名是否相同，不关心对象所属的类型；
    2. 对象的所属的类之间，继承关系可有可无；
    3. 多态增加了代码的外部调用灵活性，使代码更加通用，兼容性比较强；
    4. 多态调用方法的技巧，不会影响到类的内部设计。
class A(object):
    def __init__(self,name):
        self.name = name

    def speak(self):
        print('hello，我是%s'%self.name)

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

    def speak(self):
        print('hello,我是%s'%self.name)
a = A('刘亦菲')
b = B('邓紫棋')
#对象
def fun(obj):
    obj.speak()

fun(a)
fun(b)

#鸭子类型：
#一只鸟走起来像鸭子，游泳像鸭子，叫起来像鸭子，\\
#我们不关注什么类型，也不关注是不是鸭子，只关注鸟的行为是否像鸭子

13. 属性和方法

  • 属性
    。类属性（直接在类中定义的属性）
    。类属性通过类或类的实例化进行访问，类属性只能通过类对象来修改，不能通过实例对象来修改
    。实例属性（通过实例对象添加的属性）
    。 实例对象可以通过实例对象来访问修改，类对象无法访问修改
#类属性和实例属性
class A(object):
    #类属性：直接定义在类中的属性
    #类属性可以通过类和实例对象来调用
    #类属性只能通过类对象来修改，不能通过实例对象来修改
    num = 0
a = A()
#实例属性：通过实例对象来添加的属性，只能通过实例对象调用，不能通过类对象调用
a.num = 100
# print(A.num)  #使用类对象来调用属性
# print(a.num)  #使用实例对象来调用属性
  • 方法
    。在类中，以self为第一个参数方法都是实例化方法
    。实例化方法通过类实例和类对象去调用，调用时，python会以self传入，实例调用时，会自动把当前调用的对象作为self传入；通过类调用，需要手动传递self。
    。类方法以@classmethod 来修饰的方法属性类方法，第一个参数时cls会被自动传递，cls就是当前的类对象，实例方法的第一个参数时self，类方法的第一个对象是cls，类方法可以通过类去调用，也可以通过实例调用。
class A(object):
    #类属性：直接定义在类中的属性
    #类属性可以通过类和实例对象来调用
    #类属性只能通过类对象来修改，不能通过实例对象来修改
    def __init__(self,name):
        self.name = name   #实例属性
    def speak(self):
        print('hello，我是%s'%self.name)  #实例
    @classmethod   #类方法
    def run(cls):
        print('hello world')
a = A('刘亦菲')
#实例方法
print(a.speak())
print(A.speak(a))
#类方法
a.run()
A.run()
  • 静态方法
    。 在类中以@staticmethod来修饰的方法属于静态方法，静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
    ，静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数，静态方法一般都是些工具方法，和当前类无关。
class A(object):
    #类属性：直接定义在类中的属性
    #类属性可以通过类和实例对象来调用
    #类属性只能通过类对象来修改，不能通过实例对象来修改
    num = 0
    def __init__(self,name):
        self.name = name   #实例属性
    def speak(self):
        print('hello，我是%s'%self.name)  #实例
    @classmethod   #类方法
    def run(cls):
        print('hello world')

    @staticmethod
    def star():   #功能方法，工具方法
        print('hello')
a = A('刘亦菲')
#静态方法
a.star()
A.star()

14. 把类放到模块里

建立独立类模块的主要操作如下：
（1）建立一个空白的python模块文件。模块拓展名为.py，给这个类模块起一个容易识别的名称，如Class_mobule.py
（2）把自定义类放到Class_module.py文件里。这里可以采用直接在该文件里编写自定义的类（适合编程熟练者使用），也可以把其他地方编写好、调试成熟的类代码复制过来。
（3）在主程序代码文件导入自定义类。导入自定义类过程的语法与导入函数一模一样。

from Class_module import *                      #*代表导入所有类

（4）在主程序使用自定义类。
类模块

class Box1():      #定义类，类名Box1
    '''
    求立方体的类
    '''
    def __init__(self,length1,width1,height1):
        self.length=length1   #长数据变量
        self.width=width1     #宽数据变量
        self.height=height1   #高数据变量

    def volume(self):          #求立方体体积函数
        return self.length*self.width*self.height


class Box2(Box1):
    def __init__(self,length1,width1,height1):
        super().__init__(length1,width1,height1)
        self.color="white"
        self.material="paper"
        self.type="fish"

    def area(self):
        re = self.length*self.width+self.length*self.height+self.width*self.height
        return re*2

使用类模块

from Class_module import *

my_box2=Box2(10,10,10)

print("立方体体积是%d"%my_box2.volume())
print("立方体表面积是%d"%my_box2.area())
print("Box颜色%s，材质%s，类型%s"%(my_box2.color,my_box2.material,my_box2.type))

结果：

总计

  本文属于作者原创，转载请注明出处，不足之处，希望大家能过给予宝贵的意见，如有侵权，请私信。每天一个knowledge point，一起学python，让技术无限发散。

以上是关于python基础篇 —— 类的主要内容，如果未能解决你的问题，请参考以下文章

python基础第5篇 python基础补充内容

python基础--结构篇

python基础篇 —— 类

Python代码阅读（第19篇）：合并多个字典

Python代码阅读（第41篇）：矩阵转置

Python代码阅读（第26篇）：将列表映射成字典