leetcode刷題筆記300題最長上升子序列

阿新 • • 發佈：2020-11-23

閱讀目錄

一引子
二定義函式
三呼叫函式
四函式的引數
五練習題

一引子

一為何要用函式之不用函式的問題

#1、程式碼的組織結構不清晰，可讀性差
#2、遇到重複的功能只能重複編寫實現程式碼，程式碼冗餘
#3、功能需要擴充套件時，需要找出所有實現該功能的地方修改之，無法統一管理且維護難度極大

二函式是什麼

針對二中的問題，想象生活中的例子，修理工需要實現準備好工具箱裡面放好錘子，扳手，鉗子等工具，然後遇到錘釘子的場景，拿來錘子用就可以，而無需臨時再製造一把錘子。

修理工===>程式設計師
具備某一功能的工具===>函式

要想使用工具，需要事先準備好，然後拿來就用且可以重複使用
要想用函式，需要先定義，再使用

三函式分類

#1、內建函式
為了方便我們的開發，針對一些簡單的功能，python直譯器已經為我們定義好了的函式即內建函式。對於內建函式，我們可以拿來就用而無需事先定義，如len(),sum(),max()
ps：我們將會在最後詳細介紹常用的內建函式。

#2、自定義函式
很明顯內建函式所能提供的功能是有限的，這就需要我們自己根據需求，事先定製好我們自己的函式來實現某種功能，以後，在遇到應用場景時，呼叫自定義的函式即可。例如

二定義函式

一如何自定義函式？

#語法
def 函式名(引數1,引數2,引數3,...):
    '''註釋'''
    函式體
    return 
 返回的值

#函式名要能反映其意義

def auth(user:str,password:str)->int:
    '''
    auth function
    :param user: 使用者名稱
    :param password: 密碼
    :return: 認證結果
    '''
    if user == 'egon' and password == '123':
        return 1
# print(auth.__annotations__) #{'user': <class 'str'>, 'password': <class 'str'>, 'return': <class 'int'>} 


user=input('使用者名稱>>: ').strip()
pwd=input('密碼>>: ').strip()
res=auth(user,pwd)
print(res)

View Code

二函式使用的原則：先定義，再呼叫

函式即“變數”，“變數”必須先定義後引用。未定義而直接引用函式，就相當於在引用一個不存在的變數名
#測試一
def foo():
    print('from foo')
    bar()
foo() #報錯

#測試二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#測試三
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() #會報錯嗎?


#結論:函式的使用,必須遵循原則:先定義,後呼叫
#我們在使用函式時,一定要明確地區分定義階段和呼叫階段

#定義階段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#呼叫階段
foo()

View Code

三函式在定義階段都幹了哪些事？

#只檢測語法，不執行程式碼
也就說，語法錯誤在函式定義階段就會檢測出來，而程式碼的邏輯錯誤只有在執行時才會知道

四定義函式的三種形式

#1、無參：應用場景僅僅只是執行一些操作，比如與使用者互動，列印
#2、有參：需要根據外部傳進來的引數，才能執行相應的邏輯，比如統計長度，求最大值最小值
#3、空函式：設計程式碼結構

#定義階段
def tell_tag(tag,n): #有引數
    print(tag*n)

def tell_msg(): #無引數
    print('hello world')

#呼叫階段
tell_tag('*',12)
tell_msg()
tell_tag('*',12)

'''
************
hello world
************
'''

#結論：
#1、定義時無參，意味著呼叫時也無需傳入引數
#2、定義時有參，意味著呼叫時則必須傳入引數

無參、有參

def auth(user,password):                             
    '''                                                           
    auth function                                                 
    :param user: 使用者名稱                                              
    :param password: 密碼                                           
    :return: 認證結果                                                 
    '''                                                           
    pass                                                          
                                                                  
def get(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
    pass                                                          
                                                                  
def put(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
def ls(dirname):                                                  
    '''                                                           
    :param dirname:                                               
    :return:                                                      
    '''                                                           
    pass                                                          

#程式的體系結構立見

空函式

三呼叫函式

一呼叫函式

函式的呼叫：函式名加括號
1 先找到名字
2 根據名字呼叫程式碼

二函式返回值

無return->None
return 1個值->返回1個值
return 逗號分隔多個值->元組

什麼時候該有返回值？
　　　　呼叫函式，經過一系列的操作，最後要拿到一個明確的結果，則必須要有返回值
　　　　通常有參函式需要有返回值，輸入引數，經過計算，得到一個最終的結果
什麼時候不需要有返回值？
　　　　呼叫函式，僅僅只是執行一系列的操作，最後不需要得到什麼結果，則無需有返回值
　　　　通常無參函式不需要有返回值

三函式呼叫的三種形式

1 語句形式：foo()
2 表示式形式：3*len('hello')
3 當中另外一個函式的引數：range(len('hello'))

四函式的引數

一形參與實參

#形參即變數名，實參即變數值，函式呼叫時，將值繫結到變數名上，函式呼叫結束，解除繫結

二具體應用

#1、位置引數：按照從左到右的順序定義的引數
        位置形參：必選引數
        位置實參：按照位置給形參傳值

#2、關鍵字引數：按照key=value的形式定義的實參
        無需按照位置為形參傳值
        注意的問題：
                1. 關鍵字實參必須在位置實參右面
                2. 對同一個形參不能重複傳值

#3、預設引數：形參在定義時就已經為其賦值
        可以傳值也可以不傳值，經常需要變得引數定義成位置形參，變化較小的引數定義成預設引數（形參）
        注意的問題：
                1. 只在定義時賦值一次
                2. 預設引數的定義應該在位置形參右面
                3. 預設引數通常應該定義成不可變型別


#4、可變長引數：
        可變長指的是實參值的個數不固定
        而實參有按位置和按關鍵字兩種形式定義，針對這兩種形式的可變長，形參對應有兩種解決方案來完整地存放它們，分別是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名關鍵字引數：*後定義的引數，必須被傳值（有預設值的除外），且必須按照關鍵字實參的形式傳遞
可以保證，傳入的引數中一定包含某些關鍵字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        結果：
            1
            2
            (3, 4, 5)
            1
            3
            {'c': 4, 'd': 5}

此乃重點知識！！！

五練習題

1、寫函式，，使用者傳入修改的檔名，與要修改的內容，執行函式，完成批了修改操作
2、寫函式，計算傳入字串中【數字】、【字母】、【空格] 以及【其他】的個數

3、寫函式，判斷使用者傳入的物件（字串、列表、元組）長度是否大於5。

4、寫函式，檢查傳入列表的長度，如果大於2，那麼僅保留前兩個長度的內容，並將新內容返回給呼叫者。

5、寫函式，檢查獲取傳入列表或元組物件的所有奇數位索引對應的元素，並將其作為新列表返回給呼叫者。

6、寫函式，檢查字典的每一個value的長度,如果大於2，那麼僅保留前兩個長度的內容，並將新內容返回給呼叫者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字串或列表

#題目一
def modify_file(filename,old,new):
    import os
    with open(filename,'r',encoding='utf-8') as read_f,\
        open('.bak.swap','w',encoding='utf-8') as write_f:
        for line in read_f:
            if old in line:
                line=line.replace(old,new)
            write_f.write(line)
    os.remove(filename)
    os.rename('.bak.swap',filename)

modify_file('/Users/jieli/PycharmProjects/爬蟲/a.txt','alex','SB')

#題目二
def check_str(msg):
    res={
        'num':0,
        'string':0,
        'space':0,
        'other':0,
    }
    for s in msg:
        if s.isdigit():
            res['num']+=1
        elif s.isalpha():
            res['string']+=1
        elif s.isspace():
            res['space']+=1
        else:
            res['other']+=1
    return res

res=check_str('hello name:aSB passowrd:alex3714')
print(res)


#題目三：略

#題目四
def func1(seq):
    if len(seq) > 2:
        seq=seq[0:2]
    return seq
print(func1([1,2,3,4]))


#題目五
def func2(seq):
    return seq[::2]
print(func2([1,2,3,4,5,6,7]))


#題目六
def func3(dic):
    d={}
    for k,v in dic.items():
        if len(v) > 2:
            d[k]=v[0:2]
    return d
print(func3({'k1':'abcdef','k2':[1,2,3,4],'k3':('a','b','c')}))