2.4-内置函数，匿名函数

目录

内置函数，匿名函数

内置函数

函数是以功能为导向，一个函数封装一个功能，python将一些常用的功能封装成一个个函数，供我们使用（效率高（底层是c语言）），而且拿来即用，避免重复造轮子。这些函数就称为内置函数，目前为止，python一共提供了68个内置函数

了解：

all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()

重要：

abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()

其他：

classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()

比较重要-----------------------------------------------------------

eval 执行字符串类型的代码，返回最终结果

print(eval('2 + 2'))    # 4
n = 88
print(eval('n + 1'))    # 89
eval('print(777)')  # 777

exec 执行字符串类型的代码

s = '''
for i in [1, 2, 3]:
    print(i)
'''
exec(s)

hash 获取一个对象（可哈希对象：int，str， book， tuple）的哈希值

print(hash(123))
print(hash('123'))
print(hash('aaa'))
print(hash(True))
print(hash(False))
print(hash((1, 2, 3)))
# 123
# 3891538836099095335
# 907318982906182040
# 1
# 0
# 2528502973977326415

help 函数用于查看函数或模块用途的详细说明

print(help(list))

callable 检查对象是否可调用

# 如果返回True， object仍然可能调用失败；但如果返回False，调用对象object肯定不会成功
name = '黑色利穆'
def func():
    pass
print(callable(name))       # False
print(callable(func))       # True

int 将一个字符串或数字转换成整型

print(int())        # 0
print(int('123'))   # 123
print(int(4.6))     # 4
print(int('0100', base=2))  # 4 二进制转化成十进制

float 用于将整数和字符串转化成浮点数

print(float(3)) # 3.0

complex 创建一个值为real +imag * j 的复数，或转化一个字符串或数为复数

# 如果第一个参数为字符串，则不需要指定第二个参数
print(complex(1, 2))        # (1+2j)

bin 将十进制转化成二进制并返回

print(bin(10), type(bin(10)))       # 0b1010 <class 'str'>

oct 将十进制转化成八进制并返回

print(oct(10), type(oct(10)))       # 0o12 <class 'str'>

hex 将十进制转化成十六进制并返回

print(hex(10), type(hex(10)))       # 0xa <class 'str'>

divmod 计算除数与被除数的结果，返回一个包含商和余数的元组（a // b, a % b)

print(divmod(9, 4))     # (2, 1)

round 保留浮点数的小数位数，默认保留整数

print(round(7/3, 2))        # 2.33
print(round(7/3))       # 2
print(round(3.1415926, 4))      # 3.1416

pow 求x ** y次幂（三个参数为x**y的结果对z取余）

print(pow(2, 3))        # 8
print(pow(2, 3, 3))     # 2

bytes 不同编码之间的转化

s = '你好'
bs = s.encode('utf-8')
print(bs)       # b'\xe4\xbd\xa0\xe5\xa5\xbd'
s1 = bs.decode('utf-8')
print(s1)       # 你好
bs = bytes(s, encoding='utf-8')
print(bs)       # b'\xe4\xbd\xa0\xe5\xa5\xbd'
b = '你好'.encode('gbk')
print(b)        # b'\xc4\xe3\xba\xc3'
b1 = b.decode('gbk')
print(b1)       # 你好
print(b1.encode('utf-8'))   # b'\xe4\xbd\xa0\xe5\xa5\xbd'

ord 输入字符找该字符编码的位置

print(ord('a'))     # 97
print(ord('利'))     # 21033

chr 输入位置数字找其对应的字符

print(chr(97))      # a
print(chr(21033))   # 利

repr 返回一个对象的string形式

# %r 原封不动的写出来
name = '黑色利穆'
print('我叫%r'%name)      # 我叫'黑色利穆'
# repr 原形毕露
print(repr('{"name":"黑色利穆"}'))  # '{"name":"黑色利穆"}'
print('{"name":"黑色利穆"}')        # {"name":"黑色利穆"}

all 可迭代对象中，全都是True才是True

print(all([1, 2, True, 0]))     # False
​```python

### any   可迭代对象中，有一个True就是True
​```python
print(any([1, '', 0]))      # True

重要---------------------------------------------------------------------

pring 屏幕输出

''' 源码分析
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: 立即把内容输出到流文件，不作缓存
    """
'''
print(111, 222, 333, sep='*')       # 111*222*333

print(111,end='')
print(222)      # 111222

f = open('log', mode='w', encoding='utf-8')
print('写入文件', file=f,flush=True)

int pass

str pass

bool pass

set pass

list 将可迭代对象转化成列表

l1 = list('abcd')
print(l1)       # ['a', 'b', 'c', 'd']

tuple 将可迭代对象转化成元组

​```python
tu = tuple('abcd')
print(tu) # ('a', 'b', 'c', 'd')


### dict    将可迭代对象转化成字典

### abs     返回绝对值

```python
i = -8
print(abs(i))       # 8

sum 求和

print(sum([1, 2, 3]))       # 6
print(sum((1,2,3), 100))    # 106

min 最小值

print(min([1,2,3]))     # 1

ret = min([-7, 2, -3,], key=abs)    # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动回获取传入函数中的参数的每个元素，然后通过设定的返回值比较大小，返回最小的传入的那个参数

print(min(1,2,-4,5,-6,key=lambda x:abs(x))) # 1 可以设置很多参数比较大小

dic = {'a':1, 'b':2, 'c':3}
print(min(dic,key=lambda x:dic[x]))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键

max 最大值，用法和min相同

reversed 将一个序列翻转，返回翻转序列的迭代器

l = reversed('你好')    # 获取到一个生成器
print(list(l))          # ['好', '你']
ret = reversed([1, 2, 3, 4, 5, 6])
print(list(ret))        # [6, 5, 4, 3, 2, 1]

bytes 把字符串转成bytes类型

s = '黑色利穆'
bs = s.encode('utf-8')
print(bs)       # b'\xe9\xbb\x91\xe8\x89\xb2\xe5\x88\xa9\xe7\xa9\x86'

s1 = bs.decode('utf-8')
print(s1)       # 黑色利穆

bs = bytes(s, encoding='utf-8')     # 字符串转成字节
print(bs)       # b'\xe9\xbb\x91\xe8\x89\xb2\xe5\x88\xa9\xe7\xa9\x86'
s1 = str(bs, encoding='utf-8')      # 字节转成字符串
print(s1)       # 黑色利穆

zip 拉链方法

# 用于将可迭代对象作为参数，将对象中对应的元素打包转成一个个元组；
# 然后返回由这些元组组成的内容，如果各个迭代器的元素个数不一致，按长度最短的返回
lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c', 'd']
lst3 = (4, 5, 6, 7, 8, 9)
for i in zip(lst1, lst2, lst3):
    print(i)
# (1, 'a', 4)
# (2, 'b', 5)
# (3, 'c', 6)

sorted 排序函数

# 语法：sorted(iterable, key=None, reverse=False)
# iterable  可迭代对象
# key   排序规则，在sorted内部会将可迭代对象的每一个元素传递给这个函数的参数，根据函数运算的结果进行拍粗
# reverse   是否倒序，True倒序，False正序
lst = [1,2,3,6,5,4]
lst2 = sorted(lst)
print(lst)      # [1, 2, 3, 6, 5, 4]
print(lst2)     # [1, 2, 3, 6, 5, 4]
lst3 = sorted(lst, reverse=True)
print(lst3)     # [6, 5, 4, 3, 2, 1]

# 字典排序
dic = {1:'a', 3:'c', 2:'b', 4:'d'}
print(sorted(dic))      # [1, 2, 3, 4]  # 返回排序后的key

# 和函数组合使用
# 定义一个列表，根据元素长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
# 计算字符串长度
def func(s):
    return len(s)
print(sorted(lst, key=func))        # ['西游记', '红楼梦', '天龙八部', '三国演义']

# 和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst, key=lambda s:len(s), reverse=True))       # ['天龙八部', '三国演义', '西游记', '红楼梦']

lst = [{'id':1,'name':'xiaoming','age':18},
    {'id':2,'name':'xiaohong','age':17},
    {'id':3,'name':'xiaozhang','age':16},]
# 按照年龄对学生信息进行排序
print(sorted(lst, key=lambda s:s['age']))
# [{'id': 3, 'name': 'xiaozhang', 'age': 16}, {'id': 2, 'name': 'xiaohong', 'age': 17}, {'id': 1, 'name': 'xiaoming', 'age': 18}]

filter 筛选过滤

# 语法 filter(function, iterable)
# function  用来筛选函数，在filter中自动把iterable中的元素传递给funciton
# 然后根据function返回的True或者False判断是否保留此项数据
# iterable  可迭代对象
lst = [{'id':1,'name':'xiaoming','age':18},
    {'id':2,'name':'xiaohong','age':17},
    {'id':3,'name':'xiaozhang','age':16},]

print(list(filter(lambda s:s['age'] > 16, lst)))
# [{'id': 1, 'name': 'xiaoming', 'age': 18}, {'id': 2, 'name': 'xiaohong', 'age': 17}]

map 映射函数

# 语法 map(function, iterable)
# 可以对可迭代对象中的每一个元素进行映射，分别去执行function
# 计算列表中每个元素的平方，返回新列表
lst = [1,2,3,4,5]
def func(s):
    return s*s
print(list(map(func, lst)))
# [1, 4, 9, 16, 25]

# 改写成lambda
lst = [1,2,3,4,5]
print(list(map(lambda s:s*s, lst)))
# [1, 4, 9, 16, 25]

# 计算两个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x,y:x+y, lst1,lst2)))
#  [3, 6, 9, 12, 15]

reduce

# reduce的作用是先把列表中的前两个元素取出计算出一个值然后临时保存；
# 用临时保存的值和列表中第三个元素进行计算，求出䘝新的值覆盖上一步临时保存的值；
# 然后用这个新的和第四个元素进行计算，一次类推
# reduce使用方法：reduce(函数名, 可迭代对象)
from functools import reduce
def func(x,y):
    return x + y
ret = reduce(func, [1,2,3,4,5,6])
print(ret)      # 21

# 先有[2,3,4,5]想让列表中的数编程2345，使用reduce
# 普通版
def func(x, y):
    return x * 10 + y
    # step1:x=2,y=3 ,2*10+3=23,23临时保存
    # step2:x=23,y=4,23*10+4=234,234临时保存
    # step3:x=234,y=4,234*10+5=2345,返回
print(reduce(func, [2,3,4,5]))      # 2345

# 匿名函数版
print(reduce(lambda x,y:x*10+y, [2,3,4,5]))     # 2345
# python2中reduce可以直接import，python3需要从functools这个包中导入

匿名函数

匿名函数，没有名字的函数。lambda（一句话函数）

def func(a, b):
    return a+b
print(func(3,4))

# 用匿名函数完成上面函数
func = lambda a,b: a+b
print(func(3,4))

语法：

  1. 函数名 = lambda 参数: 返回值
  2. 此函数不是没有名字，名字就是设置的变量，比如func
  3. lambda是定义匿名函数的关键字，相当于函数的def
  4. lambda后面直接加形参，形参加多少都可以，只用逗号隔开就行
  5. 返回值在冒号之后设置，返回值和正常的函数一样，可以是任意数据类型
  6. 匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据
func = lambda a,b,*args,sex='女',c,**kwargs: kwargs
print(func(3,4,c=5,name='hslm'))        # {'name': 'hslm'}

练习：

# 写匿名函数，接收一个可切片数据，返回索引为0与2的对应的元素（元组形式）
func = lambda x:(x[0], x[2])
print(func('黑色利穆'))
# ('黑', '利')

# 写匿名函数：接收两个int参数，将较大的数据返回
func = lambda x,y:x if x > y else y
print(func(1, 2))
posted @ 2020-12-03 18:50  黑色利穆  阅读(66)  评论(0)  编辑  收藏  举报