1,大作业,yield 返回之后可以对数据进行处理了就,注意函数的解耦,每一个小功能写成一个函数,增强可读性,写之前自己要先把整体功能分块,先做什么,在做什么

# 现在需要对这个员工信息文件进行增删改查。

# 可以进行查询,支持三种语法:
# 支持:大于小于等于,还要支持模糊查找。
# 示例:
# select name, age where age>22
# select * where job=IT
# select * where phone like 133 # 用户信息处理-分析信息
# user_msg = input('>>>')
user_msg = 'select * where age>22' # 规律都有where
view,condition= user_msg.split('where') # 查询内容,查询条件,拆包 # view = view.split('select').pop().strip() # strip不可以去掉完整的字符串,split前面字典必然有个空值,因为是从头开始切得
view = view.replace('select','').strip() # 和上一句效果一样的
view_list = view.split(',') # 读取文件 ---将文件内容整理
def get_line(filename):
'''
返回员工的列表
:param filename:
:return:
'''
with open(filename,encoding='utf-8') as f1:
for line in f1:
line = line.strip()
list_line = line.split(',')
yield list_line # 这一句是关键,信息可以拿出去处理了 dic = {'name':1,'id':0, 'age':2,'phone':3,'job':4} def condition_filter(condition):
'''条件筛选'''
print(condition)
condition = condition.strip()
if '>' in condition:
col,value = condition.split('>')
print(col,value)
g_line = get_line('employ_list.txt')
for line in g_line:
if int(line[dic.get(col)]) > int(value):
yield line # 尽量做到程序的解耦,就是把它拆分成几个函数去完成
def view(view_list,staff_g):
'''展示符合条件的员工信息''' for staff in staff_g:
if '*' in view_list:
view_list = dic.keys() for i in view_list:
print(staff[dic[i]],end=' ')
print('\r') staff_g = condition_filter(condition)
view(view_list,staff_g)

2,凡是参数里面带key的要特别记忆一下,因为可能会在面试题里面考试,目前就是min和max函数,另外,min和max可以接受多个参数,sum只可以接收iterable和start并且只能是数字

3,数据结构相关的24个,先说序列,list和tuple 函数,这两个只有在数据类型强制转换的时候才会用

4,数据类型:int,bool,和其他的很多;数据结构:指的是容器相关的,list,tuple,set,str,dic,tuple和dict是Python独有的,别的语言没有,所以这两个一定不要忘了

5,reversed 函数

# 这个的话,原来的函数就不存在了
l = [1,2,3,4,5]
l.reverse()
print(l) l = [1,2,3,4,5]
l2 = reversed(l)
print(l) # 首先原来的列表没变
print(l2) # 第二给出了迭代器,不改变原列表,返回反序的迭代器 运行结果:
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
<list_reverseiterator object at 0x10b1397b8>

6,slice切片函数,注意内置函数是不需要用点来调用的,都可以直接用的

l = [145,221,45,67,56,789,222,334,556,54]
sli = slice(1,6,2) # 只是给出一个切片规则
print(l[sli]) #这两句效果是一样的
print(l[1:6:2])# 其实内部流程是一样的,也是一种语法糖 运行结果:
[221, 67, 789]
[221, 67, 789]

7,字符串相关的函数,首先format函数

str.format() # 这个是字符串的format格式化输出
format() # 内置函数的format非常的强大,有很多的功能,这里简单写几个

8,和小数相关的,数学相关的,非常强大,有兴趣可以去专门研究

print(format('test','<20')) # 20个空间,左对齐
print(format('test','>20')) # 20个空间,右对齐
print(format('test','^20')) # 20个空间,居中

9,bytes函数,转换成bytes类型,其实读到内存里面都是Unicode的,我们想把它转成UTF-8,我们是把他转换成了bytes类型的utf-8,为何要转换成bytes?主要原因:

# bytes()函数就是把unicode转换成GBK或者是utf-8,哪些情况需要转呢,比方说我拿到了GBK想转换为UTF8
# 就需要先decode 成Unicode,在encode成utf-8
print(bytes('你好',encoding='GBK')) # unicode 转换成GBK的bytes
print(bytes('你好',encoding='utf-8')) # Unicode转换成utf-8的bytes
print(bytes('你好',encoding='GBK').decode('GBK'))
# 文件里面存的是GBK,我想存储UTF-8格式的,读到内存里,内存转换成Unicode,这个转换的过程是decode的,然后从内存里面拿出来
# 转换成utf-8的,这个过程是encode的过程,编码,bytes过程 # 网络编程,网络传输的角度,两个机器想要进行通信,只能传递二进制
# 照片和视频也只能是二进制传输
# 文件存储,平时写进去,读出来,已经指定编码了,二进制,就是bytes
# HTML 爬取到的也是二进制编码
# 工作的时候,编码是个大工程,一定要学好
# 2.7里面编码是混乱的,Python3记住这几个就好, 运行结果:
b'\xc4\xe3\xba\xc3'
b'\xe4\xbd\xa0\xe5\xa5\xbd'

10,bytearray函数,用的不多,byte类型的一个数组,好处是修改字符串的时候可以节省内存,不好的地方麻烦,只能通过字符编码来改,例如把你改成您

# 发现规律了吗?
b_array = bytearray('你好',encoding="utf-8")
print(b_array)
# bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(b_array[0])
print(hex(b_array[0]))
print(hex(b_array[1])) s1 = 'lisa'
s2 = 'lisa2' # 当然我们可以按照自己改,但是比较麻烦,还要查编码,用的不多,了解一下就行 运行结果:
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
228
0xe4
0xbd

11,memoryview这个用的也不多,但要知道的,更鸡肋的功能,memoryview是一个字节类型的切片,你能看到的只是字节,不占用内存,只是给你看看,但是转成字符串又开始占内存了

memoryview切的时候就不占了,不给你,只给你看看,只是从原来的内存里拿一部分给你看,根据字节也不好操作,不用太研究

s ='jdshfiuascidjhueughiqlbi'
s2 = s[:10] #不用memoryview 每切一次都会创建一个新的

12,字符按照Unicode转换成数字ord函数

# 参数必须是字符类型
print(ord('a'))
print(ord(''))
print(ord('好')) # 中文也可以检测,是按照Unicode来转换的
运行结果:
97
49
22909

13,数字按照Unicode转成字符,和上一个刚好相反

print(chr(68))
print(chr(98)) #没有的结果为空
运行结果:
D
b

14,ASCII函数,如果是ASCII中的,就打印ASCII码,不是就打印出\u...这个方法了解一下就行,用的不多

print(ascii('你'))
print(ascii("a")) 运行结果:
'\u4f60'
'a'

15,下面这个方法用的比较多repr方法

name = 'lisa'
print("你好%s"%name) # %s str
print("你好%r"%name) # %r repr,其实内部就是调用了repr方法 # 带着符号就打出字符串了,后面面向对象还会讲,其实是一个很神奇的函数
# 原封不动的输出某个变变量
print(repr(1))
print(repr(''))
# 所有的字符串在这里都会原形毕露,防止你忘了是字符串类型,这里了解一下就好, 运行结果:
你好lisa
你好'lisa'
1
''

16,下面讲解数据集合,set,frozenset和dict方法,有没有发现,只要是大括号括起来的,都是无序的,set类似于字典的key,就是没有value的字典,可哈希,不重复,和字典要求一样,frozenset之后就不可以变了,frozen之后就可以做字典的key了

17,比较重要的,len,enumerate这个不写了,由于很熟悉了。

18,两个需要了解一下的函数,注意参数必须是iterabal的,不然后报错

# 判断是否有bool值是false的值,也就是全为真值,最后结果才为真,有一个false整体就是false
print(all(range(10)))
print(all([1,'',9]))
print(all([1,' ',9])) # 控制也代表有值,就代表这个字符串不为空
print(bool('')) # 注意空串和空值的区别,只有是空串的时候才为false
print(bool(' '))
print('***************************') # 判断是否有bool值为true的值,有一个false,整体就是false
print(any([1,'',2]))
print(any([1,' ',2]))
print(any([0,'',()])) 运行结果:
False
False
True
False
True
***************************
True
True
False

19,zip,filter,sored,map非常重要的四个函数,zip 有拉链的意思,

# 拉链方法
list1=[1,2,3]
list2=['a','b','c']
list3 =['*','**',[],'pp']
dict1 = {'k1':1,'k2':2}
z1= zip(list1,list2) print(z1) # <zip object at 0x10cf51388>,这个地方一看是个内存地址,就要猜测是个迭代器了,
# 因为我们知道他是有多个值的,有时候迭代器不会明确说自己是迭代器的,我们要去猜,只要可迭代,就可以循环
print("__next__" in dir(zip))
for i in z1:
print(i) # 可以拉上不同类型的可迭代对象,不同数量,拉最少的数量,字典只是拉上key,字典很多时候都只是key,返回元祖,因为字典无序,所以有时候,顺序会颠倒的
print('**************************')
z2 = zip(list1,list2,list3,dict1)
for i in z2:
print(i) 运行结果:
<zip object at 0x10258e408>
True
(1, 'a')
(2, 'b')
(3, 'c')
**************************
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')

20,filter,非常重要的,像什么?像生成器表达式,和filter的效果是一样的,只是形式不一样,它里面的函数可以做的事情比生成式多。只做过滤,满足条件的筛选出来,注意return这儿,很多时候都可以简化

def is_odd(x):
return x%2 == 1 # 本身就能代表真假,必须返回bool值, # 接收两个参数,第一个是一个函数地址,也就是函数名,第二个参数是一个可迭代的,会把第二个里面每一个元素作为参数传递到第一个函数里面,根据
# 返回是true或者false来决定你是否在我筛选的范围之内
ret = filter(is_odd,[1,2,3,4,5,6,7,8,9])
print(ret) # 返回也是迭代器
for i in ret: #只要函数return是True就返回列表里面的原值,这里循环就可以取出
print(i) # ret = [i for i in[1,2,3,4,5] if i%2==1] 和生成式表达式一样的
# 这里不能推理出过程,必须记忆一下
# 判断是否是字符串
def is_str(x):
return type(x) == str
# 这个fiter可以做很多事情的,我们可以删除None或者空字符串等等
ret = filter(is_str,[1,2,3,'lll',5,' pp',7,8,9]) #这里可以传任何数据类型
for i in ret:
print(i) 运行结果:
lll
pp
# 返回所有bool值不是false的值
def is_str(s):
return s and str(s).strip()
# if type(s) != int:
# return s and s.strip()
# else:
# return s
# 这个fiter可以做很多事情的,我们可以删除None或者空字符串等等
ret = filter(is_str,[0,2,None,'lll','',' ', 'pp',7,8,9]) #这里可以传任何数据类型
for i in ret:
print(i)

21,filter 100以内平方根为整数的值

import math
def is_sqrt(s):
return math.sqrt(s)%1 == 0 # 判断是否是整数,取余1位零就可以了 ret = filter(is_sqrt,range(101))
for i in ret:
print(i)
print(int(2.5)) #强转也是整数值了 运行结果:
0
1
4
9
16
25
36
49
64
81
100
2

22,非常重要的map函数,map和filter和列表生成式是分不开的,元列表,按照函数加工,返回值

ret = map(abs,[1,-2,-3,4,-5,6])
print(ret)
for i in ret:
print(i)
# 输出结果,值变了,但是个数没变,abs的返回值,作为新值返回来
运行结果:
<map object at 0x1015db630>
1
2
3
4
5
6

23,结论:filter,执行了filter之后的机构集合小于等于执行之前的个数,并且filter只管筛选,不会改变原来的值,map之执行前后元素个数不变,值可能发生改变,二者的参数是一样的,一个函数名,一个iterable.

24,重要的,sorted 函数,排序方法,接收可迭代的类型,和一个函数名,根据要求排序。

l = [1,-8,3,-2,5,6]
# sort,是字符串对象的函数,sorted是内置函数,不用点来调用
l.sort(reverse=True)
print(l)
l.sort(key=abs)
# print(l) # 默认改过之后元列表就不存在和,默认升序,这点和reverse一样,都是原来的列表不存在了,但是,reverse
l = [1,-8,3,-2,5,6]
l.reverse() # 没有key
print(l) ret = sorted(l,key=abs,reverse=True)
print(ret) # 直接返回列表,不修改原来的列表,占内存
ret = reversed(l)
print(ret) # 返回迭代器 运行结果:
[6, 5, 3, 1, -2, -8]
[6, 5, -2, 3, -8, 1]
[-8, 6, 5, 3, -2, 1]
<list_reverseiterator object at 0x108d057b8>

25,另外一个例子,sorted 要慎用,占用内存,和reverse不同,排序要挑算法的,一定要预知所有值,才可以排序,所以和reverse机制是不一样的,reverse只要去指定位置取就可以了,一个一个来,可以用迭代器,排序用不了,尽管占内存,也比已知的所有排序算法好很多,所有自己写的都没有sorted快,实现语言C语言,操作系统也有优化机制,用还是用人家的,自己写的会慢。

l = ['   ',[1,2,3,4,5],'hello world']
new_l = sorted(l,key=len,reverse=True) # reverse参数
print(new_l)
运行结果:
['hello world', [1, 2, 3, 4, 5], ' ']

26,这个函数也可以是自己定义的,复杂算法,不支持返回可迭代的,也可以根据需求来排序。sorted,min,max,key在后面,并且必须写,map,filter func在前面

def func(item):
return len(item) l = [' ',[1,2,3,4,5],'hello world']
new_l = sorted(l,key=func,reverse=True) # iterable的每个元素作为参数进行计算,和上面的例子是一模一样的
print(new_l) 运行结果:
['hello world', [1, 2, 3, 4, 5], ' ']

27,最最重要的,匿名函数。匿名函数本身简单,但是难在和其他内置函数一起使用的时候,就比较难了,lambda定义匿名函数,和def差不多

def calc(n):
return n**n
print(calc(5)) calc = lambda n:n**n
print(calc(5))
# 函数名 参数:返回值,不允许换行,一行写完
# 参数可以有多个,逗号分隔 运行结果:
3125
3125

28,练一练:

def add(x,y):
return x+y
print(add(10,20)) add = lambda x,y:x+y
print(add(10,20)) 运行结果:
30
30

29,匿名函数是可以有函数名字的,整个表达式就是函数名,可以赋值给一个变量,另外一个是,他真的可以匿名,后面的函数,给出的是比较标准,最后结果函数原来的迭代器里面的数字,

dic={'k1':10,'k2':100,'k3':30}

print(max(dic)) # 这样的话,默认的是拿key来做比较,所以最大的是k3
print(max(dic,key=lambda k:dic[k])) #拿到value值最大的key,也就是k2,后面的key =给出了比较标准,给出最后还k2
print(dic[max(dic,key=lambda k:dic[k])]) 运行结果:
k3
k2
100

30,带key的函数,min,max,sort map和filter,他们都可以和lambda 合作,一道简单的面试题

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x) #
x = t(x) #
x = d(x) #
print(x) 运行结果:
24

31,另外一道题,两个元祖联系起来的就是zip函数,应用匿名函数,只要考到匿名函数,一定不是单纯的匿名函数,肯定会用到内置函数,那内置函数就去想那五个函数,个数没变,内容变了,就是map函数,map函数的参数,就是可迭代对象的元素

# 现有两个元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

# 第一个版本,自己写的,最复杂
tuple1 = (('a'),('b'))
tuple2 = (('c'),('d'))
ret = zip(tuple1,tuple2) dict1 = {}
l = []
for i in ret:
dict1.setdefault(i[0],i[1]) for i in dict1:
l.append({i:dict1[i]})
print(l) # 第二个版本:
ret = zip((('a'),('b')),(('c'),('d'))) # 这个返回本身就是iterable,可以作为map的参数
def func(tup):
return {tup[0]:tup[1]}
ret = map(func,ret)
print(list(ret)) # 第三个版本:当然最好不要这样写,会挨骂的
print(list(map(lambda tup:{tup[0]:tup[1]},zip((('a'),('b')),(('c'),('d'))))))

32,这个题蛮刁钻的,不容易想到,生成器必考的,所以一看到就要往这边想

def multipliers():
return [lambda x:i*x for i in range(4)] # 这样的话,我要一次 后面的for循环都已经执行完了,所以i全部是3 print([m(2) for m in multipliers()])
# 请修改multipliers的定义来产生预期的结果 def multipliers():
return (lambda x:i*x for i in range(4)) # 改成生成器,每要一次,for走一次 print([m(2) for m in multipliers()])
# 请修改multipliers的定义来产生预期的结果 运行结果:
[6, 6, 6, 6]
[0, 2, 4, 6]

33,要学会归纳,尤其是内置函数这一块儿

day16:内置函数二的更多相关文章

  1. python---day14( 内置函数二)

    内置函数二一:匿名函数 lambda函数 lambda 表示匿名函数,不需要用def 来申明. 语法: 函数名=lambda 参数:返回值 ----〉 案例:f=lambda n:n*n 例子01: ...

  2. python函数知识六 内置函数二、匿名函数与内置函数三(重要)

    19.内置函数二 abs():绝对值 lst = [1,2,-3,1,2,-5] print([abs(i) for i in lst]) enumerate("可迭代对象",&q ...

  3. python 内置函数(二) 进阶函数 递归内容及二分法查找 知识点

    1,lambda:  匿名函数 2.sorgted()  排序函数 3,filter()   过滤函数 筛选 4,map()  映射函数 5.递归 6.二分法 一. 匿名函数: lambda lamb ...

  4. Python入门-内置函数二

    看到标题你也能猜到今天要说大概内容是什么了,没错,昨天没有说完的部分再给大家说说(有一些重合的部分),内置函数的内容比较多,并且工作中经常用到的却不太多,很多都是不太常用的,所以我就着重说一些比较常用 ...

  5. python(day16)内置函数,匿名函数

    # add = lambda x,y:x+y # print(add(1,2)) # dic={'k1':10,'k2':100,'k3':30} # def func(key): # return ...

  6. 内置函数二: map sorted filter

    -----------生活里没有奇迹,大部分的时候奇迹是你自己创造的. # -------------------------------------------------------------- ...

  7. Python内置函数二 (递归函数,匿名函数,二分法)

    匿名函数 lambda() 语法: lambad  参数 : 返回值 def func(a,b): return a * b print(func(2,5)) a = lambda a ,b : a* ...

  8. 百万年薪python之路 -- 内置函数二 -- 最常用的内置函数

    1.内置函数 1.1 匿名函数 匿名函数,顾名思义就是没有名字的函数(其实是有名字的,就叫lambda),那么什么函数没有名字呢?这个就是我们以后面试或者工作中经常用匿名函数 lambda,也叫一句话 ...

  9. day 15 内置函数二 递归 lamda sorted filter map 二分法求值

    回顾 for i in dict  #对字典进行遍历,拿到的是字典的key  今日主要内容 1. lambda 匿名函数 语法: lambda 参数:返回值 不能完成复杂的操作.只能写一行 注意: 1 ...

随机推荐

  1. Java编译过程(传送门)

    我不是要做一门编程语言,了解这个对我现在的工作也没什么帮助,纯粹好奇而已. 传送门

  2. 单片机成长之路(51基础篇) - 004 STC89C52MCU 软件实现系统复位

    用户应用程序在运行过程中,有时会有特殊需求,需要实现单片机系统复位(热启动之一),传统的8051单片机由于硬件上未支持此功能,用户必须用软件模拟实现,实现起来较麻烦.STC单片机增加了相应的硬件功能, ...

  3. TLB的作用及工作原理

    TLB的作用及工作过程 以下内容摘自<步步惊芯——软核处理器内部设计分析>一书 页表一般都很大,并且存放在内存中,所以处理器引入MMU后,读取指令.数据需要访问两次内存:首先通过查询页表得 ...

  4. Atitit s2018.6 s6 doc list on com pc.docx Atitit s2018.6 s6 doc list on com pc.docx  Aitit algo fix 算法系列补充.docx Atiitt 兼容性提示的艺术 attilax总结.docx Atitit 应用程序容器化总结 v2 s66.docx Atitit file cms api

    Atitit s2018.6 s6  doc list on com pc.docx Atitit s2018.6 s6  doc list on com pc.docx  Aitit algo fi ...

  5. 【原创 Hadoop&Spark 动手实践 11】Spark Streaming 应用与动手实践

    [原创 Hadoop&Spark 动手实践 11]Spark Streaming 应用与动手实践 目标: 1. 掌握Spark Streaming的基本原理 2. 完成Spark Stream ...

  6. Matlab信号处理基础

    一. 简介 离散傅立叶.离散余弦和离散小波变换是图像.音频信号常用基础操作,时域信号转换到不同变换域以后,会导致不同程度的能量集中,信息隐藏利用这个原理在变换域选择适当位置系数进行修改,嵌入信息,并确 ...

  7. IFRAME练习 各种调用

    parent.html. <html> <head> <script type="text/javascript"> function say( ...

  8. 【转载】基于rasa的对话系统搭建(上)

    文章介绍使用rasa nlu和 rasa core 实现一个电信领域对话系统demo,实现简单的业务查询办理功能,更完善的实现需要进一步数据的收集.demo基于玩具数据集,可以达到下面的效果: Bot ...

  9. 转载记录一个有效的jetbrains激活码

    来自:https://blog.csdn.net/ahun535915415/article/details/80687762 K03CHKJCFT-eyJsaWNlbnNlSWQiOiJLMDNDS ...

  10. c 时间转移函数

    /*                 @param       date                 @param       formart  of date                 @ ...