面向过程编程：面向（对着）--》过程（流程/步骤）--》编程（码代码）
IPO
Input（输入）--》Process（过程/处理）--》Output（输出）
塑料（定义变量） --》 （融化 --》 丢到瓶子的摸具里面） --》瓶子（输出结果）
类似于车间（流水线的工作过程）--》面向对象编程
未来码代码的目的：输入一些变量，然后会通过一系列的步骤改变变量，然后得到你想要的结果
def compare2(x, y):
if x > y:
return x
else:
return y
x = input()
y = input()
res = compare2(x, y)
print(res)
面向过程编程：一步一步（一个函数一个函数），上一个函数的输出是下一个函数的输入
优点：代码的独立性提高了，流程清晰
缺点：一个错误，让程序直接崩掉了
编程
控制变量不断地变化（初级开发）
怎么找bug
x = 10
y = 20
# 流程1
# 变量没变化一次，就打印一次，
# 流程2
# 流程（方法有无数种）--》需求的实现是多样化的，压根就没有唯一解
res = 50
debug的来源
- 定位bug，不一定是那一行出错了
- 打印变量变化的状态，判断该流程是否有问题
计算机永远不会出错，出了问题，一定是自己的代码逻辑有问题
面向对象编程
面向(对着)对象object编程
对象与对象之间交互
类和对象
对象
一系列特征(属性)和技能(方法)的结合体
选课系统
'''
学生类：
姓名
身高
体重
年龄
技能：
选课
默默对象：
姓名：默默
身高：175
体重：140
年龄：21
技能：
选课
把妹
大炮对象：
姓名：大炮
身高：160
体重：240
年龄：38
技能：
选课
大炮
老师类：
姓名
身高
体重
年龄
技能：
上课
nick对象：
姓名：nick
身高：172
体重：120
年龄：31
技能：
上课
泡妞
'''
类
(模板/类别)划分了对象，具有相同的属性和技能的对象属于同一类（自己控制）
1000个对象，类小于1000种。
现实世界先有对象才会有类，但是python种先有类后才有对象
定义类
class Student:
def __init__(self,name,height,weight,age)
self.name=name
self.height=height
self.weight=weight
self.age=age
def choose_course(self):
print(f'{self.name}正在选课')
定义对象
momo=Student('momo',170,130,21)
print(momo,name)
print(momo,height)
print(momo,weight)
print(momo.age)
momo.choose_course()
dapao=Student('大炮',160,240,38)
print(dapao,name)
print(dapao,height)
print(dapao,weight)
print(dapao,age)
dapao1=Student('大炮',160,240,38)
print(dapao1.name)
print(dapao1.height)
print(dapao1.weight)
print(dapao1.age)
如果该对象属于这个类，那么类拥有的，对象一定拥有
定义类语法
'''
class 类名(驼峰体)：
school='odboy' # 定义变量(给类添加属性)
def choose_course(self): # 定义在类内部的函数一般称为方法(给类增加技能)
'''
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_choose()
'''
函数对象
x=10
y=x
print(y)
def x():
print('from f1')
y=x
y()
'''
定制对象独有特征
stu1=Student()
stu1.name='momo'
stu1.height=160
stu1.weight=170
print(stu1.name)
print(stu1.weight)
stu2=Student
stu2.name='dapao'
stu2.height=160
stu2.weiht=240
print(stu2.name)
print(stu2.weight)
class Student():
school='oldboy'
def choose_course(self):
print('正在选课')
def init(obj,name,height,weight):
obj.name=name
obj.height=height
obj.weight=weight
stu1=Student()
init(stu1,'momo','175','140')# init是你用来给对象添加独有特征的函数
print(stu1.name)
print(stu1.height)
print(stu1.weight)
stu2=Student()
init(stu2,'dapao','160','240')# init是你用来给对象添加独有特征的函数
print(stu2.name)
print(stu2.height)
print(stu2.weight)
class Student():
school='oldboy'
def __init__(self,name,height,weight):
print(self)
self.name=name # self=stul --> stu1.name='dapao'
self.height=height
self.weight=weight
def choose_course(self):
print('正在选课')
stu1=Student('momo',175,140)
print('stu1:',stu1)
print('stu1.name',stu1)
stu2=Student('dapao',160,240)
print('stu2:',stu2)
print('stu2.name',stu2)
LeetCode检测机制
class Solution:
def twoSum(self,nums:list,target:int) --> list:
for i in range(len(sums),-1,-1): # for i in range=(4) == for i in [0,1,2,3]:
for j in range(i+1,len(nums)): #[1,2,3]
if num[i]+nums[j] == target:
return[i,j]
def main(nums,target,result):
s = Solution()
res = s.twoSum(nums,target)
if res == result:
print('通过')
def main2():
main([2, 7, 11, 15], 9, [0, 1])
main([1, 2, 3], 3, [0, 1])
main([1, 2, 3], 3, [0, 1])
main([1, 2, 3], 3, [0, 1])
main([1, 2, 3], 3, [0, 1])
main([1, 2, 3], 3, [0, 1])
main([1, 2, 3], 3, [0, 1])
main2()
