Python隨筆——中級篇

前言

在講解了Python中的一些基礎知識後，這篇文章主要通過一些編程案例來學會熟練編寫python代碼。話不多說，來看代碼~

判斷字符串是否爲數字

判斷list中的每個值是否爲數字

'''
@author xjh 2020.3.15
'''
def is_number(s):
    try:    #如果能運行float(s)語句，返回True (s爲爲浮點數)
        float(s)
        return True
    except ValueError: # ValueError爲Python的一種標準異常，表示"傳入無效的參數"
        pass # pass作爲佔位符，不做任何處理
    try:
        import unicodedata #處理ASCI碼的包
        for i in s:
            unicodedata.numeric(i) #把一個表示數字的字符串轉換爲浮點數返回的函數
            return True
    except (TypeError,ValueError):
        pass
    return False

list=['acn',123,123.45,'ACDBN']
for i in list:
    print(i,": ",is_number(i))

結果：

acn :  False
123 :  True
123.45 :  True
ACDBN :  False

斐波那契序列

'''
輸出包含n個數的斐波那契數列
@author xjh 2020.2.15
'''
def fib1(n): #循環解決
    f1=0; f2=1;
    if n<=0:
        print("請輸入一個正數")
    elif n==1:
        print('斐波拉契序列: %d'%f1)
    else:
        print('斐波拉契序列: ',end=' ')
        print(f1,f2,end=' ')
        for i in range(1,n-1):
            f1,f2=f2,f1+f2
            print(f2,end=' ')

def fib2(n):    #遞歸
    if n <= 1:
        return n
    else:
        return fib2(n - 1) + fib2(n - 2)


n=int(input('please input a number: '))
fib1(n)
print()
# 檢查輸入的數字是否正確
if n <= 0:
   print("輸入正數")
else:
   print("斐波那契數列:", end=' ')
   for i in range(n):
       print(fib2(i), end=' ')

結果：

please input a number: 10
斐波拉契序列:  0 1 1 2 3 5 8 13 21 34 
斐波那契數列: 0 1 1 2 3 5 8 13 21 34 

List常用操作

這裏菜鳥教程的總結寫的不錯，借來參考。源地址：Python list 常用操作

1.list 定義

>>> li = ["a", "b", "mpilgrim", "z", "example"]
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1]         
'b'

2.list 負數索引

>>> li 
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[-1] 
'example'
>>> li[-3] 
'mpilgrim'
>>> li 
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1:3]  
['b', 'mpilgrim'] 
>>> li[1:-1] 
['b', 'mpilgrim', 'z'] 
>>> li[0:3]  
['a', 'b', 'mpilgrim'] 

3.list 增加元素

>>> li 
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")
>>> li 
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.insert(2, "new")
>>> li 
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"]) 
>>> li 
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

4.list 搜索

>>> li 
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.index("example")
5
>>> li.index("new")
2
>>> li.index("c")
Traceback (innermost last):
 File "<interactive input>", line 1, in ?
ValueError: list.index(x): x not in list
>>> "c" in li
False

5.list 刪除元素

>>> li 
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.remove("z")  
>>> li 
['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.remove("new")    # 刪除首次出現的一個值
>>> li 
['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']    # 第二個 'new' 未刪除
>>> li.remove("c")     #list 中沒有找到值, Python 會引發一個異常
Traceback (innermost last): 
 File "<interactive input>", line 1, in ? 
ValueError: list.remove(x): x not in list
>>> li.pop()      # pop 會做兩件事: 刪除 list 的最後一個元素, 然後返回刪除元素的值。
'elements'
>>> li 
['a', 'b', 'mpilgrim', 'example', 'new', 'two']

6.list 運算符

>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['example', 'new']
>>> li 
['a', 'b', 'mpilgrim', 'example', 'new']
>>> li += ['two']         
>>> li 
['a', 'b', 'mpilgrim', 'example', 'new', 'two']
>>> li = [1, 2] * 3
>>> li 
[1, 2, 1, 2, 1, 2] 

7.使用join鏈接list成爲字符串

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'
join 只能用於元素是字符串的 list; 它不進行任何的類型強制轉換。連接一個存在一個或多個非字符串元素的 list 將引發一個異常。

8.list 分割字符串

>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s 
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")   
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1) 
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']
split 與 join 正好相反, 它將一個字符串分割成多元素 list。

注意, 分隔符 (";") 被完全去掉了, 它沒有在返回的 list 中的任意元素中出現。

split 接受一個可選的第二個參數, 它是要分割的次數。

9.list 的映射解析

>>> li = [1, 9, 8, 4] 
>>> [elem*2 for elem in li]    
[2, 18, 16, 8] 
>>> li
[1, 9, 8, 4] 
>>> li = [elem*2 for elem in li] 
>>> li 
[2, 18, 16, 8] 

10.dictionary 中的解析

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params.keys()
dict_keys(['server', 'database', 'uid', 'pwd'])
>>> params.values()
dict_values(['mpilgrim', 'master', 'sa', 'secret'])
>>> params.items()
dict_items([('server', 'mpilgrim'), ('database', 'master'), ('uid', 'sa'), ('pwd', 'secret')])
>>> [k for k, v in params.items()]
['server', 'database', 'uid', 'pwd']
>>> [v for k, v in params.items()]
['mpilgrim', 'master', 'sa', 'secret']
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'database=master', 'uid=sa', 'pwd=secret']

11.list 過濾

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1]
['a', 'mpilgrim', 'foo', 'c']

數組翻轉指定個數的元素

'''
數組翻轉指定個數的元素
@author xjh 2020.3.15
'''
#方法1：數組向前移動
def reverse1(arr,d,n):
    for i in range(d):
        move(arr,n) #關鍵在於數組中的元素向前移動了d次
def move(arr,n):
    t=arr[0]
    for i in range(n-1):
        arr[i]=arr[i+1]
    arr[n-1]=t

#方法2：方法1的簡化版
def reverse2(arr,d,n):
    for i in range(d):
        arr.append(arr.pop(0))

# 方法3： 利用列表截取與拼接來翻轉
def reverse3(arr,d,n):
    res=arr[d:]+arr[:d]
    return res
arr=[1,2,3,4,5,6,7]
print('翻轉前： ',arr)
print('reverse3: ',reverse3(arr,2,len(arr)))
reverse2(arr,2,len(arr))
print('reverse2: ',arr)

結果：

翻轉前：  [1, 2, 3, 4, 5, 6, 7]
reverse3:  [3, 4, 5, 6, 7, 1, 2]
reverse2:  [3, 4, 5, 6, 7, 1, 2]

翻轉列表

'''
翻轉列表
@auhor xjh 2020.3.15
'''
# 方法1： 從後向前遍歷 賦值給新的數組
def reverse1(arr):
    res=arr[::-1] #步長 -1表示逆序遍歷  等同於arr[-1::-1]
    return res
#方法2： 直接調用reverse方法
def reverse2(arr):
    arr.reverse()
    return arr

arr=[1,2,3,4,5,6,7]
print(reverse2(arr))

結果：

[7, 6, 5, 4, 3, 2, 1]

翻轉字符串

'''
@author xjh 2020.3.15
'''
#原理 同反轉列表
str='China'
print('reverse result: ',str[::-1])
str2='Changsha'
print(''.join(reversed(str2)))

結果：

reverse result:  anihC
ahsgnahC

複製列表

'''
複製列表
@author xjh 2020.3.15
'''
#方法1
def clone_1(arr):
    res=arr[:] #也可用res=list(arr)
    return res
#方法2 使用extend方法
def clone_2(arr):
    res=[]
    res.extend(arr)
    return res

arr=[1,2,3,4,5]
print('arr: ',arr)
print('copy result: ',clone_2(arr))

結果：

arr:  [1, 2, 3, 4, 5]
copy result:  [1, 2, 3, 4, 5]

字典中移除特定的鍵值對

'''
Python 移除字典點鍵值(key/value)對
使用del pop item關鍵字
@author xjh 2020.3.15
'''

if __name__=='__main__':
    dict = {"Alibaba": 1, "Google": 2, "Taobao": 3, "Zhihu": 4,"Tencent":5,"ByteDance":6}

    # 輸出原始的字典
    print("字典移除前 : " + str(dict))

    # 使用 del 移除 Zhihu
    del dict['Zhihu']
    # 輸出移除後的字典
    print("字典移除Zhihu後 : " + str(dict))

    #使用pop移除
    dict.pop('Taobao')
    print("字典移除Taobao後 : " + str(dict))

    #item遍歷賦值給新的字典
    new_dict={k:v for k,v in dict.items() if k!='Tencent' }
    print(str(new_dict))

結果：

字典移除前 : {'Alibaba': 1, 'Tencent': 5, 'Google': 2, 'Taobao': 3, 'ByteDance': 6, 'Zhihu': 4}
字典移除Zhihu後 : {'Alibaba': 1, 'Tencent': 5, 'Google': 2, 'Taobao': 3, 'ByteDance': 6}
字典移除Taobao後 : {'Alibaba': 1, 'Tencent': 5, 'Google': 2, 'ByteDance': 6}
{'Alibaba': 1, 'Google': 2, 'ByteDance': 6}

按鍵(key)或值(value)對字典進行排序

'''
Python 按鍵(key)或值(value)對字典進行排序
@author xjh 2020.3.15
'''
# 按key排序
def sort_key(dict):
    for i in sorted(dict): # sorted(key_value) 返回一個迭代器
        print((i,dict[i]),end=' ')
#按value排序
def sort_value(dict):
    print(sorted(dict.items(), key=lambda kv: (kv[1], kv[0])))

if __name__=='__main__':
    #聲明字典
    dict={}
    # 初始化
    dict[2] = 56
    dict[1] = 2
    dict[5] = 12
    dict[4] = 24
    dict[6] = 18
    dict[3] = 323

    print('原始字典： ',dict)
    print('按Key排序：',end=' ')
    sort_key(dict)
    print()
    print('按Value排序：', end=' ')
    sort_value(dict)
    print('\r')
    # 字典列表排序
    lis = [{"name": "Taobao", "age": 100},
           {"name": "Runoob", "age": 7},
           {"name": "Google", "age": 100},
           {"name": "Wiki", "age": 200}]
    print('原始列表： ')
    print(lis)

    # 通過 age 升序排序
    print("列表通過 age 升序排序: ")
    print(sorted(lis, key=lambda i: i['age']))

    # 先按 age 排序，再按 name 排序
    print("列表通過 age 和 name 排序: ")
    print(sorted(lis, key=lambda i: (i['age'], i['name'])))

    # 按 age 降序排序
    print("列表通過 age 降序排序: ")
    print(sorted(lis, key=lambda i: i['age'], reverse=True))

結果：

原始字典：  {1: 2, 2: 56, 3: 323, 4: 24, 5: 12, 6: 18}
按Key排序： (1, 2) (2, 56) (3, 323) (4, 24) (5, 12) (6, 18) 
按Value排序： [(1, 2), (5, 12), (6, 18), (4, 24), (2, 56), (3, 323)]

原始列表： 
[{'name': 'Taobao', 'age': 100}, {'name': 'Runoob', 'age': 7}, {'name': 'Google', 'age': 100}, {'name': 'Wiki', 'age': 200}]
列表通過 age 升序排序: 
[{'name': 'Runoob', 'age': 7}, {'name': 'Taobao', 'age': 100}, {'name': 'Google', 'age': 100}, {'name': 'Wiki', 'age': 200}]
列表通過 age 和 name 排序: 
[{'name': 'Runoob', 'age': 7}, {'name': 'Google', 'age': 100}, {'name': 'Taobao', 'age': 100}, {'name': 'Wiki', 'age': 200}]
列表通過 age 降序排序: 
[{'name': 'Wiki', 'age': 200}, {'name': 'Taobao', 'age': 100}, {'name': 'Google', 'age': 100}, {'name': 'Runoob', 'age': 7}]

合併字典

'''
Python 合併字典
1. 使用 update() 方法，第二個參數合併第一個參數
2. 使用 **，函數將參數以字典的形式導入
@author xjh 2020.3.15
'''
def Merge1(dict1,dict2):
    dict2.update(dict1)
    print(str(dict2))

def Merge2(dict1,dict2):
    res={**dict1,**dict2}
    print(res)

if __name__=='__main__':
    # 兩個字典
    dict1 = {'a': 10, 'b': 8}
    dict2 = {'d': 6, 'c': 4}
    Merge1(dict1,dict2)
    Merge2(dict1,dict2)

結果：

{'d': 6, 'c': 4, 'a': 10, 'b': 8}
{'d': 6, 'c': 4, 'a': 10, 'b': 8}

二分查找

二分查找的講述在之前的博客中有詳細描述過，可參考：二分查找算法詳解及對應leetcode習題詳解 java實現

'''
Python實現二分查找
@author xjh 2020.3.15
'''
def bin_search(data_list, val):
    low = 0                         # 最小數下標
    high = len(data_list) - 1       # 最大數下標
    while low <= high:
        mid = (low + high) // 2     # 中間數下標
        if data_list[mid] == val:   # 如果中間數下標等於val, 返回
            return mid
        elif data_list[mid] > val:  # 如果val在中間數左邊, 移動high下標
            high = mid - 1
        else:                       # 如果val在中間數右邊, 移動low下標
            low = mid + 1
    return # val不存在, 返回None

res = bin_search(list(range(1, 10)), 3)
print(res)

結果：2

快排

快排和歸併作爲兩種最常用的比較排序算法，時間複雜度爲O(nlogn)。算法描述和相應的Java實現，可參考：排序2-時間複雜度爲O(nlogn)的算法 歸併排序 快排

'''
@author xjh 2020.3.15
'''
def quickSort(arr,low ,high):
    if(low>=high):
        return
    p=partition(arr,low,high)
    quickSort(arr,low,p)
    quickSort(arr,p+1,high)

def partition(arr,low,high):
    pivot=arr[low]
    while(low<high):
        while(low<high and arr[high]>=pivot):
            high-=1
        arr[low]=arr[high]
        while(low<high and arr[low]<=pivot):
            low+=1
        arr[high]=arr[low]
    arr[low]=pivot
    return low


if __name__=='__main__':
    arr = [10, 7, 8, 9, 1, 5]
    n = len(arr)
    quickSort(arr, 0, n - 1)
    print("排序後的數組:")
    for i in range(n):
        print("%d" % arr[i],end=' ')

結果：

排序後的數組:
1 5 7 8 9 10 

歸併排序

'''
歸併排序（分治）
@author xjh 2020.3.15
'''
def merge_sort(arr):
    if len(arr)<=1:
        return arr
    mid=int(len(arr)/2)
    left=merge_sort(arr[:mid])
    right=merge_sort(arr[mid:])
    res=[]
    while left and right:
        res.append(left.pop(0) if left[0]<=right[0] else right.pop(0))
    res.extend(right if right else left)
    return res

if __name__=='__main__':
    arr = [10, 7, 8, 9, 1, 5]
    print(merge_sort(arr))

結果：[1, 5, 7, 8, 9, 10]

堆排序

'''
@author xjh 2020.3.15
'''
def heapify(arr,n,i):
    max=i
    left=2*i+1
    right=2*i+2
    if left<n and arr[max]<arr[left]:
        max=left
    if right<n and arr[max]<arr[right]:
        max=right
    if max!=i:
        arr[i],arr[max]=arr[max],arr[i]
        heapify(arr,n,max)

def heapSort(arr):
    n=len(arr)
    #建立一個大根堆
    for i in range(n,-1,-1): #元素下標逆序遍歷， i=6 5 4 3 2 1 0
        heapify(arr,n,i)

    #交換元素
    for i in range(n-1,0,-1):
        arr[i],arr[0]=arr[0],arr[i] #交換
        heapify(arr,i,0)

if __name__=='__main__':
    arr = [12, 11, 13, 5, 6, 7]
    print('排序前：')
    for i in range(len(arr)):
        print(arr[i],end=' ')
    print()

    heapSort(arr)
    n = len(arr)
    # for i in range(n, -1, -1):
    #     print(i,end=' ') #輸出 6 5 4 3 2 1 0
    print("排序後")
    for i in range(n):
        print("%d" % arr[i],end=' ')

結果：

排序前：
12 11 13 5 6 7 
排序後
5 6 7 11 12 13