www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

Python自动化运营开采实战,学习笔记

2019-08-31 03:04 来源:未知

Python 学习笔记(十三)Python函数(二),学习笔记python函数

参数和变量

1 >>> def foo(a,b):  #函数是一个对象
2     return a b
3 
4 >>> p =foo #对象赋值语句。将foo函数赋值给p这个变量
5 >>> foo(4,5)
6 9
7 >>> p(4,5) 变量p就指向了foo这个函数
8 9
9 >>> 

 按援引传递参数

  根据顺序实行赋值,函数中的变量a就本着了x,x是第一个实参,a这几个参数指向了x所引述的对象,并非把3这几个数复制八个放手函数中,这种调用对象的措施,称之为按援引传递。

 1 >>> x,y=3,4 #x,y两个变量分别指向了3和4
 2 >>> foo(x,y) #函数中有两个参数a和b
 3 7
 4 >>> def bar(x):
 5     x =1
 8 >>> m = 9
 9 >>> bar(m)
10 >>> m
11 9
12 >>> 

  叁个顺序的装有的变量并不是在哪个地方都足以访谈的。访问权限调整于那几个变量是在哪儿赋值的。

  变量的功效域决定了在哪部分程序你能够访问哪个特定的变量名称。两种最基本的变量成效域如下:

  全局变量和部分变量

  定义在函数内部的变量具备一个片段作用域,定义在函数外的保有全局效能域。

  局地变量只好在其被声称的函数内部访谈,而全局变量能够在总体程序范围内访问。调用函数时,全数在函数内表明的变量名称都将被插手到功效域中

 1 >>> x =2  #全局变量
 2 >>> def foo():
 3     x =9     #局部变量
 4     print "this x is the fun:",x
 5 
 6     
 7 >>> foo()
 8 this x is the fun: 9
 9 >>> x
10 2
  函数中的x 与函数外面的x,是不一样的。我们把像x=9这样的x,作用于某个函数体范围内的,称之为局部变量。
11 >>> def bar(): 
12     global x #在函数体中声明全局变量
13     x =9
14     print "this x is the fun:",x
15 
16     
17 >>> x
18 2
19 >>> bar()
20 this x is the fun: 9
21 >>> x
22 9
23 >>> 

取名空间:命名空间是对效用域的一种特殊抽象

参数收罗和传值

收罗情势1:*args  

  * args 是以元组的花样选择参数

 1 >>> def foo(*arg):
 2     print arg
 3 
 4     
 5 >>> foo(1,2,3)
 6 (1, 2, 3)     #元组形式接收参数
 7 >>> foo("baidu","ali","qq","weixin")
 8 ('baidu', 'ali', 'qq', 'weixin')
 9 >>> foo("web",[1,2,3,"pythom"])
10 ('web', [1, 2, 3, 'pythom'])
11 >>> def foo(x,*arg):
12     print "x:",x
13     print "arg:",arg
14 
15     
16 >>> foo(1,2,3)
17 x: 1
18 arg: (2, 3)
19 >>> foo(7)
20 x: 7
21 arg: ()
22 >>> 

访谈情势2:**kargs 是以字典方式采纳参数

 1 >>> def foo(**karg):
 2     print karg
 3 
 4     
 5 >>> foo(a=1,b=2,c=3)
 6 {'a': 1, 'c': 3, 'b': 2}
 7 >>> def foo(x,*arg,**karg):
 8     print x
 9     print arg
10     print karg
11 
12     
13 >>> foo(1)
14 1
15 ()
16 {}
17 >>> foo(1,2)
18 1
19 (2,)
20 {}
21 >>> foo(1,2,3)
22 1
23 (2, 3)
24 {}
25 >>> foo(1,2,3,name="python")
26 1
27 (2, 3)
28 {'name': 'python'}
29 >>> 

>>> def book(author,name):
    print "{0} has a book :{1}".format(author,name)


>>> bars={"name":"learn python with cc","author":"cc"}
>>> book(**bars)
cc has a book :learn python with cc
>>> 

非同一般函数

zip() 补充

 1 >>> colors =["red","green","blue"]
 2 >>> values=[234,12,89,65]
 3 >>> zip(colors,values)
 4 [('red', 234), ('green', 12), ('blue', 89)]
 5 >>> dots=[(1,2),(3,4),(5,6)]
 6 >>> x,y=zip(*dots)
 7 >>> x
 8 (1, 3, 5)
 9 >>> y
10 (2, 4, 6)
11 >>> seq =range(1,10)
12 >>> zip(*[iter(seq)]*3)
13 [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
14 >>> x =iter(range(1,10))
15 >>> x
16 <listiterator object at 0x0000000003E8F860>
17 >>> list(x)
18 [1, 2, 3, 4, 5, 6, 7, 8, 9]
19 >>> zip(x,x,x)
20 []
21 >>> x=iter(range(1,10))
22 >>> zip(x,x,x)
23 [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
24 >>> 

lambda  lambda x: x y lambda 变量: 表达式

map、reduce、filter

 1 >>> def foo(x):
 2     x -3
 3     return x
 4 
 5 >>> foo(4)
 6 4
 7 >>> n =range(10)
 8 >>> n
 9 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
10 >>> [i 3 for i in n ]
11 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
12 >>> lam =lambda x:x 3
13 >>> n2=[]
14 >>> for i in n
15 SyntaxError: invalid syntax
16 >>> for i in n:
17     n2.append(lam(i))
18 
19     
20 >>> n2
21 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
22 >>> g =lambda x,y:x y
23 >>> g(3,4)
24 7
25 >>> lambda x:x 4
26 <function <lambda> at 0x0000000003E91438>
27 >>> n
28 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
29 >>> map(foo,n)
30 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
31 >>> map(lambda x:x 3,n)
32 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
33 >>> lst1 =[1,2,3,4,5]
34 >>> lst2=[6,7,8,9,0]
35 >>> map(lambda x,y:x y,lst1,lst2)
36 [7, 9, 11, 13, 5]
37 >>> reduce(lambda x,y:x y,lst1)
38 15
39 >>> n =range(-5,5)
40 >>> n
41 [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
42 >>> filter(lambda x:x>0,n)
43 [1, 2, 3, 4]
44 >>> [x for x in n if x>0]
45 [1, 2, 3, 4]
46 >>> 

学习笔记(十三)Python函数(二),学习笔记python函数 参数和变量 1 def foo(a,b): #函数是三个目的 2 return a b 3 4 p = foo #目的赋值语句。...

参数和变量

导语:

函数是团体好,可重复使用,用来贯彻单一或相关联成效的代码段,能增高使用的模块性和代码的双重利用率。
Python提供了众多内建函数,举个例子print()。
也能够友善创立函数,被堪称客商自定义函数。

1 >>> def foo(a,b):  #函数是一个对象
2     return a b
3 
4 >>> p =foo #对象赋值语句。将foo函数赋值给p这个变量
5 >>> foo(4,5)
6 9
7 >>> p(4,5) 变量p就指向了foo这个函数
8 9
9 >>> 

概念函数:

规则:

函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法:

   def functionname( parameters ):
       "函数_文档字符串"
       function_suite
       return [expression]

例:
#!/usr/bin/python
def printme( str ): # 定义函数
"打字与印刷任何传入的字符串"
print str
return

 按援引传递参数

调用函数

printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

以上实例输出结果:
我要调用用户自定义函数!
再次调用同一函数

  根据顺序实行赋值,函数中的变量a就本着了x,x是第二个实参,a这几个参数指向了x所引用的指标,实际不是把3以此数复制三个放权函数中,这种调用对象的方法,称之为按引用传递。

按援引传递参数:

所有参数在Python里都是按引用传递。如果你在函数里修改了参数,那么在调用这个函数的
函数里,原始的参数也被改变了。

例:
#!/usr/bin/python
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print "函数内取值: ", mylist
return

# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ",mylist

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下:
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
 1 >>> x,y=3,4 #x,y两个变量分别指向了3和4
 2 >>> foo(x,y) #函数中有两个参数a和b
 3 7
 4 >>> def bar(x):
 5     x =1
 8 >>> m = 9
 9 >>> bar(m)
10 >>> m
11 9
12 >>> 

文书档案字符串

我们在利用def 关键字定义一个函数时,其后必得跟有函数名和满含方式参数的圆括号。函数体的下一行开首,必得是缩进的。函数体的首先行能够是字符串,这一个字符串正是文书档案字符串documentation string,经常也称作:docstring

  三个主次的兼具的变量并非在哪个地点都能够访谈的。访谈权限调节于那一个变量是在哪个地方赋值的。

定义:

在函数体的第一行,可以使用一对三引号(''')或者(""")来定义文档字符串,文档字符串通常第一行以大写字母开头,以句号 (.)结束,第二行是空行,第三行开始是详细描述。强烈建议为你重要的函数写文档字符串都遵循此惯例。

  变量的功用域决定了在哪一部分顺序你能够访谈哪个特定的变量名称。二种最大旨的变量功能域如下:

作用:

文档字符串是使用Python过程中一个很重要的工具,他对程序文档很有帮助,使程序很容易理解。甚至当程序运行的时候,可以从一个函数中返回文档字符串。把函数当做一个对象来看,这更有助于我们的理解,就相当于获取一个对象的属性(__doc__).

  全局变量和局地变量

函数文书档案字符串举个例子:

#cat nester.py    这是一个模块文件
#!/usr/bin/env python3
"这是模块文档字符串"
def print_list(name):
    '''这是函数文档字符串'''
    for each_item in name:
        if isinstance(each_item,list):
            print_list(each_item)
        else:
            print each_item

#python         
>>> import nester           
>>> print nester.print_list.__doc__
这是函数文档字符串
>>> help(nester)
Help on module nester:
NAME
    nester - 这是模块文档字符串
FILE
    /python/nester.py
FUNCTIONS
    print_list(name)
        这是函数文档字符串
(END) 

  定义在函数内部的变量具有三个有的成效域,定义在函数外的拥有全局作用域。

参数:

调用函数时可使用的参数类型:
• 必备参数
• 关键字参数
• 私下认可参数
• 不定长参数

  局地变量只可以在其被声称的函数内部访谈,而全局变量能够在总体程序范围内访问。调用函数时,全部在函数内注脚的变量名称都将被参与到功能域中

必备参数:

必备参数须以科学的顺序传入函数。调用时的数目必需和注脚时的同样。
举例调用printme()函数,你必需传入七个参数,不然会油可是生语法错误:
#!/usr/bin/python
def printme( str ):
print str;
return;

#调用printme函数
printme();

出口结果:
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)

 1 >>> x =2  #全局变量
 2 >>> def foo():
 3     x =9     #局部变量
 4     print "this x is the fun:",x
 5 
 6     
 7 >>> foo()
 8 this x is the fun: 9
 9 >>> x
10 2
  函数中的x 与函数外面的x,是不一样的。我们把像x=9这样的x,作用于某个函数体范围内的,称之为局部变量。
11 >>> def bar(): 
12     global x #在函数体中声明全局变量
13     x =9
14     print "this x is the fun:",x
15 
16     
17 >>> x
18 2
19 >>> bar()
20 this x is the fun: 9
21 >>> x
22 9
23 >>> 

第一字参数:

重大字参数和函数调用关系紧凑,函数调用使用首要字参数来明确传入的参数值。
利用重要字参数允许函数调用时参数的相继与注解时不一样,因为 Python 解释器可以用参数名相配
参数值。
以下实例在函数 printme() 调用时使用参数名:
#!/usr/bin/python3
def printme( str ):
print str;
return;

#调用printme函数
printme( str = "My string");

输出结果: 
My string

下例能将重大字参数顺序不重大体现得更清楚:
#!/usr/bin/python3
def printinfo( name, age ):
print "Name: ", name;
print "Age ", age;
return;

#调用printinfo函数
printinfo( age=50, name="miki" )

输出结果:
Name:  miki
Age  50

取名空间:命名空间是对成效域的一种新鲜抽象

缺省参数:

调用函数时,缺省参数的值如果未有传到,则被感觉是私下认可值。
下例会打字与印刷暗中同意的age,要是age未有被传出:
#!/usr/bin/python3
def printinfo( name, age = 35 ):
print "Name: ", name;
print "Age ", age;
return;

#调用printinfo函数
printinfo( age=50, name="miki" );
printinfo( name="miki" )

输出结果:
Name:  miki
Age  50
Name:  miki
Age  35

参数收罗和传值

不定长参数:

设若须要二个函数能处理比那时声称时越多的参数。这一个参数叫做不定长参数,和上述2种参数不
同,注明时不会取名。
语法:
def functionname([formal_args,] var_args_tuple ):
function_suite
return [expression]
#加了星号(
)的变量名会寄存全体未命名的变量参数。

例1:
#!/usr/bin/python3
def printinfo( arg1, *vartuple ):
print "输出: "
print arg1
for var in vartuple:
print var
return

# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 )

输出结果:
    输出:
    10
    输出:
    70
    60
    50

例2:
#vim multi.py
def multiarg(*args):
for i in args:
print i
return

def multiargs(*args):
    print args[2]
    return

print "第一个调用:"
multiarg('hello','lili','tom','wing')
print "第2个调用:"
multiargs('hello','lili','tom','wing')        

执行结果:       
    第一个调用:
    hello
    lili
    tom
    wing
    第2个调用:
    tom

访谈格局1:*args  

*args和**kwargs

[wing@macserver ~]$ cat b.py
#!/usr/bin/env python
def foo(*args,**kwargs):
    print 'args = ',args
    print 'kwargs = ',kwargs
    print '-'*20
if __name__ == '__main__':
    foo(1,2,3,4)                         
    foo(a=1,b=2,c=3)
    foo(1,2,3,4,a=1,b=2,c=3)    #同时使用*args和**kwargs,必须*args参数列在前
    foo('a',1,None,a=1,b='2',c=3)
    #*args是一个tuple,**kwargs表示关键字参数,是一个dict

执行结果:
[wing@macserver ~]$ python b.py
args =  (1, 2, 3, 4)
kwargs =  {}
--------------------
args =  ()
kwargs =  {'a': 1, 'c': 3, 'b': 2}
--------------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'c': 3, 'b': 2}
--------------------
args =  ('a', 1, None)
kwargs =  {'a': 1, 'c': 3, 'b': '2'}
--------------------   

  * args 是以元组的情势接受参数

return 语句:

return [表达式] 用来退出函数,接纳性地向调用方再次回到二个表明式。
不带参数值的return语句再次来到None
例:
#!/usr/bin/python3
def sum( arg1, arg2 ):
total = arg1 arg2
return total

# 调用sum函数
print sum( 10, 20 )

输出结果:
30      
 1 >>> def foo(*arg):
 2     print arg
 3 
 4     
 5 >>> foo(1,2,3)
 6 (1, 2, 3)     #元组形式接收参数
 7 >>> foo("baidu","ali","qq","weixin")
 8 ('baidu', 'ali', 'qq', 'weixin')
 9 >>> foo("web",[1,2,3,"pythom"])
10 ('web', [1, 2, 3, 'pythom'])
11 >>> def foo(x,*arg):
12     print "x:",x
13     print "arg:",arg
14 
15     
16 >>> foo(1,2,3)
17 x: 1
18 arg: (2, 3)
19 >>> foo(7)
20 x: 7
21 arg: ()
22 >>> 

变量成效域:

叁个主次有所的变量并非在别的职分都足以访谈的。访谈权限调节于这些变量是在哪儿赋值的。
变量的作用域决定了在哪一部分顺序你能够访谈哪个特定的变量名称。
调用函数时,全体在函数内注脚的变量名称都将被投入到功用域中

三种最基本的变量成效域:全局变量和一些变量

概念在函数内部的变量具有一个有的效用域
概念在函数外的变量具备全局作用域

局地变量只可以在其被声称的函数内部访谈
全局变量能够在任何程序范围内访谈

例:
#!/usr/bin/python
total = 0 # 这是三个全局变量
def sum( arg1, arg2 ):
total = arg1 arg2 # total在此处是部分变量.
print "函数内是一对变量 : ", total
return total;

#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ",total 

输出结果:
函数内是局部变量 :  30
函数外是全局变量 :  0           

募集格局2:**kargs 是以字典情势选取参数

取名空间和效能域

变量:
是全部特别对象的名字(标识符)。

命名空间:
是叁个蕴涵了变量名称们(键)和它们分别对应的靶子们(值)的字典。

1.二个Python表明式可以访谈片段命名空间和大局命名空间里的变量。
2.要是三个某个变量和叁个全局变量重名,则有个别变量会覆盖全局变量。
3.各个函数都有和好的命名空间。类的秘籍的成效域法规和日常函数的同样。
4.Python以为其余在函数内赋值的变量都以一对的。由此,假如要给全局变量在四个函数里赋
值,必须采纳global语句。

global VarName表明式会报告Python, VarName是二个全局变量,那样Python就不会在
部分命名空间里找找那些变量了。

譬喻,在大局命名空间里定义二个变量money,再在函数内给变量money赋值,然后Python
会假定money是二个局地变量。可是,大家并从未在做客前声称一个部分变量money,结
果正是会冒出二个UnboundLocalError的不当。撤废global语句的讲解就能够消除这些难题。
#!/usr/bin/python
Money = 2000
def AddMoney():
#想订正代码就收回以投注释:
#global Money
Money = Money 1

print Money
AddMoney()
print Money

 1 >>> def foo(**karg):
 2     print karg
 3 
 4     
 5 >>> foo(a=1,b=2,c=3)
 6 {'a': 1, 'c': 3, 'b': 2}
 7 >>> def foo(x,*arg,**karg):
 8     print x
 9     print arg
10     print karg
11 
12     
13 >>> foo(1)
14 1
15 ()
16 {}
17 >>> foo(1,2)
18 1
19 (2,)
20 {}
21 >>> foo(1,2,3)
22 1
23 (2, 3)
24 {}
25 >>> foo(1,2,3,name="python")
26 1
27 (2, 3)
28 {'name': 'python'}
29 >>> 

>>> def book(author,name):
    print "{0} has a book :{1}".format(author,name)


>>> bars={"name":"learn python with cc","author":"cc"}
>>> book(**bars)
cc has a book :learn python with cc
>>> 

globals()和locals()函数

依据调用地方的例外,globals()和locals()函数可被用来回到全局和有个别命名空间里的名字。

在函数内部调用locals():
重回的是怀有能在该函数里拜会的命名。

在函数内部调用globals():
再次回到的是具备在该函数里能访问的全局名字。

八个函数的回来类型都是字典。所以名字们能用keys()函数摘取。

新鲜函数

无名氏函数与 lambda

python 使用 lambda 来创制无名函数。
• 无名是因为无需以专门的工作的方法来声称,比如说, 使用 def 语句。
• 一个完全的 lambda“语句”代表了几个表明式,那些表达式的定义体必得和表明放在同一行。
• lambda的珍爱是二个表明式,并非三个代码块。仅仅能在lambda表明式中封装有限的逻辑进去。
• lambda函数具备协和的命名空间,且不能够访问自有参数列表之外或全局命名空间里的参数。
• lambda函数看起来只能写一行,却差别等C或C 的内联函数,前面一个的目标是调用小函数时不占用栈内部存款和储蓄器进而扩张运转功效。

语法:
lambda [arg1 [,arg2,.....argn]]:expression
参数是可选的,假使使用参数,参数平日也是表达式的一部分。
例:
#!/usr/bin/python
sum = lambda arg1, arg2: arg1 arg2

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

输出结果:
相加后的值为 :  30
相加后的值为 :  40

复习下单行语句:
def true():
return True
上边的函数没有带任何的参数况兼连接回到 True。python 中单行函数能够和标题写在同一行。

重写true()函数:
    def true(): return True

应用 lambda 的等价表明式(没有参数,再次回到二个 True)为:
lambda :True

In [4]:     a = lambda x, y=2: x   y
In [5]:     a(5)
Out[5]:   7

In [6]:     a(3,5)
Out[6]:   8

In [2]:     a=lambda *z:z
In [3]:     a(1,2,3,4)
Out[3]:   (1, 2, 3, 4)

zip() 补充

函数不带括号:

In [1]: def hello(a,b): #函数定义
...: print a b
...:

In [2]: hello(1,2) #函数调用,带括号表示报告编写翻译器”试行这一个函数“

In [6]: c=hello #不带括号表示把函数赋给另二个函数对象
In [8]: c(3,4)
7

 1 >>> colors =["red","green","blue"]
 2 >>> values=[234,12,89,65]
 3 >>> zip(colors,values)
 4 [('red', 234), ('green', 12), ('blue', 89)]
 5 >>> dots=[(1,2),(3,4),(5,6)]
 6 >>> x,y=zip(*dots)
 7 >>> x
 8 (1, 3, 5)
 9 >>> y
10 (2, 4, 6)
11 >>> seq =range(1,10)
12 >>> zip(*[iter(seq)]*3)
13 [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
14 >>> x =iter(range(1,10))
15 >>> x
16 <listiterator object at 0x0000000003E8F860>
17 >>> list(x)
18 [1, 2, 3, 4, 5, 6, 7, 8, 9]
19 >>> zip(x,x,x)
20 []
21 >>> x=iter(range(1,10))
22 >>> zip(x,x,x)
23 [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
24 >>> 

递归函数

递归函数不须求任何修改就足以管理任性深度的嵌套列表

#!/usr/bin/env python
name=['wing',['tom',['jim',['lilei','han×××']]]]
def print_list(name):
    for each_item in name:
        if isinstance(each_item,list):
            print_list(each_item)
        else:
            print each_item

print_list(name)
def print_list(list_name,level=0):
    for each_item in list_name:
        if isinstance(each_item,list):
            print_list(each_item,level 1)
        else:
            for tab_num in range(level):
                print "t",
            print each_item

print_list(name)

题目:利用递归方法求5!。                     
程序分析:递归公式:fn=fn_1*4!
程序源代码:
#!/usr/bin/python
# -*- coding: UTF-8 -*-

def fact(j):
    sum = 0
    if j == 0:
        sum = 1
    else:
        sum = j * fact(j - 1)
    return sum

for i in range(5):
    print '%d! = %d' % (i,fact(i))
以上实例输出结果为:
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24

lambda  lambda x: x y lambda 变量: 表达式

内建函数

Python中,依据指标是或不是可变,将项目分类为:

不足变类型:
对象的从头到尾的经过不能够转移(not mutable),这个项目中关键有数值类型(整数,浮点数,复数),字符
串类型,元组等
可变类型:
对象的剧情约财富够转移(mutable),主要有列表,字典

Python针对广大的品类,提供了广大的内建函数来管理(内建是相对于导入import来讲的,前边学
习到包package时,将会介绍),

那么些内建函数功效在于其往往可对五种类型对象举办类似的操作,即多样类型对象的共有的操作;
一经某种操作只对特殊的某一类对象可行,Python常将其安装为该种类型的议程(method)

内建函数的查看
通过在python交互模式下,键入相应的命令即可查看当前python版本的一些内建函数
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

也可以通过如下方式查看:
    >>> import __builtin__
    >>>dir(__builtin__)

获得内建函数支持:

help()  
获取支持音信

其完全的貌似采纳形式为:
help(module.class.function)

例子:
In [3]: import sys
In [4]: help(sys.getsizeof)

数值类型表示的内建函数

bin()     获取一个整数(int类型或长整型),返回其2进制形式的字符串
oct()     获取一个整数,返回其8进制形式的字符串
hex()    获取一个整数,返回其16进制形式的字符串

指标生成的内建函数

int() 将数值或字符串转换为整数int,完整使用情势int(x,base),base用于钦定进制
long() 将数值或字符串转变为整数long,完整使用格局long(x, base),base用于钦定进制
float() 将数值或字符串转变为浮点数
complex()再次回到一个复数,完整使用情势 complex(real,imag)
str() 将所给目的调换为字符串,使用方式为str(object)
list() 获取对象,调换为列表, list(object)
dict() 获取映射调换为字典,dict(mapping)
tuple() 获取多少个可迭代的对象,重临二个元组, tuple(iterable)
注:这里留心dict()内建函数创造字典的不如措施

map、reduce、filter

装饰器Decorator

装饰器是我们明日碰到的难点之一,非常小好通晓,可以省略的以为装饰器正是为着给函数增多额外的机能,而不用每一次都手写那几个功效,只要求用"@装饰器名称"调用就足以了

不利用装饰器给函数增多叁个附加的效果:
下例中是给foo函数增加日志效能

#!/usr/bin/env python3
import logging
def foo():
        print "hello world"

def use_logging(func):
        logging.warn("%s is running" % func.__name__)
        func()

use_logging(foo)   #每次执行foo的时候都得调用use_logging函数

应用装饰器:
@use_logging #装饰器
foo()

简陋写法:因为不能给带有参数的函数装饰,所以简陋
#!/usr/bin/env python
#coding=utf8
import logging

def use_logging(func):
    logging.warn("%s is running" % func.__name__)
    return func

@use_logging
def foo():
    print "hello world"

foo()

标准写法:
    #!/usr/bin/env python
    #coding=utf8
    import logging

    def use_logging(func):
        def wrapper(*args,**kw):
            logging.warn("%s is running" % func.__name__)
            return func()
        return wrapper

    @use_logging
    def foo():
        print "hello world"

    foo()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
带参数:
#!/usr/bin/env python
#coding=utf8
import logging

def use_logging(func):
    def wrapper(*args,**kw):   
        logging.warn("%s is running" % func.__name__)
        return func()               #会报错
    return wrapper

@use_logging
def foo(arg1,arg2):
    print "arg1 arg2=%s" % (arg1 arg2)

foo(5,3)

正确写法如下:
#!/usr/bin/env python
#coding=utf8
import logging

def use_logging(func):
    def wrapper(*args,**kw):      
        logging.warn("%s is running" % func.__name__)
        return func(*args,**kw)   
    return wrapper

@use_logging
def foo(*args,**kw):
    print "arg1 arg2=%s" % (args[0] args[1])
    print "hello world"

foo(1,2)
因为装饰器会先执行,在没有wrapper函数的情况下return func(*args,**kw)会出现args未定义错误    
 1 >>> def foo(x):
 2     x -3
 3     return x
 4 
 5 >>> foo(4)
 6 4
 7 >>> n =range(10)
 8 >>> n
 9 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
10 >>> [i 3 for i in n ]
11 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
12 >>> lam =lambda x:x 3
13 >>> n2=[]
14 >>> for i in n
15 SyntaxError: invalid syntax
16 >>> for i in n:
17     n2.append(lam(i))
18 
19     
20 >>> n2
21 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
22 >>> g =lambda x,y:x y
23 >>> g(3,4)
24 7
25 >>> lambda x:x 4
26 <function <lambda> at 0x0000000003E91438>
27 >>> n
28 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
29 >>> map(foo,n)
30 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
31 >>> map(lambda x:x 3,n)
32 [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
33 >>> lst1 =[1,2,3,4,5]
34 >>> lst2=[6,7,8,9,0]
35 >>> map(lambda x,y:x y,lst1,lst2)
36 [7, 9, 11, 13, 5]
37 >>> reduce(lambda x,y:x y,lst1)
38 15
39 >>> n =range(-5,5)
40 >>> n
41 [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
42 >>> filter(lambda x:x>0,n)
43 [1, 2, 3, 4]
44 >>> [x for x in n if x>0]
45 [1, 2, 3, 4]
46 >>> 
TAG标签:
版权声明:本文由澳门新葡8455手机版发布于www.2527.com,转载请注明出处:Python自动化运营开采实战,学习笔记