面向过程编程
函数内定义注释可以提取
def f1():
"""f1的注释"""
pass
print(f1.__doc__) #函数内定义注释可以将注释提取出来
面向过程编程:面向(对着)-->过程(流程/步骤)-->编程(码代码)
IPO
iput(输入)-->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 #实际结果res = 40
debug的来源
x = 10
#流程
print('第一步',x)
x *= 10
x *=0
print(1/x)
print('第二步',x)
#流程
print('第三步',x)
x += 2
print('第四步',x)
1.定位bug,不一定是那一行出错了,从该行往上找错
2.打印变量变化的状态,判断该流程是否有问题
面向对象编程
#面向(对象)对象(object)编程(码代码)-->(一个孙悟空就是一个对象,一个猪八戒也是一个对象)
#西游记-->4个和尚-->悟空(七十二变,金箍棒)/沙和尚(36变,九齿钉耙)/猪八戒/唐僧
#-->1匹马-->小白龙
#做一个游戏:西游记()
#1.孙悟空
#2.沙和尚
#3.猪八戒
#4.唐僧
#这种方法造出来的游戏-->通过面向编程造的-->对象与对象之间交互
#优点:孙悟空的变化不会对其他对象造成影响
#缺点:异常复杂
#面向对象编程:就是对象与对象之间交互
类和对象
#对象:一系列属性(特征)和技能(方法)的结合体
'''
nick对象:
姓名:nick
身高:180
体重:140
年龄:18
技能:
上课
学生类:
姓名
身高
体重
年龄
技能:
选课
老师类:
姓名
身高
体重
年龄
技能
上课
'''
#类:(模板/类别)划分了对象,具有相同的属性和技能的对象属于同一类(自己控制)
#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}正在选课')
#定义对象
yutong = Student('宇通',150,170,16)
print(yutong.name)
print(yutong.height)
print(yutong.weight)
print(yutong.age)
yutong.choose_course()
#如果该对象属于这个类，那么类拥有的，对象一定也拥有
定制对象独有属性
# class Student():
# school = 'q34y'
# name = 'd12'
# height = 1
# weight = 1000
# def choose_course(self): #self实例化对象
# print('正在选课')
# stu1 = Student()
# print(stu1.name)
# stu2 = Student()
# print(stu2.name)
#
# def init(obj,name,height,weight):
# obj.name = name
# obj.height = height
# obj.weight = weight
# stu3 = Student()
# init(stu3,'cql',172,120)
# print(stu3.name)
# print(stu3.height)
# print(stu3.weight)
class Student():
school = 'oldboy'
def __init__(self,name,weight,height): #init函数初始化类定制的独有属性
self.name = name
self.weight = weight
self.height = height
print(self)
stu4 = Student('lyz',6,20) #类中定义了几个属性,实例化对象中就需要传入几个参数
print('stu4:',stu4)
print(stu4.__dict__) #获取对象stu4的所有属性并以字典形式存储
print(stu4.name)
print(stu4.weight)
print(stu4.height)
stu5 = Student('lcy',54,130)
print('stu5:',stu5)
print(stu5.__dict__)
print(stu5.name)
print(stu5.weight)
print(stu5.height)
#类在对象实例化是就会调用类中的函数
LeetCode检测机制
class Solution:
def twoSum(self, nums: list, target: int) -> list:
for i in range(len(nums), -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 nums[i] + nums[j] == target:
return [i, j]
nums = [2, 7, 11, 15]
target = 9
result = [0,1]
def main(nums,target,result):
s = Solution()
res = s.twoSum(nums,target)
if res == result:
print('tongguo')
else:
print('butongguo')
main(nums,target,result)
类与数据类型
# lt = list([2,3,1])
# lt.sort()
# print(lt)
# class List:
# def __init__(self,lis):
# print(self)
# self = lis
# print(self)
# pass
# lt = List([2,3,1])
# print(lt)
class List:
def __init__(self,lis):
self.lis = lis
def paixu(self): #self == lt
self.lis.sort()
lt =List([2,3,1,456,231,789])
print(lt.lis)
lt.paixu()
print(lt.lis)
#python中一切(数据类型)皆对象,一切皆数据类型
# dic1 = dic()
# dic2 = dic()
x = int(10)
y = float(10.1)
def func():
pass
print(func)
#1.作为对象
#1.引用 x = 10; y = x
#2.作为容器类元素 lis = [x,func,Student]
#3.作为函数参数 def func(x, func, Student)
#4.作为函数返回值, return x, func, Student
def func():
print('from func')
lis = [1,2,func]
lis[2]()
def f2(f):
f()
f2(func)
def f3():
return func
f3()() #调用f3,返回对象函数func,在通过func()调用对象func函数
list_ = [23,41,58,9,5,27,15]
#冒泡排序算法
def maopao():
for j in range(len(list_)-1):
for i in range(0,len(list_)-1-j):
if list_[i] > list_[i+1]:
list_[i], list_[i+1] = list_[i+1],list_[i]
maopao()
print(list_)
#选择排序算法
def xuanze():
min = 0
for j in range(len(list_)):
for i in range(j+1, len(list_)):
if list_[i] < min:
min = list_[i]
list_[j] = min
xuanze()
print(list_)