内置函数

# 作用域相关
# print(locals())         # 返回本地作用域中的所有名字
# print(globals())        # 返回全局作用域中的所有名字
# 迭代器/生成器相关##############################################

# 迭代器.__next__()    取值
# next(迭代器)
# def next(迭代器):
#     迭代器.__next__()

# 迭代器 = iter(可迭代对象)
# 迭代器 = 可迭代对象.__iter__()
# def iter(可迭代对象):
#     可迭代对象.__iter__()
##################################################################
# range()
# range(10)
# range(1,11)
# range(1,11,2)
# print(‘__next__‘ in dir((range(1,11,2)).__iter__()))

# dir 查看一个变量拥有的方法
# print(dir([]))
# print(dir(()))
# help      返回和变量相关的方法名和用法，比dir更加详细
# help(str)


# callable() （产看一个名字能否被调用）判断变量是一个值还是函数，是值返回False，是函数名返回True
# print(callable(print))


# import time   导入模块
# time = __import__(‘time‘)
# print(time.time())


# open()  文件操作
# f = open(‘f‘,‘r+‘)
# print(f.writable())     # 能不能写
# print(f.readable())     # 能不能读


# 内存相关########################################################
# id()  一个变量的内存地址
# a = 1
# print(id(a))
# hash()
# 对于相同可hash数据的hash值在依次程序的执行过程中总是不变的
    # 字典的寻址方式
# print(hash(12345))
# print(hash(‘sflhadfasdfkaf‘))
# print(hash((‘1‘,‘aaa‘)))
# print(hash([]))
############################################################3
# input() 输入方法
# ret = input(‘输入里的提示信息‘)


# print()
# print(‘我爱看小说‘,end=‘‘)       # 指定输出的结束符
# print(‘我爱看小说‘)
#
# print(1,2,3,4,5,sep=‘|‘)        # 指定输出多个符的分割符
#
# f = open(‘f‘,‘w‘,encoding=‘utf-8‘)
# print(‘aaa‘,file=f)             # 制定输出到文件
# f.close()


# import time
# for i in range(0,101,2):
#     time.sleep(0.1)
#     char_num = i//2
#     per_str = ‘\r{}%:{}\n‘.format(i,‘*‘*char_num) if i== 100 else ‘\r{}%:{}‘.format(i,‘*‘*char_num)
#     print(per_str,end=‘‘)

# 字符串类型的执行########################################################

# exec(‘print(123)‘)
# eval(‘print(123)‘)
# print(exec(‘1+2+3+4‘))      # 无返回值
# print(eval(‘1+2+3+4‘))      # 有返回值
# exec 和 eval 都可以执行字符串类型的代码
# eval有返回值  —— 适合处理：有结果的简单计算
# exec无返回值  —— 适合处理：简单流程控制
# eval只能用在你明确知道你要执行的代码是什么
# exec示例
# code = ‘‘‘
# for i in range(10):
#     print(i*‘*‘)
# ‘‘‘
# exec(code)

# compile 用法        同一段代码多次调用（一次编译出来）

# code = ‘‘‘
# for i in range(10):
#     print(i)
# ‘‘‘
# compile1= compile(code,‘‘,‘exec‘)
# print(exec(compile1))

# code = ‘1+2+3‘
# compile2 = compile(code,‘‘,‘eval‘)
# print(eval(compile2))

# code = ‘name = input(">>>")‘
# compile3 = compile(code,‘‘,‘single‘)
# exec(compile3)
# print(name)
##########################################################################

# 数据类型相关###########################################################

# 复数——complex
# 实数：
    # 有理数，
    # 无理数
# 虚数：虚无缥缈的数
# 5+12j == 复合的数 == 复数

# 浮点数 (有限循环小数，无限循环小数)== 小数？：有限循环小数，无限循环小数，无限不循环小数
# 浮点数
    # 354.123 = 3.54123*10**2 == 35.4123*10
# f = 1.7819387410348721348   # 当小数位数足够长的时候就不准了（因为二进制转换）
# print(f)

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

# abs
# print(abs(-5))      # 绝对值
# print(abs(5))      # 绝对值

# divmod    除余
# print(divmod(7,2))  #div除法，mod取余
# print(divmod(9,5))

#round  做精确值
# print(round(1.222445,2))

# pow   幂运算
# print(pow(2,3))       # 2**3
# print(pow(2,3,3))   # 幂运算之后取余
# print(pow(3,2,2))

# sum                   接收可迭代对象
# print(sum([1,2,3]))
# print(sum([1,2,3],10))

# min
# print(min([1,2,3,4]))
# print(min(1,2,3,4))
# print(min(1,2,3,-4))
# print(min(1,2,3,-4,key=abs))    # 都按照绝对值挑选最大值

# max
# print(max([1,2,3,4]))
# print(max(1,2,3,4))
# print(max(1,2,3,-4))
# print(max(1,2,3,-4,key=abs))    # 都按照绝对值挑选最大值

# list tuple  数据强制类型转换使用

# reversed()    反转
# l = [1,2,3]
# l.reverse()
# print(l)
# l2 = reversed(l)    # 保留原列表，返回一个反序的迭代器
# print(l2)

# slice()    生成一个切片规则
# l = [1,2,3,4,5]
# s = slice(1,5,2)
# print(l[s])
# print(l[1:5:2])

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

# bytes   转换成bytes类型
# 我拿到的是gbk编码文件，打算转成utf-8编码
# print(bytes(‘你好‘,encoding=‘gbk‘))           # unicode转换成gbk
# print(bytes(‘你好‘,encoding=‘utf-8‘))         # unicode转换成utf-8
# print(bytes(‘你好‘,encoding=‘utf-8‘).decode(‘utf-8‘))
# print(bytes(‘你好‘,encoding=‘gbk‘).decode(‘gbk‘))

# 网络编程  只能传二进制
# 照片和视频也是以二进制存储
# html网页爬取到的也是bytes编码

# bytearray  一个列表，列表里每个元素都是一个编码
# b_array =bytearray(‘你好‘,encoding=‘utf-8‘)   # bytes
# print(b_array)
# print(b_array[0])

# memoryview    转成bytes类型再切片
# 切片——字节类型  不占内存，只是切出来给你看看
# 字节——转换成字符串就又占空间了
# l = ‘asadfkjasdklfjakfjfakjff‘
# l2 = l[:10]

# ord       把字符串转化成对应数字
# print(ord(‘a‘))
# print(ord(‘1‘))

# chr
# print(chr(97))

# ascii()   在ascii码里原封不动打印，不在打印成某格式
# print(ascii(‘好‘))
# print(ascii(‘1‘))

# reper() 让一个变量原封不动的输出，比如字符串带引号，数字直接数字
# name = ‘egg‘
# print(‘你好%r‘ % name)
# print(repr(‘1‘))
# print(repr(1))

#***********************************************************************#
# len enumerate

# all   若可迭代对象中有一个为False，返回False，否则返回True
# print(all([‘a‘,‘‘,123]))
# print(all([‘a‘,123]))
# print(all([0,123]))

# any       有一个为True ,返回True，否则返回False
# print(any([‘‘,True]))

# zip()         拉链方法,交错着的迭代器,以长度最短方法
# l = [1,2,3]
# l2 = [‘a‘,‘b‘,‘c‘]
# l3 = (‘*‘,‘**‘,[1,2])
# dic = {‘k1‘:1,‘k2‘:2,‘k3‘:3}
# for i in zip(l,l2,l3,dic):
#     print(i)

#*****
# filter(函数名,可迭代对象)  循环可迭代对象,放入函数中,如果函数返回True,那么将可迭代对象中符合条件的值放入迭代器
# def is_odd(x):
#     return type(x) is str
# def is_feikong(x):
#     return x and str(x).strip()
# ret = filter(is_odd,[1,4,‘a‘,‘hello‘,3,5,6,7])    # 返回迭代器,节省内存
# ret1 = filter(is_feikong,[1,4,‘a‘,‘hello‘,3,5,6,7,None,[],‘‘,‘ ‘])    # 返回迭代器,节省内存
# for i in ret1:
#     print(i)
# print(ret)

# from math import sqrt
# def func(num):
#     res = sqrt(num)         # 1.0   1.23333
#     return res % 1 == 0     # 判断是否转成整数
# ret = filter(func,range(1,101))
# for i in ret:
#     print(i)


# map   把可迭代对象的每一个值都执行一次函数,返回执行后的值
# ret = map(abs,[1,-4,5,6,9])
# print(ret)
# for i in ret:
#     print(i)


### filter  执行了filter之后的结果集合 <= 执行之前的个数
    #filter只管筛选,不会改变原来的值
### map     执行前后元素个数不变
    #值可能发生改变

# sortd()
# l = [1,-4,6,5,-10]
# l.sort(key=abs)     # key=函数名   在原列表的基础上进行排序
# print(l)

# print(sorted(l,key=abs,reverse=True))       # 慎用,在列表不大,并且想保留原有列表情况下使用,费内存
# print(l)

# l = [‘abc‘,‘a‘,‘fjasfjasjdfasd‘,[1,2,3,4],(1,2,3,5,6,7)]
# print(sorted(l,key=len))




# 某个方法属于某个数据类型的变量就用.调用
# 如果某个方法不依赖于任何数据类型，就直接调用——内置函数  和  自定义函数

# 数据类型：int bool ...tuple dict
# 数据结构：dict list tuple set str