Python 内置函数

1.　　abs()

# 对传入参数取绝对值
print(abs(-4))
print(abs(7))

4
7

 

 

2.　　all()

# 判断可迭代参数iterable中全部元素，都为真返回True，不然返回False
# 0，空，False外都为真
print(all(['a', 'b']))
print(all(['', 3]))
print(all((0, 3)))
print(all(['0', 1]))

True
False
False
True

 

 

3.　　any()

# 判断可迭代参数iterable中全部元素，都为假返回False，不然返回Ture
# 0，空，False外都为真
print(any(['a', 'b']))
print(any(['', 3]))
print(any((0, False)))
print(any(['0', 1]))

True
True
False
True

 

 

4.　　ascii()

# ascii 函数相似repr()函数，返回一个表示对象的字符串
# 可是对于字符串中的非ASCII字符则返回经过repr()函数使用\x,\u或\U编码的字符
# 生成相似Python2中repr()函数的返回值
print(ascii('runoob'))

'runoob'

 

 

5.　　bin()

# bin()返回一个整数int或者长整数long int 的二进制表示
print(bin(12))

0b1100

 

 

6.　　oct()

# oct()函数将一个整数转换成8进制字符串
print(oct(8))

0o10

 

 

7.　　hex()

#hex()用于将10进制整数转换成16进制，以字符串形式表示
print(hex(23))

0x17

 

 

8.　　bool()

# bool()函数用于将给定参数转换成布尔类型
# 若是没有参数则返回False，bool是int的子类
print(bool())
print(bool(0))
print(bool(1))
print(bool(False))

False
False
True
False

 

 

9.　　bytearray()

# bytearray()方法返回一个新字节数组
# 这个数组里的元素是可变的，而且每一个元素的值范围：0<=x<256
# 语法：class bytearray([source[,encoding[,errors]]])
# 若是source为整数，则返回一个长度为source的初始化数组
# 若是source为字符串，则按照指定的encoding将字符串转为字节序列
# 若是source为可迭代类型，则元素必须为[0， 255]中的整数
# 若是source为与buffer接口一致的对象，则此对象也能够被用于初始化bytearray
# 若是没有输入任何参数，默认就是初始化数组为0个元素
print(bytearray())
print(bytearray([1,2,3]))
print(bytearray('res','utf-8'))

bytearray(b'')
bytearray(b'\x01\x02\x03')
bytearray(b'res')

 

 

10.　　　　bytes()

# bytes()函数返回一个新的bytes对象，
# 该对象是一个0<=x<256区间的整数不可变序列
# 它是bytearray的不可变版本
# 语法： class bytes([source[,encoding[,errors]]])
# 若是source为整数，则返回一个长度为source的初始化数组
# 若是source为字符串，则按照指定的encoding将字符串转为字节序列
# 若是source为可迭代类型，则元素必须为[0， 255]中的整数
# 若是source为与buffer接口一致的对象，则此对象也能够被用于初始化bytearray
# 若是没有输入任何参数，默认就是初始化数组为0个元素
print(bytes([1,2,3]))
print(bytes('hello', 'ascii'))

b'\x01\x02\x03'
b'hello'

 

 

11.　　callable()

# callable(object)函数用于检查一个对象是不是可调用的
# 若是返回True，object仍然可能调用失败
# 但若是返回False，调用对象object绝对不会成功
print(callable(0))
print(callable('res'))
class A:
    def method(self):
        return 0
print(callable(A))
a = A()
print(callable(a))

False
False
True
False

 

 

12.　　chr()

# chr()用一个范围在range(256)内的整数做为参数，返回一个对应的字符
print(chr(97))
print(chr(100))

a
d

 

 

13.　　ord()

# ord()函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于unicode对象）的配对函数
# 返回对应ASCII数值或unicode数值
# 若是所给Unicode字符超出了你的Python定义范围。则会引起一个TypeError的异常
print(ord('a'))
print(ord('d'))

97
100

 

 

14.　　classmethod

# classmethod修饰符对应的函数不须要实例化，不须要self参数
# 可是第一个参数须要是表示自身类的class参数，
# 能够来调用类的属性，类的方法，实例化对象等
class A(object):
    bar = 1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        # 调用foo方法
        cls().func1()
# 不须要实例化
A.func2()

func2
1
foo

 

 

15.　　complile()

# compile()函数将一个字符串编译为字节代码
# compile(score,filename,mode[,dont_inherit]])
# source--字符串或者AST(Abstract Syntax Trees)对象
# filename--代码文件名称，若是不是从文件读取代码则传递一些可辨认的值
# mode--指定编译代码的种类，能够指定为exec, eval, single
# flags--变量做用域，局部命名空间，若是被提供，能够是任何映射对象
# flags和dont_inherit是用来控制编译源码时的标志
str = 'for i in range(0, 10): print(i)'
c = compile(str,'','exec')
print(c)
exec (c)

<code object <module> at 0x0000000000538270, file "", line 1>
0
1
2
3
4
5
6
7
8
9

 

str = '3 * 4 + 5'
a = compile(str, '', 'eval')
print(eval(a))

17

 

 

16.　　complex()

# complex()函数用于建立一个值为real+imag*j的复数或者转化为一个字符串或数为复数
# 若是第一个参数为字符串，则不须要指定第二个参数
# class complex([real[,img]])
# real--int,long,float或字符串
# imag--int，long，float
print(complex(1,2))
print(complex(1))

(1+2j)
(1+0j)

 

 

17.　　delattr()

# delattr(object, name)函数用于删除属性
# delatter(x,'foo')至关于del x.foo
# object--对象
# name--必须是对象的属性
class C:
    x = 10
    y = 5
    z = 0
point1 = C()
print('x=',point1.x)
print('y=',point1.y)
print('z=',point1.z)
delattr(C,'z')
print('--删除z属性后--')
print('x=',point1.x)
print('y=',point1.y)

x= 10
y= 5
z= 0
--删除z属性后--
x= 10
y= 5

 

 

18.　　dir()

# dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表
# 带参数时，返回参数的属性、方法列表
# 若是参数包含方法__dir__(),该方法将被调用。
# 若是参数不包含__dir__(),该方法将最大限度的收集参数信息

 

 

19.　　divmod()

# divmod()返回一个包含商和余数的元组(a//b, a%b)
print(divmod(7,2))
print(divmod(8,2))

(3, 1)
(4, 0)

 

 

20.　　enumerate()

# enumerate()用于将一个可遍历的数据对象（列表、元组、字符串）组合为一个索引序列
# 同时列出数据和数据下标，通常用在for循环当中
# enumerate(sequence, [start=0])
# sequence--一个序列、迭代器或其余支持迭代的对象
# start--下标的起始位置
print(list(enumerate(['a', 'b', 'c'])))

[(0, 'a'), (1, 'b'), (2, 'c')]

 

 

21.　　eval

#eval()用来执行一个字符串表达式，并返回表达式的值
# eval(expression[,globals[,locals]])
# expression--表达式
# globals--变量做用域，全局命名空间，若是被提供，则必须是一个字典对象
# locals--变量做用域，局部命名空间，若是被提供，能够是任何映射对象
print(eval('3 * 2'))
print(eval('3''*''2'))

6
6

 

 

22.　　exec()

# exec()执行储存在字符串或文件中的Python语句
# 至关于eval，exec能够执行更复杂的Python代码
# exec(object[,globals[,locals]])
# object--必选参数，表示须要被指定的Python代码，它必须是字符串或code对象
# 若是object是一个字符串，该字符串会先被解析为一组Python语句，而后在执行（除非发生错误）
# 若是object是一个code对象，那么它只是被简单地执行
# globals--可选参数，表示全局命名空间（存放全局变量），若是被提供，则必须是一个字典对象
# locals--可选参数，表示当前局部命名空间（存放局部变量），若是被提供，能够是任何映射对象
# 若是该参数被忽略，那么它将会取与globals相同的值
exec('''for i in range(5):
    print('iter time:%d'%i)
''')

iter time:0
iter time:1
iter time:2
iter time:3
iter time:4

 

 

23.　　float()

# float()将整数和字符串转换成浮点数
print(float(10))
print(float('10'))

10.0
10.0

 

 

24.　　frozenset()

#frozenset()返回一个冻结的集合，冻结后集合不能添加或删除任何元素
# frozenset（[iterable]）
# iterable--可迭代对象（字典、元组、列表等）
print(frozenset(range(5)))
print(frozenset([1,2,3]))

frozenset({0, 1, 2, 3, 4})
frozenset({1, 2, 3})

 

 

 

25.　　getattr

# getattr()返回一个对象属性值
# getattr(object,name[,default])
# object--对象
# name--字符串，对象属性
# default--默认返回值，若是不提供该参数，在没有对应属性时，将触发AttributeError
class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))

 1

 

 

26.　　hasattr()

# hasattr()用于判断对象是否包含对应的属性
# hasattr(object,name)
# object--对象
# name--字符串，属性名
# 若是对象有该属性返回True，不然返回False
class C:
    x = 10
    y = 2
    z = 5
point1 = C
print(hasattr(point1, 'x'))
print(hasattr(point1, 'n'))

True
False

 

 

27.　　hash()

# 获取一个对象（字符串或数值等）的hash值
print(hash('test'))
print(hash(str([1, 2, 3])))
print(hash(str({'1':'a'})))

-5407184177310519943
4889424586042814161
1115203415993729361

 

 

28.　　help()

# help()函数用于查看函数或模块用途的详细说明
help(str)

显示str数据类型的帮助

 

 

29.　　id()

# id()用于获取对象的内存地址
a = '12'
print(id(a))

30649960

 

 

30.　　isinstance()

# isinstance()判断一个对象是不是一个已知类型，相似type()
# isinstance()与type()区别：
#type()不会认为子类是一种父类类型，不考虑继承关系
# isinstance()会认为子类是父类类型，考虑继承关系
# 若是要判断两个类型是否相同推荐使用isinstance()
# isinstance(object,classinfo)
# classinfo--能够是直接或间接类名，基本类型或者由他们组成的元组
# 若是对象的类型与参数二的类型（classinfo）相同则返回True，不然返回False
a = 2
print(isinstance(a, int))
print(isinstance(a, str))

True
False

 

 

31.　　issubclass()

# issubclass()方法用于判断class是不是类型参数classinfo的子类
# issubclass(class, classinfo)
# 若是class是classinfo的子类返回True，不然返回False
class A:
    pass
class B(A):
    pass
print(issubclass(B, A))

True

 

 

32.　　locals()

# locals()以字典类型返回当前位置的所有局部变量
# 对于函数，方法lambda函式，类，以及实现了__call__方法的类实例，它都返回True
def ru(arg):
    z = 1
    print(locals())
ru(4)

{'arg': 4, 'z': 1}

 

 

33.　　max()

# 函数max的终极用法
people = [
    {'name': 'ax', 'age': 100},
    {'name': 'wq', 'age': 500},
    {'name': 'lf', 'age': 19}
]
print(max(people,key=lambda dic:dic['age']))
# 解释：比较列表people里元素的大小，people里的元素是字典
# 字典是没有办法直接比较的，用lambda定义max的比较方法key
# key的意思是比较age的值

{'name': 'wq', 'age': 500}

 

 

34.　　min()

用法与max（）相同

 

 

35.　　memoryview()

# memoryview(object)返回给定参数的内存查看对象
# 内存查看对象，是指支持缓冲区协议的数据进行包装，再不须要复制对象基础上容许Python代码访问
v = memoryview(bytearray('abcd','utf-8'))
print(v[1])
print(v[-1])
print(v[1:4].tobytes())

98
100
b'bcd'

 

 

36.　　next()

# next(iterator[,default])返回迭代器的下一个项目
# iterator--可迭代对象
# default--可选，用于设置在下一个元素时返回该默认值
# 若是不设置，有没有下一个元素则会触发Stoplteration异常
it = iter([1, 2, 3])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break

1
2
3

 

 

37.　　pow()

# pow()方法返回X的Y次幂的值
import math
print(math.pow(10,2))

100.0

 

 

38.　　repr()

# repr(object)将对象转化为供解释器读取的形式
# 返回一个对象的string格式
s = 'ruuu'
print(repr(s))
dict1 = {'re': 1, 'ds': 2}
print(repr(dict1))
print(type(repr(dict1)))

'ruuu'
{'re': 1, 'ds': 2}
<class 'str'>

 

 

39.　　reversed()

# reversed(seq)返回一个反转的迭代器
# seq--要转换的序列，能够是tupe，string、list、range
str1 = 'root'
print(list(reversed(str1)))

['t', 'o', 'o', 'r']

 

 

40.　　round()

# round(x[,n])返回浮点数X的四舍五入，默认值为0
print(round(1.234))
print('round(1.567):',round(1.567))

1
round(1.567): 2

 

 

41.　　setattr

#setattr(object, name, value)对应函数getatt()
# 用于设置属性值，该属性必须存在
# object--对象
# name--字符串，对象属性
# value--属性值
class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))
# 获取属性bar
setattr(a, 'bar', 5)
#设置属性bar值 
print(a.bar)

1
5

 

 

42.　　slice()

# slice()实现切片对象，主要用在切片操做函数里的参数传递
# class slice(start,stop[,step])
# step--间距
myslice = slice(1, 6, 2)
print(myslice)
arr = [1, 2, 3, 4, 5, 6]
print(arr)
print(arr[myslice])

slice(1, 6, 2)
[1, 2, 3, 4, 5, 6]
[2, 4, 6]

 

 

43.　　sorted()

# sorted()对全部可迭代对象进行排序操做
# list的sort方法返回的是对已经存在的列表进行操做
# 内建函数sorted方法返回的是一个新的list，而不是在原来的基础上的操做
# sorted(iterable, key = None, reverse = False)
# iterable--可迭代对象
# key--主要用来进行比较元素，只有一个参数，具体的函数的参数就是取自于可迭代对象，指定可迭代对象的一个元素来进行排序
# reverse=True 降序， reverse=False 升序（默认）
list_1 = [ 2, 1, 3, 5, 4]
list_2 = sorted(list_1)
print(list_2)
print(list_1)
list_3 = [4, 2, 6, 1,]
list_4 = list_3.sort()
print(list_3)
print(list_4)

[1, 2, 3, 4, 5]
[2, 1, 3, 5, 4]
[1, 2, 4, 6]
None

 

 

44.　　staticmethod()

#staticmethod(function)返回函数的静态方法
# 该方法不强制要求传递参数
class C(object):
    @staticmethod
    def f():
        print('root')
# 静态方法无需实例化
C.f()
co = C()
# 也能够实例化后调用
co.f()

root
root

 

 

45.　　vars()

# vars()返回对下那个object的属性和属性值的字典对象
print(vars())
class Ro:
    a = 1
print(vars(Ro))

 

 

46.　　zip()

# zip()用于将可迭代对象做为参数，将对象中对应的元素打包成一个元组
# 而后返回由这些元组组成的对象，这样作的好处是节约内存
# 可使用list()转换来输出列表
# 若是各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
# 利用*号操做符，能够将元组解压为列表
a = [1, 2, 3]
bb = ['a', 'b', 'c']
x1 = ['a1', 'd3', 'bv', 11]
zipped = zip(a,bb)
print(zipped)
print(list(zipped))
print(list(zip(a,x1)))
# 与zip相反，*zip可理解为解压，返回二维矩阵
a1,a2 = zip(*zip(a,bb))
print(list(a1))
print(list(a2))

<zip object at 0x0000000002378288>
[(1, 'a'), (2, 'b'), (3, 'c')]
[(1, 'a1'), (2, 'd3'), (3, 'bv')]
[1, 2, 3]
['a', 'b', 'c']

 

 

47.　　__import__

# __import__(name[,globals[,locals[,fromlist[,level]]]])
# __import__('a')
# 导入字符串形式的模块 a.py