Python-面向过程编程、面向对象编程

1、面向过程编程

以五子棋为例（面向过程的思路）：

面向对象的思路：

2、面向对象编程

1）简介

2）对象和类

#类(class)
class Cat:
    #属性:一般是名词，比如name,age,gender.....
    name = 'name'
    kind = 'kind'
    #方法：一般是动词，比如create,delete,run.....
    def eat(self):
        print('cat like eating fish ....')

#对象(Object)：对类的实例化(具体化)
fentiao = Cat()
print(Cat)  #<class '__main__.Cat'>
print(fentiao) #<__main__.Cat object at 0x0000000002549400> Cat这个类实例化一个对象保存在这个内存空间中

执行结果如下：

3）特性

（1）封装特性

#类(class)
class Cat:
    def __init__(self,name,kind):
        """
        1.构造方法，实例化对象时自动执行的方法
        2.self是什么？self实质是实例化的对象
        3.类方法中，python解释器会自动把对象作为参数传给self
        """
        print('正在执行__init__构造方法')
        print('self:',self)
        #属性:一般是名词，比如name,age,gender.....
        #封装：self.name将对象和name属性封装/绑定
        self.name = name
        self.kind = kind
    #方法：一般是动词，比如create,delete,run.....
    def eat(self):
        print('cat %s like eating fish ....' %(self.name))

#对象(Object)：对类的实例化(具体化)
fentiao = Cat('粉条','美短猫')
print(fentiao.name)
print(fentiao.kind)
fentiao.eat()

执行结果如下：

练习

代码如下：

class People:
    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age

    def shopping(self):
        print('%s,%s,%s,去西安赛格购物广场购物' %(self.name,self.gender,self.age))
    def playgame(self):
        print('%s,%s,%s,去西安赛格购物广场玩游戏' % (self.name, self.gender, self.age))
    def learning(self):
        print('%s,%s,%s,在西部开源学习' % (self.name, self.gender, self.age))
        
xiaoming = People('小明','18岁','男')
xiaoming.shopping()
xiaowang = People('小王','22岁','男')
xiaowang.playgame()
xiaohong = People('小红','10岁','女')
xiaohong.learning()

（2）继承和多继承特性

class Student:
    """父类Student"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def learning(self):
        print(f'{self.name}正在学习')

    def choice_course(self):
        print('正在选课'.center(50,'*'))

class MathStudent(Student):
    """MathStudent的父类是Student"""
    def choice_course(self):
        # 需求：先执行父类的choice_course方法，再个性化执行自己的方法
        # Student.choice_course(self) #解决方法1：直接执行父类，但不建议
        super(MathStudent, self).choice_course() #解决方法2：通过super找到父类，再执行方法
        info = """
                      课程表
                    1.高等数学
                    2.线性代数
                    3.概率论
        """
        print(info)

#实例化
m1 = MathStudent("粉条博士",'9')
print(m1.name)
print(m1.age)
m1.learning() #不会报错，子类没有，但是父类里有方法
#m1.choice_couese() #报错，子类和父类都没有方法
m1.choice_course()

封装链表

#封装节点类
class ListNode:
    def __init__(self,val = None,next = None):
        self.val = val
        self.next = next

    def travel(self,head):
        """遍历链表里面的每一个元素"""
        while head.next:
            print(head.next.val)
            head = head.next
#l1 = 2,4,3
#l2 = 5,6,4
def create_l1():
    l1 = ListNode()
    node1 = ListNode(val=2)
    node2 = ListNode(val=4)
    node3 = ListNode(val=3)
    l1.next = node1
    node1.next = node2
    node2.next = node3
    return l1

def create_l2():
    l2 = ListNode()
    node1 = ListNode(val=5)
    node2 = ListNode(val=6)
    node3 = ListNode(val=4)
    l2.next = node1
    node1.next = node2
    node2.next = node3
    return l2
l1 = create_l1()
l2 = create_l2()
l1.travel(l1)
l2.travel(l2)

练习题

我的代码：

#封装节点类
class ListNode:
    def __init__(self,val = 0,next = None):
        self.val = val
        self.next = next

    def travel(self,head):
        """遍历链表里面的每一个元素"""
        while head:
            print(head.val)
            head = head.next
#l1 = 2,4,3
#l2 = 5,6,4
def create_l1():
    l1 = ListNode()
    node1 = ListNode(val=2)
    node2 = ListNode(val=4)
    node3 = ListNode(val=3)
    l1.next = node1
    node1.next = node2
    node2.next = node3
    return l1.next

def create_l2():
    l2 = ListNode()
    node1 = ListNode(val=5)
    node2 = ListNode(val=6)
    node3 = ListNode(val=4)
    l2.next = node1
    node1.next = node2
    node2.next = node3
    return l2.next

def addtwonumber(l1:ListNode,l2:ListNode) -> ListNode:
    res = 0
    l3 = ListNode()
    cur = l3
    while(l1 or l2):
        if(l1):
            res += l1.val
            l1 = l1.next
        if(l2):
            res += l2.val
            l2 = l2.next
         #res = 10,val=0,res=>val val = res %10
         #res = 14 val=4 14%10=4
        l3.next = ListNode(val=res%10)
        #res=10,进1
        l3 = l3.next
        res = res // 10
    if res == 1:
        l3.next = ListNode(1)
    return cur.next

if __name__ == '__main__':
    l1 = create_l1()
    l2 = create_l2()
    l3 = addtwonumber(l1,l2)
    l3.travel(l3)

用哈希表来解决：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashes = {}
        n = len(nums)   #统计nums个数
        for i in range(n):
            if target - nums[i] in hashes:
                return hashes[target - nums[i]],i
            hashes[nums[i]] = i

笨办法：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashes = {}
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []

多继承

新式类：广度优先算法（python3中都是新式类）
经典类：深度优先算法（python2中的部分属于经典类）

（3）私有属性和私有方法

class Student:
    """父类"""
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        #私有属性，以双下划线开头
        #工作机制：类的外部不能访问和操作（包括它的子类），类的内部可以访问和操作
        self.__score =score
    def learning(self):
        print(f'{self.name}正在学习')

    def get_score(self):
    	self.__modify_score()
        return self.__score
        
    def __modify_score(self):
        self.__score += 20
        #只能在内部调用
        
#子类也无法继承父类的私有属性和私有方法
class MathStudent(Student):
    """父类是student"""
    pass

#实例化
s1 = Student('张三',18,100)
print(s1.name)
print(s1.age)

score = s1.get_score()
print(score)

执行结果如下：

（4）多态特性