首页 » 编程 » Python-5.面向对象编程设计与开发 » 正文

编程范式与面向对象介绍(待完善)

一、编程范式

对不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式。

不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路,大多数语言只支持一种编程范式,也有些语言可以同时支持各种编程范式。

两种最重要的编程范式分别是:面向过程编程面向对象编程

 

1. 面向过程编程(Procedural Programming)

面向过程:核心是过程二字,过程指的是解决问题的步骤,设计一条流水线,机械式的思维方式。

优点:把复杂的问题流程化,进而简单化

缺点:可扩展性差

 

例子(用户注册流程):

import json


def interactive():
    user = input("user:").strip()
    pwd = input("pwd:").strip()
    return {
        "user": user,
        "pwd": pwd
    }


def check(user_info):
    is_avlid = True
    if len(user_info["user"]) == 0:
        print("用户名不能为空")
        is_avlid = False
    if len(user_info["pwd"]) < 6:
        print("密码不能小于6位")
        is_avlid = False
    return {
        "is_avlid": is_avlid,
        "user_info": user_info
    }


def register(check_info):
    if check_info["is_avlid"]:
        with open("db.json", "w", encoding="utf-8") as f:
            json.dump(check_info["user_info"], f)


def main():
    user_info = interactive()
    check_info = check(user_info)
    register(check_info)


if __name__ == '__main__':
    main()

 

2. 面向对象编程(Object Oriented Programming)

OOP(Object Oriented Programming)编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述。

面向过程=个人视角

面向对象=上帝视角

 

面向对象:核心就是对象二字,对象就是特征与技能的结合体

优点:可扩展性强

缺点:编程复杂度高

应用场景:用户需求经常变化,互联网应用,游戏,企业内部应用

 

 

二、面向对象介绍

1.类与对象

 

# 定义类
class LuffyStudent:
    school = "luffycity"

    def learn(self):
        print("is learning")

    def eat(self):
        print("eating")


# 查看类的名称空间
print(LuffyStudent.__dict__)
print(LuffyStudent.__dict__["school"])
print(LuffyStudent.__dict__["learn"])

# 查
print(LuffyStudent.school)  # LuffyStudent.__dict__["school"]
print(LuffyStudent.learn)  # LuffyStudent.__dict__["learn"]

# 增
LuffyStudent.county = "China"
print(LuffyStudent.__dict__)
print(LuffyStudent.county)

# 删
del LuffyStudent.county
print(LuffyStudent.__dict__)

# 改
LuffyStudent.school = "Luffycity"
print(LuffyStudent.school)

 

如何使用对象:

__init__方法:

# __init__方法用来为对象定制对象自己独有的特征
class LuffyStudent:
    school = "luffycity"

    def __init__(self, name, sex, age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):
        print("is learning")

    def eat(self):
        print("eating")


# 实例化
stu1 = LuffyStudent("alex", "male", 23)

# 加上__init__方法后,实例化的步骤
# 1. 先产生一个空对象
# 2. LuffyStudent.__init__

# 查
print(stu1.__dict__)
print(stu1.Name)
print(stu1.Sex)
print(stu1.Age)

# 改
stu1.Name = "李二丫"
print(stu1.__dict__)
print(stu1.Name)

# 删
del stu1.Name
print(stu1.__dict__)

# 增
stu1.class_name = "python开发"
print(stu1.__dict__)

 

 

2.属性与绑定方法

class LuffyStudent:
    school = "luffycity"

    def __init__(self, name, sex, age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):
        print("%s is learning" % (self.Name))

    def eat(self):
        print("eating")


# 实例化
stu1 = LuffyStudent("alex", "male", 23)
stu2 = LuffyStudent("jack", "male", 25)
stu3 = LuffyStudent("jessie", "male", 22)

# 对象:特征与技能的结合体
# 类:类是一系列对象相似的特征与相似的技能的结合体

# 类中的数据属性:是所有对象共有的
print(LuffyStudent.school)  # 输出:luffycity
print(stu1.school, id(stu1.school))  # 输出:luffycity 2714080715632
print(stu2.school, id(stu2.school))  # 输出:luffycity 2714080715632
print(stu3.school, id(stu3.school))  # 输出:luffycity 2714080715632

# 类中的函数属性:是绑定给对象使用的,绑定到不同的对象是不同的绑定方法,对象调用绑定方法时,会把对象本身当做第一个传入,传给self
print(stu1.learn)  # 输出:<bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000019526269908>>
print(stu2.learn)  # 输出:<bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000019526269940>>
print(stu3.learn)  # 输出:<bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000019526269978>>

#
LuffyStudent.learn(stu1)  # 输出:alex is learning
stu1.learn()  # 输出:alex is learning

stu2.learn()  # 输出:jack is learning



stu1.x = "from stu1"
LuffyStudent.x = "from Luffycity class"
print(stu1.x)  # 输出:from stu1

 

3.类即类型

Python一切皆对象,在Python3里统一了类与类型的概念

l1 = [1, 2, 3]
l1.append(4)  # 等于   list.append(l1, 4)
print(l1)  # 输出:[1, 2, 3, 4]

 

 

三、小结练习

练习1:编写一个学生类,产生一堆学生对象。

要求:

        1. 有一个计数器(属性),统计总共实例了多少个对象

"""
练习1:编写一个学生类,产生一堆学生对象。
要求:
1. 有一个计数器(属性),统计总共实例了多少个对象
"""


class Student:
    count = 0

    def __init__(self, name):
        self.name = name
        Student.count += 1
        # 特别注意:上面写成 self.count += 1
        # 如果写成这样,就表示是针对每个对象实例化时加1,是统计不了总的次数的

    def lear(self):
        print("%s is learning" % (self.name))


stu1 = Student("Alex")  # 第一次实例化
stu2 = Student("Jack")  # 第二次实例化

print(Student.count)  # 获取实例化次数:得到2
print(stu1.count)  # 获取实例化次数:得到2
print(stu2.count)  # 获取实例化次数:得到2

 

 

练习2:模仿王者荣耀定义两个英雄类。

要求:

        1. 英雄需要有昵称、攻击力、生命值等属性;

        2. 实例化出两个英雄对象;

        3. 英雄之间可以互殴,被殴打的一方掉血,血量小于0则判定为死亡。

"""
练习2:模仿王者荣耀定义两个英雄类。
要求:
        1. 英雄需要有昵称、攻击力、生命值等属性;
        2. 实例化出两个英雄对象;
        3. 英雄之间可以互殴,被殴打的一方掉血,血量小于0则判定为死亡。
"""


class Hero:
    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        enemy.life_value -= self.aggresivity


class Garen:
    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        print("%s 正在遭受攻击..." % (enemy.nickname))
        enemy.life_value -= self.aggresivity
        print("%s 生命值还有 %s" % (enemy.nickname, enemy.life_value))

        if enemy.life_value <= 0:
            print("%s 已死。" % (enemy.nickname))


class Riven:
    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        print("%s 正在遭受攻击..." % (enemy.nickname))
        enemy.life_value -= self.aggresivity
        print("%s 生命值还有 %s" % (enemy.nickname, enemy.life_value))

        if enemy.life_value <= 0:
            print("%s 已死。" % (enemy.nickname))


g1 = Garen("alex", 29, 30)
r1 = Riven("jack", 40, 40)

print("攻击前r1生命值:", r1.life_value)  # r1被攻击之前生命值:40
g1.attack(r1)  # g1攻击r1
g1.attack(r1)  # g1攻击r1
print("攻击后r1生命值:", r1.life_value)  # r1被攻击后生命值:10

运行效果:

攻击前r1生命值: 40
jack 正在遭受攻击...
jack 生命值还有 10
jack 正在遭受攻击...
jack 生命值还有 -20
jack 已死。
攻击后r1生命值: -20

 

发表评论

验证码加载中....