python-函数内置方法

 　　　　　　　　　　　　　　　　函数的内置方法

 

 

查看菜鸟教程里面的内置方法

 

abs()：

绝对值函数。如abs（-1）= 1

>>> abs(-10)
10
>>> f = abs
>>> f(-1)
1
>>> abs=id
>>> abs(1)
1869788224

以abs()函数为例，展示两个特性。一是，内置函数是可以被赋值给其他变量的，同样也可以将其他对象赋值给内置函数，这时就完全变了。所以，内置函数不是Python关键字，要注意对它们的保护，不要使用和内置函数重名的变量名，这会让代码混乱，容易发生难以排查的错误。

all()

接收一个可迭代对象，如果对象里的所有元素的bool运算值都是True，那么返回True，否则False。不要小瞧了这个函数，用好了，有化腐朽为神奇的特效。

>>> all([1,1,1])
True
>>> all([1,1,0])
False

any()

接收一个可迭代对象，如果迭代对象里有一个元素的bool运算值是True，那么返回True，否则False。与all()是一对兄弟。

>>> any([0,0,1])
True
>>> any([0,0,0])
False

ascii()

调用对象的__repr__()方法，获得该方法的返回值。__repr__()方法是由对象所属类型实现的方法。不可以简单地理解为print或echo。

>>>s = “haha”
>>> ascii(s)
"'haha'"
>>> a = [1,2,3]
>>> ascii(a)
'[1, 2, 3]'

bin()、oct()、hex()

三个函数是将十进制数分别转换为2/8/16进制。

>>> i = 10
>>> bin(i)
'0b1010'
>>> oct(i)
'0o12'
>>> hex(i)
'0xa'

bool()

测试一个对象或表达式的执行结果是True还是False。实际上bool是一个类，不是函数，bool()的返回值是一个布尔类型的实例。builtins中的很多函数，其实都是类，比如bytes()，str()等等。其中bool对于一个空列表或者带有0的列表，返回的是False。

 

>>> bool(1==2)
False
>>> bool(abs(-1))
True
>>> bool(None)
False
>>>a = []
>>>bool(a)
False

bytearray()

描述

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

语法

bytearray()方法语法：

　　

class bytearray([source[, encoding[, errors]]])

参数

• 如果 source 为整数，则返回一个长度为 source 的初始化数组；
• 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
• 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
• 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
• 如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值

返回新字节数组。

实例

以下实例展示了 bytearray() 的使用方法：

>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')
>>>

bytes()

将对象转换成字节类型。例如：s = '张三';m = bytes(s,encoding='utf-8')

>>> i=2
>>> bytes(i)
b'\x00\x00'
>>> s = 'haha'
>>> bytes(s)

Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    bytes(s)
TypeError: string argument without an encoding

>>> bytes(s, encoding="utf-8")
b'haha'
>>> bytes(s, encoding="GBK")
b'haha'

str()

将对象转换成字符串类型，同样也可以指定编码方式。例如：str(bytes对象，encoding='utf-8')

>>> i =  2
>>> str(i)
'2'
>>> b = b"haha"
>>> str(b)      # 注意！
"b'haha'"
>>> str(b,encoding="gb2312")
'haha'
>>> str([1,2,3,])
'[1, 2, 3]'

Bytes和string之间的互相转换，更多使用的是encode()和decode()方法。

callable()

判断对象是否可以被调用。如果某个对象具有__call__方法，那它就能被调用。 例如，def f1(): pass,那么callable(f1)返回True。常用于判断一个变量是否是函数。函数可调用。

>>> def f1():
    pass
>>> callable(f1)
True
>>> a = "123"
>>> callable(a)
False
>>> class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age       
>>> f_obj = Foo("jack",20)
>>> callable(f_obj)
False
>>> callable(Foo)
True

chr()

返回某个十进制数对应的ASCII字符，例如：chr(99) = ‘c’。它可以配合random.randint(65，91)随机方法，生成随机字符，用于生产随机验证码。

mport random
for i in range(10):
    a = random.randint(65,91)
    c = chr(a)
    print(c)

ord()

与chr()相反，返回某个ASCII字符对应的十进制数，例如，ord('A') = 65

>>> ord("A")
65
>>> ord("\n")
10

classmethod()、staticmethod()和property()

类机制中，用于生成类方法、静态方法和属性的函数。在面向对象章节会有详细介绍。

compile()

将字符串编译成Python能识别或执行的代码。 也可以将文件读成字符串再编译。

>>> s  = "print('helloworld')"
>>> r = compile(s,"<string>","exec")
>>> r
<code object <module> at 0x000001B23E6BE660, file "<string>", line 1>

>>> r()
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    r()
TypeError: 'code' object is not callable

>>> exec(r)
helloworld

>>> eval(r)
helloworld

complex()

通过数字或字符串生成复数类型对象。

 

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

使用字符串的时候，+号左右不能有空白。

delattr()、setattr()、getattr()、hasattr()

类机制中，分别用来删除、设置、获取和判断属性。后面会有详解。

dir()

查看详细介绍

显示对象所有的属性和方法。打印当前程序的所有变量。最好用的辅助函数之一。

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'builtins', 'r', 's']
 
>>> dir([1,2,])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

nt()、float()、list()、dict()、set()、tuple()

与bool()、str()、bytes()一样，它们都是实例化对应数据类型的类。

divmod()

除法，同时返回商和余数的元组。

>>> divmod(10,3)
(3, 1)
>>> divmod(11,4)
(2, 3)

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

Python 2.3. 以上版本可用，2.6 添加 start 参数。

语法

以下是 enumerate() 方法的语法:

enumerate(sequence, [start=0])

参数

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置。

# 实例
# 以下展示了使用 enumerate() 方法的实例：
 
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
 
# 普通的 for 循环
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
...     print i, seq[i]
...     i +=1
...
0 one
1 two
2 three
 
# for 循环使用 enumerate
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
...
0 one
1 two
2 three

通常用于对那些无法提供序号的迭代对象使用。但对于字典，依然是无序的。

eval()

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

语法

以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])

参数

• expression -- 表达式。
• globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值

返回表达式计算结果。

实例

以下展示了使用 eval() 方法的实例：

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
 4
>>> eval('2 + 2')
 4
>>> n=81
>>> eval("n + 4")
85

exec()

描述

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

需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个

execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的

exec() 函数中去了。

 

语法

以下是 exec 的语法:

exec obj

参数

• obj -- 要执行的表达式。

返回值

exec 返回值永远为 None。

实例

以下展示了使用 exec 的实例：

实例 1

>>>exec 'print "Hello World"'
Hello World
# 单行语句字符串
>>> exec "print 'runoob.com'"
runoob.com
  
#  多行语句字符串
>>> exec """<br>...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

实例 2

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
     
func()
 
输出结果：
 
60
33
34

eval() exec() 

eval()只能处理单行代码而exec()可以处理多行代码

eval()有返回值，exec没有返回值

res = eval('1+3+2')
res2 = exec('1+3+2')
print('res', res, res2)
 
# 执行结果
res 7 None

format()

查看详细讲解

执行format()，其实就是调用该对象所属类的__format__方法。类似print功能。

>>> format("324324")
'324324'
>>> format([1,2,3])
'[1, 2, 3]'

frozenset()

描述

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

语法

frozenset() 函数语法：

class frozenset([iterable])

参数

• iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值

返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

实例

以下实例展示了 frozenset() 的使用方法：

>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>

globals()

列出当前环境下所有的全局变量。注意要与global关键字区分！在本节的开始，我们就已经展示了它的用法。

hash()

为不可变对象，例如字符串生成哈希值的函数！

>>> hash("i am jack")
5602200374213231465
>>> hash(1)
1
>>> hash(100000)
100000
>>> hash([1,2,3,])
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    hash([1,2,3,])
TypeError: unhashable type: 'list'
>>> hash((1,2,3))
2528502973977326415

help()

返回对象的帮助文档。谁用谁知道！

>>> a = [1,2,3]
>>> help(a)
Help on list object:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 ...

id()

返回对象的内存地址,常用来查看变量引用的变化，对象是否相同等。常用功能之一！

>>> id(0)
1456845856
>>> id(True)
1456365792
>>> a = "Python"
>>> id(a)
37116704

input()

接收用户输入，返回一个输入的字符串。

a = input("Please input a number:  ")
Please input a number:  100
>>> a
'100'
>>> type(a)
<class 'str'>

isinstance()

判断一个对象是否是某个类的实例。比type()方法适用面更广。

>>> isinstance("haha", str)
True
>>> isinstance(1, str)
False

issubclass()

issubclass(a，b),判断a是否是b的子类。

>>> class Foo:
    pass
>>> class Goo(Foo):
    pass
>>> issubclass(Goo, Foo)
True

iter()

制造一个迭代器，使其具备next()能力。

>>> lis = [1, 2, 3]
>>> next(lis)

Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    next(lis)
TypeError: 'list' object is not an iterator

>>> i = iter(lis)
>>> i
<list_iterator object at 0x0000000002B4A128>
>>> next(i)
1

len()

返回对象的长度。不能再常用的函数之一了。

locals()

locals() 函数会以字典类型返回当前位置的全部局部变量。简单点就是返回局部变量。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

返回值：字典类型的局部变量

>>>def runoob(arg):    # 两个局部变量：arg、z
...     z = 1
...     print (locals())
...
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
>>>

max()/min():

返回给定集合里的最大或者最小的元素。可以指定排序的方法！

max() 方法返回给定参数的最大值，参数可以为序列。

print "max(80, 100, 1000) : ", max(80, 100, 1000)

max(80, 100, 1000) :  1000

 

min() 方法返回给定参数的最小值，参数可以为序列。

print "min(80, 100, 1000) : ", min(80, 100, 1000)

min(80, 100, 1000) :  80

 

lst=['abcdhush8','abc9iujtwertwert','abcdjlas','abcdj897h']
a = min(lst,key=len)
print(a)

memoryview(obj)

返回obj的内存视图对象。obj只能是bytes或bytesarray类型。memoryview对象的使用方法如下：

>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'

next()

通过调用迭代器的__next__()方法，获取下一个元素。

object()

该方法不接收任何参数，返回一个没有任何功能的对象。object是Python所有类的基类。

open()

打开文件的方法。在Python2里，还有一个file()方法，Python3中被废弃了。后面章节会详细介绍open()的用法。

pow()

幂函数。

>>> pow(3, 2)
9

print()

语法

以下是 print() 方法的语法:

print(*objects, sep=' ', end='\n', file=sys.stdout)

参数

• objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep -- 用来间隔多个对象，默认值是一个空格。
• end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file -- 要写入的文件对象。

>>> print("www","runoob","com",sep=".")  # 设置间隔符
www.runoob.com>
>>print(1)
1
 >>>print("Hello World")
 Hello World

>>> a = 1 
>>> b = 'runoob' 
>>> print(a,b)
 1 runoob
>>> print("aaa""bbb")
 aaabbb 
>>> print("aaa","bbb")
 aaa bbb

range()

没错，这是Python内置的函数，前面已经介绍了。

repr()

repr() 函数将对象转化为供解释器读取的形式。并且返回一个对象的 string 格式。

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

reversed()

反转，逆序对象

>>> reversed            # reversed本身是个类
<class 'reversed'>
>>> reversed([1,2,3,4,5])   # 获得一个列表反转器
<list_reverseiterator object at 0x0000022E322B5128>
>>> a = reversed([1,2,3,4,5])
>>> a
<list_reverseiterator object at 0x0000022E32359668>
>>> list(a)         # 使用list方法将它转换为一个列表
[5, 4, 3, 2, 1]

round()

描述

round() 方法返回浮点数x的四舍五入值。

语法

以下是 round() 方法的语法:

round( x [, n] )

参数

• x -- 数值表达式。
• n -- 数值表达式。

返回值

返回浮点数x的四舍五入值。

a = round(2.33333, 2)
print(a)
 
b = round(3.555, 1)
print(b)
 
# 执行结果
2.33
3.6

slice()

返回一个切片类型的对象。slice是一个类，一种Python的数据类型。Python将对列表等序列数据类型的切片功能单独拿出来设计了一个slice类，可在某些场合下使用。

slice 语法：

class slice(stop) class slice(start, stop[, step])

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

sum()

求和．

>>> sum(1,2,3)          # 需要传入一个可迭代的对象
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    sum(1,2,3)
TypeError: sum expected at most 2 arguments, got 3
>>> sum([1,2,3])            # 传入一个列表
6
>>> sum({1:1,2:2})          # 突发奇想，作死传入一个字典
3

 

super()

调用父类。面向对象中类的机制相关。后面介绍。

type()

显示对象所属的数据类型。常用方法！前面已经展示过。

vars()

与dir()方法类似，不过dir()方法返回的是key，vars()方法返回key的同时还把value一起打印了

vars() 函数语法：

vars([object])

>>>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))
{}

map()

描述

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法

map() 函数语法：

map(function, iterable, ...)

参数

• function -- 函数，有两个参数
• iterable -- 一个或多个序列

返回值

Python 2.x 返回列表。

Python 3.x 返回迭代器。

实例

以下实例展示了 map() 的使用方法：

 

>>>def square(x) :            # 计算平方数
...     return x ** 2
...
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
  
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

 

filter()

描述

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

• function -- 判断函数。
• iterable -- 可迭代对象。

返回值

返回列表。

实例

以下展示了使用 filter 函数的实例：

过滤出列表中的所有奇数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
  
def is_odd(n):
    return n % 2 == 1
  
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
 
#执行结果
[1, 3, 5, 7, 9]　

过滤出1~100中平方根是整数的数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
  
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
  
newlist = filter(is_sqr, range(1, 101))
print(newlist)
 
# 输出结果 ：
 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

zip()

描述

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

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

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

如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。

语法

zip 语法：

zip([iterable, ...])

参数说明：

• iterabl -- 一个或多个迭代器;

返回值

返回元组列表。

实例

以下实例展示了 zip 的使用方法：

>>>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)]

sorted()

排序方法。有key和reverse两个重要参数。

基础用法: 直接对序列进行排序

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

指定排序的关键字。关键字必须是一个可调用的对象。例如下面的例子，规则是谁的绝对值大，谁就排在后面。

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
 
# 或者可以使用lambda函数指定列表的那个排序

d = {}
for i in range(10):
    d[i] = i - 50
print(d)
d2 = d.items()
d[2] = 5
d3 = sorted(d2, key=lambda x:x[1])　　# key后面还可以添加recerse = True进行反转排序
print(d3)

# 执行结果
# {0: -50, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
# [(0, -50), (1, -49), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41), (2, 5)]

指定按反序排列。下面的例子，首先按忽略大小写的字母顺序排序，然后倒序排列。

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

描述

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

语法

hash 语法：

hash(object)

参数说明：

• object -- 对象；

返回值

返回对象的哈希值。

实例

以下实例展示了 hash 的使用方法：

>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378

__import__(name)

这个方法为我们提供了一种通过字符串反射包、库或模块的手段。其中的name是你想要导入的库的名称的字符串。

t = __import__("time")
print(t.time())

例子中，利用字符串“time”，导入了实际的time库，并赋值给t变量。这个变量实际就相当于import time的结果。然后使用t.time()进行调用。

在某些场景下，这个方法非常有用。但是很多时候，它也存在安全问题，Python官方不建议经常使用它。

至此，除了个别遗留，近80个内置函数就基本介绍完毕。