Python—类

面向对象编程基础
于 2019-07-30 19:21:49 发布
阅读量427 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Dirge__/article/details/97812465

文章目录

类的定义和使用

面向对象设计的思想，先抽象出类，再根据类创建实例

类的定义

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

class ClassName(object):
   """docstring"""
   class_statement

类的命名，大驼峰式

大驼峰就是变量名称的单词的首字母大写

创建一个类

class MyFirstClass:
   pass

类的作用是一个模版，我们可以在创建实例的时候，把一些我们认为必须要绑定的属性填写进去。这时就通过特殊的__init___方法。在创建实例的时候，绑定相关的属性，比如前面的name等

class student:
    school='zucc'
    def __init__(self,name,age):
        self.name=name
        self.age=age

stu1=student('tom',20)  # 实例化
print(stu1.name,stu1.age,stu1.school) # school为固有属性

tom 20 zucc

和普通函数相比，在类中定义方法时，第一个参数必须是self，除第一个参数外，其他的和普通函数没有什么区别

self代表的是实例，而非类

__init__方法

  • 1.为对象初始化自己独有的特征
  • 该方法中可以有任意的代码，但是一定不可以有返回值

数据封装

class student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def find(self):
        print(self.name,':',self.age)

stu1=student('tom',20)

我们通过__init__()让stu1实例本身就拥有了相关数据，如果要访问这些数据，我们可以直接在student类的内部定义相关的函数来访问数据，以此”封装“数据

这些封装数据的函数和student这个类本身是关联起来的，它们被称之为方法

# 返回两个对象的距离
import math
class Point:
    def __init__(self,x,y):
        # self.x=x
        # self.y=y
        self.move(x,y)
    def move(self,x,y):
        self.x=x
        self.y=y
    def reset(self):
        self.move(0,0)
    def cal_distance(self,other_point):
        return math.sqrt((self.x-other_point.x)**2+
                         (self.y-other_point.y)**2)
p1=Point(0,0)
p2=Point(3,4)
p3=Point(6,8)
print(p2.cal_distance(p1))
print(p2.cal_distance(p3))

5.0
5.0

类的两个作用：

  • 属性引用
    • 类名·属性
  • 实例化
    • 类名加上一个括号就是实例化，它能够自动触发__init__函数的运行，进而为每个实例定制自己的特征

类属性的补充

  • 加定义
  • 加固定属性
class student:
    school='zucc'
    def __init__(self,name,age):
        self.name=name
        self.age=age

类属性的查看

  • dir(类名)
    • 返回一个列表
  • 类名.__dict__
    • 返回一个字典，key是属性名。value是属性值

特殊的类属性

类名.__name__ # 返回类的名字
类名.__doc__ # 类的文档字符串
类名.__base__ # 类的第一个父类
类名.__bases__ # 类的所有父类构成的元组
类名.__module__ # 类定义所在的模块
类名.__class__ # 实例所对应的类
类名.__dict__ # 类的字典属性

总结：

class ClassName:
   def __init__(self,para1,para2,...):
      self.对象属性1=para1
      self.对象属性2=para2
      
   def 方法名1(self):
      pass
   def 方法名2(self)：
      pass
obj=ClassName(para1,para2)
# 对象的实例化，代表具体的东西
# ClassName()：调用__init__
# 括号内传参，无需传入self，参数一一对应
# 结果是返回对象obj

obj.对象属性1 # 查看对象的属性
obj.方法名1 # 调用类的方法

对象之间的交互

假如说现在定义两个类,Person,Dog

攻击交互

class Person:
    def __init__(self,name,aggress,life_value):
        self.name=name
        self.aggress=aggress
        self.life_value=life_value

    def attack(self,dog):
        dog.life_value-=self.aggress

class Dog:
    def __init__(self,name,breed,aggress,life_value):
        self.name=name
        self.breed=breed
        self.aggress=aggress
        self.life_value=life_value

    def bite(self,people):
        people.life_value-=self.aggress

per=Person('Jack',10,1000)
dog=Dog('Jerry','husky',8,1000)
print(dog.life_value)
per.attack(dog)
print(dog.life_value)

类命名空间与对象、实例的空间

创建一个类就会创建一个类的名称空间，用来存储我们定义的所有的变量名。

这些名字就是属性

类的属性有两种

  • 静态属性
    • 直接在类中定义的变量
  • 动态属性
    • 在类中定义的方法

静态属性是共享给所有对象的

动态属性是绑定到所有对象的

class student:
    school='zucc'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def find(self):
        print(self.name)

stu1=student('tom',20)
stu2=student('jack',22)
print(id(stu1.school))
print(id(stu2.school))
print(stu1.find)
print(stu2.find)
print(student.find)

2493429036960
2493429036960
<bound method student.find of <__main__.student object at 0x000002448BF49E48>>
<bound method student.find of <__main__.student object at 0x000002448BF42240>>
<function student.find at 0x000002448C10B378>

类的三大特性

  • 继承
  • 多态
  • 封装

继承

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（Subclass），而被继承的类则被称为基类，父类，超类（Base Class，Father Class，Super Class）

比如，我们定义一个动物类（Animal）

class Animal(object):
    def run(self):
        print('Animal is running')
class Animal2:
    pass
class Dog(Animal):
    def run(self):
        print('Dog is running')
class Cat(Animal):
    def run(self):
        print('Cat is running')
class Husky(Animal,Animal2):  # 多继承 逗号分开
    pass
dog=Dog()
cat=Cat()
dog.run()
cat.run()
print(Dog.__bases__)
print(Husky.__bases__)
print(Animal.__class__)
print(Animal2.__class__)
# 如果不指定基类，python类会默认继承object类
# object是所有python类的基类，提供一些常见方法的实现

Dog is running
Cat is running
(<class '__main__.Animal'>,)
(<class '__main__.Animal'>, <class '__main__.Animal2'>)
<class 'type'>
<class 'type'>

继承属性

class B:
    """类B"""
    def __init__(self):
        pass

    def func(self):
        print("B.handle")


class A(B):
    """类A"""
    def __init__(self):
        super().__init__()

    def func(self):
        super().func()  # super依赖于继承


a = A()
a.func()

# B.handle

继承的查看

ClassName.__bases__

class Animal(object):
    def run(self):
        print('Animal is running')
class Animal2:
    pass
class Dog(Animal):      #单继承
    def run(self):
        print('Dog is running')
class Husky(Animal,Animal2):  # 多继承 逗号分开
    pass
dog=Dog()
cat=Cat()
print(Dog.__bases__)
print(Husky.__bases__)

(<class '__main__.Animal'>,)
(<class '__main__.Animal'>, <class '__main__.Animal2'>)

多态

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，在运行代码时，总会调用子类和父类同名的方法

这样就是继承的另一个好处，多态。

class Animal(object):
    def run(self):
        print('Animal is running')
class Dog(Animal):
    def run(self):
        print('Dog is running')
class Cat(Animal):
    def run(self):
        print('Cat is running')
dog=Dog()
cat=Cat()
dog.run()
cat.run()

Dog is running
Cat is running

理解多态，首先要对数据类型再进行说明，定义一个类的时候实际上就是定义了一种数据类型。我们自定义的数据类型和python自带的数据类型，比如str,list,dict没什么区别

用isinstance()来判断某个变量是否是某个类型

class Animal(object):
    def run(self):
        print('Animal is running')
class Dog(Animal):
    pass
dog=Dog()

print(isinstance(dog,Animal))
print(isinstance(dog,Dog))

True
True

对于一个变量，我们只要知道它的父类型，无需确切知道子类型，就可以放心调用相关的方法。运行时具体的方法是作用在子类型上还是父类型上，由我们运行的对象决定。

也就是说，调用时只管调用，不管细节。

当我们新增一个子类时，只要保证相关的方法编写正确，就不用管原来的代码时如何调用的

—>“开闭”原则

  • 对拓展开放：允许新增子类
  • 对修改封闭：不需要修改依赖父类类型的函数

总结：

继承可以一级一级的继承下来，类比人类，就好比，爷爷奶奶到父母再到子女

任何类都可以追溯到根类object

鸭子类型

鸭子类型不要求有严格的继承关系

也就是说，如果要编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的对象，但与其无任何关系的全新对象

比方说，利用标准库中定义的各种“与文件类似的”的对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法

class TestFile:
   def read(self):
      pass
   
   def write(self):
      pass

class OpenFile:
   def read(self):
      pass
   
   def write(self):
      pass

封装

隐藏对象的属性和实现细节，仅对外提供公共访问的方式

这样做的优点在于

  • 可以将变化隔离
  • 便于使用
  • 提高安全性
  • 提高复用性

封装的原则是：

  • 将不需要对外提供的内容隐藏起来
  • 隐藏属性，提供公共方法对其进行访问

—>私有方法，私有变量—>私有属性

用双下划线开头的方式将属性隐藏起来，设置为私有的

私有属性

在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据。这样，隐藏内部的复杂逻辑

比如student类

class student:
    school='zucc'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def find(self):
        print(self.age)

stu1=student('tom',20)
stu2=student('jack',22)
stu1.find()
stu1.age=10
stu1.find()

20
10

从这可以看出，外部代码可以自由修改一个实例的属性(name,age)

如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线

在python中，实例的变量名如果以双下划线开头，就变成一个私有变量，只有内部可以访问，外部不能访问

修改student的类

class student:
    school='zucc'
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def find(self):
        print(self.__age)

stu1=student('tom',20)
stu2=student('jack',22)
stu1.find()
stu1.__age=10
stu1.find()

20
20
Dirge__
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值