python基础十三之内置函数

内置函数

　　操作字符串代码

　　　　eval和exec

print(eval('1+2'))  # 简单的计算 有返回值
exec('for i in range(10):print(i)')  # 简单的流程控制  没有返回值

　　　　compile 将字符串代码编译成eval或exec理解的对象供其进行操作

c = compile('1+2', '', 'eval')
print(eval(c))
c = compile('for i in range(10):print(i)', '', 'exec')
exec(c)

　　输入输出

　　　　print和input

input('用户交互：')  # 接收用户输入

# 打印输出，end默认换行
print('默认换行', end='')
print('默认换行')
print('默认换行', end='')
# sep默认空格分割
print(1, 2, 3, 4, 5)
print(1, 2, 3, 4, 5, sep='|')
# file默认打印在控制台
f = open('print_test', 'w')
l = 'zxc'
print(l, file=f)
f.close()

　　内存相关

　　　　id和hash

print(id(1))  # 获取对象的内存地址
print(hash('zxc'))  # 获取对象的哈希值 在一次程序运行中一个对象的哈希值是不变的

　　文件操作

　　　　open

f = open('file', encoding='utf-8')  # 以指定方式打开文件 f叫文件句柄或文件操作符

　　模块相关

　　　　import和__import__

import time  # 导入功能模块
time = __import__('time')  # 相当于import time
print(time.time())

　　调用相关

　　　　callable

def test():
    pass
print(callable(list))  # 判断一个对象是否可以被调用 返回bool值
print(callable(test))

　　帮助

　　　　help

help()  # 进入帮助模式，q推出
help(help)  # 获取对象的帮助信息

　　查看对象的内置方法

　　　　dir

print(dir(str))
print(dir(__builtins__))  # 查看所有的内置函数

　　作用域

　　　　globals和locals

print(globals())  # 获取全局作用域的名字
print(locals())  # 获取本地作用域的名字

　　迭代器和生成器相关

　　　　iter和next

iterator = iter([1, 2, 3])
print(iterator)  # iter将一个可迭代对象转换为迭代器
print(next(iterator))  # 获取迭代器的下一个值
for i in range(5):  # range可迭代的，不是迭代器 取值通过for循环或list转格式
    print(i)

　　数据类型

　　　　bool布尔值 int整形 float浮点型 complex复数 str字符串 lIst列表 tuple元组 dict字典 set集合

　　进制转换

　　　　bin，oct和hex

print(bin(10))  # 转换为二进制
print(oct(10))  # 转换为八进制
print(hex(10))  # 转换为十六进制

　　数学运算

　　　　abs

print(abs(-5))  # 获取数字的绝对值

　　　　divmod

print(divmod(5, 2))  # 获取(商，余数)

　　　　round

print(round(10.562398498234, 3))  # 获取小数精确到指定位数的数字

　　　　pow

print(pow(2, 4))  # 进行指定幂的幂运算
print(pow(2, 4, 3))  # 进行指定幂的幂运算后对指定数取余

　　　　sum

print(sum([1, 2, 3], 3))  # 计算可迭代的对象的和，元素要都是数字类型  可以指定加和开始位置

　　　　max和min

print(max([3, 2, 4, 5], [5, 8]))   # 获取多个数字中的最大值
print(min(3, 2, 4, 5))   # 获取多个数字中的最小值

　　和数据结构相关

　　　　reversed反转

lis = [1, 2, 4, 5, 6, 'zx']  # 参数可迭代的
iterator = reversed(lis)  # 返回迭代器
print(list(iterator))   # ['zx', 6, 5, 4, 2, 1]

　　　　sliec 用于对可迭代对象的切片

lis = [1, 2, 3, 4, 5, 6]
print(lis[slice(4, None, -1)])  # 相当于lis[4::-1]  [5, 4, 3, 2, 1]

　　　　format

# 数据类型转换
print(type(format([1, 3, 4])))  # 相当于str() 转换为字符串格式

# 格式化输出
print(format('zxc', '<20'))  # 左对齐
print(format('zxc', '^20'))  # 居中显示
print(format('zxc', '>20'))  # 右对齐

# 进制转换
print(format(10, 'b'))  # 转换为二进制
print(format(10, 'd'))  # 转换为十进制
print(format(10, 'o'))  # 转换为八进制
print(format(10, 'x'))  # 转换为十六进制

　　　　bytes和bytearray

# bytes 将对象转换为bytes类型，不能修改里面的内容
print(bytes('zxc', encoding='utf-8'))
# bytearray 将对象转换为bytes类型,且能修改里面的字节
s = bytearray('zxc', encoding='utf-8')
s[0] = 65
print(s)  # bytearray(b'Axc')

　　　　ord，chr和ascii

# ord 获取单个字符ASCII码对应数字
print(ord('a'))  #

# chr 返回指定数字在ASCII码中对应的字符
print(chr(97))  # a

# ascii
print(ascii('a'))  # 'a'
print(ascii('中'))  # '\u4e2d'

　　　　reper

# reper 格式化输出 传进去的什么样就打印什么样
print('my name is %r' % 'zxc')  # my name is 'zxc'
print(repr(''))  # '1'
print(repr(1))  #

　　　　enumerate

# enumerate 枚举
for index, i in enumerate([1, 2, 3], 1):
    print(index, i)

　　　　all和any

# all 判断可迭代对象是否有bool值为False的元素，对象为空返回True
print(all([1, True, 'a']))  # True
print(all([1, '', 'a']))  # False

# any 判断可迭代对象是否有bool值为True的元素
print(any([1, True, 'a']))  # True
print(any([False, '', ()]))  # False

　　　　zip

# zip 将多个可迭代的对象拉链组合 返回一个迭代器
z = zip([1, 2], 'ab')
print(next(z))  # (1, 'a')
print(next(z))  # (2, 'b')

　　　　filter

# filter  筛选，将可迭代对象的每个元素传入前面的函数，筛选出返回结果为True的元素
def func(s):
    return len(s) > 2
f = filter(func, ['zxc', '', 'good'])  # f为迭代器
for i in f:
    print(i)

　　　　map

# map  处理，将可迭代对象的每个元素传入前面的函数，获取处理结果
m = map(len, ['zxc', '', 'good'])
for i in m:
    print(i)

　　　　sorted

# sorted 排序，获取一个全新的对象
lis = [1, 4, 5, 2, 3]
lis1 = sorted(lis)
print(lis1)   # [1, 2, 3, 4, 5]
print(lis)    # [1, 4, 5, 2, 3]
lis = ['zxc', '', 'good']
lis1 = sorted(lis, key=len)  # key指定函数，按返回值对对象进行排序
print(lis1)   # ['1', 'zxc', 'good']