内置函数

作用域相关：
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
# def func():
#     a = 1
#     b = 2
#     print(locals())   #根据所在的位置不同，打印的内容不同
#     print(globals())  #不管在哪儿，打印的内容都一样
# func()

迭代器，生成器相关
# range(100).__iter__()
# iterator = iter(range(100))  #拿到一个迭代器  更优秀的方法
# print(iterator.__next__())
# print(next(iterator))        #打印更优秀的方法

# for i in range(100):
#     print(i)

查看内置属性：
# print(dir([]))
# print(dir(5))

调用相关：
callable：查看能否调用
# a = 1
# def func():pass
# print(callable(a))      #不可以调用
# print(callable(print))  #可以调用
# print(callable(func))   #可以调用

帮助：
#help：包含所有方法名以及他的使用方法 —— 不知道用法

#ctrl + 左键单击 ：pycharm
#help：包含所有方法名以及他的使用方法 —— 不知道用法
#dir：只包含方法名 —— 想查看某方法是否在这个数据类型中

模块相关：
import 后面跟的是模块
import time   #时间
import os     #操作系统

文件操作相关：
# f = open('文件名','w',encoding='utf-8')
#打开模式：r、w、a、rb、wb，ab
#编码 utf-8/GBK

内存相关：
# print(id(1))
# print(id(2))
# print(hash('sajghfj;eyrwodnvjnz,.jifupwk'))  #算法
# print(hash(125342))
# print(hash((1,2,3,4)))

# hash([1,2,3,4,5,6,])
#hash 判断一个数据类型是否可以hash
#在一个程序执行的过程中，对同一个值hash的结果总是不变
#多次执行，对同一个值的hash结果可能改变

输入输出相关：
input：
# s = input('提示:')

print：
# print(1,2,3,4,5,sep='*')  #sep是指定多个要打印的内容之间的分隔符
# print(1,2,3,4,5)  #多个要打印的内容之间的分隔符默认为空

# print(1,2,sep=',')   #print('%s,%s'%(1,2))   #这两种是一样的

# f = open('a','w')
# print('abc
'，file=f)指定往文件里写内容
# print('abc
')默认打印到屏幕，本质也是写到文件里输出
# print(2)


打印进度条：
# import time
# for i in range(0,101,2):  #[0,2,4,6,8...100]
#      time.sleep(0.2)
#      char_num = i//2      #打印多少个'*'    8/2 = 4
#      if i == 100:
#           per_str = '
%s%% : %s
' % (i, '|' * char_num)  #
 :把光标移到文件最开始
#      else:
#           per_str = '
%s%% : %s'%(i,'|'*char_num)
#      print(per_str,end='', flush=True)
带颜色输出：
# print("33[31;1mHello world,how are you 33[0m")
格式：
# print('33[4;32;41m金老师')
# print('egon')
# print('alex 33[0m')


字符串类型的代码的执行：（exec，eval，compile非常危险的函数执行）
# exec("print('12345')")
# eval("print('12345')")
exec，eval都是内置函数，都可以以Python代码的形式执行一个字符串，括号中必须是一串合法的代码。

# print(exec('1+2+3-4'))  #exec 没有返回值，用于流程性代码的执行
# print(eval('1+2+3-4'))  #eval 有返回值，用于值计算的时候（有结果的）

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

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

# code1 = 'for i in range(0,10): print (i)'
# compile1 = compile(code1,'','exec')
# exec(compile1)

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

# code3 = 'name = input("please input your name:")'
# compile3 = compile(code3,'','single')
# # name #执行前name变量不存在
# exec(compile3)
# print(name)

基础数据类型相关：
数学运算：
abs：取绝对值
# print(abs(5))

divmod：取商余
# ret = divmod(10,2)
# print(ret)
# ret = divmod(3,2)
# print(ret)
# ret = divmod(7,2)
# print(ret)

round：保留几位小数
# print(round(3.14159,2))

pow：幂运算，括号里三个参数，先取幂运算，再取余运算
# print(pow(2,3.5))   #幂运算
# print(pow(3,2))
# print(pow(2,3,2))
# print(pow(2,3,3))  #x**y%z

sum：括号内接受一个迭代对象
# print(sum([1,2,3,4,5,6],-2))
# print(sum(range(100)))

min：
# print(min([1,4,0,9,6]))
# print(min([],default=0))  #防止报错，加一个default值
#print(min([-9,1,23,5],key=abs))  #可以附加函数

max：
# t = (-25,1,3,6,8)
# print(max(t))
# print(max(t,key = abs))
# print(max((),default=100))

数据结构相关的：
reversed：求反序
# l = [3,4,2,5,7,1,5]    
# ret = reversed(l)
# print(ret)
# print(list(ret))
reversed：返回迭代器，生成一个新的序列迭代器

# l.reverse()
# print(l)
reverse：返回None，是在原本的列表的基础上修改的

sli:切片
# l = (1,2,23,213,5612,342,43)
# sli = slice(1,5,2)   #实现了切片的函数  等于l[1:5:2]
# print(l[sli])

format:
# print(format('test', '<20'))      #左对齐
# print(format('test', '>20'))      #右对齐
# print(format('test', '^20'))      #居中


bytes：
#网络编程的时候：能在网络上传递的必须是字节
# ret = bytes('你好，哈哈哈，再见',encoding='utf-8')
# #中间是网络传输的过程
# print(ret.decode(encoding='utf-8'))


bytearray：
# ret = bytearray('alex',encoding='utf-8')  #对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearry的内存地址
# print(id(ret))
# print(ret[0])  #打印“alex”中的a的ASCII码数值
# ret[0] = 65    #改变a的ASCII数值，改变了它的大小写
# print(ret)
# print(id(ret))

ord：字符按照Unicode转数字
# print(ord('a'))

chr：数字按照Unicode转字符
# print(chr(97))

repr：查看数据类型
# print(repr(1))
# print(repr('1'))
# print('name : %r'%('金老板'))  #   %r 打印内容跟括号里完全一致

enumerate：
# l = ['笔记本','phone','apple','banana']
# for i,j in enumerate(l,1):
#     print(i,j)

# l = ['笔记本','phone','apple','banana']
# for i in enumerate(l,1):
#     print(i[0],i[1])

all:接收一个可迭代对象，对象中有一个是False，整体的结果就是False
# print(all([1,2,3,4,0]))
# print(all([1,2,3,4]))
# print(all([1,2,3,None]))
# print(all([1,2,3,'']))

any；接收一个可迭代对象，对象中有一个是True，整体的结果就是True
# print(any([True,None,False]))
# print(any([False,None,False]))

拉链函数：
zip：
# print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))


filter：过滤函数，就是有一个可迭代对象，想要一个新的内容集，是从原可迭代对象中筛选出来的，#新内容少于等于原内容的时候，才能用到filter
# def is_odd(x):
#     if x>10:
#         return True
# ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
# print(list(ret))

# def is_odd(x):
#     if x%2 == 0:
#         return True
# ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
# print(list(ret))

# def func(x):
#     return x and x.strip() 
#去掉所有的空内容和字符串中的空格
# l = ['test', None, '', 'str', '  ', 'END']
# ret = filter(func,l)
# print(list(ret))

map：
# ret = map(abs,[-1,-5,6,-7])   #abs(-1) = 1   abs(-5) = 5
# print(list(ret)

面试真题:
#有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理
# def func(x):
#     return x*x
# ret = map(func,[1,2,3,4,5,6,7,8])
# print(list(ret))


ilter和map
#参数很相近：都是一个函数名+可迭代对象
#且返回值页很相近：都是返回迭代器
#区别
#filter是做筛选的，结果还是原来就在可迭代对象中的项
#map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项

#sort 是直接修改原列表的顺序，节省内存
#sorted 是生成一个新列表，不改变原来的列表
#key = func  #key参数，接收一个函数名
# print(sorted([-5,3,-4,2,-1],reverse=True))
# print(sorted([-5,3,-4,2,-1],key=abs))

# l2 = ['ajkhs',(1,2),'a',[1,2,3,4]]
# print(sorted(l2,key=len,reverse=True))


ascii：只要是ascii码中的内容，就打印出来，不是就转成

# print(ascii('a'))
# print(ascii(1))