【转载】Python3内建函数

最新推荐文章于 2024-04-16 02:46:11 发布
最新推荐文章于 2024-04-16 02:46:11 发布
阅读量312 收藏
点赞数
分类专栏： Python 文章标签： Python 内建函数

原文链接：Python标准库(3.x): 内建函数扫盲

Built-in Functions
abs()dict()help()min()setattr()
all()dir()hex()next()slice()
any()divmod()id()object()sorted()
ascii()enumerate()   
input()oct()staticmethod() 
bin()eval()int()open()str()
bool() exec() isinstance()  ord() sum() bytearray() filter() issubclass()  pow() super() bytes() float() iter() print() tuple() callable() format() len() property()    
type() chr() frozenset() list() range() vars() classmethod()  getattr() locals() repr() zip() compile() globals() map() reversed()     complex() hasattr() max() round()   delattr() hash() memoryview() set()  

 

abs(x)

　　求一个数的绝对值。

>>> abs(13)
13
>>> abs(-15)
15

all(iterable)

　　如果迭代器中的所有值都为“真”则返回 True, 否则返回 False

　　注意: 如果迭代器为空，返回 True

复制代码 
>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True
复制代码

any(iterable)

　　如果迭代器中的任意一个值为“真”则返回 True, 否则返回 False

　　注意: 如果迭代器为空，返回 False

复制代码 
>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False
复制代码

ascii(object)

　　该函数返回表示对象的可打印ascii字符串，如果字符串中含有非ascii字符，则以\x, \u 或者 \U 编码来表示

　　函数其实是返回了对象的 __repr__() 方法的值

复制代码 
>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>> 
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world.'
... 
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'
复制代码

bin(x)

　　将整型转换为二进制的字符串，字符串以'0b' 开头.

　　不过说是将整型转换为二进制，其实是将对象的__index__() 方法返回的值转换为二进制字符串

　　注意: 如果对象没有__index__() 方法，将会产生异常

复制代码 
>>> bin(11)
'0b1011'
>>> class MyTest():
...     def __index__(self):
...         return 5
... 
>>> t = MyTest()
>>> bin(t)
'0b101'
复制代码

 bool(x)

　　如果对象为“真”则返回 True, 否则返回 False

>>> bool(0)
False
>>> bool(1)
True

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

　　创建一个 “可变的” byte数组，可以使用整型，字符串和迭代器来初始化

　　参数为字符串时，字符串中的每一个字符将转换为数组的元素，因此需要提供编码类型，类似utf-8, ascii等

　　参数为整型时，整形值将作为数组的初始化大小，数组的元素则初始化为0

　　参数为迭代器时，迭代器的每一个元素将作为数组的元素，因此迭代器的值必须为0-255的整型，否则将产生异常。

复制代码 
>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')
复制代码

bytes([source[, encoding[, errors]]])

　　bytes是bytearray的一个不可变的版本，其他的可以参考bytearray

复制代码 
>>> d = bytes([1,2,3])
>>> d
b'\x01\x02\x03'
>>> d[1] = 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
复制代码

callable(object)

　　判断对象是否可以调用，如果可以则返回 True, 否则返回 False

　　类是可调用的，调用后返回一个类的实例。对象如果包含了__call__() 方法也是可调用的。

　　其实，只要可以写成 object() 的，都是callable的

复制代码 
>>> def foo():
...     pass
... 
>>> callable(foo)
True
>>> 
>>> class MyTest:
...     def __call__(self):
...         pass
... 
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>> 
>>> b = 1
>>> callable(b)
False
复制代码

 chr(i)

　　返回Unicode对应的字符。

　　参数范围为 0 -- 1114111, 超过此范围将产生异常

复制代码 
>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)
复制代码

classmethod(function)

　　一般作为函数装饰器 @classmethod

　　将类中的一个方法指定为类方法。被指定的类方法第一个参数必须为cls(方法所在的类)

　　类方法的调用可以直接通过类调用，即C.f(); 也可以通过实例调用，即C().f()

　　类方法有一个比较方便的用处就是作为类似C++中的初始化函数重载

复制代码 
class MyTest():
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day 

@classmethod
</span><span style="color: #0000ff">def</span><span style="color: #000000"> from_string(cls, date_string):
    year, month, day </span>= map(int, date_string.split(<span style="color: #800000">'</span><span style="color: #800000">-</span><span style="color: #800000">'</span><span style="color: #000000">))
    </span><span style="color: #0000ff">return</span><span style="color: #000000"> cls(year, month, day)

</span><span style="color: #0000ff">def</span><span style="color: #000000"> output(self):
    </span><span style="color: #0000ff">print</span>(<span style="color: #800000">'</span><span style="color: #800000">Birthday: {}-{}-{}</span><span style="color: #800000">'</span><span style="color: #000000">.format(self.year, self.month, self.day))

>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>>
>>> b = MyTest.from_string(‘1990-1-1’)
>>> b.output()
Birthday: 1990-1-1

复制代码

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

　　该函数将含有python语句的字符串编译成可执行的字节码，编译的结果配合 eval, 或 exec 使用。

　　source -- 需要编译的字符串

　　filename -- 存储字符串的文件

　　mode -- 'eval' 配合 eval 使用, 'exec' 配合多语句的 exec 使用，'single' 配合单语句的 exec 使用

　　注：实测中，编译的时候会判断mode, 但是执行的时候使用 exec 或者 eval，结果一样

复制代码 
>>> a = compile('1+2', filename='',  mode='eval')
>>> eval(a)
3
>>> 
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>> 
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.
复制代码

complex([real[, imag]])

　　返回一个复数。复数值为  real + imag*1j

　　参数也可以为一个表示复数的字符串，但是字符串中不能有空格。使用字符串作为参数时，没有第二个参数。

　　注1: 两个参数的缺省值均为0

　　注2: 直接用复数表达式 a+bj 创建的对象也是 complex 类型

复制代码 
>>> a = complex(1, 2)
>>> a
(1+2j)
>>> 
>>> b = 2+3j
>>> type(b)
<class 'complex'>
>>> 
>>> c = complex('5+6j')
>>> c
(5+6j)
>>> 
>>> d = complex(1+2j, 1+2j)
>>> d
(-1+3j)
复制代码

delattr(object, name)

　　删除对象的一个属性（不能是对象的方法），但是不会影响该类的其他对象。同 del object.name

　　注: 参数 name 是一个字符串

复制代码 
>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>> 
>>> b.test
'test'
复制代码

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

　　创建并返回一个字典对象。初始化参数可以有三种传入方式。

　　关键字方式，将直接根据关键字生成字典

　　迭代器方式，迭代器中的对象必须只有两个元素，第一个元素将作为key，第二个作为值

　　映射方式，其实也是一种迭代器方式

　　注: 当然也可以直接使用字典作为参数来初始化

复制代码 
>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>> 
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}
复制代码

dir([object])

　　很有用的帮助函数。显示当前命名空间，对象或者类的所有属性和方法。

　　object 可以为对象或者类，如果省略表示当前的命名空间

复制代码 
>>> class MyTest():
...     pass
... 
>>> def foo():
...     pass
... 
>>> a = 1
>>> 
>>> dir()
['MyTest', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo']
>>> 
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> 
>>> d = dict()
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
复制代码

divmod(a, b)

　　返回 (a // b, a % b) 的元组

　　注：a，b可以为整型或者浮点型，但是不能是复数

复制代码 
>>> divmod(7, 3)
(2, 1)
>>> 
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>> 
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)
复制代码

enumerate(iterable, start=0)

　　返回一个可迭代的枚举类型。

　　迭代器中的对象，第一个元素为序号（默认从start=0开始），第二个元素为传入迭代器中的对象。

　　注: 多用于for遍历过程中，需要同时得到序号的情况。

复制代码 
>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
...     print(i ,name)
... 
1 Tom
2 Jack
3 Lily
复制代码

eval(expression, globals=None, locals=None)

　　将一个表示python表达式的字符串编译成python语句并执行（慎用！）

　　返回值，如果传入参数是字符串或者mode='eval'编译的字节码，则返回交互式运行结果，否则返回None

　　globals和locals为高级用法，此处不展开。默认使用当前命名空间。

　　注1: 语句必须是单条语句

　　注2: 字符串中可以带入变量，但变量必须在命名空间中定义。

　　注3: 可以配合compile()使用

>>> eval('2+5')
7
>>> x = 3
>>> eval('x**2 + 3*x + 5')
23

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

　　将一个表示python表达式的字符串编译成python语句并执行（慎用！）

　　返回值为None

　　globals和locals为高级用法，此处不展开。默认使用当前命名空间。

　　注1: 语句可以是多条

　　注2: 字符串中可以带入变量，但变量必须在命名空间中定义。

　　注3: 可以配合compile()使用

复制代码 
>>> exec('for i in range(5): print(i)')
0
1
2
3
4
复制代码

filter(function, iterable)

　　将一个可迭代的对象按传入的函数进行过滤。函数返回 True 的元素将保留，其它将被过滤掉。

>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]

float([x])

　　创建并返回一个浮点型的对象。

　　x可以为一个数或者一个表示浮点数的字符串，缺省值为0

>>> float(3)
3.0
>>> float('1.23')
1.23

format(value [, format_spec])

　　将value按格式化转化为字符串，并返回。

　　目前较多的用法是调用字符串的format方法。

　　format_spec 指定格式化方式，此处不展开（将会有专题博文）。

>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'

frozenset([iterable])

　　传入一个可迭代的对象，创建一个不可变的集合。除了元素不能添加删除外，其他和可变集合类似。

　　如果没有参数，则创建一个空集合。

>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True

getattr(object, name [, default])

　　获取对象的一个属性的值。

　　如果对象存在该属性则返回属性值。

　　如果属性不存在，当传了default时返回default的值，否则产生异常。

　　注:参数 name 是一个字符串

复制代码 
>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> getattr(a, 'test')
'test'
>>> getattr(a, 'foo', 'attr not exist')
'attr not exist'
>>> 
>>> getattr(a, 'foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'foo'
复制代码

globals()

　　返回当前全局域的{对象: 值} 字典

>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}

hasattr(object, name)

　　判断一个对象是否存在指定的属性。存在返回 True, 否则返回 False

　　注: 参数name 是一个字符串

复制代码 
>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False
复制代码

hash(object)

　　返回一个对象的hash值，如果对象不可hash会产生异常。

复制代码 
>>> hash(10)
10
>>> 
>>> hash('test')
2595417156033713210
>>> 
>>> hash((1,2,3))
2528502973977326415
>>> 
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
复制代码

help([object])

　　显示对象的帮助信息。如果没有参数则进入帮助的交互模式。

复制代码 
>>> help(eval)

Help on built-in function eval in module builtins:

eval(source, globals=None, locals=None, /)
Evaluate the given source in the context of globals and locals.

The source may be a string representing a Python expression
</span><span style="color: #0000ff">or</span><span style="color: #000000"> a code object as returned by compile().
The globals must be a dictionary </span><span style="color: #0000ff">and</span><span style="color: #000000"> locals can be any mapping,
defaulting to the current globals </span><span style="color: #0000ff">and</span><span style="color: #000000"> locals.
If only globals </span><span style="color: #0000ff">is</span> given, locals defaults to it.</pre>
复制代码

hex(x)

　　返回x的16进制字符串，字符串以'0x'开头，字符串中的字符都以小写形式表示。

　　当x不是一个int型对象时，则对象必须定义一个__index__() 方法，则返回整型值，否则将产生异常。

>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'

id(object)

　　返回对象的内部ID值。

复制代码 
>>> id(123)
10923328
>>> id('test')
140589176043704
>>> id([1,2,3])
140589199591816
复制代码

 input([prompt])

　　接收标准输入转为字符串并返回。

　　prompt 为输入提示字符串，可以省略。

　　注：如果读到 EOF 将产生异常。

>>> s = input('Enter: ')
Enter: hello
>>> s
'hello'

 int(x=0)  int(x, base=10)

　　返回一个整型数。输入参数可以是一个数或者一个字符串（当然可以是其他对象，但这里不讲解这种非主流用法）。

　　参数为一个数时，返回对象的__int__()方法的值，对于整型对象就是自身的值，对于浮点型对象就是整数部分。

　　参数为一个字符串时，字符串必须表示一个2、8、10、16进制，并传入相应的base值。

复制代码 
>>> int(3)
3
>>> int(1.25)
1
>>> int('101', 2)
5
>>> int('54', 8)
44
>>> int('123', 10)
123
>>> int('F3', 16)
243
复制代码

 isinstance(object, classinfo)

　　判断对象是否属于指定的类。（可以配合 type 使用）

　　注1: 如果指定类是当前对象的父类，判断结果也是 True

　　注2: 如果 classinfo 参数是一个元组，那么只要对象属于其中的一个类即返回 True

复制代码 
>>> a = 12
>>> b = 25
>>> isinstance(a, int)
True
>>> isinstance(a, type(b))
True
>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> a = A()
>>> b = B()
>>> isinstance(a, A)
True
>>> isinstance(b, B)
True
>>> isinstance(a, B)
False
>>> isinstance(b, A)
True
>>> isinstance(a, (A,B))
True
复制代码

issubclass(class, classinfo)

　　判断一个类是否为指定类的子类。

　　注1: 类都是自身的子类

　　注2: 如果 classinfo 参数是一个元组，那么只要类属于其中一个类的子类即返回 True

复制代码 
>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> issubclass(B, A)
True
>>> issubclass(A, B)
False
>>> issubclass(A, A)
True
>>> issubclass(A, (A,B))
True
复制代码

iter(object [, sentinel])

　　返回一个迭代器对象，用于遍历，一般与 next() 配合使用。

　　如果 sentinel 参数没有传入则 object 必须是一个可迭代的对象。

　　如果 sentinel 参数有值，则object 必须是一个 callable 的对象，此时的遍历将重复调用object, 直到返回值等于 sentinel（将产生StopIteration异常）

复制代码 
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> for i in iter([1,2,3]):
...     print(i)
... 
1
2
3
>>> f = open('test.txt', 'r')
>>> itf = iter(f.readline, '')
>>> next(itf)
'test line 1\n'
>>> next(itf)
'test line 2\n'
>>> next(itf)
'test line 3\n'
>>> next(itf)
'\n'
>>> next(itf)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()
复制代码

len(s)

　　返回对象的长度。对象一般是一个序列和一个集合。

　　如果是其他对象，则对象必须包含 __len__() 方法，否则会产生异常。

复制代码 
>>> a = [1, 2, 3]
>>> len(a)
3
>>> b = 'abcdefg'
>>> len(b)
7
>>> 
>>> class MyTest:
...     def __len__(self):
...         return 5
... 
>>> c = MyTest()
>>> len(c)
5
复制代码

list([iterable])

　　创建并返回一个列表对象。如果没有传入参数，则返回一个空列表。

　　传入的参数必须是一个可迭代的，迭代器中的每一个对象将作为列表的一个元素。

>>> list('abcd')
['a', 'b', 'c', 'd']
>>> list([1,2,3])
[1, 2, 3]

locals()

　　返回当前命名空间的{对象: 值} 字典。

复制代码 
>>> def foo():
...     i = 1
...     j = 2
...     k = 3
...     print(locals())
... 
>>> foo()
{'i': 1, 'k': 3, 'j': 2}
复制代码

map(function, iterable, ...)

　　返回一个迭代器。迭代器中的每一个对象将是传入的迭代器根据function的映射。

　　如果超过两个参数，后面的参数适用于 function 有多个参数的情况，因此后面的迭代器的长度不能小于 iterable

复制代码 
>>> for i in map(lambda x: x**2, [1,2,3]):
...     print(i)
... 
1
4
9
>>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]):
...     print(i)
... 
2
4
8
复制代码

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

　　返回最大值。要比较的参数可以是一个可迭代的对象，也可以直接传入对象列表。

　　参数 key 可以改变默认的比较方式。

　　当传入的是一个迭代器时，如果迭代器为空，则返回default值，如果没有传入default将产生异常。

复制代码 
>>> max([3,5,1,7,9,2])
9
>>> max('aaa', 'bbb', 'ccc')
'ccc'
>>> 
>>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1])
(2, 4)
>>> max([], default='empty')
'empty'
复制代码

memoryview(obj)

　　返回一个内存观察对象。传入的对象必须支持缓冲区协议，内建对象中支持的有 bytes 和 bytearray 。

　　内存观察对象提供一个共享的内存，可以在不需要复制的情况以不同的方式访问共享内存。在大量数据处理时比较有用。

复制代码 
>>> a = memoryview(b'abcdefg')
>>> a
<memory at 0x7f22addc3e88>
>>> a[0]
97
>>> a[1]
98
>>> a.tolist()
[97, 98, 99, 100, 101, 102, 103]
>>> a.tobytes()
b'abcdefg'
>>> a[1:3].tobytes()
b'bc'
复制代码

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

　　返回最小值。用法与 max 类似

复制代码 
>>> min([3,5,1,7,9,2])
1
>>> min('aaa', 'bbb', 'ccc')
'aaa'
>>> min((4,2), (3,3), (2,4), key=lambda x: x[1])
(4, 2)
>>> min([], default='empty')
'empty'
复制代码

next(iterator [, default])

　　返回迭代器中的下一个。一般与 iter() 配合使用。

　　当迭代完成以后，如果传入了default参数，则返回default的值，否则产成StopIteration异常

复制代码 
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> it = iter([1,2,3])
>>> next(it, default='end')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: next() takes no keyword arguments
>>> next(it, 'end')
1
>>> next(it, 'end')
2
>>> next(it, 'end')
3
>>> next(it, 'end')
'end'
复制代码

object()

　　创建一个基本对象。该类是所有类的基类。

>>> a = object()
>>> dir(a)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

oct(x)

　　返回x的8进制字符串，字符串以'0o'开头，字符串中的字符都以小写形式表示。

　　当x不是一个int型对象时，则对象必须定义一个__index__() 方法，则返回整型值，否则将产生异常。

>>> oct(10)
'0o12'
>>> oct(16)
'0o20'

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

　　打开一个文件，返回一个文件的对象。open的使用非常丰富，这里为扫盲，只说明最常用最基本的用法。

　　参数 file, 文件名，路径可以为相对，也可以为绝对。

　　参数 encoding，以何种编码方式打开文件，例如 'utf-8', 'gbk'等。

　　参数 mode，打开模式

　　　　- 'r',  只读方式，如果文件不存在将产生异常。

　　　　- 'w',  写方式打开，如果文件存在，原文件将被覆盖，如果不存在将创建新文件。

　　　　- 'x'，创建一个新文件并打开，如果文件存在将产生异常。

　　　　- 'a',  追加方式打开，如果文件存在，打开后指针指向文件尾部，如果不存在将创建新文件。

　　　　- ‘b',  二进制模式打开。

　　　　- 't',  文本模式打开（缺省）

　　　　- '+', 读写方式打开，配合r, w, a使用

　　　　其中常用组合模式，r+, rb+, w+, wb+, a+, ab+

　　注: 为保证使用安全性，常配合 with 使用

复制代码 
>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1\n'
>>> f.close()
>>> 
>>> with open('test.txt', 'r') as f:
...     print(f.readline())
... 
test line1
复制代码

ord(c)

　　返回字符的unicode码，该函数是chr()反向操作。

　　注: 参数必须是单一的字符

复制代码 
>>> ord('a')
97
>>> ord(chr(99))
99
>>> chr(ord('k'))
'k'
复制代码

pow(x, y [, z])

　　求 x 的 y 次方。结果相当于  x ** y

　　如果传入了参数 z，则相当于 (x ** y) % z

　　注:  如果 y 是负数，则不能传入 z

>>> pow(2, 3)
8
>>> pow(2, 4, 5)
1

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

　　打印函数。可以一次打印多个对象。sep, end, file, flush 如果需要修改，需以关键字形式指定。

　　参数sep，多个对象的打印内容之间的分割符。

　　参数end，所有对象内容输出完毕后输出的字符。

　　参数file, 输出的地方，默认是标准输出，可以修改成文件等具有write() 方法的对象。

　　参数flush, 是否立即输出。False 可能会暂时放入缓冲区。

　　注: 对于自定义的对象，如果想被print调用，需要具有 __str__() 方法

复制代码 
>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='\n\n\n')
hello world

>>> print(‘hello’, ‘world’, ‘123’, flush=True)
hello world 123
>>>
>>> class MyTest:
… def str(self):
… return ‘test’
…
>>> a = MyTest()
>>> print(a)
test

复制代码

property(fget=None, fset=None, fdel=None, doc=None)

　　属性装饰器。可以方便的访问对象的某个属性，避免直接操作内部属性。

　　函数返回一个装饰属性，将关联 fget, fset, fdel 函数

　　参数doc提供一个帮助信息。

　　当用@property装饰类方法时，方法名将作为装饰属性，方法定义为只读。此时如果需要set和del需要配合@method.setter和@method.deleter使用

　　注1: 两种实现方式中，get, set 和 del 都不是必须全部存在的

　　注2: 两种实现方式中，get函数都只能有self参数

复制代码 
class MyTest:
    def __init__(self):
        self._x = None

</span><span style="color: #0000ff">def</span><span style="color: #000000"> getx(self):
    </span><span style="color: #0000ff">return</span><span style="color: #000000"> self._x

</span><span style="color: #0000ff">def</span><span style="color: #000000"> setx(self, v): 
    self._x </span>=<span style="color: #000000"> v 

</span><span style="color: #0000ff">def</span><span style="color: #000000"> delx(self):
    </span><span style="color: #0000ff">del</span><span style="color: #000000"> self._x

x </span>= property(getx, setx, delx, <span style="color: #800000">"</span><span style="color: #800000">The '_x' property</span><span style="color: #800000">"</span><span style="color: #000000">)

class MyTest2:
def init(self):
self._x = None

@property
</span><span style="color: #0000ff">def</span><span style="color: #000000"> x(self):
    </span><span style="color: #0000ff">return</span><span style="color: #000000"> self._x

@x.setter
</span><span style="color: #0000ff">def</span><span style="color: #000000"> x(self, v): 
    self._x </span>=<span style="color: #000000"> v 

@x.deleter
</span><span style="color: #0000ff">def</span><span style="color: #000000"> x(self):
    </span><span style="color: #0000ff">del</span><span style="color: #000000"> self._x

>>> a = MyTest()
>>> a.x
>>>
>>> a = MyTest()
>>> print(a.x)
None
>>> a.x = ‘test’
>>> print(a.x)
test
>>> del a.x
>>> print(a.x)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
File “/home/taopeng/Workspace/CodeWars/tmp.py”, line 7, in getx
return self._x
AttributeError: ‘MyTest’ object has no attribute ‘_x’

>>> b = MyTest2()
>>> print(b.x)
None
>>> b.x = 3
>>> print(b.x)
3
>>> del b.x
>>> print(b.x)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
File “/home/taopeng/Workspace/CodeWars/tmp.py”, line 25, in x
return self._x
AttributeError: ‘MyTest2’ object has no attribute ‘_x’

复制代码

range(stop)  range(start, stop [, step])

　　生成一个数字序列迭代器。

　　当只有一个参数时，序列为0到stop(不包括stop值)， 步进为1

　　当有两个参数时，序列为start到stop(不包括stop值)，步进为1

　　三个参数时，即可自定义步进

复制代码 
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,9))
[3, 4, 5, 6, 7, 8]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
复制代码

repr(object)

　　和 ascii() 类似，返回对象的可打印字符串。

　　自定义对象如果需要 repr()，需要定义__repr__() 方法

复制代码 
>>> a = 123
>>> repr(a)
'123'
>>> b = 'test'
>>> repr(b)
"'test'"
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world'
... 
>>> c = MyTest()
>>> repr(c)
'Hello, world'
复制代码

reversed(seq)

　　返回一个序列逆序的迭代器。

　　如果是自定义对象，需要实现 __reversed__() 方法或者支持序列协议

>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]

round(number [, ndigits])

　　保留指定的小数位，返回一个最接近的数。

　　参数 ndigits 默认为None， 即只保留整数部分。

　　注1: 该函数当向上和向下取近似距离相同时，优先取较小的偶数。

　　注2: ndigits 如果填0，虽然只保留整数位，但是会返回浮点型

复制代码 
>>> round(1.1)
1
>>> round(1.8)
2
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(3.14, 1)
3.1
>>> round(3.16, 0)
3.0
复制代码

set([iterable])

　　创建一个集合对象。如果没有参数则创建一个空集合。

　　参数必须是可迭代的。迭代器中的相同的对象将只会保留一个。

复制代码 
>>> set([1,2,3])
{1, 2, 3}
>>> set([1,1,2,2,3])
{1, 2, 3}
>>> set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
复制代码

setattr(object, name, value)

　　给对像的指定属性赋值。如果对象不存在该属性，将先创建该属性。

　　注: 参数 name 是一个字符串

复制代码 
>>> class MyTest():
...     pass
... 
>>> a = MyTest()
>>> setattr(a, 'test', 'hello')
>>> getattr(a, 'test')
'hello'
>>> setattr(a, 'test', 'hello, world')
>>> getattr(a, 'test')
'hello, world'
>>> a.test
'hello, world'
复制代码

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

　　生成一个分片对象。用于对序列进行分片。

　　当只有一个参数时，序列为0到stop(不包括stop值)， 步进为1

　　当有两个参数时，序列为start到stop(不包括stop值)，步进为1

　　三个参数时，即可自定义步进

　　不过一般可以直接在序列中用分片语法，例如 a为一个列表，分片语法为: a[start:stop:step]

复制代码 
>>> myslice = slice(1,5,1)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a[myslice]
[2, 3, 4, 5]
>>> a[1:5:1]
[2, 3, 4, 5]
复制代码

sorted(iterable, *, key=None, reverse=False)

　　返回一个经过排序的列表。key, reverse参数必须以关键字形式传入。

　　需要排序的对象必须是可迭代的。

　　参数key，排序的关键字。

　　参数reverse，是否逆序，默认从小到大。

　　注: 参数*可以忽略。

复制代码 
>>> a = [5,6,3,1,7,4,9]
>>> sorted(a)
[1, 3, 4, 5, 6, 7, 9]
>>> sorted(a, reverse=True)
[9, 7, 6, 5, 4, 3, 1]
>>> b = ['B', 'a', 'g', 'F', 'z', 'K']
>>> sorted(b)
['B', 'F', 'K', 'a', 'g', 'z']
>>> sorted(b, key=str.lower)
['a', 'B', 'F', 'g', 'K', 'z']
复制代码

staticmethod(function)

　　一般作为函数装饰器使用 @staticmethod 。类似 classmethod

　　将类中的一个方法指定为静态方法。　　

　　静态方法的调用可以直接通过类调用，即C.f(); 也可以通过实例调用，即C().f()

　　个人感觉静态方法适合将函数归类打包

　　注:静态方法是可以继承的

复制代码 
>>> class MyTest:
...     @staticmethod
...     def static_test():
...         print('This is a static method')
... 
>>> 
>>> a = MyTest()
>>> a.static_test()
This is a static method
>>> 
>>> MyTest.static_test()
This is a static method
复制代码

str(object='')  str(object=b'', encoding='utf-8', errors='strict')

　　创建并返回一个字符串对象。

　　可以使用指定的对象来初始化。初始化将使用对象的 __str__() 方法返回的值。

复制代码 
>>> str(12345)
'12345'
>>> str('test')
'test'
>>> str([1,2,3])
'[1, 2, 3]'
>>> class MyTest:
...     def __str__(self):
...         return 'Hello'
... 
>>> a = MyTest()
>>> str(a)
'Hello'
复制代码

sum(iterable [, start])

　　对一个序列求和。

　　参数start， 指定一个初始值，默认是0

复制代码 
>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,3})
6
复制代码

super([type [, object-or-type]])

　　返回父类的方法、对象。一般用于继承处理中，特别是初始化。

　　在初始化中，super的参数可以省略。

复制代码 
class A:
    def __init__(self):
        print('Class A init')

class B(A):
def init(self):
super().init()
print(‘Class B init’)

class C(A):
def init(self):
super(C, self).init()
print(‘Class C init’)

>>> b = B()
Class A init
Class B init
>>> c = C()
Class A init
Class C init

复制代码

tuple([iterable])

　　创建并返回一个元组对象。

　　可以使用一个可迭代对象初始化元组。

>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('test')
('t', 'e', 's', 't')

type(object)  type(name, bases, dict)

　　两个功能。传入的参数个数不同，功能不同

　　一个参数时，返回对象所属的类。

　　三个参数时，动态创建一个自定义类的对象。

　　当需要动态创建一个类时，

　　参数name, 类名

　　参数bases, 类的基类，使用一个元组传入，因此可以有多个父类。

　　参数dict, 类的属性和方法字典。{属性名=属性值，方法名=函数名}, 其中“函数名”是一个已经定义的函数

　　注: 直接通过字典传入的方法是一个静态方法。

复制代码 
>>> a = [1,2,3]
>>> type(a)
<class 'list'>
>>> 
>>> def test_func():
...     print('This is a test func.')
... 
>>> b = type('MyTest', (object, ), dict(test_attr='Hello', test_method=test_func))
>>> type(b)
<class 'type'>
>>> b.test_attr
'Hello'
>>> b.test_method()
This is a test func.
复制代码

vars([object])

　　返回对象新添加的属性字典。如果没有参数，返回当前命名空间更新的属性字典。

　　实际上函数返回的就是对象 __dict__ 属性的值。

　　注: 在初始化时添加的属性不会放入 __dict__

复制代码 
>>> class MyTest:
...     def __init__(self):
...         a = 1
...         b = 2
... 
>>> a = MyTest()
>>> 
>>> vars(a)
{}
>>> a.c = 3
>>> vars(a)
{'c': 3}
>>> a.__dict__
{'c': 3}
>>> 
>>> vars()
{'MyTest': <class '__main__.MyTest'>, 'a': <__main__.MyTest object at 0x7f1ca394f828>, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
复制代码

zip(*iterables)

　　将多个序列进行重新组合，返回一个元组列表。

　　每个元组从各个序列中各提取一个值。因此元组的个数由最短的序列决定。

复制代码 
>>> list(zip([1,1,1], [2,2,2], [3,3,3]))
[(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>> 
>>> list(zip([1,2,3], [4,5,6], [7,8,9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> 
>>> list(zip([1,1,1], [2,2,2], [3,3]))
[(1, 2, 3), (1, 2, 3)]
复制代码

 

da_kao_la
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python中内建函数的简单用法说明
09-21
Python内建模块`__builtins__`（在Python 2中是`__builtin__`）还包含许多其他有用的函数，如`abs()`、`bool()`、`cmp()`、`delattr()`、`eval()`、`float()`、`hash()`、`help()`、`id()`、`input()`（Python 2）、...
Python标准库(3.x): 内建函数扫盲
andymeng2014的博客
02-19 268
Built-in Functions abs() dict() help() min() setattr() all() dir() hex() next() slice() any() divmod() id() object() sorted() ascii() enumerate() input() oc...
mybatisplus返回map日期转字符串 timestamp转string
qq_42569136的博客
04-28 2672
mybatisplus或者mybatis返回map，日期时间为时间戳timestamp时，转为字符串String
python eval函数
Gordennizaicunzai的博客
02-24 505
主要用于求值，特殊之处在于表达式是以字符串的形式书写的，并且求值完之后返回结果。 help(eval) Help on built-in function eval in module builtins: 内建函数 eval(source, globals=None, locals=None, /) Evaluate the given source in the context o...
python eval()内置函数
weixin_33979363的博客
12-24 264
python有一个内置函数eval()，可以将字符串进行运行。 通过help(eval)查看帮助文档 Help on built-in function eval in module builtins: eval(source, globals=None, locals=None, /) Evaluate the given source in the context of...
⭐️Python内置函数exec()详解 基本用法 示例 使用场景 安全注意事项 总结——《跟老吕学Python编程》
Python老吕的博客
04-16 1668
exec()是一个强大的内置函数，允许你执行存储在字符串或对象代码中的Python代码。然而，由于它可以执行任意的Python代码，因此在使用时必须格外小心，以避免安全风险。在处理用户输入或不可信的来源的代码时，你应该遵循最佳实践来确保应用程序的安全性。如果需要更深入的了解Python内置函数exec()Python内置函数exec()——《Python内置函数手册》Python老吕编著博主：Python老吕CSDN网站为我们搭建了一个如此卓越的学习平台，使我们有机会分享知识与经验。
python元组和字典的内建函数实例详解
09-18
在Python编程语言中，元组和字典是两种非常重要的数据类型，它们各自都有自己的内建函数，可以极大地提升开发效率。本篇文章将详细介绍Python中元组和字典的常用内建函数，并通过实例进行深入解析。 首先，我们来...
对Python 内建函数和保留字详解
09-20
值得注意的是，'xrange()' 函数在Python 3中已经被 'range()' 替代，不再作为内建函数。 对于编程初学者，熟悉内建函数和保留字是非常重要的。它不仅有助于编写正确的代码，还能避免因误用这些关键字或函数而产生的...
Python内建函数.docx
最新发布
07-20
根据提供的文档信息，我们可以深入探讨Python中的内建函数及其用法。这些函数是Python语言的基础组成部分，对于初学者和有经验的开发者来说都是极其重要的工具。 ### 1. abs() `abs()` 函数用于获取一个数字（整数...
python3内置函数学习笔记
10-17
个人学习所用，对python3内置函数以及面向对象等思想的整理所得
Python 类中的object是什么
热门推荐
yingxuanzhang的博客
05-30 1万+
在python中，object是一个我们会经常遇到的词汇，那么这个词汇究竟有什么含义呢？通过查阅一些文档，我们发现，object其实是一个类的实例，而这个类的名字是Object(默认类的命名首字母大写)，它是所有类的父类，换句话说，python是默认所有的类都继承自Object类。而如abc(抽象基类)等其他的内置的类都是基于Object类的一些功能实现的。可以说，Object类规定了类的结构，加载方式，常用函数等。对Object类的常见应用主要有以下两个形式，python2和python3 #以前的写
python常用自定义函数_Python自定义函数及常用函数分析【isinstance&type】
weixin_39667797的博客
12-04 204
一.isinstance&typeisinstance()函数用来判断一个对象是否是一个已知类型的数据，类似于type()。isinstance()和type()的区别：1.type()不会认为子类是一种父类类型，不考虑继承关系。2.isinstance()会认为子类是一种父类类型，考虑继承关系。相同点：都不认为父类是子类的一种类型！判断两个类型是否相同可以根据具体业务进行选择，一般建议选...
python 深入理解赋值、拷贝、引用、作用域
m0_37907238的博客
07-15 193
转自：https://www.cnblogs.com/jiangzhaowei/p/5740913.html 关键内容： 1. 对于不可变对象和可变对象来说，浅复制都是复制的引用，只是因为复制不变对象和复制不变对象的引用是等效的（因为对象不可变，当改变时会新建对象重新赋值）。所以看起来浅复制只复制不可变对象（整数，实数，字符串等），对于可变对象，浅复制其实是创建了一个对于该对象的...
python3--内置函数
Hellen_2015的博客
12-13 204
# Auther: Aaron Fanprint(abs(-10)) #取绝对值print(all([0,'a',3])) #如果参数中有一个不为真，就返回False。（非0即真）print(any([0,'a',3])) #如果参数中有一个为真，就返回True#返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x,\u或\U等字符来表示。与python2版本里的...
python3系列之内建函数
besmarterbestronger的博客
10-26 206
文章目录1. 前言2. 参考文献 1. 前言 总是对python3的内置函数不太了解，阅读官方文档之后，做个记录。 序号 内建函数名 类型 描述 类型 1 bool([x]) 类 返回一个Boolean值，True 或 False。 2 bytes([source[, encoding[, errors]]]) 类 返回一个新的bytes对象，该对象是不可变的整数序列...
Python 内建函数大全
weixin_34186950的博客
04-28 637
翻译总结自官方文档：原文地址 Python 解释器内置了许多函数和类型，列表如下（按字母排序）（省略了几个我没用过或者不常用的）。 - - 内建函数表 - - abs() delattr() hash() memoryview() set() all() dict() help() min() setattr() any() dir() hex() next() slic...
Python常用内置函数（python 3.x）
黑夜中的潜行者
03-29 499
Python常用内置函数 1 类型相关 2 数理统计相关 3 进制转换 4 面向对象相关 5 迭代器相关 6 map函数 7 排序相关 8 其他
Python3 常用内建函数解析（基础篇）
weixin_39540280的博客
11-01 417
1、数值对象的构造(创建)函数 函数 说明 float(obj) 用字符串或数字转换为浮点数, 如果不给出参数，则返回0.0 int(x, base=10) 用数字或字符串转换为整数,如果不给出参数，则返回0 int() complex(r=0.0, i=0.0) 用数字创建一个复数(实部为r,虚部为i) bool(x) 用x创建一个布尔值(True/False) 2、预置(内建)的数值型函数 函数 说明 abs(x) 取x的绝对值 round(number[, ndigits]).
python内置函数eval(x)的作用_python eval()内置函数
weixin_39897749的博客
11-27 1175
python有一个内置函数eval()，可以将字符串进行运行。通过help(eval)查看帮助文档Help on built-in function eval inmodule builtins:eval(source, globals=None, locals=None, /)Evaluate the given sourcein the context of globals andlocals...
Python列表内建函数详解与实战应用
在Python编程中，列表类型内建函数是开发者必备的工具，它们提供了高效的操作列表数据结构的能力。以下是一些关键的列表操作方法： 1. `list.append(obj)`：此函数用于向列表的末尾添加一个对象`obj`，使得列表长度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值