python内置函数

# -*- coding:utf-8 -*-


# 作用域相关
globals()     # 返回一个字典：包含全部的全局变量
locals()     # 返回一个字典：包含全部的局部变量

# 其他相关（不建议用）
eval('1+1')      # 把字符串两边的引号去掉，执行中间的代码，并返回执行结果
# eval只能用在你明确知道你要执fn 行的代码是什么
exec("""for i in range(3):
            print(i)""")      # 把字符串两边的引号去掉，执行中间的代码，没有返回值，用于代码流
# compile()     # 将字符串类型的代码编译，代码对象能够通过exec语句来执行或eval进行求值

# 输入输出相关
# input()     # 接收一个标准输入数据，返回一个字符串
print()     # 打印输出
print(*(1, 2, 3))    # 函数的定义*是聚合的意思；函数的执行*是打散的意思
# print(1, 2, 3, sep='|', end='')  # sep打印多个内容的分隔符默认是空格,end默认换行
f = open('t1', encoding='utf-8', mode='w')
print(1, '2', file=f)

# 内存相关
hash(3)   # 获取一个对象的哈希值（可哈希的对象：int ，str， bool， tuple）    字典和集合都是不可哈希的数据类型
# 对于相同可哈希的数据hash值在一次程序执行过程中无论哈希多少次都不会有变化
# 字典：会将你所有的key在内存中转化为ID  （字典的键必须是可哈希的数据类型，即不可变数据类型）
id(1)    # 获取该对象的内存地址

# 文件相关   open()

# 模块相关   __import__   函数用于动态加载类和函数

# 帮助
# help(str)

# 调用相关
a = 1
callable(1)   # 检测一个变量是否可以被调用

# 查看内置方法
# name = 'alex'
# dir(name)    # 变量的所有方法

# 迭代器生成器相关
# range(2)   返回可迭代的对象
# iter()
# next()

# 基础数据类型相关
bool()    # 检测一个对象
int()     # 取整，不是四舍五入
int('0101', base=2)   # 将二进制0101转化为十进制
float()    # 将字符串转化为浮点型

# 进制转换
# bin()   # 将十进制转化为二进制并返回
# oct()   # 将十进制转化为八进制字符串并返回
# hex()   # 将十进制转化为十六进制字符串并返回

# 数学运算
# abs()       # 返回数字的绝对值
# divmod()    # 计算除数与被除数的结果，返回一个包含商和余数的元组
# round()     # 保留浮点数的小数位数，默认保留整数
# pow()       # 求x**y的次幂，（第三个参数对z取余）
# sum()       # 对可迭代的对象进行求和  sum(iterable, start_num)  第二个参数设置初始值
# min()       # min(iterable, key=函数名)  根据函数的规则求最小值
list1 = [('alex', 1000), ('wusir', 500), ('taibai', 18)]
def func(x):
    return x[1]
min(list1, key=func)
# 1、他会将iterable的每一个元素当做函数的参数传进去
# 2、他会按照key的返回值去取最小值
# 3、返回的是遍历iterable中的元素
dict1 = {'a':3, 'b':2, 'c':1}
def func2(x):
    return dict1[x]
print(min(dict1, key=func2))
print(max(dict1, key=lambda x: dict1[x]))

#数据类型强转换类
list()
tuple()
set()
frozenset()   # 比可变的集合
str()

# 数据类型：int str bool dict list set tuple
# 数据结构：dict list set tuple str      dict和tuple是python独有的数据类型

# 反转
list2 = []
# list2.reverse()    反转列表，改变原来的列表
reversed(list2)      # 保留原列表，返回一个反向的迭代器

# 切片
slice(1,5,2)    # 制定一个其切片规则

# 字符串
print(format('test', '<40'))   # 开40个空格，向左对齐
print(format('test', '>40'))
print(format('test', '^40'))

print(bytes('石谦', encoding='utf-8'))
print(bytes('石谦', encoding='GBK').decode('gbk'))
# 文件保存可以是各种编码，读到内存中都是Unicode编码

print(ord('a'))   # 字符按照Unicode转数字
print(ord('石'))   # 字符按照Unicode转数字
print(chr(97))    # 数字按照Unicode转字符
print(ascii('石'))  # 不是asciii的加/u输出

print(repr('1'))   # 原形毕露数据类型，格式化输出%r
print(repr(1))

# 数据结构相关
# enumerate()   # 枚举
# all和any接收一个可迭代的
# all()   # 有任何一个FALSE整体返回FALSE
# any()   # 有人一个true整体返回true

# 几个重要的
zip()     # 拉链方法，返回一个生成器
lst1=[1,2,3]
lst2=['a','b','c']
print(dict(zip(lst1, lst2)))

filter('函数名','可迭代的对象')
# 1、将可迭代的对象依次传入函数中，
# 2、函数的返回值必须是bool，过滤出结果为true的，
# 3、返回值是生成器，仍是可迭代对象的值

map('函数名','可迭代的对象')
# 1、将可迭代的对象依次传入函数中，
# 2、函数的返回值任意
# 3、返回值是生成器，是函数的返回值的生成器

l=[]
l.sort(key='函数名')   # 改变列表，排序，省内存
sorted(l,key='',reverse=True)    # 速度快，占内存
# 1、将可迭代的对象依次传入函数中，
# 2、根据函数的返回值进行排序
# 3、排好序后，返回的是遍历iterable中的元素，返回的是一个直接的列表，不是生成器。


# 面试题
#1、匿名函数+zip+map
ret = zip((('a'), ('b')), (('c'), ('d')))
print(list(map(lambda tup:{tup[0]: tup[1]}, ret)))
#2、下面代码的输入
def multipliers():
    return (lambda x:i*x for i in range(4))
print([m(2) for m in multipliers()])