面向对象及类

于 2019-12-27 18:20:46 发布
阅读量477 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41321563/article/details/103723647
版权

1、基本概念

1.1 面向对象

面向对象是一种抽象，是一种用分类的方式看待问题的方法，用 Java 的编程思想来说就是：万物皆对象；面向对象有三大特性：封装、继承、多态。
　　面向对象的编程一般分为三个步骤：
　　 1、面向对象分析（OOA）→ 分析对象特征行为
　　 2、面向对象设计（OOD）→ 写类描述对象模版
　　 3、面向对象编程（OOP）→ 实例化对象模拟过程

1.2 面向对象术语介绍

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

2、类的基本使用

2.1 类定义

# 类的定义
class ClsaaName:
    pass

类的名字一般使用大写字母首写，同样使用小驼峰命名法，多个单词时不加下划线（“_”）分隔开。

2.2 类对象

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

输出结果为：
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

3、类中的方法

3.1 类的内置方法

Python 创建任何一个类的时候，都会包含一些内置的方法，主要包括如下：
在这里插入图片描述

3.2 自定义方法

python类中有三种常见的方法，分别为：实例方法、类方法、静态方法。

3.2.1 类方法

类方法是将类本身作为对象操作的方法。

'''
类方法（可调类变量、可被实例调用、可被类调用）
1、类方法通过@classmethod装饰器实现，只能访问类变量，不能访问实例变量；
2、通过cls参数传递当前类对象，不需要实例化。
'''
class Car:
	#定义类基本属性
    name = 'BMW'
    #初始化实例属性
    def __init__(self, name):
        self.name = name
    @classmethod
    def run(cls,speed):
        print(cls.name,speed)
# 访问方式1
c = Car("宝马")
c.run("100迈")
print(c.name)
print(Car.name)
# 访问方式2
Car.run("100迈")

运行结果：
宝马
BMW
BMW 100迈
BMW 100迈

3.2.2 静态方法

静态方法是类中的函数，不需要实例。

'''
静态方法（可调类变量、可被实例调用、可被类调用）
1、用 @staticmethod 装饰的不带 self 参数的方法；
2、调用时并不需要传递类或实例。
'''
class Car:
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    @staticmethod
    def run(speed):
        print(Car.name,speed,'行驶')
		
# 访问方式1
c = Car("宝马")
c.run("50迈")
# 访问方式2
Car.run("50迈")

运行结果：
BMW 50迈 行驶中
BMW 50迈 行驶中

3.2.3 实例方法

实例方法就是只有类的实例能够使用的方法。

# 实例方法（可调类变量、可调实例变量、可被实例调用）
# 第一个参数强制为实例对象 self。
class Car:
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print(self.name,speed,'行驶')
        
# 访问
c = Car("宝马")
c.run("150迈")

运行结果：
宝马 150迈 行驶

3.2.4 类的私有属性和方法

类的私有属性和方法以两个下划线开头（"__private")，表示该属性（该方法）为私有的，只能在类的内部使用self.__private访问（调用），不能在类的外部被访问（调用）。继承的子类中进行同样初始化也不能调用私有属性。

类的私有属性实例如下

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
counter = JustCounter()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  #报错

运行结果
1
1
Traceback (most recent call last):
  File "E:/pycharm/demo/test/cuboid.py", line 14, in <module>
    print(counter.__secretCount)  
AttributeError: 'JustCounter' object has no attribute '__secretCount'

类的私有方法实例

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

运行结果：
name  :  菜鸟教程
url :  www.runoob.com
这是公共方法
这是私有方法
File "E:/pycharm/demo/test/cuboid.py", line 21, in <module>
AttributeError: 'Site' object has no attribute '__foo'

4 类的继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

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

  • 1、单继承实例
#类定义
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("{}说: 我{}岁。".format(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("{}说: 我{}岁了，我在读{}年级".format(self.name,self.age,self.grade))
 
s = Student('ken',10,60,3)
s.speak()

运行结果：
ken说: 我10岁了，我在读3年级

这里子类的speak（）方法覆盖了父类的同名speak（）方法，即在程序运行时按照从左至右的顺序找寻该方法。

  • 2、类的多重继承
#类定义
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("{}说: 我{}岁了，我在读{}年级".format(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class Speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫{}，我是一个演说家，我演讲的主题是{}".format(self.name,self.topic))
 
#多重继承
class Sample(Speaker,Student):
    a =''
    def __init__(self,n,a,w,g,t):
        Student.__init__(self,n,a,w,g)
        Speaker.__init__(self,n,t)
 
test = Sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

运行结果：
我叫Tim，我是一个演说家，我演讲的主题是Python

5、类的多态

多态：多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

多态性：多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。

# 父类
class Car:
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print('Car-->',self.name,speed,'行驶')

# 子类1
class BMWCar(Car):
    def run(self,speed):
        print('BMWCar-->',self.name,speed,'行驶')

# 子类2
class SVWCar(Car):
    def run(self,speed):
        print('SVWCar-->',self.name,speed,'行驶')

# 调用 run 方法
c = Car("Car")
c.run("120迈")

bc = BMWCar("宝马")
bc.run("100迈")

sc = SVWCar("大众")
sc.run("80迈")

输出结果：
Car--> Car 120迈 行驶
BMWCar--> 宝马 100迈 行驶
SVWCar--> 大众 80迈 行驶

在上面的例子中，我们可以看出：c、bc 、sc 是不同类型的对象，在它们调用 run 方法时，调用的均是各自类中的方法，这就是多态。

6、运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：

class Car:
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print('Car-->',self.name,speed,'行驶')
    def __repr__(self):
   		return '这是车的类对象，对象位置为{}'.format(id(self)

In[2]: from day_1.test1 import Car
In[3]: a=Car('audo')
In[4]: a
Out[4]: 这是车的类对象，对象位置为1364904101200

更新模块后控制台重新载入模块使用或者直接点Rerun（这样我觉得更方便）
import importlib
importlib.reload(模块名)#只能是模块

一个支点a
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值