python学习-面向对象
面向对象
编程方式的区别
-
过程式编程
-
函数式编程
-
面向对象式编程
面向对象编程
对象是类的一个实例
- 创建
class foo():
def __init__(self): #类的构造方法
pass
def doing(self): #类的其他自定义方法
pass
- 实例化
#根据我们创建的类来实例化一个对象
obj_foo = foo() #实例化了一个对象,所以称对象是类的一个实例化
- 类的方法调用
obj_foo.doing()
- 构造方法
__init__
,会在对象创建的过程中被自动执行
class foo():
def __init__(self,name,age):
self.name = name
self.age = age
def doing(self): #类的其他自定义方法
pass
def speak(self):
print("My name is %s" %(self.name))
obj_foo = foo(“ Leon”,22)
obj_foo.speak()
>>>My name is Leon
- 析构方法
__del__
会在当对象在内存中被释放时,自动触发执行
三大特性之-封装
- 构造方法:
__init__(self,*args,**kwargs)
来接受类实例化过程的中封装传入的参数。构造完成后,每个类的实例都具有这样的的属性,属性的值确定要根据类的实例化过程传入的参数来确定
class foo(object):
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def talk(self):
print("My name is {name},{age} years old!".format(name=self.name,age=self.age))
def detail(self):
print(self.name)
print(self.age)
print(self.sex)
- 对象实例化,调用类对对象进行实例化,实例化完成后,传入以下参数,那么这个
obj_1
就会具有对应的属性 - 实例化过程中会自动执行对象的构造方法
__init__
进行封装
obj_1 = foo("forsaken",22,"man")
- 对象实例化完成后,就可以调用被封装的内容
- 通过对象直接调用
print(obj_1.name)
print(obj_1.age)
print(obj_1.sex)
- 通过类中的方法使用self调用,此处为detail
- 类中的几种属性
- 私有属性
- 公有属性
- 成员属性
class Role(object):
#定义公有属性
international_organization = "WTO"
def __init__(self,name,role,weapon,life_value=100,money=15000):
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.money = money
self.__heart = "healthy" #私有属性
def buy_gun(self, gun_name):
print(" %s has just bought % s" % (self.name, gun_name) )
#修改成员属性
self.weapon = gun_name
def got_shot(self):
print("ohh... I got shot...")
self.__heart = "Died" #私有属性只能在内部使用
print(self.__heart)
def shot(self):
print("%s is shooting.."%self.name)
def get_heart(self):
return self.__heart
1.成员属性,即__init__
方法中定义的属性
r1 = Role("Leon","FBI","ak-47")
print(r1.weapon)
>>>ak-47
r1.buy_gun("ak-68")
>>>Leon has just bought ak-68
print(r1.weapon)
>>>ak-68
2.私有属性__private_attr_name = value
通过这种方式定义,只能在内部访问
r1 = Role("Leon","FBI","ak-47")
r1.got_shot()
>>>ohh... I got shot...
>>>Died
2.1. 但是强制在外部访问的方式如下,但是不能更改,_类名__private_attr_name
print(r1._Role__heart)
2.2. 或者通过自己写的方法来return访问获取,如本例子中get_heart
方法
print(r1.get_heart())
3.公有属性,需要在类中直接定义的属性即是公有属性,如本例中的international_organization
3.1. 属于本类的对象的实例都可以访问的属性称为公有属性
3.2. 实例化的两个对象都有这个international_organization属性
r2 = Role("Leon","police","shouqiang")
print(r1.international_organization)
>>>WTO
print(r2.international_organization)
>>>WTO
3.3. 程序运行,即使类没有实例化,该类的公有属性也被存放在了内存中,如下
print(Role.international_organization)
>>>WTO
3.4. 修改公有属性
3.4.1. 直接修改
Role.international_organization = "wwc" #这样修改后类的实例都会更改
print(r1.international_organization)
>>>wwc
print(r2.international_organization)
>>>wwc
3.4.2. 通过实例修改,会在内存中的对象的对应地方创建一个international_organization
字段来存新的值,而不会更改公有属性的值
r1.international_organization = "NBA" #修改r1的值,不会更改r2的,应为r2还是使用共有中定义的
print(r1.international_organization)
>>>NBA
print(r2.international_organization)
>>>wwc
备注
寻找当前类实例的共有变量,会首先寻找该实例内存中是否有,如果没有再去共有属性中寻找
通过实例修改r1.international_organization = "NBA"
,不会更改原有的公有属性,会在当前实例的队形内存中创建该变量,以便于下次使用
在内存中的解释为,即通过这种方式修改不会访问该变量的引用,而是修改了就会自己在保存一份
跟函数中的局部变量和全局变量的性质一样
4.类中的方法公有,只有一份共享
而类中的各种方法,都是共享的,实例化后不会重新创建某个方法
如果非要将方法私有化,可以使用下面的方法
将shut方法变成私有的方法
def shou4(self):
print("run shot in my own method",self.name)
r1.shot = shou4
r1.shot(r1)
r2.shot()
三大特性之-继承
class f1(object):
def show(self):
print("show")
class f2(f1):
def bar(self):
print("bar")
-
f2中并没有show方法,但是当 f2(f1)写了以后,就代表f2继承f1的方法,f1为f2的父类,f2为f1的子类
-
创建子类对象,但是可以执行父类f1中的方法
_obj_f2 = f2()
_obj_f2.show()
- python中的类可以有很多个父类
静态方法-类方法-属性方法
class Person(object):
name = "Rain"
def __init__(self,name):
self.name = name
self.__mes = None
@staticmethod
def eat(name,food): #静态方法即不能访问公有属性,也不能访问实例,只是相当于一个单纯的函数,跟类没有什么关系,但是需要类名来调用
#不能使用实例的属性
#不需要self
#类似于台湾 中国台湾
#类似于该类的一个工具包
print("%s is eating..%s." % (name,food))
@classmethod
def walk(self): #类方法 只能访问类的公有属性, 不能访问实例属性
#类方法可以用于类中的公有属性与成员变量相同时,强制访问公有属性
print("%s is walking..."%self.name) #此时的name仍然是公有属性的值
@property #属性方法, 的作用是把一个方法变成一个静态属性
def talk(self):
#使用@property后,该方法变成一个静态属性,不能加括号进行调用,如果调用会NoneType xception
print("%s says " %(self.name))
@talk.setter #通过这种方式为这个静态属性赋值,就可以传入参数
def talk(self, msg):
print("old msg:", self.__mes)
self.__mes = msg #这样就实现了修改
print("set msg:", msg)
print("set msg:", self.__mes)
@talk.deleter #正常类的属性,实例的实行可以被删除
#那么使用这样的方式来删除属性方法
def talk(self):
del self.__mes #删除了就不能再使用了
print("delet talk...")
p1 = Person("leon")
p1.talk #>>leon says
p1.talk = "set static attr" #调用talk来实现talk的静态属性赋值
del p1.talk
类的特殊成员方法
1.__module__
和__class__
class C:
def __init__(self):
self.name = 'wupeiqi'
from lib import C
obj = C()
print(obj.__module__)
# 输出 lib即:输出模块
print(obj.__class__)
#<class 'lib.C'>
2.__call__
对象后面加括号,触发执行,区别于__init__
- 构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 call 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print
'__call__'
obj = Foo() # 执行 __init__
obj() # 执行 __call__
3.__dict__
查看类或对象中的所有成员
class Province:
country = 'China'
def __init__(self, name, count):
self.name = name
self.count = count
def func(self, *args, **kwargs):
print('func')
# 获取类的成员,即:公有属性、方法
print(Province.__dict__)
#获取 对象obj1 的成员属性
obj1 = Province('HeBei',10000)
print(obj1.__dict__)
4.__str__
如果一个类中定义了__str__
方法,那么在打印对象时,默认输出该方法的返回值
class Foo:
# def __str__(self):
# return 'Leon'
pass
obj = Foo()
print(obj)
#如果不定义__str__方法,那么返回该对象的内存地址<__main__.Foo object at 0x10d2c6dd8>
5.__getitem__
、__setitem__
、__delitem__
用于索引操作,如字典。分别表示获取、设置、删除数据
class Foo(object):
def __getitem__(self, key):
print('__getitem__', key)
def __setitem__(self, key, value):
print('__setitem__', key, value)
def __delitem__(self, key):
print('__delitem__', key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'alex' # 自动触发执行 __setitem__
del obj['k1']
6.__init__
和__del__
被称为构造方法
和析构方法
class SchoolMember(object):
member = 0
def __init__(self,name,age,sex): #构造方法在实例化的过程中运行
self.name = name
self.age = age
self.sex = sex
def __del__(self): #析构函数会在程序完成后吧每个对象的实例都删除
print("把[%s]开除了"%self.name)
SchoolMember.member -= 1