Day04基礎（四）

時間 2019-11-13

標籤 day04 day 基礎简体版

原文原文鏈接

python 基礎（四）

一. 本章主要內容簡介：

1. Python內置函數的功能用途(繼續上一章講解)

內置函數：python

1）數字運算、類型轉換、集合類操做：express

　　bin()、oct()、int()、hex() 進制轉換，round()四捨五入，pow()返回x的y次冪，range() 生成序列，sum()求和，divmod()商和餘數，json

　　chr() 、ord()用來作ascii碼轉換，max()序列中最大值， min()最小值；random隨機數；小程序

　　basestring() 是str和unicode的超類（父類），format()格式化字符串，unichr()返回給定int類型的unicode，enumerate()枚舉函數，iter()生成一個對象的迭代器,數組

　　complex()複數，float()浮點數，bool()布爾值，dict()字典，list()列表，tuple()元組，str()字符串，set()集合，frozenset()產生一個不可變的set,sorted()排序，app

　　yeild()、xrange()py3時此函數已取消，生成器，len()計算長度；dom

2）邏輯判斷：函數

　　all()全部元素爲真、any()任何一個爲真、cmp()比較是否相等（Python3已經沒有這個函數了）；ui

3）IO操做：spa

　　input() 獲取輸入（Python3以前使用raw_input），print()打印輸出，open()文件操做；

4）反射

　　callable() 檢查對象object是否可調用、 classmethod() 是用來指定一個類的方法爲類方法

　　compile() 將source編譯爲代碼或者AST對象。代碼對象可以經過exec語句來執行或者eval()進行求值。

　　dir()不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。

　　delattr()刪除object對象名爲name的屬性，eval()計算表達式expression的值，filter()用於過濾序列。

　　execfile()用法相似exec()，不一樣的是execfile的參數filename爲文件名，而exec的參數爲字符串。　

　　getattr()獲取一個類的屬性，globals()返回一個描述當前全局符號表的字典，hasattr() 判斷對象object是否包含名爲name的特性，

　　hash()若是對象object爲哈希表類型，返回對象object的哈希值，isinstance()判斷object是不是class的實例，

　　id()返回對象的惟一標識，issubclass()判斷是不是子類，len()返回序列長度，locals()返回當前的變量列表， map()遍歷每一個元素，執行function操做，

　　memoryview()返回一個內存鏡像類型的對象， next()相似於iterator.next()， object()基類，

　　property()屬性訪問的包裝類，設置後能夠經過c.x=value等來訪問setter和getter,

　　reduce()合併操做，從第一個開始是前兩個參數，而後是前兩個的結果與第三個合併進行處理，以此類推,

　　reload()從新加載模塊, setattr()設置屬性值, repr()將一個對象變幻爲可打印的格式,

　　slice()是個類，切片類型，Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).

　　staticmethod()聲明靜態方法，是個註解，super()引用父類， type()返回該object的類型，

　　vars()返回對象的變量，若無參數與dict()方法相似，bytearray()返回一個byte數組，

　　zip()按列合併多個可迭代對象的列值，相同列的元素生成一個元組元素，有一列的元素爲空時，就再也不生成；

5）重要的內置函數，一會作一些實例，這裏只作簡介；　

2. 裝飾器講解；　

裝飾器是比較難理解的，這裏只作簡介。裝飾器使用環境：不想改變原函數，又要添加額外的功能時使用，裝飾器能夠在原函數以前、以後添加新增功能；

二. 經過實例講解內置函數

2.1 內置函數

1）數字運算類：

　　一、絕對值：abs(-1) 結果：1；

　　二、最大最小值：max([1,2,3])結果：3； min([1,2,3])結果：1

　　三、序列長度：len('abc')結果：3； len([1,2,3])結果：3； len((1,2,3))結果：3

　　四、取商和餘數：divmod(5,2) 結果：(2,1)

　　五、乘方：pow(2,3,4)//2**3/4 官方功能說明： Equivalent to x**y (with two arguments) or x**y % z (with three arguments)

　　六、四捨五入：round(2.7) 結果：3

　　七、求和：sum((1,2,3)) 結果：6 將純數字元素的列表或元組，計算求和；

　　八、切片：a = [1,2,3,4,5] ;a[0:3]結果：[1,2,3], 切片執行顧前不顧後，從0位開始，到3的位置終止，不包括3

　　九、步長：a = [1,2,3,4,5] ;a[0:5:2]結果：[1,3,5], 步長是隔幾個數取值，取值範圍1-5，每隔兩個取值，1開始取，2開始步長一次，3的時候步長爲2，再次取值，以此類推；

2）進制轉換：

　　一、二進制轉換，bin(10) 結果：'0b1010' ，將十進制轉爲二進制表示；

　　二、八進制轉換，oct(10) 結果： '0o12' ，將十進制轉爲八進制表示；

　　三、十進制整數表示，int(10) 結果： 10 ，默認是字符串，int後轉成十進制整數；

　　四、十六進制轉換，hex(16) 結果：'0x10，將十進制轉爲十六進制表示；

3）類型和類型轉換：

　　一、整數類型轉換，int('123') 　　結果：123，將字符串轉換成整數類型；

　　二、字符串類型轉換，type(str(int('123'))) 　　結果：<class 'str'>，將數字轉成字符串類型；

　　三、浮點類型轉換，float(123) 　　結果：123.0，　　　將整數轉爲浮點數表示；

　　四、複數類型轉換，complex(123) 　　結果：(123+0j)，將整數或浮點數轉爲複數；

　　五、列表類型轉換, list((1,2,3))、list('123')　　結果：['1','2','3'], 將可迭代對象轉爲列表；注意：字符串能夠轉換，數字類型不行（不可迭代）

　　六、元組類型轉換， tuple((1,2,3))、tuple('123')結果：（'1','2','3'）, 將可迭代對象轉爲列表；注意：字符串能夠轉換，數字類型不行（不可迭代）

　　七、集合類型轉換，set('abc') 　　　　　　　　　結果：{’a','b','c'} 將可迭代對象轉爲集合；

　　八、字典類型轉換，類型是字符串樣子倒是字典，須要json格式化轉換，如：a = '{"a":1}' ； json.loads(a) 結果：a轉爲字典類型；

　　九、布爾類型，布爾類型只有True和False兩種返回值， 0、None、False、" "、[]、()、{}是False，其它是True；

　　十、ASCII碼轉換，chr(48)與ord('0'), 對照ASSCII表操做，效果更好，chr(65) 結果：ASSCII 碼的 ‘A'；ord('A')結果：65；

　　　　chr(48)返回對應的ASCII字符0,與ord('0')做用相反。

　　十一、查看類型，type()，返回一個值的類型，type('abc') 結果：<class 'str'>；type(123) 結果：<class 'int'>；　　

4）判斷：

　　一、全部元素爲真，才爲真，all((1,'a')) 結果：True，參數必須是可迭代類型；

　　二、任何一個爲真，就爲真，any((1,0,None)) 結果：True，參數必須是可迭代類型；

　　三、判斷object是不是class的實例，isinstance('a',str) 結果： True，兩個參數，字符串a 和 str類型，’a‘是str類型返回True；

　　四、判斷對象是否能夠調用， callable() 若是對象能夠調用的，則返回true,若是對象不能調用，則返回false.

5）filter ()、map()和 lambda（）函數；

　　一、filter（函數，可迭代對象），過濾序列；

# filter
def f1(a):
    if a > 22:
        return True
li = [11,22,33,44,55]

ret = filter(f1,li)
print(list(ret))
執行結果：
[33,44,55]

　　lambda 函數，操做簡單的條件語句；

li = [11,22,22,33,44,55]
r = filter(lambda a: a > 33, li) 
print(list(r))
執行結果：
[44,55]

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda表達式是起到一個函數速寫的做用。容許在代碼內嵌入一個函數的定義。

　　二、map（函數，可迭代對象），執行函數操做，將返回值添加到結果中；

def f1(a):
    return a + 100
r = map(f1,li)
print(list(r))
執行結果：
[111, 122, 122, 133, 144, 155]

　　lambda 函數，操做簡單的條件語句；

li = [11,22,33,44,55]
ret = map(lambda a: a + 100 ,li)
print(list(ret))
執行結果:
[111, 122, 133, 144, 155]

　　三、filter 和 map 的區別：

　　　　filter 函數返回True，將結果添加到結果中；

　　　　map 將函數返回值添加到結果中；

6） globals() 和 locals()

　　一、globals(*args, **kwargs) 返回一個當前做用域裏全局變量的字典； Return a dictionary containing the current scope's globla variables.

　　二、locals(*args, **kwargs) 返回一個當前做用域裏局部變量的字典； Return a dictionary containing the current scope's local variables.

7）len() 函數

len返回序列長度；

s = "劉海龍"
print(len(s))

z = bytes(s,encoding='utf-8')
print(len(z))
執行結果：
3
9
這個結果：　Python2和3是不一樣的，中文字符Python3是按字符計算的，一個字是一個字符，支持經過bytes轉爲字節；
　　　　　  Python2是按字節計算的，一箇中文字符等於2個gbk字節，3個utf8字節，而且不支持轉爲字符；

8）compile()、exec() 和eval()函數

　　一、compile(source, filename, mode[, flags[, dont_inherit]])

　　中文說明：

　　　　將source編譯爲代碼或者AST對象。代碼對象可以經過exec語句來執行或者eval()進行求值。

　　　　參數source：字符串或者AST（Abstract Syntax Trees）對象。

　　　　參數 filename：代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值。

　　　　參數model：指定編譯代碼的種類。能夠指定爲 ‘exec’,’eval’,’single’。

　　　　參數flag和dont_inherit：這兩個參數暫不介紹，可選參數。

a = "print(123)"
r = compile(a,"<string>" , "exec")
exec(r)
print(a)
print(r)
執行結果：
123
print(123)
<code object <module> at 0x00000000006C2F60, file "<string>", line 1>
過程解析：
a 是一個字符串，經過compile函數，將字符串編譯成Python代碼，exec 執行代碼，獲得print結果；
有三種模式（single、exec、eval）

經過exec能夠執行動態Python代碼，相似Javascript的eval功能；而Python中的eval函數能夠計算Python表達式，並返回結果（exec不返回結果，print(eval("…"))打印None）；

s = "3*3"
ret = eval(s)
print(ret)
執行結果：
9
過程解析：
s 變量是一個字符串3*3，不是可計算的數字類型，當使用eval函數執解析後，打印就會將s轉換，並計算表達式，返回結果；

9） range(生成數字序列)、random（生成隨機數）

range()的返回值，Python3和2的區別很大；
a = range(5)
print(a)
執行結果：
range(0, 5)

# 製做6位隨機數小程序：
import  random

li = []
for i in range(6):
    r = random.randrange(0,5)
    if r == 2 or r == 4:
        num = random.randrange(0,10)
        li.append(str(num))
    else:
        temp = random.randrange(65,91)
        c = chr(temp)
        li.append(c)

result = "".join(li)
print(result)
過程解析：
　　加載random模塊，準備一個空列表，循環6次（生成6個值），定義r在循環時，隨機取0-5的值，若是r的值是2或是4時，隨機取0-9的數字追加到列表，
　　其它值時取大寫字母追加到列表，將列表經過join轉爲字符串，打印這個循環6次的字符串，便是6個隨機數；

10）zip()函數

　　按列合併多個可迭代對象的列值，相同列的元素生成一個元組元素，當其中一個列的元素爲空時，就再也不繼續生成；調用時，要指定類型調用；

a = (1,2,3,4,5)
b = ['alex','wusir','hailong','dawang','eric']
c = {'filter','map','exec','eval'}
ret = zip(a,b,c)
print(list(ret))
執行結果：
[(1, 'alex', 'map'), (2, 'wusir', 'filter'), (3, 'hailong', 'exec'), (4, 'dawang', 'eval')]
過程解析：
　　定義三個不一樣的序列，使用zip函數合併列值，相同列的元素生成一個元組元素，當c的值沒有第五個值的時候，就再也不繼續生成了，結果就是，在內存裏生成了四個元組元素；
　　打印返回值時，要使用相應的序列函數轉換，可使用列表、元組或集合內置函數轉換成相應類型使用； 本實例使用list函數轉換成列表；

三. 裝飾器

3.1 Python程序的執行順序

def f1():
    print(123)

def f1():
    print('abc')

f1()
# 函數執行結果：
abc
# 過程解析：
定義兩個相同的函數，輸出不一樣的內容，當在下方調用此函數時，執行的是最後定義的函數；

畫個圖：

實例二：

# 函數和執行函數的表示方法
def func():
    print('func')

func    # 表示函數
func()  # 表示執行func函數

# lambda建立函數，以及相同函數的執行順序：
def func():
    print('func')

func = lambda a: a + 3
print(func(4))
備註：lambda表達式只是建立一個函數，並不執行；

3.2 裝飾器是什麼？如何使用？

裝飾器就是把函數包裝一下，爲函數添加一些附加功能，裝飾器就是一個函數，參數爲被包裝的函數，返回包裝後的函數；

實例講解：

def d(fp):
    def _d(*arg, **karg):
        print("do sth before fp..")
        r= fp(*arg, **karg)
        print("do sth after fp..")
        return r
    return _d

@d
def f(f):
    print("call" ,f)
#上面使用@d來表示裝飾器和下面是一個意思
#f = d(f)

# 執行函數f
f("hailong")
# 執行結果：
do sth before fp..
call hailong
do sth after fp..
# 過程解析：
定義一個d函數，返回值是嵌套在函數裏的函數的返回值；函數自己是不執行的，只是加載到內存裏，當使用@d時，就是給下面的函數加一個d函數的裝飾器；
@d會自動執行d函數，而且把@d下面的f函數，做爲d函數的參數使用，而後將d函數的返回值，賦值給下面的f函數；