Python中的關鍵字的用法

時間 2019-12-08

原文原文鏈接

Python有哪些關鍵字

-Python經常使用的關鍵字
and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, print, class, exec, in, raise, contiue, finally, is, return, def, for, lambda, trypython

-1.and , or
and , or 爲邏輯關係用語，Python具備短路邏輯，False and 返回 False
不執行後面的語句， True or 直接返回True，不執行後面的語句
-2.del
刪除變量express

if __name__=='__main__':
    a=1       # 對象 1 被 變量a引用，對象1的引用計數器爲1
    b=a       # 對象1 被變量b引用，對象1的引用計數器加1
    c=a       #1對象1 被變量c引用，對象1的引用計數器加1
    del a     #刪除變量a，解除a對1的引用
    del b     #刪除變量b，解除b對1的引用
    #print a #運行此句出錯，name 'a' is not defined，說明 del 刪除變量a
    print(c)  #最終變量c仍然引用1
    print c

而列表自己包含的是變量，例：markdown

list = [1,2,3]
# 包含list[0],list[1],list[2]
# 並不包含數字1,2,3

因此ide

if __name__=='__main__':
    li=[1,2,3,4,5]  #列表自己不包含數據1,2,3,4,5，而是包含變量：li[0] li[1] li[2] li[3] li[4] 
    first=li[0]     #拷貝列表，也不會有數據對象的複製，而是建立新的變量引用
    del li[0]  # 列表自己包含的是變量，del 刪除的是變量。

    print li     #輸出[2, 3, 4, 5]
    print(first)   #輸出 1

-3.from
from引用模塊時會用到，例：函數

from sys import argv
# 從sys中導入argv
from sys import *
# 將sys中全部東西都導入
import sys 
# 導入sys，當須要sys中內容時，需sys.argv而from sys import *
#不用每次都重複輸入'sys.'

-4.golbal
golbal爲全局變量，但當單個函數中出現同一變量名時，在單個函數中爲局部變量測試

golbal q
q = 66
print "q=", q #q = 66
def function():
    q = 3
    print 'q =',q
function() # q = 3
print 'q =',q # q = 66

-5.with
with被用來處理異常ui

# 不用with 處理文件異常
file = open("/tmp/foo.txt")
try:
    data = file.read()
finally:
    file.close()

# 用with
with open("/tmp/foo.txt")
 as file:
    data = file.read()

緊跟with後面的語句被求值後，返回對象的enter()方法被調用，這個方法的返回值將被賦值給as後面的變量，此處爲file
當with後面的代碼塊所有被執行完後，將調用前面返回對象的exit()方法idea

#with 的工做 
class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self, type, value, trace):
        print "In __exit__()"


def get_sample():
    return Sample()

with get_sample() as sample:
    print "sample:", sample
#1. __enter__()方法被執行
#2. __enter__()方法返回的值 - 這個例子中是"Foo"，賦值給變量'sample'
#3. 執行代碼塊，打印變量"sample"的值爲 "Foo"
#4. __exit__()方法被調用

#with真正強大之處是它能夠處理異常。
#可能你已經注意到Sample類的__exit__方法有三個參數- val, type 和 trace。 
#這些參數在異常處理中至關有用。

class Sample:
    def __enter__(self):
        return self

    def __exit__(self, type, value, trace):
        print "type:", type
        print "value:",
 value
        print "trace:",
 trace

    def do_something(self):
        bar = 1/0
        return bar + 10

with Sample() as sample:
    sample.do_something()

實際上，在with後面的代碼塊拋出任何異常時，exit()方法被執行。
正如例子所示，異常拋出時，與之關聯的type，value和stack trace傳給exit()方法，
所以拋出的ZeroDivisionError異常被打印出來了。
開發庫時，清理資源，關閉文件等等操做，均可以放在exit方法當中。spa

-6.while, for…in…
均爲循環語句，使用while時要注意成立條件，防止陷入死循環
for in 遍歷code

-7.assert
斷言，聲明其布爾值必須爲真的斷定，若是發生異常就說明表達示爲假。
能夠理解assert斷言語句爲raise-if-not，用來測試表示式，其返回值爲假，就會觸發異常。

assert 1==1
assert 1 == 2# 會報錯 Asserterror
assert expression , 'arguments'
#assert 表達式 [, 參數]用來解釋斷言並更好知道哪裏錯了

-8.pass
pass是空語句，爲了保證程序結構的完整性，
pass不作任何事情，通常用做佔位語句
當你編寫程序部份內容還沒想好，可用pass語句佔位

def no_idea():
   pass

#實例
for letter in 'python':
    if letter == 'h':
        pass
        print u'這是pass塊'
    print u'當前字母：', letter
print 'bye,bye'

-9.yield
yield的意思是生產，返回了一個生成器對象，每一個生成器只能使用一次

def h():
    print 'To be brave'
    yield 5

h() #看到某個函數包含了yield，這意味着這個函數已是一個Generator
#調用h()函數後,print 語句並未執行，執行yield用.next()方法

def h():
    print 'Wen Chuan'
    yield 5
    print 'Fighting!'

c = h()
# >>>c.next()# 在IDE 中不用print c.next()，直接c.next()。
# next()語句將恢復Generator執行，並直到下一個yield表達式處
# Wen Chuan 
# 5 
# 當再次運行c.next()時因爲沒有yield了報錯
# >>>c.next()
# Fighting 
# Traceback (most recent call last):
# File "/home/evergreen/Codes/yidld.py", line 11, in <module>
# c.next()
# StopIteration

一個帶有 yield的函數就是一個generation，他和普通函數不一樣，生成一個generator看起來像函數調用，但不會執行任何函數代碼，直到對其調用.next()（在 for 循環中會自動調用 next()）纔開始執行
雖然執行流程仍按函數的流程執行，但每執行到一個 yield 語句就會中斷，並返回一個迭代值，下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函數在正常執行的過程當中被 yield 中斷了數次，每次中斷都會經過 yield 返回當前的迭代值。

#使用isgeneratorfunction判斷一個函數是不是一個特殊的generator 函數
from inspect import isgeneratorfunction 
isgeneratorfunction(h) 
# True

send() 與next()

def h():
    print 'Wen Chuan',
    m = yield 5  # Fighting!
    print m
    d = yield 12
    print 'We are together!'

c = h()
m = c.next()  #m 獲取了yield 5 的參數值 5
d = c.send('Fighting!')  #d 獲取了yield 12 的參數值12
print 'We will never forget the date', m, '.', d

#send()能夠傳遞yield表達式的值進去，而next()不能傳遞特定的值，只能傳遞None進去。
#所以，咱們能夠看作c.next() 和 c.send(None) 做用是同樣的
#注意！！！第一次調用時，請使用next()語句或是send(None)，不能使用send發送一個非None的值，不然會出錯的，由於沒有yield語句來接收這個值

-10.break 與 contiue
Python break語句用來終止循環，用在while和for循環中！！直接跳出整個循環
嵌套循環，break語句將中止執行最深層的循環，並開始執行下一行代碼

for letter in 'python':# 第一個例子
    if letter == 'h'
        break 
    print u'當期字母：',letter
#輸出到'p''y''t' 

var= 10 # 第二個例子
while var > 0:
    print u'當期字母：',var 
    var = var -1
    if var == 5
       break
#輸出到6 
print 'bye'

break是跳出整個循環，continue是跳出當前循環

#例1
for letter in 'pyhton':
    if letter == 'h':
        continue
    print u'當前字母：', letter
#打印出 pyton

#例2
var = 10
while var > 0:
    var -= 1
    if var == 5:
        continue
    print u'當前字母：', var
#結果 98764321

-11.try except finally

try:
<語句>        #運行別的代碼
except <名字>：
<語句>        #若是在try部份引起了'name'異常
except <名字>，<數據>:
<語句>        #若是引起了'name'異常，得到附加的數據
else:
<語句>        #若是沒有異常發生

若是當try後的語句執行時發生異常，python就跳回到try並執行第一個匹配該異常的except子句，異常處理完畢，控制流就經過整個try語句（除非在處理異常時又引起新的異常）。
若是在try後的語句裏發生了異常，卻沒有匹配的except子句，異常將被遞交到上層的try，或者到程序的最上層（這樣將結束程序，並打印缺省的出錯信息）。
若是在try子句執行時沒有發生異常，python將執行else語句後的語句（若是有else的話），而後控制流經過整個try語句。

try:
    try:
        raise NameError
    except TypeError:
        print 'as'
except NameError:
    print 'e'
# e，try後語句raise觸發異常，except沒有匹配字句，被拋到上層try匹配，print 'e'

try:    
     1/0
except Exception , e:    
     print e 
#以上傳統的異常處理，加入!!!traceback後會打印出詳細的錯誤信息
import traceback
try:   
      1/0
except Exception: 
     traceback.print_exc()

try:
<語句>
finally:
<語句>    #退出try時總會執行
raise

try:
    1 / 0
except Exception as e:
    '''異常的父類，能夠捕獲全部的異常'''
    print "0不能被除"
else:
    '''保護不拋出異常的代碼'''
    print "沒有異常"
finally:
    print "最後老是要執行我"

-12.raise
觸發異常
raise [Exception[,args[,traceback]]]
語句中Exception是異常的類型（例如，NameError）參數是一個異常參數值。
該參數是可選的，若是不提供，異常的參數是」None」。
最後一個參數是可選的（在實踐中不多使用），若是存在，是跟蹤異常對象。

def mye( level ):
    if level < 1:
        raise Exception("Invalid level!", level)

raise 觸發異常後，後面的代碼就不會再執行

try:
     s = None
     if s is None:
         print "s 是空對象"
         raise NameError     #若是引起NameError異常，後面的代碼將不能執行
     print len(s)  #這句不會執行，可是後面的except仍是會走到
except TypeError:
     print "空對象沒有長度" #因爲錯誤類型並非TypeError,不執行print

try:
     s = None
     if s is None:
         print u"s 是空對象"
         raise NameError('name is wrong','is')     #若是引起NameError異常，後面的代碼將不能執行
     print len(s)  #這句不會執行，可是後面的except仍是會走到
except NameError,argvment:
     print u"空對象沒有長度",argvment

s = None
if s is None:
    raise NameError

 print 'is here?' #若是不使用try......except這種形式，那麼直接拋出異常，不會執行到這裏

def mye( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 觸發異常後，後面的代碼就不會再執行

try:
    mye(0)                # 觸發異常
except "Invalid level!":
    print 1
else:
    print 2

die函數，打印錯誤信息

def die(error_massage):
    raise Exception(error_massage)

a = 'wer'
if a == None:
    print 'None'
else:
    die()

-13.exec–eval–execfile
exec 用來執行儲存在字符串或文件中的Python語句
exec是一條語句將字符串str當成有效的python代碼來執行
eval與execfile是pytho內置函數
eval(str[globals[locals]])函數將字符串str當成有效的python表達式來求值，並提供返回計算值

exec 'print"hello world"'
exec 'a=100'
# 執行後 a = 100
print a #100
eval('3+5')# 8
b = eval('5+6')#eval 返回計算值
print b + 1 #12

execfile(filename)函數能夠用來執行文件

execfile(r'F:\learn\ex1.py')
# 若你位於文件所在目錄直接執行
execfile(r'ex1.py')

from os.path import exists
exists(file)將文件名字符串做爲參數，若是文件存在返回True，不然返回False

-14.return
return 是函數返回值

def fun():
    print 'asd'
# fun() 函數沒有顯示return,默認返回None

def fan(a):
    return a
#有返回值

-15.lambda—filter—map—reduce—
lambda 只是一個表達式，定義了一個匿名函數，起到函數速寫的做用
因爲lambda只是一個表達式，它能夠直接做爲python 列表或python 字典的成員，好比

info = [lambda a:a**3 , lambda b:b**3]

g = lambda x:x+1
g(1) #2 等價於 lambda x:x+1(1)
g(3) #4
#其中 x 爲入口參數，x+1 爲函數體
#用的函數來一樣表示
def g(x):
    return x+1


#lambda 也能夠用在函數中
def action(x):
    return lambda y:x+y

a = action(3)# a是action函數的返回值，
a(22) # 24 ，a(22) ，調用了action返回的lambda表達式
# 上面函數也可直接寫成下式
b = lambda x:lambda y:x+y
a = b(3)
a(2) # 也可直接 (b(3))(2)


# lambda 能夠一個、多個參數
g = lambda x:x*2 #one
print g(3)

m = lambda x,y,z: (x-y)*z # mutiple
print m(3,1,2)

#lambda 並不會帶來程序運行效率的提升，只會使代碼更簡潔。
#若是可使用for...in...if來完成的，堅定不用lambda。
#若是使用lambda，lambda內不要包含循環，若是有，我寧願定義函數來完成，
#使代碼得到可重用性和更好的可讀性。
# lambda 是爲了減小單行函數的定義而存在的。


# --filter(function or None, sequence) -> list, tuple, or string
# function是一個謂詞函數，接受一個參數，返回布爾值True或False。
# filter函數會對序列參數sequence中的每一個元素調用function函數，
# 最後返回執行結果爲True的
# 返回值的類型和參數sequence（list, tuple, string）的類型相同
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

print filter(lambda x: x % 3 == 0, foo)# filter 是 過濾/篩選 函數
print[x for x in foo if x % 3==0] #[18, 9, 24, 12, 27] 篩選foo中能被3整除的

map(function, sequence)
對sequence中的item 依次執行 function，將執行結果組成list返回
單個參數

str = ['a', 'b','c', 'd'] 

def fun2(s): 
    return s + ".txt"

ret = map(fun2, str)
print ret # ['a.txt', 'b.txt', 'c.txt', 'd.txt']

多個參數，要求函數接受多個參數

def add(x,y):
    return x+y

print map(add,range(5),range(5))
#[0,2,4,6,8]

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
print map(lambda x: x * 2 + 10, foo) 
#[14, 46, 28, 54, 44, 58, 26, 34, 64]

reduce(function, sequence, starting_value)
對sequence中的item順序迭代調用function，若是有starting_value，
還能夠做爲初始值調用，例如能夠用來對List求和

def add1(x,y):
    return x+y

print reduce(add1,range(1,100))
# 4950 注：1+2+...+99
print reduce(add1,range(1,100),20)
# 4970 注：1+2+...+99+20，20爲初始值

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。