1.python模塊：
標準庫和第三方庫，第三方庫需要下載安裝
2.模塊sys：
命令 功能
sys.stdin 標準輸入流
sys.stdout 標準輸出流
sys.stderr 標準錯誤流
sys.argv[value] 接收命令行的參數。例如，windows下的命令行cmd裡面的參數。其中，argv[0]表示該文件本身。
sys.version 查看該python的版本。
sys.platform 判斷是什麼操作系統
sys.exit(n) 若 n 為0，則正常退出；其他都是異常退出，可以捕獲
sys. path 查找模塊所在的目錄，以列表的形式顯示出來
3.os模塊：
命令 功能
os.name 獲取操作系統平臺
os.getcwd() 獲取現在的工作目錄
os.listdir() 獲取某個目錄下的所有文件名
os.remove() 刪除某個文件
os.system() 用來運行shell命令
os.path.existe() 檢驗給出的路徑是否真地存在
os.path.isfile() 判斷是否為文件;若是，返回值為真
os.path.isdir() 判斷是否為文件夾;若是，返回值為真
os.path.abspath(name) 獲得絕對路徑
os.path.splitext() 分離文件名與擴展名
os.path.split() 把一個路徑拆分為目錄+文件名的形式
os.path.join(path,name) 連接目錄與文件名或目錄
os.path.basename(path) 返回文件名
os.path.dirname(path) 返回文件路徑
os.popen("dir") 返回當前目錄，顯示的是內存地址
os.popen("dir").read() 返回內存地址的內容
4.數據類型：整型(int)、浮點型(float)、複數(complex)、字符串、布爾值
5.數據運算：https://www.cnblogs.com/topspeedking/p/6403513.html
6.三元運算：
result = 值1 if 條件 else 值2
如果條件為真：result = 值1
如果條件為假；result = 值2
7.Python 3中bytes/string的區別：
https://www.cnblogs.com/abclife/p/7445222.html
8.Python3中byte和string之間各種編碼轉換：
http://blog.csdn.net/htdeyanlei/article/details/50866307
9.decode解碼 encode編碼
10.列表（list）：
list.append(x)
在列表的尾部添加一個項，等價於 a[len(a):] = [x]。
list.extend(L)
將給定的列表L接到當前列表後面，等價於 a[len(a):] = L。
list.insert(i, x)
在給定的位置 i 前插入項，例如：a.insert(0, x) 會在列表的頭部插入，而 a.insert(len(a), x) 則等價於 a.append(x)。
list.remove(x)
移除列表中第一個值為 x 的項，沒有的話會產生一個錯誤。
list.pop([i])
刪除列表給定位置的項，並返回它。如果沒指定索引，a.pop()移除並返回列表最後一項。（方括號表示可選）
list.clear()
刪除列表中的所有項，相當於 del a[:]。
list.index(x)
返回列表中第一個值為 x 的項的索引。如果沒有匹配的項, 則產生一個錯誤。
list.count(x)
返回列表中 x 出現的次數。
list.sort()
就地完成列表排序。
list.reverse()
就地完成列表項的翻轉。
list.copy()
返回列表的一個淺拷貝，相當於a[:]。
---------------------------------------
1.元組
元組其實跟列表差不多，也是存一組數，只是它一旦創建，便不能在修改，所以又叫只讀列表
語法：names =('shgd','sjdh')
它只有兩個方法，一個是count，一個是index
2.字符串操作
大全：https://www.cnblogs.com/huangcong/archive/2011/08/29/2158268.html
s.capitalize() #字符串s首寫字母大寫
s.lower() #全部變成小寫
s.upper() #全部變成大寫
s.swapcase() #大小寫互換
len(s) #得到字符串的大小
s.find(substring,[start[,end]]) # 找到，返回索引值，找不到，返還－1
s.rfind(substring,[start[,end]]) #反向查找
s.index(substring,[start[,end]]) #與find()類似，如果找不到substring，就產生一個
ValueError的異常
s.rindex(substring,[start[,end]]) #反向查找
s.count(substring,[start[,end]]) #返回找到substring的次數
s.formate() #傳值進去如 s.formate(name='shd',year=20)具體用法自行查詢。
s.ljust(width) #左對齊，如果width比len(s)大，則後面補空格。否則返回s。
s.rjust(width) #右對齊
s.center(width) #居中
s.lstrip() #去掉左邊的空白字符
s.rstrip() #去掉右邊的空白字符
s.strip() #去掉兩邊的空白字符
s.split(words) #words是一個字符串，表示分隔符。split的操作和join相反。將s分解為一個list。
s.endswith() #判斷字符串以什麼結尾。
s.expandtabs(tabsize=30) #將\\t符號轉換為30個空格。
s.isalnum() #判斷是否是英文或數字 包含所有的英文字符加上0到9
s.decimal() #判斷是否是十進制
s.digit() #判斷是否是數字
s.isdentifier() #判斷是否是一個合法的標識符。說白了是否是合法的變量名。
s.numeric() #判斷是否是數字具體用法自行搜索
s.istitle() #判斷是否是標題，即單詞是否首字母為大寫。
''.join(['1','2','3']) #得到結果為123
maketrans和translate一起用如：
p = str.maketrans('abcdef','123456') #將‘abcdef’用‘123456’代替。
print('husngshijie'.translate(p))
s.replace（） #代替
s.swapcase() #大寫變小寫，小寫變大寫。
s.zfill() #左邊補0，個數決定於括號裡面的參數。
3.字典
字典是無序的可通過key找到相對應的value
具體用法自查。http://blog.csdn.net/u010480899/article/details/52737739
字典可以多層嵌套
dict.values() #打印所有的值value
dict.keys() #打印所有的鍵key
dict.setdefault() #類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值
dict.update() #用一個字典更新另外一個字典
dict.items() #items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表
dict.fromkeys() #使用給定的鍵建立新的字典，鍵默認對應的值為None
---------------------------------------------------------------------
1.集合
集合是一個無序的，不重複的數據組合，作用如下：
>>去重，把一個列表變成集合，就自動去重
>>關係測試，測試兩組數據之前的交集、差集、並集等關係
2.關係運算
交集: set1.intersection(set2)
並集: set1.union(set2)
差集: set1.difference(set2) # 在set1有，set2沒有
子集: set1.issubset(set2) #判斷set1是否是set2的子集
父集: set1.issuperset(set2) #判斷set1是否是set2的父
對稱差集: set1.symetric_difference(set2) #把兩個集合都有的即並集去掉，互相都沒有的取出來
判斷是否有交集：set1.isdisjoint(set2)
3.運算符關係運算
交集: &
並集: |
差集: -
對稱差集: ^
子集: <=
父集: >=
4.集合基本操作
添加: set1.add(x) #添加一項
更新: set1.update([10,37,45]) #添加多項
移除: set1.remove() #可以刪除一項，不存在會報錯
移除: set1.discard() #移除一項，不存在不會報錯，返回none
測量長度: len(set1)
x in set1 #測試x是否是set1的成員
x not in set1 #測試x是否不是set1的成員
淺複製: set1.copy()
set1.pop() #任意刪除set1zhong的元素
5.文件操作
（1）打開文件，得到文件柄並賦值給一個變量
（2）通過句柄對文件進行操作
（3）關閉文件
6.文件操作大全
https://www.cnblogs.com/nulige/archive/2016/12/06/6037752.html
-------------------------------------------------------------------
1.編程方式分：面向對象、面向過程、函數式編程
2.區分
面向對象----》類----》class
面向過程----》過程----》def
函數式編程----》函數----》def
3.編程語言中函數的定義：
函數是邏輯結構化和過程化的一種編程方法
4.過程是沒有返回值的函數
5.使用函數的優點：
1）代碼可重複使用
2)代碼可保持一致性
3)可擴展性
6.
當一個函數/過程沒有使用return顯示的定義返回值時，python解釋器會隱式的返回None，所以在python中即便是過程也可以算作函數。
7.返回值
返回值的數等於0，返回None
返回值的數等於1，返回object
返回值的數大於1，返回tuple
8.參數
1）形參和實參形參：形式參數，不是實際存在的，是虛擬變量 。在定義函數體的時候使用形參，目的是在函數 調用時接受參數（形參參個數、類型與實參一一對應）
實參：實際參數，調用函數時傳給函數的參數，可以是常量、變量、表達式、函數，傳給形參
2）位置參數和關鍵字參數
標準調用：實參與形參位置一一對應；
關鍵字調用：位置無需固定
3）默認參數
特點：調用函數的時候，默認參數非必須傳遞
4）參數組
*args 接收n個位置參數，轉換成元組的方式
**kwargs 接收 n個關鍵字參數，轉換成字典的方式
9.局部變量
只在局部範圍內發生作用，即只在函數內部發生作用
10.全局變量
全局變量作用域是整個程序，要把局部變量變成全局變量用global，但是不建議在函數里使用，可能會出現很嚴重bug
11.局部變量除了整數、字符串不能影響全局變量，像字典、元組、列表、類都可以更改，並影響到全局變量
12.遞歸
如果一個函數在內部調用自身，這個函數就是遞歸函數
13.遞歸特性
1）必須有一個明確的結束條件
2）每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減少
3）遞歸效率不高，遞歸層次過多會導致棧溢出（在計算機中，函數調用是通過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞歸調用的次數過多，會導致棧溢出
14.高階函數
變量可以指向函數，函數的參數能接收變量，那麼一個函數可以接收另一個函數作為參數，這種 函數就稱之為高階函數。
15.函數詳解：
http://www.cnblogs.com/alex3714/articles/5740985.html
------------------------------------------------------------
python 3.x 學習筆記5 （裝飾器）
1.裝飾器：
本質是函數，（裝飾其他函數）就是為其他函數添加附加功能
原則：
1）不能修改被裝飾的函數的源代碼
2）不能修改被裝飾的函數的調用方式
2.實現裝飾器知識儲備：
1）函數即“變量”
2）高階函數
a.把一個函數當作實參傳給另一個函數（可以做到不修改被裝飾函數的源代碼的情況下為其添加功能）
b.返回值中包含函數名）（不修改函數的調用方式）
3）嵌套函數
3.高階函數+嵌套函數=》裝飾器
4.初步裝飾器
複製代碼
import time
def timer(func): #timer(test1) func = test1
def deco():
start_time = time.time()
func() #run test1
stop_time = time.time()
print('the func run time is %s'%(stop_time-start_time))
return deco
@timer #test1 = timer(test1)
def test1():
time.sleep(3)
print('in the test1')
test1()
複製代碼
5.功能比較完善的裝飾器
複製代碼
user,passwd = 'hsj','1234'
def auth(auth_type):
print('auth func:',auth_type)
def outer_wrapper(func):
def wrapper(*args, **kwargs):
print('wrapper:',*args, **kwargs)
if auth_type == 'local':
username = input('Username:').strip()
password = input('Password:').strip()
if username == user and password == passwd:
print('\\033[32;1mUser has pass authentication\\033[0m')
return func(*args, **kwargs) # from home #函數wrapper的返回值
else:
exit('\\033[31;1mInvalid username or password\\033[0m')
elif auth_type =='ldap':
print('ldappppppppp')
return wrapper
return outer_wrapper
def index():
print('welcome to index psge')
@auth(auth_type='local') # 加了括號相當於運行了outer_wraper所以會執行裡面內容 # home = auth(home)
def home():
print('welcome to home page')
return 'from home' #這裡有返回值在裝飾器裡也應該有個返回值不然是print（）不出來的
@auth(auth_type='ldap')
def bbs():
print('welcome to bbs page')
index()
print(home())
bbs()
複製代碼
==================================================
python 3.x 學習筆記6 ( 迭代器 and 生成器 )
1.迭代器(Iterator):
可以被next()函數調用並不斷返回下一個值的對象，成為迭代器：Iterator
可以直接用於for 循環的對象統稱為可迭代對象：Iterable
迭代，顧名思義就是重複做一些事很多次（就現在循環中做的那樣）。迭代器是實現了__next__()方法的對象（這個方法在調用時不需要任何參數），它是訪問可迭代序列的一種方式，通常其從序列的第一個元素開始訪問，直到所有的元素都被訪問才結束。但是迭代器只能前進不能後退
優點：
使用迭代器不要求事先準備好整個迭代過程中的所有元素。迭代器僅僅在迭代到某個元素時才計算該元素，而在這之前或之後元素可以不存在或者被銷燬。因此迭代器適合遍歷一些數量巨大甚至無限的序列。
2.生成器：
只有調用時才會生成相應的數據，且只有一個__next__()方法
如果列表元素可以按照某種算法推算出來，那我們是否可以在循環的過程中不斷推算出後續的元素呢？這樣就不必創建完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱為生成器（Generator）。
創建方法：
1）最簡單的是把一個列表生成式的[]改成()，就創建了一個generator
2）可以把函數變成generator object，只需要把print()改為yield 即可。
3.
yeild 作用：保存當前狀態並返回
send（）作用：喚醒並傳遞一個值
__next__()作用：只是喚醒
4.
生成器都是Iterator對象，但是list、低產田、str雖然是Iterable，卻不是Iterator，把list、dict、str等Iterable變成Iterator可以使用iter()函數。
5.通過yield將斐波那契函數變成生成器
複製代碼
1 def fib(max):
2 n,a,b = 0,0,1
3 while n < max:
4 yield b #將函數變成生成器
5 a,b = b,a+b
6 n += 1
7 return 'lalalalal'
8
9 f = fib(10)
10
11 while True:
12 try13 x = next(f) #相當於執行一次函數fib()
14 print(x)
15 except StopIteration as e:
16 print('Generator return value is %s '%e.value) #e的value是函數返回值如fib函數的返回值'lalalalal'
17 break
複製代碼
============================================
python 3.x 學習筆記7 ( 模塊 )
1.定義：
模塊：用來從邏輯上組織python代碼（變量、函數、類、邏輯：實現一個功能），本質就是.py結尾的python文件
包：用來從邏輯上組織模塊的，本質就是一個目錄（必須帶有一個__init__.py文件）
2.導入方法
import module_name1,module_name2
from module import * (不建議使用)
from module import m1,m2,m3
from module import m1 as m
3.import 本質
導入模塊的本質就是把python文件解釋一遍
導入包的本質就是執行該包下面的__init__.py文件
4.導入優化
from module_test import test
5.模塊分類
a.標準庫
b.開源模塊
c.自定義模塊
標準庫：
1.time與datetime
strftime("格式"，struct_time)----->"格式化的字符串"
strptime("格式化的字符串"，"格式")
6.模塊大全
http://blog.51cto.com/egon09/p2
7.例子
複製代碼
import time
print(time.time()) #返回當前時間的時間戳
print(time.altzone) #返回與utc時間的時間差,以秒計算 -32400
print(time.asctime()) #返回時間格式"Fri Jan 26 20:38:48 2018",
print(time.gmtime()) #gmtime()方法是將一個時間戳轉換為UTC時區（0時區）的struct_time
print(time.mktime(time.localtime())) #將一個struct_time轉化為時間戳
print(time.asctime()) #把一個表示時間的元組或者struct_time表示為這種形式：'Fri Jan 26 20:38:48 2018'。如果沒有參數，將會將time.localtime()作為參數傳入。
print(time.asctime(time.gmtime())) # 把一個表示時間的元組或者struct_time表示為這種形式：'Fri Jan 26 20:38:48 2018'。如果沒有參數，將會將time.localtime()作為參數傳入。
print(time.ctime()) #把一個時間戳（按秒計算的浮點數）轉化為time.asctime()的形式。如果參數未給或者為None的時候，將會默認time.time()為參數。它的作用相當於time.asctime(time.localtime(secs))。
string_2_struct = time.strptime("2018-01-26 20:38:48","%Y-%m-%d %H:%M:%S") #將 日期字符串 轉成 struct時間對象格式
print(string_2_struct)
print(time.gmtime(time.time() - 98546) # 將utc時間戳轉換成struct_time格式
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) #將utc struct_time格式轉成指定的字符串格式
import datetime
print(datetime.datetime.now())
print(datetime.date.fromtimestamp(time.time())) # 時間戳直接轉成日期格式2018-01-26
print(datetime.datetime.now()+datetime.timedelta(6)) #當前時間+6天
print(datetime.datetime.now()-datetime.timedelta(6)) #當前時間-6天
print(datetime.datetime.now()+datetime.timedelta(hours=6)) #當前時間+6小時
print(datetime.datetime.now()+datetime.timedelta(minutes=30)) #當前時間+30分
c_time = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2)) #時間替換
複製代碼
=====================================================
python 3.x 學習筆記8 (os模塊及xml修改)
1.os模塊操作
os.getcwd()： # 查看當前所在路徑。
os.listdir(path): # 列舉目錄下的所有文件，返回的是列表類型。
os.path.abspath(path): # 返回path的絕對路徑。
os.path.join(path1,path2,...): # 將path進行組合，若其中有絕對路徑，則之前的path將被刪除。
os.path.dirname(path): # 返回path中的文件夾部分，結果不包含'\\'
os.path.basename(path): # 返回path中的文件名。
os.path.getmtime(path): # 文件或文件夾的最後修改時間，從新紀元到訪問時的秒數。
os.path.getatime(path): # 文件或文件夾的最後訪問時間，從新紀元到訪問時的秒數。
os.path.getctime(path): # 文件或文件夾的創建時間，從新紀元到訪問時的秒數。
os.path.getsize(path): # 文件或文件夾的大小，若是文件夾返回0
os.path.exists(path): # 文件或文件夾是否存在，返回True 或 False。
2.xml的使用
xml建立
複製代碼
from xml.etree import ElementTree as ET
def build_sitemap():
urlset = ET.Element("urlset") # ET.Element創建一個根節點，標籤為urlset
url = ET.SubElement(urlset,"url") # ET.SubElement在根節點urlset下建立子節點
loc = ET.SubElement(url,"loc",attrib={"name":"百度"}) #attrib為創建屬性
loc.text = "http://www/baidu.com" #loc.test 為寫入內容
time = ET.SubElement(url,"time")
time.text = "2018-1-30"
change = ET.SubElement(url,"change")
change.text = "daily"
priority = ET.SubElement(url,"priority")
priority.text = "1.0"
tree = ET.ElementTree(urlset)
tree.write("set.xml",'utf-8') #寫入時加上‘utf-8’可以轉譯中文，不會有亂碼
if __name__ == '__main__':
build_sitemap()
複製代碼
生成的xml
複製代碼
<urlset>
<time>2018-1-30/<time>
<change>daily/<change>
<priority>1.0/<priority>
複製代碼
下面是要修改的文件
複製代碼
<data>
<country>
<rank>1/<rank>
<year>2008/<year>
<gdppc>141100/<gdppc>
<neighbor>
<neighbor>
<country>
<rank>4/<rank>
<year>2011/<year>
<gdppc>59900/<gdppc>
<neighbor>
<country>
<rank>68/<rank>
<year>2011/<year>
<gdppc>13600/<gdppc>
<neighbor>
<neighbor>
複製代碼
修改程序
複製代碼
import xml.etree.ElementTree as ET
tree = ET.parse('xmltest.xml')
root = tree.getroot()
#修改
for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
node.set('updated_by','hsj')
tree.write('xmltest2.xml')
#刪除
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('xmltest3.xml')
複製代碼
============================================
python 3.x 學習筆記9 (面向對象)
1.面向對象
面向對象是一種對現實世界理解和抽象的方法，是計算機編程技術發展到一定階段後的產物。
2.類(class):
一個類即是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具備的屬性（variables(data)）、共同的方法
3.對象(Object):
一個對象即是一個類的實例化後實例，一個類必須經過實例化後方可在程序中調用，一個類可以實例化多個對象，每個對象亦可以有不同的屬性，就像人類是指所有人，每個人是指具體的對象，人與人之前有共性，亦有不同
4.特性
封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裡面包含著類的數據和方法
繼承
一個類可以派生出子類，在這個父類裡定義的屬性、方法自動被子類繼承
多態
多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。
5.構造函數
在實例化時做一些類的初始化的工作
實例變量：self.a = a
實例變量（靜態屬性），作用域為實例本身
例子
複製代碼
1 class Person:
2 n = 123 #類變量
3
4 def __init__(self,name,ability):
5 #構造函數
6
7 self.name = name #實例化變量（靜態屬性） ，作用域為實例化本身
8 self.ability = ability
9
10 def eat(self): # 類方法 功能（動態屬性）
11 print('I will eat something ! ')
12
13 def run(self):
14 print('I will runing !')
15
16 def sleep(self):
17 print('I will sleep !')
18
19 def doing(self):
20 print('I am %s'% self.ability)
21
22 r1 = Person('張三','dancing')
23
24 r1.sleep()
25 r1.run()
26 r1.eat()
27 r1.doing()
28 print(r1.n)
複製代碼
結果
I will sleep !
I will runing !
I will eat something !
I am dancing
1234
===========================================
python 3.x 學習筆記10 (析構函數and繼承)
1.類變量的用途：
大家公用的屬性，節省開銷（內存）
2.析構函數
在實例釋放和銷燬的時候執行的，通常用於做一些收尾工作，如關閉一些數據庫鏈接和打開的臨時文件
3.私有方法
兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。
4.私有屬性
兩個下劃線開頭，聲明該屬性為私有，不能在類地外部被使用或直接訪問。
5.
繼承的時候重寫構造函數要先將父類的所有參數寫一遍加上子類變量，然後調用父類，再添加子類的實例化變量。
6.
python2.x 經典類是按深度有先來繼承的，新式類是按廣度有先來繼承的。
python3.x 經典類和新式類都是統一按廣度優先來繼承的。
練習
#父類1
class Person(object): #新式寫法
def __init__(self,name,age):
#構造函數
self.name = name #實例化變量（靜態屬性） ，作用域為實例化本身
self.age = age
self.friends = []
def eat(self): # 類方法 功能（動態屬性）
print('%s will eat something ! '%self.name)
def run(self):
print('%s will runing !'%self.name)
def sleep(self):
print('%s will sleep !'%self.name)
#父類2
class Relation(object):
def make_friends(self,obj):
print('%s make friend with %s'% (self.name,obj.name))
self.friends.append(obj) #這裡傳的參數是obj，在這例題裡 obj既是 w1
#子類
class Man(Person,Relation): #多繼承
def __init__(self,name,age,money): #重寫構造函數
#Person.__init__(self,name,age,money) #經典寫法
super(Man,self).__init__(name,age) #新式寫法，建議用這種寫法
self.money = money
def piao(self):
print('%s is piaoing .......'% self.name)
#子類
class Woman(Person,Relation): #多繼承
def piao(self):
print('%s is piaoing .......'% self.name)
m1 = Man('張三',20,10)
w1 = Woman('lili',21)
m1.make_friends(w1)
print(m1.friends[0].name)
print(m1.friends[0].age)
# m1.piao()
# m1.eat()
# m1.run()
# m1.sleep()
========================================
python 3.x 學習筆記11 (靜態、類、屬性、特殊成員方法)
1.靜態方法
通過@staticmethod裝飾器即可把其裝飾的方法變為一個靜態方法。靜態方法是不可以訪問實例變量或類變量的即沒有self，一個不能訪問實例變量和類變量的方法，其實相當於跟類本身已經沒什麼關係了，它與類唯一的關聯就是需要通過類名來調用這個方法
2.靜態方法的調用
在調用靜態方法的時候，可以使用類名或者是實例名來進行調用，一般使用類名來進行調用
3.類方法
通過@classmethod裝飾器即可把其裝飾的方法變為一個類方法
類方法只能訪問類變量，不能訪問實例變量
4.屬性方法
通過@property裝飾器即可把其裝飾的方法變為一個類方法
把一個方法變成一個靜態屬性
類的特殊成員方法
1）.__doc__:打印類的描述方法
2）.__module__:表示當前操作的對象在那個模塊
3）.__class__:表示當前操作的對象的類是什麼
4）.__init__:構造方法，通過類創建對象時，自動觸發執行。
5.）.__del__:析構方法，當對象在內存中被釋放時，自動觸發執行。
6）. __call__:對象後面加括號，觸發執行。
7）. __dict__: 查看類或對象中的所有成員以字典形式返回
8）.__str__ 如果一個類中定義了__str__方法，那麼在打印 對象 時，默認輸出該方法的返回值。
9）.__getitem__、__setitem__、__delitem__ ：用於索引操作，如字典。以上分別表示獲取、設置、刪除數據
10）. 類的生成 調用 順序依次是 __new__ --> __init__ --> __call__
===================================================================
python 3.x 寫 shell sed 替換功能
shell sed 替換功能
複製代碼
f1 = open('yesterday','r',encoding='utf-8')
f2 = open('yesterday2','w',encoding='utf-8')
for line in f1:
if '噢 昨日當我年少輕狂'in line:
line = line.replace('噢 昨日當我年少輕狂','啦啦啦啦啦啦啦啦啦')
f2.write(line)
f1.close()
f2.close()
複製代碼
要替換的文件：
閱讀更多 雨神168 的文章
