day 10 预科

目录

• IPO
• 编程
• 面向对象编程
• 类和对象
  • 对象
  • 类
  • 定义类
  • 定义对象
  • 定义类语法
  • 定义对象 (实例化对象)
• 定制对象独有特征
• LeetCode检测机制

面向过程编程：面向（对着）--》过程（流程/步骤）--》编程（码代码）

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的来源

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

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

目录

• IPO
• 编程
• 面向对象编程
• 类和对象
  • 对象
  • 类
  • 定义类
  • 定义对象
  • 定义类语法
  • 定义对象 (实例化对象)
• 定制对象独有特征
• LeetCode检测机制

面向对象编程

面向(对着)对象object编程

对象与对象之间交互

目录

• IPO
• 编程
• 面向对象编程
• 类和对象
  • 对象
  • 类
  • 定义类
  • 定义对象
  • 定义类语法
  • 定义对象 (实例化对象)
• 定制对象独有特征
• LeetCode检测机制

类和对象

对象

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

选课系统

'''
学生类：
     姓名
     身高
     体重
     年龄
     技能：
         选课

默默对象：
     姓名：默默
     身高：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()

'''

目录

• IPO
• 编程
• 面向对象编程
• 类和对象
  • 对象
  • 类
  • 定义类
  • 定义对象
  • 定义类语法
  • 定义对象 (实例化对象)
• 定制对象独有特征
• LeetCode检测机制

定制对象独有特征

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)

目录

• IPO
• 编程
• 面向对象编程
• 类和对象
  • 对象
  • 类
  • 定义类
  • 定义对象
  • 定义类语法
  • 定义对象 (实例化对象)
• 定制对象独有特征
• LeetCode检测机制

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()