函数内定义注释可以提取

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