day10

2023-11-17 14:46:04

面向过程

面向过程编程：面对(对着)--》过程(过程/处理)--》编程（码代码）

def compare2(x, y):
    if x > y:
        return x
    else:
        return y


x = input()
y = input()
res = compare2(x, y)

print(res)

面向过程编程：一步一步（一个函数一个函数），上一个函数的输出是下一个函数的输入

优点：代码的独立性提高了，流程清晰

缺点：一个错误，让程序直接崩掉了

IPO

Input（输入）--》Process（过程/处理）--》Output（输出）

塑料（定义变量） --》（融化 --》丢到瓶子的摸具里面） --》瓶子（输出结果）

类似于车间（流水线的工作过程）--》面向对象编程

未来码代码的目的：输入一些变量，然后会通过一系列的步骤改变变量，然后得到你想要的结果

编程

控制变量不断地变化（初级开发）

x = 10
y = 20

# 流程1
# 变量没变化一次，就打印一次，
# 流程2

# 流程（方法有无数种）--》需求的实现是多样化的，压根就没有唯一解


res = 50

debug的来源

定位bug，不一定是那一行出错了
打印变量变化的状态，判断该流程是否有问题

计算机永远不会出错，出了问题，一定是自己的代码逻辑有问题

面向对象

面向（对着）对象（object）编程（码代码）

# 西游记 --》4个人 --》孙悟空（猫脸雷公嘴/金箍棒/七十二变/筋斗云。。。。）/沙和尚/猪八戒（陈雨彤--》三十六便/肥头大耳/九齿钉耙/背媳妇）/唐僧
#        --》 一匹马 --》 小白龙


# 做一个游戏：西游记（）

# 1. 孙悟空（。。。）
# 2. 沙和尚
# 3. 猪八戒
# 4. 唐僧
# 5. 白龙马（）
# 6. 如来佛祖（光头）


# 这种方法造出来的游戏--》通过面向对象编程造的 --》 对象与对象之间交互


# 优点：孙悟空的变化不会对其他对象造成影响
# 缺点：异常复杂


# 面向对象编程: 对象与对象之间交互

类和对象

对象

一系列特征(属性)和技能（方法）的结合体

类

（模板/类别）划分了对象，具有相同的属性和技能的对象属于同一类（自己控制）

1000个对象，类小于1000种
现实世界中先有对象才会有类，但是python中现有类后有对象

#定义类
class Student():
    def __init__(self,name,height,weight,age):
        self.name=name
        self.height=height
        self.height = weight
        self.height =age

    def choose_course(self):
        print(f'{self}正在选课')

#定义对象
jzm = Student('zhimeng',175,130,18)
print(jzm.name)
print(jzm.height)
print(jzm.age)

定制类和对象

定义类

# 定义类语法
'''
class 类名（驼峰体）:
    school = 'oldboy'  # 定义变量（给类添加属性)
    
    def choose_course(self):  # 定义在类内部的函数一般称为方法（给类增加技能）
        pass
'''

class Student:
    """注释：学生类"""
    school = 'oldboy'  # 定义变量（给类添加属性)

    def choose_course(self):  # 定义在类内部的函数一般称为方法（给类增加技能）
        print(self)
        print('选择课程')


# stu_dict = Student.__dict__  # 获取类的所有属性和方法
# print(stu_dict)
# print(stu_dict['school'])  # 获取学校
# stu_dict['choose_course'](123)
# print(Student.__doc__)


# 函数定义阶段：检测语法，不执行代码
# 类定义阶段：执行代码

定义对象

# 定义对象（实例化对象）
stu1 = Student()  # stu1就是一个对象

print('stu1:', stu1)
print(stu1.school)
print(id(stu1.school))

stu1.choose_course()  # 对象使用类中的方法时，不需要加参数,因为实例化对象调用该方法时，python会自动将该实例化对象传给self

stu2 = Student()
print('stu2:', stu2)
print(stu2.school)
print(id(stu2.school))
stu2.choose_course()

'''
# 函数对象
x = 10
y = x
print(y)

def x():
    print('from f1')

y = x
y()
'''

定制对象的独有特征

第一次

class Student():
    school = 'oldboy'

    def choose_course(self):
        print('正在选课')

stu1 = Student()
stu1.name = 'yutong'
stu1.height = 160
stu1.weight = 170
print(stu1.name)
print(stu1.height)
print(stu1.weight)

stu2 = Student()
stu2.name = 'dapao'
stu2.height = 100
stu2.weight = 300
print(stu2.name)
print(stu2.weight)
print(stu2.height)

第二次

class Student():
    school = 'oldboy'

    def choose_course(self):
        print('正在选课')


def init(obj, name, height, weight):
    obj.name = name
    obj.weight = weight
    obj.height = height

stu1 = Student()
init(stu1, 'yutong', '170', '140')  # init是你用来给对象添加独有特征的函数
print(stu1.name)
print(stu1.weight)
print(stu1.height)

stu2 = Student()
init(stu2, 'dapao', 100, 300)
print(stu2.name)
print(stu2.weight)
print(stu2.height)

第三次

class Student():
    school = 'oldboy'

    def __init__(self, name, height, weight):
        print(self)
        self.name = name  # self = stu1 --> stu1.name = 'dapao'
        self.height = height
        self.weight = weight

    def choose_course(self):
        print('正在选课')


stu1 = Student('yutong', 170, 140)
print('stu1:',stu1)
print('stu1.name:',stu1.name)

stu2 = Student('dapao', 100, 300)
print('stu2.name:',stu2.name)
print('stu2:',stu2)

类与数据类型

# python中一切皆对象，一切皆数据类型 3-5w的代码
# 作为对象
# 1. 引用  x = 10 ； y = x
# 2. 作为容器类元素 lis = [x,func,Student]
# 3. 作为函数参数 def func(x, func, Student)
# 4. 作为函数返回值 return x,func,Student

码农公寓