LF 模块三

面向过程编程

面向过程：核心是过程二字，过程是指的解决问题的步骤，
设计一条流水线，机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差，功能一旦实现，扩展很麻烦

应用场景：功能一旦实现基本不需要扩展的情况，自动部署脚本之类

import json

def inter_active():
    name = input("name>>:").strip()
    pwd = input("password>>:").strip()2
    return {
        "name":name,
        "password":pwd
    }


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


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

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

if __name__ == '__main__':
    main()

面向对象编程

面向对象：核心是对象二字，对象是特征与技能的集合（属性和方法）
优点：可扩展性强
缺点：编程复杂度高

应用场景：用户需求经常变化

对象：特征与技能的集合体（属性和方法）
类：一些类对象相似的特征与技能的结合体
注意：站在不同角度，分类不同
在现实生活中，先有对象，再有类
在计算机中，现有类，后有对象

class LuffyStudent:
    school = "luffycity"
    def learn(self):
        print("is learning")

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

    def sleep(self):
        print("is sleeping")

# 生成对象
stu1 = LuffyStudent()
print(stu1.school)

如何使用类

定义一个类（注意类名首字母大写）。

1.执行：

与函数不同，函数声明过程中并不执行，只有在调用时（函数名+括号）才能执行。（类后面+括号是实例化，生成对象）

类在定义阶段，内部代码就会执行，会产生新的名字，创建新的名称空间，名称空间的结果都是字典模式

2.名称

通常情况下，类里面定义了行为和属性，但是在python中一般也可以加入其他代码

类内部定义的变量叫数据属性，函数叫函数属性。

针对类的属性，python中有专门的属性访问语法点（.）

class Luffy_Student:
    school = "luffycity"
    def learn(self):
        print("is learning")

    def eat(self):
        print("is eating|")
#查看类的名称空间
print(Luffy_Student.__dict__)
print(Luffy_Student.__dict__["school"])

#查
print(Luffy_Student.school) #等同于在名称空间里查找Luffy_Student.__dict__["school"]

#增
Luffy_Student.country = "China"

#删
del Luffy_Student.country

#改
Luffy_Student.school = "Luffycity123"

#类的用法，点（.）方法，属性
#类的两大操作 第一是 
#类加（）是实例化一个对象。
#第一大类用处对属性操作，第二大操作是生成一个个对象

__init__方法

用来为对象定制对象自己独有的特征（构造函数，对象初始化）

class Luffy_Student:
    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("is eating|")

stu1=Luffy_Student('alex','女',19)
print(stu1)
print(stu1.Name)

加上__init__方法后是实例化步骤：

1.先产生一个空对象

2.触发类的init方法 >> LuffyStudent.__init__(stu,'alex','女',18)

3.执行过程中，在init方法内，把方法给对象赋值,self.name = name

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("is eating")

stu1 = LuffyStudent("Alex","女",18)

# 实例化之后，对对象操作
# 查
print(stu1.name)

# 改
stu1.name = "bbbb"
print(stu1.name)

#删除
del stu1.name
print(stu1.__dict__)

#增
stu1.class_name = "python"
print(stu1.class_name)

属性查找

对象：特征与技能的结合体

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

{'name': 'Alex', 'sex': '女', 'age': 18}
{'name': 'ben', 'sex': '男', 'age': 28}
{'name': 'cici', 'sex': '女', 'age': 21}

类：类是一系列对象相似的特征和技能的结合体

类中的属性，是对象共有的

print(id(stu1.school))
print(id(stu2.school))

35262960
35262960

类中的函数属性：是绑定给对象的，绑定到不同的对象是不同的绑定方法。对象调用绑定方法时，会将对象自身当做第一个参数传入绑定方法

print(LuffyStudent.learn)

>> <function LuffyStudent.learn at 0x000000000240AE18>


LuffyStudent.learn(stu1)

>> Alex is learning

类中定义的函数，在没有经过任何附加处理的情况下就是绑定方法，谁来调，就把自己传入

对象本身只有独有属性(init)，相似特征放在类里，如果有同名属性，那么就先访问对象本身，再访问类

# 类中的函数属性：是绑定给对象的，绑定到不同的对象是不同的绑定方法。对象调用绑定方法时，会将对象自身当做第一个参数传入绑定方法