国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

經驗拾憶(純手工)=> Python好用深度技能工具介紹

UnixAgain / 2436人閱讀

摘要:單元素元祖這是整數這才是元祖也許這兩行,你們當時疑惑過,并且現在也都知道了,當然重點并不在這里。。雖然我水平很垃圾,但是我知道匿名函數有一種執行方式叫做自執行。看吧,這就是版的匿名函數自執行方法。

單元素元祖:
a = (1)    # 這是整數1
a = (1,)   # 這才是元祖
也許這兩行,你們當時疑惑過,并且現在也都知道了,當然重點并不在這里。。

我無聊的時候想過,為什么單元素元祖要這樣設計 -> (1,)?
不多廢話,看下面代碼,自己理解:
    a = (3,)
    a = (3)
    
    a = (1+2)
    a = (1+2,)
    
    a = (1+2) + (3+4)
    a = (1+2,) + (3+4,)

注:
    這是我個人原創理解的一個微不足道的知識點,但是印象卻特別深刻。
    因為我反向推測出 設計者為什么會設計出這種語法。
    (當然,也許我的推測和設計者當時的想法的并不一樣~~~手動滑稽)
深/淺拷貝-copy/deepcopy(皮/肉)
"""
    最開始接觸深淺拷貝的時候沒太大感覺,只是普通的覺得避免數據污染就夠了
    后來有一次用scrapy寫爬蟲的時候,層次太多導致內存有些頂不住。
    后來用的 deepcopy() 來 優化  scrapy 的 meta, 雖然效果不是特別明顯,但是感覺深淺拷貝很有用
"""
    1. =號,不拷貝
        =號就意味著,引用指向同一個地址空間,‘敵動我動,敵不動我不懂’ 的感覺。 LOL一句話:"連體嬰兒"~~
    2. copy:也稱淺拷貝
        我用最簡單的話解釋一下:淺拷貝就是只能拷貝最外面的一層皮,來獨立開辟空間使用,再深還是共用的
        eg:
            from copy import copy
            from copy import deepcopy
            
            a = [[1,2,3],[4,5,6]]
            b = deepcopy(a)
            b[0] = 0            # 這就是最外面的一層皮
            print(b)
            print(a)
    
    3. deepcopy:顧名思義了,深拷貝
       如果你聽懂我上面的話,我感覺這個就更好理解了, 淺拷貝是皮,深拷貝那就是肉了唄。
       沒錯,無論套了幾層的序列結構,每一層都是獨立開辟空間,獨立指向。
            from copy import copy
            from copy import deepcopy
            
            a = [[1,2,3],[4,5,6]]
            b = deepcopy(a)
            b[0][1] = 0    # 看清楚,這回就是里面的肉了, 深拷貝:你改哪里都行,哪里都與我無關
            print(b)
            print(a)

lambda黑科技
"""lambda相當于匿名函數,可以使代碼簡介,但有時也會被人唾棄,但我仍然喜歡用lambda"""

1. 試想:如果你想在lambda調用多個函數,該如何寫?
    lambda: (print(1),print(2))    # 最外層加個括號即可
    
2. 如果你想讓這個 lambda函數直接自執行,而不是通過賦予一個函數引用再執行?
    1. 這個也是我自己瞎鼓搗出來的。
    2. 雖然我JS水平很垃圾,但是我知道JS匿名函數有一種執行方式叫做 ‘自執行’。
    3. 把上面類比一下。
    
    看吧,這就是Python版的匿名函數自執行方法。
        Python版本: (lambda a:print(a))(1)        
        JS版:       (function(){})()
lambda的虛偽替代品-operator
"""
    據說這個模塊可以替代lambda, 個人理解此模塊并不那么太有實用價值,理解成本也偏高,
    建議:如果不喜歡lambda或者lambda用的很少的人,可以研究一下此模塊。此模塊的意圖還是可以的。
    我還是喜歡使用 lambda
"""
直接上個例子:(字典基于Value來排序) 
    傳統lambda寫法:
        In [27]: a = {"1":6, "2":5, "3":4}
        In [28]: sorted(a.items(), key=lambda a:a[1])   # 看key= 這里
        Out[28]: [("3", 4), ("2", 5), ("1", 6)]
                                
    operator寫法:
        from operator import itemgetter
        
        In [25]: a = {"1":6, "2":5, "3":4}
        In [26]: sorted(a.items(), key=itemgetter(1))   # 就是key= 這里有區別
        Out[26]: [("3", 4), ("2", 5), ("1", 6)]

如果上面兩種新舊方法都很模糊,那么我再解釋一下: 我認為上面能讓人頭疼的也就是 索引 1 了!!!!
    sorted, map這種高階函數,我之前也多帶帶講過,它會把 一個序列的每一個元素用管道函數進行映射。
    
    sorted稍微特殊一點,它的管道函數方法變成了key=這里: (變相理解為 指定排序的基準/參考)
        1. key=lambda a:a[1]
            指定基準:序列a的 每子元素 的 第1號索引子元素    # eg: [[1,2],[3,4],[5,6]]  就是2,4,6
        
        2. key=itemgetter(1)
            指定基準:同上一模一樣,只不過寫法不一樣,邏輯步驟就是 原原本本從 lambda那里演變過來的。
            
總結與個人觀點:
    1. operator 模塊只是 lambda 使用思想 的 高一層的封裝
    2. 讓使用者可以忽略lambda格式細節
    3. 但是我認為 如果lambda都用不好, 那么 這個 itemgetter(1) 這種子元素 索引的指定 也會很困難
    4. 所以我還是建議用 lambda, 當你 lambda思想練熟了之后, 用 operator看看官方文檔就是很快的事情
    
            
      
            
                            
封包/拆包(解構賦值)/函數占位參數騷操作
"""
    再次說明一下:我寫的所有的都是Py3的/   Py2的解構賦值可能有些出入,此處我只說Py3
"""

封包:
    1)
        def f(a,*b):
            print(a)    # 1
            print(b)    # (2,3,4)
        f(1,2,3,4)
    2) 
        def f(**kwargs):
            print(kwargs)    # {"a": 3, "b": 4}
        f(**dict(a=3,b=4))
        
拆包(解構賦值):
    """
        我說過太多次了, ES6的語法和Python很像。解構賦值這個詞也是從ES6聽到的。
        不過ES6的解構,還可以解構 {} 和 解構空值 和 解構默認值,   而Python不可以
    """
    1)  只要第一個
            a, *_ = range(5)
            print(a, _)     # 0  [1, 2, 3, 4]

    2)  只要第一個和最后一個
            a, *_, c = range(5)
            print(a, _, c)    # 0  [1, 2, 3]  4
            
    3)  只要最后一個
            *_, b = range(5)
            print(_, b)      # [0, 1, 2, 3]  4


函數占位參數騷操作:
    """
        這是我在源碼中看到的,當時覺得很驚訝,自己試了一下,下面說下自己的理解:
        這個*的作用就是: (*后面的參數是 調用時 必須命名 且 必須傳遞 的參數)
            a你必須給我傳過來,但是你不寫   a=
            b你必須給我傳過來,但是你必須寫 b=
    """
    def f(a,*,b):
        print(a)
        print(b)
    f(1,b=3)    # f(a=1,b=3)    # 只能通過這兩種方式調用
反射-getattr & setattr & hasattr & delattr & import_module
綜合例子:
    from importlib import import_module
    random = import_module("random")          # 動態反射導入模塊  
    # 或 random = __import__("random")         
    if hasattr(random, "randint"):            # 檢測模塊中是否有函數
        randint = getattr(random,"randint")   # 動態反射導入函數
        print(eval("randint(0,1)"))               # 字符串轉語句執行(類似反射)
    
getattr & setattr & hasattr & delattr 講解:
    hasattr & getattr
        random = __import__("random")
        if hasattr(random,"randint"):    # 檢測 random 模塊中是否有 randint 函數
            randint = getattr(random,"randint")
            print(randint(0,1))
            
    delattr & hasattr 
        delattr(random, "randint")      # 動態刪除模塊中的 randint函數
        if not hasattr(random,"randint"):
            print("沒有此函數了,讓delattr刪除了")
            
    setattr & getattr                   # 動態重新設置模塊的 randint函數,并給個函數體
        setattr(random, "randint", lambda:print("設置這個方法湊合用把。"))
        randint = getattr(random, "randint")
        randint()     

模塊重新導入到內存-reload
from imp import reload
import time
reload(time)
print(time.time())
進度條-tqdm
for x in tqdm(range(100)):
    import time
    time.sleep(1)
    print(x)
tqdm包裝一個可迭代對象, 只是裝飾了一下,使用方法還是像原來一樣使用。 
票數統計-Counter
In [2]: from collections import Counter

In [3]: Counter([1,2,3,4])
Out[3]: Counter({1: 1, 2: 1, 3: 1, 4: 1})

In [4]: Counter([1,1,1,2,2,3])    # 統計頻次
Out[4]: Counter({1: 3, 2: 2, 3: 1})

In [5]: Counter([1,1,1,2,2,3]).most_common(1)    # 頻次最多的前1個
Out[5]: [(1, 3)]
文件 復制/移動-shutil
import shutil
shutil.copy(源,目標)    # 復制
shutil.move(源,目標)    # 移動,改名
shutil.rmtree(r"目錄名")  # 刪除目錄(級聯刪除)    # 參數只能是目錄
文件遍歷-os.walk
"""
    os.walk() 是一個深度遍歷模式的文件遍歷函數
    返回值是一個迭代器,遍歷這個迭代器后,每一次的返回值都是如下順序三種構成
        1. current_path: 當前路徑 
        2. dir_list:     其下目錄列表
        3. file_list:    其下文件列表
    
"""
import os
file_generator = os.walk("D:/虛擬E盤-代碼空間/TF2")
for current_dir, dir_list, file_list in file_generator:
    print(current_dir, dir_list, file_list)
非阻塞執行cmd/shell-subprocess
"""
    主要代替os.system
""" 
import subprocess
res = subprocess.run("dir", shell=True, stdout=subprocess.PIPE) # 結果輸入到res管道中去
print(res.stdout.decode("gbk"))    # res管道中有輸出日志,如果在win下,需要 decode
排列組合-itertools模塊
import itertools
list(itertools.product([1,2,3],repeat=3))    # 復制3份有序全排列, repeat=3    
list(itertools.permutations([1,2,3], 3))     # 內部有序排列, 3表示最后排列為幾位
list(itertools.permutations([1,2,3,4],3))    # 無序組合, 3表示3位
枚舉-emunerate
In [100]: list(enumerate(list("abcde"),start=1))    # 默認從0,開始標號, start=1就從1開始
Out[100]: [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")]

In [108]: list(enumerate(((1,2),(3,4))))
Out[108]: [(0, (1, 2)), (1, (3, 4))]        

In [106]: list(enumerate({"a":"c","b":"d"}))
Out[106]: [(0, "a"), (1, "b")]
global & nonlocal & globals() & locals()
global: 函數外的變量只能在函數內部取值,而不能修改, 如果想要在函數內部修改外部變量, ‘global 變量名’ 即可
    a = 1
    def f():
        global a
        a += 1
        print(a)
    f()
        
nonlocal: 原理同上一模一樣,只不過應用場景是閉包了,代碼如下:
    def f():
        a = 1
        def f1():
            nonlocal a
            a = a+1
            print(a)
        f1()
    f()

日歷-calendar
import calendar
calendar.calendar(2019)    # 返回2019年的日歷
calendar.month(2919,5)    # 返回2019年5月的日歷
calendar.isleap(2000)    # 判斷2000年是否為閏年
時間/日期-time/datetime
import time
1. 時間戳:
    time.time()
    
2. 字符串轉時間(p-pass方便記憶)
    from datetime import datetime
    fordate = datetime.strptime("2019-5-25 9:30:30", "%Y-%m-%d %H:%M:%S")
    print(fordate)

3. 時間轉字符串(f-from方便記憶)
    from datetime import datetime
    strdate = datetime.strftime(fordate, "%Y-%m-%d %H:%M:%S")
    print(strdate)
    
4. 初始化時間
    from datetime import datetime
    dt1 = datetime(2019,5,25,9,37)    # 初始化時間為 datetime格式
    dt1 = datetime.now()   # 獲取當前時間為 datetime格式
    print(dt1.year)
    print(dt1.month)
    print(dt1.day)
    print(dt1.hour)
    print(dt1.minute)
    print(dt1.second)



    

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/43889.html

相關文章

  • 經驗拾憶手工)=> Python基本數據類型

    摘要:不要疑惑,告訴你答案這個代表正負號的正。雖然一點技術含量沒有,但是你要懂序列也許叫可迭代對象更為合適,但是我喜歡叫序列。 數據結構 可變類型與不可變類型(重頭戲) 基操: 可變類型:[], {} # 可增刪改 查 不可變類型: int float str () # 無法增刪改, 只可查 升操: + 與...

    Andrman 評論0 收藏0
  • 經驗拾憶手工)=> Linux實用工具命令

    摘要:為啥直接不行呢因為以開頭的最后一條命令是。和和和強制終止最常用的,先提出來。。。。我們可以通過這一條命令來迅速回到程序運行的環境。其實這些配置文件以及這些命令和用戶以及權限等都是有很大關系的。 Ubuntu16升級到18.04 有特殊新穎強迫癥癖好可以升下,如果你覺得16.04好用,就根本沒必要升了 我當時租的 云服務器通常都是16.04,現在估計也是16.04較多 我是個...

    kk_miles 評論0 收藏0
  • 經驗拾憶手工)=> Python高階函數操作

    摘要:解釋就相當于把每個序列元素的每一個單獨用一個管道函數處理,再把他們按順序組合成一個新可迭代對象注意這個管道函數只能是單參數函數,如果想傳遞多個參數怎么辦使用偏函數怕有些人看不懂,這里就不用了,而是用普通函數定義方式固定值固定值固定值固定值固 map In [25]: list(map(lambda a:a**2, [1,2,3,4])) Out[25]: [1, 4, 9, 16] 解...

    Elle 評論0 收藏0

發表評論

0條評論

UnixAgain

|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<