Python 内置函数详解 3

repr 函数

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

语法：repr(object) object 对象

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

实例：

s = 'RUNOOB'
res1 = repr(s)
print(type(res1),res1) #  'RUNOOB'

dict = {'runoob': 'runoob.com', 'google': 'google.com'}
res2 = repr(dict)
print(type(res2),res2) #  {'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__': ,
'__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 模块

在 a.py 文件中 4394716136

exec 内置语句

功能：执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码

语法: exec obj

参数:要执行的表达式

返回值为 None