巨蟒python全栈开发-第13天 内置函数 匿名函数lambda

一.今日内容总览

1.内置函数(1):并不是每一个内置函数都是那么常用

上菜:内置函数部分//思维导图:https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac

2.匿名函数

3.map\filter\sorted\zip

4.eval\exec\compile

二.今日内容大纲

1.内置函数(1)

2.匿名函数

3.map\filter\sorted\zip

4.eval\exec\compile

三.今日内容详解

1.内置函数(1)

(1)

lst=['今天星期三','明天星期四','马上星期五']
# 法一
it=lst.__iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())
print(dir(it))
#法二     #等价写法
it=iter(lst)          # it = lst.__iter__()
print(next(it))       # it.__next__()
print(next(it))
print(next(it))
print(dir(it))

(2)

#print
print('你好,我叫娃哈哈',end='  ')    #去掉换行
print('你好,我叫周润发')
#
print('宝浪','女神','日天','MJJ','太白')#这是打印的效果

#宝浪 女神 日天 MJJ 太白
#注意:python里的self都不用管

print('宝浪','女神','日天','MJJ','太白',sep='_')
# sep=' '默认是空格，我们可以进行修改

'''
结果:
你好,我叫娃哈哈  你好,我叫周润发
宝浪 女神 日天 MJJ 太白
宝浪_女神_日天_MJJ_太白
'''

(3)

hash  #四大不可变数据类型:数字&bool&元组&字符串

数字算出来就是数字本身,其他的数据算完是一坨很长的数字
print(hash(12344543))       #hash算法,最后算出来的一定是一个数字

len(),出来的是数字就认为是哈希算法，以后用到哈希，可以用len（）

print(id('呵呵'))   #id计算的是内存地址，深浅拷贝中讲过，
is 比较的是内存地址
== 比较的是值

(4)

这个直接用import吧,以后碰到再说
# __import__()   动态导入模块//很容易出错,很危险
re=__import__(input('请输入你要导入的模块:'))
re.search()
(5)

#在黑窗口中看源代码

#help查看帮助.....高级框架

# print(help(str))
# #尤其是高级框架的源代码,比如flask &tornado(1000行)的源代码
(6)

callable() 能调用
iterable  可迭代
hashable  可哈希

例子:func是否是可调用的，也就是能不能加括号

def func():
    pass
an=18
print(callable(func()))     #不可调用的

print(callable(func))     #可调用的
print(callable(an))       `#不可调用的

可调用 =>  可以加(),进行调用

(7)

dir 查看数据类型有哪些操作

此类型的数据可以执行哪些方法(函数)

print(dir('ni hao'))
print(dir([]))

[].count()

(8)

复数=实数(有理数,无理数(无限不循环小数))+虚数 i**2=-1

注意:专业的东西 做专业的事儿!!!!!!
shell就是写脚本的

手机=>任何位置打电话
MP3=>  耳机+功效

数字类型(int bool float complex)

(9)

bin  #计算二进制 binary
print(bin(5))     #转化成二进制    0b101  二进制
print(oct(8))     #八进制      #0o10
print(hex(16))    #十六进制    #0x10
'''
二进制（binary）没有2
八进制（octonary）没有8
十六进制（hexadecimal）没有16
'''
def func():
    pass
print(func)     #内存地址：<function func at 0x000001D8864C1E18>

(10)

必须是可迭代对象
min  max sum

print(sum([1,2,3,4,5]))
print(max([1,2,3,4,5]))
print(min([1,2,3,4,5]))

print(divmod(20,3))  #计算商和余数
#结果(6, 2)

(11)

print(round(2.6))  #整数是奇数=> 正常四舍五入
                    #整数是偶数=>五舍六入
print(round(2.5))
print(round(1.5))
print(round(1.6))

print(pow(4,4))
#4的4次方

(12)

lis=['篮球','足球','摔跤','挤公交']

for el in lis:
    print(el)
#记住这个然哥
for i in range(len(lis)):
    print(i,lis[i])

for i,el in enumerate(lis,1):
    print(i,el)

for i,el in enumerate(lis):
    print(i,el)

enumerate 以元组形式返回!!!索引!!!和!!!元素!!!,我们进行拆分
enumerate #第二个参数的设置起始位置,注意修改的时候需要减一

(13)

#any all
#all必须全是真,才是真
print(all([1,3,'哈哈']))      #all 就是and
#any一个是真就是真
print(any([False,1,None]))   #any 就是or

(14)

zip 拉链函数

lst1=['赵四','刘能','香秀']
lst2=['刘小光','王小利'] #水桶效应
lst3=['街舞','磕巴','哭']
z=zip(lst1,lst2,lst3)
print('__iter__'in dir(z))  #判断是否是可迭代对象
#这个__iter__是否在这拉链包起来的
for el in z:
    print(el)

应用场景:卫星数据,横向时间切割,应用的就是拉链

#金融数据的同一时段对比可能会用到

2.匿名函数\map\filter\sorted\zip

(1)

def func(a,b):
    return a+b
ret=func(1,3)
print(ret)      #
print(func)     #<function func at 0x000002252CFD1E18>

(2)

# 匿名函数统一的名字是:<lambda>
fn=lambda a,b:a+b         #定义一个很简单的函数. 复杂的函数不要用lambda
ret=fn(3,5)
#为什么叫匿名函数?
print(ret)      #结果:8
print(fn)       #<function <lambda> at 0x000001CC501B1E18>//打印出来的fn中名字是lambda,所以是匿名函数
# #变量名:fn

(3)

lambda使用场景:配合着sorted,map,filter 一起使用

sorted 排序函数,让你自己去定义排序的规则

lst=[11,5,36,1,27,58]
s=sorted(lst) #默认从小到大排序
print(s)

lst=['胡一菲','张伟','关谷神奇','曾小贤吕小布','若兰']
#按照字符串长度排序
def func(s):
    return len(s)  #返回长度
#执行流程:把可迭代对象中的每一项拿出来,作为参数传递给后面key函数,
#函数返回数字,根据数字进行排序
a=sorted(lst,key=func)
print(a)

#传统写法:
lst=['胡一菲','张伟','关谷神奇','曾小贤吕小布','若兰']
def func(s):
    return len(s)  #返回长度
a=sorted(lst,key=func)
print(a)

#lambda写法:
lst=['胡一菲','张伟','关谷神奇','曾小贤吕小布','若兰']
s=sorted(lst,key=lambda k:len(k),reverse=False)
print(s)
#注意:这里的是拿出lst中的每一项对其进行排序

# sorted规则
# sorted(可迭代对象,规则,顺序还是倒叙)
# sorted(iterable,key,reverse)
# 说白了,内部还是用数字排序的

# sorted中reverse默认是False
lst=['胡一菲','张伟','关谷神奇','曾小贤吕小布','若兰']
s=sorted(lst,key=lambda k:len(k),reverse=False)
print(s)

(4)sorted

lst=[
    {'name':'alex','shenggao':150,'tizhong':''},
    {'name':'wusir','shenggao':158,'tizhong':''},
    {'name':'taibai','shenggao':177,'tizhong':''},
    {'name':'ritian','shenggao':165,'tizhong':''},
    {'name':'nvshen','shenggao':160,'tizhong':''},
    {'name':'baoyuan','shenggao':183,'tizhong':''},
]
# 按照体重进行排序,从大到小
print(sorted(lst,key=lambda dic:dic['tizhong'],reverse=True))
# 按照身高进行排序,从大到小
print(sorted(lst,key=lambda dic:dic['shengao'],reverse=True))

(5)filter() 过滤

lst=['张无忌','张翠山','范冰冰','金毛狮王','李冰冰']
# s=filter(lambda x:'张' not in x,lst)     #错误写法
# 过滤掉姓张的人
# 把可迭代对象打开. 把内部元素一个一个的传递给前面的函数. 由这个函数决定此项是否保留
s=filter(lambda x: not x.startswith('张'),lst)
print('__iter__' in dir(s))     #True
print(s)                         #<filter object at 0x0000016A2BCD74E0>
for i in s:
    print(i)
'''
迭代后的对象是:
范冰冰
金毛狮王
李冰冰
'''

练习:

lst=[
    {'name':'alex','shenggao':150,'tizhong':''},
    {'name':'wusir','shenggao':158,'tizhong':''},
    {'name':'taibai','shenggao':177,'tizhong':''},
    {'name':'ritian','shenggao':165,'tizhong':''},
    {'name':'nvshen','shenggao':160,'tizhong':''},
    {'name':'baoyuan','shenggao':183,'tizhong':''},
]
#过滤掉体重大于180的人,想要的是小于180的人

s=filter(lambda x:int(x['tizhong'])<180,lst)
# for i in s:
#     print(i)
print(list(s))

(6)

map() 映射函数

只对数据做处理

lst=['篮球','台球','唱歌','爬黄山','徒步']
k=map(lambda a:'爱好:'+a ,lst)
print(list(k))

练习:在列表中,求每一个数字的平方

lst=[1,5,78,12,16]
print([i**2 for i in lst])

m=map(lambda i:i**2,lst)
print(list(m))

3.eval\exec\compile(这一部分还有待总结)

(1)

#注意eval慎用,安全问题
# eval:是把字符串类型的数据作为代码进行执行

s='18+2'
ret=eval(s)   #执行字符串类型的代码
print(ret)      #

#计算器新写法
code=input('请输入你要执行的代码')
ret=eval(code)
print(ret)

s="{'name':alex,'age':18,'isMan':False}" #字符串
# # 把字符串类型的代码还原回字典,列表,元组
ret=eval(s)  #侧重点是有返回值
print(ret)
print(type(ret))

(2)

# exec()  execute执行字符串类型的代码, 不能太长. 不能太乱
code = input("请输入你要执行的代码")
a=exec(code) # 没有返回值. 想要返回值用eval
print(a)   # pycharm报错不一定准

(3)

# compile() 编译:把你要执行的代码先预编译,通过exec和eval可以执行我们的代码
code='''
for i in range(10):
    if i %2==0:
        print(i)
'''
c=compile(code,"",'exec')  #预加载代码
exec(c)  #运行代码

#应用:可以使用compile写一个编程大赛,是大赛写的程序,在相同条件下运行
#用机器,动态运行

四.作业

4，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
   name=[‘oldboy’,'alex','wusir']

name=['oldboy','alex','wusir']
s=map(lambda x:x+'sb', name)
# print(s)
print(list(s))

5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
   l=[{'name':'alex'},{'name':'y'}]

l=[{'name':'alex'},{'name':'y'}]
s=map(lambda x:x['name']+'sb',l)
print(list(s))

l=[{'name':'alex'},{'name':'y'}]
a = list(map(lambda dic:{'name':dic['name'] + 'sb'},l))
print(a)

6，用filter来处理,得到股票价格大于20的股票名字
shares={
       'IBM':36.6,
       'Lenovo':23.2,
   'oldboy':21.2,
    'ocean':10.2,
   }

shares={
       'IBM':36.6,
       'Lenovo':23.2,
      'oldboy':21.2,
    'ocean':10.2,
    }
s=filter(lambda x:shares[x]>20,shares)
print(list(s))

7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
结果：list一下[9110.0, 27161.0,......]

portfolio=[
   {'name':'IBM','shares':100,'price':91.1},
   {'name':'AAPL','shares':50,'price':543.22},
   {'name':'FB','shares':200,'price':21.09},
   {'name':'HPQ','shares':35,'price':31.75},
   {'name':'YHOO','shares':45,'price':16.35},
   {'name':'ACME','shares':75,'price':115.65}]

portfolio=[
    {'name':'IBM','shares':100,'price':91.1},
    {'name':'AAPL','shares':50,'price':543.22},
    {'name':'FB','shares':200,'price':21.09},
    {'name':'HPQ','shares':35,'price':31.75},
    {'name':'YHOO','shares':45,'price':16.35},
    {'name':'ACME','shares':75,'price':115.65}]
s=map(lambda x:x['shares']*x['price'],portfolio)

print(list(s))

# l=[]
# for i in s:
#  # print(round(i,1))
#  l.append(round(i,1))
# print(l)

8,还是上题的字典，用filter过滤出单价大于100的股票。

portfolio=[{'name':'IBM','shares':100,'price':91.1},
    {'name':'AAPL','shares':50,'price':543.22},
    {'name':'FB','shares':200,'price':21.09},
    {'name':'HPQ','shares':35,'price':31.75},
    {'name':'YHOO','shares':45,'price':16.35},
    {'name':'ACME','shares':75,'price':115.65}]
s=filter(lambda x:x['price']>100,portfolio)
print(list(s))

9,有下列三种数据类型，
   l1 = [1,2,3,4,5,6]
   l2 = ['oldboy','alex','wusir','太白','日天']
   tu = ('**','***','****','*******')
写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个）
   [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。 

l1 = [1,2,3,4,5,6]
l2 = ['oldboy','alex','wusir','太白','日天']
tu = ('**','***','****','*******')
lis=zip(l1,l2,tu)
s=filter(lambda x:x[0]>2 and len(x[2])>=4,lis)      #注意条件*至少是4个
print(list(s))

10,有如下数据类型：
   l1 = [ {'sales_volumn': 0},
          {'sales_volumn': 108},
          {'sales_volumn': 337},
          {'sales_volumn': 475},
          {'sales_volumn': 396},
          {'sales_volumn': 172},
          {'sales_volumn': 9},
          {'sales_volumn': 58}, 
          {'sales_volumn': 272}, 
          {'sales_volumn': 456}, 
          {'sales_volumn': 440},
          {'sales_volumn': 239}]
将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。

l1 = [ {'sales_volumn': 0},
       {'sales_volumn': 108},
       {'sales_volumn': 337},
       {'sales_volumn': 475},
       {'sales_volumn': 396},
       {'sales_volumn': 172},
       {'sales_volumn': 9},
       {'sales_volumn': 58},
       {'sales_volumn': 272},
       {'sales_volumn': 456},
       {'sales_volumn': 440},
       {'sales_volumn': 239}]

s=sorted(l1,key=lambda x:x['sales_volumn'],reverse=False )        #从小到大
s=sorted(l1,key=lambda x:x['sales_volumn'],reverse=True )            #从大到小
print(s)