1. 程式人生 > >Python進階技巧匯總01

Python進階技巧匯總01

chat 關註 port 字符 申請 mon 表示 lac 復雜

總結自原創: Leoxin 菜鳥學Python

原文地址:強烈推薦|麻煩剛關註2699名小夥伴一定要看,信息量太大

1 字符串

  • 字符串的format格式一般有兩種操作:

(1)使用%操作符

name = "zhang"
age =20
print("Your name is %s,age is %d %(name,age)")

(2)使用.format

name = "zhang"
age =20
print("Your name is {0},age is {1}.format(name,age)")
# .format的用法比較靈活,參數的順序和格式化的順序不必完全相同,推薦使用
  • 常用的文本處理7招

(1)字符串的連接和合並

# 簡單連接用+號
new_str = str1 + str2
# 合並用join方法
url = ["www","python","org"]
print(".".join(url))
>>>www.python.org

(2)字符串的切片和相乘

# 相乘,類似數學計算
line=‘*‘*30
print(line)
>>>******************************
# 切片,類似列表操作
str = "Monday"
str[0:3]
>>>Mon

==(3)字符串的分割==

# 簡單分割用split(),但不支持多個分割
phone = 400-800-123
print(phone.split("-"))
>>>["400","800","123"]

# 復雜分割用正則表達式和r表示不轉義
line = "hello world;  python,  I  ,like,     it"
# 處理這種分隔符不一致的字符串,操作如下
import re
print(re.split(r‘[;,s]\s*‘,line))
>>>["hello world","python","I","like","it"]

(4)字符串的開頭和結尾處理

# 查一個文件的名字是以什麽開頭或者結尾的
file_name = ‘trace.h‘
print(file_name.endswith(‘h‘))
>>>True
print(file_name.startswith(‘trace‘))
>>>True

==(5)字符串的查找和匹配==

# 一般查找,返回子字符串所在位置的索引,若找不到返回-1
title = "what the fox say? ding ding ding~"
print(title.find("fox"))
>>>10

# 復雜的匹配,又要用到正則表達式
mydate = "19/12/2018"
import re
if re.match(r"\d+/\d+/\d+",mydate):
    print("ok,match")
else:
    print("ok,not match")
>>>ok,match

==(6)字符串的替換==

# 普通替換用replace()
text = "i like running"
print(text.replace("running","swimming"))
>>>i like swimming

# 復雜的替換用re模塊的sub函數
student = "boy 103 , girl 105"
print(re.sub(r‘\d+‘,‘100‘,student))
>>>boy 100 ,girl 100

==(7)字符串中去掉一些字符==

# 去掉文本兩側的空格
line = "  i like you   "
print(line.strip())
>>>i like you

# 復雜的文本清理,用str.translate,先構建一個轉換表,table是一個翻譯表,表示把‘t‘‘o‘轉成大寫的‘T‘ ‘O‘,然後在old_str裏面去掉‘12345‘,然後剩下的字符串再經過table翻譯
import string
instr = "to"
outstr = "TO"
table = string.maketrans(instr,outstr)
old_str = "Hello world,welcome to use Python. 123456"
new_str = old_str.translate(table,"12345")
print(new_str)
>>>Hello world,welcome to use Python. 6

2 列表、字典

  • 列表

(1)支持*,+操作

list1 = [1,2,3]
list2 = [10,20,30]
list3 = list1 + list2
print(list3)
>>>[1, 2, 3, 10, 20, 30]

list4 = [‘a‘,‘b‘,‘c‘]
list5 = list4 * 3
print(list5)
>>>[‘a‘, ‘b‘, ‘c‘, ‘a‘, ‘b‘, ‘c‘, ‘a‘, ‘b‘, ‘c‘]

(2)擴展,用內置函數extend()

list = [1,2,3]
b = [4,5,6]
list.extend(b)
print(list)
>>>[1, 2, 3, 4, 5, 6]
# extend()與+的區別在於,前者直接修改列表,後者返回一個新的列表

(3)查找列表中某個元素的索引,用內置函數index()

list = ["i","am","a","dog"]
print(list.index(‘a‘))
>>>3

(4)統計某個元素在列表的次數,用內置函數count()

list=[‘to‘,‘do‘,‘or‘,‘not‘,‘to‘,‘do‘]
print(list.count(‘to‘))
>>>2

(5)讓列表中的元素存在就返回,不存在就返回默認值

def list_get(list,i,value=None):
    # 列表下標的負數範圍是[-len,len)
    if -len(list) <= i <len(list):
        return list[i]
    else:
        return value
print(list_get([1,2,3],5,10))
>>>10

(6)循環訪問序列中的元素和索引

# 將元素10改為3
list = [1,2,10,4]
for index ,item in enumerate(list): 
    # print(list(enumerate(list)))  >>>[(0, 1), (1, 2), (2, 10), (3, 4)]
    if item > 9:
        list[index] = 3
  • 字典

==(1)根據key或value排序,用內置函數sorted()==

my_dict={"cc":100,"aa":200,"bb":10}
# 按照key排序
print(sorted(my_dict.items(),key=lambda x:x[0]))
>>>[(‘aa‘, 200), (‘bb‘, 10), (‘cc‘, 100)]
# 表示按照value排序
print(sorted(my_dict.items(),key=lambda x:x[1]))
>>>[(‘bb‘, 10), (‘cc‘, 100), (‘aa‘, 200)]
# 註意,my_dict本身順序沒有變,排序返回了一個新的字典

(2)讓字典一開始就按添加順序進行有序排列(比如讀取CSV文件),用collection模塊的OrderedDict()函數

from collections import OrderedDict
orderDict = OrderedDict()
orderDict[‘a‘] = 1
orderDict[‘b‘] = 2
orderDict[‘c‘] = 3
print(orderDict)
>>>OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
# OrderedDict()雖然是好東西,但是它內部維護了一個雙向鏈表,若數據量很大的話,會非常消耗內存

(3)字典的取值

# 一般取值用dict[key],但當取值不在時會引起異常,不符合代碼健壯的要求
dic = {"a":10,"b":20,"c":30}
print(dic.get("d"))
# 當鍵值不存在時,會返回None,而不是異常
# 另外一個用法是dict.get(key,somethingelse)
print(dic.get("d","Not found"))
>>>Not found
# 建議盡量用dict.get()來代替dict[key]

(4)字典中提取部分子集、大寫合並、鍵值互換,用字典推導式

dic_01 = {"a":80,"b":91,"c":100,"d":70}
# 提取分數超過90分的信息,形成一個新的字典
good_score = {name:score for name,score in dic.items() if score>90}

# 大小寫key合並
dic_02 = {‘a‘: 10, ‘b‘: 34, ‘A‘: 7, ‘Z‘: 3}
new_dic = {
    k.lower(): dic_02.get(k.lower(), 0) + dic_02.get(k.upper(), 0)
    for k in dic_02.keys()
    if k.lower() in [‘a‘,‘b‘]
}
print(new_dic)
# Output: {‘a‘: 17, ‘b‘: 34}

# 以字符串為鍵,其索引為值,建立字典
strings = ["jim","paul","peter","jessca"]
dic_01 = {key:value for value,key in enumerate(strings)}
# 以字符串為鍵,其長度為值,建立
dic_02 = {k:len(k) for k in strings}
print(dic_01)
print(dic_02)

# Output
{‘jim‘: 0, ‘paul‘: 1, ‘peter‘: 2, ‘jessca‘: 3}
{‘jim‘: 3, ‘paul‘: 4, ‘peter‘: 5, ‘jessca‘: 6}

# 鍵值互換
dict = {‘a‘: 10, ‘b‘: 34}
new_dict = {v:k for k, v in dict.items()}
print(new_dict)
# Output: {10: ‘a‘, 34: ‘b‘}

# 或者,利用內置函數zip()進行翻轉處理
new_dict = zip(dict.values(),dict.keys())
print(list(new_dict))
# Output: [(25.6, ‘a‘), (32.3, ‘b‘), (299.5, ‘c‘), (18.6, ‘d‘)]
# 註意,此處的new_dict返回的是一個對象,不能直接打印

# 最後,若碰到數據量較大的字典,最好用Python標準庫裏的itertools模塊(非常實用)
from itertools import izip
new_dict = izip(dict.values(),dict.keys())
print(invert_stocks2)

(5)字典的計算

# 假設字典中記錄了股票價格,希望獲得最高和最低股價的股票
stocks = {‘a‘:25.6,‘b‘:32.3,‘c‘:299.5,‘d‘:18.6}
print(min(stocks.values))
print(max(stocks.values))

(6)字典的缺省值

aDict={}.fromkeys((‘aa‘,‘bb‘,‘cc‘),100)
for k,v in aDict.items():
   print(k,v)
>>>
aa 100
cc 100
bb 100

(7)字典的更新

aInfo={‘Wang‘:3000,‘NiuYun‘:2000,‘Lin‘:4500,‘Tianqi‘:8000}
bInfo={‘Wang‘:4000,‘NiuYun‘:8000,‘Ming‘:3300}
aInfo.update(bInfo)
print(aInfo)
>>>{‘Wang‘: 4000, ‘Tianqi‘: 8000, ‘Lin‘: 4500, ‘NiuYun‘: 8000, ‘Ming‘: 3300}

3、新手坑

  • Python3中==is的區別:is判斷兩個對象是否為同一對象,是通過id來判斷的;當兩個基本類型數據(或元組)內容相同時,id會相同,但並不代表a會隨b的改變而改變,==判斷兩個對象的內容是否相同, 是通過調用eq()來判斷的
  • 連接字符串特別是大規模的字符串,最好用join而不是+
# 用+連接字符串:
str1,str2,str3 = ‘test‘,‘string‘,‘connection‘
print(str1+str2+str3)
# 用join連接字符串
str1,str2,str3 = ‘test‘,‘string‘,‘connection‘
print(‘‘.join([str1,str2,str3]))
>>>teststringconnection
# Python中的字符串與其他的語言有一點不同,它是不可變對象,一旦創建不能改變,而這個特性直接會影響到Python中字符串連接的效率。因為若要連接字符串:S1+S2+S3+....+SN,由於字符串是不可變的對象,執行一次就要申請一塊新的內存,這樣的話在N個字符串連接的過程中,會產生N-1個中間結果,每產生一個中間結果就要申請一次內存,這樣會嚴重影響執行效率。而join不一樣,它是一次性申請總的內存,然後把字符串裏面的每一個元素復制到內存中去,所以join會快很多.
  • 不要在for和while循環後面寫else塊
for i in range(3):
    print(‘Loop %d‘%i)
else:
    print(‘Else block‘)
>>>Loop 0
>>>Loop 1
>>>Loop 2
>>>Else block
# 以上的else塊會在整個循環執行完之後立刻運行。剛接觸Python的程序員可能會把for/else結構中的else 塊理解為:如果循環沒有正常執行完,那就執行else塊,實際上剛好相反。在循環裏用break語句提前跳出,會導致程序不執行else塊。

參考文章:

1、正則表達式 - 教程

原文地址:http://www.runoob.com/regexp/regexp-tutorial.html

Python進階技巧匯總01