angle python复数 python复数abs

python内置函数

abs()

abs() 函数返回数字的绝对值。

abs( x )
x -- 数值表达式，可以是整数，浮点数，复数。

函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。

all()

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

all(iterable)
iterable -- 元组或列表。

如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

注意：空元组、空列表返回值为True，这里要特别注意。

any()

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

any(iterable)
iterable -- 元组或列表。

如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

ascii()

ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。

ascii(object)
object -- 对象。

返回字符串。

>>> ascii('runoob')
"'runoob'"

 

bin()

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

bin(x)
x -- int 或者 long int 数字

字符串。

>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'

 

bool()

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类。

class bool([x])
x -- 要进行转换的参数。

返回 Ture 或 False。

bytearray()

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

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

返回新字节数组。

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

 

bytes()

bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

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

返回一个新的 bytes 对象。

>>>a = bytes([1,2,3,4])
>>> a
b'\x01\x02\x03\x04'
>>> a = bytes('hello','ascii')
>>> a
b'hello'

 

$callable()

callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

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

callable(object)
object -- 对象

可调用返回 True，否则返回 False。

>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True

 

chr()

chr() 用一个整数作参数，返回一个对应的字符。

chr(i)
i -- 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。

返回值是当前整数对应的 ASCII 字符。

classmethod修饰符

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

classmethod
返回函数的类方法。

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

 

$compile()

compile() 函数将一个字符串编译为字节代码。

compile(source, filename, mode[, flags[, dont_inherit]])
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

返回表达式执行结果

>>>str = "for i in range(0,3): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval（a)
17

 

complex()

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。

class complex([real[, imag]])
real -- int, long, float或字符串；
imag -- int, long, float；

返回一个复数。

>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)

 

delattr()

delattr 函数用于删除属性。

delattr(x, 'foobar') 相等于 del x.foobar。

delattr(object, name)

object -- 对象。
name -- 必须是对象的属性。

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)

 

dict()

dict() 函数用于创建一个字典。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
**kwargs -- 关键字
mapping -- 元素的容器。
iterable -- 可迭代对象。

>>>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()，该方法将被调用。如果参数不包含dir()，该方法将最大限度地收集参数信息。

dir([object]) object -- 对象、变量、类型。 返回模块的属性列表。

divmod()

Python divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

在 python 3.x 版本该函数不支持复数。

divmod(a, b) a: 数字，非复数。 b: 数字，非复数。

enumerate()

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

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

 

eval（)

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

eval（expression[, globals[, locals]]) expression -- 表达式。 globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。 locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。 返回表达式计算结果。

>>>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 代码。

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

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

 

filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

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

filter(function, iterable) function -- 判断函数。 iterable -- 可迭代对象。 返回一个迭代器对象

def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

 

float()

float() 函数用于将整数和字符串转换成浮点数。

class float([x]) x -- 整数或字符串 返回浮点数。

format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11)'{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

frozenset()

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

class frozenset([iterable]) iterable -- 可迭代的对象，比如列表、字典、元组等等。 返回新的 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'])   # 创建不可变集合

 

getattr()

getattr() 函数用于返回一个对象属性值。

getattr(object, name[, default]) object -- 对象。 name -- 字符串，对象属性。 default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。 返回对象属性值。

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3

 

globals()

globals() 函数会以字典类型返回当前位置的全部全局变量。

globals() 返回全局变量的字典。

>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

 

hasattr()

hasattr() 函数用于判断对象是否包含对应的属性。

hasattr(object, name) object -- 对象。 name -- 字符串，属性名。 如果对象有该属性返回 True，否则返回 False。

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性

 

hash()

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

hash(object) object -- 对象； 返回对象的哈希值。

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

 

help()

help() 函数用于查看函数或模块用途的详细说明。

help([object]) object -- 对象； 返回对象帮助信息。

hex()

hex() 函数用于将一个指定数字转换为 16 进制数。

hex(x) x -- 一个整数 返回一个字符串，以 0x 开头。

id()

id() 函数用于获取对象的内存地址。

id([object]) object -- 对象。 返回对象的内存地址。

input()

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

input([prompt]) prompt: 提示信息

int()

int() 函数用于将一个字符串或数字转换为整型。

class int(x, base=10) x -- 字符串或数字。 base -- 进制数，默认十进制。 返回整型数据。

isinstance()

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance(object, classinfo) object -- 实例对象。 classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

issubclass()

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

issubclass(class, classinfo) class -- 类。 classinfo -- 类。 如果 class 是 classinfo 的子类返回 True，否则返回 False。

iter()

iter() 函数用来生成迭代器。

iter(object[, sentinel]) object -- 支持迭代的集合对象。 sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。 迭代器对象。

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3

 

len()

Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。

len( s ) s -- 对象。 返回对象长度。

list()

list() 方法用于将元组或字符串转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

list( seq ) seq -- 要转换为列表的元组或字符串。 返回列表。

locals()

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

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

locals() 返回字典类型的局部变量。

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

 

map()

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

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

map(function, iterable, ...) function -- 函数 iterable -- 一个或多个序列 Python 2.x 返回列表。 Python 3.x 返回迭代器。

max()

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

max( x, y, z, .... ) x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。 返回给定参数的最大值。

$memoryview()

memoryview() 函数返回给定参数的内存查看对象(Momory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

memoryview(obj) obj -- 对象 返回元组列表。

>>>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'

 

min()

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

min( x, y, z, .... ) x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。 返回给定参数的最小值。

next()

next() 返回迭代器的下一个项目。

next(iterator[, default])
iterator -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

返回对象帮助信息。

oct()

oct() 函数将一个整数转换成8进制字符串。

oct(x) x -- 整数。 返回8进制字符串。

open()

Python open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

open(file, mode='r')
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

mode 参数有：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

ord()

ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。

ord(c) c -- 字符。 返回值是对应的十进制整数。

>>>ord('a')
97
>>> ord('€')
8364
>>>

 

pow()

pow() 方法返回 xy（x的y次方） 的值。

pow(x, y[, z]) x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z 返回 xy（x的y次方） 的值。

print()

print() 方法用于打印输出，最常见的一个函数。

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

property()

property() 函数的作用是在新式类中返回属性值。

class property([fget[, fset[, fdel[, doc]]]]) fget -- 获取属性值的函数 fset -- 设置属性值的函数 fdel -- 删除属性值函数 doc -- 属性描述信息 返回新式类属性。

class C(object):
    def __init__(self):
        self._x = None
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):
        del self._x
 
    x = property(getx, setx, delx, "I'm the 'x' property.")

 

如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。 如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。

将 property 函数用作装饰器可以很方便的创建只读属性：

class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

 

上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。 property 的 getter,setter 和 deleter 方法同样可以用作装饰器：

class C(object):
    def __init__(self):
        self._x = None
 
    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x
 
    @x.setter
    def x(self, value):
        self._x = value
 
    @x.deleter
    def x(self):
        del self._x

 

range()

Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。

range(stop)
range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

repr()

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

repr(object) object -- 对象。 返回一个对象的 string 格式。

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

 

recersed()

reversed 函数返回一个反转的迭代器。

reversed(seq) seq -- 要转换的序列，可以是 tuple, string, list 或 range。 返回一个反转的迭代器。

round()

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

round( x [, n] ) x -- 数字表达式。 n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。 返回浮点数x的四舍五入值。

set()

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

class set([iterable]) iterable -- 可迭代对象对象； 返回新的集合对象。

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 值
>>> a.bar
5

 

slice()

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

class slice(stop) class slice(start, stop[, step]) 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]

 

sort()

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, key=None, reverse=False)  
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回重新排序的列表。

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]

 

staticmethod()

python staticmethod 返回函数的静态方法。

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

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

 

str()

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

class str(object='') object -- 对象。 返回一个对象的string格式。

sum()

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

tuple()

tuple 函数将列表转换为元组。

tuple( seq ) seq -- 要转换为元组的序列。 返回元组。

type()

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

type(object) type(name, bases, dict) name -- 类的名称。 bases -- 基类的元组。 dict -- 字典，类内定义的命名空间变量。 一个参数返回对象类型, 三个参数，返回新的类型对象。

vars()

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

 

zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

zip([iterable, ...]) iterabl -- 一个或多个迭代器; 返回一个对象。

import()

import() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 import() 来动态载入。

__import__(name[, globals[, locals[, fromlist[, level]]]]) name -- 模块名 返回元组列表。

import sys __import__('a') # 导入 a.py 模块