python進階篇

來源:互聯網
上載者:User

標籤:實用   star   私人化   不定長參數   迭代器   策略   不同   類型   閉包   

python進階篇import 匯入模組

sys.path:擷取指定模組搜尋路徑的字串集合,可以將寫好的模組放在得到的某個路徑下,就可以在程式中import時正確找到。

? import sys

? sys.path.append("")

重新匯入模組

? reload(模組)

==、is
    a = [11,22,33]    b = [11,22,33]    >>>a == b    True    >>>a is b    False    >>>a = c    >>>a is c    True

數字在一定範圍內a is b,True,其他範圍False

深拷貝和淺拷貝

? a = [11,22,33]

? b =a

? >>>id(a)==id(b)

? True

? 沒有複製資料,只是把指向的位置複製給它就是淺拷貝

? import copy

? c = copy.deepcopy(a)

? id(a)和id(c)不同,深拷貝

? a = [11,22,33]

? b = [44,55,66]

? c = [a,b]

? d = copy.deepcopy(c)

? e = copy.copy(c)

? a.append(44)

? >>>c[0]

? [11,22,33,44]

? >>>d[0]

? [11,22,33]

? >>>e[0]

? [11,22,33,44]

copy.copy()列表後,id 也不同,但是會持續拷貝

改為元組後,copy.copy(),id相同,元組不可變類型,直接淺拷貝

copy.copy()根據可變不可變類型,功能不同

十進位,二進位,八進位,十六進位之間的轉換

私人化
  • xx:公有變數

  • _x:from somemodule import * 禁止匯入,類對象和子類可以訪問

  • __xx:雙前置底線,避免與子類中的屬性命名衝突,無法在外部直接存取

  • ___xx___:雙前後底線,對象或屬性

  • xx_:單後置底線,用於避免與python關鍵字的衝突

###### 1.私人屬性添加getter和setter方法

?

```python
class Money(object):

    def __init__(self):        self.__money = 0    def getMoney(self):        return self.__money    def setMoney(self,value):        if  isinstance(value,int):            self.__money = value        else:            print("error:不是整型數字")

```

?

###### 2.使用property升級getter和setter方法

?

```python
class Money(object):

    def __init__(self):        self.__money = 0    def getMoney(self):        return self.__money    def setMoney(self,value):        if isinstance(value,int):            self.__money = value        else:            print("error:不是整型數字")    money = property(getMoney,setMoney)

```

注意:

  1. t.num到底是調用getNum()還是setNum(),要根據實際情境來判斷;

  2. 如果是給t.num賦值,那麼一定是調用setNum()

  3. 如果是擷取t.num的值,那麼就一定調用getNum()

  4. property的作用:相當於把方法進行了封裝,開發人員在對屬性設定資料的時候更方便

    ?

    ```python
    class Money(object):

        def  __init__(self):        self.__money = 0    @property    def money(self):        return self.__money    @money.setter    def money(self,value):        if  isinstance(value,int):            self.__money = value        else:            print("error:不是整型數字")

    ```

    ?

    #### 迭代器

    1.可迭代對象

    直接作用於for迴圈的資料類型有以下幾種:

    一種是集合資料類型,如list,tuple,dict,set,str等;

    一種是generator,包括產生器和帶yield的generator function。

    這些可以直接作用於for迴圈的對象統稱為可迭代對象:lterable。

    ##### 2.判斷是否可以迭代

    可以使用isinstance()判斷一個對象是否是lterable:

    ```python
    from collections import Iterable

    isinstance("abc",Iterable)>>>True

    ```

    ?

    ##### 3.迭代器

    可以被next()函數調用並不斷返回下一值的對象成為迭代器:Iterator

    ? from collections import Iterator

    ? isinstance([],Iterator)

    ? >>>False

    ? isinstance((x for x in range(10)),Iterator)

    ? >>>True

    ##### 4.iter()函數

    產生器都是Iterator對象,但list、dict、str雖然是Iterable,卻不是Iterator。

    把list、dict、str等Iterable變成Iterator可以使用iter()函數:

    ? isinstance(iter([]),Iterator)

    ? >>>True

    #### 閉包

    ```python
    #在函數內部再定義一個函數,並且這個函數用到了外邊函數的變數,那麼將這個函數以及用到的一些變數稱之為閉包

    def  test(number):    print("----1------")    def test_in(number2):        print("------2----")        print(number-number2)    print("-----3-----")    return test_inret = test(100)ret(1)\>>>----1------    -----3-----    ------2----    99def  test(a,b):    def  test_in(x):        print(a*x+b)    return  test_inline1 = test(1,1)   line1(0)line2 = test(10,4)line2(0)line1(0)

    ```

    ?

    #### 裝飾器

    ? def w1(func):

    ? def inner():

    ? print("----正在驗證許可權------")

    ? func()

    ? return inner

    ? def f1():

    ? print("----f1-----")

    ? def f2():

    ? print("----f2-----")

    ? innerFunc = w1(f1)

    ? innerFunc()

    f1 賦值地址,f1()調用函數

    ? def w1(func):

    ? def inner():

    ? print("----正在驗證許可權------")

    ? func()

    ? return inner

    ? def f1():

    ? print("----f1-----")

    ? def f2():

    ? print("----f2-----")

    ? f1 = w1(f1)

    ? f1()

    @w1等價於w1(f1)

    def w1(func):

    ? def inner():

    ? print("----正在驗證許可權------")

    ? func()

    ? return inner

    ? @w1

    ? def f1():

    ? print("----f1-----")

    ? @w1

    ? def f2():

    ? print("----f2-----")

    ? f1()

    ? f2()

    ###### 多個裝飾器

    ? def makeBold(fn):

    ? def wrapped():

    ? print("----1------")

    ? return "" + fn() + ""

    ? return wrapped

    ? def makeItalic(fn):

    ? def wrapped():

    ? print("----2------")

    ? return "" + fn() +""

    ? return wrapped

    ? @makeBold#只要python解譯器執行到了這個代碼,那麼就會自動進行裝飾,而不是等到調用才裝飾的

    ? @makeItalic

    ? def test3():

    ? print("--------3-----")

    ? return "hello world-3"

    ? ret = test3()

    ? print(ret)

    ? >>>----1------

    ? ----2------

    ? --------3-----

    ? hello world-3

    從上往下執行,從下往上裝飾

    ? def w1(func):

    ? print("----正在裝飾1-----")

    ? def inner():

    ? print("------正在驗證許可權1-----")

    ? def w2(func):

    ? print("---- 正在裝飾2-----")

    ? def inner():

    ? print("----正在驗證許可權2----")

    ? func()

    ? return inner()

    ? @w1

    ? @w2

    ? def f1():

    ? print("----f1----")

    ? f1() #在調用f1之前,已經進行裝飾了

    ? >>>---- 正在裝飾2-----

    ? ----正在裝飾1-----

    ? ------正在驗證許可權1-----

    ? ----正在驗證許可權2----

    ? ----f1----

    ###### 裝飾器對有參數,無參數函數進行裝飾

    ```python
    def func(functionName):

        print("----func---1---")    def  fun_in(*args,**kwargs):#定義不定長參數        print("---func_in---1---")        functionName(*args,**kwargs)        print("---func_in---2---")    print("---func---2---")    return func_in@funcdef  test1(a,b,c):    print("----test-a=%d,b=%d,c=%d---"%(a,b,c))@funcdef  test2(a,b,c,d):    print("----test-a=%d,b=%d,c=%d,d=%d---"%(a,b,c,d))test1(11,22,33)test2(44,55,66,77)\>>>----func---1---    ---func---2---    ---func---1---    ---func---2---    ---func_in---1---    ----test-a=11,b=22,c=33---    ---func_in---2---    ---func_in---1---    ----test-a=44,b=55,c=66,d=77---    ---func_in---2---

    ```

    ###### 裝飾器對帶有傳回值的參數進行裝飾

    ```python
    def func(functionName):

        print("---func---1---")    def  func_in():        print("---func_in---1---")        ret = functionName()#儲存返回來的haha        print("---func_in---2---")        return ret  #把haha返回到調用處    print("---func---2---")@funcdef  test():    print("----test----")    return  "haha"ret = test()print("test return value is %s"%ret)

    帶有參數的裝飾器

    def  func_arg(arg):    def  func(functionName):        def  func_in():            print("---記錄日誌-arg=%s--"%arg)            if  arg =="heihei":                functionName()                functionName()            else:                functionName()        return func_in()    return  func@func_arg("heihei")#帶有參數的裝飾器,能夠起到在運行時,有不同的功能def  test():    print("--test--")@func_arg("haha")def  test2():    print("--test2--")test()test2()

    ```

    ?

    #### 範圍

    ###### LEGB規則

    locals -> enclosing function -> globals -> builtings

    locals:當前所在命名空間

    enclosing function:外部嵌套函數的命名空間(閉包中常見)

    globals:全域變數

    builtings:內嵌

    ##### 動態添加屬性和方法

    添加屬性 類/執行個體.屬性 = XX

    添加方法 不能按上面方法,

    ? import types.MethodType

    ? 綁定的對象.函數名() = types.MethodType(函數名,綁定的對象)

    ###### __slots__

    為了達到限制的目的,Python允許在定義class的時候,定義一個特殊的__slots__變數來限制class執行個體能添加的屬性:

    ```python

    class Person(object):
    slots = ("name","age")

    P = Person()
    P.name = "老王"
    P.age = 20
    #添加其他屬性會報錯
    ```

    ##### 產生器

    一邊迴圈一邊計算

    ###### 建立產生器方法

    1.把列表產生式的[]改成(),通過next函數擷取產生器的下一個傳回值

    python def creatNum(): print("-----start-----") a,b = 0,1 for i in range(5): print("----1----") yield b #程式停下來,把yield後面的值返回 print("----2----") a,b = b,a+b print("----3----") print("----stop----") \>>>a = creatNum() \>>>a <generator object creatNum at 0x7f42d27de7d8> \>>>next(a) -----start----- ----1---- 1 \>>>next(a)#等價於a.__next__() ----2---- ----3---- ----1---- 1

    python def test(): i = 0 while i<5: temp = yield i print(temp) i+=1 \>>>t = test() \>>>t.__next__() [out] 0 \>>>t.__next__() None [out] 1 \>>>t.__next__() None [out] 2 \>>>t.send("haha") haha [out] 3

    ##### 類當作裝飾器

    定義一個__call__方法,類就可以直接調用

class Test(object):    def __init__(self,func):        print("---初始化---")        print("func name is %s"%func.__name__)        self.__func = func    def __call__(self):        print("---裝飾器中的功能---")        self.__func()@Testdef test():#當用Test來裝作裝飾器對test函數進行裝飾的時候,首先會建立一個Test的執行個體對象,func指向test(),func.__name__函數名    print("---test---")test()
元類

類也是一個對象

使用type建立類

python = type(類名,由父類名稱組成的元組(針對繼承的情況可以為空白),包含屬性的字典) Person = type("Person",(),{"num":0}) p1 = Person() \>>>p1.num 0 def printNum(self): print("---num-%d---"%self.num) \>>>Test3 = type("Test3",(),{"printNum":printnum}) t1 = Test3() t1.num = 100 t1.printNum() ---num-100---

__metaclass__屬性
def upper_attr(future_class_name,future_class_parents,future_class_attr):    #遍曆屬性字典,把不是__開頭的屬性名稱字變為大寫    newAttr = {}    for name,value in future_class_attr.items():        if not name.startswith("__"):            newAttr[name.upper()] = value    #調用type來建立一個類    return type(future_class_name,future_class_parents,newAttr)class Foo(object,metaclass = upper_attr):   #設定Foo類的元類為upper_attr    bar = "bip"print(hasattr(Foo,‘bar‘))print(hasattr(Foo,‘BAR‘))f = Foo()print(f.BAR)
記憶體回收

1.小整數對象池

[-5,257)這些整數對象是提前建立好的,不會被記憶體回收。在一個python程式中,所有位於這個範圍內的整數使用的都是同一個對象

2.大整數對象池

3.intern機制

  • 小整數共用對象,常駐記憶體
  • 單個字元共用對象,常駐記憶體
  • 單個單詞,不可修改,預設開啟intern機制,共用對象,引用計數為0,則銷毀
Garbage collection(GC記憶體回收)

python採用的是引用計數機製為主,標記-清除和分代收集兩種機製為輔的 策略

引用計數機制的優點:

  • 簡單
  • 實用性:一旦沒有引用,記憶體就直接釋放了。處理回收記憶體的時間分攤到了平時

缺點:

  • 維護引用計數消耗資源

  • 循環參考

python list1 = [] list2 = [] list1.append(list2) list2.append(list1)

相互引用,list1與list2的引用計數也仍然為1,所佔用的記憶體永遠無法被回收。

鏈表引用計數,分代收集

1.引用計數+1的情況

  • 對象被建立,例如a=23
  • 對象被引用,例如b =a
  • 對象被作為參數,傳入到一個函數中,例如func(a)
  • 對象作為一個元素,儲存在容器中,例如list1=[a,a]

2.引用計數-1的情況

  • 對象的別名被顯式銷毀,例如del a
  • 對象的別名被賦予新的對象,例如a=24
  • 一個對象離開他的範圍,例如func函數執行完畢時,func函數中的局部變數(全域變數不會)
  • 對象所在的容器被銷毀,或從容器中刪除對象

3.查看一個對象的引用計數

python import sys a = "hello world" sys.getrefcount(a) \>>>2

python import gc#gc預設運行 gc.disable()#關閉gc gc.collect()#手動調用collect

##### 內建屬性

常用專有屬性 說明 觸法方式
__init__ 構造初始化函數 建立執行個體後,賦值時使用,在__new__後
__new__ 產生執行個體所需屬性 建立執行個體時
__class__ 執行個體所在的類 執行個體.__class__
__str__ 執行個體字串表示,可讀性 print(類屬性),如沒實現,使用repr結果
__repr__ 執行個體字串表示,準確性 類執行個體 斷行符號 或者print(repr(類執行個體))
__del__ 析構 del刪除執行個體
__dict__ 執行個體自訂屬性 vars(執行個體.__dict__)
__doc__ 類文檔,子類不能繼承 help(類或執行個體)
__getattribute__ 屬性訪問攔截器 訪問執行個體屬性時
__base__ 類的所有父類構成元素 類名.__bases__

#### 內建函數

###### map函數

map(function,sequence[,sequence,...]) -> list

  • function:是一個函數
  • sequence:是一個或多個序列,取決於function需要幾個參數
  • 傳回值是一個list

```python
#函數需要一個參數
map(lambda x:x*x,[1,2,3])
# 結果為:[1,4,9]

#函數需要兩個參數
map(lambda x, y: x+y,[1,2,3],[4,5,6])
#結果為:[5,7,9]

def f1(x, y):
return (x,y)
l1 =[0,1,2,3,4,5,6]
l2 =[‘Sun‘,‘M‘,‘T‘,‘W‘,‘T‘,‘F‘,‘S‘]
l3 =map(f1,l1,l2)
print(list(l3))
#結果為:[(0,‘Sun‘),(1,‘M‘),(2,‘T‘),(3,‘W‘),(4,‘T‘),(5,‘F‘),(6,‘S‘)]

```

##### filter函數

對指定對象執行過濾

filter函數會對序列參數sequence中的每個元素調用function函數,最後返回的結果包含調用結果為Ture的元素。

傳回值的類型和參數sequence的類型相同

python filter(lambda x: x%2,[1,2,3,4]) [1,3] filter(None,"she") ‘she‘

##### reduce函數

reduce依次從sequence中取一個元素,和上一次調用function的結果做參數再次調用function。第一次調用function時,如果提供initial參數,會以sequence中的第一個元素和initial作為參數調用function,否則會以序列sequence中的前兩個元素做參數調用function.注意function函數不能為None。

```python
reduce(lambda x, y: x+y,[1,2,3,4])
10

reduce(lambda x,y:x+y,[1,2,3,4],5)
15

reduce(lambda x, y:x+y,[‘aa‘,‘bb‘,‘cc‘],‘dd‘)
‘ddaabbcc‘
python3裡面reduce函數要先引入:from functools import reduce
```

##### sorted函數

```python
a = [55,22,77,99]
a.sort()
>>>a
[22,55,77,99]
a.sort(reverse=Ture)
>>>a
[99,77,55,22]

sorted([1,5,4,2])
>>>[1,2,4,5]
sorted([1,5,4,2],reverse=1)
>>>[5,4,2,1]
```

#### 集合set

```python
a=[11,55,44,22,11,11]
b = set(a)
>>>b
{11,55,44,22}
>>>a=list(b)
>>>a
[11,55,44,22]

a = "abcdef"
b = set(a)
>>>b
{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘}
A="bdfhuy"
B = set(A)
>>>B
{‘b‘,‘d‘,‘f‘,‘h‘,‘u‘,‘y‘}
>>>b&B
{‘b‘,‘d‘,‘f‘}
>>>b|B
{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f,‘h‘,‘u‘,‘y‘}
>>>b-B
{‘a‘,‘c‘,‘e‘}
>>>b^B
{‘a‘,‘c‘,‘e‘,‘h‘,‘u‘,‘y‘}
```

##### functools

###### partial函數

```python
import functools
def showarg(*args,**kw):
print(arg)
print(kw)

p1=functools.partial(showarg,1,2,3)
p1()
p1(4,5,6)
p1(a=‘python‘,b=‘itcast‘)

>>>(1,2,3)
{}
(1,2,3,4,5,6)
{}
(1,2,3)
{‘a‘:‘python‘,‘b‘:‘itcast‘}
```

###### wraps函數

使用裝飾器時,被裝飾後的函數其實已經是另外一個函數(函數名等函數屬性會發生改變,functools包中提供了叫warps的裝飾器來消除這樣的副作用。

import functoolsdef note(func):    "note function"    @functools.wraps(func)    def wrapper():        "wrapper function"        print(‘note something‘)        return func()    return wrapper@notedef test():    "test function"    print(‘I am test‘)    test()print(test.__doc__)
模組

hashlib密碼編譯演算法

import hashlibm = hashlib.md5()#建立hash對象,md5print mm.update(‘itcast‘)#更新雜湊對象以字串參數print(m.hexdigest())#返回十六進位數字字串

python進階篇

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.