资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

Python3面向对象

Python3 面向对象

python是一门面向对象语言，在python中有一句话：一切都是对象

创新互联主要从事网页设计、PC网站建设（电脑版网站建设）、wap网站建设（手机版网站建设）、成都响应式网站建设公司、程序开发、网站优化、微网站、小程序设计等，凭借多年来在互联网的打拼，我们在互联网网站建设行业积累了丰富的网站制作、成都做网站、网站设计、网络营销经验，集策划、开发、设计、营销、管理等多方位专业化运作于一体。

面向对象简介

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
    • 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
    • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
    • 实例变量：定义在方法中的变量，只作用于当前实例的类。
    • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
    • 实例化：创建一个类的实例，类的具体对象。
    • 方法：类中定义的函数。
    • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

      类的定义

      语法格式如下：


class ClassName:
    
    .
    .
    .

类实例化后，可以使用其属性；实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。
属性引用语法：obj.name
对象创建后，类命名空间中所有的命名都是有效属性名

#!/usr/bin/python3
class People:
    """一个人类"""
    def __init__(self, name, age):    # 类的初始化方法，实例化的时候首先调用的方法，前后双下划线的方法都是特殊方法
        self.name = name              # 类的属性，也是特点、特征
        self.age = age

    def walk(self):                  # 普能方法
        """人类会走路"""
        print(f'{self.name} is walking')
# 实例化
p = People('yhyang', 18)
# 访问类的属性和方法
print(f'我的名字是：{p.name}，我今年{p.age}岁')
p.walk()
输出：
我的名字是：yhyang，我今年18岁
yhyang is walking

注：上例中，init() 是类的初始化方法，用于初始化类中的属性和方法。

  • self代表类的实例，而非类
  • 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
  • self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

    类的方法

    类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
    示例代码：

#!/usr/bin/python3
class People:
    """一个人类"""
    def __init__(self, name, age):    # 类的初始化方法，实例化的时候首先调用的方法，前后双下划线的方法都是特殊方法
        self.name = name              # 类的属性，也是特点、特征
        self.age = age

    def walk(self):                  # 普能方法
        """人类会走路"""
        print(f'{self.name} is walking')
# 实例化
p = People('yhyang', 18)
# 访问类的方法
p.walk()
输出：
yhyang is walking

类中的变量

  • 私有变量：__name，不能被继承
  • 内部变量：_开头
  • 通过方法修改私有数据，对数据进行保护
    示例代码：
#!/usr/bin/python3
class Car:
    name = 'xxx'                                      # 类的属性
    def __init__(self, brand, price, wheels, power):
        self._brand = brand
        self.price = price
        self.wheels = wheels
        self.power = power
        self.__speed = 0

    def run(self, action):
        print(f'{self.brand} is running')
        if action == '1':
            self.__speed += 1 * 10                          # 修改私有变量
            print('当前速度是：{} km/h'.format(self.__speed))

    def start(self):
        print(f'{self.brand} is on')

    @property
    def speed(self):                                       # 只读，getter方法
        return self.__speed

    @property
    def brand(self):
        return self._brand

    @brand.setter                                          # 添加setter方法，可以被赋值
    def brand(self, brand):
        if not isinstance(brand, str):
            raise TypeError('牌子是字符串类型')            # raise 抛出异常
        self._brand = brand                                # 可以对属性操作，提前判断

    @property                                              # 把下边的函数变成了属性，可以直接用 实例名.info 这样调用
    def info(self):
        return f'{self.brand}: {self.price}'

# 实例化
auto = Car('auto', 30000, 4, 'oil')
auto.run('1')                                           # 调用run()方法，修改私有变量
auto.info                                                 # 以访问属性的方式访问info()方法
auto.brand = 'audiA8'    # 此处的brand不是属性，而是下边的@brand.setter处定义的brand方法
auto.brand
tesla = Car('Tesla', 100000, 4, 'electric')
tesla.run('1')
tesla.price = 999999        # 此处是类对象的属性
tesla.price
tesla.name
Car.name
auto.country = 'China'  # 在类的对象中动态的新声明一个属性，原类之中不存在
auto.country

输出：
auto is running
当前速度是：10 km/h
'auto: 30000'
'audiA8'
Tesla is running
当前速度是：10 km/h
999999
'xxx'
'xxx'
'China'

特殊方法

  • init: 把各种属性都绑定到self
  • slots:限制实例的动态属性，减少内存消耗，类型为tuple
  • str:对象的说明文字
  • eq: 比较对象是否相等

  • classmethod 与 staticmethod ；classmethod 会把类本身作为第一个参数传入
    示例代码1：

    #!/usr/bin/python3
class Computer:
__slots__ =('__name', 'mem', 'cpu')  # 为节省资源，不允许实例对象随意添加属性
def __init__(self, name, mem, cpu):
    self.__name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)
# 实例化
pc2 = Computer('admin', '8G', '8核')
pc2.mem
pc2.ssd = 'ssd'  # 此处会报错，类中用了__slots__所以不能随意添加
输出：
'8G'
AttributeError: 'Computer' object has no attribute 'ssd'

    示例代码2：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 为节省资源，不允许实例对象随意添加属性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 当print(对象)时，自动调用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'
# 实例化
pc3 = Computer('admin', '8G','8核')
print(pc3)                       # 直接打印对象
输出：
admin:8G-8核

    示例代码3：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 为节省资源，不允许实例对象随意添加属性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 当print(对象)时，自动调用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 对象A == 对象B 时调用
    return self.cpu == other.cpu
# 实例化
pc2 = Computer('admin','8G','8核')
pc3 = Computer('admin','4G','8核')
pc2 == pc3                               # 调用__eq__方法，认为cpu相等即为两个对象相等
输出：
True

    示例代码4：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 为节省资源，不允许实例对象随意添加属性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 当print(对象)时，自动调用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 对象A == 对象B 时调用
    return self.cpu == other.cpu

@classmethod
def new_pc(cls, info):            #cls 相当于类本身，通过 类名.new_pc（‘参数’）来直接生成实例，而不调用__init__
    "从字符串直接产生新的实例"
    name, mem, cpu = info.split('-')  # 传参时用-连接三个参数
    return cls(name, mem, cpu)
# 使用classmethod建立新对象
pc666 = Computer.new_pc('yhyang-16G-8eeeee核')
print(pc666)
输出：
yhyang:16G-8核

    示例代码5：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 为节省资源，不允许实例对象随意添加属性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 当print(对象)时，自动调用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 对象A == 对象B 时调用
    return self.cpu == other.cpu

@classmethod
def new_pc(cls, info):            #cls 相当于类本身通过 类名.new_pc（‘参数’）来直接生成实例，而不调用__init__
    "从字符串直接产生新的实例"
    name, mem, cpu = info.split('-')  # 传参时用-连接三个参数
    return cls(name, mem, cpu)

@staticmethod   # 不需要生成类的实例，就可以使用的方法 ，直接用 类名.calc来调用此方法
def calc(a,b,oper): # 不用第一个参数
    "根据操作符+-*/来计算a 和b的结果"
    if oper == '+':
        return a + b
Computer.calc(2,5,'+')
输出：
7

    面向对象三大特征

  • 封装
  • 继承

  • 多态

    继承（多继承暂时不说）

    python支持类的继承，如下格式：

    class DerivedClassName(BaseClassName1):

.
.
.

    要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
示例代码：


#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()
输出：
ken 说: 我 10 岁了，我在读 3 年级

方法重写（多态）

  • 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法
  • super() 函数是用于调用父类(超类)的一个方法。
    示例代码：

#!/usr/bin/python3

class Parent:        # 定义父类
   def FatherMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def FatherMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.FatherMethod()         # 子类调用重写方法
super(Child,c).FatherMethod() #用子类对象调用父类已被覆盖的方法
输出：
调用子类方法
调用父类方法

元编程

  • 类的类型是type，type类型是元类型metaclass，对象的类型是类类型
  • 顺序为 type---> class -----> object
  • 类A继承于type,通过type的new方法返回一个对象，可以认为是类A的对象，所以
  • 类实例化的方式为：a = A(),其实a是A调用type中new方法的返回值
    示例代码1：
#!/usr/bin/python3
# 运行时动态创建类和函数
# metaclass -> class ->obj
# __new__
class Game:
    pass
Game.__class__
输出：
type
type(Game)
输出：
type

示例代码2：

#!/usr/bin/python3
# type 是一个metaclass
# 通过type创建一个新的metaclass
class Yuhy(type):
    pass
class Yhy(metaclass=Yuhy):
    pass
print(type(Yuhy))       # 查看Yuhy类的类型
print(type(Yhy))         # 查看Yhy类的类型
输出：



isinstance(Yhy,Yuhy)      # Yhy与Yuhy是否是同样的类型
输出：
True

用Yhy.__new__?查看此方法
Signature: Yhy.__new__(*args, **kwargs)
Docstring: Create and return a new object. See help(type) for accurate signature.
Type: builtin_function_or_method
help(type)
示例代码：

class Yuhy(type):
    def __new__(cls, name, bases, my_dict):   # classmethod
        print(f'{name} 使用__new__创建')
        yhy = super().__new__(cls, name, bases, my_dict)
        return yhy
class Ks(metaclass=Yuhy):
    pass
输出：
Ks 使用__new__创建
a = Ks()
print(a)
输出：
<__main__.Ks object at 0x0000024AF06E9A20>

反射能用来干什么

反射也叫内省，其实就是让对象自己告诉我们他有啥，能干啥
有三个方法

  • hasattr(obj,attr)
  • setattr(obj,attr,val )
  • getattr(obj,attr)
    示例代码1：
#!/usr/bin/python3
# hasattr(obj, attr) 检查obj是否有一个名为attr的值的属性，返回一个bool
# getattr(obj,attr) 检查obj中是否有attr属性或方法，并将其返回
# setattr(obj,attr,value)  向对象obj中添加一个属性，值为value
s = 'yhyang'                   # s是一个字符串对象
s.upper()
输出：
'YHYANG'

isinstance(s, str)
输出：
True
hasattr(s,'upper')    # 查看s当中是否有一个叫upper的方法
输出：
True

示例代码2：

#!/usr/bin/python3
class People:
    def eat(self):
        print('eate')
    def drink(self):
        print('drink')
p = People()

p.eat()
hasattr(p,'eat')  # 找这个对象p中有没有eat这个方法
getattr(p,'eat') # 在p中找到eat方法 并返回
aa = getattr(p,'eat')
aa()
setattr(p, 'sleep', 'sleep1234')     # 添加一个新的属性，值为sleep1234
p.sleep
输出：
eate
True
>
eate
'sleep1234'

示例代码3：汽车工厂

#!/usr/bin/python3
# 汽车类
class Car:
    def info(self):
        print('Car 父类 ')

class Audi(Car):
    def info(self):
        print('Audi 汽车')

class Tesla(Car):
    def info(self):
        print('Tesla 汽车')

# 工厂类
class Factory:
    def create(self):
        print('创建汽车，工厂基类')

class AudiFactory(Factory):
    def creat(self):
        print('创造Audi汽车')
        return Audi()

class TeslaFactory(Factory):
    def creat(self):
        print('创造Tesla汽车')
        return Tesla()

# 生产汽车
audi_F = AudiFactory()
audi = audi_F.creat()
audi.info()

#另一种写法
AudiFactory().creat().info()
TeslaFactory().creat().info()
输出：
创造Audi汽车
Audi 汽车
创造Audi汽车
Audi 汽车
创造Tesla汽车
Tesla 汽车

当前题目：Python3面向对象
网页网址：http://cdkjz.cn/article/jpcddg.html
返回首页 了解更多建站资讯

相关资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求
友情链接 交换友情链接
IDC机房托管德阳东方电机技改资阳网站建设品牌网站建设绵阳网站建设网站推广公司鳄鱼养殖胜锦安防科技成都恒翔机电维修新网创想

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图