內置函數，匿名函數，正則表達式，經常使用模塊

時間 2019-11-11

標籤內置函數匿名正則表達式經常使用模塊欄目正則表達式简体版

原文原文鏈接

匿名函數：python

1.函數沒有名字正則表達式

2.函數體自帶return,因此不能在lambda中用returnshell

lambda x,y,z=1:x+y+z 等同於 def func(x,y,z=1):return x+y+zjson

print(func) 和print(lambda x,y,z=1:x+y+z) 同樣都是打印的內存地址windows

匿名函數的應用場景：bash

應用於一次性的場景，臨時使用網絡

內置函數：dom

print(abs(-1))  # 取絕對值
# 1

print(all([1,2,'a',None]))  # all()至關於對可迭代對象進行for循環，取出一個值判斷它的bool值，若是一個爲假，則爲假，直到全爲真，表達式的結果才爲真
# False
print(all([]))
# True

print(any([1,2,'a',None]))  # 與all()相反，any()只要可迭代對象有一個爲真，則表達式的結果爲真
# True
print(any([]))
# False

bool值爲假的狀況，None,空，0，False

print(any(['  ',None,False]))  # '  ' 不爲空
# Ture

print(any(['',None,False]))   # '' 爲空
# False

print(bin(10))  # 十進制轉二進制
print(oct(10))  # 十進制轉八進制
print(hex(10)) # 十進制轉十六進制

bytes()
# python3 字符串自己就是以unicode形式存儲的
unicode---->encode---->bytes
便可獲得bytes類型

print('hello'.encode('utf-8'))
# b'hello'
print(bytes('hello',encoding='utf-8'))
# b'hello'

callable   # 檢查是否可被調用的，就是名稱加括號後可否被執行
print(callable(bytes))  
# True
print(callable(abs))
# True

print(chr(65))
# A
print(ord('#'))
# 35

#工廠函數
x = 1 # x = int(1)
x = int(2)

complex
float
str
list
tuple
dict
set
frozenset  # s1 = frozenset({1，2，3，4})  # print(type(s1))

# dir   查看能夠調用的屬性
import sys
print(dir(sys))

print(divmod(10,3))
# (3,1)      (商,餘數)

#enumerate
l=['a','b','c']
res=enumerate(l)   # enumerate是迭代器
print(res)      # <enumerate object at 0x000001DAA438>  打印的是enumerte的對象
for i in res:
    print(i)

#
(0,'a')
(1,'b')
(2,'c')
#enumerate就是給每一個元素前面加一個索引

#globals,locals  查看全局做用域（內置和全局）（經過字典形式展現出來）和局部做用域

#hash 校驗字符串
print(hash('abcdefg123'))
print(hash('abcdefg123'))
# 6142847409289919031
# 6142847409289919031

#id      是python解釋器實現的功能，只是反映了變量在內存的地址，但並非真實的內存地址
x=1
print(id(x))

#isinstance
x=1
print(type(x) is int)
print(isinstance(x,int))  # x是int的一個實例

print(pow(3,2))    # 3**2
# 9
print(pow(3,2,2))  # 3**2%2
# 1

#reversed
l=[1,'a',2,'c']
print(list(reversed(l)))
# ['c',2,'a',1]

#slice切片
l=[1,2,3,4,5,6]
print(l[0:4:2])   # 已經寫死
#[1,3]

s=slice(0,4,2)    # 能夠應用於不少列表
print(l[s])
#[1,3]

#sorted  排序
l=[1,10,4,3,-1]
print(sorted(l))
# [-1,1,3,4,10]
print(sorted(l,reverse=True))
# [10,4,3,1,-1]

#sum
print(sum(i for i in range(10)))
# 45

#vars
import m1    # m1.py
print(vars(m1) == m1.__dict__)

#zip
s='hello'
l=[1,2,3,4,5]
res=zip(s,l)   # zip對象，res是迭代器
print(list(res))
# [('h',1),('e',2),('l',3),('l',4),('o',5)]

#__import__  根據字符串導入模塊
sys=__import__('sys')
print(sys)
-----------------------------------------
import sys   # sys 這裏並非字符串，是一個名字
1.執行模塊裏面的內容
2.產生名稱空間
3.在當前位置拿到名字sys

如今有一個需求是根據用戶輸入的字符串來導入模塊
m_name = input('module>>: ')
if m_name == 'sys':
    m=__import__(m_name)
    print(m)   # 獲得內置模塊
    print(m.path)

內置函數的補充ide

salaries={
'tom':3000,
'jerry':10000000,
'peter':10000,
'brian':2000
}
#取出工資最高的人名
print(list(zip(salaries.values(),salaries,keys())))
#[(1000, 'tom'),(10000000, 'jerry'),(10000, 'peter'),(2000, 'brian')]
print(max(zip(salaries.values(),salaries,keys())))
#(10000000, 'jerry')
print(max(zip(salaries.values(),salaries,keys()))[1])

# 簡便方法
print(max(salaries,key=lambda name:salaries[name]))  # max for循環salaries,獲得名字，傳給lambda的name,而後根據name獲得薪資，這個薪資就看成max的key
# jerry

def get_value(name):   # 經過key獲取value    
    return salaries[name]

print(max(salaries,key=get_value))   #key指定的是函數的內存地址
# jerry
此方法，函數一直佔據內存空間，使用lambda會更好

salaries={
'tom':3000,
'jerry':10000000,
'peter':10000,
'brian':2000
}

def get_value(name):   # 經過key獲取value    
    return salaries[name]

print(sorted(salaries,key=get_value,reverse=True))

#map
names=['tom','jerry','peter','brian','json']

res=map(lambda x:x+'_hello',names)
# map for循環names,取出一個值賦給前面的lambda
print(list(res))
print(list(res))
print(list(res))
#
['tom_hello','jerry_hello','peter_hello','brian_hello','json_hello']
[]   # res是一個迭代器，只能由前日後走，第一次運行就已經走完了，後面沒有值了
[]

res=map(lambda x:x if x == 'tom' else x+'hello',names)
print(list(res))
# ['tom','jerry_hello','peter_hello','brian_hello','json_hello']

#reduce
from functools import reduce

print(reduce(lambda x,y:x+y,range(101)))   # 沒有指定初始值，reduce會先for循環，獲得的第一個值做爲初始值，再for循環獲得下一個值，傳給前面的函數
#5050

print(reduce(lambda x,y:x+y,range(101),100))   #指定初始值爲100,把初始值做爲第一個值，還有for循環獲得一個值，這兩個值傳給前面的函數（0和100））
#5150

#filter
names=['tom_hello','jerry_hello','peter_hello','json_hello','brian']
filter(lambda print(list(name:name.endswith('hello'),names)))
#['tom_hello','jerry_hello','peter_hello','json_hello']

eval函數

cmd='print(x)'

x=1

# eval能夠本身指定名稱空間，名稱空間有兩種，一個全局一個局部，全都是字典形式

#eval(cmd,{},{})  
#第一個{}是全局做用域，第二個{}是局部做用域，找的時候先從局部做用域中找，
找不到再去第一個{}全局做用域查找

eval(cmd,{},{'x':1000})  
# 1000
eval(cmd,{'x':0},{'x':1000}) 
# 1000   先從局部找，因此仍是1000
eval(cmd,{'x':0},{'y':1000})
# 0   找全局名稱空間中的變量

re模塊

import re
#\w 匹配字母數字下劃線
print(re.findall('\w','hello_ | tom 123'))
# ['h', 'e', 'l', 'l', 'o', '_', 't', 'o', 'm', '1', '2', '3']

#\W 非字母數字下劃線
print(re.findall('\W','hello_ | tom 123'))
#[' ', '|', ' ', ' ']

#\s 匹配任意空白字符，等價於[\t\n\r] #\r回到行首
print(re.findall('\s','hello_ | tom 123 \n \t'))
#[' ', ' ', ' ', ' ', '\n', ' ', '\t']

#\S匹配任意非空字符
print(re.findall('\S','hello_ | tom 123 \n \t'))
# ['h', 'e', 'l', 'l', 'o', '_', '|', 't', 'o', 'm', '1', '2', '3']

#\d 匹配任意數字，等價於[0-9]
print(re.findall('\d','hello_ | tom 123 \n \t'))
#['1', '2', '3']

#\D 匹配任意非數字
print(re.findall('\D','hello_ | tom 123 \n \t'))
# ['h', 'e', 'l', 'l', 'o', '_', ' ', '|', ' ', 't', 'o', 'm', ' ', ' ', '\n', ' ', '\t']

#^匹配字符串開頭
print(re.findall('^he','hello_ | hello h tom 123 \n \t'))
#['he']

#$ 匹配字符串結尾
print(re.findall('123$','hello_ | hello h tom 123 \n \t123'))
#['123']

# . 匹配任意一個字符,除了\n
print(re.findall('a.c','a a1c a*c a2c abc a c aaaaaac aacc'))
#['a1c', 'a*c', 'a2c', 'abc', 'a c', 'aac', 'aac']

print(re.findall('a.c','a a1c a*c a2c abc a\nc'))
# ['a1c', 'a*c', 'a2c', 'abc']

print(re.findall('a.c','a a1c a*c a2c abc a\nc',re.DOTALL))
print(re.findall('a.c','a a1c a*c a2c abc a\nc',re.S))
# ['a1c', 'a*c', 'a2c', 'abc','a\nc']
# ['a1c', 'a*c', 'a2c', 'abc','a\nc']

# []內部能夠有多個字符，可是自己只能匹配多個字符中的一個
print(re.findall('a[1 23]c','a a1c a*c a2c a c a\nc',re.S))
#['a1c', 'a2c', 'a c']

print(re.findall('a[a-z]c','aac abc aAc a12c a1c a*c a2c a c a\nc',re.S))
#['aac','abc']

print(re.findall('a[a-zA-Z]c','aac abc aAc a12c a1c a*c a2c a c a\nc',re.S))
#['aac','abc','aAc']

print(re.findall('a[+/*-]c','a-c a+c a/c aac abc aAc a12c a1c a*c a2c a c a\nc',re.S))
#['a-c','a+c','a/c','a*c']

# \ 轉義
print(re.findall(r'a\\c','a\c abc'))
#['a\\c']

# ？ 左邊那一個字符有0個或1個
print(re.findall(r'ab?','a ab abb abbb abbbbb bbbbb'))
#['a', 'ab', 'ab', 'ab', 'ab']

print(re.findall('ab?','aab a ab'))
#['a','ab','a','ab']

print(re.findall('ab?','aab a ab'))
#['a', 'ab', 'a', 'ab']

# * 左邊那一個字符有0個或無窮個
print(re.findall('ab*','a ab abb abbb abbbb bbbbbb'))
# ['a', 'ab', 'abb', 'abbb', 'abbbb']

# +左邊那個字符有1個或無窮個
print(re.findall('ab+','a ab abb abbb abbbb bbbbbb'))
# ['ab', 'abb', 'abbb', 'abbbb']

#{n,m} 左邊的字符有n到m次
print(re.findall('ab{3}','a ab abb abbb abbbb bbbbbb'))
# ['abbb', 'abbb']

print(re.findall('ab{2,3}','a ab abb abbb abbbb bbbbbb'))
# ['abb', 'abbb', 'abbb']

print(re.findall('ab{0,}','a ab abb abbb abbbb bbbbbb')) ==>'ab*'
#  ['a', 'ab', 'abb', 'abbb', 'abbbb']

print(re.findall('ab{1,}','a ab abb abbb abbbb bbbbbb'))  ==>'ab+'
#  ['ab', 'abb', 'abbb', 'abbbb']

# .* 匹配全部字符  貪婪匹配

print(re.findall('a.*c','a123c456c'))
# ['a123c456c']

# .*? 非貪婪匹配  --> 推薦使用
print(re.findall('a.*?c','a1c23c456c'))
#['a1c']

# | 或
print(re.findall('company|companies','Too many companies have gone bankrupt, and the next one is my company'))
#['companies','company']

#() 分組,只顯示組裏面的內容

print(re.findall('ab','abababab123'))
#['ab', 'ab', 'ab', 'ab']

print(re.findall('ab+','abababab123'))
# ['ab','ab','ab','ab']

print(re.findall('ab+123','abababab123'))
# ['ab123']

print(re.findall('(ab)','abababab123'))
# ['ab','ab','ab','ab']

print(re.findall('(a)b','abababab123'))
# ['a','a','a','a']

print(re.findall('a(b)','abababab123'))
# ['b','b','b','b']

print(re.findall('(ab)+','abababab123'))
# ['ab']

print(re.findall('(?:ab)+','abababab123'))
# ['abababab']

print(re.findall('(abc)+','abababab123'))
# []      

print(re.findall('(ab)+123','abababab123'))
# ['ab']     最後 ab123中的ab

print(re.findall('(?:ab)+123','abababab123'))
# ['abababab123']

print(re.findall('(ab)+(123)','abababab123'))
# [('ab','123')]

print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

# ['ies','y']

print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

# ['companies','company']

re的其餘方法

#re.search和re.findall的區別是，re.findall會一直找到結尾，re.search只要匹配到一次就再也不繼續往下尋找了

print(re.search('ab','abababab123').group())
# ab  是第一個ab

print(re.search('ab','12asdsadsdf'))
# None   None值的就不能有group()了

print(re.search('ab','123ab456'))
print(re.match('ab','123ab456'))

#<_sre.SRE_Match object; span=(3, 5), match='ab'>
#None

match和search的區別是：match只有在開頭能匹配到時才匹配
search是一直尋找到第一次

print(re.split('b','abcde'))
# ['a','cde']

print(re.split('[ab]','abcde'))
# ['','','cde']

print(re.sub('tom','hello','tom make love tom'))
#hello make love hello

print(re.sub('tom','hello','tom make love tom',1))    只替換一次
#hello make love tom

print(re.subn('tom','hello','tom make love tom tom'))
#('hello make love hello hello', 3)

print(re.sub('(\w+)(\W+)(\w+)(\W+)(\w+)',r'\5\2\3\4\1','tom make love'))
或
print(re.sub('(\w+)( .* )(\w+)',r'\3\2\1','tom make love'))
#love make tom

obj=re.compile('\d{2}') 事先把正則表達式進行編譯

print(obj.search('abc123eeee').group())
print(obj.findall('abc123eeee'))

#12
#['12']
能夠重複使用一個正則表達式

sys模塊

打印進度條

import sys
import time
for i in range(1,10):
    sys.stdout.write('\r%s' %('#'*i))
    sys.stdout.flush()
    time.sleep(0.3)
    
等同於

import sys,time

for i in range(1,100):
    print('\r%s'%('#'*i),file=sys.stdout,flush=True,end='')
    time.sleep(0.5)

print('[%-10s]'%'hello') 打印固定長度，可是已經寫死了

如今把滾動條長度設定爲認爲輸入

width=10
print(('<%%-%ds>'%width)%('hello'))

def progress(percent,width=50):
    if percent >= 100:
        #print('\r[%s] 100%%' %(width*'#'))
        percent=100
    show_str=('[%%-%ds]'%width)%(int(width*percent/100)*'#')
    print('\r%s %d%s' %(show_str,percent),file=sys.stdout,flush=True,end='')

total_size=102141
recv_size=0

while recv_size < total_size:
    time.sleep(0.01)  # 模擬下載的網絡延遲
    recv_size+=1024  #後面網絡部分能夠改成len(conn.recv())
    recv_per=int(100*recv_size/total_size)
    progress(recv_per)

序列化

把對象（變量）從內存中變成可存儲或傳輸的過程稱爲序列化

爲何要序列化
1.持久保存狀態
2.跨平臺數據交互

import json

dic={'name':'tom','age':18}
# print(json.dumps(dic))  # {"name":"tom","age":18}


序列化
with open('a.json','w') as f:
    f.write(json.dumps(dic))

反序列化
with open('a.json','r') as f:
    data=f.read()
    dic=json.loads(data)
    print(dic['name'])

更簡單的方法

序列化:把一個類型按照json的格式轉成json認識的字符串
dic={'name':'tom','age':18}
json.dump(dic,open('b.json','w'))

反序列化：把json格式的字符串按照json格式轉成一個類型
print(json.load(open('b.json','r'))['name'])

pickle序列化

import pickle
dic={'name':'tom','age':18}

# print(pickle.dumps(dic))   # 與json獲得的結果不一樣，pickle獲得的是pickle格式的bytes

with open('d.pkl','wb') as f:
    f.write(pickle.dumps(dic))

with open('d.pkl','rb') as f:
    dic=pickle.loads(f.read())
    print(dic['name'])

dic={'name':'tom','age':18}
pickle.dump(dic,open('e.pkl','wb'))

=======================================
print(pickle.load(open('e.pkl','rb'))['name'])

def func():
    print('from func')
    
import pickle
print(pickle.dumps(func))
或
pickle.dump(open(func,'func.pkl','wb'))

==========================================
pickle的反序列化

import pickle

print(pickle.load('func.pkl','rb'))
#報錯
#func在序列化結束的時候，內存地址已經被清掉了，反序列化的時候
#須要在內存中找一個func的內存地址，但沒法找到
==================================

import pickle

def func():
    print('反序列化的文件')

print(pickle.load('func.pkl','rb'))
#此時的fun指向的函數內存地址已經發生改變

#凡是涉及到內存地址的序列化，反序列化的時候必定要基於內存中事先要存在這個內存地址

os模塊

os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
os.removedirs('dirname1')    若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；至關於shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove()  刪除一個文件
os.rename("oldname","newname")  重命名文件/目錄
os.stat('path/filename')  獲取文件/目錄信息
os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")  運行shell命令，直接顯示
os.environ  獲取系統環境變量
os.path.abspath(path)  返回path規範化的絕對路徑
os.path.split(path)  將path分割成目錄和文件名二元組返回
os.path.dirname(path)  返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path)  返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
os.path.isabs(path)  若是path是絕對路徑，返回True
os.path.isfile(path)  若是path是一個存在的文件，返回True。不然返回False
os.path.isdir(path)  若是path是一個存在的目錄，則返回True。不然返回False
os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
os.path.getatime(path)  返回path所指向的文件或者目錄的最後存取時間
os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小

View Code

在Linux和Mac平臺上，該函數會原樣返回path，在windows平臺上會將路徑中全部字符轉換爲小寫，並將全部斜槓轉換爲飯斜槓。
>>> os.path.normcase('c:/windows\\system32\\')   
'c:\\windows\\system32\\'   
   

規範化路徑，如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')   
'c:\\windows\\Temp'   

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1

View Code

import os

print(os.listdir('.'))  # 列出當前目錄下的文件

res=os.system('dir .')  #顯示當前路徑下的全部文件
print('=====>',res)   #拿不到命令的執行結果

print(os.path.dirname(r'C:\a\b\c\d\a.txt'))  #  C:\a\b\c\d
print(os.path.basename(r'C:\a\b\c\d\a.txt')) # a.txt
print(os.path.split(r'C:\a\b\c\d\a.txt'))  #('C:\\a\\b\\c\\d','a.txt')
print(os.path.join('C:\\','a','b','c','d.txt')) # C:\a\b\c\d.txt
print(os.path.join('C:\\','a','b','D:\\','c','d.txt')) # D:\c\d.txt  
a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
print(os.path.normpath(a))   # \Users\jieli\test1

Django處理路徑的方式

print(os.path.dirname(os.path.dirname(os.path.abspath(__fiel__))))

Openstack處理路徑的方式

BASE_DIR=os.path.normpath(os.path.join(
os.path.abspath(__fiel__),
'..',
'..'
)
)
print(BASE_DIR)

以上兩種處理路徑的方式用哪一種均可以

time模塊

import time

# 3種形式的時間
#1.時間戳,計算機使用  
print(time.time())  #1970年到如今的秒數

#2.格式化的時間
print(time.strftime('%Y-%m-%d %X'))  #年-月-日 時-分-秒

#3.元組形式
print(time.localtime())
print(time.localtime().tm_mon)
print(time.gmtime())   # UTC 時間

print(time.localtime(123123123))
print(time.gmtime(123123123))
print(time.mktime(time.localtime()))
print(time.strftime('%Y',time.gmtime()))

'2017-03-01'
print(time.strptime('2017-03-01','%Y-%m-%d'))

print(time.ctime())
print(time.ctime(123123123))
print(time.asctime())
print(time.asctime(time.gmtime()))

random模塊

import random
 
print(random.random())#(0,1)----float    大於0且小於1之間的小數
 
print(random.randint(1,3))  #[1,3]    大於等於1且小於等於3之間的整數
 
print(random.randrange(1,3)) #[1,3)    大於等於1且小於3之間的整數
 
print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]
 
print(random.sample([1,'23',[4,5]],2))#列表元素任意2個組合
 
print(random.uniform(1,3))#大於1小於3的小數，如1.927109612082716 
 
 
item=[1,3,5,7,9]
random.shuffle(item) #打亂item的順序,至關於"洗牌"
print(item)

生成隨機驗證碼

def make_code(n):
    res = ''
    for i in range(n):
        s1=str(random.randint(0,9))
        s2=chr(random.ranint(65,90))
        res+=random.choice([s1,s2])
    return res
print(make_code(10))

shelve 模塊

能夠作序列化,不能跨平臺，支持python全部的數據類型

import shelve

f=shelve.open(r'sheve.shl')

f['tom']={'age':18,'password':'123'}
f['jerry']={'age':20,'password':'123'}
f.close()

-------------------------------
import shelve

obj=shelve(r'sheve.shl')
print(obj['tom'])
print(obj['jerry'])

for i in obj:
    print(i,obj[i])

obj.close()