面向对象编程

面向对象编程
python面向对象编程
1.首先了解下什么是面向过程?什么面向对象?以及他们之间的区别。

  面向过程的核心就是过程, 面向过程就是分析出解决问题所需要的步骤，就像写函数中把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了,考虑的比较周

  面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为.

面向对象编程可以使程序的维护和扩展变的简单,从而大大的提升了程序开发的效率,面向对象的程序也能让别人更容易理解你的编程逻辑,利于团队开发.
2.面向对象概念

研究面向对象就要了解一些名词: 类,对象,实例,实例化 简单就是要知道类和对象的关系!!!

首先说明在python中万物皆对象,类型的本质就是类.

1.什么是类呢?类是怎么定义呢?

 具有相同属性和方法的一类事物,描述一类事物轮廓的一个机制,当然描述的的比较抽象.例如商品,店铺,用户....都是类

类的定义如下:

class People: # class 类名:就定义了一个类 ,当然类名的首字母必须大写,如果由多个单词组成,使用大驼峰写法即可,一般不推荐使用下划线
　　pass
print (People)

输出<class ‘main.Person’> 这里的People就是一个类

2.什么是对象呢?

具体来说对象就是类的实例化,是类的一个具体表现和例子(拥有具体的属性和具体的方法)

我们可以用代码展现如下:
复制代码

class People:
pass
Sheldon = People() # 对象 = 类名()
Penny = People() # Sheldon,Penny 就是对象,也是实例
print(Sheldon)
print(Penny)

输出: <main.People object at 0x00000000027BC940> #main 文件 object 对象
<main.People object at 0x00000000027BCA20> # Sheldon,Penny 都是People类的对象,但他们表示两个不同的对象,拥有自己的内存地址
复制代码

什么是实例?

通过上述代码来看对象就是就是实例.

再看看什么是实例化过程?

1.创建一个属于对象的空间.    对象名 = 类名(参数)

2.把这个空间地址和参数传递给init第一个参数self,,执行__init__方法

3.再把对象空间地址作为返回值返回给对象名    因此self ==对象变量

这3个步骤就展现了类–实例化–>对象/实例 类创建了对象过程也就是实例化的过程.
复制代码

class People:
def init(self,name,sex,hp,ad): #语法 init 本身存在的内置方法,self是一块内存空间
　　　　　　self.name = name #name,sex,hp,ad都是对象属性
　　　　　　self.sex = sex
　　　　　　self.hp = hp
　　　　　　self.ad = ad

Sheldon = People(‘sheldon’,male,10,10) #括号内参数传递给People类并且让Sheldon拥有了参数内的属性
#类名()相当于执行类中的__init__方法
Penny = People(‘penny’, ‘girl’, 999, 998)

print(Penny.sex) # 输出girl sex就是Penny的属性
print(Sheldon.name) # 输出sheldon name就是Sheldon的属性
print(Sheldon.sex) # 输出 male
print(Sheldon.hp) #输出 10

整个过程就是 People类 创建 Sheldon对象的过程!!!

复制代码

什么是对象属性?

 通过上述实例化的过程中得出,存储在实例化后创建的空间中所有的变量都是对象属性,也就是每一次实例化产生的空间都是独立的,每个对象都有自己属性值.

对象有什么作用呢?

1.调用对象属性

2.调用类中的方法(动态属性)

3.类有什么作用呢?

1.实例化对象 对象 = 类名()

2.查看类中的属性类名.(静态属性/类属性)属性名

复制代码

class People: #类
COUNTRY = ‘US’ #静态属性/类属性 所有属于这个类的对象都共同的属性
def init(self, name, sex, hp, ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
Sheldon = People(‘sheldon’,‘male’,10,10) #实例化对象
print(People.COUNTRY) #输出US

复制代码

如何调用类中方法呢?

请查看以下代码:
复制代码

class People:
COUNTRY = ‘US’
def init(self, name, sex, hp, ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self): #一个函数,在类中定义的常规的函数都是方法,自带self参数
print(’%s发起了攻击’%self.name)
Sheldon = People(‘sheldon’,‘male’,10,10) #实例化对象
#如何调用attack的方法呢?
Sheldon.attack() #一般使用这种方法
People.attack(Sheldon)
#输出: sheldon发起了攻击
#输出 sheldon发起了攻击

复制代码

3.针对对象属性的增,删,改,查

以下代码具体表现:
复制代码

class People:
COUNTRY = ‘US’
def init(self, name, sex, hp, ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
Sheldon = People(‘sheldon’,‘male’,10,10)
#查看对象属性
print(Sheldon.hp) # 10

#修改属性的值?如何修改?
Sheldon.hp = 60
print(Sheldon.hp) # 修改后变成 60
#如何给对象添加属性?
Sheldon.level = 1
print(Sheldon.level) #创建了一个属性 level 值为1
#删除属性的值
del Sheldon.level
print(Sheldon.level)

删除后报错,没有level属性了 AttributeError: ‘People’ object has no attribute ‘level’

#扩展
print(Sheldon.dict) #查看 Sheldon 所有的属性
Sheldon.dict[‘name’] = ‘Sheldon_007’
print(Sheldon.name) #通过字典更改 Sheldon 的 name 但一般不常用.

复制代码

查看代码后有没有发现对象属性的操作十分方便呢?那是当然的!

4.类的交互
复制代码

#人类
class People:
COUNTRY = ‘US’
def init(self, name, sex, hp, ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self,giant): #攻击方法 Sheldon攻击对象为giant 参数写在self后面
print(’%s发起了攻击了%s’%(self.name,giant.name)) #sheldon发起了攻击了giant
giant.hp -= Sheldon.ad #攻击后巨人的血量 = Sheldon的攻击力 - 巨人的血量
print(’%s的HP剩余%s’ % (giant.name, giant.hp)) #giant的HP剩余90
#怪兽类
class Monster:
def init(self,name,kind,hp,ad):
self.name = name
self.kind = kind
self.hp = hp
self.ad = ad
def bite(self,Sheldon): #撕咬方法 giant撕咬对象为Sheldon 参数同样写在self后面
print(’%s撕咬了%s’%(self.name,Sheldon.name)) #giant撕咬了sheldon
Sheldon.hp -= giant.ad #撕咬后后Sheldon的血量 = 巨人的攻击力 - Sheldon的血量
print(’%s的HP剩余%s’%(Sheldon.name,Sheldon.hp)) #sheldon的HP剩余80
#实例化一些对象
giant = Monster(‘giant’,‘big’,100,20)
Sheldon = People(‘sheldon’,‘male’,100,10)

Sheldon.attack(giant) #Sheldon对象调用方法(动态属性)进行攻击
giant.bite(Sheldon) #gaint对象调用方法(动态属性)进行撕咬

#通过两个类或多个类的交互可以让对象调用方法(动态属性)产生相应的动作,实现最终的效果,还是非常有意思的.

复制代码

5.类的结构解析
复制代码

class A:
Country = ‘China’
def eat(self):
print(’%s is eatting’%self.name) # Mary is eatting
Mary = A()
Mary.name = ‘Mary’
Mary.eat()

上述代码证明一个类可以没有__init__用法

复制代码

1.那么在没有__init__的情况下,实例化经历了哪些过程?

总结来说:1,创建一个空间给对象
2.将这个空间地址返回

2.类中的代码是执行情况?

class A:
Country = ‘China’
def init(self,name):
self.name = name
def eat(self):
print(’%s is eatting’%self.name)

查看上述代码得出是在实例化之前执行的

3.静态属性能操作吗?

复制代码

class A:
Country = ‘China’

A.Country = ‘印度’
print(A.Country) # 印度 已经修改静态属性

del A.Country
print(A.Country) # 报错 AttributeError: type object ‘A’ has no attribute ‘Country’

print(A.dict) # 只能看,不能改也不能删

复制代码

上述代码告诉我们 静态属性可以进行修改和删除

同理: 静态属性也可以新增 : A.静态属性名 =‘US’

看着是不很神奇呀,我也觉得很有趣._

6.类的命名空间和对象命名空间

1.类的命名空间有什么?

静态属性和动态属性(方法)

2.对象命名空间和类命名空间的关系

1.对象和类之间有一个单向的联系,类对象指针

2.对象在使用某个名字的时候,如果在自己空间里没有找到,就到类的空间去找

以下代码详解:
复制代码

class A:
Country = ‘China’
def init(self,name):
self.name = name
def eat(self):
print(’%s is eatting’%self.name)

Mary = A(‘Mary’) #在实例化的过程中,开辟了一块属于对象的空间
Jack = A(‘Jack’)
print(Mary.Country) # China Mary的类指针指向类的空间里的Country,自己没有东西

Mary.Country = ‘US’ # Mary在自己空间创建了一个Country =‘US’,并没有改变类空间的Country,只是不再指向类空间Country
print(Mary.Country) # US

print(Jack.Country) # Jack的空间没有东西,所以类指针指向 类 的空间里的Country.

del Mary.Country
print(Mary.Country) # Mary删除掉自己空间创建了一个Country =‘US’,发现自己没有东西后,类指针再次指向类空间的Country

复制代码

总结:1.对象可以查看类的静态属性,但尽量不要修改,否则就取不到类中的内容

    2.所有的静态属性修改都应该由类名完成,而不是使用对象名来完成.

3.静态属性就是来描述所有对象共享的某一个值
复制代码

class People:
Money = 1000 #某个对象尽量不要改变类的静态变量,你并不知道其他对象是否在使用这个值.
def salary(self):
People.Money += 1000

Mary = People()
Jack = People()
Mary.salary() #调用salary方法实现对静态变量的值进行改变,而不是直接对类空间的静态变量改变
Jack.salary()
print(People.Money,Mary.Money,Jack.Money)

复制代码

4.静态变量形态
复制代码

class B:
l = [] #可变数据类型 容器
def init(self,name):
self.l.append(name)

Mary = B(‘Mary’)
Jack = B(‘Jack’)
print(B.l) #[‘Mary’, ‘Jack’]
print(Mary.l) #[‘Mary’, ‘Jack’]
print(Jack.l) #[‘Mary’, ‘Jack’]

复制代码

大总结:

1.如果静态变量是一个不可变数据类型,那么只要对象修改这个数据,就相当于在对象的空间中新建
2.如果静态变量是一个可变数据类型,那么对象修改这个容器中的元素,相当于修改类的空间中的元素
3.如果静态变量是一个可变数据类型,那么对象直接对这个变量重新赋值,相当于修改对象自己空间中的元素

谨记:只要是静态变量,就用类名来操作静态属性,静态变量修改后,并且所有的对象都共享这个改变

7.类的组合

什么是组合?

一个类对象的属性是另外一个类的对象

代码描述1:

复制代码

class People:
def init(self,name,sex,hp,ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self,dog):
print(’%s攻击了%s’%(self.name,dog.name))
dog.hp -= self.ad

class Monster:
def init(self,name,kind,hp,ad):
self.name = name
self.kind = kind
self.hp = hp
self.ad = ad
def bite(self,people):
print(’%s嘶咬了%s’%(self.name,Sheldon.name))
Sheldon.hp -= self.ad

Sheldon = People(‘Sheldon’,‘25’,100,20)
giant = Monster(‘giant’,‘big’,100,30)
giant.bite(Sheldon)

武器装备 增加人的攻击力ad

武器类 :

class Weapon:
def init(self,name,price,ad):
self.name = name
self.price = price
self.ad = ad
def skill(self,giant):
print(’%s被%s攻击了’%(giant.name,self.name))
giant.hp -= self.ad

sword = Weapon(‘无影剑’,9.99,66)

sword.skill(giant) # sword 本身不能攻击

Sheldon.weapon = sword # 组合 是People类的对象属性是Sheldon 是 Weapon类的对象

什么是组合 : 一个类对象的属性是另外一个类的对象

Sheldon.weapon.skill(giant) # 组合的应用
sword.ad -= 10
Sheldon.weapon.skill(giant)

复制代码

代码展现:

复制代码

class Date:
def init(self,year,month,day):
self.year = year
self.month = month
self.day = day

class Student:
def init(self,name,sex,birthday):
self.name = name
self.sex = sex
self.birthday = birthday

birth = Date(1993,1,16)
feifei = Student(‘feifei’,‘male’,birth)

feifei.birthday = birth #Student类,对象属性feifei 是Date类中的对象

print(feifei.birthday.year)

复制代码

代码展现:

复制代码

#环形类
#实例化 接收参数 :大圆半径 小圆半径
#有两个对应的方法:计算环形周长,环形的面积

from math import pi
class Circle:
def init(self,r):
self.r = r

def area(self):
    return pi*self.r**2

def perimeter(self):
    return 2*pi*self.r

c1 = Circle(10)
print(c1.area())
print(c1.perimeter())

class Ring:
def init(self,outer_r,inner_r):
c1 = Circle(outer_r)
c2 = Circle(inner_r)
self.out_c = c1 # c1.area() self.out_c.area()
self.in_c = c2 # c2.area() self.in_c.area()

def area(self):
    return self.out_c.area() - self.in_c.area()

def perimeter(self):
    return self.out_c.perimeter() + self.in_c.perimeter()

r1 = Ring(10,5)
print(r1.area())
print(r1.perimeter())