运算

[b]1、用户登录，验证，注册[/b]

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="\n"+ 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()

[b] 2、冒泡排序[/b]

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

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

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)

[b]3、递归[/b]

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

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)

[b] 4、装饰器[/b]

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

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