day7 面向对象编程

编程范式

　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程

面向过程编程

　　面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改， 随着程序越来越大， 这种编程方式的维护难度会越来越高。 所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护的， 那还是用面向对象最方便了。

示例：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#面向过程编程

while True：

    if cpu利用率 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

 

    if 硬盘使用空间 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

 

    if 内存占用 > 80%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

函数式编程

　　将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

示例：

练习：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

#!/usr/bin/env python

# -*- coding:utf-8 -*-

#-Author-Lian

#函数式编程

def firewood(name, age, gender):

    print("%s,%s岁,%s,上山去砍柴" %(name, age, gender))

def drive(name, age, gender):

    print("%s,%s岁,%s,开车去东北" %(name, age, gender))

def dbj(name, age, gender):

    print("%s,%s岁,%s,最爱大保健" %(name, age, gender))

firewood(‘小明‘, 10, ‘男‘)

drive(‘小明‘, 10, ‘男‘)

dbj(‘小明‘, 10, ‘男‘)

#小明,10岁,男,上山去砍柴

#小明,10岁,男,开车去东北

#小明,10岁,男,最爱大保健

firewood(‘老李‘, 90, ‘男‘)

drive(‘老李‘, 90, ‘男‘)

dbj(‘老李‘, 90, ‘男‘)

#老李,90岁,男,上山去砍柴

#老李,90岁,男,开车去东北

#老李,90岁,男,最爱大保健

面向对象编程

1、类、对象、实例

　　OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

示例：

练习：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

#!/usr/bin/env python

# -*- coding:utf-8 -*-

#-Author-Lian

#面向对象

class Foo:

    def __init__(self, name, age, gender):

        self.name = name

        self.age = age

        self.gender = gender

    def firewood(self):

        print("%s,%s岁,%s,上山去砍柴" % (self.name, self.age, self.gender))

    def drive(self):

        print("%s,%s岁,%s,开车去东北" % (self.name, self.age, self.gender))

    def dbj(self):

        print("%s,%s岁,%s,最爱大保健" % (self.name, self.age, self.gender))

xiaoming = Foo(‘小明‘, 10, ‘男‘)

xiaoming.firewood()

xiaoming.drive()

xiaoming.dbj()

#小明,10岁,男,上山去砍柴

#小明,10岁,男,开车去东北

#小明,10岁,男,最爱大保健

laoli = Foo(‘老李‘, 90, ‘男‘)

laoli.firewood()

laoli.drive()

laoli.dbj()

#老李,90岁,男,上山去砍柴

#老李,90岁,男,开车去东北

#老李,90岁,男,最爱大保健

　　面向对象编程的主要作用也是使你的代码修改和扩展变的更容易，那么小白要问了，既然函数都能实现这个需求了，还要OOP干毛线用呢？ 呵呵，说这话就像，古时候，人们打仗杀人都用刀，后来出来了枪，它的主要功能跟刀一样，也是杀人，然后小白就问，既然刀能杀人了，那还要枪干毛线，哈哈，显而易见，因为枪能更好更快更容易的杀人。函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改。　

上面的程序做个简单认识即可，下面我们通过写一个cs程序来对面向对象编程做进一步认识

 CS游戏


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#!/usr/bin/env python

# -*- coding:utf-8 -*-

#-Author-Lian

#面向对象class

class Role(object):      #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，暂且先记住

    def __init__(self,name,role,weapon,life_value=100,money=15000):#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里

        self.name = name        #__init__中的第一个参数self为实例名称

        self.role = role     

        self.weapon = weapon

        self.life_value = life_value

        self.money = money

        #__init__()叫做初始化方法(或构造方法)， 在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了, 叫方法)会自动执行，

                                                                                                # 进行一些初始化的动作

    def shot(self):

        # 开了枪后要减子弹数

        print("%s is shooting......."%(self.name))

    def got_shot(self):

        # 中枪后要减血

        print("ah.....%s:I got shot...."%(self.name))

    def buy_gun(self,gun_name):

        # 检查钱够不够,买了枪后要扣钱

        print("%s just bought %s "%(self.name,gun_name))

#生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法,这个过程叫做类的实例化，r1叫做类的实例

r1 = Role(‘Alex‘,‘police‘,"AK47")   #此时self 相当于 r1 ,  Role(r1,‘Alex‘,‘police‘,‘AK47’)

r2 = Role(‘Jack‘,‘terrorist‘,"B22") #此时self 相当于 r2 ,  Role(r2,‘Jack‘,‘terrorist‘,‘B22’)

print(r1,type(r1))

print(r1.role)

r1.shot()

r1.got_shot()

r1.buy_gun("DZT100")

# <__main__.Role object at 0x005A5BF0> <class ‘__main__.Role‘>

# police

# Alex is shooting.......

# ah.....Alex:I got shot....

# Alex just bought DZT100

2、类变量和实例变量 

类变量为大家都共有的变量，只加载在类内存当中，不会加载在每个实例里；举个栗子：创建14亿用户，大家国籍都是中国，如果不把国籍写到类变量中，而是写到实例变量默认参数中，则14亿个实例，每个都要加载国籍到内存当中，会占用大量内存，这就是为什么我们要了解类变量的意义


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#类变量和实例变量

class Role(object):      #定义一个类， class是定义类的语法

    n = 123              #类变量

    name = "类name"

    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

r1 = Role(‘Alex‘,‘police‘,"AK47")   #实例

print(Role.n,r1.n)

print(Role.name,r1.name)

#123 123

#类name Alex

由上面程序可知，类变量对全局生效，输入类名可直接调用；当类变量与实例变量相同且同时存在的话，实例变量优先


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#实例变量

class Role(object):      #定义一个类， class是定义类的语法

    n = 123              #类变量

    name = "类name"

    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

r1 = Role(‘Alex‘,‘police‘,"AK47")   #实例

r1.name="wupeiqi"

r1.bullet= True

print(r1.name,r1.bullet)

#wupeiqi True

类进行实例化之后，还可以对实例变量重新赋值、增加变量　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

#类变量和实例变量

class Role(object):      #定义一个类， class是定义类的语法

    n = 123              #类变量

    name = "类name"

    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

r1 = Role(‘Alex‘,‘police‘,"AK47")   #实例

r2 = Role(‘lzl‘,‘terrorist‘,‘B22‘)

r1.n = "r1的123"

print(r1.name,r1.n)

print(r2.name,r2.n)

# Alex r1的123

# lzl 123

Role.n = "Role的123"

print(r1.name,r1.n)

print(r2.name,r2.n)

# Alex r1的123

# lzl Role的123

执行上面的程序发现，赋值r1.n后只是影响到实例r1，对r2.n并没有任何影响，这是因为赋值的实例变量与类变量名一样时，并不会改变类变量中的值，只影响到当前实例；当重新赋值类变量时，r2也跟着改变；哈哈，此时你以为你都懂了，那让我们对上面的程序做个升级吧！！


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

#类变量和实例变量

class Role(object):      #定义一个类， class是定义类的语法

    list = []      #定义一个列表类变量

    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

r1 = Role(‘Alex‘,‘police‘,"AK47")   #实例

r2 = Role(‘lzl‘,‘terrorist‘,‘B22‘)

print(Role.list)            #此时list为空

#[]

r1.list.append("from r1")

r2.list.append("from r2")

print(r1.list)

print(r2.list)

#[‘from r1‘, ‘from r2‘]

# [‘from r1‘, ‘from r2‘]

print(Role.list)

# [‘from r1‘, ‘from r2‘]

从上面的程序可看出r1、r2改变了类变量；懒得解释了，自己理解吧O(∩_∩)O哈哈~

3、析构函数 

在实例释放、销毁的时候执行，通常用于做一下收尾工作（如关闭数据连接）


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

#析构函数

class Role(object):      #定义一个类， class是定义类的语法

    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

    def __del__(self):

        print("%s 彻底死了"%self.name)

    def shot(self):

        # 开了枪后要减子弹数

        print("%s is shooting......."%(self.name))

    def got_shot(self):

        # 中枪后要减血

        print("ah.....%s:I got shot...."%(self.name))

r1 = Role(‘Alex‘,‘police‘,"AK47")

r2 = Role(‘Wupeiqi‘,‘terrorist‘,‘B22‘)

r1.got_shot()

del r1

r2.got_shot()

# ah.....Alex:I got shot....

# Alex 彻底死了

# ah.....Wupeiqi:I got shot....

# Wupeiqi 彻底死了

程序结束、del删除实例时才会执行__del__里的内容

4、私有属性、私有方法

记住私有的概念：只能在类里面进行调用 看完下面的代码你就明白了


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

#class私有属性、私有方法

class Role(object):      #定义一个类， class是定义类的语法

    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

    def show_status(self):                  #定义函数，调用私有属性

        print("name:%s weapon:%s life_value:%s"%(self.name,self.weapon,self.__life_value))

    def __shot(self):                      #定义私有方法

        print("%s is shooting......."%(self.name))

    def got_shot(self):

        self.__shot()                       #调用私有方法

        print("ah.....%s:I got shot...."%(self.name))

r1 = Role(‘lzl‘,‘police‘,"AK47")

#私有属性

#print(r1.__life_value)          #外部调用life_vaule 直接报错

#AttributeError: ‘Role‘ object has no attribute ‘__life_value‘

r1.show_status()                #通过方法执行私有属性

#name:lzl weapon:AK47 life_value:100

#私有方法

#r1.__shot()                     #外部调用私有方法 直接报错

#AttributeError: ‘Role‘ object has no attribute ‘__shot‘

r1.got_shot()                    #通过其他方法执行私有方法

# lzl is shooting.......

# ah.....lzl:I got shot....

5、继承

继承：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

#类的继承

class People():

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def eat(self):

        print("%s is eating..."%self.name)

    def sleep(self):

        print("%s is sleeping...."%self.name)

class Man(People):      #继承类People

    def play(self):         #增加新功能

        print("%s is playing...."%self.name)

    def sleep(self):        #重构sleep功能

        People.sleep(self)

        print("man is sleeping....")

class Woman(People):         #继承类People

    def get_birth(self):        #增加新功能

        print("%s is born a boby...."%self.name)

m1 = Man("lianzhilie",22)

w1 = Woman("Alex",33)

m1.eat()                #调用People方法

m1.play()               #调用Man方法

# lianzhilie is eating...

# lianzhilie is playing....

m1.sleep()

# lianzhilie is sleeping....

# man is sleeping...

w1.get_birth()

# Alex is born a boby...

由上面程序可知，类的继承可省大量重复的代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

#类的继承，子类初始化

class People():

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def eat(self):

        print("%s is eating..."%self.name)

    def sleep(self):

        print("%s is sleeping...."%self.name)

class Man(People):

    def __init__(self,name,age,money):     #重构初始化 覆盖父类

        # People.__init__(self,name,age)      #加载父类初始化

        super(Man,self).__init__(name,age)       #加载父类初始化

        self.money = money

        print("%s 一出生就有 $%s"%(self.name,self.money))

    def play(self):         #增加新功能

        print("%s is playing...."%self.name)

class Woman(People):

    def get_birth(self):

        print("%s is born a boby...."%self.name)

m1 = Man("lianzhilie",22,1000)

w1 = Woman("Alex",33)

#lianzhilie 一出生就有 $1000

子类需要重构初始化时，会把父类的初始化覆盖掉，所以在重构时需要加载父类初始化


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

# 类的继承-多继承

class People(object):       #新式类

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def eat(self):

        print("%s is eating..." % self.name)

    def sleep(self):

        print("%s is sleeping...." % self.name)

class Relation(object):

    def make_friends(self,obj):

        print("%s is making friends with %s"%(self.name,obj.name))

class Man(Relation,People):             #多继承

    def play(self):

        print("%s is playing...." % self.name)

class Woman(People):

    def get_birth(self):

        print("%s is born a boby...." % self.name)

m1 = Man("lianzhilie", 22)

w1 = Woman("Alex", 33)

m1.make_friends(w1)

#lianzhilie is making friends with Alex

多继承时需注意，在多继承中从父类继承初始化属性时，顺序从左到右开始初始化，只要初始化到属性数据就不再向后继续，所以越往前越优先；当父类有初始化，子类也有初始化时，执行子类的初始化，父类的不生效

刚才我们已经知道了新式类的概念，那么经典类与新式类的区别是什么呢？！

通过上面的程序我们知道Python的类可以继承多个类，那如果Python的类如果继承了多个类，有多层继承关系，那么其初始化时寻找的路线是什么样的呢？，通过下面这段代码来看下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

#经典类

class A():

    def __init__(self):

        print("A")

class B(A):

    pass

class C(A):

    def __init__(self):

        print("C")

class D(B,C):

    pass

obj = D()

#A

#新式类

class A(object):

    def __init__(self):

        print("A")

class B(A):

    pass

class C(A):

    def __init__(self):

        print("C")

class D(B,C):

    pass

obj = D()

#C

当类是经典类时，多继承情况下，会按照深度优先方式查找；当类是新式类时，多继承情况下，会按照广度优先方式查找；具体参考下图

6、多态

　　多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。Pyhon不直接支持多态，但可以间接实现

看完上面的话，完全懵逼； 说人话！！--》一个接口，多种实现，实现接口重用


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

#多态

class Animal:

    def __init__(self, name):  # Constructor of the class

        self.name = name

    @staticmethod

    def animal_talk(obj):

        obj.talk()

class Cat(Animal):

    def talk(self):

        print(‘%s:Meow!‘%(self.name))

class Dog(Animal):

    def talk(self):

        print(‘%s:Woof! Woof!‘%(self.name))

c = Cat(‘Missy‘)

d = Dog(‘Lassie‘)

Animal.animal_talk(c)

Animal.animal_talk(d)

# Missy:Meow!

# Lassie:Woof! Woof!
时间： 2024-10-07 15:08:31

day7 面向对象编程的相关文章

Python之路，Day7 - 面向对象编程进阶

本节内容 面向对象高级语法部分 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业开发一个支持多用户在线的FTP程序 面向对象高级语法部分 静态方法 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法什么是静态方法呢其实不难理解普通的方法可以在实例化后直接调用并且在方法里可以通过self.调用实例变量或类变量但静态方法是不可以访问实例变量或类变量的一个不能访问实例变量和类变量的方法其实相当于跟类本身已经没什么关系了它与类唯一的关联就是需要通过

python_way.day7 模块（configparser，xml，shutil，subprocess）、面向对象（上）（创建类，类的构成，函数式编程与面向对象编程的选择，类的继承）

python_way.day7 1.模块 configparser,xml,shutil,subprocess 2.面向对象(上) 创建类,类的构成,函数式编程与面向对象编程的选择,类的继承 1.模块 configparser 用于处理特定格式的文件,其本职上使用open来操作,只能是  [test1] 特定的格式 [test1] k1 = 123 k2 = True [test2] k1 = 123 k2 = v1 文件内容 1.获取 import configparser #打开文件找到文件

Python之路第一课Day6--随堂笔记(面向对象编程进阶...未完待续 )

本节内容: 面向对象高级语法部分 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 面向对象高级语法部分 一.静态方法 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它

Python之路，Day8 - 面向对象编程进阶

本节内容: 面向对象高级语法部分 经典类vs新式类 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 面向对象高级语法部分 经典类vs新式类 把下面代码用python2 和python3都执行一下 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #_*_coding:utf-8_*_ class A:     def __init__(self):

python第七周-面向对象编程进阶

申明:本文内容主要转自Alex老师的博客,仅供学习记录! 静态方法 只是名义上归类管理,实际上在静态方法里访问不了类实例中的任何属性 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法 1 clas

面向对象编程

面向对象:类,属性,方法 面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如Student类,而实例是根据类创建出来的一个个具体的"对象",每个对象都拥有相同的方法,但各自的数据可能不同. 仍以Student类为例,在Python中,定义类是通过class关键字: class Student(object): pass class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下

python面向对象编程

java和c#只支持面向对象编程,python即可支持面向对象也可以支持函数式编程. 面向对象两个重要的概念:  1.类 2.对象 函数式 def sendemail(email,msg):            函数 print("8888") 面向对象 class Myclass: def sendmail(self,email,msg):      函数定义在类中第一个参数必须是self print("8888")              函数在类中定义叫方

面向对象编程的一些理解

(1) 简单的说类是对象的模版. 首先我们可以来理解一下对象的概念,面向对象编程的程序实际就是多个对象的集合,我们可以把所有的事物都抽象成对象,在程序设计中可以看作:对象=属性+方法.属性就是对象的数据,而方法就是对象的行为. 下面来说类,就像我开头所说类是对象的模版,而对象是类的实例化.举个例子,饼干模子可以看作是类,而具体的饼干就是对象.再比如有一个类是表示人,然后可以通过人这个模版来实例化出张三.李四... 比如说一个类是描述人的特征,为什么实例化? p = People(); 这个人有很

Python之路【第五篇】：面向对象编程

面向对象编程思维导向图 http://naotu.baidu.com/file/03516c91377d6cad0ded041aa4ce4433?token=ccaba09527261666 密码: Tim 面向:过程.函数.对象 面向过程:根据业务逻辑从上到下写垒代码! 面向过程的编程弊:每次调用的时候都的重写,代码特别长,代码重用性没有,每次增加新功能所有的代码都的修改!那有什么办法解决上面出现的弊端呢?函数就出现了. 面向函数:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可!