内置函数

Posted 2021-01-01 ming-yuan

globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
input() 输入
print() 输出    # file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件，sep:   打印多个值之间的分隔符，默认为空格 end:   每一次打印的结尾，默认为换行符 ，flush: 立即把内容输出到流文件，不作缓存
type(o) 返回变量o的数据类型
id(o) o是参数，返回一个变量的内存地址
hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。*每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
open()  打开一个文件，返回一个文件操作符(文件句柄)
__import__导入一个模块    #os = __import__(‘os‘)
help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出
callable(o)，o是参数，看这个变量是不是可调用。
dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
eval() 将字符串类型的代码执行并返回结果
exec()将自字符串类型的代码执行
compile  # compile1 = compile(code1,‘‘,‘exec‘)    compile2 = compile(code2,‘‘,‘eval‘)    compile3 = compile(code3,‘‘,‘single‘)    #将字符串类型的代码编译。代码对象能够通过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‘。
数字——数据类型相关：bool，int，float，complex
数字——进制转换相关：bin，oct，hex
数字——数学运算：abs，divmod，min，max，sum，round，pow
序列——列表和元组相关的：list和tuple
序列——字符串相关的：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr
序列：reversed，slice
数据集合——字典和集合：dict，set，frozenset
数据集合：len，sorted，enumerate，all，any，zip，filter，map
filter()    # filter(lambda i:i%2==0, [1, 4, 6, 7, 9, 12, 17])    #函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
map()        # map(func,[])函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
sort()
sorted()    # l2 = sorted(l1,key=abs)    # iterable：是可迭代类型;key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，有默认值。返回值：有序列表


locals ：    函数会以字典的类型返回当前位置的全部局部变量。    # print(locals())
globals：    函数以字典的类型返回全部全局变量。                # print(globals())
eval：        执行字符串类型的代码，并返回最终结果。            # eval("n + 4")  # 85
exec:        执行字符串类型的代码。                            # s = ‘‘‘for i in [1,2,3]:print(i)‘‘‘    exec(s)
compile:    将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
    # >>> #流程语句使用exec    #简单求值表达式用eval    >>> #交互语句用single
    # >>> code3 = ‘name = input("please input your name:")‘
    # >>> compile3 = compile(code3,‘‘,‘single‘)
    # 有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile。
input:        函数接受一个标准输入数据，返回为 string 类型。    # name = input(‘>>>name is ‘)
print:        打印输出。    
    # print(value, ..., sep=‘ ‘, end=‘
‘, file=sys.stdout, flush=False)
    # file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    # sep:   打印多个值之间的分隔符，默认为空格        # print(111,222,333,sep=‘*‘)    # 111*222*333
    # end:   每一次打印的结尾，默认为换行符            # print(111,end=‘‘)    print(222)    # 两行的结果 111222
    # flush: 立即把内容输出到流文件，不作缓存        # print(‘写入文件‘,file=f,flush=True)
hash：        获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。        # print(hash(‘123‘))    # -2996001552409009098
id:            用于获取对象的内存地址。                                        # print(id(‘abc‘))        # 2033192957072
open：        函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
__import__：函数用于动态加载类和函数 。
help：        函数用于查看函数或模块用途的详细说明。                # print(help(list))
callable：    函数用于检查一个对象是否是可调用的。                # callable("runoob")    # False
dir：        # >>> dir([ ])    # 查看列表的方法                  # 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
range：        函数可创建一个整数对象，一般用在 for 循环中。        # for i in range(10)
next：        内部实际使用了__next__方法，返回迭代器的下一个项目。# it = iter([1, 2, 3, 4, 5])    # next(it)
iter：        函数用来生成迭代器（将一个可迭代对象，生成迭代器）。# it = iter([1, 2, 3, 4, 5])
bool ：        用于将给定参数转换为布尔类型。                        #数值0、空序列等值为False  # bool(‘‘) False    bool(3) True
int：        函数用于将一个字符串或数字转换为整型。                # print(int(‘12‘))  # 12
float：        函数用于将整数和字符串转换成浮点数。                # print(float(‘4‘))    # 4.0
complex：    函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
bin：        将十进制转换成二进制并返回。                        # print(bin(10),type(bin(10)))  # 0b1010 <class ‘str‘>
oct：        将十进制转化成八进制字符串并返回。                    # print(oct(10),type(oct(10)))  # 0o12 <class ‘str‘>
hex：        将十进制转化成十六进制字符串并返回。                # print(hex(10),type(hex(10)))  # 0xa <class ‘str‘>
abs：        函数返回数字的绝对值。                                # print(abs(-5))  # 5
divmod：    计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。# print(divmod(7,2))  # (3, 1)
round：        保留浮点数的小数位数，默认保留整数。　　　　        # print(round(3.32567,3))  # 3.326
pow：        求x**y次幂。（三个参数为x**y的结果对z取余）            # print(pow(2,3))  # 两个参数为2**3次幂    # print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。
sum：        对可迭代对象(元素是数字)进行求和计算（可设置初始值）。
    # print(sum([1,2,3]))    # 6        # print(sum((1,2,3),100))    # 106
min：        返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。　
    # print(min([1,2,3]))    # 返回此序列最小值        # min([1,2,-5,],key=abs)    # 按照绝对值的大小，返回此序列最小值
max：        返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。　
    # print(max([1,2,3]))    # 返回此序列最大值        # max([1,2,-5,],key=abs)    # 按照绝对值的大小，返回此序列最大值
list：        将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。    # l = list({1,2,3})    
tuple：        将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。    # tu = tuple([1,2,3])
reversed：    将一个序列翻转，并返回此翻转序列的迭代器。                            # reversed([‘a‘,2,3,‘c‘,4,2])
slice：        构造一个切片对象，用于列表的切片。                                    # sli_obj = slice(0,7,2)    print(li[sli_obj])
str：        将数据转化成字符串。
format:        与具体数据相关，用于计算各种小数，精算等。                            # print(format(‘test‘, ‘<20‘)) # str,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐        # 整形数值可以提供的参数有 ‘b‘ ‘c‘ ‘d‘ ‘o‘ ‘x‘ ‘X‘ ‘n‘ None        # 浮点数可以提供的参数有 ‘e‘ ‘E‘ ‘f‘ ‘F‘ ‘g‘ ‘G‘ ‘n‘ ‘%‘ None
bytes：        用于不同编码之间的转化。            # bytes(‘你好‘,encoding=‘utf-8‘)        # ‘你好‘.encode(‘utf-8‘)    # ‘你好‘.decode(‘utf-8‘)
bytearry：    返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。    # ret = bytearray(‘alex‘,encoding=‘utf-8‘)    ret[0] = 65
ord:        输入字符找该字符编码的位置                # print(ord(‘a‘))
chr:        输入位置数字找出其对应的字符            # print(chr(97))    
ascii:        是ascii码中的返回该值，不是就返回/u...    # print(ascii(‘a‘))
repr:        返回一个对象的string形式（原形毕露）。    # print(‘我叫%r‘%name)    # %r 原封不动的写出来    # print(repr(‘{"name":"alex"}‘))
dict：        创建一个字典。
set：        创建一个集合。
frozenset：    返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
len:        返回一个对象中元素的个数。
sorted：    对所有可迭代的对象进行排序操作。
    # sort        在原列表的基础上进行排序           # l.sort(key = abs)
    # 生成了一个新列表 不改变原列表 占内存        # sorted(L, key=lambda x:x[1],reverse=True) # 利用key# 按降序
enumerate:    枚举，传入可迭代对象，返回一个枚举对象。# for i in enumerate([1,2,3]):print(i)    # (0, 1) (1, 2) (2, 3)
all：        可迭代对象中，全都是True才是True        # print(all([1,2,True,0]))
any：        可迭代对象中，有一个True 就是True        # print(any([1,‘‘,0]))
zip：        函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
    # l1 = [1,2,3,]        # l2 = [‘a‘,‘b‘,‘c‘,5]        #l3 = (‘*‘,‘**‘,(1,2,3))    for i in zip(l1,l2,l3):print(i)        #最后一个值为 (3, ‘c‘, (1, 2, 3))
filter：    过滤。#filter只管筛选，不会改变原来的值    # ret = filter(func,[1,2,3,4,5,6,7])                    # ret = filter(lambda dic:True if dic[‘price‘] > 100 else False,portfolio)
map:        会根据提供的函数对指定序列做映射。        # map(lambda x, y: x + y, [1, 3,], [2, 4, 6, 8, 10])    # map(func, *iterables) # 提供了两个列表，对相同位置的列表数据进行相加，返回一个可迭代对象
函数名 = lambda 参数 ：返回值
    # 匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。通常与含有key的内置函数搭配使用：#  res = filter(lambda x:x>10,[5,8,11,9,15])    # for i in res:print(i)
isinstance：    判断对象是否是类或者类型元组中任意类元素的实例        # >>> isinstance(1,int)
issubclass：    判断类是否是另外一个类或者类型元组中任意类元素的子类        # >>> issubclass(bool,int)
hasattr：        检查对象是否含有属性        # >>> class Student:#self.name = name    # >>> s = Student(‘Aim‘)    # >>> hasattr(s,‘name‘) #a含有name属性
getattr：        获取对象的属性值            # getattr(s,‘name‘) #存在属性name        # >>> getattr(s,‘age‘,6)     # 不存在属性age，但提供了默认值，返回默认值
setattr：        设置对象的属性值            # >>> setattr(a,‘name‘,‘Bob‘)
delattr：        删除对象的属性                # >>> delattr(a,‘name‘)
callable：        检测对象是否可被调用        # callable(b) #实例b是可调用对象    # b()
classmethod：    标示方法为类方法的装饰器    # >>> class C:    @classmethod    def f(cls,arg1):
staticmethod：    标示方法为静态方法的装饰器    # >>> class Student(object):        @staticmethod    def sayHello(lang):
property        内置装饰器函数 只在面向对象中使用