python︱函數(shù)、for、if、_name_、迭代器、防范報(bào)錯(cuò)、類定義、裝飾器

新手入門Python,開始寫一些簡(jiǎn)單函數(shù)，慢慢來，加油~
一、函數(shù) +三個(gè)內(nèi)建函數(shù)filter，map和reduce + if
1、def/lambda

def myadd(a=1,b=100):
    result = 0
    i = a
    while i <= b:    # 默認(rèn)值為1+2+3+……+100
        result += i    
        i += 1
    return result

跟R一樣都可以用return返回

lambda函數(shù)

lambda表達(dá)式有什么好處？匿名函數(shù)，一般用來給filter，map這樣的函數(shù)式編程服務(wù)，map(lambda x: x*2,[1,2,3,4,5])

或者就是一次性產(chǎn)品。類似于這種即用即扔的產(chǎn)品：(lambda x: x*2)(3)

或者作為回調(diào)函數(shù)，傳遞給某些應(yīng)用，比如消息處理。

2、if

python 中的三元表達(dá)式（三目運(yùn)算符）
這個(gè)輸出1，但沒有什么意義，僅僅是一個(gè)例子。
而在python中的格式為

為真時(shí)的結(jié)果 if 判定條件 else 為假時(shí)的結(jié)果  

還是上面的例子

1 if 5>3 else 0

3、filter
filter(bool_func,seq)：此函數(shù)的功能相當(dāng)于過濾器。調(diào)用一個(gè)布爾函數(shù)bool_func來迭代遍歷每個(gè)seq中的元素；返回一個(gè)使bool_seq返回值為true的元素的序列。
例如：

>>> filter(lambda x : x%2 == 0,[1,2,3,4,5])  
[2, 4]  

filter內(nèi)建函數(shù)的python實(shí)現(xiàn)：

def filter(bool_func,seq):  
    filtered_seq = []  
    for eachItem in seq:  
        if bool_func(eachItem):  
            filtered_seq.append(eachItem)  
    return filtered_seq  

4、map
map(func,seq1[,seq2…])：將函數(shù)func作用于給定序列的每個(gè)元素，并用一個(gè)列表來提供返回值；如果func為None，func表現(xiàn)為身份函數(shù)，返回一個(gè)含有每個(gè)序列中元素集合的n個(gè)元組的列表。
例如：

>>> map(lambda x : None,[1,2,3,4])  
[None, None, None, None]  
>>> map(lambda x : x * 2,[1,2,3,4])  
[2, 4, 6, 8]  
>>> map(lambda x : x * 2,[1,2,3,4,[5,6,7]])  
[2, 4, 6, 8, [5, 6, 7, 5, 6, 7]]  
>>> map(lambda x : None,[1,2,3,4])  
[None, None, None, None]  

map內(nèi)建函數(shù)的python實(shí)現(xiàn)：

>>> def map(func,seq):  
    mapped_seq = []  
    for eachItem in seq:  
        mapped_seq.append(func(eachItem))  
    return mapped_seq  

5、reduce
reduce(func,seq[,init])：func為二元函數(shù)，將func作用于seq序列的元素，每次攜帶一對(duì)（先前的結(jié)果以及下一個(gè)序列的元素），連續(xù)的將現(xiàn)有的結(jié)果和下一個(gè)值作用在獲得的隨后的結(jié)果上，最后減少我們的序列為一個(gè)單一的返回值：如果初始值init給定，第一個(gè)比較會(huì)是init和第一個(gè)序列元素而不是序列的頭兩個(gè)元素。
例如：

>>> reduce(lambda x,y : x + y,[1,2,3,4])  
10  
>>> reduce(lambda x,y : x + y,[1,2,3,4],10)  
20  
reduce的python實(shí)現(xiàn)：

def reduce(bin_func,seq,initial=None):  
    lseq = list(seq)  
    if initial is None:  
        res = lseq.pop(0)  
    else:  
        res = initial  
    for eachItem in lseq:  
        res = bin_func(res,eachItem)  
    return res  

二、for、while
python中的for比R中的要廣泛很多，R中的for (i in 1:3)循環(huán)的較多的是數(shù)值，python包括數(shù)值+文本列表。
1、字母當(dāng)做循環(huán)

for letter in 'Python':     # 第一個(gè)實(shí)例
   print '當(dāng)前字母 :', letter

當(dāng)前字母 : P
當(dāng)前字母 : y
當(dāng)前字母 : t
當(dāng)前字母 : h
當(dāng)前字母 : o
當(dāng)前字母 : n

2、列表當(dāng)做循環(huán)

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二個(gè)實(shí)例
   print '當(dāng)前字母 :', fruit

3、數(shù)字當(dāng)做循環(huán)

for num in range(10,20):  # 迭代 10 到 20 之間的數(shù)字
   for i in range(2,num): # 根據(jù)因子迭代
      if num%i == 0:      # 確定第一個(gè)因子
         j=num/i          # 計(jì)算第二個(gè)因子
         print '%d 等于 %d * %d' % (num,i,j)
         break            # 跳出當(dāng)前循環(huán)
   else:                  # 循環(huán)的 else 部分
      print num, '是一個(gè)質(zhì)數(shù)'

4、for 中的 _ 下劃線的應(yīng)用
for 中出現(xiàn)了 _ 那么作用跟R里面的repeat一致，有復(fù)制的功能。

import numpy as np
l=[("f1",'g1'),("f2","g2")]
h=['go1','go2']

In [17]:{iter:np.zeros(2) for iter,_ in l }
Out[17]: {'f1': array([ 0.,  0.]), 'f2': array([ 0.,  0.])}

In [18]:[{iter:np.zeros(2) for iter,_ in l } for _ in h]
Out[18]:
[{'f1': array([ 0.,  0.]), 'f2': array([ 0.,  0.])},
 {'f1': array([ 0.,  0.]), 'f2': array([ 0.,  0.])}]

比較小白，對(duì)python里面的生成器一開始看不懂，不過后來覺得跟R里面的lappy功能很像。
for iter,_ in l 提取了l=[(“f1”,’g1’),(“f2”,”g2”)]兩個(gè)的第一個(gè)數(shù)字，屏蔽了第二個(gè)g1/g2
然后f1 f2賦值給了前面的函數(shù)，函數(shù)內(nèi)容是iter:np.zeros(2)，那么就是出現(xiàn)out[17]的結(jié)果。
for _ in h，完全就是repeat兩次。

5、while - 重復(fù)執(zhí)行
無限循環(huán)的時(shí)候，可以用ctrl + C結(jié)束。
while 語句用于循環(huán)執(zhí)行程序，即在某條件下，循環(huán)執(zhí)行某段程序，以處理需要重復(fù)處理的相同任務(wù)。其基本形式為：
（1）常規(guī)用法：重復(fù)執(zhí)行

#!/usr/bin/python
count = 0
while (count < 9):   
   print 'The count is:', count    count = count + 1
print "Good bye!"

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!
for里面的重復(fù)執(zhí)行，可以用 for _ in np.arrange(10):
（2）continue，break + while
while 語句時(shí)還有另外兩個(gè)重要的命令 continue，break 來跳過循環(huán)，continue 用于跳過該次循環(huán)，break 則是用于退出循環(huán)，此外”判斷條件”還可以是個(gè)常值，表示循環(huán)必定成立，具體用法如下：

# continue 和 break 用法i = 1
while i < 10:      i += 1    if i%2 > 0:     
# 非雙數(shù)時(shí)跳過輸出        
continue    print i         
# 輸出雙數(shù)2、4、6、8、10i = 1
while 1:            
# 循環(huán)條件為1必定成立   
 print i        
i += 1    
if i > 10:    
 # 當(dāng)i大于10時(shí)跳出循環(huán)  
       break
（3）循環(huán)使用 else 語句

#!/usr/bin/python
count = 0
while count < 5:   
  print count, " is  less than 5"   count = count + 1
else:   
  print count, " is not less than 5"

>>>
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
三、迭代器
兩個(gè)列表同時(shí)迭代
nfc = ["Packers", "49ers"]
afc = ["Ravens", "Patriots"]
for teama, teamb in zip(nfc, afc):
     print teama + " vs. " + teamb
>>> Packers vs. Ravens
>>> 49ers vs. Patriots

帶索引的列表迭代

teams = ["Packers", "49ers", "Ravens", "Patriots"]
for index, team in enumerate(teams):
    print index, team
>>> 0 Packers
>>> 1 49ers
>>> 2 Ravens
>>> 3 Patriots

已知一個(gè)列表，刷選出偶數(shù)列表方法：

numbers = [1,2,3,4,5,6]
even = []
for number in numbers:
    if number%2 == 0:
        even.append(number)
字典推導(dǎo)

teams = ["Packers", "49ers", "Ravens", "Patriots"]
print {key: value for value, key in enumerate(teams)}
>>> {'49ers': 1, 'Ravens': 2, 'Patriots': 3, 'Packers': 0}
和collections庫一樣，還有一個(gè)庫叫itertools

from itertools import combinations
teams = ["Packers", "49ers", "Ravens", "Patriots"]
for game in combinations(teams, 2):
    print game
>>> ('Packers', '49ers')
>>> ('Packers', 'Ravens')
>>> ('Packers', 'Patriots')
>>> ('49ers', 'Ravens')
>>> ('49ers', 'Patriots')
>>> ('Ravens', 'Patriots')
四、_name_
    _name_在當(dāng)前文件中：_name_=_main_
    _name_在別的文件中：_name_=def的名字

_name_是指示當(dāng)前py文件調(diào)用方式的方法。如果它等于”_main_“就表示是直接執(zhí)行，如果不是，則用來被別的文件調(diào)用，這個(gè)時(shí)候if就為False，那么它就不會(huì)執(zhí)行最外層的代碼了。
比如你有個(gè)Python文件里面

def XXXX():
#body
print "asdf"

這樣的話，就算是別的地方導(dǎo)入這個(gè)文件，要調(diào)用這個(gè)XXXX函數(shù)，也會(huì)執(zhí)行print “asdf”，因?yàn)樗亲钔鈱哟a，或者叫做全局代碼。但是往往我們希望只有我在執(zhí)行這個(gè)文件的時(shí)候才運(yùn)行一些代碼，不是的話（也就是被調(diào)用的話）那就不執(zhí)行這些代碼，所以一般改為

def XXXX():
#body
if __name__="__main__":
print "asdf"

延伸：if _name_ == ‘_main_‘:

本python文檔，if name == ‘main‘:以下的內(nèi)容可以執(zhí)行，
別的python文檔， 調(diào)用的話，if name == ‘main‘:以下內(nèi)容不管了。

同時(shí)main()的意義是：python 如何判斷應(yīng)該哪個(gè)是主執(zhí)行文件呢？應(yīng)用場(chǎng)景是在互相調(diào)用python內(nèi)函數(shù)的時(shí)候。
五、防范報(bào)錯(cuò)
1、assert 斷言

Python的assert是用來檢查一個(gè)條件，如果它為真，就不做任何事。如果它為假，則會(huì)拋出AssertError并且包含錯(cuò)誤信息。例如：

py> x = 23
py> assert x > 0, "x is not zero or negative"
py> assert x%2 == 0, "x is not an even number"
Traceback (most recent call last):
File "", line 1, in
AssertionError: x is not an even number

類似R中的stopifnot

參考博客：Python 中何時(shí)使用斷言？
.
2、try…except…

try:
    f = open('xxx')
except:
    print 'fail to open'
    exit(-1)
如果try中open不出來，那么就except返回相應(yīng)的內(nèi)容“fail to open”
.
3、with…as…

那么with和as也是一種防止報(bào)錯(cuò)的防范方式，
當(dāng)python執(zhí)行這一句時(shí)，會(huì)調(diào)用enter函數(shù)，然后把該函數(shù)return的值傳給as后指定的變量。
之后，python會(huì)執(zhí)行下面do something的語句塊。最后不論在該語句塊出現(xiàn)了什么異常，都會(huì)在離開時(shí)執(zhí)行exit。

ith open("x.txt") as f:
    data = f.read()

with open("x.txt") as f1, open('xxx.txt') as f2:
    do something with f1,f2

那么try和with也可以合起：

try:
    with open( "a.txt" ) as f :
        do something
except xxxError:
    do something about exception
六、類定義

參考于:Python的hasattr() getattr() setattr() 函數(shù)使用方法詳解

class <類名>:
    <語句>

類需注意：

    類適合存函數(shù)，不用非要return
    在類中定義的函數(shù)只有一點(diǎn)不同，就是第一個(gè)參數(shù)永遠(yuǎn)是實(shí)例變量self，并且，調(diào)用時(shí)，不用傳遞該參數(shù)。

1、類里面一直存著參數(shù)

init存入

class save_def(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

這樣save_def里面就會(huì)一直存著name、score函數(shù)。

initialization = save_def（name,score）

初始化的方式跟函數(shù)一樣，直接傳入。
同時(shí)，initialization.name，initialization.score 也相當(dāng)于initialization的屬性。
不過，如果你覺得還需要額外加入一些臨時(shí)屬性的話，可以直接賦值：

initialization.other = "other"
.
2、類里面函數(shù)如何調(diào)用

類內(nèi)的參數(shù)前面加self.para

class save_def(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def function1(self,dataframe):
    temp_data = type(dataframe[self.name])
    return temp_data

如果類里面包著函數(shù)，而且函數(shù)里面包著屬性，那么可以直接用：

initialization = save_def（name,score）
 initialization.function1(dataframe)

如果是函數(shù)的話，則為：

>>>def function1(name,dataframe):
    temp_data = type(dataframe[name])
    return temp_data

>>>function1(name,dataframe)

不同的地方在于類里面，可以直接用類內(nèi)存著的函數(shù)。
.
3、類內(nèi)函數(shù)套函數(shù)

類內(nèi)函數(shù)調(diào)用類內(nèi)的函數(shù)，前面需要加self.

class save_def(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def function1(self,dataframe):
    temp_data = type(dataframe[self.name])
    return temp_data

    def function2(self):
        temp_data2 = self.function1(dataframe.ix[self.score>10,:])
self.function1就是一種類內(nèi)調(diào)用函數(shù)的方式。從這一案例可以看出：
類內(nèi)調(diào)用函數(shù)+參數(shù)，都需要用self.
.
延伸一：關(guān)于如何從調(diào)用另一個(gè).py文件中的類

因?yàn)?，Python里面全局變量所謂的全局是針對(duì)在一個(gè)文件里面的函數(shù)而言的，跨文件就等于定義在不同的包里面，也就相當(dāng)于是使用了不同的命名空間。（來源：PYTHON全局變量在模塊中的無法引用？）
筆者在調(diào)用另一個(gè).py文件中的類的時(shí)候，發(fā)生大面積的報(bào)錯(cuò)：

globel name 'xxx' is not defined

無奈只能寫在一個(gè)文檔中。

一般來說，調(diào)用的方式有兩種：import 和 from…import…：
import datetime
print(datetime.datetime.now())

from datetime import datetime
print(datetime.now())

通俗的說：

from import : 從車?yán)锇训V泉水拿出來，給我
import : 把車給我
.
七、裝飾器

參考于：深入淺出Python裝飾器、Python裝飾器學(xué)習(xí)（九步入門）、Python 的閉包和裝飾器

    其中筆者認(rèn)為，類class適合打包函數(shù)，裝飾器@適合包裝函數(shù)，并不是包裝參數(shù)。 同時(shí)，裝飾器適合，函數(shù)之間有一定遞進(jìn)、級(jí)聯(lián)關(guān)系，比較適合。

1、閉包

裝飾器相當(dāng)于升級(jí)版的閉包，一個(gè)閉包就是你調(diào)用了一個(gè)函數(shù)A，這個(gè)函數(shù)A返回了一個(gè)函數(shù)B給你。這個(gè)返回的函數(shù)B就叫做閉包。你在調(diào)用函數(shù)A的時(shí)候傳遞的參數(shù)就是自由變量。

def func(name):
    def inner_func(age):
        print 'name:', name, 'age:', age
    return inner_func

bb = func('the5fire')
bb(26)  # >>> name: the5fire age: 26

這里面調(diào)用func的時(shí)候就產(chǎn)生了一個(gè)閉包——inner_func,并且該閉包持有自由變量——name，因此這也意味著，當(dāng)函數(shù)func的生命周期結(jié)束之后，name這個(gè)變量依然存在，因?yàn)樗婚]包引用了，所以不會(huì)被回收。
2、初級(jí)裝飾器

函數(shù)傳入、函數(shù)傳出,裝飾器的本質(zhì)就是函數(shù)閉包，或者說利用了函數(shù)閉包的特性。

def outer(function):
    def inner():
        print("執(zhí)行function之前可以進(jìn)行額外操作")
        result = function()
        print("執(zhí)行function之后還可以進(jìn)行額外操作")
        result *= 2        # 對(duì)function的返回值本身進(jìn)行額外操作
        return result      # 返回‘加強(qiáng)’后的結(jié)果
    return inner

def wait_for_deco():
    return 1024

decorated = outer(wait_for_deco)
print decorated()
# 輸出
2048

上例就是純手工實(shí)現(xiàn)的一個(gè)最簡(jiǎn)單的裝飾器。裝飾器函數(shù)outer并沒有修改被裝飾函數(shù)wait_for_deco，但我們調(diào)用被裝飾后的decorated函數(shù)閉包卻能夠得到原函數(shù)的加強(qiáng)版結(jié)果，還能進(jìn)行額外的操作。

超級(jí)簡(jiǎn)單的案例一則：

def function1(function):
    return function() + 1
# function作為參數(shù)傳入，且這個(gè)參數(shù)名稱是任意的，跟普通參數(shù)一致，需要對(duì)齊，函數(shù)也要寫function

def function2():
    return 2
#這樣的裝飾器，一般不傳入?yún)?shù)

# 使用
>>> function1(function2)
>>> 3
# 其中，不能寫成function1(function2())
.
3、帶裝飾符@-裝飾器

實(shí)際上裝飾符@就僅僅是幫我們自動(dòng)地把返回的閉包函數(shù)名字替換為原函數(shù)的名字。

def outer(function):
    def inner():
        print("執(zhí)行function之前可以進(jìn)行額外操作")
        result = function()
        print("執(zhí)行function之后還可以進(jìn)行額外操作")
        result *= 2        # 對(duì)function的返回值本身進(jìn)行額外操作
        return result      # 返回‘加強(qiáng)’后的結(jié)果
    return inner

@outer
def wait_for_deco():
    return 1024

print wait_for_deco()
# 輸出
2048
.
4、帶參數(shù)+裝飾符的裝飾器

# 例如為下面的函數(shù)寫一個(gè)裝飾器，應(yīng)該在內(nèi)部的wapper中按原樣傳遞參數(shù)
def decorator(func):
    def wrapper(x, y)
      ret = func(x, y)    # 原函數(shù)的返回值
      return ret*2        # 原函數(shù)的結(jié)果“加強(qiáng)”后再返回
    return wrapper

@decorator
def wait_for_deco(x, y):
  return x + y

print(wait_for_deco(1, 2))

# 輸出
6
可調(diào)節(jié)的多參數(shù)
按照上面這種寫法雖然可以傳參了但有個(gè)缺陷，參數(shù)個(gè)數(shù)不確定的函數(shù)就沒法使用這個(gè)裝飾器了。

def decorator(func):
    def wrapper(*args, **kwargs)
      ret = func(*args, **kwargs)
      return ret*2
    return wrapper

@decorator
def wait_for_deco_a(x, y):
  return x + y

@decorator
def wait_for_deco_b(x, y, z):
  return x + y + z

print(wait_for_deco_a(1, 2))
6
print(wait_for_deco_b(1, 2, 3))
12

超級(jí)簡(jiǎn)單案例一則：

def function2(function):
    # 因?yàn)橐獋魅雲(yún)?shù)，所以下面的def 就相當(dāng)于在寫了一次_function2，但也不是簡(jiǎn)單的加個(gè)def，其中_代表，專屬于函數(shù)內(nèi)
    def _function2(b):
        # 并不能寫出：function2(function)
        a = function(b)
        return a + 1
    return _function2
# 返回的是函數(shù)本身

@function2
def function1(b):
    return b + 1

function2(function1)
.
5、傳參數(shù)+裝飾符@+多選項(xiàng)裝飾器
def mydec(is_print):
    def mydec_f(func):
        def mydec_a(*args, **kwargs):
            r = func(*args, **kwargs)
            if is_print:
                print("結(jié)果是:{}".format(r))
            else:
                print("不打印結(jié)果")
        return mydec_a
    return mydec_f

@mydec(True)
def mysum(a, b):
    c = a + b
    return c
@mydec(False)
def mysum2(a, b, c):
    d = a + b + c
    return d

mysum(1, 2)
mysum2(1, 2, 3)
>>>結(jié)果是:3
.
6、傳參數(shù)+裝飾符@+類 裝飾器
class mycls():
    def __init__(self):
        print("類初始化了")

    @staticmethod
    def test1():
        print("我是mycls.test1")

    @staticmethod
    def test2():
        print("我是mycls.test2")

# 裝飾器
def mydec(cls):
    def mydec_f(func):
        def mydec_a(*args, **kwargs):
            cls.test1()
            r = func(*args, **kwargs)
            print("結(jié)果是:{}".format(r))
            cls.test2()
        return mydec_a
    return mydec_f

@mydec(mycls)
def mysum(a, b):
    c = a + b
    return c
@mydec(mycls)
def mysum2(a, b, c):
    d = a + b + c
    return d

mysum(1, 2)
mysum2(1, 2, 3)
結(jié)果：

我是mycls.test1
結(jié)果是:3
我是mycls.test2
我是mycls.test1
結(jié)果是:6
我是mycls.test2