Python学习日记(十一) 内置函数

什么是内置函数?

就是Python中已经写好了的函数,可以直接使用

内置函数图表:

以3.6.2为例

内置函数分类:

一、反射相关

1.hasattr()

2.getattr()

3.setattr()

4.delattr()

二、基础数据类型相关

1.和数字相关

(1)数据类型

　　a.bool()

　　　　把一个值转换成布尔值

li = ['',[],1,12,0]
for i in li:
    print(bool(i))
# False
# False
# True
# True
# False

　　b.int()

　　　　把一个值转换成整型

num = input('Please input a number:')
print(10 + int(num))
# Please input a number:20
#

　　c.float()

　　　　把一个整数或数字字符串转换成带小数点的数

print(float('123.5'),type(float('123.5')))      #123.5 <class 'float'>
print(float(-50.2),type(float(-50.2)))          #-50.2 <class 'float'>

　　d.complex()

　　　　返回一个复数

a = 1 + 2j
b = 2
print(complex(a))   #(1+2j)
print(complex(b))   #(2+0j)
print(complex(2,3)) #(2+3j)

(2)进制转换

　　a.bin()

　　　　将一个数以二进制字符串的方式表示

print(bin(2))   #0b10
print(bin(10))  #0b1010

　　b.oct()

　　　　把一个数转换成八进制的字符串

print(oct(20),type(oct(20)))    #0o24 <class 'str'>
print(oct(8),type(oct(8)))      #0o10 <class 'str'>

　　c.hex()

　　　　把一个数字转换成十六进制的字符串

print(hex(10),type(hex(10)))    #0xa <class 'str'>
print(hex(28),type(hex(28)))    #0x1c <class 'str'>

(3)数学运算

　　a.abs()

　　　　对一个数的值取绝对值,结果不改变原值

a = -5
print(abs(a))   #

　　b.divmod()

　　　　返回一个以商和余数组成的元祖

print(divmod(10,5),type(divmod(10,5)))      #(2, 0) <class 'tuple'>
print(divmod(4,9))                          #(0, 4)

　　c.round()

　　　　将浮点值四舍五入

import math
Pi = math.pi
print(round(Pi,4))      #3.1416

　　d.pow()

　　　　一般情况下给函数两个数可以计算次方,若给定三个数则在幂运算后再取余

print(pow(2,3))     #
print(pow(2,0.5))   #1.4142135623730951
print(pow(3,2,2))   #

　　e.sum()

print(sum([2,2,3,5,6,2,4]))        #
print(sum([2,2,3,5,6,2,4],10))     #34  这里只是先让10进行sum的运算

　　f.min()

print(min(-1,-2,2,3))                    #-2
print(min(-1,-2,2,3,key=abs))            #-1
print(min('aab','aaab','bc',key=len))    #bc

　　g.max()

print(max(-4,-2,2,3))                    #
print(max(-4,-2,2,3,key=abs))            #-4
print(max('aab','aaab','bc',key=len))    #aaab

2.和数据结构相关

(1)序列

　　<1>列表和元祖

　　　　a.list()

　　　　　　将一个元祖或者字符串转化成一个列表

print(list('abcdefg'))  #['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list((1,2,'l')))  #[1, 2, 'l']

　　　　b.tuple()

　　　　　　将一个列表转化为元祖

print(tuple([1,2,3,'h','k']))   #(1, 2, 3, 'h', 'k')

　　<2>相关内置函数

　　　　a.reversed()

　　　　　　函数返回一个反转的迭代器

l = [1,2,3,'h','k',True]
l2 = reversed(l)        #<list_reverseiterator object at 0x0000000001DD5470>
print(l2)               #不改变原列表并返回一个迭代器
for i in l2:
    print(i)
# True
# k
# h
#
#
#

　　　　b.slice()

l = ['a',1,2,3,4,8,'h','k']
sli = slice(2,7,2)      #切片顾头不顾尾
print(l[sli])           #[2, 4, 'h']

　　<3>字符串

　　　　a.str()

　　　　　　将对象转化为适合人阅读的格式

tu = (1,2,'h')
dic = {'k1' : 1,'k2' : 2}
li = [1,2,3,'h']
i = 123
print(str(tu),type(tu))     #(1, 2, 'h') <class 'tuple'>
print(str(dic),type(dic))   #{'k1': 1, 'k2': 2} <class 'dict'>
print(str(li),type(li))     #[1, 2, 3, 'h'] <class 'list'>
print(str(i),type(i))       #123 <class 'int'>

　　　　b.format()

　　　　　　主要用于格式化输出也可以用于数学方面的研究

value = 'ox123'
tu = ('value1','value2','value3')
print('get value->{0}'.format(value))   #get value->ox123
print('{0} {1} {2}'.format(*tu))        #value1 value2 value3

'''数字格式化'''
a = 12.579
print('{:.2f}'.format(a))               #12.58  保留小数点的后两位
print('{:+.2f}'.format(a))              #+12.58 带符号的保留小数点的后两位
print('{:-.2f}'.format(-a))             #-12.58  带符号的保留小数点的后两位
print('{:.0f}'.format(a))               #13     不带小数返回并对结果四舍五入
print('{:.2%}'.format(a/100))           #12.58% 结果以百分比格式输出

b = 1001
print('{:0>8d}'.format(b))              #00001001   数字补0(填充左边宽度为8)
print('{:*>8d}'.format(b))              #****1001   数字补*(填充左边宽度为8)
print('{:*<8d}'.format(b))              #1001****   数字补*(填充右边宽度为8)

c = 10**10
print('{:,}'.format(c))                 #10,000,000,000    结果以逗号的形式分隔
print('{:.2e}'.format(c))               #1.00e+10          结果以指数标准格式输出

d = 7
print('{:>5d}'.format(d))               #    7      向右对齐
print('{:<5d}'.format(d))               #7          向左对齐
print('{:^5d}'.format(d))               #  7        中间对齐

e = 15
print('{:b}'.format(e))                 #1111       返回二进制
print('{:d}'.format(e))                 #15         返回十进制
print('{:o}'.format(e))                 #17         返回八进制
print('{:x}'.format(e))                 #f          返回十六进制
print('{:#x}'.format(e))                #0xf        返回带格式输出的十六进制小写
print('{:#X}'.format(e))                #0XF        返回带格式输出的十六进制大写

　　　　c.bytes()

　　　　　　主要用在网络编程、照片和视频、爬取网页等二进制文件的时候

print(bytes('Python爬虫',encoding='utf-8'))   #b'Python\xe7\x88\xac\xe8\x99\xab'

　　　　d.bytearray()

　　　　　　返回一个bytes数组

b = bytes('Python爬虫',encoding='utf-8')   #b'Python\xe7\x88\xac\xe8\x99\xab'
print(bytearray(b))                        #bytearray(b'Python\xe7\x88\xac\xe8\x99\xab')

　　　　e.memoryview()

　　　　　　在一个缓冲区中查看一个对象,返回值为一个元祖

v = memoryview(bytearray('abcdef','utf-8'))
print(v[2])     #
print(v[-1])    #
print(v[1:5:2]) #<memory at 0x00000000024DE288>
print(v[1:5:2].tobytes())   #b'bd'

　　　　f.ord()

　　　　　　以一个字符作为参数返回一个unicode值或者ascii值,返回值为一个对应的十进制整数

print(ord('a'))     #
print(ord('A'))     #
print(ord('az'))    #TypeError 超过给定长度报错

　　　　g.chr()

　　　　　　以一个十进制或十六进制的整数作为参数,数字范围为0-1114111(16进制为0x10FFFF)，返回值为对应的ASCII字符

print(chr(65))      #A
print(chr(97))      #a
print(chr(0x35))    #

　　　　h.ascii()

　　　　　　返回一个ascii字符,如果找不到这个ascii字符则通过repr()使用\x,\u或\U编码的字符　　　　　　　

print(ascii(10))     #
print(ascii('a'))    #'a'
print(ascii('中'))    #'\u4e2d'

　　　　i.repr()

　　　　　　将对象转化为供解释器读取的形式,返回一个string的格式

name = 'jane'
print('hello %r'%name)  #hello 'jane'
print(repr(''))        #'1'
print(repr(1))          #

(2)数据集合

　　<1>字典

　　　　a.dict()　　　　　　

'''
    dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
'''

mapping为元素容器、iterable为可迭代的对象、**kwargs为关键字

这里的主要语法:

'''映射函数创建字典'''
dict1 = dict(zip(['key1','key2','key3','key4'],[1,2,3]))    #{'key1': 1, 'key2': 2, 'key3': 3}
print(dict1)
'''关键字创建字典'''
dict2 = dict(a = 1,b = 'b',c = None)
print(dict2)        #{'a': 1, 'b': 'b', 'c': None}
'''可迭代创建字典'''
dict3 = dict([('a',1),('b',None),('c','')])
print(dict3)        #{'a': 1, 'b': None, 'c': ''}

　　<1>集合

　　　　a.set()

　　　　　　创建一个无序不重复的元素集合,这里的参数必须是可迭代对象

set1 = set([1,2,2,3,'a','a','b'])
print(set1) #{1, 2, 3, 'a', 'b'}

　　　　b.frozenset()

　　　　　　返回一个冻结的集合,之后不能进行添加或修改任何元素

set1 = {1,2,3,'a'}
set1 = frozenset(set1)
print(set1,type(set1))  #frozenset({1, 2, 3, 'a'}) <class 'frozenset'>
set1[0] = 'b'           #TypeError: 'frozenset' object does not support item assignment

(3)相关内置函数

　　a.len()

　　　　返回该对象的长度

print(len(''))           #
print(len([1,2,3,4,5,6]))   #6 

　　b.enumerate()　　　

语法:
    enumerate(sequence, [start=0])
sequence:必须是一个序列、迭代器或者其他支持迭代的对象
start:下标开始位置

names = ['Jane','Mike','Byes','Suke']
iterator = enumerate(names)     #<enumerate object at 0x0000000001E9CA68> 获得一个关于枚举的迭代器
for i in iterator:
    print(i)
# (0, 'Jane')
# (1, 'Mike')
# (2, 'Byes')
# (3, 'Suke')
iterator2 = enumerate(names)
print(list(iterator2))                  #[(0, 'Jane'), (1, 'Mike'), (2, 'Byes'), (3, 'Suke')]
print(list(enumerate(names,start=5)))   #[(5, 'Jane'), (6, 'Mike'), (7, 'Byes'), (8, 'Suke')]

和for循环相关:

for i,e in enumerate(range(4),2):
    print('i = {0},e = {1}'.format(i,e))
# i = 2,e = 0
# i = 3,e = 1
# i = 4,e = 2
# i = 5,e = 3

　　c.all()

　　　　如果给定一个可迭代对象中的元素都为True,则返回True,否则返回False

print(all([1,2,0]))                 #False
print(all([1,2,False]))             #False
print(all([1,2,None]))              #False
print(all([1,2,()]))                #False
print(all([1,2,set()]))             #False
print(all([1,2,{}]))                #False
print(all([1,2,'']))                #False
print(all([1,2,2]))                 #True
print(all([]))                      #True
print(all({}))                      #True　　

　　d.any()

　　　　如果给定一个可迭代对象中的元素都为False,则返回False,否则返回True

print(any([1,2,0]))                 #True
print(any([1,2,False]))             #True
print(any([1,2,None]))              #True
print(any([1,2,()]))                #True
print(any([1,2,set()]))             #True
print(any([1,2,{}]))                #True
print(any([1,2,'']))                #True
print(any(['',None,()]))            #False
print(any([]))                      #False
print(any({}))                      #False

　　e.zip()

l1 = ['key1','key2','key3']
l2 = [1,2,3,4]
zipped = zip(l1,l2)
print(zipped)       #<zip object at 0x00000000024EA7C8>
print(dict(zipped)) #{'key1': 1, 'key2': 2, 'key3': 3}

l1 = ['key1','key2','key3']
for i in zip(*l1):
    print(i)
# ('k', 'k', 'k')
# ('e', 'e', 'e')
# ('y', 'y', 'y')
# ('1', '2', '3')

　　f.filter()

　　　　用于过滤序列,过滤掉不合格的元素,返回一个迭代器,不改变原来的值

　　　　语法:filter(function,iterable) function:筛选函数 iterable:可迭代的对象

def is_even(x):
    return x % 2 == 0
fiterator = filter(is_even,[1,2,2,3,4,5,6,7])
print(fiterator)        #<filter object at 0x00000000006722E8>
print(list(fiterator))  #[2, 2, 4, 6]

筛选含有字符串的元素:

def is_str(s):
    if type(s) == str and str(s).strip():
        return True
ret = filter(is_str,['h',1,'',None,2,'k','l'])
print(list(ret))        ##['h', 'k', 'l']

　　g.map()

　　　　会根据提供的函数对指定序列做映射

　　　　执行前后元素个数不变,值可能发生改变

　　　　返回值是一个迭代器　

l = [-2,-1,2,0]
ret = map(abs,l)
print(ret)              #<map object at 0x0000000001DA2F60>
print(list(ret))        #[2, 1, 2, 0]

　　h.sorted()

　　　　语法:sorted(iterable,key=None,reverse=False)

　　　　iterable:是一个可迭代对象

　　　　key:用于比较的元素

　　　　reverse:排序规则,reverse=False 升序(默认),反之降序

l = [-2,-2,1,6,-5,-2,4,3]
print(sorted(l))                            #[-5, -2, -2, -2, 1, 3, 4, 6]   升序排列
print(sorted(l,reverse=True))               #[6, 4, 3, 1, -2, -2, -2, -5]   降序排列
print(sorted(l,key=abs))                    #[1, -2, -2, -2, 3, 4, -5, 6]

三、作用域相关

1.locals()

　　找到当前作用域下所有的变量对应关系,并以字典返回

2.globals()

　　找到全局作用域下所有的变量对应关系,并以字典返回

a = 1
b = 'hello'
def func():
    c = 3
    print(locals())     #{'c': 3}
    print(globals())    #{'__name__': '__main__', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x002A5910>,
                        # 'func': <function func at 0x00527CD8>, '__file__': 'C:/Users/Administrator/PycharmProjects/PYL/生成器/1.py',
                        # '__spec__': None, '__cached__': None, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, 'b': 'hello',
                        # '__doc__': None, '__package__': None}
func()

四、面向对象相关

1.定义特殊方法的装饰器

　　a.classmethod()

　　b.property()

　　c.staticmethod()

2.判断对象/类与类之间的关系

　　a.isinstance()

　　b.issubclass()

3.所有类的基类

　　a.object()

4.继承相关

　　a.supper()

5.封装相关

　　a.vars()

6.数据类型相关

　　a.type()

　　　　一个参数时查看类型

print(type(2))      #<class 'int'>
print(type(str))    #<class 'type'>

五、迭代器/生成器相关

1.range()

用于创建一个整数列表,常用在for循环中

li = list(range(0,11,2))
print(li)   #[0, 2, 4, 6, 8, 10]

2.__next__()

一个next对应一个值返回,如果这个迭代器已经没有值可以返回了那么就将报错

li = ['a',1,2]
iterator = li.__iter__()
print(iterator.__next__())      #a
print(iterator.__next__())      #

3.__iter__()

当一个具有可迭代数据使用__iter__()它会返回一个迭代器的内存地址

li = ['a',1,2]
iterator = li.__iter__()
print(iterator)         #<list_iterator object at 0x0000000002202F60>

六、其他

1.输入输出

(1)input()

content = input('请输入一个数:')
print(content)
# 请输入一个数:5
#

(2)print()

特殊字符分隔

print('a','b','c',sep = '&&',end = '')  #a&&b&&c

将用户输入的数据直接写入文件

f = open('file',mode='w',encoding='utf-8')
content = input()
print(content,sep=',',end='',file = f,flush=True)  #file默认是输出到屏幕,如果设置文件句柄则输出到文件
                                                   #flush立即将内容输出到文件流,不留缓存
f.close()

2.内存相关

(1)hsah()

这里hash()中用到的参数必须是不可变数据类型,hash()完后结果会返回一串数字

print(hash(133))        #
print(hash('aaaaa'))    #-868214941
print(hash('aaaax'))    #
print(hash((1,2,3)))    #-378539185

最直接的例子就是字典键的值,字典中的key是唯一的并且只能对应一个hash值

(2)id()

返回一个变量的内存地址

a = 5
b = 'hello'
c = [1,2]
print(id(a))    #
print(id(b))    #
print(id(c))    #

3.字符串类型代码的执行

(1)eval()

可以执行字符串类型的代码,有返回值,适用于简单计算

建议一般情况下不要使用eval()除非自己很明确要执行什么

print(eval(''))              #
print(eval('1 + 2 + 3 + 4'))    #

(2)exec()

可以执行字符串类型的代码,无返回值,适用于简单流程控制

print(exec(''))                  #None
print(exec('1 + 2 + 3 + 4 + 5'))    #None
code = '''for i in [1,5,10]:
                print(i*2)'''
exec(code)
#
#
#

(3)complie()

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
source:字符串或者AST
filename:代码文件的名称,如果不是从文件中读取代码则传递一些可辨认的值。当传入source参数时,filename参数传空即可
model:编译代码的种类 eval属于计算类、exec属于流程类、single属于交互类

计算类:

code = '2*5/10 + 6'
ret = compile(code,'','eval')
print(eval(ret))    #7.0

流程类:

code = '''print([i*i for i in range(10) if i > 5])'''
ret = compile(code,'','exec')
exec(ret)   #[36, 49, 64, 81]

交互类:

code = "name = input('Please input your name:')"
ret = compile(code,'','single')
exec(ret)
print(name)

4.文件操作相关

(1)open()

打开一个文件的相关操作

5.模块相关

(1)__import__()

# import time
time = __import__('time')
print(time.time())

6.帮助

(1)help()

能够查看一个变量或类型的方法

help(bool)
# Help on class bool in module builtins:
#
# class bool(int)
#  |  bool(x) -> bool
#  |
#  |  Returns True when the argument x is true, False otherwise.
#  |  The builtins True and False are the only two instances of the class bool.
#  |  The class bool is a subclass of the class int, and cannot be subclassed.
#  |
#  |  Method resolution order:
#  |      bool
#  |      int
#  |      object
#  |
#  |  Methods defined here:
#  |
#  |  __and__(self, value, /)
#  |      Return self&value.
#  |
#  |  __new__(*args, **kwargs) from builtins.type
#  |      Create and return a new object.  See help(type) for accurate signature.
#  |
#  |  __or__(self, value, /)
#  |      Return self|value.
#  |
#  |  __rand__(self, value, /)
#  |      Return value&self.
#  |
#  |  __repr__(self, /)
#  |      Return repr(self).
#  |
#  |  __ror__(self, value, /)
#  |      Return value|self.
#  |
#  |  __rxor__(self, value, /)
#  |      Return value^self.
#  |
#  |  __str__(self, /)
#  |      Return str(self).
#  |
#  |  __xor__(self, value, /)
#  |      Return self^value.
#  |
#  |  ----------------------------------------------------------------------
#  |  Methods inherited from int:
#  |
#  |  __abs__(self, /)
#  |      abs(self)
#  |
#  |  __add__(self, value, /)
#  |      Return self+value.
#  |
#  |  __bool__(self, /)
#  |      self != 0
#  |
#  |  __ceil__(...)
#  |      Ceiling of an Integral returns itself.
#  |
#  |  __divmod__(self, value, /)
#  |      Return divmod(self, value).
#  |
#  |  __eq__(self, value, /)
#  |      Return self==value.
#  |
#  |  __float__(self, /)
#  |      float(self)
#  |
#  |  __floor__(...)
#  |      Flooring an Integral returns itself.
#  |
#  |  __floordiv__(self, value, /)
#  |      Return self//value.
#  |
#  |  __format__(...)
#  |      default object formatter
#  |
#  |  __ge__(self, value, /)
#  |      Return self>=value.
#  |
#  |  __getattribute__(self, name, /)
#  |      Return getattr(self, name).
#  |
#  |  __getnewargs__(...)
#  |
#  |  __gt__(self, value, /)
#  |      Return self>value.
#  |
#  |  __hash__(self, /)
#  |      Return hash(self).
#  |
#  |  __index__(self, /)
#  |      Return self converted to an integer, if self is suitable for use as an index into a list.
#  |
#  |  __int__(self, /)
#  |      int(self)
#  |
#  |  __invert__(self, /)
#  |      ~self
#  |
#  |  __le__(self, value, /)
#  |      Return self<=value.
#  |
#  |  __lshift__(self, value, /)
#  |      Return self<<value.
#  |
#  |  __lt__(self, value, /)
#  |      Return self<value.
#  |
#  |  __mod__(self, value, /)
#  |      Return self%value.
#  |
#  |  __mul__(self, value, /)
#  |      Return self*value.
#  |
#  |  __ne__(self, value, /)
#  |      Return self!=value.
#  |
#  |  __neg__(self, /)
#  |      -self
#  |
#  |  __pos__(self, /)
#  |      +self
#  |
#  |  __pow__(self, value, mod=None, /)
#  |      Return pow(self, value, mod).
#  |
#  |  __radd__(self, value, /)
#  |      Return value+self.
#  |
#  |  __rdivmod__(self, value, /)
#  |      Return divmod(value, self).
#  |
#  |  __rfloordiv__(self, value, /)
#  |      Return value//self.
#  |
#  |  __rlshift__(self, value, /)
#  |      Return value<<self.
#  |
#  |  __rmod__(self, value, /)
#  |      Return value%self.
#  |
#  |  __rmul__(self, value, /)
#  |      Return value*self.
#  |
#  |  __round__(...)
#  |      Rounding an Integral returns itself.
#  |      Rounding with an ndigits argument also returns an integer.
#  |
#  |  __rpow__(self, value, mod=None, /)
#  |      Return pow(value, self, mod).
#  |
#  |  __rrshift__(self, value, /)
#  |      Return value>>self.
#  |
#  |  __rshift__(self, value, /)
#  |      Return self>>value.
#  |
#  |  __rsub__(self, value, /)
#  |      Return value-self.
#  |
#  |  __rtruediv__(self, value, /)
#  |      Return value/self.
#  |
#  |  __sizeof__(...)
#  |      Returns size in memory, in bytes
#  |
#  |  __sub__(self, value, /)
#  |      Return self-value.
#  |
#  |  __truediv__(self, value, /)
#  |      Return self/value.
#  |
#  |  __trunc__(...)
#  |      Truncating an Integral returns itself.
#  |
#  |  bit_length(...)
#  |      int.bit_length() -> int
#  |
#  |      Number of bits necessary to represent self in binary.
#  |      >>> bin(37)
#  |      '0b100101'
#  |      >>> (37).bit_length()
#  |      6
#  |
#  |  conjugate(...)
#  |      Returns self, the complex conjugate of any int.
#  |
#  |  from_bytes(...) from builtins.type
#  |      int.from_bytes(bytes, byteorder, *, signed=False) -> int
#  |
#  |      Return the integer represented by the given array of bytes.
#  |
#  |      The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
#  |
#  |      The byteorder argument determines the byte order used to represent the
#  |      integer.  If byteorder is 'big', the most significant byte is at the
#  |      beginning of the byte array.  If byteorder is 'little', the most
#  |      significant byte is at the end of the byte array.  To request the native
#  |      byte order of the host system, use `sys.byteorder' as the byte order value.
#  |
#  |      The signed keyword-only argument indicates whether two's complement is
#  |      used to represent the integer.
#  |
#  |  to_bytes(...)
#  |      int.to_bytes(length, byteorder, *, signed=False) -> bytes
#  |
#  |      Return an array of bytes representing an integer.
#  |
#  |      The integer is represented using length bytes.  An OverflowError is
#  |      raised if the integer is not representable with the given number of
#  |      bytes.
#  |
#  |      The byteorder argument determines the byte order used to represent the
#  |      integer.  If byteorder is 'big', the most significant byte is at the
#  |      beginning of the byte array.  If byteorder is 'little', the most
#  |      significant byte is at the end of the byte array.  To request the native
#  |      byte order of the host system, use `sys.byteorder' as the byte order value.
#  |
#  |      The signed keyword-only argument determines whether two's complement is
#  |      used to represent the integer.  If signed is False and a negative integer
#  |      is given, an OverflowError is raised.
#  |
#  |  ----------------------------------------------------------------------
#  |  Data descriptors inherited from int:
#  |
#  |  denominator
#  |      the denominator of a rational number in lowest terms
#  |
#  |  imag
#  |      the imaginary part of a complex number
#  |
#  |  numerator
#  |      the numerator of a rational number in lowest terms
#  |
#  |  real
#  |      the real part of a complex number

7.调用相关

(1)callable()

判断参数是否是一个可调用的函数名,若是则True,不是则False

a = 1
print(callable(a))  #False
def func():
    return 5
print(callable(func))     #True
print(callable(func()))   #False

8.查看内置属性

(1)dir()

查看一个参数或变量的属性

print(dir([]))  #['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']