运算

1、用户登录，验证，注册

def login(a,b):
    """
    用于用户名和密码的验证
    :param a: 用户名
    :param b: 密码
    :return:Ture  用户验证成功   False  用户验证失败
    """
    c=open("334.txt","r",encoding="utf-8")
    for line in c:
        line=line.strip()          #默认strip无参数用于去除换行符和空格
        new_line=line.split("*")    #有参数，移除两端指定的值
        if new_line[0]==a and new_line[1]==b:
            return True
    return False

def yanzheng(a):
    """
    用于验证用户名是否存在
    :param a: 用户名
    :return: True  用户名存在
    """
    c=open("334.txt","r",encoding="utf-8")
    for line in c:
        line=line.strip()          #默认strip无参数用于去除换行符和空格
        new_line=line.split("*")    #有参数，移除两端指定的值
        if new_line[0] ==a:
            return True

def zhuche(a,b):
    """
    用于用户注册
    :param a: 用户名
    :param b: 密码
    :return: True   注册成功
    """
    c = open("334.txt", "a", encoding="utf-8")
    temp="
"+ f1 + "*" + f2
    c.write(temp)
    return True

def min():
    print("欢迎登录英雄联盟官网")
    m=input("登录：1；注册：2")
    if m=="1":
        f1=input("请输入用户名：")
        f2=input("请输入密码：")
        f3 = login(f1, f2)
        if f3:
            print("登录成功")
        else:
            print("登录失败")
    elif m=="2":
        f1=input("请输入用户名：")
        f2=input("请输入密码：")
        f4=yanzheng(f1)
        if f4:
            print("用户名已存在")
        else:
            f5=zhuche(f1,f2)
            if f5:
                print("恭喜注册成功")

min()

 2、冒泡排序

冒泡排序是排序中经典排序之一，它利用相邻元素比较并进行位置的互换...

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

li = [22, 4, 77, 44, 6, 99, 100, 3]
for j in range(1,len(li)):        #多循环几次把顺序排出来
    for i in range(len(li)-1):   #减1是因为最后一位不能比了
#        print(li[i])            先利用索引把li中元素循环出来
        if li[i]>li[i+1]:       #比较相邻俩数的大小
            temp=li[i]          #利用第三个数把大小不同的俩数位置互换
            li[i]=li[i+1]
            li[i+1]=temp
#    print(li)                   这样只能把最大的数挑出来
print(li)

3、递归

程序本身自己调用自己称之为递归，递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回

def f4():
    def f3():                         #f4函数中包括f3函数
        def f2():                     #f3函数中包括f2函数
            def f1():                 #f2函数中包括f1函数
                return "qqqq"         #f1函数的返回值"qqq"
            return f1()
        return f2()
    return f3()
m=f4()
print(m)    

 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

def f1(a1,a2):
    print(a1)
    a3=a1+a2
    f1(a2,a3)
f1(0,1)

 4、装饰器

定义：　　 装饰器用于装饰某个函数，可以让函数在执行前或执行后执行某些操作

@outer:   1、执行outer函数，并将其下面的函数名赋值给outer的参数

　　　　   2、将outer的返回值重新赋值给f1

def outer(func):
    def inner():
        print("222")
        print("222")
        r=func()
        print("3333")
        print("3333")
        return r
    return inner
@outer
def f():
    print("000")
r=f()
#1、遇到outer函数放到内存
#2、遇到@outer 执行outer函数，把@outer下面的函数名当做参数执行outer函数，
#3、把outer的返回值inner重新赋值给f
#4、现在执行f（）就相当于执行inner
#5、执行inner，先print("222")
#6、再执行func  ，这里的func是原来的函数f()既print("000")
#7、再执行print（"333"）
#8、返回一个原来函数的返回值r给inner就是现在的f

装饰器可以装饰具有处理n个参数的函数（利用*args和**kwargs）

def outer(func):
    def inner(*args,**kwargs):
        print("222")
        print("222")
        r=func(*args,**kwargs)
        print("3333")
        print("3333")
        return r
    return inner
@outer
def f(a1,a2):
    print("000")
r=f(1,2)　　　　　　　　#这里传的参数必须和f函数的参数个数一致

 多个装饰器同时对一个函数装饰的情况

def outer(func):
    def inner(*arg,**kwargs):
        print("123")
        ret=func(*arg,**kwargs)
        print("456")
        return ret
    return inner

def outer9(func):
    def inner(*arg,**kwargs):
        print("3.5")
        ret=func(*arg,**kwargs)
        return ret
    return inner

@outer
@outer9
def index(a1,a2):
    print("ffffff")
    return a1+a2
index(1,2)