Python学习(14)--内置函数

1.Python内置函数

          在Python中有很多的内置函数供我们调用,熟练的使用这些内置函数可以让编写代码时事半功倍,所谓内置函数就是那些Python已经预定义并且已经实现的,可以供我们直接调用的函数,很多高级语言都有内置函数,比如java语言中的Math类中就提供了很多有关数学方面的函数供我们调用。

     下面我们来看一个求一个数绝对值的例子,代码如下:

def fun(x):
    if x<0:
        return -x
    return x
print(fun(-10))
print(fun(10))

      代码很简单,函数fun(x)接收一个实参,如果x>0，直接返回x;否则返回x的相反数.代码运行结果如下:

     

      Python作为一种数据处理能力超强的高级语言,以代码简洁可读性强著称。很重要的一个原因就是Python为我们提供了很多有关数据处理的内置函数,所以我们在用Python解决一个问题的时候,首先考虑的是Python是否把问题已经为我们解决了。当然,对于求一个数绝对值这件小事,Python已经为我们提供了内置函数.下面我就为大家介绍下Python中常用的内置函数。如下:

     

print(abs(-5))
print(abs(5))
l=[1,2,3,4,5,6,34,45,14]
print(max(l))
print(min(l))

       以上代码分别有abs(x),max(x),min(x)3个内置函数,abs(x)是Python为我们提供的求一个数绝对值的内置函数,相比较之前我们编写的代码,使用内置函数abs(x)只需要一行代码就能使问题迎刃而解。内置函数max(x)是求一个序列的最大值,内置函数min(x)则是求一个序列中值最小的元素。

      打印结果如下:

      

      再看以下2个内置函数:

      

l=[1,2,3,4,5,6,34,45,14]
print(len(l))
print(divmod(5,2))

     打印结果如下:

     

      

     

      以上代码有两个函数,len(x)函数的功能是求一个序列的长度,divmod的打印结果为(2,1),这个结果是怎么来的呢？其实Python中的很多内置函数,我们都知其名却未必知其意，比如divmod(x,y),那么如何获取这个内置函数的功能呢？其实Python为我们提供了获取内置函数信息的命令,就是help命令。如下:

     

print(help(divmod))

       打印结果如下:

       

      倒数第三行,Return the tuple(x//y,x%y),告诉我们divmod(x,y)返回的是一个元组,元组中有两个元素,第一个元素是x//y，即x整除y,第二个元素是x%y,即x对y取余;这就解释了divmod(5,2)打印结果为什么为(2,1),因为5//2=2,5%2=1。

      再介绍下以下2个数学计算中常用的内置函数,如下:

      

print(pow(2,3))
print(pow(2,3,4))
print(round(8/3,3))

         代码打印结果如下:

      

       

      函数pow(x,y,z)返回的结果为:（x的y次方）%z，如果参数调用函数时没有参数z,则返回结果为:x的y次方。

      round(x,y)是按照四舍五入的方式对浮点型数据x保留到小数点后y位,比如round(8/3,3),8/3=2.6666...,是一个无限循环小数,保留小数点后3位为2.667。这个函数适用于保留一个无限小数小数点后y位。

      callable(x)函数是检查一个对象是否能够被调用,代码如下:

def f():
    pass
print(callable(f))

      如上我们定义了一个函数f，并使用callable(x)函数判断f是否能够被调用,返回值是一个布尔值.打印结果如下:

             

      因为函数f是可调用的,所以打印结果为true,若变量f不是一个函数对象,比如是一个整数,则不能被调用,返回为false.如下:

      

f=100
print(callable(f))

      打印结果如下:

      

       当我们在Python中接收一个对象时,有的时候可能需要判断对象的类型来决定我们对其相应的操作,获取一个对象的类型可以使用函数type(x),x为未知类型对象。在Python又如何判断一个对象的类型呢,下面举一个不使用内置函数的例子：

       

lt=[1,2,3,4,5,6]
print(type(lt))
if type(lt)==type([]):
    print('is list')

       如上所示,lt为一个列表,[]为一个空列表,两者虽然元素不同，但对象类型都是一样的,通过type(x)函数获取对象类型进行比较,来判断一个对象是不是列表类型.

       代码打印结果如下:

        

     其实Python已经为我们提供了内置函数来判断一个对象的类型,内置函数为isinstance(x,y),x为待判断类型的对象,y为Python中的数据类型,函数返回的是布尔值,如下代码:

         

lt=[1,2,3,4,5,6]
print(isinstance(lt,list))
print(isinstance(lt,int))

      代码是使用内置函数isinstance(x,y)，isinstance(lt,list)为判断对象lt的是否是list类型,即列表类型,若是返回true,若不是返回false。isinstance(lt,int)为判断对象lt是否为int类型,若是返回true，否则返回false。

      打印结果如下:

      

       在Python中还有很多类型转换函数,即将一种类型的对象转换成另一种类型的对象。如int(x),就是把x类型的对象转换成整数类型,如下:

       

print(int('123'))
print(int('zhangsan'))

      打印结果如下:

      

       以上是将字符串'123'和'zhangsan'转换成int类型,但这种转换却不一定能够成功,如将‘123’可以转换成整数123,但是‘zhangsan’却不能转换成整数,所以这种转换是在一定条件下的转换,被转换对象必须具有一定的合理性。

      此外,我们还可以将对象转换成其他各种类型,如tuple(x)将对象x转换成元组，str(x)将对象x转换成字符串等等。以如下代码为例:

      

list=[1,2,3,4,5,6,7]
print(tuple(list))
print(type(str(123)))

      代码打印结果如下:

       

       

      如上tuple(list)将序列list转换成元组,str(123)将整数123转换成字符串'123'，使用函数type(x)打印转换后的对象类型如上为。

2.有关字符串的内置函数  

      Python同样为我们提供了许多有关字符串操作的内置函数,了解并掌握这些函数可以让我们在今后的Python编程中游刃有余。下面我们一一介绍这些内置函数.

      (1)capitalize()函数

       capitalize()函数是Python为字符串对象提供的一个首字母变大写的函数,需使用字符串对象来调用这个函数。代码例子如下:

       

s='hello world'
print(s.capitalize())

       打印结果如下：

       

       (2)replace(old,new,count)函数

      函数replace(old,new,count)同样也是Python为字符串对象提供的内置函数,调用者也必须是字符串对象,有3个参数old,new,和count,功能为将字符串对象的模式子串替换为新的字符串,old为模式子串，即被替换的子字符串，new为要替换的新字符串,count为需要被替换的old模式子串的数量,即会替换前count个old模式子串。如果count大于字符串对象中old模式子串的数量的话，那么所有模式子串都将被替换。如果调用函数时,没有为count提供实参,默认所有的old模式子串都被替换。代码例子如下:

ss='123123123'
print(ss.replace('1','0'))
print(ss.replace('1','0',1))
print(ss.replace('1','0',2))
print(ss.replace('1','0',3))
print(ss.replace('1','0',4))

      运行结果如下:

      

        代码中字符串对象'123123123',使用的old模式子串为'1',替换之后的新字符串为'0',count分别为1,2,3,4,如上count=1时只替换了第1个模式子串'1'。

        (3)split(sep,maxsplite)函数

        函数split(seq,maxsplite)是把一个字符串对象分割成若干个字符串对象的内置函数,其中seq表示分隔符,函数split(seq,maxsplite)就是根据分隔符seq分割字符串对象的,参数maxsplite是控制分割的次数,maxsplite=1会把一个字符串对象分割1次,分割成2个字符串对象，即此内置函数会把字符串对象分割成maxsplite+1个字符串对象,并把每个分割成的字符串对象封装到列表中返回,如果不指定参数maxsplite的值,默认情况下会把字符串对象分割成最多的字符串对象。代码案例如下:

ss='192.168.12.13'
print(ss.split('.'))
print(ss.split('.',1))
print(ss.split('.',2))
print(ss.split('.',3))

         代码运行结果如下:

         

      如上代码所示,字符串对象为'192.168.12.13',分割符seq='.',不指定maxsplite的值的话默认有一个'.'就分割1次，直至把所有的'.'都遍历并分割完。maxsplite=1,则分割按照字符串对象从左至右的顺序遇到的第一个'.'分割,将字符串对象分割成两个字符串对象，并封装到列表中返回。同理,maxsplite=2或3,则从左至右把字符串对象分割2或3次。

      介绍完有关字符串操作的内置函数,下面我们来介绍几个常用的有关序列操作的内置函数。

3.序列操作的内置函数

      (1)过滤函数filter(function,iterable)

       内置函数filter(function,iterable)的功能为把可迭代对象中不符合条件的数据元素过滤出去,把符合条件的元素封装到一个集合内并返回。它的数据来源是参数iterable,这是一个可迭代对象，什么是可迭代对象呢？说白了就是一个可以被遍历的数据集合,可以是序列，字典或者字符串。function是一个返回布尔值的函数,内置函数filter(function,iterable)会把iterable对象中的每一个元素取出来,作为判断函数function的参数,通过function的判断,如果该元素符合条件则返回true保留此元素,否则把此元素过滤出去。看如下代码:

def f(x):
    if x>5:
        return True
li=[0,1,2,3,4,5,6,7,8,9,10]
fil=filter(f,li)
print(li)

       代码为把列表中所有<=5的元素过滤出去,代码运行结果如下:

       

       通过代码发现,似乎并没有把序列li中<=5元素过滤掉,其实不然。因为filter(function,iterable)对元素的过滤并不是在原有iterable对象上做出修改,它实质上是把符合条件的元素放到一个filter对象中,不符合条件的元素则不被放入.而filter(function,iterable)返回的其实就是这个filter对象。如上的fil就是返回的filter对象,所有符合条件的元素都在这个集合中。如果要想获取符合条件的元素,只需要遍历这个filter对象就可以了。方法有两种，代码如下:

       方法一:

def f(x):
    if x>5:
        return True
li=[0,1,2,3,4,5,6,7,8,9,10]
fil=filter(f,li)
print(list(fil))

     方法一是list(fil),是把迭代器对象转换成一个列表,就像我们之前介绍的每一种数据类型都有类型转换函数,比如int(x)把x转换成整数类型,这里同样用到的是类型转换。代码运行结果如下:

  

       方法二:

def f(x):
    if x>5:
        return True
li=[0,1,2,3,4,5,6,7,8,9,10]
fil=filter(f,li)
for i in fil.__iter__():
    print(i)

    方法二使用filter对象的__iter__()方法返回一个迭代器iterator对象,
这个对象是可遍历的,通过for循环可以把其中的每个元素取出来.代码运行结果如下:    

        (2)zip(iter1,iter2,iter3,...)函数

       zip(iter1,iter2,iter3,...)函数的参数是一个个的可序列化对象,而它的功能就是把一个个可序列化对象中的每个元素按次序取出并组成一条记录的形式放到元组里作为返回列表的一个元素,直至把可序列化对象中的所有元素都取出。这么说有点抽象,代码例子如下:

        

name=['zhangsan','lisi','wangwu']
age=[20,30,40]
tel=['123','456','789']
print(list(zip(name,age,tel)))

         打印结果如下:

         如上所示,分别有3个序列依次是name,age和tel, zip(name,age,tel)会把每一个序列的元素按照顺序依次取出,如name[0],age[0],tel[0]组成一个元组('zhangsan',20,'123'),最后返回的是一个zip对象,获取zip对象中的元素可以把它转换成列表list,也可以通过for循环访问每个元素,代码如下:

name=['zhangsan','lisi','wangwu']
age=[20,30,40]
tel=['123','456','789']
for x in zip(name,age,tel):
    print(x)

         打印结果如下:

   

      需要注意的是如果zip(iter1,iter2,iter3,...)的每个可序列化对象中元素个数不一致,内置函数zip(iter1,iter2,iter3,...)会在最短的可序列化被遍历完之后就不在遍历其他可序列化对象，比如上面的例子如果列表name只有两个元素,代码如下:

name=['zhangsan','lisi']
age=[20,30,40]
tel=['123','456','789']
for x in zip(name,age,tel):
    print(x)

      代码运行结果如下:

      

      如上所示,列表name只有'zhangsan','lisi'两个元素,当遍历完他们之后就函数就结束了,因为name在三个列表中元素是最少的.

        (3)map(function,iter1,iter2,iter3,...)函数
       map函数与zip函数其实差不多,只是map函数比zip函数更加灵活,功能更加强大,zip函数可以实现的，map函数也可以实现。

       map(function,iter1,iter2,iter3,...),第一个参数为一个函数，后面的参数都是可迭代对象,map会把可迭代对象的每一个元素依次取出来作为function对象的实参,取元素的过程和zip函数是一样的。代码如下:

def fun(x,y):
    return x*y
lis=[1,2,3]
lis2=[4,5,6]
print(list(map(fun,lis,lis2)))

      

      代码功能为把列表lis和lis2中的元素依次取出来做乘积,如1和4作为fun(x,y)的实参,返回1*4；代码运行结果如下:

   

       在map函数取元素的过程中,也会遇到可迭代对象元素个数不一致的情况,其处理方法与zip函数是一致的.代码例子如下：

def fun(x,y):
    return x*y
lis=[1,2]
lis2=[4,5,6]
print(list(map(fun,lis,lis2)))

       运行结果如下:

        

      如上所示,列表lis比列表lis2少一个元素,在取完lis中的元素后map函数就结束了,其处理迭代对象长度不一致的情况所用方法与zip函数是一样的.

      不知不觉写了好多,其实想把内置函数当做两节来写的,但是写着写着就忘了.

      下一节我们来学习Python中的包和模块,敬请期待.