面向对象:两手交换牌

======封装思想、构造函数=========
第1题.问题:两手交换牌

1.1面向对象编程介绍

1.定义类(个人理解:指代具体事物的单体,属性指的是类的单体的构成部分,题目中明显看到的有手和牌两个事物,以及交换这个动作,那么我们就知道交换的动作是人制造的,然后手有牌,牌有花色和数字,之所以把人牵扯进来,是因为交换的动作需要人来进行,而动作可以视为人这个类的一个函数,所以需要加入人的类)
1)定义牌类(一张牌分为颜色和数字,所以需要做拼接)
属性:花色、数字(一般赋值为空,或设置变量,不会赋具体数值,具体数值由对象来做)

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

2)定义手类(这里指的是一只手,而发生交换这个动作必须要人的两只手,不需要创建两个相同的类,所以必然需要创建两个对象)
属性:卡牌

·面向对象:将数据与函数绑定到一起,进行封装,这样能够更快速的开发程序,减少了重复代码的重写过程

3)定义人类(一个人类有两只手,所以属性中需要分别定义左手和右手用来组成人类的手部)
属性:左手、右手(变量、构造函数)
动作:交换卡牌(函数)

面向过程的思路是将数据与函数按照执行的逻辑顺序组织在一起,数据与函数分开考虑。

2.创建类和函数

def发送邮件(内容)

1)创建卡牌类
定义属性:分为花色和数字
class pai: #创建牌类
def init(self): #创建构造函数
self.colors=None #定义牌的花色变量为空
self.nums=None #定义牌的数字变量为空

#发送邮件提醒

2)创建手类
定义属性:牌
class hand: #创建手类
def init(self): #定义构造函数
self.pai="" #定义牌变量为空

连接邮箱服务器

3)创建人类
定义属性:左手和右手
class Persion: #创建人类
def init(self): #创建构造函数
self.left_hand=None #定义左手变量为空
self.right_hand=None #定义右手变量为空

发送邮件

创建动作:交换
def change(self): #创建函数
c=self.left_hand #将变量c赋值为左手
self.left_hand=self.right_hand #将变量左手赋值为变量右手
self.right_hand=c #将变量c赋值为右手

关闭连接

3.创建对象
1)卡牌对象
第一个牌对象(第一张牌)
p1=pai() #创建牌类对象
p1.colors="黑" #将color赋值为黑
p1.nums="3" #将nums赋值为3

while True:

第二个牌对象(第二张牌)
p2=pai() #创建牌类对象
p2.colors="黑" #将color赋值为黑
p2.nums="4" #将nums赋值为4

if cpu利用率> 90%:

2)手类对象
第一个手对象(第一只手)
l=hand() #创建手类对象(左手)
l.pai=p1.colors+p1.nums #将牌的变量赋值为牌类的变量花色和数字的拼接(l为对象,pai为类中定义的构造函数变量,l.pai就相当于self.pai,这里是讲类中的变量模板拿出来进行赋值,类里面的self.pai为空值,这里就是通过对象,将其调用进行具体赋值了,这里有两只手,就对类中的变量进行两次赋值,两次对象的赋值都是独立进行的,左手赋值会保持一个变量,右手赋值会再保持一个变量,这也是扩展性的一个体现,不需要更改类里面的模板,只需要通过创建对象就可以不断的扩展

发送邮件('CPU报警')

第二个手对象(第二只手)
r=hand() #创建手类对象(右手)
r.pai=p2.colors+p2.nums #将牌的变量赋值为牌类的变量花色和数字的拼接

if硬盘使用空间> 90%:

3)人类对象
d1=Persion() #创建人类对象
d1.right_hand=l #将右手赋值给手类(左手)对象
d1.left_hand=r #将左手赋值给手类(右手)对象
d1.change() #将左右手交换(调用交换函数)
print(d1.left_hand.pai,d1.right_hand.pai) #打印左手和右手的牌

发送邮件('硬盘报警')

if内存占用> 80%:

发送邮件('内存报警')

面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)

面向对象(object-oriented ;简称: OO)指按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法。

面向对象编程(Object Oriented Programming-OOP)是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

面向对象的理解:

面向对象是一种设计思想

1.符合人们的思考习惯

2.把执行者变成指挥者

3.简化功能,把复杂的事情简单化

面向对象有三大特征:

1.封装

2.继承

3.多态

1.2类和对象

对象是面向对象编程的核心,在使用对象的过程中,为了将具有共同特征和行为的一组对象抽象定义,提出了另外一个新的概念——类

类是对事务的描述,是抽象的。

对象是类的具体体现。

1.2.1类

类:

具有相似内部状态和运动规律的实体的集合(或统称为抽象)。

具有相同属性和行为事物的统称

类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

1.2.2对象

对象:

某一个具体事物的存在,在现实世界中可以是看得见摸得着的。

可以是直接使用的

1.2.3类和对象之间的关系

类就是创建对象的模板

1.2.4类的构成

类(Class)由3个部分构成

·类的名称:类名

·类的属性:一组数据成员变量

·类的方法:允许对进行操作的方法(行为)成员方法

1.2.5类的抽象

拥有相同(或者类似)属性和行为的对象都可以抽像出一个类

方法:一般名词都是类(名词提炼法)

1.3定义类

定义一个类,格式如下:

class类名:

方法列表

demo:定义一个Car类

#定义类

classCar:

#方法

defgetCarInfo(self):

print('车轮子个数:%d,颜色%s'%(self.wheelNum, self.color))

defmove(self):

print("车正在移动...")

说明:

·定义类时有2种:新式类和经典类,上面的Car为经典类,如果是Car(object)则为新式类

·类名的命名规则按照"大驼峰"

1.4创建对象

创建对象的格式为:

对象名=类名()

创建对象demo:

#定义类

classCar:

#移动

defmove(self):

print('车在奔跑...')

#鸣笛

deftoot(self):

print("车在鸣笛...嘟嘟..")

#创建一个对象,并用变量BMW来保存它的引用

BMW = Car()

BMW.color ='黑色'

BMW.wheelNum =4#轮子数量

BMW.move()

BMW.toot()

print(BMW.color)

print(BMW.wheelNum)

总结:

·BMW = Car(),这样就产生了一个Car的实例对象,此时也可以通过实例对象BMW来访问属性或者方法

·第一次使用BMW.color

金沙官网线上,= '黑色'表示给BMW这个对象添加属性,如果后面再次出现BMW.color = xxx表示对属性进行修改

·BMW是一个对象,它拥有属性(数据)和方法(函数)

·当创建一个对象时,就是用一个模子,来制造一个实物

1.5__init__()方法

在创建对象的时候,直接设置对象的属性。

1.5.1使用方式

def类名:

#初始化函数,用来完成一些默认的设定

def__init__():

pass

1.5.2__init__()方法的调用

#定义汽车类

classCar:

def__init__(self):

self.wheelNum =4

self.color ='蓝色'

defmove(self):

print('车在跑,目标:夏威夷')

#创建对象

BMW = Car()

print('车的颜色为:%s'%BMW.color)

print('车轮胎数量为:%d'%BMW.wheelNum)

1.5.3总结1

当创建Car对象后,在没有调用__init__()方法的前提下,BMW就默认拥有了2个属性wheelNum和color,原因是__init__()方法是在创建对象后,就立刻被默认调用了

调用__init__()方法时传参:

#定义汽车类

classCar:

def__init__(self, newWheelNum, newColor):

self.wheelNum = newWheelNum

self.color = newColor

defmove(self):

print('车在跑,目标:夏威夷')

#创建对象

BMW = Car(4,'green')

print('车的颜色为:%s'%BMW.color)

print('车轮子数量为:%d'%BMW.wheelNum)

1.5.4总结2

·__init__()方法,在创建一个对象时默认被调用,不需要手动调用

·__init__(self)中,默认有1个参数名字为self,如果在创建对象时传递了2个实参,那么__init__(self)中出了self作为第一个形参外还需要2个形参,例如__init__(self,x,y)

·__init__(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递进去

1.6"魔法"方法

1.6.1打印id()

print(对象名)

1.6.2定义__str__()方法

classCar:

def__init__(self, newWheelNum, newColor):

self.wheelNum = newWheelNum

self.color = newColor

def__str__(self):

msg ="嘿。。。我的颜色是"+ self.color +"我有"+ int(self.wheelNum) +"个轮胎..."

returnmsg

defmove(self):

print('车在跑,目标:夏威夷')

BMW = Car(4,"白色")

print(BMW)

1.6.3总结

·在python中方法名如果是__xxxx__()的,那么就有特殊的功能,因此叫做“魔法”方法

·当使用print输出对象的时候,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据

·

1.7self

1.7.1理解self

示例:

#定义一个类

classAnimal:

#方法

def__init__(self, name):

self.name = name

defprintName(self):

print('名字为:%s'%self.name)

#定义一个函数

defmyPrint(animal):

animal.printName()

dog1 = Animal('西西')

myPrint(dog1)

dog2 = Animal('北北')

myPrint(dog2)

self表示是当前对象

1.7.2总结

·所谓的self,可以理解为自己

·可以把self当做C++中类里面的this指针一样理解,就是对象自身的意思

·某个对象调用其方法时,python解释器会把这个对象作为第一个参数传递给self,所以开发者只需要传递后面的参数即可

1.8保护对象的属性

如果有一个对象,当需要对其进行修改属性时,有2种方法

·对象名.属性名=数据---->直接修改

·对象名.方法名() ---->间接修改

为了更好的保存属性安全,即不能随意修改,一般的处理方式为

·将属性定义为私有属性

·添加一个可以调用的方法,供调用

classPeople(object):

def__init__(self, name):

self.__name = name

defgetName(self):

returnself.__name

defsetName(self, newName):

iflen(newName) >=5:

self.__name = newName

else:

print("error:名字长度需要大于或者等于5")

xiaoming = People("xx")

print(xiaoming.__name)

classPeople(object):

def__init__(self, name):

self.__name = name

defgetName(self):

returnself.__name

defsetName(self, newName):

iflen(newName) >=5:

self.__name = newName

else:

print("error:名字长度需要大于或者等于5")

xiaoming = People("xx")

xiaoming.setName("yy")

print(xiaoming.getName())

xiaoming.setName("lisi")

print(xiaoming.getName())

总结

·Python中没有像关键字来区别公有属性和私有属性

·它是以属性命名方式来区分,如果在属性名前面加了2个下划线'__',则表明该属性是私有属性,否则为公有属性(方法也是一样,方法名前面加了2个下划线的话表示该方法是私有的,否则为公有的)。

1.9__del__()方法

创建对象后,python解释器默认调用__init__()方法;

当删除一个对象时,python解释器也会默认调用一个方法,这个方法为__del__()方法

importtime

classAnimal(object):

#初始化方法

#创建完对象后会自动被调用

def__init__(self, name):

print('__init__方法被调用')

self.__name = name

#析构方法

#当对象被删除时,会自动被调用

def__del__(self):

print("__del__方法被调用")

print("%s对象马上被干掉了..."%self.__name)

#创建对象

dog = Animal("哈皮狗")

#删除对象

deldog

cat = Animal("波斯猫")

cat2 = cat

cat3 = cat

print("---马上删除cat对象")

delcat

print("---马上删除cat2对象")

delcat2

print("---马上删除cat3对象")

delcat3

print("程序2秒钟后结束")

time.sleep(2)

总结

·当有1个变量保存了对象的引用时,此对象的引用计数就会加1

·当使用del删除变量指向的对象时,如果对象的引用计数不会1,比如3,那么此时只会让这个引用计数减1,即变为2,当再次调用del时,变为1,如果再调用1次del,此时会真的把对象进行删除,__del__会被调用

1.10继承介绍以及单继承

为什么要继承:

将共性的内容放在父类中,子类只需要关注自己特有的内容

1.10.1继承的概念

继承描述的是事物之间的所属关系。

1.10.2继承示例

#定义一个父类,如下:

classCat(object):

def__init__(self, name, color="白色"):

self.name = name

self.color = color

defrun(self):

print("%s--在跑"%self.name)

#定义一个子类,继承Cat类如下:

classBosi(Cat):

defsetNewName(self, newName):

self.name = newName

defeat(self):

print("%s--在吃"%self.name)

bs = Bosi("印度猫")

print('bs的名字为:%s'%bs.name)

print('bs的颜色为:%s'%bs.color)

bs.eat()

bs.setNewName('波斯')

bs.run()

说明:

·虽然子类没有定义__init__方法,但是父类有,所以在子类继承父类的时候这个方法就被继承了,所以只要创建Bosi的对象,就默认执行了那个继承过来的__init__方法

总结

·子类在继承的时候,在定义类时,小括号()中为父类的名字

·父类的属性、方法,会被继承给子类

1.10.3注意点

classAnimal(object):

def__init__(self, name='动物', color='白色'):

self.__name = name

self.color = color

def__test(self):

print(self.__name)

print(self.color)

deftest(self):

print(self.__name)

print(self.color)

classDog(Animal):

defdogTest1(self):

#print(self.__name) #不能访问到父类的私有属性

print(self.color)

defdogTest2(self):

#self.__test() #不能访问父类中的私有方法

self.test()

A = Animal()

#print(A.__name) #程序出现异常,不能访问私有属性

print(A.color)

#A.__test() #程序出现异常,不能访问私有方法

A.test()

print("------分割线-----")

D = Dog(name ="小花狗", color ="黄色")

D.dogTest1()

D.dogTest2()

总结

·私有的属性,不能通过对象直接访问,但是可以通过方法访问

·私有的方法,不能通过对象直接访问

·私有的属性、方法,不会被子类继承,也不能被访问

·一般情况下,私有的属性、方法都是不对外公布的,往往用来做内部的事情,起到安全的作用

1.11多继承

所谓多继承,即子类有多个父类,并且具有它们的特征

多继承的格式如下:

#定义一个父类

classA:

defprintA(self):

print('----A----')

#定义一个父类

classB:

defprintB(self):

print('----B----')

#定义一个子类,继承自A、B

classC(A,B):

defprintC(self):

print('----C----')

obj_C = C()

obj_C.printA()

obj_C.printB()

运行结果:

----A----

----B----

说明

·python中是可以多继承的,在java中叫接口

·父类中的方法、属性,子类会继承

1.12重写/覆盖父类方法与调用父类方法

1.12.1重写父类方法

所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法

#coding=utf-8

本文由金沙官网线上发布于编程,转载请注明出处:面向对象:两手交换牌

您可能还会对下面的文章感兴趣: