Python 内置函数详解 3

╰半橙微兮° 2022-10-29 12:24 234阅读 0赞

### 文章目录 ###

*   *  repr 函数
     *  reverse 方法
     *  round 函数
     *  set 函数
     *  setattr 函数
     *  slice 函数
     *  sorted 函数
     *  staticmethod 函数
     *  str 函数
     *  sum 方法
     *  super 函数
     *  tuple 方法
     *  type 函数
     *  unichr 函数
     *  vars 函数
     *  xrange 函数
     *  zip 函数
     *  \\\_\\\_import\_\_ 函数
     *  exec 内置语句

## repr 函数 ##

功能：repr() 函数将对象转化为供解释器读取的形式

> 语法：repr(object) object 对象

返回值：返回一个对象的 string 格式

实例：

s = 'RUNOOB'
    res1 = repr(s)
    print(type(res1),res1) # <class 'str'> 'RUNOOB'
    
    dict = { 'runoob': 'runoob.com', 'google': 'google.com'}
    res2 = repr(dict)
    print(type(res2),res2) # <class 'str'> {'google': 'google.com', 'runoob': 'runoob.com'}

## reverse 方法 ##

功能：reverse() 函数用于反向列表中元素

> 语法：list.reverse()

返回值：无

实例：

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    aList.reverse()
    print("List : ", aList) # List : ['xyz', 'abc', 'zara', 'xyz', 123]

## round 函数 ##

功能：round() 方法返回浮点数x的四舍六入值

> 语法：round( x \[, n\])

参数：  
x - - 数值表达式  
n - - 数值表达式，表示从小数点位数

返回值：返回浮点数 x 的四舍六入值

实例：

print("round(80.23456, 2) : ", round(80.23456, 2))
    print("round(100.000056, 3) : ", round(100.000056, 3))
    print("round(-100.000056, 3) : ", round(-100.000056, 3))

注意：round 函数是有一些坑的

round 的返回值很 python 版本有关系

例如 python 2.7 中 round 保留值将保留到离上一位更近的一端（四舍六入），如果距离两端一样远，则保留到离0远的一边。所以round(0.5)会近似到1，而round(-0.5)会近似到-1

但是在python 3.5 中 round 值，如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2

print("round(2.355,2):",round(2.355,2))#2.35
    print(round(2.675,2)) #2.67

总之尽量避免使用 round

还有其他选择

*  使用math模块中的一些函数，比如math.ceiling（天花板除法）
 *  python自带整除，python2中是/，3中是//，还有div函数
 *  字符串格式化可以做截断使用，例如 “%.2f” % value（保留两位小数并变成字符串……如果还想用浮点数请披上float()的外衣）
 *  对浮点数精度要求如果很高的话，用 decimal 模块

## set 函数 ##

功能：创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

> 语法：class set(\[iterable\]) iterable - - - 可迭代对象对象

返回值：返回新的集合对象

实例：

>>> x = set('eleven')
    >>> y = set('twelve')
    >>> x,y
    ({ 'l', 'e', 'n', 'v'}, { 'e', 'v', 'l', 't', 'w'})
    >>> x & y  #交集
    { 'l', 'e', 'v'}
    >>> x | y  #并集
    { 'e', 'v', 'n', 'l', 't', 'w'}
    >>> x - y  #差集
    { 'n'}
    >>> y -x   #差集
    { 't', 'w'}
    >>> x ^ y  #补集
    { 't', 'n', 'w'}
    >>> y ^ x  #补集
    { 'w', 'n', 't'}

交集 : x&y，返回一个新的集合，包括同时在集合 x 和y中的共同元素  
并集 : x|y，返回一个新的集合，包括集合 x 和 y 中所有元素。  
差集 : x-y，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素  
补集 : x^y，返回一个新的集合，包括集合 x 和 y 的非共同元素

## setattr 函数 ##

功能：setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的

> 语法：setattr(object, name, value)

object - - - - - 对象  
name - - - - - 字符串，对象属性  
value - - - - - 属性值

返回值：无

实例：

class A(object):
       bar = 1
    
    a = A()
    getattr(a, 'bar')          # 获取属性 bar 值 1
    setattr(a, 'bar', 5)       # 设置属性 bar 值
    print(a.bar)               # 5

实例2：会报一个警告(Unresolved attribute reference ‘age’ for class ‘A’ )

setattr(a, "age", 28)
    print(a.age)

## slice 函数 ##

功能：函数实现切片对象，主要用在切片操作函数里的参数传递

> 语法：  
> class slice(stop)  
> class slice(start, stop\[, step\])

参数：  
start - - - - 起始位置  
stop - - - - 结束位置  
step - - - - 间距

返回值：返回一个切片对象

实例

myslice = slice(5)      # 设置截取5个元素的切片
    arr = range(10)
    print(list(arr))              # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(list(arr[myslice]))     # 截取 5 个元素 [0, 1, 2, 3, 4]

## sorted 函数 ##

功能：对所有可迭代的对象进行排序操作

> sort 与 sorted 区别

*  sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
 *  list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作

> 语法：sorted(iterable, cmp=None, key=None, reverse=False)

参数

*  iterable - - 可迭代对象
 *  cmp - - - - - 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
 *  key - - - - - 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
 *  reverse - - – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

实例

a = [5, 7, 6, 3, 4, 1, 2]
    b = sorted(a)  # 保留原列表
    print(a)  #[5, 7, 6, 3, 4, 1, 2]
    print(b)  #[1, 2, 3, 4, 5, 6, 7]
    
    
    L = [('b', 2), ('c', 1), ('c', 3), ('d', 4)]
    l1 = sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数,python3.x 中已移除 cmp函数
    print(l1) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    
    l2 = sorted(L, key=lambda x: x[1],reverse=False)  # 利用 key [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    print(l2)
    
    students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    l3 = sorted(students, key=lambda s: s[2])  # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    print(l3)
    
    l4 = sorted(students, key=lambda s: s[2], reverse=True)  # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    print(l4)

## staticmethod 函数 ##

python staticmethod 返回函数的静态方法

该方法不强制要求传递参数，如下声明一个静态方法：

实例1：

class C(object):
        @staticmethod
        def f(arg1, arg2, ...):
            pass

以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()

> 语法：staticmethod(function)

参数：无

实例2：

class C(object):
        @staticmethod
        def f():
            print('runoob')
    
    C.f()       # 静态方法无需实例化
    cobj = C()
    cobj.f()    # 也可以实例化后调用

输出：  
runoob  
runoob

## str 函数 ##

功能：str() 函数将对象转化为适于人阅读的形式

> 语法：class str(object=’’) object 对象

返回值：返回一个对象的string格式

实例：

s = 'RUNOOB'
    str(s) #'RUNOOB'
    
    dict = { 'runoob': 'runoob.com', 'google': 'google.com'};
    str(dict) # "{'google': 'google.com', 'runoob': 'runoob.com'}"

## sum 方法 ##

功能：对序列进行求和计算

语法 : sum(iterable\[, start\])

参数：  
iterable - - - - 可迭代对象，如：列表、元组、集合  
start - - - - - - 指定相加的参数，如果没有设置这个值，默认为 0

返回值：返回计算结果

实例：

sum([0,1,2])             # 3 
    sum((2, 3, 4), 1)        # 元组计算总和后再加 1 10
    sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2 12

## super 函数 ##

功能：super() 函数是用于调用父类(超类)的一个方法

super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表

> 语法: super(type\[, object-or-type\])

参数：  
type - - - - - - - - - - 类  
object-or-type - - - 类，一般是 self

实例 1：Python3.x

class A:
        def add(self, x):
            y = x + 1
            print(y)
    class B(A):
        def add(self, x):
            super().add(x)
    b = B()
    b.add(2)  # 3

实例 2：Python2.x

class A(object):   # 记得继承 object
        def add(self, x):
             y = x + 1
             print(y)
    class B(A):
        def add(self, x):
            super(B, self).add(x)
    b = B()
    b.add(2)  # 3

返回值：无

实例3：

class FooParent(object):
        def __init__(self):
            self.parent = 'I\'m the parent.'
            print('Parent')
        def bar(self, message):
            print("%s from Parent" % message)
            
    class FooChild(FooParent):
        def __init__(self):
            # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），
            # 然后把类 FooChild 的对象转换为类 FooParent 的对象
            super(FooChild, self).__init__()
            print('Child')
    
        def bar(self, message):
            super(FooChild, self).bar(message)
            print('Child bar fuction')
            print(self.parent)
    if __name__ == '__main__':
        fooChild = FooChild()
        fooChild.bar('HelloWorld')
    ''' Parent Child HelloWorld from Parent Child bar fuction I'm the parent. '''

## tuple 方法 ##

描述：Python 元组 tuple() 函数将列表转换为元组

> 语法：tuple( iterable)

参数：要转换为元组的可迭代序列

返回值：返回元组

实例1：

>>>tuple([1,2,3,4])
    (1, 2, 3, 4)
    >>> tuple({ 1:2,3:4})    #针对字典 会返回字典的 key 组成的 tuple
    (1, 3)
    >>> tuple((1,2,3,4))    #元组会返回元组自身
    (1, 2, 3, 4)

实例2：

aList = [123, 'xyz', 'zara', 'abc'];
    aTuple = tuple(aList)
    print("Tuple elements : ", aTuple)
    # Tuple elements : (123, 'xyz', 'zara', 'abc')

提示：tuple() 函数不是改变对象的类型，而是返回改变类型后的对象，原对象不会被改变

test_list1 = ('a','b','c')
    test_list2 = ['x','y','z']
    test_tuple = tuple(test_list2)
    # test_list2 可以修改，tuple() 函数不是改变值的类型，而是返回改变类型后的值，原值不会被改变
    test_list2[2] = '这是修改的'
    #下面这行报错，元组不可修改
    # test_list1[2]='这是修改的'
    print(test_list1)
    print(test_list2)
    print(test_tuple)

## type 函数 ##

功能：type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象

> isinstance() 与 type() 区别：

*  type() 不会认为子类是一种父类类型，不考虑继承关系。
 *  isinstance() 会认为子类是一种父类类型，考虑继承关系。
 *  如果要判断两个类型是否相同推荐使用 isinstance()

语法：  
type(object)  
type(name, bases, dict)

参数：  
name - - - - - 类的名称  
bases - - - - 基类的元组  
dict - - - - - - 字典，类内定义的命名空间变量

返回值：一个参数返回对象类型, 三个参数，返回新的类型对象

## unichr 函数 ##

功能： unichr() 函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符

注意： Python3 不支持 unichr()，改用 chr() 函数

> 语法：unichr(i) i - - - 可以是10进制也可以是16进制的形式的数字

返回值：返回 unicode 的字符

实例：

'''python2.x 写法'''
    unichr(97) #u'a'
    unichr(98) #u'b'
    unichr(99) #u'c'
    
    '''python3.x写法'''
    c1 = chr(97)
    c2 = chr(98)
    c3 = chr(99)
    print(c1,c2,c3) #a b c

## vars 函数 ##

功能：返回对象 object 的属性和属性值的字典对象

> 语法：vars(\[object\]) object - - - 对象

返回值：返回对象 object 的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()

实例：

print(vars())
    ''' {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None} '''
    class Runoob:
        a = 1
    print(vars(Runoob)) # {'a': 1, '__module__': '__main__', '__doc__': None}
    runoob = Runoob()
    print(vars(runoob))  #{}

## xrange 函数 ##

用法和 range 相同，只不过返回值是一个生成器，需要转换成 list 列表

## zip 函数 ##

功能：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 \* 号操作符，可以将元组解压为列表

> zip 方法在 Python 2 和 Python 3 中的不同

*  在 Python 3.x 中为了减少内存，zip() 返回的是一个对象
 *  如需展示列表，需手动 list() 转换。

语法：zip(\[iterable, …\]) iterabl – 一个或多个迭代器;

返回值：返回元组列表

实例1：

>>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 打包为元组的列表
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(a,c)              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
    [(1, 2, 3), (4, 5, 6)]

实例2：

# 可以用于对二维列表（矩阵）取列:
    matrix = [[1,2,3],[4,5,6],[7,8,9]]
    print(zip(*matrix))
    # 输出结果:
    [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

## \_\_import\_\_ 函数 ##

功能：用于动态加载类和函数 ，如果一个模块经常变化就可以使用\_\_import\_\_() 来动态载入

语法:\_\_import\_\_(name\[, globals\[, locals\[, fromlist\[, level\]\]\]\])

name 为模块名

返回值：返回元组列表

实例

a.py 文件代码：

#!/usr/bin/env python 
    #encoding: utf-8 
     
    import os  
     
    print ('在 a.py 文件中 %s' % id(os))

test.py 文件代码：

#!/usr/bin/env python 
    #encoding: utf-8 
     
    import sys  
    __import__('a')        # 导入 a.py 模块