python内置函数

//描述
abs() 函数返回数字的绝对值。
//语法
以下是 abs() 方法的语法:
abs( x )
//参数
x -- 数值表达式，可以是整数，浮点数，复数。
//返回值
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
//实例
以下展示了使用 abs() 方法的实例：
#!/usr/bin/python3
print ("abs(-40) : ", abs(-40))       #负数
print("abs(2-3):",abs(2-3))     #表达式
以上实例运行后输出结果为：
abs(-40) :  40
abs(2-3) 1

abs()

//描述
all() 函数用于判断给定的可迭代对象 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
函数等价于：
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
Python 2.5 以上版本可用。
//语法
以下是 all() 方法的语法:
all(iterable)
//参数
iterable -- 元组或列表。
//返回值
如果iterable的所有元素不为0、‘‘、False，all(iterable)返回True，否则返回False；

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

//实例
以下展示了使用 all() 方法的实例：
print(all([‘a‘,‘b‘,‘c‘,‘d‘]))  #True
print(all([‘a‘,‘b‘,‘‘,‘d‘]))   #False
print(all([0,1,2,3]))       #False
print(all(("",1,2,3)))      #False
print(all({}))          #True
print(all([]))          #True
print(all(()))          #True

all()

//描述
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，是则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
函数等价于：
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
Python 2.5 以上版本可用。
//语法
以下是 any() 方法的语法:
any(iterable)
//参数
iterable -- 元组或列表。
//返回值
如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
//实例
以下展示了使用 any() 方法的实例：
>>>any([‘a‘, ‘b‘, ‘c‘, ‘d‘])  # 列表list，元素都不为空或0
True
>>> any([‘a‘, ‘b‘, ‘‘, ‘d‘])   # 列表list，存在一个为空的元素
True
>>> any([0, ‘‘, False])        # 列表list,元素全为0,‘‘,false
False 
>>> any((‘a‘, ‘b‘, ‘c‘, ‘d‘))  # 元组tuple，元素都不为空或0
True 
>>> any((‘a‘, ‘b‘, ‘‘, ‘d‘))   # 元组tuple，存在一个为空的元素
True 
>>> any((0, ‘‘, False))        # 元组tuple，元素全为0,‘‘,false
False 
>>> any([]) # 空列表
False
>>> any(()) # 空元组
False

any()

//描述
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
//语法
以下是 ascii() 方法的语法:
ascii(object)
//参数
object -- 对象。
//返回值
返回字符串。
//实例
以下展示了使用 ascii() 方法的实例：
>>> ascii([1,2,3])
‘[1, 2, 3]‘

ascii()

//描述
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
//语法
以下是 bin() 方法的语法:
bin(x)
//参数
x -- int 或者 long int 数字
//返回值
字符串。
//实例
以下展示了使用 bin 函数的实例：
>>>bin(10)
‘0b1010‘
>>> bin(20)
‘0b10100‘

bin()

//描述
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
class bool 是 int 的子类。
0,空字典，空列表。。。都是False，非零为真
//语法
以下是 bool() 方法的语法:
bool([x])
//参数
x -- 要进行转换的参数。
//返回值
返回 Ture 或 False。
//实例
以下展示了使用 bool 函数的实例：
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int)  # bool 是 int 子类
True

bool()

//描述
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
语法
bytearray()方法语法：
class bytearray([source[, encoding[, errors]]])
//参数
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
//返回值
返回新字节数组。
//实例
以下实例展示了 bytearray() 的使用方法：
a=bytearray(12)   #为整数
print(a)     #回一个长度为12的初始化数组
b=bytearray("abcde",encoding="utf-8")    #为字符串
b[0]=99           #修改a为c
print(b)            
c=bytearray([1,2,3])  #为可迭代类型，则元素必须为[0 ,255] 中的整数
print(c)
//执行结果依次为
bytearray(b‘\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00‘)
bytearray(b‘cbcde‘)
bytearray(b‘\x01\x02\x03‘)

//注意正常字节，字符串类型是修改不了的，要修改只能用新的覆盖原先的。但是用bytearray可以修改
a=bytes(‘abcde‘,encoding="utf-8")
print(a.capitalize(),a)      #a.capitalize()首字母大写
b=bytearray("abcde",encoding="utf-8")
b[0]=99
print(b)
//执行结果
b‘Abcde‘ b‘abcde‘
bytearray(b‘cbcde‘)

bytearray()

//描述
bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
//语法
以下是 bytes 的语法:
class bytes([source[, encoding[, errors]]])
//参数
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
//返回值
返回一个新的 bytes 对象。
//实例
以下展示了使用 bytes 的实例：
//代码
>>>a = bytes([1,2,3,4])   #为可迭代类型
>>> a
b‘\x01\x02\x03\x04‘
>>> type(a)
<class ‘bytes‘>
>>>
>>> a = bytes("hello",encoding="utf-8"
>>>
>>> a
b‘hello‘
>>> type(a)
<class ‘bytes‘>
>>>

bytes()

//描述
callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
//语法
callable()方法语法：
callable(object)
//参数
object -- 对象
//返回值
可调用返回 True，否则返回 False。
//实例
以下实例展示了 callable() 的使用方法：
>>>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

callable()

//描述
chr() 用一个整数作参数，返回一个ASCII码对应的字符。
//语法
以下是 chr() 方法的语法:
chr(i)
//参数
i -- 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。
//返回值
返回值是当前整数对应的 ASCII 字符。
//实例
以下展示了使用 chr() 方法的实例：
>>>chr(0x30)
‘0‘
>>> chr(97) 
‘a‘
>>> chr(8364)
‘€‘

chr()

//描述
ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
//语法
以下是 ord() 方法的语法:
ord(c)
//参数
c -- 字符。
//返回值
返回值是对应的十进制整数。
//实例
以下展示了使用 ord() 方法的实例：
>>>ord(‘a‘)
97
>>> ord(‘€‘)
8364
>>>

ord()

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

//语法
classmethod 语法：
classmethod
//参数
无。
//返回值
返回函数的类方法。
//实例
class A(object):
    # 属性默认为类属性（可以给直接被类本身调用）
    num = "类属性"

    # 实例化方法（必须实例化类之后才能被调用）
    def func1(self):  # self : 表示实例化类后的地址id
        print("func1")
        print(self)

    # 类方法（不需要实例化类就可以被类本身调用）
    @classmethod
    def func2(cls):  # cls : 表示没用被实例化的类本身
        print("func2")
        print(cls)
        print(cls.num)
        cls().func1()

    # 不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）
    def func3():
        print("func3")
        print(A.num)  # 属性是可以直接用类本身调用的


# A.func1() 这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的
A.func2()
A.func3()

//执行结果
func2
<class ‘__main__.A‘>
类属性
func1
<__main__.A object at 0x00000000010E8780>
func3
类属性

classmethod

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

//语法
以下是 compile() 方法的语法:
compile(source, filename, mode[, flags[, dont_inherit]])
//参数
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。（没有用可忽略不写）
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。（基本不用）
flags和dont_inherit是用来控制编译源码时的标志（基本不用）
//返回值
返回表达式执行结果。
//实例
以下展示了使用 compile 函数的实例：
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,‘‘,‘exec‘)   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,‘‘,‘eval‘)
>>> eval(a)
17

compile()

//描述
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
//语法
complex 语法：
class complex([real[, imag]])
//参数说明：
real -- int, long, float或字符串；
imag -- int, long, float；
//返回值
返回一个复数。
//实例
以下实例展示了 complex 的使用方法：
>>>complex(1, 2)
(1 + 2j)
>>> complex(1)    # 数字
(1 + 0j)
>>> complex("1")  # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

complex()

//描述
delattr 函数用于删除属性。
delattr(x, ‘foobar‘) 相等于 del x.foobar。
//语法
setattr 语法：
delattr(object, name)
//参数
object -- 对象。
name -- 必须是对象的属性。
//返回值
无。
//实例
以下实例展示了 delattr 的使用方法：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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)
输出结果：
(‘x = ‘, 10)
(‘y = ‘, -5)

delattr

//描述
dict() 函数用于创建一个字典。
//语法
dict 语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
//参数说明：
**kwargs -- 关键字
mapping -- 元素的容器。
iterable -- 可迭代对象。
//返回值
返回一个字典。
//实例
以下实例展示了 dict 的使用方法：
>>>dict()                        # 创建空字典
{}
>>> dict(a=‘a‘, b=‘b‘, t=‘t‘)     # 利用 dict(([key,value],[key,value])) 的方式创建字典
{‘a‘: ‘a‘, ‘b‘: ‘b‘, ‘t‘: ‘t‘}
实例2：
//代码
# !/usr/bin/python3
dict0 = dict()  # 传一个空字典
print(‘dict0:‘, dict0)
dict1 = dict({‘three‘: 3, ‘four‘: 4})  # 传一个字典
print(‘dict1:‘, dict1)
 
dict2 = dict(five=5, six=6)  # 传关键字
print(‘dict2:‘, dict2)
 
dict3 = dict([(‘seven‘, 7), (‘eight‘, 8)])  # 传一个包含一个或多个元祖的列表
print(‘dict3:‘, dict3)
 
dict5 = dict(zip([‘eleven‘, ‘twelve‘], [11, 12]))  # 传一个zip()函数
print(‘dict5:‘, dict5)
以上实例输出结果为：
dict0: {}
dict1: {‘four‘: 4, ‘three‘: 3}
dict2: {‘five‘: 5, ‘six‘: 6}
dict3: {‘seven‘: 7, ‘eight‘: 8}
dict5: {‘twelve‘: 12, ‘eleven‘: 11}

dict()

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

//语法
dir 语法：
dir([object])
//参数说明：
object -- 对象、变量、类型。
//返回值
返回模块的属性列表。
//实例
以下实例展示了 dir 的使用方法：
>>>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‘]
>>>
#也可以返回类的属性列表

dir()

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
//函数语法
divmod(a, b)
//参数说明：
a: 数字
b: 数字
//实例
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)

divmod()

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

//语法
以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])
//参数
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
//返回值
返回 enumerate(枚举) 对象。
//实例
以下展示了使用 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 循环使用 enumerate
seq = [‘one‘, ‘two‘, ‘three‘]
for i,element in enumerate(seq):
print(i,seq[i])
执行结果
0 one
1 two
2 three
>>>
//或者
seq = [‘one‘, ‘two‘, ‘three‘]
for i,element in enumerate(seq):
print(i,element)
执行结果
0 one
1 two
2 three

enumerate()

//描述
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
//实例：
eval 方法能使字符串本身的引号去掉，保留字符的原本属性。
应用：
字符串转换成列表
>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>>type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>> type(b)
<type ‘list‘>
字符串转换成字典
>>> a = "{1: ‘a‘, 2: ‘b‘}"
>>> type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
{1: ‘a‘, 2: ‘b‘}
>>> type(b)
<type ‘dict‘>
字符串转换成元组
>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
>>> type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
>>> type(b)
<type ‘tuple‘>

eval()

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

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


变量查找顺序：
object→locals→globals
//返回值
exec 返回值永远为 None。
//实例
以下展示了使用 exec 的实例：
实例 1
>>>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
实例 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})  #变量查找顺序object→locals→globals；因此z=30,y=3,x=1                                                                
    
func()
输出结果：

60
33
34

exec()

//描述
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
//语法
以下是 filter() 方法的语法:
filter(function, iterable)
//参数
function -- 判断函数。
iterable -- 可迭代对象。
//返回值
返回一个迭代器对象
//实例
以下展示了使用 filter 函数的实例：
//过滤出列表中的所有奇数：
#!/usr/bin/python3
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)
输出结果 ：
[1, 3, 5, 7, 9]

//过滤出1~100中平方根是整数的数：
#!/usr/bin/python3
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
输出结果 ：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


//判断是否返回一个迭代器对象
from collections import Iterator
def is_odd(n):
    return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(isinstance(tmplist,Iterator))    #是否为迭代器对象
for i in tmplist:
print(i)
执行结果
True
1
3
5
7
9

//filter()函数结合匿名函数
list=filter(lambda n:n>5,range(10))
for i in list:
print(i)
执行结果
6
7
8
9

filter()

//描述
float() 函数用于将整数和字符串转换成浮点数。
//语法
float()方法语法：
class float([x])
//参数
x -- 整数或字符串
//返回值
返回浮点数。
//实例
以下实例展示了 float() 的使用方法：
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float(‘123‘)     # 字符串
123.0

float()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
//实例1
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
‘hello world‘
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
‘hello world‘
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
‘world hello world‘
也可以设置参数：

//实例2
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = [‘菜鸟教程‘, ‘www.runoob.com‘]
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
输出结果为：
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com

format

//描述
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‘, ‘n‘, ‘r‘, ‘o‘, ‘u‘})  # 创建不可变集合
>>>

frozenset

//描述
getattr() 函数用于返回一个对象属性值。
//语法
getattr 语法：
getattr(object, name[, default])
//参数
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
//返回值
返回对象属性值。
//实例
以下实例展示了 getattr 的使用方法：
>>>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
>>>

getattr()

//描述
globals() 函数会以字典类型返回当前位置的全部全局变量。
//语法
globals() 函数语法：
globals()
//参数
无
//返回值
返回全局变量的字典。
//实例
以下实例展示了 globals() 的使用方法：
>>>a=‘runoob‘
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘runoob‘, ‘__package__‘: None}

globals()

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

//语法
hasattr 语法：
hasattr(object, name)
//参数
object -- 对象。
name -- 字符串，属性名。
//返回值
如果对象有该属性返回 True，否则返回 False。
//实例
以下实例展示了 hasattr 的使用方法：
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
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‘))  # 没有该属性
输出结果：
True
True
True
False

hasattr()

//描述
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
//语法
hash 语法：
hash(object)
//参数说明：
object -- 对象；
//返回值
返回对象的哈希值。
//实例
以下实例展示了 hash 的使用方法：
>>>hash(‘test‘)            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({‘1‘:1}))) # 字典
7666464346782421378
>>>

//hash() 函数的用途
hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。

name1=‘正常程序代码‘
name2=‘正常程序代码带病毒‘
print(hash(name1)) # 2403189487915500087
print(hash(name2)) # -8751655075885266653

hash()

//描述
help() 函数用于查看函数或模块用途的详细说明。
//语法
help 语法：
help([object])
//参数说明：
object -- 对象；
//返回值
返回对象帮助信息。
//实例
以下实例展示了 help 的使用方法：
>>>help(‘sys‘)             # 查看 sys 模块的帮助
……显示帮助信息……
>>>help(‘str‘)             # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
>>>help(a.append)          # 显示list的append方法的帮助
……显示帮助信息……

help()

//描述
hex() 函数用于将10进制数字转换为 16 进制数。
//语法
hex 语法：
hex(x)
//参数说明：
x -- 一个整数
//返回值
返回一个字符串，以 0x 开头。
//实例
以下实例展示了 hex 的使用方法：
>>>hex(255)
‘0xff‘
>>> hex(-42)
‘-0x2a‘
>>> hex(12)
‘0xc‘
>>> type(hex(12))
<class ‘str‘>      # 字符串

hex()

//描述
id() 函数用于获取对象的内存地址。
//语法
id 语法：

id([object])
//参数说明：
object -- 对象。
//返回值
返回对象的内存地址。
//实例
以下实例展示了 id 的使用方法：
>>>a = ‘runoob‘
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608

id()

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
//函数语法
input([prompt])
//参数说明：
prompt: 提示信息
//实例
input() 需要输入 python 表达式
>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<class ‘str‘>              # 字符串
>>> a = input("input:")    
input:runoob              # 正确，字符串表达式
>>> type(a)
<class ‘str‘>             # 字符串

input()

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
//语法
以下是 isinstance() 方法的语法:

isinstance(object, classinfo)
//参数
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。(int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple)
//返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

//实例
以下展示了使用 isinstance 函数的实例：
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True
//type() 与 isinstance()区别：
class A:
    pass


class B(A):
    pass
print(isinstance(A(), A))# returns True
print(type(A()) == A)  # returns True
print(isinstance(B(), A))  # returns True
print(type(B()) == A)  # returns False
print(isinstance(A(),B))  # returns False

isinstance()

//描述
int() 函数用于将一个字符串或数字转换为整型。
//语法
以下是 int() 方法的语法:
class int(x, base=10)
//参数
x -- 字符串或数字。
base -- 进制数，默认十进制。
//返回值
返回整型数据。

//实例
以下展示了使用 int() 方法的实例：
print(int())                # 不传入参数时，得到结果0
print(int(0.5))             # 去掉小数部分，得到结果0
print(int(3))               # 得到结果3
print(int(‘0xa‘,16))        # 十六进制数“0xa”转换成十进制整数，得到结果10，其中16表示”oxa”为16进制
print(int(‘00010‘,2))       # 二进制数“00010”转换成十进制整数，得到结果2
print(int(‘10‘,8))           # 八进制数“10”转换成十进制整数，得到结果8

int()

//描述
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
//语法
以下是 issubclass() 方法的语法:
issubclass(class, classinfo)
//参数
class -- 类。
classinfo -- 类。
//返回值
如果 class 是 classinfo 的子类返回 True，否则返回 False。
//实例
以下展示了使用 issubclass 函数的实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class A:
    pass
class B(A):
    pass   
print(issubclass(B,A))    # 返回 True

issubclass()

//描述
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

iter()

//描述
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
//语法
len()方法语法：
len( s )
//参数
s -- 对象。
//返回值
返回对象长度。
//实例
以下实例展示了 len() 的使用方法：

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

len()