自学Python--内置函数

内置函数：

 

作用域相关：

本地作用域中所有名字：locals()

全局作用域中所有名字：globals()

 

迭代器相关：

迭代器下一个值：next(迭代器)

生成一个迭代器：iter(可迭代对象)

 

其他：

查看一个对象拥有的方法：dir(对象)

s = ''
print('join' in dir(s)) # True

 

查看函数是否可调用：callable(函数名)  只可以检查函数，如果检查变量则返回false

print(callable(print)) # True

 

帮助文档：help() 不需要print也能输出帮助文档，比dir详细

 

文件相关：

打开文件：open()

是否可写：writable()

是否可读：readable()

f = open('xxx')
print(f.writable()) # 是否可写
print(f.readable()) # 是否可读

 

内存相关：

内存地址：id()

哈希：hash(),不可哈希即可变数据类型会报错unhashable，在一次程序执行中，同一个不可变数据类型的哈希值唯一

字典的key就是经过hash存储value，字典寻址时拿hash后的key取对应的值，因为hash值唯一所以字典速度快

 

字符串类型代码的执行：

exec(str):执行字符串格式的代码，无返回值,适合处理简单流程控制

eval(str):同exec()，返回执行结果，适合处理有结果的简单计算

compile():将字符串类型代码进行编译，使代码能通过eval或者exec执行。一次编译多次执行

只能用在明确知道所要执行的代码是什么且确实需要使用

print(exec('1 + 2 + 3')) # 无返回值
print(eval('1 + 2 + 3')) # 6

 

列表相关：

反转：reversed(),保留原列表，返回新的列表迭代器

l1 = [1, 2, 3, 4, 5, 6]
l1.reverse()
print(l1) # 反转后原列表变化

l2 = [1, 2, 3, 4, 5, 6]
l3 = reversed(l2)
print(type(l3)) # <class 'list_reverseiterator'>
print(list(l3)) # [6, 5, 4, 3, 2, 1]
print(l2) # [1, 2, 3, 4, 5, 6]

 

切片：slice(切片规则)

l1 = [1, 2, 3, 4, 5, 6]
sli = slice(1, 5, 2) # 切片规则
print(l1[sli]) # [2, 4]

 

字符串相关：

格式化：format()

 

几个重要的内置函数：

all():接收一个可迭代对象，所有元素为真时返回真，否则返回假

print(all(['a', '', 123])) # False
print(all(['a', '1', 123])) # True
print(all([0, 123])) # False

any():同all()类似，所有元素都为假时返回假，否则返回真

zip():“拉链”，zip的两个参数数量不一样时，以数量少的为准。参数为字典时，只“拉”字典的key

l1 = [1, 2, 3]
l2 = ['a', 'b', 'c']
res = zip(l1,l2)
print(type(res)) # <class 'zip'>
print(list(res)) # [(1, 'a'), (2, 'b'), (3, 'c')]

 

filter(函数，可迭代对象):过滤后返回迭代器

def is_odd(n):
    return n % 2 == 1
l = [1, 2, 3, 4, 5, 6]
res = filter(is_odd, l) # 相当于[i for i in l if i % 2 == 1]
print(type(res)) # <class 'filter'>
print(list(res)) # [1, 3, 5]

===========================================================

def is_str(l):
    return type(l) is str
l = [1, '2', 3, '4', 5, '6']
res = filter(is_str, l) 
print(type(res)) # <class 'filter'>
print(list(res)) # ['2', '4', '6']

 

map():接受一个函数名和一个可迭代对象，类似于filter，但不过滤，返回迭代器

res = map(abs, [1, -1, 2, -2, 3, -3])
print(list(res)) # [1, 1, 2, 2, 3, 3]

map和filter区别：

filter只筛选，不改变原值，可能改变个数

map不改变个数，可能改变值

 

sorted():接收可迭代对象，返回新的可迭代对象。占内存

l = [1, -4, 6, 5, -10, -12]
res = sorted(l)
print(res) # [-12, -10, -4, 1, 5, 6]
print(l) # [1, -4, 6, 5, -10, -12]

列表按元素长度排序：

l = ['aadf', 'dsgagadgs', 'afd', 'adfasdfasfsv', 'asfaaa', 'ajksdnfaksf;akljsdf']
print(sorted(l, key=len)) # ['afd', 'aadf', 'asfaaa', 'dsgagadgs', 'adfasdfasfsv', 'ajksdnfaksf;akljsdf']