Python教程033 python内置函数2

delattr(object, name)

删除对象的属性。delattr(x, ‘foobar’) 相当于del x.foobar

dict()

用于创建一个字典。

dict函数语法：

1
2
3


dict(**kwarg)  
dict(mapping, **kwarg)  
dict(iterable, **kwarg)

参数说明：
**kwargs – 关键字参数。
mapping – 元素的容器。
iterable – 可迭代对象。

例如：

1
2
3
4
5
6
7
8


>>>dict() #创建空字典
{}
>>> dict(a='a', b='b', t='t') #传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) #映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) #可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

dir()

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法dir()，该方法将被调用。如果参数不包含dir()，该方法将最大限度地收集参数信息。

例如：

1
2
3
4


>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

divmod(a, b)

分别取商和余数，返回值是元组。
对于整数来说，相当于(a // b, a % b)。
对于浮点数来说，相当于(q, a % b)。

例如：

1
2
3
4
5


a = 5
b = 2
result = divmod(a,b)
print(type(result))
print(result)

执行以上程序会输出如下结果：

1
2


<class 'tuple'>
(2, 1)

enumerate(iterable, start=0)

返回enumerate对象。iterable必须是序列、迭代器或其他支持迭代的对象。enumerate()返回的迭代器的next()方法返回一个包含计数（默认为0）和通过迭代iterable获得的值的元组。start指定从那个数字开始，默认为0。

例如：

1
2
3
4
5


my_list = ['apple', 'banana',]
e  =  enumerate(my_list, 3)
print(type(e))
print(e.__next__())
print(e.__next__())

执行以上程序会输出如下结果：

1
2
3


<class 'enumerate'>
(3, 'apple')
(4, 'banana')

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

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

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

例如：

1
2


a=10;
print(eval("a+1"))   # 执行结果为：11

1
2
3


a=10;
g={'a':4}
print(eval("a+1",g)) # 执行结果为：5

1
2
3
4
5
6


a=10
b=20
c=30
g={'a':6,'b':8}
t={'b':100,'c':10}
print(eval('a+b+c',g,t)) # 执行的结果为：116

exec(object[, globals[, locals]])

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

参数
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后再执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


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

结果如下

float([x])

函数用于将整数或字符串转换成浮点数。如果参数是字符串，它应该包含一个十进制数字，可以选择在前面加一个符号，也可以选择嵌入空白。可选符号可以是“+”或“-”。“+”符号对生成的值没有影响。参数也可以是表示NaN（非数字）或正无穷大或负无穷大的字符串。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

format(value[, format_spec])

依照format_spec格式来格式化value。format_spec的解释将取决于值value参数的类型。format(value, format_spec)相当于 type(value).__format__(value, format_spec) 。其中，type(value)意味着使用value的type类的format()方法。

frozenset()

创建一个不可修改的集合。set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，一般来说使用fronzet的地方都可以使用set。

1
2


>>> frozenset([1,2,3])
frozenset({1, 2, 3})

getattr(object, name[, default])

返回对象的属性的值。name必须是字符串例如，getattr（x，’foobar’）相当于x.foobar。如果命名属性不存在，则返回default（如果提供），否则将引发attributeError。

hasattr(object, name)

如果字符串是对象某个属性的名称，则结果True；否则为False。

hash(object)

返回对象的哈希值（如果有）。哈希值是整数。它们用于在字典查找期间快速比较字典键。不同类型的值，具有相同的哈希值（int 1和float 1.0,具有相同的hash值）。可哈希的即不可变数据类型，不可哈希即可变数据类型。

hex()

将整数转换为前缀为“0x”的小写十六进制字符串。如果x不是int对象，它必须定义一个返回整数的index()方法。

例如：

1
2
3
4


>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

id(object)

返回对象的“标识”。这是一个整数，它保证在这个对象的生存期内是唯一的和不变的。生命周期不重叠的两个对象可能具有相同的id（）值。不同的解释器，实现是不一样的。Cpython解释器中的id返回的是对象的内存地址。

input([prompt])

接受一个标准输入数据，返回为string类型。

例如：

1
2
3
4
5
6
7
8


>>>a = input("input:")
input:123 # 输入整数
>>> type(a)
<type 'int'> # 整型
>>> a = input("input:")
input:"runoob" # 正确，字符串表达式
>>> type(a)
<type 'str'> # 字符串

int([x]) int(x, base=10)

返回一个由数字或字符串x构造的整数，如果没有给定参数，则返回0。如果x定义了int(),int(x)返回x。如果x定义了trunc(),则返回x.__trunc__()。对于浮点数，返回整数部分。

例如：

1
2
3
4
5


int("1000")           # 1000
int('100', base=8)    # 64
int('100', base = 2)  # 4
int()                 # 0
int(3.2)              # 3

注意
oct，hex，bin函数返回值是字符串。
int函数返回值是数值。

isinstance(object, classinfo)

来判断一个对象是否是一个已知的类型，类似type()。isinstance()会认为子类是一种父类类型，考虑继承关系。classinfo参数可以是一个Tuple，元素可以是重复的。

例如：

1
2
3
4
5
6
7


>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>>isinstance (a,(str,int,list,str)) # 是元组中的一个返回True,str类型有两个。
True

issubclass(class, classinfo)

用于判断参数class是否是类型参数classinfo的子类。类本身也会返回True。

例如：

1
2
3
4
5
6
7
8


class A:
    pass

class B(A):
    pass

print(issubclass(B,A)) # 返回True
print(issubclass(A,A)) # 返回True

iter(object[, sentinel])

返回迭代器对象。根据第二个参数的存在，第一个参数的解释非常不同。
如果没有第二个参数sentinel，object必须是支持迭代协议的集合对象（__iter__方法），或者必须支持序列协议（__getItem__方法，整数参数从0开始）。否则，抛出TypeError异常。如果给出了第二个参数sentinel，那么object必须是可调用对象。在这种情况下创建的迭代器将调用对象，每次调用其__next__()时都不带参数；如果返回的值等于sentinel，则将引发StopIteration，否则将返回该值。例如，利用第二个参数创建一个阅读器。

1
2
3
4


from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), ''):
        process_block(block)

len()

返回对象（字符、字节，列表、元组、range对象，set，frozen set，字典等）长度或项目个数。

例如：

1
2
3
4
5
6


>>>s = "runoob"
>>> len(s) #字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l) #列表元素个数
5

list([iterable])

用于将元组或字符串转换为列表。

例如：

1
2
3
4
5
6


aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print("列表元素 : ", list1)
str="Hello World"
list2=list(str)
print("列表元素 : ", list2)

结果如下

1
2


列表元素 : [123, 'Google', 'Runoob', 'Taobao']
列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

locals()

以字典类型返回当前位置的全部局部变量。

例如：

1
2
3
4
5
6


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

max(iterable, [, key, default])或max(arg1, arg2, args[, key])

返回给定参数的最大值，参数可以为序列。

例如：

1
2


print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))

结果

1
2


max(80, 100, 1000) : 1000
max(-80, -20, -10) : -10

memoryview()

返回对象obj的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用

例如：

1
2


print(memoryview(b'aabc'))      # <memory at 0x00000185CCC95408>
print(list(memoryview(b'abc'))) # [97, 98, 99]

min(iterable, [, key, default])或min(arg1, arg2, args[, key])

返回给定参数的最小值，参数可以为序列。

例如：

1
2


print("min(80, 100, 1000) : ", min(80, 100, 1000))
print("min(-80, -20, -10) : ", min(-80, -20, -10))

结果

1
2


min(80, 100, 1000) : 80
min(-80, -20, -10) : -80

next(iterator[, default])

通过调用迭代器的next()方法，返回迭代器的下一个项目。如果给定默认值，则在迭代器耗尽时返回，否则将引发StopIteration异常。

object()

返回一个新的无特征对象。对象是所有类的父类。它具有所有Python类实例通用的方法。此函数不接受任何参数。object没有dict属性，因此不能将任意属性分配给对象类的实例。

oct(x)

将整数转换为以“0o”为前缀的八进制字符串。如果x不是int对象，它必须定义一个返回整数的index()方法。

例如：

1
2
3
4


>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

转载请注明本网址。

文章目录