python27期day12：推导式、内置函数、高阶函数、匿名函数、作业题

　　1、推导式：做一些有规律的数据结构

列表推导式：

　　　　　　普通循环模式：

　　　　　　[加工后的变量 for 循环]

　　　　　　示例一：print([i for i in range(1,51)])
　　　　　　结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]

　　　　　　示例二：print([i for i in range(1,51,2)])
　　　　　　结果：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49]

　　　　　　格式化：

　　　　　　print([f"python{i}期" for i in range(1,51)])
　　　　　　筛选模式：
　　　　　　[加工后的变量 for循环 加工条件]

　　　　　　print([i for i in range(1,51) if i > 25])
　　　　　　结果：[26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
for循环两个数的和：
lst = []
for i in range(2):
　　for j in range(2):
　　　　lst.append(i+j)
print(lst)
结果：[0, 1, 1, 2]
列表推导式两个数的和（推导式最多建议使用三层）：

print([i + j for i in range(2) for j in range(2)])
结果：[0, 1, 1, 2]
字典推导式：

print({i:i+1 for i in range(3)})
结果：{0: 1, 1: 2, 2: 3}
集合推导式：

print({f"{i}:{i+1}" for i in range(3)})
结果：{'1:2', '0:1', '2:3'}
{加工后的变量：加工后的变量 for循环 加工条件}

print({i:i+1 for i in range(3) if i >= 0})
结果：{0: 1, 1: 2, 2: 3}
推导式：用在哪？简化代码、提高可读性
生成一些有规律的数据、生成的数据较大时建议使用生成器推导式
for循环索引推导式：

s = "alex,meet"
count = 0
for i in s:
    if i == "e":
        print(count)
    count += 1
结果：2
　　　6
　　　7
len索引推导式：

print([i for i in range(len(s)) if s[i] == "e"])
列表嵌套推导式：

names = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
         ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']
]
写法一：
for i in names:
    for em in i:
        if "e" in em:
            print(em)
写法二：
print([em for i in names for em in i if "e" in em])
偶数推导式：

print([i for i in range(30) if i % 3 is 0])
结果：[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
过滤和转大写：

l = ['wusir','laonanhai','aa','b','taibai']
print([i.upper() for i in l if len(i) > 3])
结果：['WUSIR', 'LAONANHAI', 'TAIBAI']
2、生成器表达式和列表推导式的语法上一模一样、只是把[]换成()就行了、例如将10以内所有数的平方放到一个生成器表达式中：

gen = (i**2 for i in range(10))
print(gen)　　　　　　　　　　　　　　 #得到生成器对象
print(gen.__next__())　　　　　　　　#生成一个数
print(next(gen))　　　　　　　　　　　#再次生成一个数
生成器表达式进行筛选：

gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
    print(num)
3、生成器表达式和列表推导式的区别？
列表推导式比较耗内存、所有数据一次性加载到内存、而生成器表达式遵循迭代器协议、逐个产生元素。
得到的值不一样、列表推导式得到的是一个列表、生成器表达式获取的是一个生成器
列表推导式一目了然、生成器表达式只是一个内存地址
无论是生成器表达式还是列表推导式、只是python提供了一个相对简单的构造方式、因为使用推导式非常简单、推导式只能构建相对复杂的并且有规律的对象
对于没有什么规律、而且嵌套层数比较多不建议使用推导式构建
生成器的惰性机制：生成器只有在访问的时候才取值、
4、内置函数：python写了很多功能避免重复造轮子
一带而过：
all()　　#判断元素是否都为true
any()　　#判断元素是否有一个是true就是true
bytes() #字符串转字节
callable("你好")　　#判断是否可调用
chr()　　#根据当前编码查看对应的内容
complex()　　#查看复数
divmod()　　#获取是元组、第一个是商、第二个是余数
eval()　　#禁用
exec()　　#禁用
frozenset()　　#冻结集合
globals()
hash()　　#有值是不可变的数据类型
help()　　#查看方法的帮助信息
id()　　　
input()
int()
iter()
locals()
next()
oct()　　#十进制转成八进制
bin()　　#十进制转成二进制
hex()　　#十进制转成十六进制
print(int("0x1e",16))　　#十六进制转成十进制
ord()　　#根据值查看当前编码
pow()　　#幂
repr()　　#原形毕露
round()　　#保留小数位
重点记住：
abs()　　#绝对值
format()　　#格式化
enumerate()　　#枚举、自动获取元素下标、自动计数
filter()
map()
max()
min()
open()
range()
print()
len()
list()
dict()
str()
float()
reversed()
set()
sorted()　　#排序
sum()
tuple()
type()
zip()
dir()　　#查看当前对象都有什么方法
未来会用：
classmethod()
delattr()
getattr()
hasattr()
issubclass()
isinstance()
object()
property()
selattr()
staticmethod()
super()
5、高阶函数：
filter（规则函数，可迭代对象）、
map（规则函数，可迭代对象，可迭代对象）、
max（）、
min（）、
reversed（可迭代对象）、
sorted（可迭代对象，key = 规则函数）、
reduce（累加函数，可迭代对象）、
zip（）、
6、匿名函数，顾名思义就是没有名字的函数，那么什么函数没有名字呢？这个就是我们以后面试或者工作中经常用匿名函数 lambda，也叫一句话函数。
现在有一个需求：你们写一个函数，此函数接收两个int参数，返回和值。

def func(a,b):
    return a+b
print(func(3,4))
那么接下来我们用匿名函数完成上面的需求：

func = lambda a,b: a+b
print(func(3, 4))  # 7
语法：

​ 1）此函数不是没有名字，他是有名字的，他的名字就叫做lambda

​ 2）lambda 是定义匿名函数的关键字，相当于函数的def.

​ 3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。　　

​ 4）返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。(但是想要返回多个元素要以容器的形式返回)

​ 5）匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。

func = lambda x:(x[0],x[2])
print(func('afafasd'))

7、匿名函数三元表达式：
func = lambda x,y: x if x > y else y
print(func(3,100))
结果：100
8、匿名函数lambda和有名函数def：

f = lambda a,b:a + b
print(f(1,2))
# 结果3
def func(a,b):
    c = a + b
    return c
print(func(1,2))
# 结果3
lambda和def是一样的、
a,b和（a,b）是一样的
：a + b和return a + b是一样的
冒号前面叫做形参、冒号后面叫做返回值
形参可以接受位置参数、动态位置、默认、动态关键字参数、形参不可不写
返回值只能返回一个数据、返回值必须写
返回值是多个时用括号包起来

print(f.__name__)--查看函数名
9、lambda函数举例：

# g = [lambda i:i+1 for i in range(3)]　　#首先这是列表推导式、循环三圈得到三个匿名函数lambda、例如定义是L、第二圈还是L、第三圈还是L、函数体中存的是代码、也可以把for i定义成for j、整个推完之后有三个函数的内存地址定义为g、
# print([em(3) for em in g])　　　　　　　　 #然后循环三个内存地址定义em、加括号运行、命名参数3、得到结果3+1=4、第二圈还是4、第三圈还是4

#上面两行代码拆解：
lst = []
for i in range(3):          #for循环0到3
    def func(i):            #形参是i也就是0、1、2
        return i + 1        #返回值是循环的每个值加1
    lst.append(func)        #往空列表里面增加func函数的内存地址
print(lst)                  #打印出lst列表里面的3个func函数的内存地址
# 结果：[<function func at 0x00000000001E2EA0>, <function func at 0x0000000001E9AB70>, <function func at 0x0000000001E9AA60>]

new_lst = []                #新建空列表new_lst
for em in lst:              #循环lst列表里面的3个func函数的内存地址
    new_lst.append(em(3))    #空列表里面增加3个func函数的内存地址运行结果、说白了在调用func、但是func函数需要参数i、所以增加em里面增加一个参数3
print(new_lst)              #打印new_lst列表
# 结果：[4, 4, 4]
10、lambda函数举例二：

# g = (lambda i:i+1 for j in range(3))
# print([em(3) for em in g])
#上面两行代码拆解：
def foo():
    for j in range(3):
        def func(i):
            return i + 1
        yield func
g = foo()
# print(g)                   #得到生成器
# print(next(g))             #得到函数的内存地址

lst = []
for i in g:
    lst.append(i(3))
print(lst)
结果：[4,4,4]
11、小括号是生成器推导式、中括号是列表推导式
12、lambda函数举例三：

# g = [lambda :i+1 for i in range(3)]
# print([em() for em in g])
#上面两行代码拆解：
g = []
for i in range(3):
    def func():
        return i + 1
    g.append(func)
print(g)

new_lst = []
for em in g:
    new_lst.append(em())
print(new_lst)
结果：[3,3,3]
13、lambda函数举例四：

g = (lambda :i+1 for i in range(3))
print([em() for em in g])
#上面两行代码拆解：
def foo():
    for i in range(3):
        def func():
            return i + 1
        yield func
g = foo()

lst = []
for i in g:
    lst.append(i())
print(lst)
结果：[1,2,3]
14、lambda函数举例五：

g = [lambda x:x*i for i in range(3)]
for j in [2,10]:
    g1 = (em(3) for em in g)
print([e+j for e in g1])
结果：[16, 16, 16]
15、lambda函数举例六：

lst = []    #[func,func,func]
for i in range(3):
    def func(x):
        return x * i                    #3*2
    lst.append(func)

for j in [2,10]:
    def g1():                           #循环产生两个生成器、第二个生成器10覆盖第一个的2
        for em in lst:
            yield em(3)                 #func(3)

new_lst = []
for e in g1():
    new_lst.append(e + j)               #g1是6、e是6、j是10
print(new_lst)
# 结果：[16, 16, 16]
16、模拟高阶函数filter过滤：

filter函数是把列表中的值所有的都筛选一遍最后在得到一个值（列表）

lst = [1,2,3,4,54,65,7,8]
def foo(x): #规则函数
    return x > 4    #判断的是True和False

def f(func,iter):   #filter
    lst = []        #[54,65,7,8]
    for i in iter:
        if func(i):
            lst.append(i)
    return lst
print(f(foo,lst))
# 结果：[54, 65, 7, 8]
17、高阶函数filter：

lst = [1,2,3,4,54,65,7,8]
print(list(filter(lambda x:x > 4,lst)))

18、#过滤掉年龄大于等于17的

lst = [{'id':1,'name':'alex','age':18},
       {'id':1,'name':'wusir','age':17},
       {'id':1,'name':'taibai','age':16},]
print(list(filter(lambda x:x["age"] >= 17,lst)))
结果：[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}]

19、过滤掉名字长度大于等于5的（过滤出是拿到、过滤掉是不要）

lst = [{'id':1,'name':'alex','age':18},
       {'id':1,'name':'wusir','age':17},
       {'id':1,'name':'taibai','age':16},]
print(list(filter(lambda x:len(x["name"]) >= 5,lst)))
# 结果：[{'id': 1, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'taibai', 'age': 16}]
20、高阶函数map映射--将可迭代对象中每个元素执行函数功能：

map函数是装一个列表依次处理得到的还是一个列表，跟原先的列表顺序一样、只不过每个元素被处理了

转成字符串：

lst = [1,2,3,4,5,6,8,9]
print(list(map(str,lst)))
# 结果：['1', '2', '3', '4', '5', '6', '8', '9']
合并求列表和：

lst1 = [1,2,3]
lst2 = [3,2,1]
print(list(map(lambda x,y:x + y,lst1,lst2)))
结果：[4, 4, 4]
21、sorted排序函数：

lst = [1,2,3,4,65,7]
print(sorted(lst))  #新建列表
结果：[1, 2, 3, 4, 7, 65]

lst.sort()
print(lst)          #原地修改
结果：[1, 2, 3, 4, 7, 65]

print(sorted("alex,mdsb"))              #升序
结果：[',', 'a', 'b', 'd', 'e', 'l', 'm', 's', 'x']

print(sorted("alex,mdsb",reverse=True)) #降序
结果：[',', 'a', 'b', 'd', 'e', 'l', 'm', 's', 'x']
排键：

dic = {1:"a",3:"c",2:"b"}
print(sorted(dic))
结果：[1, 2, 3]
四大名著排序：

lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key = len))    #key = 排序规则
结果：['西游记', '红楼梦', '天龙八部', '三国演义']

lst = [{'id':1,'name':'alex','age':18},
       {'id':2,'name':'wusir','age':17},
       {'id':3,'name':'taibai','age':16},]
print(sorted(lst,key=lambda x:x['age'],reverse=True))
# 结果：[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 3, 'name': 'taibai', 'age': 16}]
22、max最大值：

print(max([1,2,3,4,5,6,-9,10,-22],key=abs))
结果：-22
23、min最小值：

print(min([1,2,3,4,5,6,-9,10,-22],key=abs))
结果：1
24、reduce累计算：

reduce函数是可以把完整的序列合并到一块儿最终得到一个值

累乘：

from functools import reduce
lst = [1,2,3,4,5]
print(reduce(lambda x,y:x*y,lst))
结果：120
25、zip拉链：

lst1 = [1,2,3,4,5]
lst2 = [5,4,3,2,1]
print(list(zip(lst1,lst2)))
结果：[(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]

26、print加参数分隔符

print("alex","wusir","太亮",sep="|")
结果：alex|wusir|太亮

print("alex","wusir","太亮",sep="|",end="")
print("meet")
结果：alex|wusir|太亮meet
作业题：
三次登陆锁定：

"""
四.用代码实现三次用户登录及锁定(选做题,这是一个单独的程序)
项目分析:
一.首先程序启动,显示下面内容供用户选择:
1.注册
2.登录
a.用户选择登录的时候,首先判断用户名在userinfo.txt表中存在不在,存在就不能进行注册
b.当注册的用户名不存在的时候将用户名和密码写入到userinfo.txt文件中
c.用户选择登录的时候,判断用户输入的账号和密码是否userinfo.txt存储的一致
d.用户名和密码一致就终止循环,并提示用户登录成功!
e.用户名和密码不一致,只有三次登录机会,三次过后提示用户名被锁定,请联系管理员!并终止循环
f.当用户名错误三次,再次运行程序.登录锁定的账号继续提示用户名被锁定,请联系管理员!
"""
# 结束标识
quite_flag = False  # ------------------------------2、

# 错误登录次数 #------------------------------------3、
login_fail = 0

# 登录功能
def login():  # -----------------------------5、
    """
    登录
    :return:
    """
    while True:
        global login_flag  # 定义全局登录状态
        global quite_flag  # 定义全局结束标识
        global login_fail  # 定义全局登录次数
        user_name = input ( "请输入登录用户名：" )
        password = input ( "请输入密码：" )
        if user_name in userinfo_dic:
            login_flag = True if password == userinfo_dic[user_name] else False
            if userinfo_dic[user_name + "locked"] == "True":
                login_flag = False
                print ( "用户名被锁定,请联系管理员！" )
                break
            if login_flag:
                print ( "登陆成功！" )
                quite_flag = True
                break
            else:
                login_fail += 1
                if login_fail == 3:
                    modif_userinfo(user_name,userinfo_dic[user_name],str(True))
                    quite_flag = True
                    print("用户名被锁定，请联系管理员！")
                    break
                else:
                    print("用户账号或密码错误，请重新输入")
        else:
            print("用户名不存在！请重新输入！")

# 注册功能
def register():
    """
    注册
    :return:
    """
    while True:
        user_name = input ( "请输入用户名（不能有特殊字符）：" )
        password = input ( "请输入密码长度要在6~14个字符之间：" )
        if user_name not in userinfo_dic:
            if user_name.isalnum () and 5 < len ( password ) < 15:
                write_userinfo ( user_name, password )
                print ( "注册成功！" )
                global login_fail                                   # 声明全局错误登录次数
                login_fail = 0
                global login_flag                                   # 声明全局登录状态
                login_flag = True                                   #改成登录状态True
                break                                               #改成break相当于注册完毕了
            else:
                print ( "输入错误，请重新输入" )
        else:
            print ( "用户名已存在！请重新输入！" )

def quite():
    """
    退出
    :return:
    """
    global quite_flag
    quite_flag = True

# 定义用户读取文件信息功能
def read_userinfo(path_add: str):
    """
    读取用户信息
    :return:
    """
    with open ( path_add, "a+", encoding="utf-8" ) as f:
        global userinfo_dic
        f.seek ( 0 )
        for i in f:
            if i != "\n" and i != "" and i is not None:
                userinfo_dic[i.split ( ":" )[0].strip ()] = i.split ( ":" )[1].strip ()
                userinfo_dic[i.split ( ":" )[0].strip () + "locked"] = i.split ( ":" )[2].strip ()

# 定义用户写入文件信息功能
def write_userinfo(user_name: str, password: str):
    """
    写入用户信息
    :param user_name:
    :param password:
    :return:
    """
    with open ( path_add, "a", encoding="utf-8" ) as f1:    #a模式、防止文件不存在时报错
        f1.write ( f"\n{user_name}:{password}:False" )     #第一次注册往字典里面添加状态没有被锁定
        f1.flush ()
        global login_fail                                   # 定义全局错误登录次数
        userinfo_dic[user_name] = password                  # 字典是可变数据类型、在局部使用全局进行修改不用使用global、往字典里面增加键值对
        userinfo_dic[user_name + "locked"] = str ( False )  # 往用户信息字典里面建立用户锁定状态

# 定义用户锁定信息功能
def modif_userinfo(user_name: str, password: str, locked: str):
    """
    锁定用户信息修改
    :param user_name:
    :param password:
    :param locked:
    :return:
    """
    with open ( path_add, "r", encoding="utf-8" ) as f4, \
            open ( path_add.replace ( ".txt", "1.txt" ), "w", encoding="utf-8" ) as f5:
        for i in f4:
            if i != "\n" and i.split ( ":" )[0].strip () == user_name:
                i = f"{user_name}:{password}:{locked}\n"
            f5.write ( i )
            f5.flush ()
        global userinfo_dic
        userinfo_dic[user_name] = password
        userinfo_dic[user_name + "locked"] = locked
    import os
    import time
    os.rename ( path_add, path_add.replace ( ".txt", str ( time.time () ) + ".bak" ) )
    os.rename ( path_add.replace ( ".txt", "1.txt" ), path_add )
    global login_fail  # 定义全局登录次数
    login_fail = 0

# 组成字典容器
choose_dic = {"1": register,
              "2": login,
              }

# 新建已注册的用户账户和密码字典形式：
userinfo_dic = dict ()

# 定义文件地址信息存储位置变量
path_add = "userinfo_single.txt"

# 读取一下已经注册的用户和密码
read_userinfo ( path_add )

# 登陆信息提示：#-----------------------------------1、
print ( """1.注册
2.登录""" )

# 主程序    #---------------------------------------4、
while not quite_flag:
    choose = input ( "请选择您要进行的操作对应的序号：" )
    choose_dic[choose] () if choose in choose_dic else print ( "输入错误，请重新输入！" )
else:
    print ( "结束" )

# 1、用列表推导式做下列小题
lst = ["alex","wusir","太白","宝元"]
# 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
print([i.upper() for i in lst if len(i) > 3])
# 2、求[{x:y}]其中x是0-5之间的偶数组成的元组的，y是0-5之间的奇数组成的元组
print([{tuple([i for i in range(0,6,2)]):tuple([i for i in range(1,6,2)])}])
# 3、求3,6,9 组成的列表结果: M = [[1,2,3],[4,5,6],[7,8,9]]
print([[i for i in range(1,4)],[i for i in range(4,7)],[i for i in range(7,10)]])
# print([i-2,i-1,i] for i in [3,6,9])?????????????????????????这道题我不会做太难了
# 4、求出50以内能被3整除的数的平方，并放入到一个列表中。
print([i**2 for i in range(51) if i // 3])
# 5、构建一个列表：['python1期', 'python2期', 'python3期', 'python4期', 'python6期', 'python7期', 'python8期', 'python9期', 'python10期']
print(["python%s期" %i for i in range(1,11)])
# 6、构建一个列表：[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
# 7、构建一个列表：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print([i for i in range(20) if i % 2 == 0])
# 8、有一个列表l1 = ['alex', 'WuSir', '老男孩', '太白']将其构造成这种列表
# ['alex0', 'WuSir1', '老男孩2', '太白3']
print(['%s%s' %(l1,i) for i,l1 in enumerate(l1)])
# for循环形式：
# l1 = ['alex','Wusir','老男孩','太白']
# for i,em in enumerate(l1):
#     print(em + str(i))
# 9、有以下数据类型：
x = {
'name':'alex',
'Values':[{'timestamp':1517991992.94,
'values':100,},
{'timestamp': 1517992000.94,
'values': 200,},
{'timestamp': 1517992014.94,
'values': 300,},
{'timestamp': 1517992744.94,
'values': 350},
{'timestamp': 1517992800.94,
'values': 280}
],}
# 将上面的数据通过列表推导式转换成下面的类型：[[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]]
print([[i["timestamp"],i["values"]] for i in x["Values"]])
# 10、构建一个列表，列表里面是三种不同尺寸的T恤衫，每个尺寸都有两个颜色（列表里面的元素为元组类型）。
# colors = ['black', 'white']
# sizes = ['S', 'M', 'L']
print(list(zip(colors,sizes)))
# 11、构建一个列表,列表里面的元素是扑克牌除去大小王以后，所有的牌类（列表里面的元素为元组类型）。
# l1 = [('A','spades'),('A','diamonds'), ('A','clubs'), ('A','hearts')......('K','spades'),('K','diamonds'), ('K','clubs'), ('K','hearts') ]
# 12、看代码求结果（面试题）：
# v = [i % 2 for i in range(10)]
# print(v)
# 结果：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
# v = (i % 2 for i in range(10))
# print(v)
# 结果：<generator object <genexpr> at 0x0000000002152D00> #生成器内存地址