Python自动化开发学习的第四周------函数进阶

1.装饰器

定义：本质就是函数
功能：用来装饰其余函数，（就是为其余函数添加附加功能）
原则：
1.不能修改被装饰的函数的源代码
2.不能修改被装饰的函数的调用方式
实现装饰器知识储备：
1.函数即“变量”
2.高级函数

变量能够指向函数，函数的参数能接收变量，那么一个函数就能够接收另外一个函数做为参数，这种函数就称之为高阶函数。

1 def bar():
2     print("in the bar")
3 
4 def foo(func):
5     res=func()
6     return res
7 foo(bar)

2.1把一个函数当成实参传给另一个函数（在不修改被装饰函数源代码的状况下添加功能）
2.2返回值中包含函数名（不修改函数的调用方式）
3.嵌套函数

1 def foo():
2     def bar():
3         print （“in the bar”）
4  
5     bar()
6  
7 foo()

 

高阶函数+嵌套函数=》装饰器

装饰器：

1.函数参数固定

import time
def timer(func):
    def deco():
        start_time=time.time()
        func()
        stop_time=time.time()
        print("the func run time %s" %(stop_time-start_time))
    return  deco
@timer
def test1():
    time.sleep(1)
    print("in the test1")
@timer
def test2():
    time.sleep(1)
    print("in the test2")
test1()
test2()

打印结果：

in the test1
the func run time 1.000126838684082
in the test2
the func run time 1.0001270771026611

2.函数参数不固定

import time
def timer(func):
    def deco(*args,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("the func run time %s" %(stop_time-start_time))
    return  deco
@timer
def test1():
    time.sleep(1)
    print("in the test1")
@timer
def test2(name):
    time.sleep(1)
    print("test2:",name)
test1()
test2("苍老师")

打印结果：

in the test1
the func run time 1.0001270771026611
test2: 苍老师
the func run time 1.0001270771026611

3.函数有返回值

name="hh"
passwd="123"

def auth(func):
    def wapper(*args,**kwargs):
        username=input("input your username:").strip()
        password=input("input your password:").strip()
        if username==name and password==passwd:
            print("\033[32;1mWelcome %s\033[0m"%username)
            return func(*args,**kwargs)
        else:
            exit("\033[31;1mInvalid username or password\033[0m")
    return wapper


def index():
    print("welcome to index")
@auth
def home():
    print("welcome to home")
    return "form home"
@auth
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

打印结果：

welcome to index
input your username:hh
input your password:123
Welcome hh
welcome to home
form home
input your username:hh
input your password:123
Welcome hh
welcome to bbs

4.装饰器没有参数

name="hh"
passwd="123"

def auth(func):
    def wapper(*args,**kwargs):
        username=input("input your username:").strip()
        password=input("input your password:").strip()
        if username==name and password==passwd:
            print("\033[32;1mWelcome %s\033[0m"%username)
            return func(*args,**kwargs)
        else:
            exit("\033[31;1mInvalid username or password\033[0m")
    return wapper


def index():
    print("welcome to index")
@auth
def home():
    print("welcome to home")
    return "form home"
@auth
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

打印结果：

welcome to index
input your username:hh
input your password:123
.Welcome hh
welcome to home
form home
input your username:hh
input your password:456
Invalid username or password

5.装饰器有参数

name="hh"
passwd="123"
def auth(auth_type):
    print("auth_type:",auth_type)
    def out_wapper(func):
        def wapper(*args,**kwargs):
            print("auth_type:",*args,**kwargs)
            if auth_type=="local":
                username=input("input your username:").strip()
                password=input("input your password:").strip()
                if username==name and password==passwd:
                    print("\033[32;1mWelcome %s\033[0m"%username)
                    return func(*args,**kwargs)

                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type=="ldap":
                print("啥都不会")
        return wapper
    return out_wapper


def index():
    print("welcome to index")

@auth(auth_type="local")
def home():
    print("welcome to home")
    return "form home"

@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

 打印结果：

auth_type: local
auth_type: ldap
welcome to index
auth_type:
input your username:hh
input your password:123
Welcome hh
welcome to home
form home
auth_type:
啥都不会

2.列表生成式

列表生成式，是python中内置的一种极其强大的生成list的表达式。

若是要生成一个list [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9] 能够用 range(1 , 10)：

>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

但是，若是要生成[1*1 , 2*2 , 3*3 , ... , 10*10] 怎么作呢？可使用循环：

>>> a=[]
>>> for i in range(1,10):
...     a.append(i*i)
...
>>> a
[1, 4, 9, 16, 25, 36, 49, 64, 81]

而列表生成式，能够用一句代替以上的繁琐循环来完成上面的操做：

>>> print([i*i for i in range(1,10)])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

列表生成式的书写格式：[x*x for x in range(1 , 11)]

第一：把要生成的元素 x*x 放到前面

第二：后面跟上for循环

这样就能够把list建立出来，代码简洁。

for循环后面还能够加上if判断，这样能够筛选出偶数的平方：

>>> [i*i for i in range(1,10) if i%2==0]
[4, 16, 36, 64]

固然，使用两层循环，生成全排列：

>>> print( [m + n for m in 'ABCD' for n in 'XYZ'])
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ', 'DX', 'DY', 'DZ']

如今有 list 中包含字符串，和整数，把list中得大写字符转为小写，推到出另一个list

一、使用内建的isinstance函数能够判断一个变量是否是字符串

二、s.lower() 能够将一个大写字母转为小写。

三、增长if语句保证列表生成式正确执行。

L = ["Java" ,"C" , "Swift" , "Python" , 123]
print(s.lower() if isinstance(s,str) else s for s in L)
print([s.lower() if isinstance(s,str) else s for s in L])

打印结果：

<generator object <genexpr> at 0x0000000000B63A40>
['java', 'c', 'swift', 'python', 123]

3.生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。　　

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？

若是要一个一个打印出来，能够经过next()函数得到generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

咱们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

固然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
...
0
1
4
9
16
25
36
49
64
81

因此，咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误。

generator很是强大。若是推算的算法比较复杂，用相似列表生成式的for循环没法实现的时候，还能够用函数来实现。

好比，著名的斐波那契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波那契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        print(b)
        a,b = b,a+b
        n+=1
    return "----done----"

fib(10)

结果：
1
1
2
3
5
8
13
21
34
55

仔细观察，能够看出，fib函数其实是定义了斐波那契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print(b)改成yield b就能够了：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)

结果：
<generator object fib at 0x0000000000A13B48>

这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：

这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)
print(f.__next__())
print(f.__next__())
print("我是插进来的")
print(f.__next__())
print(f.__next__())
print(f.__next__())

结果：
<generator object fib at 0x0000000000473BA0>
1
1
我是插进来的
2
3
5

在上面fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。

一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)
print(f.__next__())
print(f.__next__())
print("我是插进来的")
print(f.__next__())
print(f.__next__())
print(f.__next__())
for i in f:
    print(i)

结果：
<generator object fib at 0x00000000005F3BA0>
1
1
我是插进来的
2
3
5
8
13
21
34
55

可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

经过yield实如今单线程的状况下实现并发运算的效果

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备作包子啦!")
    for i in range(10):
        time.sleep(1)
        print("作了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

生成器总结：

1.生成器不会把结果保存在一个系列中，而是保存生成器的状态，在每次进行迭代时返回一个值，直到遇到StopIteration异常结束，只有在调用时才会生成相应的数据。

2.生成器表达式： 通列表解析语法，只不过把列表解析的[]换成()，生成器表达式能作的事情列表解析基本都能处理，只不过在须要处理的序列比较大时，列表解析比较费内存。

3.在函数中若是出现了yield关键字，那么该函数就再也不是普通函数，而是生成器函数。

yield 的做用就是把一个函数变成一个 generator，带有 yield 的函数再也不是一个普通函数，Python 解释器会将其视为一个 generator。

 4.yield 与 return

在一个生成器中，若是没有return，则默认执行到函数完毕时返回StopIteration；

若是遇到return,若是在执行过程当中 return，则直接抛出 StopIteration 终止迭代。

若是在return后返回一个值，那么这个值为StopIteration异常的说明，不是程序的返回值。

生成器没有办法使用return来返回值。

 5.生成器支持的方法 

close()

手动关闭生成器函数，后面的调用会直接返回StopIteration异常。

send()

生成器函数最大的特色是能够接受外部传入的一个变量，并根据变量内容计算结果后返回。
这是生成器函数最难理解的地方，也是最重要的地方，实现后面的协程就全靠它了。

 throw()

用来向生成器函数送入一个异常，能够结束系统定义的异常，或者自定义的异常。
throw()后直接跑出异常并结束程序，或者消耗掉一个yield，或者在没有下一个yield的时候直接进行到程序的结尾。

4.迭代器

咱们已经知道，能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

可使用isinstance()判断一个对象是不是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能够做用于for循环，还能够被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。

*能够被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可使用isinstance()判断一个对象是不是Iterator对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为何list、dict、str等数据类型不是Iterator？

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。

Iterator甚至能够表示一个无限大的数据流，例如全体天然数。而使用list是永远不可能存储全体天然数的。

 

小结

凡是可做用于for循环的对象都是Iterable类型；

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

Python的for循环本质上就是经过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上彻底等价于：

# 首先得到Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 得到下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

5.内置函数

abs (x)

返回一个数的绝对值。参数多是整数或浮点数。若是参数是一个复数,返回它的大小。

>>> abs(-1)
1
>>> abs(2)
2
>>> abs(-123)
123

all (iterable)

返回 True若是全部的元素iterable真(或者若是iterable为空)。等价于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any (iterable)

返回 True若是任何元素的iterable是正确的。若是iterable为空,返回 False。等价于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii (对象)

做为 repr()返回一个字符串,包含一个可打印的表示一个对象,可是逃避返回的字符串中的非ascii字符 repr()使用 \x, \u或 \U逃跑了。这生成一个字符串返回的类似 repr()在Python中2。

>>> [ascii([1,2,"abc"])]
["[1, 2, 'abc']"]

bin (x)

将一个整数转换成一个二进制字符串。结果是一个有效的Python表达式。若是x是Python int对象,它必须定义一个 __index__()方法返回一个整数。

>>> bin(2)
'0b10'
>>> bin(4)
'0b100'
>>> bin(8)
'0b1000'
>>> bin(9)
'0b1001'

类  bool ([x])

返回一个布尔值,即之一 True或 False。x是使用标准的转换 真理的检验程序。若是x是虚假或省略,这个回报 False;不然它返回 True。的 bool类的一个子类 int(见 数值类型,int、浮点数、复杂)。它不能再进一步。它惟一的实例 False和 True(见 布尔值).

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

类  bytearray ([源[,编码[,错误]]])

返回一个新的数组的字节数。的 bytearray类是一个可变的序列的整数范围0 < = x < 256。它具备可变序列的最多见的方法,描述了 可变序列类型,以及大多数的方法 bytes类型,看 字节和中Bytearray操做.

可选的源参数能够用来初始化数组在几个不一样的方式:

• 若是它是一个字符串,你还必须给编码(和可选地,错误)参数; bytearray()而后将字符串转换成字节使用 str.encode().
• 若是它是一个整数,该数组将与空字节大小和将被初始化。
• 若是它是一个对象符合缓冲界面,一个只读缓冲区将被用来初始化对象的字节数组。
• 若是它是一个iterable,它必须是一个整数的iterable范围 0 <= x < 256,这是做为数组的初始内容。

没有一个论点,建立了一个数组大小为0。

另请参阅 二进制序列类型——字节中bytearray,memoryview和 中Bytearray对象.

类  bytes ([源[,编码[,错误]]])

返回一个新的“字节”对象,这是一个不可变的序列的整数范围 0 <= x < 256. bytes不可变的版本吗 bytearray接触非变异——它有相同的刺突的方法和相同的索引和切片的行为。

所以,构造函数参数解释为 bytearray().

字节对象也能够建立文字,明白了 文本字符串和字节.

另请参阅 二进制序列类型——字节中bytearray,memoryview, 字节, 字节和中Bytearray操做.

>>> a= bytes("abcde",encoding="utf-8")
>>> b= bytearray("abcde",encoding="utf-8")
>>> print(a[0])
97
>>> print(a[1])
98
>>> print(b[0])
97
>>> print(b[1])
98
>>> a[0]=100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
>>> b[0]=100
>>> print(b)
bytearray(b'dbcde')

callable (对象)

返回 True若是对象参数出现可调用的, False若是不是。若是返回true,它仍然是有可能的,调用失败,可是若是它是假的,调用对象永远不会成功。注意,类是可调用(调用一个类返回一个新实例);若是他们的类有一个可调用的实例__call__()方法。

在新的3.2版本:这个函数首先移除在Python 3.0,而后带回在Python 3.2。

>>> def hello():pass
...

>>> print(callable(hello))
True
>>> print(callable([]))
False

chr (我)

返回的字符串表明一个字符的Unicode代码点整我。例如, chr(97)返回的字符串 'a',而 chr(8364)返回的字符串 '€'。这是的倒数 ord().

参数的有效范围从0到1114111年(0 x10ffff基地16)。 ValueError若是我不在这个范围将提升。

>>> chr(98)
'b'
>>> chr(8523)
'\u214b'
>>> chr(87)
'W'

classmethod (函数)

函数返回一个类方法。

一个类方法接收类隐式的第一个参数,就像一个实例方法接收实例。声明一个类方法,使用这个成语:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

的 @classmethod表单是一个函数 装饰——看到函数定义的描述 函数定义获取详细信息。

它能够被称为类(如 C.f()(好比)或在一个实例 C().f())。除了它的类实例被忽略。若是一个类派生类的方法被调用时,派生类对象做为隐含第一个参数传递。

类方法是不一样的比c++或Java静态方法。若是你想要这些,明白了 staticmethod()在这一节中。

关于类方法的更多信息,请参考文档标准类型层次结构 标准的类型层次结构.

compile (源、文件名模式,旗帜= 0,dont_inherit = False,优化= 1)

编译成一个源代码或AST对象。对象能够执行的代码 exec()或 eval()。来源能够是一个普通的字符串,一个字节的字符串,或一个AST对象。指的是 ast模块的文档信息如何使用AST对象。

文件名参数应该给文件的代码阅读,经过一些可识别的值若是不是从文件读('<string>'是经常使用的)。

模式参数指定什么样的代码必须被编译,就能够 'exec'若是源由一系列的语句, 'eval'若是它包含一个表达式,或 'single'若是它包括一个交互式的声明(在后一种状况下,表达式语句,评估之外的东西 None将打印)。

将来的可选参数标志和dont_inherit控制语句(见PEP 236)影响源的编译。若是不存在(或为零)的代码编译与将来的语句中实际上调用的代码 compile()。若是旗帜参数是dont_inherit并非(或为零),那么将来语句指定的标志使用参数除了那些将使用。若是dont_inherit是一个非零的整数,那么旗帜的论点是,将来在调用编译语句实际上被忽略。

将来语句指定比特可按位或共同指定多个语句。所需的设置指定给定的特性能够发现 compiler_flag属性 _Feature实例的 __future__模块。

参数优化指定编译器的优化级别;默认值的 -1选择的翻译的优化级别 -O选项。明确的水平 0(没有优化; __debug__是正确的), 1(断言移除, __debug__是假的)或 2(删除文档字符串)。

这个函数了 SyntaxError若是编译源无效 ValueError若是源包含空字节。

若是你想Python代码解析成AST表示,看到的 ast.parse().

请注意

当编译一个字符串与多行代码 'single'或 'eval'模式下,输入必须终止由至少一个换行符。这是为了方便检测不完整的和完整的语句 code模块。

3.2版本的变化:容许使用Windows和Mac换行。也投入 'exec'模式没有以换行符结束了。增长了优化参数。

3.5版本的变化:在此以前, TypeError长大当空字节中遇到的来源。

类  complex ([真正的[,图像放大]])

返回一个与真实值+复数图像放大* 1 j或字符串或数字转换为复数。若是第一个参数是一个字符串,它将被视为复数和函数必须调用第二个参数。第二个参数不能是一个字符串。每一个参数能够是任何数字类型(包括复杂)。若是省略图像放大,它默认为零和构造函数做为一个数字转换 int和 float。若是两个参数省略,回报 0j.

请注意

当转换从一个字符串,字符串必须不包含空格在中央 +或 -操做符。例如, complex('1+2j')是能够的,但 complex('1 + 2j')提出了 ValueError.

描述的复杂类型 数值类型,int、浮点数、复杂.

3.6版本的变化:分组代码中位数与下划线文字是被容许的。

delattr (对象,的名字)

这是一个相对的 setattr()。的参数是一个对象和一个字符串。字符串必须是一个对象的属性的名称。该函数删除指定的属性,提供了对象容许它。例如, delattr(x, 'foobar')至关于 del x.foobar.

类  dict (* * kwarg)

类  dict (映射,* * kwarg)

类  dict (iterable,* * kwarg)

建立一个新字典。的 dict对象字典类。看到 dict和 映射类型——dict类型关于这个类的文档。

对于其余容器内置 list, set, tuple类,以及 collections模块。

dir ([对象])

没有参数,返回当前局部范围的名单。与论证,试图返回有效的属性的对象的列表。

若是对象有一个名为的方法 __dir__(),这个方法将被称为,必须返回属性的列表。这样就能够实现一个自定义的对象 __getattr__()或 __getattribute__()功能定制 dir()报告它们的属性。

若是对象没有提供 __dir__(),功能尽可能从对象的收集信息 __dict__属性,若是定义,并从其类型对象。结果不必定是完整的列表,和对象有一个自定义时可能不许确 __getattr__().

默认的 dir()机制不一样的行为与不一样类型的对象,由于它试图产生最相关的,而不是完整的信息:

• 若是对象是一个模块对象,列表包含模块的属性的名称。
• 若是对象是一个类型或类对象,列表包含它的属性的名称和属性的递归的基地。
• 不然,该列表包含该对象的属性的名称、类的属性的名称和属性的递归的类的基类。

生成的列表按字母顺序排序。例如:

>>> a={}
>>> dir(a)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__forma
t__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__
le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setat
tr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get
', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>

请注意

由于 dir()主要是提供方便使用交互式提示符,它试图提供一组有趣的名字超过它试图提供一个严格或定义一致的组名称,并在发布其详细的行为可能会改变。例如,元类属性不是在结果列表参数是一个类。

divmod (一个,b)

取两个(非复杂)的数字做为参数并返回一个数字组成的商和余数当使用整数的除法。与混合操做数类型,二进制算术运算符的规则适用。为整数,结果是同样的 (a // b, a % b)。浮点数结果 (q, a % b)一般,问 math.floor(a /b)但可能小于1。在任何状况下 q * b + a % b很是接近,若是 a % b非零和b同样的标志,而后呢 0 <= abs(a % b) < abs(b).

enumerate (iterable,= 0开始)

返回一个枚举对象。iterable必须是一个序列,一个 迭代器或其余对象支持迭代。的 __next__()返回的迭代器的方法 enumerate()返回一个元组,其中包含一个计数(从开始默认为0),并得到的值遍历iterable。

>>>

>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等价于:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

eval (表达式,全局变量=没有当地人=没有)【字符串转成字典】

参数是一个字符串,可选的全局和当地人。若是提供,全局变量必须是一个字典。若是提供,当地人能够是任何对象的映射。

解析表达式参数和评估做为一个Python表达式(技术上来讲,一个条件列表)使用全局和本地词典做为全球和本地名称空间。若是存在全局字典,缺少“__builtins__”,当前全局变量复制到全局解析表达式。这意味着表达式一般有彻底访问的标准 builtins模块和限制环境传播。若是省略当地人字典它默认为全局字典。若是字典都省略了,表达式是在环境中执行 eval()被称为。返回值是计算表达式的结果。语法错误报告为例外。例子:

>>>

>>> x=1

>>> eval('x+1')

2

这个函数也能够用来执行任意代码(好比由对象 compile())。在这种状况下,传递一个代码对象,而不是一个字符串。若是代码对象编译了 'exec'做为模式的参数, eval()的返回值 None.

提示:支持动态执行语句 exec()函数。的 globals()和 locals()函数返回当前全球和本地词典,分别,这多是有用的在使用的 eval()或 exec().

看到 ast.literal_eval()为一个函数,能够安全评估与表达式只包含字符串字面值。

exec (对象[,全局变量[,当地人]])

这个函数支持Python代码的动态执行。对象必须是一个字符串或对象代码。若是它是一个字符串,字符串解析为一套而后执行Python语句(除非出现语法错误)。[1]若是它是一个代码的��象,它只是执行。在全部状况下,预计将是有效执行的代码文件输入(见参考手册中的部分“输入文件”)。请注意, return和 yield语句以外不得使用函数定义的上下文中甚至代码传递到 exec()函数。返回值是 None.

在全部状况下,若是省略可选的部分,执行代码在当前的范围。若是全局变量,它必须是一个字典,将用于全球和本地变量。若是全局变量和当地人,他们用于全球和本地变量,分别。若是提供,当地人能够是任何对象的映射。记住,在模块级别,全局和当地人是相同的字典。若是执行两个独立的对象做为全局变量和当地居民,将执行的代码,就好像它是嵌入在一个类的定义。

若是全局字典不包含一个值的关键 __builtins__,内置的词典模块 builtins插入钥匙。这样你能够控制内置命令能够执行代码插入本身的 __builtins__字典到全局变量传递以前 exec().

请注意

内置的功能 globals()和 locals()返回当前全球和本地词典,分别,这多是有用的在第二和第三个参数使用 exec().

请注意

默认的当地人做为函数的描述 locals()下图:修改默认当地人字典不该该尝试。经过显式的当地人字典若是你须要看后的代码对当地人的影响函数 exec()的回报。

filter (函数,iterable)【一组数据中，过滤出你须要的】

从这些元素的iterable构造迭代器函数返回true。iterable能够是一个���列,一个容器支持迭代,迭代器。若是函数是 None,恒等函数假设,即全部元素的iterable假被删除。

请注意, filter(function, iterable)至关于生成器表达式 (item for item in iterable if function(item))若是函数不 None和 (item for item in iterable if item)若是函数是 None.

看到 itertools.filterfalse()iterable互补函数,它返回元素的函数返回false。

res=filter(lambda n:n>5,range(10))
for i in res:
    print(i)

6
7
8
9

类  float ([x])

返回一个浮点数由一个数字或字符串x。

若是参数是一个字符串,它应该包含一个十进制数,选择以前签署,有选择地嵌入空格。可选的迹象 '+'或 '-'; '+'对产生的价值没有影响。参数也能够是一个字符串表明南(不是一个数字),或积极或消极的无穷。更准确地说,输入后必须符合如下语法前导和尾随空白字符删除:

签名::= " + " |“-”
无穷::=“∞”|“正”
南::= "南"
numeric_value::= |  | 
numeric_string::=(] floatnumberinfinitynansignnumeric_value

在这里 floatnumberPython浮点文字的形式,描述在吗 浮点文字。状况并不明显,因此,例如,“正”、“正”、“∞”和“∞”都是可接受的拼写为正无穷。

不然,若是参数是一个整数或浮点数,浮点数和相同的值(在Python的浮点精度)返回。若是参数是一个Python浮动的范围外,一个 OverflowError将会提升。

对于通常的Python对象 x, float(x)表明 x.__float__().

若是没有给出参数, 0.0返回。

例子:

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

浮子式中描述 数值类型,int、浮点数、复杂.

3.6版本的变化:分组代码中位数与下划线文字是被容许的。

format (价值[,format_spec])

将一个值转换为一个表示“格式化”,由format_spec控制。解释format_spec取决于值的类型参数,然而有一个标准格式使用语法,最内置类型: 格式规范迷你语言.

默认format_spec是一个空字符串一般给调用相同的效果 str(value).

调用 format(value, format_spec)是翻译 type(value).__format__(value, format_spec)它绕过了实例的字典当寻找价值的 __format__()方法。一个 TypeError若是搜索的方法达到异常 objectformat_spec非空,或者若是format_spec或返回值不是字符串。

3.4版本的变化: object().__format__(format_spec)提出了 TypeError若是format_spec不是一个空字符串。

类  frozenset ([iterable])【不可变集合】

返回一个新的 frozenset对象,可选元素取自iterable。 frozenset是一个内置的类。看到 frozenset和 类型——集合,frozenset关于这个类的文档。

对于其余容器内置 set, list, tuple, dict类,以及 collections模块。

getattr (对象,的名字[,默认的])

返回指定属性的值的对象。名称必须是一个字符串。若是字符串是对象的一个属性的名字,结果是,属性的值。例如, getattr(x, 'foobar')至关于 x.foobar。若是指定的属性不存在,返回默认若是提供,不然 AttributeError是提升。

globals ()【返回整个程序里面的变量和变量值的字典形式，变量：keys  变量值：vlaues】

返回一个表明当前全局符号表字典。这老是当前模块的字典(在一个函数或方法,这是定义的模块,不叫作的模块)。

>>> globals()
{'Iterable': <class 'collections.abc.Iterable'>, 'Iterator': <class 'collections.abc.Iterator'>, 'he
llo': <function hello at 0x0000000000D71B70>, '__builtins__': <module 'builtins' (built-in)>, '__pac
kage__': None, 'b': bytearray(b'dbcde'), '__doc__': None, 'res': <filter object at 0x0000000000D7886
0>, '__name__': '__main__', '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporte
r'>, 'a': 'abcd'}
>>>

hasattr (对象,的名字)

的参数是一个对象和一个字符串。结果是 True若是字符串是对象的一个属性的名字, False若是不是。(这是经过调用实现的 getattr(object, name)看到它是否提出了一个 AttributeError不信)。

hash (对象)

返回对象的散列值(若是它有一个)。散列值是整数。他们是用来快速比较在字典查找字典键。数值比较平等有相同的散列值(即便他们是不一样类型的,1和1.0)同样。

请注意

与自定义对象 __hash__()方法,注意, hash()返回值截断基于主机的位宽。看到 __hash__()获取详细信息。

help ([对象])

调用内置的帮助系统。(这个函数是用于交互式使用。)若是没有参数,翻译上的互动帮助系统启动控制台。若是参数是一个字符串,字符串查找模块的名称,函数,类,方法,关键字,或文档的主题,一个帮助页面打印在控制台上。若是参数是任何其余类型的对象,生成一个对象上的帮助页面。

这个函数添加到内置的名称空间 site模块。

3.4版本的变化:更改 pydoc和 inspect意味着报道签名可调用如今更全面和一致的。

hex (x)

把一个整数转换成小写的十六进制字符串前缀“0 x”,例如:

>>> hex(1)
'0x1'
>>> hex(16)
'0x10'
>>> hex(32)
'0x20'
>>> hex(255)
'0xff'

若是x是Python int对象,它必须定义一个__index__()方法,它返回一个整数。

另请参阅 int()将十六进制字符串转换为一个整数使用16的基地。

请注意

得到一个浮动的十六进制字符串表示,使用 float.hex()方法。

id (对象)

返回一个对象的“身份”。这是一个整数保证独特和常数这个对象在它的生命周期。两个对象重叠寿命可能有相同的 id()价值。

CPython的实现细节:这是在内存中对象的地址。

input ([提示])

若是提示存在争论,末尾写到标准输出没有换行符。从输入函数而后读取一行,将其转换为一个字符串(剥离后换行),并返回。当EOF阅读, EOFError是提升。例子:

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

若是 readline模块被加载 input()将使用它来提供详尽的行编辑和历史特征。

类  int (x = 0)

类  int (x,基础= 10)

返回一个整数对象由一个数字或字符串x,或者退货 0若是没有参数。若是x是一个数字,回报 x.__int__()。对于浮点数,这对截断零。

若是x不是不少或者基地,那么x必须是一个字符串, bytes,或 bytearray实例表明一个 整数字面在基数基础。可选地,能够以前的文字 +或 -(没有之间的空间)和周围的空白。base-n文字由数字0到n - 1, a来 z(或 A来 Z10 - 35)值。默认的基础是10。容许的值是0,转动。以2为底,8,-16文字能够选择前缀 0b/0B, 0o/0O,或 0x/0X在代码中,与整数文字。基地0意味着代码字面解释同样,因此实际的基础是2,8,10或16,因此 int('010', 0)是不合法的,int('010')是,以及 int('010', 8).

描述的整数类型 数值类型,int、浮点数、复杂.

3.4版本的变化:若是基础不是的一个实例 int和基础对象 base.__index__方法,调用方法得到一个整数的基地。使用之前的版本 base.__int__而不是 base.__index__.

3.6版本的变化:分组代码中位数与下划线文字是被容许的。

isinstance (对象,classinfo)

返回true,若是参数是对象的一个实例classinfo论点,或(直接、间接或 虚拟)子类。若是对象不是一个给定类型的对象,函数始终返回false。若是classinfo tuple类型的对象(或递归,其余元组),返回true,若是对象是任何类型的一个实例。若是classinfo不是一个类型或元组的类型和元组等 TypeError例外。

issubclass (类,classinfo)

返回true,若是类(直接、间接或一个子类 虚拟classinfo)。一个类被认为是自身的一个子类。classinfo多是一个类对象的元组,在这种状况下,每个进入classinfo将检查。在任何其余状况下, TypeError例外。

iter (对象[,哨兵])

返回一个 迭代器对象。第一个参数是解释不一样的根据第二个参数的存在。没有第二个参数,对象必须是一组对象支持迭代协议( __iter__()方法),或它必须支持序列协议( __getitem__()方法用整数参数开始 0)。若是它不支持的协议, TypeError是提升。哨兵,若是第二个参数,那么对象必须是一个可调用对象。在这种状况下,建立的迭代器将为每一个调用不带参数调用对象 __next__()方法;若是返回的值等于哨兵, StopIteration将提升,不然将返回值。

另请参阅 迭代器类型.

第二种的一个有用的应用程序 iter()是读取行一个文件直到到达必定行。下面的例子将读取一个文件,直到 readline()方法返回一个空字符串:

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len (年代)

返回对象的长度(项目)的数量。参数能够是一个序列(如一个字符串,字节,tuple,列表,或范围)或一组(如字典、集,或冷冻集)。

类  list ([iterable])

而不是一个函数, list其实是一个可变的序列类型,记录在吗 列表和 序列类型——列表、元组、范围.

locals ()【返回局部变量里面的数据】

字典更新并返回一个表示当前本地符号表。自由变量返回 locals()当它被称为功能块,但不是在课堂上。

请注意

这本字典的内容不该被修改;变化可能不会影响当地和自由变量的值所使用的翻译。

map (函数,iterable, ...)

返回一个迭代器函数适用于每件iterable,产生结果。若是额外iterable参数传递,函数必须采起许多参数和应用于项目并行iterable。与多个iterable,迭代器中止当最短的iterable耗尽。状况下,函数已经安排输入参数元组,明白了itertools.starmap().

max (iterable, *[的关键,默认的])

max (__arg一、最长,* args[,关键])

返回iterable或最大的项目中最大的两个或两个以上的参数。

若是提供了一个位置参数,它应该是一个 iterable。最大的项目返回iterable。若是提供两个或两个以上的位置参数,返��最大的位置参数。

有两个可选keyword-only参数。关键参数指定一个参数排序函数用于 list.sort()。默认参数指定一个对象返回,若是提供iterable是空的。若是iterable为空,默认不提供, ValueError是提升。

若是多个项目最大,函数返回第一个。这是符合其余sort-stability保留等工具 sorted(iterable, key=keyfunc, reverse=True)[0]和 heapq.nlargest(1, iterable, key=keyfunc).

在新的3.4版本:默认keyword-only论点。

res=map(lambda n:n>5,range(10))
for i in res:
   print(i)

False
False
False
False
False
False
True
True
True
True

memoryview (obj)

返回一个“内存视图对象建立从给定的参数。看到 内存视图为更多的信息。

min (iterable, *[的关键,默认的])

min (__arg一、最长,* args[,关键])

返回最小项iterable或最小的两个或两个以上的参数。

若是提供了一个位置参数,它应该是一个 iterable。最小的项目返回iterable。若是提供两个或两个以上的位置参数,返回最小的位置参数。

有两个可选keyword-only参数。关键参数指定一个参数排序函数用于 list.sort()。默认参数指定一个对象返回,若是提供iterable是空的。若是iterable为空,默认不提供, ValueError是提升。

若是多个项目是最小的,函数返回第一个。这是符合其余sort-stability保留等工具 sorted(iterable, key=keyfunc)[0]和 heapq.nsmallest(1, iterable, key=keyfunc).

在新的3.4版本:默认keyword-only论点。

next (迭代器[,默认的])

检索从迭代器经过调用它的下一个项目 __next__()方法。若是违约,它返回迭代器是否耗尽,不然 StopIteration是提升。

类  object

返回一个新的无特点的对象。 object是全部类的一个基地。它的方法是常见的Python类的全部实例。这个函数不接受任何参数。

请注意

object没有一个 __dict__,因此你不能指定任意属性的一个实例 object类。

oct (x)

整数转换为八进制数的字符串。结果是一个有效的Python表达式。若是x是Python int对象,它必须定义一个 __index__()方法返回一个整数。

open (文件,模式= ' r ',缓冲= 1,编码=没有错误=没有换行符= None,closefd = True,刀=没有)

打开文件并返回一个对应的 文件对象。若是文件不能打开,一个 OSError是提升。

文件是一个 就对象给路径名(绝对或相对于当前工做目录)的文件打开或整数包装文件的文件描述符。(若是一个文件描述符,它关闭时返回的I / O对象是关闭,除非closefd将 False.)

模式是一个可选的字符串,指定了模式的文件打开。它默认为 'r'这意味着在文本模式打开阅读。其余常见的值 'w'写做(删除文件若是它已经存在), 'x'为独家建立和 'a'为附加(在某些Unix系统,意味着全部写附加到文件的末尾无论当前寻求位置)。在文本模式下,若是没有指定编码的编码使用平台的依赖: locale.getpreferredencoding(False)被称为当前语言环境编码。(阅读和写做的原始字节使用二进制模式和编码未指明的离开。)可用的模式是:

字符	意义
'r'	开放阅读(默认)
'w'	开放的写做,首先删除文件
'x'	开放独家创造,失败若是文件已经存在
'a'	开放的写做,附加的文件若是它存在
'b'	二进制模式
't'	文本模式(默认)
'+'	打开磁盘文件更新(阅读和写做)
'U'	广泛的换行模式(弃用)

默认的模式是 'r'(打开阅读文本,同义词 'rt')。对于二进制读写访问模式 'w+b'打开,这样就为0字节的文件。 'r+b'打开文件没有截断。

正如前面提到的, 概述,Python区分二进制和文本I / O。打开的文件(包括以二进制模式 'b'模式参数)返回的内容 bytes对象没有任何解码。在文本模式(默认,或者当 't'包含在模式参数),返回文件的内容是 str,字节被首先使用平台相关的编码或解码编码若是使用指定的。

请注意

Python不依赖于底层操做系统概念的文本文件,全部的处理是经过Python自己,所以独立于平台的。

缓冲是一个可选的整型用于设置缓冲政策。经过0关闭缓冲(只容许在二进制模式),1选择行缓冲(仅在文本模式下可用),和一个整数> 1代表固定大小的块的大小的字节缓冲区。当没有缓冲参数,默认缓冲策略工做以下:

• 二进制文件缓存在固定大小的块,缓冲区的大小是选择使用启发式试图肯定底层设备的块大小和回落 io.DEFAULT_BUFFER_SIZE。在许多系统中,缓冲区一般是4096或8192字节。
• “互动”的文本文件(文件 isatty()返回 True)使用行缓冲。其余文本文件为二进制文件使用上述政策。

编码所使用的编码解码的名称或编码文件。这应该只用于文本模式。默认的编码是依赖于平台(无论 locale.getpreferredencoding()返回),但任何 文本编码可使用Python支持。看到 codecs模块支持的编码列表。

错误是一个可选的字符串指定编码和解码错误是如何处理这种不能用于二进制模式。各类标准的错误处理程序(如下列出 错误处理程序),尽管任何错误处理名称已被注册 codecs.register_error()也是有效的。标准的名称包括:

• 'strict'提升一个 ValueError若是有一个编码错误异常。的默认值 None有一样的效果。
• 'ignore'忽略错误。注意,忽略编码错误可能致使数据丢失。
• 'replace'致使替换标记(如 '?')插入哪里有畸形的数据。
• 'surrogateescape'将表明任何错误的字节在Unicode代码点私人使用面积从U + U + DCFF DC80。这些私人代码点就会转回时相同的字节 surrogateescape错误处理程序写入数据时使用。这是有用的在一个未知的编码处理文件。
• 'xmlcharrefreplace'只有当写入一个文件的支持。不支持的字符编码替换为适当的XML字符引用 &#nnn;.
• 'backslashreplace'经过Python的斜转义序列替换畸形数据。
• 'namereplace'(也写做时仅支持)取代了不支持的字符 \N{...}转义序列。

换行符控制 广泛的换行工做模式(它只适用于文本模式)。它能够 None, '', '\n', '\r', '\r\n'。它的工做原理以下:

• 阅读时的输入流,若是换行符 None,环球换行模式启用。行输入能够结束 '\n', '\r',或 '\r\n',这些都是翻译成 '\n'以前返回给调用者。若是它是 ''通用换行模式启用,但结局都是返回给调用者翻译。若是有任何其余的法律价值观,输入行只是被给定字符串终止,和行结束返回给调用者未翻译。
• 当编写输出流,若是换行符 None,任何 '\n'写字符转换到系统默认行分隔符, os.linesep。若是换行符 ''或 '\n',没有翻译。若是任何其余法律价值换行, '\n'字符是给定字符串翻译写的。

若是closefd False和一个文件描述符,而不是一个文件名,底层文件描述符将保持关闭打开的文件。若是一个文件名closefd必须给出 True(默认),不然,它会抛出一个错误。

可使用一个定制刀经过一个可调用的。底层文件描述符的文件对象而后经过调用刀(文件、旗帜)。开瓶器必须返回一个打开的文件描述符(传递 os.open比赛结果在功能上相似于传递 None).

新建立的文件 non-inheritable.

下面的例子使用了 dir_fd参数的 os.open()函数打开一个文件相对于给定目录:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor　

的类型 文件对象返回的 open()函数依赖于模式。当 open()用来打开一个文件在一个文本模式('w', 'r', 'wt', 'rt'等),它返回的一个子类 io.TextIOBase(特别是 io.TextIOWrapper)。当用于与缓冲以二进制方式打开一个文件,返回的类的一个子类 io.BufferedIOBase。确切的阶级���同:在读取二进制模式下,它返回一个 io.BufferedReader;在写二进制和附加二进制模式,它返回一个 io.BufferedWriter以读/写模式,它返回一个 io.BufferedRandom。禁用缓冲时,原始流的一个子类 io.RawIOBase, io.FileIO,返回。

参见文件处理模块,如 fileinput, io( open()声明), os, os.path, tempfile, shutil.

3.3版本的变化:

• 刀参数了。
• 的 'x'模式是补充道。
• IOError用于提升,如今的别名 OSError.
• FileExistsError如今在独家建立模式(若是文件打开'x')已经存在。

3.4版本的变化:

• 文件如今non-inheritable。

弃用自3.4版本,4.0版本将被删除:的 'U'模式。

3.5版本的变化:

• 若是系统调用中断和信号处理器不引起一个异常,该函数如今重试的系统调用,而不是一个 InterruptedError异常(见PEP 475基本原理)。
• 的 'namereplace'添加错误处理程序。

3.6版本的变化:

• 支持添加到接受对象实现 os.PathLike.
• 在Windows上,打开一个控制台缓冲可能返回的一个子类 io.RawIOBase除了 io.FileIO.

ord (c)

给定一个字符串表明一个Unicode字符,返回一个整数表明字符的Unicode代码点。例如, ord('a')返回整数 97和 ord('€')(欧元)的回报 8364。这是的倒数 chr().

pow (x,y[,z])

返回x到y;若是z,返回x y,z模(更有效率比计算 pow(x, y) % z)。双参数形式 pow(x, y)至关于使用权力操做符: x**y.

必定数值类型的参数。混合操做数类型,强迫二进制算术运算符规则适用。为 int操做数,结果有相同的类型做为操做数(胁迫)除非第二个参数是消极的;在这种状况下,全部参数转换为浮动,浮动的结果。例如, 10**2返回 100,但10**-2返回 0.01。若是第二个参数是负的,第三个参数必须省略。若是z,x和y必须是整数类型,和y必须是非负数。

>>> pow(2,2)
4
>>> pow(2,3)
8
>>> pow(2,4)
16

print (*对象,9 = ' ' = ' \ n '结束,文件= sys.stdout,冲洗= False)

打印文本流文件对象,由9月,紧随其后的是结束。9月结束,文件和冲洗,若是存在,必须做为关键字参数。

像全部non-keyword参数转换为字符串 str()和写入到流,由9月,紧随其后的是结束。9月和结束都必须是字符串;他们也能够 None,这意味着使用默认值。若是没有对象, print()只会写。

文件的参数必须是一个对象 write(string)方法,若是它不存在或 None, sys.stdout就会被使用。由于印刷参数转换为文本字符串, print()不能用于二进制模式文件对象。对于这些,使用 file.write(...)代替。

是否输出缓冲一般是由文件,可是若是冲洗关键字参数是正确的,流强制刷新。

3.3版本的变化:添加刷新关键字参数。

类  property (fget = None,fset = None,fdel =没有医生=没有)

返回一个财产属性。

fget函数获取一个属性的值。fset设置一个属性值是一个函数。fdel删除一个属性值是一个函数。和医生建立文档字符串属性。

一个典型的用途是定义一个属性管理 x:

class C:
    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删除人。

若是,医生将因此的财产属性。不然,房地产将复制fget docstring(若是它存在的话)。这使得它能够建立只读属性很容易使用 property()做为一个 装饰:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

的 @property修饰符将 voltage()方法为“getter”为一个只读属性相同的名称,它为电压设置有“获取当前电压”。

属性对象 getter, setter, deleter方法使用修饰符建立一份财产与相应的访问器功能设置为装饰功能。这是用一个例子作了最好的解释:

class C:
    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

这段代码是彻底等价的第一个例子。必定要给额外的函数名称相同的原始属性(x在这种状况下)。

返回的属性对象也有属性 fget, fset, fdel相应的构造函数参数。

3.5版本的变化:如今可写属性的文档字符串对象。

range (中止)

range (开始,中止[,一步])

而不是一个函数, range其实是一个不可变的序列类型,记录在吗 范围和 序列类型——列表、元组、范围.

repr (对象)

返回一个字符串包含一个可打印的表明一个对象。对于许多类型,这个函数使试图返回一个字符串,将产生一个对象传递给时相同的值 eval(),不然表示是用尖括号括起来的字符串,它包含的类型对象的名称加上额外的信息一般包括对象的名称和地址。一个类能够控制经过定义这个函数返回的实例 __repr__()方法。

reversed (seq)

返回一个反向 迭代器。seq必须有一个对象 __reversed__()方法或支持的协议序列( __len__()方法和 __getitem__()方法用整数参数开始 0).

round (数量[,ndigits])

返回数字的小数点后ndigits精度。若是省略ndigits或 None,它返回最近的整数输入。

内置类型支持 round()、价值观四舍五入为最接近的倍数10次方- ndigits;若是两个一样倍数接近,甚至舍入完成向的选择(例如,两个 round(0.5)和 round(-0.5)是 0, round(1.5)是 2)。任何整数的值是有效ndigits(正、零或负)。返回值是一个整数,若是调用了一个参数,不然相同类型的数量。

对于通常的Python对象 number, round(number, ndigits)表明 number.__round__(ndigits).

请注意

的行为 round()花车能够使人惊讶:例如, round(2.675, 2)给了 2.67而不是预期的 2.68。这不是一个错误:这是一个事实,大多数的结果小数分数不能彻底表示为一个浮点数。看到 浮点运算:问题和局限性为更多的信息。

>>> round(1.3654)
1
>>> round(1.3654,2)
1.37
>>> round(1.3654,3)
1.365

类  set ([iterable])

返回一个新的 set对象,可选元素取自iterable。 set是一个内置的类。看到 set和 类型——集合,frozenset关于这个类的文档。

对于其余容器内置 frozenset, list, tuple, dict类,以及 collections模块。

setattr (对象,名字,价值)

这是相对应的 getattr()。参数是一个对象,一个字符串和一个任意值。字符串可能现有的属性或一个新属性名称。函数分配价值属性,提供了对象容许它。例如, setattr(x, 'foobar', 123)至关于 x.foobar = 123.

类  slice (中止)

类  slice (开始,中止[,一步])

返回一个 片对象表明指定的一系列指标 range(start, stop, step)。参数默认的启动和步骤 None。片有只读数据属性的对象 start, stop和 step这仅仅是返回的参数值(或违约)���他们没有其余明确的功能,可是它们使用Numerical Python和其余第三方扩展。部分对象也使用时生成扩展索引的语法。例如: a[start:stop:step]或 a[start:stop, i]。看到 itertools.islice()返回一个迭代器的另外一个版本。

sorted (iterable[,][,反向))

返回一个新的iterable项目的有序列表。

有两个可选参数必须指定为关键字参数。

键指定一个参数的函数,用于提取比较主要从每一个列表元素: key=str.lower。默认值是 None(比较直接的元素)。

相反的是一个布尔值。若是设置为 True,那么列表元素排序好像每一个比较逆转。

使用 functools.cmp_to_key()一个老式的cmp函数转换为一个关键功能。

内置的 sorted()功能是保证稳定。排序是稳定的,若是保证不改变元素的相对顺序比较平等——这有助于排序在多个传递(例如,由部门,而后由工资等级)。

用于排序的例子和一个简短的排序教程,看看 排序如何.

a={1:2,3:5,9:7,98:-12,76:23}
print(sorted(a.items()))
print(sorted(a.items(),key=lambda x:x[1] ))
print(a)

[(1, 2), (3, 5), (9, 7), (76, 23), (98, -12)]
[(98, -12), (1, 2), (3, 5), (9, 7), (76, 23)]
{1: 2, 98: -12, 3: 5, 76: 23, 9: 7}

staticmethod (函数)

函数返回一个静态方法。

静态方法不能获得一个隐式的第一个参数。要声明一个静态方法,使用这个成语:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

的 @staticmethod表单是一个函数 装饰——看到函数定义的描述 函数定义获取详细信息。

它能够被称为类(如 C.f()(好比)或在一个实例 C().f())。除了它的类实例被忽略。

静态方法在Python中发现相似Java或c++。也看到 classmethod()为建立有用的变体替代类构造函数。

有关静态方法的更多信息,请参考文档标准类型层次结构 标准的类型层次结构.

类  str (对象= ")

类  str (对象= b”,编码=“utf - 8”,错误=“严格的”)

返回一个 str版本的对象。看到 str()获取详细信息。

str是内置的字符串 类。对于通常信息字符串,明白了 文本序列类型- str.

sum (iterable[,开始])

资金开始和iterable从左到右的物品并返回。开始违约 0。iterable的项目一般是数字,开始值不能是一个字符串。

对于一些用例,有很好的替代品 sum()。的首选,快速链接字符串序列的方法是经过调用 ''.join(sequence)。添加和扩展精度浮点值,明白了 math.fsum()。链接一系列iterable,考虑使用 itertools.chain().

super ([类型[,对象或者类型]])

方法调用返回一个代理对象,表明父母或兄弟姐妹的类型。这是很是有用的用于访问被覆盖在一个类继承的方法。使用的搜索顺序是同样的 getattr()除了类型自己是跳过。

的 __mro__属性的类型列表使用的方法解析搜索顺序 getattr()和 super()。属性是动态的,能够改变,不管什么时候更新继承层次结构。

若是省略第二个参数,返回超级对象是不受约束的。若是第二个参数是一个对象, isinstance(obj, type)必须是真实的。若是第二个参数是一个类型, issubclass(type2, type)必须是真实的(这是有用的类方法)。

有两个超级的典型用例。与单继承一个类层次结构,可使用超级引用父类没有明确命名它们,从而使代码更易于维护。这个用密切的类似之处在其余编程语言中使用的。

第二个用例是支持合做动态执行环境中多重继承。这个用例是独一无二的,没有找到Python和静态编译语言或语言只支持单继承的。这使得它能够实现“钻石图”,多个基类实现相同的方法。好的设计要求,该方法具备相同的调用签名在任何状况下(由于在运行时调用的顺序决定,由于为了适应类层次结构的变化,由于这个顺序能够包括兄弟姐妹类运行时)以前是未知的。

对于这两个用例,一个典型的超类是这样的:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

请注意, super()被实现为绑定过程的一部分等明确的虚线属性查找 super().__getitem__(name)。它经过实现本身 __getattribute__()搜索类的方法预测订单,支持合做多重继承。所以, super()是隐式定义查找使用语句或运营商如 super()[name].

还要注意,除了零参数形式, super()并不局限于使用内部的方法。这两个论点形式指定参数准确,使适当的引用。零参数形式只能在类的内部定义,编译器填写必要的细节正确检索被定义的类,以及访问当前实例的普通方法。

实际的建议关于如何设计合做类使用 super(),请参阅指南使用super().

tuple ([iterable])

而不是一个函数, tuple其实是一个不可变的序列类型,记录在吗 元组和 序列类型——列表、元组、范围.

类  type (对象)

类  type (名称、基地dict)

一个参数,返回一个对象的类型。返回值是一个对象类型和一般返回的对象同样 object.__class__.

的 isinstance()内置函数建议测试一个对象的类型,由于它考虑了子类。

有三个参数,返回一个新的类型对象。这本质上是一个动态的形式 class声明。这个名字是类名,成为字符串 __name__元组属性;基地列举了基类,变成了 __bases__属性;关键字词典是包含类定义的名称空间的身体和复制到成为一个标准的字典 __dict__属性。例如,如下两个语句建立相同的 type对象:

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

另请参阅 类型的对象.

3.6版本的变化:的子类 type不覆盖 type.__new__可能再也不使用一个参数形式来得到一个对象的类型。

vars ([对象])

返回 __dict__属性模块、类实例,或任何其余对象 __dict__属性。

对象模块和实例等可更新 __dict__属性;可是,其余对象可能会限制他们的写 __dict__属性(例如,使用一个类 types.MappingProxyType为了防止直接字典更新)。

没有一个论点, vars()就像 locals()。注意,当地人字典只用于读取以来更新当地人字典被忽略。

zip (* iterable)

作一个集合元素的迭代器从每一个iterable。

返回一个迭代器的元组,其中的第i个tuple包含每一个参数序列的第i个元素或iterable。输入迭代器中止时最短iterable耗尽。用一个iterable论点,它返回一个迭代器1-tuples。不带参数,它将返回一个空的迭代器。等价于:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

的评价从左到右顺序iterable保证。这使可能的成语集群数据系列分为n-length组使用 zip(*[iter(s)]*n)。这种重复相同的迭代器 n次,这样每一个输出元组的结果 n调用迭代器。这样作的效果是将输入分红n-length块。

zip()只能使用不平等的长度输入当你不关心的,无与伦比的值再也不iterable。若是这些值很重要,使用 itertools.zip_longest()代替。

zip()会同 *操做符能够用来解压缩一个列表:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

__import__ (名称、全局变量=没有当地人= None,fromlist =(),水平= 0)

请注意

这是一个先进的功能,不须要在天天的Python编程,不像 importlib.import_module().

这个函数被调用的 import声明。它能够(经过进口替代 builtins模块和分配 builtins.__import__为了改变语义的 import声明,但不提倡这样作,由于它一般是更简单的使用进口挂钩(见PEP 302)实现相同的目标,不会致使问题的代码假定默认实现使用的进口。直接使用 __import__()也不同意吗 importlib.import_module().

导入功能模块名称,可能使用给定的全局和当地人来决定如何解释这个名字在包上下文。fromlist给的名字应该进口的对象或子模块的名字。标准实现不使用它的当地人参数,并使用它的全局惟一肯定的包上下文 import声明。

指定是否使用绝对或相对进口水平。 0(默认)意味着只有执行绝对进口。积极的水平值显示的数量相对于目录的父目录搜索模块调用 __import__()(见PEP 328的详细信息)。

当表单的变量的名称 package.module,正常状况下,顶层包(这个名字到第一个点)返回,而不是模块的名字命名。然而,当一个非空fromlist参数,返回模块命名的名字。

例如,语句 import spam结果在字节码相似下面的代码:

spam = __import__('spam', globals(), locals(), [], 0)

该声明 import spam.ham这个调用的结果:

spam = __import__('spam.ham', globals(), locals(), [], 0)

请注意 __import__()返回顶层的模块,由于这是由对象绑定到一个名称 import声明。

另外一方面,这一声明 from spam.ham import eggs, sausage as saus结果

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在这里, spam.ham模块是回来 __import__()。从这个对象中,导入名称检索并分配给各自的名字。

若是你只是想要导入一个模块(可能在一个包)的名字,使用 importlib.import_module().

3.3版本的变化:负值为水平再也不支持(也改变默认值为0)。

 

软件目录结构规范

http://www.cnblogs.com/alex3714/articles/5765046.html