Python学习：6.python内置函数详解编程语言

Python内置函数

　　python内置函数，是随着python解释器运行而创建的函数，不需要重新定义，可以直接调用，那python的内置函数有哪些呢，接下来我们就了解一下python的内置函数，这些内置函数中，有一些是面相对象的内容，还有一些是某些模块有关的，我们今天就先了解一些，那些涉及到某些模块以及面向对象的内容我们以后学到之后可再加深了解。

abs()

这个函数的就是将传入的数值取绝对值然后将绝对值。

i = abs(-50) 
print(i) 
k = abs(50) 
print(k) 
 
 
输出结果： 
50 
50

all()

给all()这个函数传一个可迭代的数据，all()函数内部回去迭代，如果这里面所有被迭代的对象都是真值，all()函数就返回一个True，如果有一个不是真值就返回False。

li = [1,2,3,4,5]     
i = all(li) 
print(i) 
li1 = [1,2,3,0] #0为假值 
k = all(li1) 
print(k) 
 
 
输出结果： 
True 
False

如何判断哪些是真值哪些是假值，真值有很多但是假值仅有几个我们通过拿到布尔值进行判断，通过一些的示例我们可以知道0，None，以及空值都是假的。

print(bool(0))  #数字零为假 
print(bool(None))   #None为假 
print(bool("")) #空的字符串为假，这个空字符串不包含任何字符以及空格 
print(bool(())) #空的元组为假 
print(bool([]))#空的列表为假 
print(bool({}))#空的字典为假 
 
 
输出结果： 
False 
False 
False 
False 
False 
False

any()

这个any()和all()有些相似，相似的地方就是判断是否为真值，但是all()是所有为真输出True，any()是只要有一个是真就输出True。

li = [1,0] 
i = any(li) 
print(i) 
li1 = [0,0,""] 
k = any(li1) 
print(k) 
 
 
输出结果： 
True 
False

ascii()

我们使用ascii()这个函数的时候，去传入对象的类（列表list，字典dict）中找__repr__这个方法，去执行这个方法，拿到这个方法的返回值。

我们在这里举一个例子，这个例子涉及到类，没了解过的可以在我以后的博客文章中了解以后再来深入学习。

class Nuo: 
    def __repr__(self): 
        return '123' 
 
obj = Nuo() 
print(ascii(obj)) 
#这个使我们自己写的类，如果使用python中内部的__repr__方法 
 
 
li = list() 
print(ascii(li))    #列表的类中的__repr__方法返回的就是[] 
 
 
 
输出结果： 
123 
[]

bin()

这个是二进制，可以将其它进制转换为二进制格式。

oct()

这个是八进制，可以将其它进制转换为八进制格式。

int()

这个是十进制，可以将其它进制转换为十进制格式。

hex()

这个是十六进制，可以将其它进制转换为十六进制的格式。

以上四个的具体用法之前已经详细介绍，文章连接在这里：https://www.cnblogs.com/liudi2017/p/9171267.html

bool()

这个函数的作用是判断传入对象的真假，其实就是将传入的对象转换为bool值。

print(bool(None)) 
print(bool(1)) 
print(bool("123")) 
 
输出结果： 
False 
True 
True

bytes()

这个表示字节

字节和字符转的转换

bytes("xxxx",encoding="utf-8")

bytearrary()

这个表示字节列表

这两个我们仅仅知道这些即可，不需要太多的了解，很少会用到，我们以后用到会详细介绍。

chr()

接收一个数字，找到这个数字对应ascii码表中对应的元素。

print(chr(97))    #在ascii码表中数值97对应的是小写字母a 
 
输出结果： 
a

ord()

这个函数的方法正好和chr()相对，它是将一个字符转换为ascii码中的数值。

print(ord('p')) 
print(ord(' ')) 
print(ord('_')) 
 
 
输出结果： 
112 
32 
95

callable()

判断对象是否可以执行，可以执行返回一个True，不可以执行返回一个False。

def newfun(): 
    return 123 
 
 
newfun() 
r = callable(newfun) 
print(r) 
 
输出结果： 
True

compile()

接收一个字符串把这个字符串编译成python可以执行的代码，理解到这里就可以了。

str = 'name = "alexsel";print(name)' 
obj = compile(str,'string','exec') 
exec(obj) 
 
输出结果： 
alexsel

complex()

函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。
这个在我们以后的学习中基本用不到。

>>>complex(1, 2) 
(1 + 2j) 
  
>>> complex(1)    # 数字 
(1 + 0j) 
  
>>> complex("1")  # 当做字符串处理 
(1 + 0j) 
  
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 
>>> complex("1+2j") 
(1 + 2j)

dir()

查询某个类提供了什么功能，下面示例就是查看列表这个类提供了什么功能。

li=[] 
print(dir(li)) 
 
 
输出结果： 
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', ...........

divmod()

以元组的形式显示商和余数。

>>> r=divmod(10,3) 
>>> print(r) 
(3, 1)

eval()

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

>>> a="1+3" 
>>> print(a) 
1+3 
>>> ret=eval("1+3")#把字符串转换为表达式 
>>> print(ret)   
4 
>>>x = 7 
>>> eval( '3 * x' ) 
21 
>>> eval('pow(2,2)') 
4 
>>> eval('2 + 2') 
4 
>>> eval("n + 4") 
85

exec()

执行一个字符串内的代码,无返回值(返回值为None)，这个函数在我们介绍compile()的时候也用到过，可以上去看看之前的代码加深理解。

>>> exec("print(123)") 
123

filter()

循环可迭代的对象，获取每一个参数，在函数里执行参数
函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
格式：filter(函数，可迭代的对象)

示例1

def f1(x): 
    if x>22: 
        return True 
    else: 
        return False 
 
ret = filter(f1,[11,22,33,44])  #把返回为True的元素放到ret中 
for i in ret:  #用循环输出ret 
    print(i) 
 
 
输出结果： 
33 
44

示例2

def f1(x): 
    return x>22 
 
ret = filter(f1,[11,22,33,44]) #拿到传入函数的参数得到返回值得到元素。 
for i in ret: 
    print(i) 
 
 
输出结果： 
33 
44

map()

map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
格式：map(函数，可迭代的对象)

  def f1(x): 
    return x+100 
 
ret = map(f1, [1,2,3,4,5]) 
for i in ret: 
    print(i) 
 
 
输出结果： 
101 
102 
103 
104 
105

format()

字符串格式化，字符串格式化我们以后会常常用到，这里就先不讲解，明天我们做一个详细的介绍。

frozenset()

创建一个不能添加元素的set格式，保存在set()中的数据是不能重复的，所以这个就是一个不能重复的，不可修改的数据类型。

fset = frozenset([1,2,3,4,4]) 
print(fset) 
 
输出结果： 
frozenset({1, 2, 3, 4})

globals()

获取当前代码里的所有的全局变量，下面的示例中出现里一些我们没有定义的全局变量，这些是python中需要用到的全局变量，自己生成的全局变量。

name = 'alexsel' 
age = '47' 
obj = globals() 
print(obj) 
 
输出结果： 
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':  
<_frozen_importlib_external.SourceFileLoader object at 0x00000000020AB1D0>, 
 '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__':  
'C:/Users/Administrator/PycharmProjects/untitled1/Alexsel/new_one.py',  
'__cached__': None, 'name': 'alexsel', 'age': '47', 'obj': {...}}

local()

获取当前代码里的所有的局部变量。

hash()

hash() 用于获取取一个对象（字符串或者数值等）的哈希值,一般用于字典key的优化。

str = hash('alexsel') 
print(str) 
 
输出结果： 
9030579981152233445    

#在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

id()

用于查询某个对象的内存地址。

name = 'alexsel' 
print(id(name)) 
 
输出结果： 
37728920

isinstance()

判断某个对象是否由某一个类创建的。

li=[11,22,33] 
t=isinstance(li,list)#判断li是否是由list类创建的 
print(t) 
a=isinstance(li,dict)#判断li是否是由dict类创建 
print(a) 
#如果某个类是当前类的父类也是支持的 
 
 
输出结果： 
True 
False

issubclass()

判断一个类是不是另一类的子类

格式：issubclass(a,B)，判断a是不是B的子类

c = issubclass(list,object) 
print(c) 
 
输出结果： 
True

iter()

创建一个可以迭代的对象

li = [1,2,3,4,5,6] 
for i in iter(li): 
    print(i) 
 
 
输出结果： 
1 
2 
3 
4 
5 
6

next()

将一个可迭代的对象运行一个next就去一个值，取下一个值。

a = iter([11, 22, 33, 44]) 
print(a) 
r1 = next(a) 
print(r1)   
r2 = next(a) 
print(r2)   
 
 
输出结果： 
<list_iterator object at 0x0000000002120978> 
11 
22

max()

找到多个值中的最大值

min()

找到多个值中的最小值

li = [11, 22, 33, 44] 
t = max(li) 
print(t) 
 
z = min(li) 
print(z) 
 
输出结果： 
44 
11

memoryview()

根据索引判断某个对象的的地址是多少
函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

open()

文件操作，操作文件的函数，这里做个简单的示例，明天会详细讲解。

file1 = open('./text.txt',encoding='utf=-8') 
r1 = file1.read() 
print(r1)

pow()

返回x的y次方的值

格式:pow(x,y)

i=pow(2,10) 
print(i) 
 
 
输出结果： 
1024

repr()

返回__repr__的值，每个类中都写有__repr__方法，这个函数就是取到这个方法的返回值。
repr() 函数将对象转化为供解释器读取的形式

range()

生成一个可以迭代的列表

for i in range(4):  #从零开始生成，小于4 
    print(i) 
print('--------') 
for k in range(7,9):    #大于等于7小于9 
    print(k) 
 
 
输出结果： 
0 
1 
2 
3 
-------- 
7 
8

reversed()

讲一个包含有多个元素的数据进行顺序的反转。

li = [1,2,3,4,5,6] 
print(list(reversed(li))) 
 
 
输出结果： 
[6, 5, 4, 3, 2, 1]

round()

将一个数字进行四舍五入

a = round(5.5) 
print(a) 
b = round(5.4) 
print(b) 
 
 
输出结果： 
6 
5

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递

格式：slice(start,stop(step)

start起始位置

stop结束位置

step每次切片间距

li = [1,2,3,4,5,6,] 
slicetest = slice(3) 
print(li[slicetest]) 
slicetest1 = slice(3,6,2) 
print(li[slicetest1]) 
 
 
输出结果： 
[1, 2, 3] 
[4, 6]

sorted()

这个函数的功能是对含有多个元素的数据进行排序

示例1

li = [1, 22, 33, 222, 3, 1] 
print(li) 
le = sorted(li)# 生成新的值，不对原来的变量进行改变 
print(le)        #这个只能对同一个类型的数据进行排序 
print(li) 
li.sort()  # 不生成新的值，对原来的变量进行改变 
print(li) 
 
 
 
输出结果： 
[1, 22, 33, 222, 3, 1] 
[1, 1, 3, 22, 33, 222] 
[1, 22, 33, 222, 3, 1] 
[1, 1, 3, 22, 33, 222]

示例2

li = ["123","1","张","a","99","c","you","鈾","---","_","A","b","0","你","王",] 
print(li) 
le = sorted(li)# 生成新的值，不对原来的变量进行改变 
print(le) 
for i  in le: 
print(bytes(i,encoding="utf-8")) 
输出结果： 
['123', '1', '张', 'a', '99', 'c', 'you', '鈾', '---', '_', 'A', 'b', '0', '你', '王'] 
['---', '0', '1', '123', '99', 'A', '_', 'a', 'b', 'c', 'you', '你', '张', '王', '鈾'] 
b'---' 
b'0' 
b'1' 
b'123'#数字是先比较第一个元素，谁小谁在前面，第一个样就比第二个 
b'99' 
b'A' 
b'_' #字母比较ascii码，先比较第一个元素，谁小谁在前面，第一个 
b'a'            #一样就比第二个 
b'b' 
b'c' 
b'you' 
b'/xe4/xbd/xa0'#汉字比十六进制的大小 
b'/xe5/xbc/xa0' 
b'/xe7/x8e/x8b' 
b'/xe9/x88/xbe'

staticmethod()

返回函数的静态方法。

sum()

对一组数据求和。

t=sum([11,22,33]) 
print(t) 
输出结果： 
66

super()

在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用super 来实现。

tuple()

tuple 函数将列表转换为元组。

li = [1,2,3] 
print(tuple(li)) 
输出结果： 
(1, 2, 3)

type()

查看所一个对象的类型

li = [1,2,3] 
dic = {'key':'v1'} 
str = 'alexsel' 
print(type(li)) 
print(type(dic)) 
print(type(str)) 
输出结果： 
<class 'list'> 
<class 'dict'> 
<class 'str'>

zip()

传入多个可以迭代的对象，将可迭代的对象里的元素打包在一起，打包成一个元组，返回由这些元组组成的列表。

功能是从参数的多个迭代器中选取元素组合成一个新的迭代器。顾名思义，它就是一个将对象进行打包和解包的函数。

li=[11,22,33,44] 
li2=["a","VV","c","aa"] 
r=zip(li,li2) 
print(r) 
for i in r : 
print(i) 
输出结果： 
<zip object at 0x00000000027F77C8> 
(11, 'a') 
(22, 'VV') 
(33, 'c') 
(44, 'aa')

import

函数功能用于动态的导入模块，主要用于反射或者延迟加载模块

__import__(module) 相当于 import module

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12360.html