python：类1——类和对象基础

一、OO = Object Oriented 面向对象　　

OOP面向对象编程、OOA面向对象分析、OOD面向对象设计

二、属性+方法——>类（数据和函数）

class Turtle():   #类名约定用大写
    #属性
    color = 

    #方法
    def climb(self):
        pass
    def run(self):
        pass

tt = Turtle()    #创建对象
tt.run()    #调用

class Myclass(list):继承list
　　pass
list2 = Myclass()
list2.append(4)
list2.append(3)
list2.sort()

class A：
　　def fun(self):
　　　　print('I am A')
class B:
　　def fun(self):
　　　　print('I am B')
a = A()
b = B()
a.fun()
b.fun()#名字一样，打印不一样，就是多态

OOP三大特征：

封装：信息隐蔽技术

继承：子类自动共享父类之间数 据和方法的机制

多态：不同对象对同一方法响应不同的行动

三、self是什么？相当于c++的this指针！

由一个类可以生成无数个对象，当一个对象的方法被调用的时候，对象会把自身作为第一个参数传给self参数，Python就知道是哪个对象在调用方法了。例如：

class Ball():
    def setName(self, name):
        self.name = name
    def kick(self):
        print("我叫%s，谁踢我。。。" % self.name)

a = Ball()
a.setName('qiu A')
b = Ball()
b.setName('qiu B')
a.kick()
b.kick()　　　　#a对象和b对象个返回个的，正是因为self的帮助

　

四、Python的魔法方法（被双下滑线包围）

__init__(self)构造方法，用于实例化对象传入参数

上边两个例子没有显性声明构造方法，试用默认的无惨__init__()

#coding:utf8
class Ball:
        def __init__(self, name):
                self.name = name
        def kick(self):
                print("I am %s, 该死的，谁踢我" % self.name)

a = Ball('土豆')
a.kick()
c = Ball() #报错

五、公有和私有

公有变量可以通过点操作符访问

私有变量(名字改编"_类名__变量名"name mangling技术)只需在变量名或函数名前加上“__”两个下划线！此时点name或者点__name都不能访问到（报错），试用getName()

#coding:utf8
class Person:
        __name = "liyi"
        def getName(self):　　　　　　#通过方法访问
                return self.__name

p = Person()
#p.name　　报错
#p.__name　报错
p.getName()
p._Person__name  　　　　　　　　　　　 #会访问到liyi

 私有方法也是加两个下划线

python：类5——Python 的类的下划线命名有什么不同？

六、继承

1、如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性

#coding:utf8
class Parent:
        def hello(self):
                print('父类方法hello')
        def func(self):
                print('父类方法func')
class Child(Parent):
        def func(self):
                print('子类方法func，覆盖了父类方法')

p = Child()
p.hello()
p.func()


[root@CentOS6 ~]# python test.py 
父类方法hello
子类方法func，覆盖了父类方法

2、supper()方法

（技术一：调用未绑定的父类方法）调用父类的构造方法（父类点init方法，注意self参数），
　　　　　　　　　　　　　　　　此处的self不是分类的实例对象，而是子类Shark的实例对象，相当于Fish.__init__(Shark),因为被重写了。
（技术二：使用supper函数<更好>）：supper函数能自动找到需要的基类的方法，而且还会为我们自动传入self参数
　　　　　　　　　　　　　　　　supper().__init__()，不用给出基类的名字，会自动把所有父类、父父类的方法；所以修改基类名字时，不用一一修改

#coding:utf8
import random as r
class Fish:
def __init__(self):

                self.x = r.randint(0, 10)
                self.y = r.randint(0, 10)
        def move(self):
                self.x -= 1
                print("我的位置是:", self.x, self.y)

class Goldfish(Fish):
        pass
class Carp(Fish):
        pass
class Salmon(Fish):
        pass
class Shark(Fish):　　　　　　　　　　　　#定义鲨鱼，除了位置属性还要有个是否饥饿的属性
        def __init__(self):　　　　 　　#重写就会覆盖
　　　　　　　　  Fish.__init__(self)   #（技术一：调用未绑定的父类方法）
　　　　　　　　　　　　　　　　　　　　　　 （技术二：使用supper函数<更好>）
                self.hungry = True
        def eat(self):
                if self.hungry:
                        print("吃货的梦想就是天天有的吃")
                        self.hungry = False
                else:
                        print("太撑了，吃不下了")

g = Goldfish()
s = Shark()
s.eat()
g.move()

3、多重继承:会使语法混乱，尽量不用

class Base1:
    pass
class Base2:
    pass
class C(Base1, Base2):
    pass

七、组合类：把类的实例化放到新类里边（横向关系，继承是纵向关系）

#coding:utf8
把鱼类对象和乌龟类对象放到水池类中
class Turtle:
        def __init__(self, x):
                self.num = x
class Fish:
        def __init__(self, x):
                self.num = x
class Pool:
        def __init__(delf, x, y):　　#传入x个乌龟y个鱼
                self.turtle = Turtle(x)
                self.fish = Fish(y)
        def print_num(self):
                print("水池总共有乌龟%d只，小鱼%d条" % (self.turtle.num, self.fish.num)　　#这里self.turtle是不对的，必须是self.turtle.num

八、Mix-in机制（鱼c扩展）

pass

九、类、类对象、实例对象：是三个不同的东西！

#coding:utf8
class C:　　　 #类
        count = 0
a = C()
b = C()
a.count　　　　　#实例对象的count
C.count　　　　　#类对象的count
a.count = 10　　#a.count返回10  b.count返回0  C.count返回0
C.count = 100   #a.count返回10（因为上一步已经覆盖，看不到上一层） b.count返回100（未覆盖，看到上一层）  C.count返回100
对实例对象赋值后，会覆盖掉类对象，而看不到类对象

下边的会覆盖上边的！

十、属性和方法相同，属性会把方法覆盖掉！　　

　　属性名用名词，方法名用动词

---

扩展：Python绑定概念

Python严格要求方法需要有实例才能被调用，这种限制其实就是Python所谓的绑定概念。所以需要在方法定义时加上self

bb.__dict__查看实例所拥有的属性

BB.__dict__查看类所拥有的的属性，可以看到方法，会有好多东西，用来跟踪与类相关的值。实例对象会共用，但会被实例属性覆盖；以dict键值对返回

删除类对象后，实例对象（static静态的）依然存在在内存中，只有当程序退出时才会释放。