28.面向对象

Python 面向对象

---

 

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

创建类

---

 

• 使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class A:
    '''
    变量：字符串，整形。。
    函数：方法    面向对象中的函数叫方法
    '''
    pass
#A() #一类相同事务属性的集合
a = A()
b = A()
c = A()

• 实例化： 

1. a = A()      * A：代表类        * a：代表实例
2. 同时也可以创建多个实例（a,b,c）
3. 大家要习惯性把类名定义首字母大写（建议）　

• 实例

class Grilfriend:
    _sex_ = 'woman'   #性别属性
    def cookie():     #定义函数
        print('我可以做饭')
g1 = Grilfriend()   #g1是实例 
print(g1)
g2 = Grilfriend()
print(g2)
g3 = Grilfriend()
print(g3)

运行结果：

E:\python学习资料\上课代码编写\代码练习py>python zhangan.py
<__main__.Grilfriend object at 0x00000000026EAA58>
<__main__.Grilfriend object at 0x00000000026EAB00>
<__main__.Grilfriend object at 0x00000000026EAB38>　　

封装__init__初始化函数：

• 封装：所谓封装就是相同的事物放到一起
  • 语法　　

        class Person:
        	def __init__(self): #数据初始化函数
        		self.name = //
        		self.age = //　　

• 面向对象属性

　　　　属性有两种：1.私有属性  2.公有属性

• 实例函数/方法

1.变量：数据类型

　　　　1 .私有变量：init:self 实例属性

　　　　　　* 只有实例可以访问

　　　　2 .公有变量：没有标注self，全局共享 类似C++的静态变量

　　　　　　* 类可以访问

　　　　　　* 实例可以访问

　　　　　　* 实例之间共享

class Grilfriend:
    _sex_ = 'woman'    #公有变量
    def __init__(self,name):  
        self.name = name    #私有变量
g1 =  Grilfriend('小明')
g2 =  Grilfriend('小莫')
print(g1._sex_)
print(g2._sex_)
print(Grilfriend._sex_)
print('--------------------------------------')
Grilfriend._sex_ = 'man'  #对公有变量进行修改，
print(g1._sex_)
print(g2._sex_)
print('----------------------------------------')
print(g1.name)             #私有变量的值
print(g2.name)             #私有变量的值

运行结果：

　E:\python学习资料\上课代码编写\代码练习py>python zhangan.py
　woman
　woman
　woman
　--------------------------------------
　man
　man
　----------------------------------------
　小明
　小莫

2.函数：方法，可以做的事情

　　　　1. 实例的方法、私有方法：

　　　　　　* 只要带self的，都是私有函数

　　　　　　* 实例的方法可以通过self访问到当前的私有属性

　　　　　　* **在实例函数中，对于私有变量的访问要记得加self**

3.self：用来指向当前初始化好的实例

class Grilfriend:
    def __init__(self,name):  #self：用来指向当前初始化好的实例 
        self.name = name　　　　#觉得的私有变量
g1 = Grilfriend('小红')
print('我的名字叫',g1.name)
g2 = Grilfriend('小李')
print('我的名字叫',g2.name)

运行结果：

　我的名字叫 小红
　我的名字叫 小李

4._init_：

　　　　* 实例化的过程中自动调用 

　　　　* 专门为实例创建私有变量

class Grilfriend:
    def __init__(self):     #定义函数
        print('我是_init_')
g1 = Grilfriend()

运行结果：

我是_init_

5.例外一种创建私有变量：当实例创建好之后再去赋值，一下是两种方法做对比：

1.

class Grilfriend:
    _sex_ = 'woman'    #公有变量
    def __init__(self,name):  
        self.name = name    #私有变量
g1 =  Grilfriend('小明')
g2 =  Grilfriend('小莫')
g1.age = 16
g2.age = 18
print(g1.age)
print(g2.age)

运行结果：

16
18

2.　　

class Grilfriend:
    _sex_ = 'woman'    #公有变量
    def __init__(self,name,age):  
        self.name = name    #私有变量
        self.age = age
g1 =  Grilfriend('小明',16)
g2 =  Grilfriend('小莫',18)
print(g1.age)
print(g2.age)

运行结果：

16
18 

　　

• 类的函数/方法

　　　　1. 类的最普通函数：

　　　　　　* 不带有任何参数的，最垃圾函数

　　　　　　* 可以被类访问，但是无法被实例访问

class A:
    def func():
        print('hello')
A.func()

运行结果：
hello

　　　　2.类的函数：classmethod

　　　　　　* 可以被实例访问 

　　　　　　* 需要有一个cls指针 

　　　　　　* cls指向当前类 

　　　　　　* cls可以访问当前类变量：共有变量

class A:
    log = '我是个log'
    log1 = '我是个log1'
    def func():　　　　#可以被类访问，但是无法被实例访问，无法调用类的变量
        print('hello')
    @classmethod   　　　　　　#
    def class_func(cls):    #cls代表当前类，指向当前类，可以调用类的变量
        print(cls.log)
        print(cls.log1)
a = A()
a.class_func()  # 可以被实例访问
A.func()
A.class_func()

运行结果：
我是个log
我是个log1
hello
我是个log
我是个log1

　　　　3.类的普通/静态函数：staticmethod

　　　　　　* 可以被实例访问

　　　　　　* 保护类中变量,无法访问类中变量

class A:
    @staticmethod  #保护类中变量
    def static_func(a,b):   #不可以调用类的变量，但是可以被实例访问
        print(a+b)
a = A()
a.static_func(1,2)

运行结果：
3

　　　　4.　把函数升级为属性

　　　　　　*可以被实例访问

class A:
	@property #把函数升级为属性
	def is_Login(self):
		return False
a = A()
print(a.is_Login)

　　总体实例函数练习如下：

总1：

class  Computer:
    log = 'les\'s'    #公有变量
    def __init__(self,img):
        self.img = img
g1 = Computer('猎豹壁纸')
g2 = Computer('老虎壁纸')
print('%s is %s' % (g1.log,g1.img))
print('%s is %s' % (g2.log,g2.img))
Computer.log= 'zhangn\'s'     #类的公有变量修改
g1.img = '毒液壁纸'       #私有变量修改
print('------------------------------------------')  
print('%s is %s' % (g1.log,g1.img))
print('%s is %s' % (g2.log,g2.img))
g1.log = 'wang\'s' #只要通过实例赋值变量语句，都会使这个变量升级成私有变量（g1的私有变量）
print('-----------------------------------------')
print('%s is %s' % (g1.log,g1.img))
print('%s is %s' % (g2.log,g2.img))

运行结果：

E:\python学习资料\上课代码编写\代码练习py>python zhangan.py
les's is 猎豹壁纸
les's is 老虎壁纸
------------------------------------------
zhangn's is 毒液壁纸
zhangn's is 老虎壁纸
-----------------------------------------
wang's is 毒液壁纸
zhangn's is 老虎壁纸

总2：

class Gf:
    _sex_ = 'womam'
    def __init__(self,name,_sex_,age):
        self.name = name
        self.age = age
        self._sex_ = _sex_
    def speak(self):
#        print('我是%s,性别：%s,今年%s岁' % (self.name,a._sex_,self.age))
        return ('我是%s,性别：%s,今年%s岁' % (self.name,self._sex_,self.age))
a = Gf('晓明','woman,',20)
b = Gf('小小','man',21)
print(a.speak())     #Gf.speak(a)
print(b.speak())    #Gf.speak(b)

运行结果：

我是晓明,性别：woman,,今年20岁
我是小小,性别：man,今年21岁

总3：

class Computer:
	log = '我的电脑'
	def __init__(self,name): 
		'''
			创建实例的变量
			在实例化时自动调用
		'''
		self.name = name
	def play(self):
		print("%s 正在玩耍" % (self.name))

	@classmethod
	def class_method(cls):
		cls.log = '更换招牌'
		print(cls.log)

	@staticmethod
	def static_method():
		a = 1
		print('123')

c1 = Computer('小红')
c2 = Computer('小明')
c1.play()
c1.class_method()
c1.static_method()
#实例: c1
#类：Computer

#属性
	#变量：
		#私有变量==裤衩变量 只有实例操作 == private
		#共有变量==全局共享 多个实例共享同一个变量
	#函数
		#self.func
		#classmethod：在类的函数中提供了访问类变量的指针cls
		#staticmethod：不提供任何访问类变量的权限

运行结果：

小红 正在玩耍
更换招牌
123