Python--day6
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
os.rmdir('dirname') 刪除單級目錄，若目錄不為空則無法刪除
os.listdir('dirname') 列出指定目錄下的所有文件和子目錄
os.remove() 刪除一個文件
os.rename("oldname","newname") 重命名文件/目錄
os.stat('path/filename') 獲取文件/目錄信息
os.sep 輸出操作系統特定路徑分隔符，win下為“\\”，linux下為‘\’
os.linesep ? 輸出當前平臺使用的行終止符，win下為“\r\n”,linux下為“\n”
os.pathsep 輸出用于分割文件路徑的字符串
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最后的文件名
os.path.exists(path) 如果path存在，返回True，不存在返回False
os.path.isabs(path) 如果path是絕對路徑，返回True
os.path.isfile(path) 如果path是一個存在的文件返回True，如果不存在返回False
os.path.isdir(path) 如果path是一個存在的目錄，則返回True
os.path.join(path1[,path2[,...]]) 將多個路徑組合后返回，第一個絕對路徑之前的參數將被忽略
os.path.getatime(path) 返回path所指向的文件或者目錄的最后存取時間
os.path.getmtime(path) 返回path所指向的文件或者目錄的最后修改時間
os.popen(dir).read() popen 相當于打開一個臨時文件把執行結果存下來，并打印出來
?
sys模塊
sys.argv 命令行參數list，第一個元素是程序本身路徑
sys.exit(n) 退出程序，正常退出時exit（0）
sys.version 獲取Python解釋程序的版本信息
sys.maxint 最大的int值
sys.path 返回模塊的搜索路徑，初始化是使用Pythonpath環境變量的值
sys.platform 返回操作系統平臺名稱
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
?
shutil模塊
高級的 文件、文件夾、壓縮包 處理模塊
shutil.copyfileobj(fsrc,fdst[,length])
將文件內容拷貝到另一個文件中，可以部分內容
shutil.copyfile(src,dst)? 文件的復制
shutil.copymode(src,dst) 僅拷貝權限，內容、組、用戶均不變
shutil.copystat(src,dst) 拷貝狀態的信息，包括：mode bits,atime,mtime
shutil.copy(src,dst) 拷貝文件和權限
shutil.copy2(src,dst) 拷貝文件和狀態信息
?shutil.ignore_patterns(*patterns)
shutil.copytree(src,dst,symlinks=False,ignore=None) 遞歸的去拷貝文件
shutil.rmtree(path[,ignore_errors[,onerror]]) 遞歸的去刪除目錄/文件
shutil.move(src,dst) 遞歸的去移動目錄/文件
shutil.make_archive(base_name,format,...) 創建壓縮包并返回文件路徑，例如：zip、tar
base_name:壓縮包的文件名，也可以是壓縮包的路徑。否則保存至指定路徑。
如：www =>保存至當前路徑
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format:壓縮包種類，“zip”,"tar","bztar","gztar"
root_dir:要壓縮的文件夾路徑（默認當前目錄）
owner:用戶，默認當前用戶
group：組，默認當前組
logger:用于記錄日志，通常是logging.Logger對象
?
pickle 模塊提供了四個功能：dumps、dump、loads、load
import pickle? #pickle 用來序列化，幾乎可以序列化所有的Python類型
pickle是Python獨有的序列化模塊，所謂獨有就是不能和其他語言進行交互，因為pickle將數據對象轉化為bytes
dumps、dump是進行序列化?? loads、load進行反序列化
dumps 、dump序列化示例：
?
>>> import pickle >>> d=[1,2,3,4] >>> pickle.dumps(d) b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.'?
dumps將所傳入的變量的值序列化為一個bytes，然后，就可以將這個bytes寫入磁盤或者進行傳輸。
而dump則更加一步到位，在dump中可以傳入兩個參數，一個為需要序列化的變量，另一個為需要寫入的文件。
?
f=open('file_test','wb') >>> d=[1,2,3,4] >>> pickle.dump(d,f) >>> f.close() >>> f=opem('file_test','rb') f=open('file_test','rb') >>> f.read() b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.'?
?
loads當我們要把對象從磁盤讀到內存時，可以先把內容讀到一個bytes，然后用loads方法反序列化出對象，也可以直接用load方法直接反序列化一個文件。
?
例如：
>>> d=[1,2,3,4] >>> r=pickle.dumps(d) >>> print(r) b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.' >>> pickle.loads(r) [1, 2, 3, 4]>>> d=[1,2,3,4]
>>> f=open('file_test','wb')
>>> pickle.dump(d,f)
>>> f.close()
>>> f=open('file_test','rb')
>>> r=pickle.load(f)
>>> f.close()
>>> print(r)
[1, 2, 3, 4]
json模塊
如果我們要在不同的編程語言之間傳遞對象，就必須把對象序列化為標準格式，比如XML，但更好的方法是序列化為JSON，因為JSON表示出來就是一個字符串，可以被所有語言讀取，也可以方便地存儲到磁盤或者通過網絡傳輸。JSON不僅是標準格式，并且比XML更快，而且可以直接在Web頁面中讀取，非常方便。
?
json中的方法和pickle中差不多，也是dumps，dump，loads，load。使用上也沒有什么區別,區別在于，json中的序列化后格式為字符。
?
json示例：
?
shelve 模塊
shelve模塊是一個簡單的K，v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的Python數據格式
例如：
?
#!/usr/bin/env python# encoding: utf-8
import shelve
d = shelve.open('shelve_test')#打開一個文件
class Test(object):
def __init__(self,n):
self.n = n
t = Test(123)
t2 = Test(123213213)
name = ["alex","shidong","test"]
d["test"] = name #持久化列表
d["t1"] = t #持久化類
d["t2"] = t2
d.close()
xml處理模塊
（修改和刪除xml文檔內容）xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單
YAML模塊
configparser 模塊 ：用于生成和修改常見配置文檔，當前模塊的名稱在Python3.x版本中變更為configparser
#!/usr/bin/env python
# encoding: utf-8
import configparser
#1、獲取所有節點
config = configparser.ConfigParser()
config.read('shidong', encoding='utf-8')
ret = config.sections()
print(ret)
#2、獲取指定節點下所有的鍵值對
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
ret = config.items('section1')
print(ret)
#3、獲取指定節點下所有的鍵
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
ret = config.options('section1')
print(ret)
#4、獲取指定節點下指定key的值
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
res = config.get('section1','k1')
print(res)
#5、檢查、刪除、添加節點
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
has_opt = config.has_option('section1','k1')
print(has_opt)
#6、刪除
config.remove_option('section1','k1')
config.add_section('shidong')
config['shidong']['age'] = '29'
config.write(open('shidong','w'))
#7、設置
config.set('section3','k10','123')
config.write(open('shidong','w')) #8、創建配置文件 #!/usr/bin/env python
# encoding: utf-8
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval':'45',
'Compression':'yes',
'CompressionLevel':'9'
}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] ={}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '5002'
topsecret['ForwardX11'] = 'no'
topsecret['Value'] ='1024'
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini','w') as configfile:
config.write(configfile)
hashlib模塊
用于加密相關的操作，3.X里代替了md5模塊和sha模塊，主要提供SHA1，SHA224，SHA256，SHA384，SHA512
,MD5算法
import hashlib
>>> a = hashlib.md5() #先聲明一下，用什么方法加密
>>> a.update("Hello")
>>> a.update("It's me")
>>> a.digest
<built-in method digest of _hashlib.HASH object at 0x7f968ef70468>
>>> a.digest() #二進制
']\xde\xb4{/\x92Z\xd0\xbf$\x9cR\xe3Br\x8a'
>>> a.hexdigest() #十六進制
'5ddeb47b2f925ad0bf249c52e342728a'
還不夠？Python還有一個hmac模塊，它內部對我們創建愛你key和內容在進行處理然后在加密
（在原有算法上再加一層）多用于消息加密
例如：
>>> import hmac
>>> a = hmac.new("secret_key")
>>> a.update("test")
>>> a.hexdigest()
'067a732507f937494b66aea19ce9bfa3'
Subprocess 模塊
Python 3.5之后才會有run()方法,run()方法用來執行命令
在Python 2.7版本，無法使用run（）方法，但是可以使用call方法代替
call 命令：執行命令，返回狀態碼（0代表執行成功）
例如：
>>> import subprocess
>>> subprocess.call("ifconfig")
或者
>>> subprocess.call(["df","-h"])
再或者用源生的shell去執行
>>> subprocess.call("ls",shell=True)
示例：返回執行結果，并不是狀態碼，這時候就不能用call方法了，改用Popen方法加管道
>>> a = subprocess.Popen("df -h",shell=True,stdout=subprocess.PIPE)
>>> a
<subprocess.Popen object at 0x7f968ef6fc50>
>>> a.stdout
<open file '<fdopen>', mode 'rb' at 0x7f96887880c0>
>>> a.stdout.read()
'Filesystem????? Size? Used Avail Use% Mounted on\n/dev/sda2?
48G?? 32G?? 14G? 70% /\ntmpfs??????????
91M? 228K? 491M?? 1% /dev/shm\n/dev/sda1??????
291M?? 34M? 242M? 13% /boot\n.host:/????????
362G? 360G? 1.8G 100% /mnt/hgfs\n'
check_call 執行命令，如果執行狀態碼是0，則返回0，否則拋異常
例如：
>>> subprocess.check_call("ll -th",shell=True)
/bin/sh: ll: command not found
Traceback (most recent call last):
? File "<stdin>", line 1, in <module>
? File "/usr/lib64/python2.6/subprocess.py", line 505, in check_call
??? raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'll -th' returned non-zero exit status 127
subprocess.Popen() :用于執行復發的系統命令
用于兩個進程之間的交互，示例：
import subprocess a = subprocess.Popen(["python"],stdin=subprocess.PIPE,stdout=subprocess.PIPE
,stderr=subprocess.PIPE)
a.stdin.write("print(Hello)\n")
a.stdin.write("print(Hello2)\n")
a.stdin.write("print(Hello3)\n")
a.communicate()
logging模塊
logging日志可以分為五個級別，分別為：debug(),info(),warning(),error(),critical() #!/usr/bin/env python
# encoding: utf-8
import logging
#打印到屏幕上
#logging.warning("user attempted wrong password")
#logging.critical("server is down")
#把日志寫到文件里
logging.basicConfig(filename='shidong.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this ,too')
#把日志寫入到文件并加入執行時間 logging.basicConfig(filename='shidong.log',level=logging.DEBUG,format='%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this ,too')
#如果想把日志輸出到文件并打印到屏幕上，就需要一點點復雜的知識了需要用到handler #創建logging對象
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)
#創建handler，handler的作用是輸出到指定目標
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
#創建file handler,并設置級別
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
#創建時間格式formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#規定好格式后，把格式賦給對象
ch.setFormatter(formatter)
fh.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fh)
#'application' code 進行輸出
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
面向對象編程：的特性：
1、封裝
封裝最好理解了。封裝是面向對象的特征之一，是對象和類概念的主要特性。
封裝，也就是把客觀事物封裝成抽象的類，并且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的
信息進行隱藏。
2、繼承
面向對象編程（OOP）語言的一個主要功能就是“繼承”。繼承是指這樣一種能力：他可以使用現有類的所有功能，
并在無需重新編寫原來的類的情況下對這些功能進行擴展。
通過繼承創建的新類稱為“子類”或“派生類”。
被繼承的類稱為“基類”、“父類”或“超類”
繼承的過程，就是從一般到特殊的過程。
要實現繼承，可以通過“繼承”（inheritance）和“組合”（Composition）來實現 。
在某些OOP語言中，一個子類可以繼承多個基類，但是一般情況下，一個子類只能有一個基類，要實現多重繼承，可以通過
多級繼承來實現
繼承概念的實現方式有三類：實現繼承、接口繼承和可是繼承。
%%實現繼承是指使用基類的屬性和方法而無需額外編碼的能力；
%%接口繼承是指僅使用屬性和方法的名稱，但是子類必須提供實現的能力；
%%可是繼承是指子窗體（類）使用基窗體（類）的外觀和實現代碼的能力。
抽象類（指基類/父類）僅定義將由子類創建的一般屬性和方法
OOP開發范式大致為：劃分對象-->抽象類-->將類組織成為層次化結構（繼承和合成）-->用類與實例進行設計和實現
多態：
多態就是父類（基類/抽象類）在特定的情況下可以訪問子類
object是Python中的頂級父類 #!/usr/bin/env python
# encoding: utf-8
class Role(object):
def __init__(self,name,role,weapon,life_value):
#self初始化
self.name = name
self.role = role
self.weapon = weapon
self.life_val = life_value
def buy_weapon(self,weapon):
print("%s is buying[%s]" % (self.name,weapon))
self.weapon = weapon
#p1 稱為實例
#把一個抽象的類變成一個具體的對象的過程叫實例化
p1 = Role("SanJiang",'Police',"B10",90)
t1 = Role("ChunYun",'Terrorist',"B11",100)
p1.buy_weapon("AK47")
t1.buy_weapon("B51")
print("P1:",p1.weapon)
print("T1:",t1.weapon)
類變量與實例變量
實例：
#!/usr/bin/env python
# encoding: utf-8
class Role(object):
# members = 0
def __init__(self,name,role,weapon,life_value):
#self初始化
self.name = name
self.role = role
self.weapon = weapon
self.life_val = life_value
# Role.members +=1
def buy_weapon(self,weapon):
print("%s is buying[%s]" % (self.name,weapon))
self.weapon = weapon
# print(self.ac)
#p1 稱為實例
#把一個抽象的類變成一個具體的對象的過程叫實例化
p1 = Role("SanJiang",'Police',"B10",90)
t1 = Role("ChunYun",'Terrorist',"B11",100)
t2 = Role("T2",'Terrorist',"B17",100)
t3 = Role("T3",'Terrorist',"B19",100)
p1.buy_weapon("AK47")
t1.buy_weapon("B51")
p1.ac = "China Brand"#實例中設置ac
t1.ac = "US Brand"#實例中設置ac
Role.ac = "Janpanese Brand" #在類中設置ac，并且ac為全局變量
#實例中設置變量，那么則會在實例的內存地址添加一個實例，實例
#中不設置那么則用全局變量
print("P1:",p1.weapon,p1.ac)
print("T1:",t1.weapon,t1.ac)
print("T2:",t2.ac,t2.weapon)
print("T3:",t3.ac,t2.weapon)
類的繼承 #!/usr/bin/env python
# encoding: utf-8
class SchoolMember(object):
member_nums = 0
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):
SchoolMember.member_nums+=1
print("The [%s] school member [%s] is enrolled!" % (self.member_nums,self.name))
def tell(self):
print("Hello,my name is %s" %(self.name))
class Teacher(SchoolMember):#繼承父類SchoolMember
def __init__(self,name,age,sex,course,salary):#如果不寫則直接繼承父類
super(Teacher,self).__init__(name,age,sex)
#SchoolMember.__init__(self,name,age,sex)這是舊式寫法
self.course = course
self.salary = salary
def teaching(self):
print("Teacher [%s] is teaching [%s]" %(self.name,self.course))
class Student(SchoolMember):
def __init__(self,name,age,sex,course,tuition):
super(Student,self).__init__(name,age,sex)
self.course = course #self 代表的意思為實例
self.tuition = tuition
def pay_tuition(self):
print("cao,student [%s] paying tuition [%s]" %(self.name,self.tuition))
t1 = Teacher("shidong",28,"F","PY",1000000)
t2 = Teacher("Alex",28,'N/A',"PY",100000)
s1 = Student("SanJiang",23,"Female","python",20000)
s2 = Student("BaoAn",23,'Femle',"python",9000)
t1.tell()#繼承后，可以調用父類的方法
t1.teaching()
s1.tell()
s1.pay_tuition()
轉載于:https://www.cnblogs.com/sd880413/p/8034235.html
總結
以上是生活随笔為你收集整理的Python--day6的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： C# 调用WSDL接口及方法
- 下一篇： windows 连接Linux