python面向对象入门_python面向对象入门

最新推荐文章于 2023-06-03 08:15:00 发布

weixin_39989796

最新推荐文章于 2023-06-03 08:15:00 发布

阅读量55

点赞数

文章标签： python面向对象入门

一.简介

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

面向对象：【创建对象】【通过对象执行方法】

函数编程：【执行函数】

函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象技术简介：

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

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override)，也称为方法的重写。

实例变量：定义在方法中的变量，只作用于当前实例的类。

继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个(is-a)"关系(例图，Dog是一个Animal)。

实例化：创建一个类的实例，类的具体对象。

方法：类中定义的函数。

对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

1.创建类

python类使用class 关键字来创建。简单的类的声明可以是关键字后紧跟类名：

classFoo:defBar(self):print 'Bar'

defHello(self, name):print 'i am %s' %name#根据类Foo创建对象obj

obj =Foo()

obj.Bar()#执行Bar方法

obj.Hello('test') #执行Hello方法

二.面向对象特性

面向对象的三大特性是指：封装、继承和多态

1.封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容

所以，在使用面向对象的封装特性时，需要：

将内容封装到某处

从某处调用被封装的内容

#!/usr/bin/env python#-*- coding:utf-8 -*-

classFoo():#__init__为构造方法，根据类创建对象时自动执行

def __init__(self,bk):

self.backend=bkdeffun1(self):print(self.backend)deffun2(self,arg):print(arg)

obj= Foo("www.test.org") #将www.test.org封装到obj的bk属性中

obj.fun2("tet")

从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用

通过self间接调用

classPerson():def __init__(self,name,age,weight):

self.Name=name

self.Age=age

self.Weight=weightdefeat(self):

self.Weight= self.Weight + 1

defwork(self):

self.Weight= self.Weight - 2user1= Person("lily","20",100)print(user1.Weight) #直接调用

通过self间接调用被封装的内容

#间接调用

classFoo:def __init__(self, name, age):

self.Name=name

self.Age=agedefin_call(self):"""间接调用init中的值"""

print(self.Name)print(self.Age)

obj= Foo("mary", 20)

obj.in_call()

添加，更改，删除属性

classPerson():def __init__(self, name, age, weight):

self.Name=name

self.Age=age

self.Weight=weightdefeat(self):

self.Weight= self.Weight + 1

defwork(self):

self.Weight= self.Weight - 2user1= Person("lily","20",100)#添加属性

user1.address = "BJ"

print(user1.address)#更改属性

user1.address = "China"

print(user1.address)#删除属性

del user1.address

对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容

练习

#!/usr/bin/env python#-*- coding:utf-8 -*-

classGame():def __init__(self,name,age,HP,gen):

self.Name=name

self.Age=age

self.Gender=gen

self.HP=HPdeffight(self):"""格斗

:return: 生命值"""self.HP= self.HP - 100

defpromote(self):"""提升修炼

:return: 生命值"""self.HP= self.HP + 200

defmult(self):"""多人格斗

:return: 生命值"""self.HP= self.HP - 150

defdetail(self):"""人物信息描述

:return: 人物信息"""CV= "Name: %s, Age: %d, Gender: %s,initHP: %d" %(self.Name, self.Age, self.Gender, self.HP)print(CV)#创建人物

Person1 = Game("user1", 18, 1000, "female")

Person2= Game("user2", 20, 2000, "male")

Person3= Game("user3", 17, 1500, "male")#输出人物信息

Person1.detail()

Person2.detail()

Person3.detail()#游戏

whileTrue:

Person1.fight()

Person1.detail()if Person1.HP <= 200:

chose= input("\033[33;1m 您当前的生命值已低与200是否修行提升？是：y 否：n\033[0m\n")if chose.lower() == "y":whileTrue:

Person1.detail()

Person1.promote()if Person1.HP == 1000:print("\033[33;1m 恢复初始状态！！\033[0m")break

elif chose.lower() == "n":

Person1.fight()if Person1.HP ==0:break

print("user1 has been dead!!")break

View Code

2.继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容(基类，派生类)

对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

#!/usr/bin/env python#-*- coding:utf-8 -*-

classFather:deffun(self):print("Father.fun")#继承基类(Father)

classSon(Father):def __init__(self):print("Son")deff(self):print("Son.f")

obj=Son()

obj.fun()#调用继承方法

#继承

classAnimals():defeat(self):print(self.Name + "eat")defdrink(self):print(self.Name + "drink")classPerson(Animals):def __init__(self, name):

self.Name=namedefthink(self):print(self.Name + "think")

obj= Person("user1")

obj.drink()

obj.eat()

obj.think()

2.2多继承

Python的类可以继承多个类，Java和C#中则只能继承一个类

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

当类是经典类时，多继承情况下，会按照深度优先方式查找

当类是新式类时，多继承情况下，会按照广度优先方式查找

#经典类(2.7版本之前)

classA:deffun(self):print("A")classB(A):def __init__(self):print("b")

obj=B()

obj.fun()

#新式类

classD(object):defbar(self):print 'D.bar'

classC(D):defbar(self):print 'C.bar'

classB(D):defbar(self):print 'B.bar'

classA(B, C):defbar(self):print 'A.bar'a=A()#执行bar方法时#首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错#所以，查找顺序：A --> B --> C --> D#在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

a.bar()

View Code

经典类：先深度，后广度

新式类：先左后右，其次深度

如果找到匹配方法，就不会继续找下去

3.多态

classF1:pass

classS1(F1):defshow(self):print 'S1.show'

classS2(F1):defshow(self):print 'S2.show'

#由于在Java或C#中定义函数参数时，必须指定参数的类型#为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类#而实际传入的参数是：S1对象和S2对象

defFunc(F1 obj):"""Func函数需要接收一个F1类型或者F1子类的类型"""

printobj.show()