Python函数05/内置函数/闭包

内容大纲

1.内置函数(二)

2.闭包

1.内置函数(二)

#(abs())  绝对值--返回的都是正数

#print([abs(i) for i in lst])

#enumerate -- 枚举("可迭代对象","序号的起始值")

#[(0,1),(1,2),(2,3)]

#print([i for i in enumerate(lst,10)])

# lst = [11,22,33,-44,23,21]

# new_lst = []

# for i in enumerate(lst):

#     new_lst.append(i)

# print(new_lst)

# print([i for i in enumerate(lst,1000)])

# print(max([1,2,3,4,56,7,8])) # 求最大值

# print(min([1,2,3,4,-56,7,8])) # 求最小值

# print(sum([1,2,3,4,5],100))   # 求和

range

Python3:

    g = range(0,10)   可迭代对象

    g.__iter__()

Python2:

    range(0,10)       获取是一个列表

    xrange(0,10)       获取是一个可迭代对象

# from collections import Iterable,Iterator

# print(isinstance(g,Iterable))

# print(isinstance(g,Iterator))

print(sep=" ",end="\n")

print(1,2,3,sep="     ") sep多个元素的连接符

# print(1,end="\t")    "\t"制表符是四个空格

# print(2,end=" ")

# print(3)

# print(12345,file=open("t1.txt","w",encoding="utf-8"))

# print(list("alex")) #['alex',]

# print(dict(key=1,a="alex"))

# print(dict(((1,2),(2,3),(3,4))))

# print(dict([i for i in enumerate(range(20),1)]))

# zip() # 拉链 -- 按照最少的进行合并

#print(dir(list))  查看当前函数的方法

面试题

lst1 = [1,2,3,4,5]

lst2 = ['a','b','c']

print(dict(list(zip(lst1,lst2))))

print(dict(zip(lst1,lst2)))

2.匿名函数及内置函数(重要)

# def func():

#     print(123)

#     return "你好"

# func()

# def func(a,b):

#     return a+b

# print(func(1,2))

匿名函数:

f = lmabda x,y:(x,y)

print(f(1,2))

print(f.__name__)

# def func():

#     return 1

# print(func())

print((lambda x:x)(2))   #同一行定义 同一行调用

lambda 关键字--定义函数

x,y 形参

x+y 返回值--只能返回一个数据类型

lst = [lambda i:i*i for i in range(10)]

print(lst[2](2))

lst = []

for i in range(10):

    def func(i):

        return i*i

    lst.append(func)

print(lst[2](2))

lst = [lambda :i*i for i in range(10)]

print(lst[2]())

for i in range(10)

	pass

print(i)

lst = []

for i in range(10):

    def func():

        return i*i

    lst.append(func)

print(lst[2]())

一行函数

形参可以不写

返回值必须要写,返回值只能返回一个数据类型

lst = list((lambda i:i*i for i in range(5)))

print(lst[1](4))

结果:16

lst = [x for x in (lambda :i**i for i in range(5))]

print(lst[2]())

结果:256

lst1 = []

def func():

    for i in range(5):

        def foo():

            return i**i

        yield foo

for x in func():

    lst1.append(x)

print(lst1[2]())

# 内置函数(重要)

# print(format(13,">20"))  # 右对齐

# print(format(13,"<20"))  # 左对齐

# print(format(13,"^20"))  # 居中

# print(format(13,"08b"))    # 二进制

# print(format(13,"08d"))    # 十进制

# print(format(13,"08o"))    # 八进制

# print(format(12,"08x"))    # 十六进制

# print(bin(13))

filter()  # 过滤

lst = [1,2,3,4,5]

def func(s):

    return s > 3

print(list(filter(func,lst)))

func就是自己定义一个过滤条件,lst要迭代的对象

lst = [1,2,3,4,5,6,7]

print(list(filter(lambda x:x % 2 == 1,lst)))

map() 对象映射

print(list(map(lambda x:x*x,[1,2,3,4,5]))

将可迭代对象中的每一个元素进行加工

反转

      lst = [1,2,3,4,5]

      lst.reverse()

      print(lst)

      lst1 = list(reversed(lst))

      print(lst)

      print(lst1)

# lst = [1,23,34,4,5,213,123,41,12,32,1]

print(sorted(lst)   #升序

print(lst1)

# lst = [1,23,34,4,5,213,123,41,12,32,1]

print(sorted(lst,reverse=True))   #降序

dic = {"key":1,"key1":2,"key2":56}

print(sorted(dic,key=lambda x:dic[x],reverse=True))

key是指定排序规则

print(max([1,2,4,5],key=abs))     key是指定查找最大值的规则

from functools import reduce

reduce 累计算

print(reduce(lambda x,y:x+y,[1,2,3,4,5]

3.闭包

def func():

    a = 1

    def f1():

        def foo():

            print(a)

        return foo

    return f1

ret = func()

a = ret()

a()

func()()()

1.在嵌套函数内,使用非全局变量(且不是本层变量)--就是闭包

avg_lst = []

def func(price):

    avg_lst.append(price)

    avg = sum(avg_lst)/len(avg_lst)

    return avg

print(func(150000))

print(func(160000))

print(func(170000))

print(func(150000))

avg_lst.append(188888)

#全局变量可能被修改

def func(price):

    avg_lst = []

    avg_lst.append(price)

    avg = sum(avg_lst)/len(avg_lst)

    return avg

print(func(150000))

print(func(160000))

print(func(170000))

print(func(150000))

#这样取不到平均值,每次都是每天的价钱

def func():

    avg_lst = []  #自由变量

    def foo(price):

        avg_list.append(price)

        avg = sum(avg_lst)/len(avg_lst)

        return avg

    return foo

ret = func()()

# __closure__ 判断是否是闭包

# 了解:

# print(ret.__code__.co_freevars)  # 获取的是自由变量

# print(ret.__code__.co_varnames)  # 获取的是局部变量

# 闭包的作用:

# 1.  保证数据的安全性

# 2.  装饰器

4.今日总结

# 1.内置函数二:

#     1.1 匿名函数 lambda

#         lambda 形参:返回值   -  lambda x:x

#         形参可以不写,返回值必须写 返回值只能是一个数据类型

#         匿名函数的名字叫做 lambda

#     1.2 abs() 绝对值

#     1.3 filter("函数名","可迭代对象")  写函数的时候可以指定过滤条件

#     1.4 map("函数名","可迭代对象")     写函数的时候可以指定对元素的操作

#     1.5 list(zip("可迭代对象","可迭代对象")) 返回的是[(1,2),(2,3)]

#     1.6 sorted("可迭代对象",key="函数名",reverse=True) key是指定排序的规则(默认是升序)写了reverse=True就是降序

#     1.7 reversed("可迭代对象")  # 对可迭代对象进行翻转(不改变源数据)

#     1.8 max("可迭代对象",key=abs)  #key指定查找最大值时的规则

#     1.9 min("可迭代对象",key=abs)  #key指定查找最小值时的规则

#     1.10 sum(list,tuple,set)

#     1.11 reduce("函数","可迭代对象") # 函数指定累计算的方式

#     1.12 format()

#       08b -- 2

#       08d -- 10

#       08o -- 8

#       08x -- 16

# 2.闭包:

# 啥是闭包:嵌套函数内,使用非全局变量就是闭包

# 闭包干啥:保证数据的安全性,装饰器使用

5.今日练习

注意重要内置函数的使用,注意哪些打印的时候需要在外面加list

# 1.将今日课上的代码敲3遍。

# 2.都完成的做一下作业（下面题都是用内置函数或者和匿名函数结合做出）：

#

# 1)用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb

# l=[{'name':'alex'},{'name':'y'}]

# print(list(map(lambda x:{'name':x['name']+"_sb"},l)))

# 2)用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾

# l=[{'name':'alex'},{'name':'y'}]

# print(list(map(lambda x:(x['name']+"sb"),l)))

# 3)用filter来处理,得到股票价格大于20的股票名字

# shares={

#  'IBM':36.6,

#  'Lenovo':23.2,

#  'oldboy':21.2,

#  'ocean':10.2,

# }

# print(list(filter(lambda x:shares[x]>20,shares)))

# 4)有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。

# 结果：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}]

# #

# print(list(map(lambda x:x['shares']*x['price'],portfolio)))

# 5)还是上面的字典，用filter过滤出单价大于100的股票。

# print(list(filter(lambda x:x['price']>100,portfolio)))

#

# 6)有下列三种数据类型，

# l1 = [1,2,3,4,5,6]

# l2 = ['oldboy','alex','wusir','太白','日天']

# tu = ('**','***','****','*******')

# 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个。）

#  [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。

# print(list(zip(l1,l2,tu))[2:])

# print(list(filter(lambda x:x[0]>2 and len(x[2])>=4,list(zip(l1,l2,tu)))))

# 7)有如下数据类型(实战题)：

#

# 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大小进行排序，形成一个新的列表。

# print(sorted(l1,key=lambda x:x['sales_volumn']))

# 3.有如下数据结构,通过过滤掉年龄大于16岁的字典

# 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']<=16,lst)))

# 4.有如下列表,按照元素的长度进行升序

# lst = ['天龙八部','西游记','红楼梦','三国演义']

# print(sorted(lst,key=lambda x:len(x)))

# 5.有如下数据,按照元素的年龄进行升序

# 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']))

# 6.看代码叙说,两种方式的区别

# lst = [1,2,3,5,9,12,4]

# lst.reverse()

# print(lst)

# 改变原列表

# print(list(reversed(lst)))

# 没有对原列表改变,只是新开的空间做的改变

# 7.求结果(面试/题)

v = [lambda :x for x in range(10)]

print(v)        #10个生成器函数的内存地址

print(v[0])     #第一个生成器函数的内存地址

print(v[0]())       #9

# 8.求结果(面试题)

# v = (lambda :x for x in range(10))

# print(v)     #生成器的内存地址

# print(v[0])     #报错

# print(v[0]())       #报错

# print(next(v))      #生成器后面第一个函数的内存地址

# print(next(v)())    #0

# 9.map(str,[1,2,3,4,5,6,7,8,9])输出是什么? (面试题)

# map函数的内存地址(没有加list)

除了sorted reduce不需要加list 其余filter map reversed等都需要加list

10.有一个数组[34,1,2,5,6,6,5,4,3,3]请写一个函数，找出该数组中没有重复的数

的总和（上面数据的么有重复的总和为1+2=3)(面试题)

lst = [34,1,2,5,6,6,5,4,3,3]

print(sum(list(filter(lambda x:lst.count(x)==1,lst))))  #使用count

11.求结果：（面试题，比较难，先做其他题）

def num():

    return [lambda x:i*x for i in range(4)]

print([m(2)for m in num()])

[6, 6, 6, 6]

def num():

    return (lambda x:i*x for i in range(4))

print([m(2)for m in num()])

[0,2,4,6]

Python函数05/内置函数/闭包的更多相关文章

  1. Python进阶(五)----内置函数Ⅱ 和 闭包

    Python进阶(五)----内置函数Ⅱ 和 闭包 一丶内置函数Ⅱ ####内置函数#### 特别重要,反复练习 ###print() 打印输入 #sep 设定分隔符 # end 默认是换行可以打印到 ...

  2. python学习交流 - 内置函数使用方法和应用举例

    内置函数 python提供了68个内置函数,在使用过程中用户不再需要定义函数来实现内置函数支持的功能.更重要的是内置函数的算法是经过python作者优化的,并且部分是使用c语言实现,通常来说使用内置函 ...

  3. python常用的内置函数哈哈

    python常用的内置函数集合做一个归类用的时候可以查找 abs 返回数字x的绝对值或者x的摸 all (iterable)对于可迭代的对象iterable中所有元素x都有bool(x)为true,就 ...

  4. python常用的内置函数

    python常用的内置函数集合做一个归类用的时候可以查找- abs 返回数字x的绝对值或者x的摸 - all (iterable)对于可迭代的对象iterable中所有元素x都有bool(x)为tru ...

  5. python基础知识15---三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数

    阅读目录 一 三元表达式.列表推导式.生成器表达式 二 递归与二分法 三 匿名函数 四 内置函数 五 阶段性练习 一. 三元表达式.列表推导式.生成器表达式 1 三元表达式 name=input('姓 ...

  6. python之三元表达式、列表推导、生成器表达式、递归、匿名函数、内置函数

    目录 一 三元表达式 二 列表推到 三 生成器表达式 四 递归 五 匿名函数 六 内置函数 一.三元表达式 def max(x,y): return x if x>y else y print( ...

  7. Python之函数（自定义函数，内置函数，装饰器，迭代器，生成器）

    Python之函数(自定义函数,内置函数,装饰器,迭代器,生成器) 1.初始函数 2.函数嵌套及作用域 3.装饰器 4.迭代器和生成器 6.内置函数 7.递归函数 8.匿名函数

  8. 十六. Python基础(16)--内置函数-2

    十六. Python基础(16)--内置函数-2 1 ● 内置函数format() Convert a value to a "formatted" representation. ...

  9. 十五. Python基础(15)--内置函数-1

    十五. Python基础(15)--内置函数-1 1 ● eval(), exec(), compile() 执行字符串数据类型的python代码 检测#import os 'import' in c ...

随机推荐

  1. （三）log4j常用配置

    控制台(console) log4j.appender.stdout = org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target = ...

  2. 小白的mapbox学习之路-显示地图

    刚接触mapbox,只是简单记下自己的学习之路,如有错误,欢迎大神指正 1-头部引入链接 2-body中定义一个div块,用来显示地图 3-在script中创建一个map对象,并设置相关参数 mapb ...

  3. 1、python简介-变量-注释-数据类型-用户交互-if语句-while循坏

    一. 计算机是什么 基本组成: 主板+cpu+内存 cpu: 主频, 核数(16) 内存:大小(8G, 16G, 32G) 型号: DDR3, DDR4, DDR5, 主频(海盗船,玩家国度) 显卡: ...

  4. Hibenate面试

    5. 对比总结 返回值: get()返回的是查询出来的实体对象,而load()查询出来的是一个目标实体的代理对象. 查询时机: get()在调用的时候就立即发出SQL语句查询,而load()在访问非I ...

  5. Snmp扫描-snmpwalk、snmpcheck

    SNMp经常被错误配置,是信息的金矿. SNMP服务是使用明文传输的,即使不能通过community进行查询,也有可能使用抓包嗅探的方法得到SNMP数据包中的数据. snmpwalk命令可以查询到很多 ...

  6. SpringBoot--使用redis实现分布式限流

    1.引入依赖 <!-- 默认就内嵌了Tomcat 容器,如需要更换容器也极其简单--> <dependency> <groupId>org.springframew ...

  7. MFC文档视图中窗口切换 (2012-05-11 18:32:48)

    在文档试图应用程序,有时需要在工作区切换试图,以下就是如何切换试图了 .创建要切换的视图类,同时把构造函数,Create函数改变为public .在需要切换试图的动作响应中,加入切换代码,一般是在CM ...

  8. .gitkeep文件

    git 默认不会对空文件夹进行追踪: 但某些项目某些文件夹对整体框架是必不可少的,就算是空也得有: 怎么办呢?在这个文件夹下添加一个[.gitkeep]文件,这样就可以同步该文件夹了. (完)

  9. Android详细介绍MPAndroidChart-LineChart

    在开发当中曲线图用的时候太多了,之前都是自己手写,之后发现太累还丑不符合需求 MPAndroidChart 先介绍LineChart 0.效果图 首先依赖  1. implementation 'co ...

  10. MySQL 查询 存储过程 视图 触发器 函数 索引 建表语句 数据库版本 当前登录用户 当前数据库名称

    MySQL 查询 存储过程 视图 触发器 函数 索引 建表语句 数据库版本 当前登录用户 当前数据库名称   INFORMATION_SCHEMA.TABLES INFORMATION_SCHEMA. ...