python中的关键字---3（内置函数）

内置函数

# 1 range(起始位置,终止位置,步长)
    # range(终止位置)
    # range(起始,终止位置)
    # range(起始,终止,步长)
    # range(5)   [0,4]  [0,5)
    # range(1,5) [1,4]  [1,5)
    # range(1,10,2)  [1,3,5,7,9]
    # range(0,10,2)  [0,2,4,6,8]

# 2 next(迭代器) 是内置函数
    # __next__  是迭代器的方法
    # g.__next__() 带双下划线的魔术方法一般情况下不直接用
    # next(g)    之前所有的__next__都应该替换成next(g)
    # *带双下划线的所有的方法都可能和内置的函数有千丝万缕的联系

# 3 iter(可迭代的)
    # __iter__
    # 迭代器 = 可迭代的.__iter__()
    # 迭代器 = iter(可迭代的)

# 其他
# 4 open('文件名') 跟着操作系统走的
    # 打开模式 默认是r
    # 编码 默认是 操作系统的默认编码

    # 打开模式 : r w a rb wb ab
    # 编码 : utf-8(100%)
    #         gbk

# 5 input('字符串数据类型的参数,提醒用户你要输入的内容')
    # python2
        # input() 还原你输入的值的数据类型
        # raw_input = py3.input
    # python3
        # input() 输入的所有内容都是字符串类型
        # 阻塞: 等待某件事情发生,如果不发生一直等着
    # input的返回值就是用户输入的内容
        # 输入的内容 = input('提示')

# 6 print(要打印的内容1,要打印的内容2,要打印的内容3,sep = '分隔符',end = '结束符')
    # print(123)
    # print('abc')
    # print(123,'abc')
    # print(123,'abc','aaa',sep = '|')
    # print(123,'abc','aaa',end = '@')
    # print(123,'abc','aaa',end = '@')
    # print(123,'abc')
    # f = open('file','w')
    # print(123,'abc',file=f)   # print的本质 就是写文件 这个文件是pycharm的屏幕
    # f.close()
    # sep=' ' seperator

# import time   # 导入别人写好的代码
# def func():
#     for i in range(0,101,2):
#          time.sleep(0.1)   # 每一次在这个地方阻塞0.1,0.1秒结束就结束阻塞
#          char_num = i//2
#          if i == 100:
#             per_str = '
%s%% : %s
' % (i, '*' * char_num)
#          else:
#              per_str = '
%s%% : %s' % (i, '*' * char_num)
#          print(per_str,end = '')
# func()
# print('下载完成')

    # 解释过程:
    # per_str = '
%s%% : %s' % (10, '*' * 10)
    # print(per_str,)
    # time.sleep(1)
    # per_str = '
%s%% : %s' % (20, '*' * 20)
    # print(per_str,end='')

# 7 hash函数
    # 哈希 可哈希(不可变数据类型) 不可哈希(可变数据类型)
    # 哈希是一个算法,导致了字典的快速寻址
    # 'asjgkgfk'  复杂的算法 得到一个数字
    # () --> 数字
    # 数字 --> 数字
    # 所有的数据要想得到不变的hash值,必须是一个不可变的数据类型

# dir 函数 : 特殊的需求 / 研究或者了解一个新的数据类型 / 面向对象之后会介绍新的数据类型
# print(dir(__builtins__)) # 内置的名字
'''
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 
'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError',
 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 
 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 
 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 
 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 
 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError',
  'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 
  'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 
  'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 
  'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 
  'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', 
  '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__',
   'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 
   'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 
   'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 
   'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 
   'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 
   'range', 'repr', 'reversed', 'round', 'set', 'setattr','slice', 'sorted', 'staticmethod', 'str', 'sum', 
   'super', 'tuple', 'type', 'vars', 'zip']'''

# print(dir(123))

# 8 eval() 可以将字符串数据类型的python代码执行,通过拼接字符串的方式来执行不同的代码--简化代码
    # evalexec这个函数 不能直接操作文件当中读进来的 网络上传进来 用户输入的
# eval('print(1+2+3+4)') # 有返回值
# ret = eval('1+2/3*4')
# print(ret)

# 字符串 -> 其他数据类型的转换
# f = open('userinfo')
# content = f.read()
# print(content,type(content))
# ret = eval(content)
# print(ret,type(ret))
# print(ret[0])

# 员工信息表
# def get_info(f):
#     if eval('33 %s 20'%f):
#         print('是符合条件的行')
#
# if '>':
#     get_info('>')
# if '<' :
#     get_info('<')

# 9 exec()
# exec('print(1+2+3+4)')  # 没有返回值
# ret = exec('1+2/3*4')
# print(ret)
# exec('for i in range(200):print(i)')

# 10 compile  能够节省时间工具
# 先编译 python -编译-> 字节码(bytes) -解释-> 机器码 0101010100101
# 先整体编译
# code1 = 'for i in range(0,10): print (i)'   # 这是一句代码 字符串
#
# compile1 = compile(code1,'','exec')  # 预编译 python-> 字节码
# exec (compile1)  # 解释
# exec (compile1)
# exec (compile1)
# exec (compile1)
# exec (compile1)
#
# exec(code1)  # 编译+解释
# exec(code1)
# exec(code1)
# exec(code1)
# exec(code1)

# code3 = 'name = input("please input your name:")'
# compile3 = compile(code3,'','single')
# exec(compile3)
# print(name)

# 11 help() 帮助你了解python的
    # 方式一
    # 输入help() 进入帮助页面,输入数据类型,帮助我们打印具体的帮助信息
    # '123'.startswith()
    # 输入q退出帮助

    # 方式二
    # print(help(str))
    # print(help('abc'))

# 12 callable() 判断某一个变量是否可调用
# def call(arg):
#     if callable(arg):
#         arg()
#     else:
#         print('参数不符合规定')
#
#
# def func():
#     print('in func')
#     return 1
#
# func2 = 1234
# call(func)
# call(func2)

# print(callable(func))
# print(callable(func2))

# 1. locals  本地作用域/局部作用域 会随着位置的改变而改变
# 2. globals 全局作用域           永远不变 永远是全局

# a = 1
# b = 2
# print(locals())
# print(globals())
# def func():
#     c = 3
#     d = 4
#     print(locals())
#     print('-->',globals())
#
# def func2():
#     l1 = []
#     d1 = {}
#     print(locals())
#     print('-->',globals())   # 无论在哪里打印 得到的都是全局作用域中的名字
#
# func()
# func2()

# boolintfloatcomplex
# 3.complex : 复数
# 实数 (有理数和无理数) :世界上存在的数
# 虚数 : j
# 某一个数的平方是-1 ,那么这个数就是一个虚数的基础单位 j
# 复数 = 实数+虚数 = a+bj
# 选择题 :(对你的数学有要求的公司都会考)
    # 复数不能比较大小
    # 共轭复数 : a+bj 和 a-bj是一对共轭复数
    # a+bj 和 a+bJ都是复数

# c = 1+2J
# print(type(c))

# 4.bin oct hex
# a = 19
# # 0 1 2 3 4 5 6 7 8 9 A B C D E F 10
# # 256 十进制
# print(bin(a))  # 0b100000000 0b代表二进制,100000000 = 256
# print(oct(a))    # 0o400 0o代表八进制,400 = 256
# print(hex(a))

# 5 abs 求绝对值,正数的绝对值是正数,负数的绝对值也是正数
# print(abs(5))
# print(abs(-5))

# 6. divmod 商余函数
# print(divmod(10,3))
# print(divmod(7,4))
# print(divmod(8,3))
# 翻页功能
# 2520   25条  多少页 101 100+1 20
# 35条数据 在第几页的第几行显示  : 2 10行

# 7. round(小数,保留几位小数)  小数精确
# ret = round(2.3258358)
# print(ret)
# ret = round(2.3253358,2)
# print(ret)
# ret = round(2.3253358,3)
# print(ret)
# ret = round(0.5)
# print(ret)
# 2.x(完全的四舍五入)和3.x(更精准的计算方式)不同

# 8.pow(x,y,z=1) 幂运算/幂余运算 x的y次方%z
# print(pow(2,3))
# print(pow(3,2))
# print(pow(5,3,2))
# print(pow(4,2,2))
# print(pow(4,3,2))

# 9.sum(可迭代的数字集,start),start从哪个数开始加
# print(sum((1,2,3,4)))
# print(sum([1,2,3,4]))
# print(sum(range(10)))
# print(sum((i**2 for i in range(5))))
# print(sum((1,2,3,4)))
# print(sum((1,2,3,4),10))
# print(sum((1,2,3,4),30))

# 10.min/max(iterable/*args,key) key是一个函数的内存地址,key做的事情就是根据你对每一项数据大小的需求来排序
# print(min(1,2,3))
# print(min((1,2,3)))
# print(min((1,2,3),(4,5,6)))
# print(min((7,2,3),(4,5,6)))

# def func(n):   # n = 2,3,4,7
#     return n%6 # 2,3,4,1
#
# ret = min(2,3,4,7,key = func)
# print(ret)

# l = [{'name1':10},{'name2':500}]
# max函数 找到股价最高的那个字典,
# def func(dic):             #  {'name1':10}
#     for k in dic:
#         return dic[k]      # 10
# func(dic)
# def max(iter,key = None):   # 内置的max   iter = [{'name1':10},{'name2':500}] , key = func
#     ret = 0                 # ret = 0
#     max_value = 0           # max_value = 0
#     if key:                 # key = func
#         for i in iter:      # iter = [{'name1':10},{'name2':500}]
#             print(key(i),max_value)  # i = {'name1':500}  key(i) = func({'name1':500}) = 500,max_value = 10
#             if key(i) > max_value:   # 500>10
#                 max_value = key(i)   # max_value = 500
#                 ret = i              # ret ={'name1':500}
#     return ret

# def func(dic):
#     for k in dic:
#         return dic[k]
# print(max(l,key = func))
# print(min(l,key = func))
# l中的每一项都会作为参数传给func
# max和min的求值会根据func的返回值来排序

# l = [(7,2,3),(4,5,6),(-1,20,5)]
# # 根据每一个元组的和来计算max或者min
# print(max(l,key = sum))   # sum((7,2,3))

# 11. reversed(list/tuple)  返回一个迭代器,为了节省内存
# l = [1,2]
# l.reverse()
# print(l)

# ret = reversed([1,2,3])  # iterator
# print(ret)

# reverse是在原基础上修改 : 2000项的列表 不会产生额外的内存占用
# reversed不修改原基础 : 不直接返回列表而返回迭代器,为了不占用更多的内存

# 12. slice  切片
# l = [1,2,3,4,5,]
# print(l[1:4])
#
# ret = slice(1,4)   # [1:4]
# print(l[ret])

# 13. format
# print(format('test', '<20'),'alex')
# print(format('test', '>20'),'alex')
# print(format('test', '^20'),'alex')

# 14. bytes 字节
# str --> bytes
# print('abc'.encode('utf-8'))
# print('你好'.encode('utf-8'))
# bytes --> str
# b = b'xe4xbdxa0xe5xa5xbd'
# print(b.decode('utf-8'))

# 网络上传输的数据 : bytes
# 文件的存储 : wb 写字节 rb 读字节 图片视频都是字节
# 网络 + 文件 : wb / rb

# 15.bytearray 把一个字符串编程一个字节数组,较长的字符串的修改节省内存,修改行为必须依靠编码
# ret = bytearray('abc'*30,encoding='utf-8')  # 字节数组
# print(ret)
# ret[0] = 102   # asc码  65A 97abcdef 你好 您好
# print(ret)

# 16.memoryview 
# l = [1,2,3]
# l[:2]  # 复制

# ret = memoryview(bytes('hello,eva',encoding='utf-8'))
# print(ret[:10])

# 17.ord/chr  字符和编码之间的转换
# print(ord('a'))
# print(chr(97))

# 18.repr() 打印的时候输出这个变量的数据类型
# a = 1
# b = '1'
# print(repr(a),repr(b))

# 19. len 计算长度

# 1. enumerate 枚举函数

# for i in enumerate(['a','b','c'],5):
#     print(i)

# goods_lst= [
#     {'name':'电脑','price':1999},
#     {'name':'鼠标','price':20},
#     {'name':'美女','price':20},
# ]
# for good in goods_lst:
#     print(goods_lst.index(good)+1,good['name'],good['price'])
#
# for good in goods_lst:
#     print(good)

# a,b = (1,2)
# index,dic = (1, {'name': '电脑', 'price': 1999})  # 解构

# for good in enumerate(goods_lst,1):
#     # print(good)
#     index = good[0]
#     dic = good[1]
#     name = dic['name']
#     price = dic['price']
#     print(index,name,price)

# for index,dic in enumerate(goods_lst,1):
#         print(index,dic['name'],dic['price'])

# 2. all 参数iterable 只要有一个为假返回False
# print(all((1,2,3,True)))
# print(all((1,2,3,0,True)))
# print(all((1,2,3,True,[])))
# print(all((1,2,3,True,'')))

# 3. any 参数iterable 只要有一个为真返回True
# print(any((1,2,3,True)))
# print(any((1,2,3,0,True)))
# print(any((1,2,3,True,[])))
# print(any(({},False,0,[],'')))

# 4.zip 拉链函数 返回迭代器-节省内存
# a = (1,2,3,4)
# b = ('a','b','c')
# c = ['111','222']
# d = {'k1':'v1','k2':'v2'}
# ret = zip(a,b,c,d)
# print(ret)
# for i in ret:
#     print(i)

# 5. filter 筛选
# ret = filter(None,[1,2,3,0,False])  # 只保留真的
# print(ret)
# for i in ret:
#     print(i)

# def func(i):
#     if i % 2 != 0:
#         return True
# l = [1, 4, 6, 7, 9, 12, 17]
# for i in filter(func,l):  # 迭代l,每一个元素作为参数传给func,如果func的返回值为True,那么l中的这个元素就保留
#     print(i)

# def func(i):
#     if type(i) is not dict:
#         return True

# def func(i):
#     return type(i) is not dict
#
# l = ['sjkdhf',[1,2,3],{},()]  # 去掉列表中的字典,用filter
# ret = filter(func,l)
# print(list(ret))

# filter 就像 带着if条件的列表推导式
# l = ['sjkdhf',[1,2,3],{},()]
# print([i for i in l if type(i) is not dict])

# 6.map 一个迭代器中的每一个元素都需要去做同一个操作并返回一个结果组成一个新列表的时候map来处理
# def func(i):
#     return i*'*'
#
# ret = map(func,[1,2,3])
# print(ret)
# for i in ret:
#     print(i)

# range(10)内部的每一个值的平方组成的新列表
# def func(num):
#     return num**2
# ret = map(func,range(10))
# print(list(ret))



# 7.sorted() 排序 根据key对应的函数的返回值的大小来排序的
# 由于必须要知道后面的值是谁 才能排出顺序 所以结果就是排序后的结果而不是可迭代的
# l = [-3,1,2]
# l.sort()
# print(l)
# def func(n):
#     return abs(n)
# l.sort(key = func)
# print(l)

# l = [1,-3,2]
# new_l = sorted(l)   # 在不改变原列表的情况下 生成一个新列表
# print(l)
# print(new_l)
# def func(n):
#     return abs(n)
# ret = sorted(l,key = func)
# print(ret)

# l = [{'name':'电脑','price':1999},{'name':'鼠标','price':2000}]
# 按照每一个字典中商品的价格从高到低排列
# def func(dic):
#     return dic['price']
# l.sort(key=func,reverse=True)
# print(l)

# new_l = sorted(l,key = func,reverse= True)
# print(new_l)

# 面试重点
# filter(func,iterable) map(func,iterable) sorted(iterable,key) max(iterable,key) min(iterable,key) zip
# 常用的
# range enumerate print input open 基础数据类型 bytes

---

# 必会 : min max filter map sorted zip
# 常用的 : abs range print input open len sum dir eval divmod enumerate
# 基础数据类型 : list dict str int bytes set(去重,关系运算)