8.6 8.8 学习笔记

***********************day 8.6***************************

'''
def add(n,i):
    return n+i

def test():
    for i in range(4):
        yield i

g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)          #n+i   1...4,且为g=算式的形式，
# n = 1
# g=(add(n,i) for i in test())
# n = 10
# g=(add(n,i) for i in (add(n,i) for i in test()))
# n = 5
# g=(15,16,17,18)


print(list(g))       #在n到10为止之前都没有真正执行，当list（g）才开始，此时的n为5
g=test()
for n in [1,10,5]:
    g=(add(n,i) for i in g)
# n=1 g=(add(n,i) for i in 0,1,2,3)=1.2.3.4
# n=5 6.7.8.9
# n=10 16.17 18 19
print(list(g))
'''
# print(locals())  #返回本地作用域中的所有名字
# print(globals()) #返回全局作用域中的所有名字

# dir 查看一个变量拥有的方法
# print(dir([]))
# print(dir(1))

# 某个方法属于某个数据类型的变量，就用.调用
# 如果某个方法不依赖于任何数据类型，就直接调用  —— 内置函数 和 自定义函数

#id
#hash - 对于相同可hash数据的hash值在一次程序的执行过程中总是不变的
#     - 字典的寻址方式
# print(hash(12345))
# print(hash('hsgda不想你走，nklgkds'))
# print(hash(('1','aaa')))
# print(hash([]))

print('我们的祖国是花园',end='少时诵诗书')  #指定输出的结束符
print('我们的祖国是花园',end='')
print(1,2,3,4,5,sep='|') #指定输出多个值之间的分隔符         sep 用什么分割， 默认end=‘|n’，
f = open('file','w')
print('aaaa啊啊啊啊奥奥奥奥奥奥奥奥奥奥奥奥奥奥奥多多多多多大奥奥奥奥奥奥奥奥奥奥奥奥奥奥奥多无多',file=f)
f.close()
**************************day8.8**********************

#进度条
# import time
# for i in range(0,101,2):
#      time.sleep(0.1)
#      char_num = i//2
#      per_str = '\r%s%% : %s\n' % (i, '*' * char_num) \
#          if i == 100 else '\r%s%% : %s' % (i,'*'*char_num)
#      print(per_str,end='', flush=True)
#progress Bar 更加专业

# exec('print(123)')
# eval('print(123)')
# print(eval('1+2+3+4'))   # 有返回值
# print(exec('1+2+3+4'))   #没有返回值
# exec和eval都可以执行 字符串类型的代码
# eval有返回值  —— 有结果的简单计算
# exec没有返回值   —— 简单流程控制
# eval只能用在你明确知道你要执行的代码是什么
#
# code1 = 'for i in range(0,10): print (i)'
# compile1 = compile(code1,'','exec')
# exec(compile1)
#
# code2 = '1 + 2 + 3 + 4'
# compile2 = compile(code2,'','eval')
# print(eval(compile2))
#
# code3 = 'name = input("please input your name:")'      #eval简单运算 exec流程控制 single交互
# compile3 = compile(code3,'','single')
# exec(compile3) #执行时显示交互命令，提示输入        cpmpile1=compile（被编译变量名,'',模式名)
# print(name)
#name #执行后name变量有值
"'pythoner'"
# 浮点数（有限循环小数，无限循环小数）  != 小数 ：有限循环小数，无限循环小数，无限不循环小数
# 浮点数
    #354.123 = 3.54123*10**2 = 35.4123 * 10
    #位数过长有限制
# print(bin(10))          #2进制
# print(oct(10))          #8进制
# print(hex(10))          #16进制
# print(divmod(7,2))   # div出发 mod取余   (3, 1)(1, 4) 3余1 1余4
# print(divmod(9,5))   # 除余
# print(round(3.14159,3)) #约束，约数位

# ret = sum([1,2,3,4,5,6,10],)
# print(ret)
# print(max([1,2,3,4]))
# print(max(1,2,3,4))
# print(max(1,2,3,-4))
# print(max(1,2,3,-4,key = abs))       #全体去取abs之后再比较

#reversed()
# l = [1,2,3,4,5]
# l.reverse()
# print(l)
# l = [1,2,3,4,5]
# l2 = reversed(l)
# print(l2)
# #保留原列表，返回一个反向的迭代器

# l = (1,2,23,213,5612,342,43)
# l2=(5,55,555,5555,5556,56,5,64)
# sli = slice(1,5,2)      #切下标为前两位的值，最后一位为步长值，且顾头不顾腚,且为函数的执行，普通括号
# print(l2[sli])       #用slice时，要将切割内容的放入变量中，再用函数名【】的形式调用
# print(l[1:5:2])
#
# print(format('dasd', '<20'))
# print(format('test', '>40'))
# print(format('test', '^40'))
# print(format('dasdddd','^80'))
#
# #bytes 转换成bytes类型
# # 我拿到的是gbk编码的，我想转成utf-8编码
# print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes
# print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes,编辑时为万国马，然后通过encoding转成想要格式，以bytes输出（最外面）
# print(bytes('卧槽',encoding='utf-8'))
# 网络编程 只能传二进制
# 照片和视频也是以二进制存储
# html网页爬取到的也是编码
# b_array = bytearray('你好',encoding='utf-8')   #输出bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
# print(b_array)
# print(b_array[0])
# # '\xe4\xbd\xa0\xe5\xa5\xbd'
# s1 = 'alexa'
# s2 = 'alexb'
# l = 'ahfjskjlyhtgeoahwkvnadlnv'
# l2 = l[:10]
# 切片 —— 字节类型  不占内存
# 字节 —— 字符串 占内存
# print(ord('好'))
# print(ord('1')) #ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
# print(chr(97),'*')   #对0-256的整数作参数，返回一个对应的字符  ascii--97
#
# print(ascii('好'))
# print(ascii('1'))   #返回ascii码
# name = 'egg'
# print('你好%r'%name)
# print(repr('1'))       #函数将对象转化为供解释器读取的形式。
# print(repr('egg'))
#
# print(all(['a','',123]))   #所有元素是否都为 TRUE，如果是返回 True，否则返回 False    f
# print(all(['a',123]))      #t
# print(all([0,123]))          #f
#
# print(any(['',True,0,[]]))   #用于判断给定的可迭代参数 iterable **是否全部为 False***，则返回 False，如果有一个为 True，则返回 True。

# l = [1,2,3,4,5]
# l2 = ['a','b','c','d']
# l3 = ('*','**',[1,2])       #几个可迭代类型封装在一起
# d = {'k1':1,'k2':2}
# for i in zip(l,l2,l3,d):      #讲一个
#     print(i)
# def is_odd(x):
#     return x % 2 == 1
# def is_str(s):
#     return s and str(s).strip()
# ret = filter(is_odd, [1,  6, 7, 12, 17])
# ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
# print(ret)
# for i in ret:
#     print(i)
# print([i for i in [1, 4, 6, 7, 9, 12, 17] if i % 2 == 1])
import math
# from math import sqrt
# def func(num):
#     res = sqrt(num)
#     return res % 1 == 0
# ret = filter(func,range(1,101))
# for i in ret:
#     print(i)

# ret = map(abs,[1,-4,6,-8])  #先处理，后输入内容 结果为值的个数不变，但是受到处理
# print(ret)     #map() 会根据提供的函数对指定序列做映射。
# for i in ret:  #第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
#     print(i)
# dd=map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# print(list(dd))     #双元素的相加，list输出

# filter 执行了filter之后的结果集合 <= 执行之前的个数
#         filter只管筛选，不会改变原来的值
# map 执行前后元素个数不变
#       值可能发生改变

# l = [1,-4,6,5,-10]
# l.sort(key = abs)   # 在原列表的基础上进行排序  （）内用key=关键词
# print(l)
#
# print(sorted(l,key=abs,reverse=True))      # 生成了一个新列表 不改变原列表 占内存 可调反向
# print(l)

#filter 执行了filter之后的结果集合 <= 执行之前的个数
#        filter只管筛选，不会改变原来的值
#map 执行前后元素个数不变
#      值可能发生改变

# l = [1,-4,6,5,-10]
# # l.sort(key = abs)   # 在原列表的基础上进行排序
# # print(l)
#
# print(sorted(l,key=abs,reverse=True))      # 生成了一个新列表 不改变原列表 占内存
# print(l)
#
# l1 = ['   ',[1,2],'hello world']
# new_l1 = sorted(l1,key=len)
# print(new_l1)
#
# print(sorted(l,key=abs,reverse=True))   #l.sorted(key=abs,reverse=True)  不可
# print(sorted(l1,key=len,reverse=True))

# add=lambda x,y:x+y
# print(add(1,2))
#
# dic={'k1':10,'k2':100,'k3':30}
# def func(key):
#     return dic[key]
# print(max(dic,key=func))   #根据返回值判断最大值，返回值最大的那个参数是结果
# print(max(dic,key=lambda key:dic[key]))   #根据返回值判断最大值, 缩短了
# print(max([1,2,3,4,5,-6,-7],key=abs))
'''
ret = map(abs,[-1,2,-3,4])
for i in ret:
    print(i)
sd=map(abs,[1,2,3,4,5,-6,-7,-8,-9])
print(list(sd))

def func(x):
    return x**2
ret = map(func,[-1,2,-3,4])
for i in ret:
    print(i)
ret=map(lambda x:x**x,[-1,2,-3,4])          #lambda可以看成一个函数的返回值，或者一个数，所以可在很多地方写
res=filter(lambda d:d*d>2,[1,2,3,4,5,-6,-7,-8,-9])   #filter and map 括号内前功能可以判断，后可迭代对象
print(list(res),'***')
ret = map(lambda x:x**2,[-1,2,-3,4])
'''
#面试题
# d = lambda p:p*2
# t = lambda p:p*3
# x = 2
# x = d(x) #x = 4
# x = t(x) #x = 12
# x = d(x) #x = 24
# print(x)

#现有两元组(('a'),('b')),(('c'),('d')),
#请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
ret = zip((('a'),('b')),(('c'),('d')))
'''
def func(tup):
    return {tup[0]:tup[1]}      #挤成字典的形式
res=map(func,ret)                #全体处理  map（功能，对象），使得被捆绑函数中的所有对象被键值对
print(list(res))               #打印外壳
'''
# ret = map(lambda t:{t[0]:t[1]},ret)
# print(ret)
# print(list(ret))
#
# #匿名函数 == 内置函数 # max min sorted filter map
# #zip
# ret = zip((('a'),('b')),(('c'),('d')))
# res = map(lambda tup:{tup[0]:tup[1]},ret)
# print(list(res))
#
# def multipliers():
#     return [lambda x:i*x for i in range(4)]     #return后for执行完毕，i为3
# print([m(2) for m in multipliers()])

# 内置函数
    # 55个
    # 带key的 max min filter map sorted
    # 思维导图上红色和黄色方法必须会用

# 匿名函数
    # lambda 参数,参数2 : 返回值表达式
    # 和五个特殊的内置函数可以结合使用
#大礼包
#员工信息表：完善
dic={'no.':{1},'name':{2},'phone':{3},'job':4}
#读取文件
def get_line(filname):
    with open(filname,encoding='utf-8')as f:
        for line in f:
            line=line.strip()
            lst=line.split(',')
            print(lst)
            yield line
get_line('log')

#接受用户信息  分析
ret=input('select name job where age>22')
view,condition=ret.split('where')
view=view.replace('select','').strip()
view_list=view.split(',')
print(view_list)