Python面向过程和面向对象基础

总结一下：

面向过程编程：根据业务逻辑从上到下的写代码-----就是一个project写到底，重复利用性比较差

函数式：将某些特定功能代码封装到函数中------方便日后调用

面向对象：对函数进行分类封装，使开发更快捷更灵活

面向过程编程：

1 name = "mac"
2 age = 15
3 sex = ‘male‘
4 #......
5 print("%s‘s %s,%d years old!" %(name,sex,age))

函数式：

 1 def name(name):
 2     print(‘name is %s‘ %name)
 3 def age(age):
 4     print(‘age is %d‘ %age)
 5 def sex(sex):
 6     print(‘sex is %s‘ %sex)
 7
 8 name(‘mac‘)
 9 age(22)
10 sex(‘male‘)

面向对象：

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

class Message():
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def get_name(self):
        return self.name
    def get_age(self):
        return self.__age

message = Message(‘MAC‘,23)
print(message.get_name(),message.get_age())

二、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

 1 class Parent(object):
 2     def __init__(self,name,age,sex):
 3         self.name = name
 4         self.__age = age        #表示私有
 5         self.sex = sex
 6
 7     def get_name(self):
 8         return self.name
 9     def get_age(self):
10         return self.__age
11     def get_sex(self):
12         return self.sex
13
14 class Child(Parent):        #继承Parent父类
15     def get_age(self):
16         return self.age
17
18 P = Parent(‘mac‘,22,‘male‘)
19 C = Child(‘YYY‘,24,‘female‘)
20 print(P.get_name(),P.get_age(),P.get_sex())
21 print(C.get_name(),C.get_sex())

 1 class Parent(object):
 2     def __init__(self,name,age,sex):
 3         self.name = name
 4         self.__age = age        #表示私有
 5         self.sex = sex
 6
 7     def get_name(self):
 8         return self.name
 9     def get_age(self):
10         return self.__age
11     def get_sex(self):
12         return self.sex
13
14 class Child1(Parent):        #继承Parent父类
15     def get_age(self,age):
16         self.age = age        #私有类无法继承
17         return self.age

　　　　　def get_sex(self):
　　　　　　　return self.sex

18 class Child2(Parent):
19     def get_age(self):
20         return self.age
21 def func(x):
22     x.get_age
23
24 P = Parent(‘mac‘,22,‘male‘)
25 C1 = Child1(‘YYY1‘,24,‘female‘)
26 C2 = Child2(‘YYY2‘,24,‘female‘)
27 print(P.get_name(),P.get_age(),P.get_sex())
28 print(C1.get_name(),C1.get_sex(),C1.get_age(23))#调用自己的get_age()

三、多态 和多态性

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

一 什么是多态性（请务必注意注意注意：多态与多态性是两种概念。）

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数。

在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

多态性分为静态多态性和动态多态性

静态多态性：如任何类型都可以用运算符+进行运算

动态多态性：如下

 1 class Parent(object):
 2     def __init__(self,name,age,sex):
 3         self.name = name
 4         self.__age = age        #表示私有
 5         self.sex = sex
 6
 7     def get_name(self):
 8         return self.name
 9     def get_age(self):
10         return self.__age
11     def get_sex(self):
12         return self.sex
13
14 class Child1(Parent):        #继承Parent父类
15     def get_age(self,age):
16         self.age = age
17         return self.age
18     def get_sex(self):
19         print(self.sex)
20 class Child2(Parent):
21     def get_sex(self):
22         print (self.sex)
23 def func(x):
24     x.get_sex()
25
26 P = Parent(‘mac‘,22,‘male‘)
27 C1 = Child1(‘YYY1‘,24,‘male‘)
28 C2 = Child2(‘YYY2‘,24,‘female‘)
29 C1.get_sex()
30 C2.get_sex()
31 func(C1)
32 func(C2)

原文地址：https://www.cnblogs.com/nieliangcai/p/9051618.html