面向对象编程基础

面向对象技术简介

• 类(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天的目录传送门

---

无敌分割线

---

再最后面附上大神的链接 传送门