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