大佬教程收集整理的这篇文章主要介绍了python基础篇 —— 类，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。
面向过程：是一种以过程为中心的编程方法。 面向过程编程思路的核心是一个个实现相关功能的过程c;将整个过程拆分为数个小的过程c;逐一实现每个过程的编程c;最后组装为一个完整的过程。 如：每天钓鱼记录统计代码的实现过程。
面向对象：是一种对现实世界理解和抽象的方法c;把现实世界里的任何事物都看作一个相对独立的对象。将现实世界的事物进行抽象c;就出现一种新的可以高效利用的数据类型——类。
类（class）：把具有相同特性（数据）和行为（函数）的对象抽象为类。类的特性通过数据来体现c;类的行为通过函数来操作c;现实世界对象都可以抽象为数据和函数相结合的一种特殊结构的新数据类型。
如：抽象盒子 盒子是个长方体c;由长、宽、高构成c;盒子由不同的颜色、材质、类型c;这些长、宽、高、材质、类型构成了一个盒子类的特性。可以统计盒子存放物品的数量、重量、金额c;也可以计算有多少物品可以放到盒子里c;计算盒子的体积、表面积等。这些统计、计算就是针对盒子的各种行为。
抽象成类过程的步骤：
#语法 class 类名([父类]): pass
class 类名():
类文档说明 用三引号(’’’)成对引用说明内容c;使用方法和函数的文档说明一样。
类函数 类函数在类或实例里又叫方法。这里的方法必须依赖于类或实例存在。 说明 （1）在实际独立引用对象名称时c;为了区分函数与方法c;将带小括号的统一认为是方法c;不带小括号的为函数。如volume叫函数c;volume()叫方法。 （2）__init__()叫做构造方法c;这种特殊方法不对实例显示c;其他自定义方法都可被实例调用。
保留函数__init__和self关键字 保留函数就是不能用其他函数代替该函数的作用c;包括函数名的的写法c;严格按照__init__格式输入 （1）所有类需要实例化c;必须在类里声明__init__函数c;不然类的实例无法使用。self关键字c;在实例使用时c;用于传输实例对象c;所有的实例可以调用的属性（Property）c;必须在__init__定义并初始化c;然后通过self传递。 最简约的使用格式
def __init__(self)
传递多个参数
def __init__(self,length,width,height)
（2）__init__初始化实例相关参数作用c;类在实例化的同时c;会自动调用__init__函数c;可以通过它来初始化属性值。
# 在python中c;你想使用一个东西c;你必须先创建一个这样的对象
# 自定义类 如：图纸 通过图纸创造出来的汽车 汽车就是通过图纸创建出来的实例对象
# 定义类的语法
# class 类名([父类]):
# pass
class MyClass(): #定义类c;给它命名为MyClass 类相当于图纸 类对象 只是用于存储的功能
pass
mc = MyClass() #创建实例对象（类的实例化）实例对象 实现效果的功能
#类对象 （存储属性、功能） 实例对象（实现效果的功能）
mc1 = MyClass()
print(id(mC),id(mc1))
#类可以创建多个实例c;每个实例各不相同c;这一些实例我们称呼为一类实例
#isinstance() 用来检测这个实例是否是这个类创建出来的
print(isinstance(mc,MyClass))
class Person(): #定义一个类
name = '邓紫棋' #属性
def speak(self): #方法 类中的函数不叫做函数了c;叫做方法
print('你好')
p1 = Person() #类的实例化
print(p1.Name) #实列.属性 就可以获取到这个属性值
p1.speak() #实例.方法
p1.name = '刘亦菲' #更改类的属性的值
print(p1.Name)
p2 = Person()
print(p2.Name)
5.1 属性和方法
5.2 self
class Presion():
#name = '刘亦菲'
#哪个对象调用类的speak方法c;那个s就是这个对象c;类里通常使用self
def speak(s):
print('你好c;我是%s'%s.Name)
def run(self): #self就等于任何调用这个方法的对象本身
pass
p1 = Presion()
p1.name = '周慧敏'
p1.speak()
p2 = Presion()
p2.name = '刘亦菲'
p2.speak()
class MyClass(): #定义一个类
# name = '刘亦菲'
def speak(self): #定义方法
print('大家好c;我是%s'%self.Name)
p1 = MyClass() #类的实例化
p1.name = '刘亦菲'
p1.speak() #在没有定义类的公共属性的情况下会报错c;
# 两种的定义公共属性的方法:
# 1.通过 对象.属性 如：p1.name = '刘亦菲'
# 2.在类里面定义 如：类里面的 name = '刘亦菲'
#'使用初始化方法解决的问题：'
#问题： 1.手动添加容易忘记c;查看代码需要那些参数比较麻烦
# 2.没有提示c;可以创建成功实例c;会导致后面的代码运行出错
class Preson(): #定义一个类
#初始化方法
def __init__(self,name,agE): #实例化创建的时候c;init方法就会报错
self.name = name
self.age = age
def speak(self):
print('大家好c;我是{},永远{}'.format(self.name,self.agE))
name = input('请输入姓名:')
age = input('请输入年龄：')
p1 = Preson(name,agE) #类的实例化
p1.speak()
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 #私有属性,一般使用这个私有属性c;属于商议协定
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 #私有属性,一般使用这个私有属性c;属于商议协定
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())
'''
- 使用封装c;确实增加了类的定义的复杂程度c;但是它也确保了数据的安全
• 1. 隐藏属性名c;使调用者无法随意的修改对象中的属性
• 2. 增加了getter()和setter()方法c;很好控制属性是否是只读的
• 3. 使用setter()设置属性c;可以在做一个数据的验证
• 4. 使用getter()方法获取属性c;使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
'''
#封装：隐藏属性
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)
# 封装：私有属性
class Car():
def __init__(self,name,color):
self._name = name #私有属性,一般使用这个私有属性c;属于商议协定
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)
#基类
class Father():
def __init__(self):
pass
#继承
class Son(Father):
def __init__(self):
pass
#基类
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()
结果：
#super这个方法在使用时建立在两个基础之上
# 1.必须要有父类的基础
# 2.必须要有方法的重写
class Star:
def sing(self):
print('明星在唱歌')
def run(self):
print('明星在跑步')
class Music(Star):
def sing(self): #方法的重写
print('歌曲唱作')
#super的作用：将被覆盖的父类方法c;重新调用
super().sing()
#实例化对象
mc = Music()
# mc.run()
mc.sing()
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 Star:
glasses = "太阳镜"
#音乐人继承了明星类
class @H_722_375@musician(Star):
loveMusic = True
# Rapper继承了音乐人类
class Rapper(@H_816_372@musician):
pass
面向对象的三大特点： 。封装（确保对象中数据的安全） 。继承（保证对象的扩展性） 。 多态（给与了程序更多的灵活性）
多态是面向对象的三大特性之一。说白了就是一个对象可以由不同形态去呈现。python多态有以下特点：
class A(object):
def __init__(self,name):
self.name = name
def speak(self):
print('Helloc;我是%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)
#鸭子类型：
#一只鸟走起来像鸭子c;游泳像鸭子c;叫起来像鸭子c;
#我们不关注什么类型c;也不关注是不是鸭子c;只关注鸟的行为是否像鸭子
#类属性和实例属性
class A(object):
#类属性：直接定义在类中的属性
#类属性可以通过类和实例对象来调用
#类属性只能通过类对象来修改c;不能通过实例对象来修改
num = 0
a = A()
#实例属性：通过实例对象来添加的属性c;只能通过实例对象调用c;不能通过类对象调用
a.num = 100
# print(A.num) #使用类对象来调用属性
# print(a.num) #使用实例对象来调用属性
class A(object):
#类属性：直接定义在类中的属性
#类属性可以通过类和实例对象来调用
#类属性只能通过类对象来修改c;不能通过实例对象来修改
def __init__(self,name):
self.name = name #实例属性
def speak(self):
print('Helloc;我是%s'%self.name) #实例
@classmethod #类方法
def run(cls):
print('Hello world')
a = A('刘亦菲')
#实例方法
print(a.speak())
print(A.speak(a))
#类方法
a.run()
A.run()
class A(object):
#类属性：直接定义在类中的属性
#类属性可以通过类和实例对象来调用
#类属性只能通过类对象来修改c;不能通过实例对象来修改
num = 0
def __init__(self,name):
self.name = name #实例属性
def speak(self):
print('Helloc;我是%s'%self.name) #实例
@classmethod #类方法
def run(cls):
print('Hello world')
@staticmethod
def star(): #功能方法c;工具方法
print('hello')
a = A('刘亦菲')
#静态方法
a.star()
A.star()
建立独立类模块的主要操作如下： （1）建立一个空白的python模块文件。模块拓展名为.pyc;给这个类模块起一个容易识别的名称c;如Class_mobule.py （2）把自定义类放到Class_module.py文件里。这里可以采用直接在该文件里编写自定义的类（适合编程熟练者使用）c;也可以把其他地方编写好、调试成熟的类代码复制过来。 （3）在主程序代码文件导入自定义类。导入自定义类过程的语法与导入函数一模一样。
from Class_module import * #*代表导入所有类
（4）在主程序使用自定义类。 类模块
class Box1(): #定义类c;类名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颜色%sc;材质%sc;类型%s"%(my_box2.color,my_box2.material,my_box2.typE))
结果：
本文属于作者原创c;转载请注明出处c;不足之处c;希望大家能过给予宝贵的意见c;如有侵权c;请私信。每天一个knowledge pointc;一起学pythonc;让技术无限发散。
以上是大佬教程为你收集整理的python基础篇 —— 类全部内容，希望文章能够帮你解决python基础篇 —— 类所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。