上次回顾，用户登录程序，递归，冒泡算法，装饰器

一、上节内容回顾：

lambda 表达式
　　func = lambda x ,y : 9+x
参数：x ， y
　　函数体 9+x ==》 return 9+x
　　func 函数名字
函数：函数名可当做参数传给另一个函数。
函数名（）———> 执行函数
函数名—————》代指函数

def f1():
    return 'F1'

def f2(x):
    return "F2"

x = 123
qq = f2(f1())
print(qq)

内置函数：
abs 绝对值
all（）每个元素为真就为真
any（）有一个元素为真就是真
bin（）十进制转二进制
hex（）十进制转十六进制
int（）所有的通过他可以转十进制
oct（）十进制转八进制
bool（）空值，空字符串，0，None，空列表，空元祖，空字典
bytes（）字符串转为字节，注意编码格式
chr（） ASCII
ord() ASCII
dir() 找功能
help（）找功能
enumerate（）添加迭代值
eval（）执行一个表达式，有返回值
exec（）执行一个表达式，没有返回值，需要新变量接收。
filter（）过滤第一个参数 filer（f1,[11,22,33]）
map()
```
def f1(x):
    return x +100
ret = map(f1, [1,2,3,4,5])
for i in ret:
    print(i)
```
open（）文件操作
1、文件路劲
2、模式
基本操作：
r，只读
w，只写（先清空）
　　 x，不存在，创建，存在，报错：只写
二进制
　　rb
wb
　　xb
ab
+
r+ ，读写：读，从0开始读，写，先读，最后位置追加，主动seek，写从当前指针向后写。（最长用r+）
　w+，读写：先从空，在写
　x+,读写：先清空，再写，已有文件，会报错。
a+，读写：读，最后位置读取。写，最后追加，主动seek，还是最后追加
trancate, 截取前面的内容。
read，read（1）：无b，字符有b ，字节
write（）
str ：无b，字符串 bytes 有b 字节
readline 只读取一行，第二次执行readline 则读取第二行，以此类推。
readlines：【‘第一行’，“第二行”’】
flush：强行刷入硬盘
close
tell（）获取指针位置
seek（）跳转到某个位置。
with open （xxx） as f:
　　print

二、用户登录：

def login(username,password):
     """
     用于用户密码的验证
     :param username: 用户名
     :param password: 密码
     :return:  True，用户名验证成功。False ，用户验证失败。
     """
     f = open('db', 'r' , encoding='utf-8' )
     for line in f:
         #默认strip 无参数：空格，换行符
        #有参数：移除两侧指定的值：
        line = line.strip()
        line_list = line.split('$') #split 分割，已$分割
        if username == line_list[0]  and  password == line_list[1]:
             return True
     return False


user = input("请输入用户名")
pwd = input('请输入密码：')
is_login = login(user,pwd)
if is_login:
    print('登录成功')
else:
    print('登录失败')

用户登录完整版：

def login(username,password):
     """
     用于用户密码的验证
     :param username: 用户名
     :param password: 密码
     :return:  True，用户名验证成功。False ，用户验证失败。
     """
     f = open('db', 'r' , encoding='utf-8' )
     for line in f:
         #默认strip 无参数：空格，换行符
        #有参数：移除两侧指定的值：
        line = line.strip()
        line_list = line.split('$') #split 分割，已$分割
        if username == line_list[0]  and  password == line_list[1]:
             return True
     f.close()
     return False

def user_exits(username):
    '''
    判断用户名是否已经存在
    :param username: 新用户名
    :return: True，表示用户名已存在。False ，不存在。
    '''
    with open('db', 'r', encoding='utf-8') as f:
        for line in f:
            line =  line.strip()
            line_list = line.split('$')
            if username == line_list[0]:
                return  True
    return False

def register (username,password):
    '''
    新用户名和密码写入文件
    :param username: 新用户名
    :param password: 密码
    :return:  True ，注册成功。False ，注册失败。
    '''
    with open('db', 'a+' , encoding='utf-8') as f:
        temp = '\n' + username + "$" + password
        f.write(temp)
        return True

def main():
    i = int(input('1.注册   2.登录'))
    if i == 1:
        use = input('用户名')
        pwd  = input('密码：')
        ret = user_exits(use)
        if  ret: #user_exits 返回True 则用户名已存在。
            print('注册失败')
        else:
            ret2 = register(use, pwd)
            if ret2:
                print('注册成功')

    else:
        user = input("请输入用户名")
        pwd = input('请输入密码：')

        is_login = login(user, pwd)
        if is_login:
            print('登录成功')
        else:
            print('登录失败')


main()

二、冒泡排序

　　基础

　　数据库设计

　　算法题

#冒泡排序法
li = [11,22,55,44,88,33]

for j in range(1,len(li)):
 
    for i in range(len(li) -j):
        if li[i] > li[i + 1]:
            temp = li[i]
            li[i] = li[i + 1]
            li[i + 1] = temp
print(li)

递归：

def f4(a1, a2):
    if a1 > 10000:
        return
    print(a1)
    a3 = a1 + a2
    f4(a2, a3)
f4(0,1)

装饰器：

def outer(func):
    def inner():
        print('hello')
        r = func()
        print('end')
        return r
    return inner

@outer
#1、执行outer函数 ，并且将其下面的函数名，当做参数
#2、 将outer的返回值重新赋值给f1=outer的返回值
def f1():
    print('F1')
#新F1函数，=inner
f1()

函两个参数的装饰器;

def outer(func):
    def inner(a1, a2):
        print('hello')
        r = func(a1, a2)
        print(r)
        print('end')
        return r
    return inner

@outer
#1、执行outer函数 ，并且将其下面的函数名，当做参数
#2、 将outer的返回值重新赋值给f1=outer的返回值
def f1(a1, b1):
    print('F1')
    return a1 + b1

#新F1函数，=inner
f1(1, 2)

装饰器函N个参数的函数

def outer(func):
    def inner(*args, **kwargs):
        print('hello')
        r = func(*args, **kwargs)
        print(r)
        print('end')
        return r
    return inner

@outer
#1、执行outer函数 ，并且将其下面的函数名，当做参数
#2、 将outer的返回值重新赋值给f1=outer的返回值
def f1(a1, b1, c1 , d1):
    print('F1')
    return a1 + b1 + c1 + d1

#新F1函数，=inner
f1(1, 2, 3, 4)

装饰器之：多个装饰器装饰一个函数。

def outer_0(func):
    def inner(*args, **kwargs):
        print('3.5')
        r = func(*args, **kwargs)
    return inner


def outer(func):
    def inner(*args, **kwargs):
        print('hello')
        r = func(*args, **kwargs)
        print(r)
        print('end')
        return r
    return inner
@outer_0  # 看到的效果是 先执行 outer_0 在执行outer
@outer
#1、执行outer函数 ，并且将其下面的函数名，当做参数
#2、 将outer的返回值重新赋值给f1=outer的返回值
def f1(a1, b1, c1 , d1):
    print('F1')
    return a1 + b1 + c1 + d1

#新F1函数，=inner
f1(1, 2, 3, 4)

装饰器之：多个装饰器装饰一个函数流程梳理

单个装饰器：

　　1、@outer将 index 函数当做参数传给outer函数

　　2、outer函数中有inner 函数，inner函数中的func（）函数等价于index函数，

　　　　inner函数中return ret 返回值给inner 。return inner 返回值给 index函数的调用者。

多个装饰器：

　　1、@outer_0 将 @outer 和 index当做一个参数，传给@outer_0 ，之后的执行循序如上图。

posted @ 2019-06-09 18:09 Freechen0 阅读(96) 评论(0) 收藏举报

刷新页面返回顶部

Freechen0

上次回顾，用户登录程序，递归，冒泡算法，装饰器

公告