python - - 函数 - - 内置函数和匿名函数

目录

  • 内置函数
  • 匿名函数
  • 本章小结
  • 相关练习题

1，内置函数

  • python里的内置函数。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。
Built-inFunctions
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()

1.1 作用域相关

  • 基于字典的形式获取局部变量和全局变量
globals()        # 获取全局变量的字典
locals()          # 获取执行本方法所在命名空间内的局部变量的字典

1.2 迭代器与生成器

  • next() iter() range
迭代器.__next__()
next(迭代器)

迭代器 = iter(可迭代的)
迭代器 = 可迭代的.__iter__()

range(10)
range(1, 11)
print("__iter__" in dir(range(1, 11, 2)))               # True
print("__next__" in dir(range(1, 11, 2)))             # False
print("__next__" in dir(iter(range(1, 11, 2))))      # True
# range 是可迭代的 但不是迭代器

1.3 其它

1.3.1 字符串类型代码的执行

内置函数——eval、exec、compile

  • eval() 将字符串类型的代码执行并返回结果
print(eval('1+2+3+4'))
  • exec() 将自字符串类型的代码执行
print(exec("1+2+3+4"))
exec("print('hello,world')")
  • 指定global参数
code = '''
import os 
print(os.path.abspath('.'))
'''
code = '''
print(123)
a = 20
print(a)
'''
a = 10
exec(code,{'print':print},)
print(a)

  • exec 和 eval 都可以执行 字符串类型的代码

  • eval 有返回值 ---- 有结果的简单计算

  • exec 没有返回值 ---- 简单流程控制

  • eval 只能用在你明确知道你要执行的代码是什么

  • compile 将字符串类型的代码编译。代码对象能够通过 exec 语句来执行或者 eval() 进行求值。

  • 参数说明：　　　

      1. 参数 source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　
      1. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了 source 参数时，filename 参数传入空字符即可。　　
      1. 参数 model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当 source 中包含流程语句时，model 应指定为 ‘exec’；当 source 中只包含一个简单的求值表达式，model 应指定为 ‘eval’；当 source 中包含了交互式命令语句，model 应指定为 'single'。
>>> #流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
1
3
5
7
9


>>> #简单求值表达式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)


>>> #交互语句用single
>>> code3 = 'name = input("please input your name:")'
>>> compile3 = compile(code3,'','single')
>>> name #执行前name变量不存在
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"

1.3.2 输入输出相关：

  • input() 输入
# input 的用法
s = input("请输入内容 ： ")  #输入的内容赋值给s变量
print(s)  #输入什么打印什么。数据类型是str
  • print() 输出
# print 源码剖析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """

# file 关键字的说明
f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

# 打印进度条
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)
#小越越  ： \r 可以把光标移动到行首但不换行
# progress Bar

1.3.2 数据类型相关：

  • type(o) 返回变量o的数据类型

1.3.3 内存相关：

  • id(o) o是参数，返回一个变量的内存地址

  • hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。

# hash 实例
t = (1,2,3)
l = [1,2,3]
print(hash(t))  #可hash
print(hash(l))  #会报错

'''
结果：
TypeError: unhashable type: 'list'
'''
  • hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
  • 每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
  • 对于相应可 hash 值在一次程序的执行过程中总是不会变的
  • 字典的寻找方式

1.3.4 文件操作相关

  • open() 打开一个文件，返回一个文件操作符(文件句柄)
  • 操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
  • 可以用encoding指定编码.

1.3.5 模块操作相关

  • __import__ 导入一个模块
# 导入模块
import time

# __import__
os = __import__('os')
print(os.path.abspath('.'))

1.3.6 帮助方法

  • 在控制台执行 help() 进入帮助模式。可以随意输入变量或者变量的类型。输入q退出
  • 或者直接执行 help(o)，o是参数，查看和变量o有关的操作。。。

1.3.7 和调用相关

  • callable(o)，o是参数，看这个变量是不是可调用。
  • 如果o是一个函数名，就会返回True
# callable 实例
def func():pass
print(callable(func))  #参数是函数名，可调用，返回True
print(callable(123))   #参数是数字，不可调用，返回False

1.3.8 查看参数所属类型的所有内置方法

  • dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
# 查看某变量/数据类型的内置方法
print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法

1.4 和数字相关

1.4.1 数据类型相关

  • bool 根据传入的参数的逻辑值创建一个新的布尔值
>>> bool()　　　　
False
>>> bool(1)
True
>>> bool(0)　　　　#数值0、空序列等值为False
False
>>> bool('str')
True
  • int 根据传入的参数创建一个新的整数
>>> int() #不传入参数时，得到结果0。
0
>>> int(3)
3
>>> int(3.6)
3
  • float 根据传入的参数创建一个新的浮点数
>>> float() #不提供参数的时候，返回0.0
0.0
>>> float(3)
3.0
>>> float('3')
3.0
  • complex 根据传入参数创建一个新的复数，复数在python里单位为 j
>>> complex() #当两个参数都不提供时，返回复数 0j。
0j
>>> complex('1+2j') #传入字符串创建复数
(1+2j)
>>> complex(1,2) #传入数值创建复数
(1+2j)

1.4.2 进制转换相关

  • bin 将整数转换成2进制字符串
>>> bin(3)     #0b为默认
'0b11'
  • oct 将整数转化成8进制数字符串
>>> oct(10)
'0o12'
  • hex 将整数转换成16进制字符串
>>> hex(15)
'0xf'

1.4.3 数学运算

  • abs 求数值的绝对值
>>> abs(-2)
2
  • divmod 返回两个数值的商和余数
>>> divmod(10,3)
(3, 1)
  • min 返回可迭代对象的元素中的最小值或者所有参数的最小值
>>> min(-1,12,3,4,5)
-1
>>> min('1234545')
'1'
>>> min(-1,0,key=abs)
0
  • max 返回可迭代对象的元素中的最大值或者所有参数的最大值
>>> max(-1,1,2,3,4)     #传入多个参数 取其中较大者
4
>>> max('1245657')     #传入1个可迭代对象，取其最大元素值
'7'
>>> max(-1,0,key=abs)    #传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
-1
  • sum 对元素类型是数值的可迭代对象中的每个元素求和
>>> sum((1,2,3,4))
10
>>> sum([1,2,3,4])
10
>>> sum((1.1,1.2,1.3))
3.5999999999999996
>>> sum((1,2,3,4),-10)
0
>>> sum((1,2,3,4),3)
13
>>> sum((1,2,3,4),5)
15
  • round 对浮点数进行四舍五入求值
>>> round(1.456778888)
1
>>> round(1.4567787888,2)
1.46
  • pow 取两个值的幂运算值，或与其他
>>> pow(2,3)        # pow 幂运算   === 2**3
8
>>> pow(2,3,5)       #取（2,3）%5  取模就是余数
3
>>> pow(2,3,4)
0
>>> pow(2,3,3)
2

1.5 和数据结构相关

1.5.1 序列

  • reversed：反转序列生成新的可迭代对象
>>> lis = [1, 2, 3, 4, 5]
>>> lis2 = reversed(lis)
>>> print(lis2)     # 保留原列表，返回一个反向迭代器
<list_reverseiterator object at 0x7f2aec656198>
>>> for i in lis2:
...     print(i)
...
5
4
3
2
1
  • slice：根据传入的参数创建一个新的切片对象
>>> l = (1,2,23,213,5612,342,43)
>>> sli = slice(1,5,2)
>>> print(l[sli])
(2, 213)
>>> print(l[1:5:2])
(2, 213)

列表和元组相关的

  • list：根据传入的参数创建一个新的列表
>>>list() # 不传入参数，创建空列表
[] 
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']
  • tuple：根据传入的参数创建一个新的元组
>>> tuple() #不传入参数，创建空元组
()
>>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
('1', '2', '1')

字符串相关

  • str：返回一个对象的字符串表现形式(给用户)
>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'
  • format：格式化显示值
      1. 函数功能将一个数值进行格式化显示。
      1. 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。
>>> format(3.1415936)
'3.1415936'
>>> str(3.1415926)
'3.1415926'
　　3. 对于不同的类型，参数format_spec可提供的值都不一样


#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))

#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'
  • bytes：字节编码

>>> bytes("你好", encoding="GBK")    # unicode 转换成 GBK 的 bytes 编码
b'\xc4\xe3\xba\xc3'
>>> bytes("你好", encoding="utf-8")    # unicode 转换成 utf-8 的 bytes 编码
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> bytes("你好", encoding="GBK").decode("GBK")    # unicode 转换成 GBK 的 bytes 编码，decode 解码为 unicode
'你好'
  • bytearry :
>>> ret = bytearray('alex',encoding='utf-8')
>>> print(id(ret))
139822331421112
>>> print(ret[0])
97
>>> ret[0] = 65
>>> print(ret)
bytearray(b'Alex')
>>> print(id(ret))
139822331421112
  • memoryview : 根据传入的参数创建一个新的内存查看对象
>>> ret = memoryview(bytes('你好',encoding='utf-8'))
>>> print(len(ret))
6
>>> print(bytes(ret[:3]).decode('utf-8'))
你
>>> print(bytes(ret[3:]).decode('utf-8'))
好
  • ord：返回Unicode字符对应的整数
>>> ord('a')
97
  • chr：返回整数所对应的Unicode字符
>>> chr(97) #参数类型为整数
'a'
  • ascii：只要是ascii码中的内容，就打印出来，不是就转出\u
>>> ascii(1)
'1'
>>> ascii('&')
"'&'"
>>> ascii(9000000)
'9000000'
>>> ascii('中文') #非ascii字符
"'\\u4e2d\\u6587'"
  • repr 用于%r 格式化输出，返回一个对象原有的类型
>>> name = "egg"
>>> print("你好 %s" % name)
你好 egg
>>> print("你好 %r" % name)
你好 'egg'
>>> print(repr("1"))
'1'
>>> print(repr(1))
1

1.5.2 数据集合

  • dict：根据传入的参数创建一个新的字典
>>> dict() # 不传入任何参数时，返回空字典。
{}
>>> dict(a = 1,b = 2) #  可以传入键值对创建字典。
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
{'b': 2, 'a': 1}
  • set：根据传入的参数创建一个新的集合
>>>set() # 不传入参数，创建空集合
set()
>>> a = set(range(10)) # 传入可迭代对象，创建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  • frozenset：根据传入的参数创建一个新的不可变集合
>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
  • len：返回对象的长度
>>> len('abcd') # 字符串
>>> len(bytes('abcd','utf-8')) # 字节数组
>>> len((1,2,3,4)) # 元组
>>> len([1,2,3,4]) # 列表
>>> len(range(1,5)) # range对象
>>> len({'a':1,'b':2,'c':3,'d':4}) # 字典
>>> len({'a','b','c','d'}) # 集合
>>> len(frozenset('abcd')) #不可变集合
  • enumerate：根据可迭代对象创建枚举对象
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  • all：判断可迭代对象的每个元素是否都为True值，有一个为False，则返回False
>>> all([1,2]) #列表中每个元素逻辑值均为True，返回True
True
>>> all([0,1,2]) #列表中0的逻辑值为False，返回False
False
>>> all(()) #空元组
True
>>> all({}) #空字典
True
  • any：判断可迭代对象的元素是否有为True值的元素，有一个为True，则返回True
>>> any([0,1,2]) #列表元素有一个为True，则返回True
True
>>> any([0,0]) #列表元素全部为False，则返回False
False
>>> any([]) #空列表
False
>>> any({}) #空字典
False
  • zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]


>>> lis = [1, 2, 3]
>>> lis2 = ["a", "b", "c"]
>>> for i in zip(lis, lis2):
...     print(i)
...
(1, 'a')
(2, 'b')
(3, 'c')
  • filter()
  • filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
    • filter 执行了filter之后的结果集合 《== 执行之前的个数
    • filter 只管筛选，不会改变原来的值
# 例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1
# 然后，利用filter()过滤掉偶数：

>>>list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17]))
# 结果：

[1, 7, 9, 17]

# 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):
    return s and len(s.strip()) > 0
>>>list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END']))
# 结果：

['test', 'str', 'END']
# 注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

# 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

>>> a = ' 123'
>>> a.strip()
'123'

>>> a = '\t\t123\r\n'
>>> a.strip()
'123'

# 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
#方法：

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
print(list(filter(is_sqr, range(1, 101))))
# 结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  • map
    • Python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
    • map 执行前后元素的个数不变
    • 值可能发生变化

有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理。

>>> L = [1,2,3,4,] 
>>> def pow2(x): 
... return x*x 
... 
>>> list(map(pow2,L))
[1, 4, 9, 16] 

>>> ret = map(abs, [1, -4, 6, -8])
>>> print(ret)
<map object at 0x7f2ae490af28>
>>> for i in ret:
...     print(i)
...
1
4
6
8
  • sorted
    • 对List、Dict进行排序，Python提供了两个方法
    • 对给定的List L进行排序，
      • 方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
      • 方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变
    • 参数说明：
      • iterable：是可迭代类型;
      • key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
      • reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，有默认值。
      • 返回值：有序列表

--------------------------------sorted---------------------------------------
sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.

# 列表按照其中每一个值的绝对值排序

l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)

#列表按照每一个元素的len排序

l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))

2，匿名函数

  • 匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

  • 上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明
函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型
  • 匿名函数并不是真的不能有名字。
  • 匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数)
# 请把以下函数变成匿名函数
def add(x,y):
    return x+y

>>> add = lambda x,y:x+y
>>> print(add(1,2))
3

>>> l=[3,2,100,999,213,1111,31121,333]
>>> print(max(l))
31121


>>> dic={'k1':10,'k2':100,'k3':30}
>>> print(max(dic))
k3
# >>> def func(key):
# ...     return dic[key]
# ...
# >>> print(max(dic,key=func))
# k2
>>> print(max(dic,key=lambda k: dic[k]))
k2
>>> print(dic[max(dic,key=lambda k:dic[k])])
100

# 1.下面程序的输出结果是：
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)

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

# max min sorted filter map
# 匿名函数 == 内置函数
# zip

ret = zip((('a'),('b')),(('c'),('d')))
# def func(tup):
#     return {tup[0]:tup[1]}
# res = map(func, ret)
res = map(lambda tup:{tup[0]:tup[1]}, ret)
print(list(ret))
# print(list(map(lambda tup:{tup[0]:tup[1]}, zip((('a'),('b')),(('c'),('d'))))))

# 结果呈现
[('a', 'c'), ('b', 'd')]

# 3.以下代码的输出是什么？请给出答案并解释。
def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])

# 结果呈现
[6, 6, 6, 6]

4，本章小结

  • 重点掌握：
    • 其他：input,print,type,hash,open,import,dir
    • str类型代码执行：eval,exec
    • 数字：bool,int,float,abs,divmod,min,max,sum,round,pow
    • 序列——列表和元组相关的：list和tuple
    • 序列——字符串相关的：str，bytes，repr
    • 序列：reversed，slice
    • 数据集合——字典和集合：dict，set，frozenset
    • 数据集合：len，sorted，enumerate，zip，filter，map
    • 参考文档：

5，相关练习题

1，用map来处理字符串列表，把列表中所有人都变成R，比方Luffy_R

name = ["Luffy", "Zoro", "Nami", "Usopp", "Sanji", ""]
# def func(item):
#     return item+"_R"
#
# ret = map(func,name)        # ret 迭代器
#
# for i in ret:
#     print(i)
#
# print(list(ret))

ret = map(lambda item:item + "_R", name)
print(list(ret))

# 结果呈现
['Luffy_R', 'Zoro_R', 'Nami_R', 'Usopp_R', 'Sanji_R', '_R']

2, 用filter函数处理数字列表，将列表中所有的偶数筛选出来

num = [1, 3, 5, 6, 7, 8]
# def func(x):
#     return x % 2 == 0
#
# ret = filter(func, num)     # ret 是迭代器
# print(list(ret))

ret = filter(lambda x:x % 2 == 0, num)
ret = filter(lambda x:True if x % 2 == 0 else False, num)
print(list(ret))

# 结果呈现
[6, 8]

3，随意写一个20行以上的文件，运行程序，先对内容读到内存中，用列表存储，接收用户输入页码，每页5条，仅输出当页的内容

with open("page_file",encoding="utf-8") as f :
    lis = f.readlines()

page_num = int(input("请输入页码："))
print(page_num)
pages,mod = divmod(len(lis),5)      # 求有多少页，有没有剩余的行数

if mod:                 # 如果有剩余的行数，那么页数加一
    pages += 1        # 一共多少页
if page_num > pages or page_num <= 0 :        # 用户输入的页数大于总数
    print("输入有误")
elif page_num == pages and mod != 0:        # 如果用户输入的页码是最后一页，且之前有过剩余行数
    for i in  range(mod):
        print(lis[(page_num - 1) * 5 + i].strip())      # 只输出这一页上的剩余的行
else:
    for i in range(5):
        print(lis[(page_num - 1) * 5 + i].strip())      # 输出5行

# 结果呈现
请输入页码：1
1
1,“草帽”蒙奇·D·路飞（モンキーD·ルフィ/Monkey D. Luffy） [12]
2,初次登场：漫画第1话
3,年龄：17岁→19岁
4,生日：5月5日
5,血型：F型

# page_file
1,“草帽”蒙奇·D·路飞（モンキーD·ルフィ/Monkey D. Luffy） [12]
2,初次登场：漫画第1话
3,年龄：17岁→19岁
4,生日：5月5日
5,血型：F型
6,身高：172cm→174cm
7,故乡：东海·风车村
8,身份：草帽海贼团船长
9,喜欢的食物：所有美食，首先是肉。
10,爱好：喜欢探险，感兴趣于新奇怪异的事物
11,梦想：找到ONE PIECE，并成为海贼王。
12,恶魔果实：超人系橡胶果实
13,身世：父亲是革命军首领蒙奇·D·龙，爷爷是海军中将英雄卡普。
14,悬赏：3千万（可可亚西村事件）→1亿（阿拉巴斯坦事件）→3亿（司法岛事件）→4亿（顶上战争）→5亿（德雷斯罗萨篇）→15亿（蛋糕岛事件）
15,由于他的标志性特征是一顶草帽，因此常被直接称呼为“草帽”。梦想是找到传说中的ONE PIECE，成为海贼王。性格积极乐观，爱憎分明且十分重视伙伴，对任何危险的事物都超感兴趣。看似白痴，却是一个大智若愚型的无愧船长之职的人。和其他传统的海贼所不同的是，他并不会为了追求财富而无故杀戮，而是享受着身为海贼的冒险。 [13]
16,“海贼猎人”罗罗诺亚·索隆（ロロノア·ゾロ/Roronoa Zoro） [14]
17,初次登场：漫画第3话
18,年龄：19岁→21岁
19,生日：11月11日
20,血型：XF型
21,故乡：东海·霜月村
22,身份：东海海贼赏金猎人→草帽海贼团战斗员
23,身高：178cm→181cm
24,喜欢的食物：白米，海兽的肉，适合下酒的食物
25,爱好：睡觉、修炼、喝酒。
26,缺点：路痴
27,梦想：世界第一大剑豪
28,悬赏：6千万（阿拉巴斯坦事件）→1亿2000万（司法岛事件）→3亿2000万（德雷斯罗萨篇）
29,爱喝酒，爱睡觉，讲义气，海贼第一超级大路痴。为了小时候与挚友的约定而踏上了前往世界第一剑士的道路，随后成为路飞出海后遇到的第一个伙伴。在初次败给世界第一剑士“鹰眼米霍克”后向路飞发誓永不再败，并且更加努力的锻炼自己。两年后的他成功与伙伴们汇合，并且为了实现自己的梦想，奔赴强者如云的新世界。 [13]

4，如下，每个小字典的name对应股票的名字，shares对应多少股，price对应股票的价格

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},
]

4.1 计算购买每支股票的总价

result = map(lambda dic: {dic["name"]:round(dic["shares"] * dic["price"])},portfolio)
print(list(result))

# 结果呈现
[{'IBM': 9110}, {'AAPL': 27161}, {'FB': 4218}, {'HPQ': 1111}, {'YHOO': 736}, {'ACME': 8674}]

4.2 用filter过滤出，单价大于100的股票有哪些

ret = filter(lambda dic: True if dic["price"] > 100 else False, portfolio)
print(list(ret))
ret = filter(lambda dic: dic["price"] > 100, portfolio)
print(list(ret))

# 结果呈现
[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
posted @ 2018-09-19 18:24  小Q渺晓  阅读(231)  评论(0)  编辑  收藏  举报