python之面向对象初识

一、什么是面向对象？

　　　　今天只是简单了解一下面向对象，那到底什么才是面向对象呢?

　　举个简单的例子，有个笑话说把大象放冰箱里分为几步，

　　　　正常人的思维都是，第一步将冰箱门打开，第二部把大象放入冰箱里，第三部关上冰箱门。这整个的过程我们叫它面向过程

　　而在我们python中是怎样实现的呢？

　　

#面向过程
def func():
    print("打开冰箱门")
    print("将大象放入冰箱")
    print("关闭的冰箱门")
func()
# 打开冰箱门
# 将大象放入冰箱
# 关闭的冰箱门

　　　　现在我有个想法，就是想让大象自己打开冰箱门，自己进冰箱，自己在关上冰箱门，当然在现实生活中是不存在的，但是在python中我们可以实现，这个实现的过程我们就叫它面向对象

#面向对象
class Foo:
    def __init__(self,first,next,last):
        print(first)
        print(next)
        print(last)
obj = Foo("打开冰箱门","进入冰箱","关闭冰箱门")
# 打开冰箱门
# 进入冰箱
# 关闭冰箱门

　　面向对象和面向过程的区别

　　　　面向过程:就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

　　　　面向对象:把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

二、类与对象

 　　什么是类？什么是对象?

　　　　类在我们汉语言中的理解是有相同之处的事物，在python中我们也可以理解为将多种具有相同方法的的归类。

　　　　对象可以是一个动作也可以是一个抽象化的表达，总之万物皆为对象。

　　

class Foo:    
#  Foo就是一个类，将多个方法放入到Foo类中
    def func1(self):
    #func1方法，在类的里面我们称之为方法
        pass
    def func2(self):
        pass
obj = Foo
#obj就是一个对象，在详细一点obj是Foo类的一个对象，对象可以有多个。

三、面向对象的三大特性

　　封装:

　　　　封装就是将相关的功能封装到一个类中，将数据封装到一个对象中

　　

封装
class Foo:
    def __init__(self,name,age,localtion):
        self.name = name
        self.age = age
        self.localtion = localtion
obj = Foo("徐建",21,"鑫阳公寓")
print(obj.name)

　　继承:

　　　　为了方便提供代码的重用性

　　

继承
class Base(object):
    def func1(self):
        print("the first Base.method")
    def func2(self):
        print("the second Base.method")
class Foo(Base):
    def func1(self):
        print("the first Foo.method")
obj = Foo()
obj.func1()
obj.func2()

 　　　　多继承时采用的是C3算法

　　多态:

　　　　对象的多种姿态

 　　

多态
class Animal(object):
    def people(self):
        print("人")
    def pig(self):
        print("猪")
    def dog(self):
        print("狗")
obj = Animal()
obj.people()
obj.pig()
obj.dog()

四、面向对象中的成员与嵌套关系

　　面向对象的成员有三种:变量、方法、属性

　　　　变量:

　　

变量分为类变量与实例变量(字段)
class Foo:
    food = "食物"   # 类变量
    __food = "私有食物"  #私有类变量
    def __init__(self,name,__kg):
        self.name = name  #   字段
        self.__kg = __kg  #    私有字段
    def func1 (self) :
        print(self.__food)
        print(Foo.__food)    #私有类变量可以通过类直接使用
        print(self.__kg)
obj = Foo("汉堡",5)
obj.func1()

　　　　方法:

　　

方法分为实例方法、静态方法与类方法
class Foo(object):
    def func1(self):
        print("实例方法")
    @staticmethod
    def func2():
        print("静态方法")
    @classmethod
    def func3(cls):
        print("类方法")
obj = Foo()
obj.func1()
Foo.func2()    # 静态方法可以通过类直接使用
obj.func2()
Foo.func3()     # 类方法也可以通过类直接使用
obj.func3()

　　　　属性:

　　

属性可以通过类来直接使用，可以不被调用
class Foo:
    @property
    def func(self):
        return 1
obj = Foo()
print(obj.func)
print(Foo.func)      #内存地址
print(obj.func==1)

　　类的嵌套关系:

# 类的嵌套关系
class School(object):
    def __init__(self,localtion):
        self.localtion = localtion

bj = School("北京")
sh = School("上海")
sz = School("深圳")


class Course(object):
    def __init__(self,cname,term,school=None):
        self.cname = cname
        self.term = term
        self.school = school

linux = Course("linux运维","120天",bj)
python = Course("python全栈开发","150天",sz)
print(linux.school.localtion,linux.cname,linux.term)
# 运行结果 : 北京 linux运维 120天
print(python.school.localtion,python.cname,python.term)
# 运行结果 : 深圳 python全栈开发 150天

五、主动调用与特殊成员

 　　　主动调用:

　　　　　　即当我们需要使用一个没有实例化的对象的类中的方法我们可以使用主动调用来获取值。

　　

主动调用(方法1)
class Base(object):
    def f1(self):
        print("base.f1")
    def f2(self):
        print("base.f2")

class Foo(Base):
    def f1(self):
        print("Foo.f1")
obj = Foo()
obj.f1()
Base.f1(obj)   # 主动获取
主动调用(方法2)
class First:
    def f1(self):
        print("first.f1")
class Second:
    def f1(self):
        print("second.f1")
        super().f1()     # 按照类的继承顺序找下一个
        print("second.f1")

24 class order(Second,First):
25    pass
26 obj = order()
27 obj.f1()

　　类中的特殊成员:

　　　　特殊成员可以理解成当我们执行某些操作时在类的内部会自动执行相应的方法。

　　

 1 特殊成员
 2 class Foo(object):
 3 
 4     def __init__(self,a1,a2):
 5         self.a1 = a1
 6         self.a2 = a2
 7 
 8     def __call__(self, *args, **kwargs):
 9         print(args,kwargs)
10         #可以有返回值
11         return 1
12 
13     def __getitem__(self, item):
14         print(item)
15         #可以有返回值
16 
17     def __setitem__(self, key, value):
18         print(key,value)
19         #无返回值
20 
21     def __delitem__(self, key):
22         print("%s一颗子弹一人头" %key)
23 
24     def __add__(self, other):
25         print("进行加法运算")
26         return obj.a1+obj.a2
27 
28     def __enter__(self):
29         print("梦开始的地方")
30         #可以有返回值
31 
32     def __exit__(self, exc_type, exc_val, exc_tb):
33         print("梦结束了")
34     #有返回值
35 #  类名() 自动执行 __init__
36 obj = Foo(1,2)
37 
38 # 对象 () 自动执行 __call__
39 obj(1,2,3,5,6,7,kar="98k")
40 
41 # 对象[] 自动执行 __getitem__
42 obj["laoyer"]
43 
44 #对象[] = "" 自动执行 __setitem__
45 obj["kar"]="98k"
46 
47 # del 对象[]  自动执行 __delitem__
48 del obj["win94"]
49 
50 #对象+对象  自动执行  __add__
51 print(obj+obj)
52 
53 # with 对象
54 with obj:
55     print("不要梦中人")
56 
57         #  __enter__ 与 __exit__连用 有开始就要有结束
58 
59 
60 # 构造方法 __new__
61 class Foo :
62     def __init__(self,a1,a2):# 初始化对象
63         self.a1 = a1
64         self.a2 = a2
65         print("1")
66     def __new__(cls, *args, **kwargs):   # 创建一个空对象
67         print("2")      # 类后面加（）本质上执行是__new__， 然后执行__init__,如果没有设置返回值就执行不了__init__
68         return object.__new__(cls)  #返回一个在python内部创建的对象(内部为空)
69 Foo(1,2)
70 # 总结 __new__是构造方法，创建一个新对象，__init__是将对象初始化
71 #