面向对象编程基础
面向对象技术简介
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- 局部变量：定义在方法中的变量，只作用于当前实例的类。
- 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
- 实例化：创建一个类的实例，类的具体对象。
- 方法：类中定义的函数。
- 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
1. 创建类 和 创建实例对象
这里主要用的
class关键字
格式是这种样子：
class Myclass：
'this a test class'
# do what you want
实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。
以下使用类的名称 Employee 来实例化，并通过 init 方法接收参数。
实例展示下更清晰：
class person:
'some body'
def __init__(self,name = 'nobody'):
self.name = name
def movet(self):
print('i can move')
def eat(self):
print('i can eat')
someone = person()
someone.movet()
someone.eat()
print(someone.__doc__)
thisone = person('zhaosi')
print(thisone.name)
结果:
i can move
i can eat
some body
zhaosi
通过
__doc__可以查看类的说明，方便你我他,self有点像this，但是可以叫别的名字，不叫self也行
2. 访问属性
使用
.来访问对象的属性。可以通过=来增加和改变属性，用del删除属性， 也可以通过函数来实现
getattr(obj, name[, default]): 访问对象的属性。hasattr(obj,name): 检查是否存在一个属性。setattr(obj,name,value): 设置一个属性。如果属性不存在，会创建一个新属性。delattr(obj, name): 删除属性。
实例:
class student:
'this a student class'
student_cnt = 0
def __init__(self, name ,age):
self.name = name
self.age = age
student.student_cnt += 1
def can_study(self):
print('we need study')
def who_you_are(self):
print('i am ',self.name,', i am ', self.age, 'years young')
zhangsan = student('zhangsan',10)
lisi = student('lisi',12)
zhangsan.who_you_are()
lisi.who_you_are()
zhangsan.age = 13
zhangsan.who_you_are()
zhangsan.high = 130
print(zhangsan.high)
del zhangsan.high
print(hasattr(zhangsan,'high'))
print(getattr(lisi, 'name'))
setattr(lisi, 'high',120)
print(lisi.high)
delattr(lisi,'high')
print(hasattr(lisi,'high'))
结果：
i am zhangsan , i am 10 years young
i am lisi , i am 12 years young
i am zhangsan , i am 13 years young
130
False
lisi
120
False
这个还是比较牛逼的，类似可以增加，删除成员变量。66666
3. Python内置类属性
就是天生就有的，主要是标识一些信息
__dict__: 类的属性（包含一个字典，由类的数据属性组成）__doc__:类的文档字符串__name__: 类名__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__等于mymod）__bases__: 类的所有父类构成元素（包含了一个由所有父类组成的元组）
打印出来看一眼就知道了：
class testiner:
'this is test a __doc__'
def __init__(self):
pass
def i_have_a_pen(self):
print('i_have_a_pen')
def i_have_an_apple(self):
print('i_have_an_apple')
test = testiner
print(test.__dict__)
print(test.__doc__)
print(test.__name__)
print(test.__module__)
print(test.__bases__)
{'__module__': '__main__', '__doc__': 'this is test a __doc__', '__init__': <function testiner.__init__ at 0x000001E272BD58C8>, 'i_have_a_pen': <function testiner.i_have_a_pen at 0x000001E272BD5BF8>, 'i_have_an_apple': <function testiner.i_have_an_apple at 0x000001E272BD5840>, '__dict__': <attribute '__dict__' of 'testiner' objects>, '__weakref__': <attribute '__weakref__' of 'testiner' objects>}
this is test a __doc__
testiner
__main__
(<class 'object'>,)
方便了解一个类
4. python对象销毁(垃圾回收)
Python 使用了引用计数这一简单技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量，称为一个引用计数器。
当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
就是你不用了他就会回收，不用想着要不要释放内存了，开心不
5. 继承 与 多继承
是面向对象就得有继承，然后还有多继承，像合金得感觉
大概是这个样子：
继承:
class cat (animal):
'this is one '
多继承:
class taiji(taidi,keji):
'泰迪和柯基出泰基'
实例：
class person:
'i am a person'
def __init__(self,name,age):
self.name = name
self.age = age
def say(self):
print('i am ',self.name, ' , i am ', self.age, 'years young')
class student(person):
'i am a student'
def __init__(self,name,age,high):
person.__init__(self,name,age)
self.high = high
def say(self):
print('i am student ,i am ', self.high, 'cm')
class speak:
'test a speak'
def __init__(self,who,what):
self.who = who
self.who = what
def say(self):
print('test say')
class test(speak,student):
'test'
def __init__(self,who,what,name, age, high):
speak.__init__(self, who,what)
student.__init__(self, name,age,high)
test1 = test('xiaoming','duojicheng','xiaoming',12,120)
test1.say()
结果:
test say
大家都会
say，从左边先说
6. 重写
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：
class parent:
def say(self):
print('I think i can fly')
class son(parent):
def say(self):
print('no , you cant')
p = parent()
p.say()
s = son()
s.say()
super(son,s).say()
结果：
I think i can fly
no , you cant
I think i can fly
7.类的私有方法
在你得方法前面加
__就行了，例如
class test：
def __you_cant_see(self):
pass
8. 运算符重载
Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下:
class relaod:
'test str'
def __init__(self,testadd):
self.testadd = testadd
def __str__(self):
return ('this a new str')
def __add__(self, other):
return self.testadd + 2*other.testadd
class old:
'和上面对比用'
def say(self):
pass
a = relaod(10)
c = relaod(100)
print('a+c: ', a+c)
print('test a :', a)
b = old()
print('test b :', b)
结果：
a+c: 210
test a : this a new str
test b : <__main__.old object at 0x000001BC0721B5F8>
这个是显示展示，主要还是可以重写运算符来方便运算，省的每次都写很长
文集传送门 学习python100天
整个学习python100天的目录传送门
无敌分割线
再最后面附上大神的链接 传送门
