一、字符串
1. 字符串切片
切片：
name=“abcdef” name[2:5]=“cde”
跳取：
name=“abcdef” name[2:-1:2]=“ce”
逆序：
name=“abcdef” name[-1::-1]=“fedcba”
2.字符串的常見操作
find:檢測 str 是否包含在 mystr中，如果是返回開始的索引值，否則返回-1。
mystr.find(str, start=0,end=len(mystr))
index:跟find()方法一樣，只不過如果str不在 mystr中會報一個異常。
mystr.index(str, start=0,end=len(mystr))
count:返回 str在start和end之間 在mystr里面出現的次數。
mystr.count(str, start=0, end=len(mystr))
replace:把 mystr 中的 str1 替換成 str2,如果 count 指定，則替換不超過 count 次。
mystr.replace(str1, str2, mystr.count(str1))
split:以str 為分隔符切片mystr，如果 maxsplit有指定，則僅分隔 maxsplit 個子字符串。
mystr.split(str=" ", 2)
capitalize:把字符串的第一個字符大寫。
mystr.capitalize()
title:把字符串的每個單詞首字母大寫。
mystr.title()
startswith:檢查字符串是否是以obj開頭, 是則返回 True，否則返回 False。
mystr.startswith(obj)
endswith:檢查字符串是否以obj結束，如果是返回True,否則返回 False。
mystr.endswith(obj)
lower:轉換 mystr 中所有大寫字符為小寫。
mystr.lower()
upper:轉換 mystr 中的小寫字母為大寫。
mystr.upper()
ljust:返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串。
mystr.ljust(width)
rjust:返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。
mystr.rjust(width)
center:返回一個原字符串居中,並使用空格填充至長度 width 的新字符串。
mystr.center(width)
lstrip:刪除 mystr 左邊的空白字符。
mystr.lstrip()
rstrip:刪除 mystr 字符串末尾的空白字符。
mystr.rstrip()
strip:刪除mystr字符串兩端的空白字符。
mystr.strip()
rfind:類似於 find()函數，不過是從右邊開始查找。
mystr.rfind(str, start=0,end=len(mystr))
rindex:類似於 index()，不過是從右邊開始。
mystr.rindex( str, start=0,end=len(mystr))
partition:把mystr以str分割成三部分,str前，str和str后。
mystr.partition(str)
rpartition:類似於 partition()函數,不過是從右邊開始。
mystr.rpartition(str)
splitlines:按照行分隔，返回一個包含各行作為元素的列表。
mystr.splitlines()
isalpha:如果 mystr 所有字符都是字母則返回 True,否則返回 False。
mystr.isalpha()
isdigit:如果 mystr 只包含數字則返回 True 否則返回 False。
mystr.isdigit()
isalnum:如果 mystr 所有字符都是字母或數字則返回 True,否則返回 False。
mystr.isalnum()
isspace:如果 mystr 中只包含空格，則返回 True，否則返回 False。
mystr.isspace()
join:mystr 中每個字符后面插入str,構造出一個新的字符串。
mystr.join(str)
3.字符串常見問題
①字符串是不可變類型，是不能直接就改的，那么就先要將其轉化為列表，然后在循環中找到該元素，通過列表進行更改。
for i,string in enumerate(list):
if string == "love":
list[i]="automn"
二、列表
1.列表的相關操作
（1）添加元素("增"append, extend, insert)
list.append(obj): 通過append可以向列表添加元素。
list.extend(obj): 通過extend可以將另一個集合中的元素逐一添加到列表中。
list.insert(index,obj):在指定位置index前插入元素object。
（2）刪除元素("刪"del, pop, remove)
del:根據下標進行刪除，del list[i]。
pop:刪除最后一個元素，list.pop()。
remove:根據元素的值進行刪除，list.remove("obj")。
（3）修改元素("改OBJ[i] = "X"")
修改元素的時候，要通過下標來確定要修改的是哪個元素，然后才能進行修改。
（4）查找元素("查"in, not in, index, count)
in（存在）,如果存在那么結果為true，否則為false。
not in（不存在），如果不存在那么結果為true，否則false。
index和count與字符串中的用法相同。
（5）排序(list.sort(cmp = None,key = None,reverse = False))
sort方法是將list按特定順序重新排列，默認為由小到大，參數reverse=True可改為倒序，由大到小，list.sort() | list.sort(reverse=True)。
reverse方法是將list逆置，list.reverse()。
reverse=True就是從大到小，key=len就是長度划分，reverse=True就是列表倒序。
2.列表與字符串對比及轉化
（1）列表和字符串的相同點
索引，切片，合並
（2）列表和字符串的不同點
在字符串中，每個元素只能是字符，在列表中，元素可以任意類型
列表可以改變，字符串不能改變
（3）列表和字符串的轉化
mystr.split(" "):可以使字符串以空格方式隔開並以列表存放
".".join(list):列表可以用"."來連接列表的元素
3.列表常見問題
漏刪元素。
num = [11,22,33,44,55,66]
for i in num:
if i == 33 or i == 44:
num.remove(i)
解釋：此時的結果是num = [11,22,44,55,66]，即出現了漏刪的情況，因為刪完33時，44往前挪一位，即跳過了它。
解決：要想避免漏刪就要在這個外面加上一個while True死循環，也可以把要刪的全部組合成另一個列表b，然后一個for循環，for i in b: num.remove(b)。
三、字典
1.字典的相關操作
（1）添加元素（變量名['鍵'] = 數據）
這個鍵在字典中，不存在，那么就會新增這個元素。
（2）刪除元素（del，clear()）
del 變量名["鍵"]：刪除指定元素
del 變量名：刪除整個字典
變量名.clear()：刪除整個字典
（3）修改元素（字典的每個元素中的數據是可以修改的，只要通過key找到，即可修改）
變量名['鍵'] = 數據
2.字典的常見操作
len:測量字典中，鍵值對的個數。
len(dict)
keys:返回一個包含字典所有KEY的列表。
dict.keys()
values:返回一個包含字典所有value的列表。
dict.values()
items:返回一個包含所有 (鍵，值) 元組的列表。
dict.items()
has_key: 如果key在字典中，返回True，否則返回False。
dict.has_key(key)
get: 獲得某個鍵的值。
dict.get(key) dict["key"] # 也可獲取值但如果鍵不存在，就會異常，而dict.get()只返回一個空
setdefault:如果有這個鍵就會返回它的值，沒有的話就創建這個鍵值對。
dict.setdefault(key)
items/iteritems，key/iterkeys，values/itervalues
# 能夠得到字典的列表，元素是鍵和值的元組 infor.items() # 是一個"dictionary-itemiterator"類型，這種迭代器類型，必須用list轉換一下，才能看到里面的真面目 infor.iteritems()
3.字典常見問題
①dict = {} ,並不是真正意義的清空，它只是指向了另一個對象。
②不能重復刪除同一個鍵，即刪除一個沒有鍵會發生異常。
③可變類型在字典中不能當作鍵值 (原因是它可變，故地址不確定)。
四、元組和集合
1.列表和元組
基本沒什么區別，都能存多個值，唯一的區別就是元組不讓增刪改（只讀）。
2.元組的內置函數
①cmp(tuple1,tuple2)：比較兩個元組元素。
②len(tuple)：計算元組元素個數。
③max(tuple)：返回元組中元素最大值。
④min(tuple)：返回元組中元素最小值。
⑤tuple(seq)：將列表轉換為元組。
3.集合的去重
可以用set()來去重復，也可以set = {}，但並不推薦，因為容易與字典相混淆。
4.集合常用操作
（1）增：set.add("jack") # 新添加元素
set.update("huang") #從另一個集合合並到一起。
（2）刪：pop,remove,discard,clear
set.pop()不能有參數，且是隨機刪除，當刪除到集合為空如果還繼續刪除則發生異常。
set.remove("obj") 刪除指定的元素，沒有則發生異常。
set.discard("obj") obj是set里的元素就刪除，不是就不做，不發生異常。
set.clear()清空整個集合。
5.元素和集合的關系
"obj" in set ，元素在集合內就返回True，沒有就返回False。
6. 集合與集合關系
①相等與不等:a==b，a!=b ，正確就返回True，錯誤就返回False。
②子集：c<a ,True，c是a的子集，c.issubset(a)判斷c是否是a的子集。
③並集：a.union(b) ，把a集合和b集合並起來。
④交集：a.intersection(b) ，把a集合和b集合交起來。
五、函數
1.函數的定義
把具有一個獨立功能的代碼塊當作一個整體，這個整體就是函數。
2.函數的目的
使程序變的更加模塊化。
3.實參
當調用一個函數的時候，傳遞的值叫實參（實實在在傳遞的）。
4.形參
用來接收的叫形參，過程希望調用時，傳遞該值。
5.局部變量
在一個函數里能用，出了這個函數哪都用不了，這樣的變量稱為局部變量。
6.全局變量
定義在函數外面的變量，在整個代碼中都可使用。
7.修改全局變量的值
在修改語句前加上global變量名，這是對一個全局變量的聲明，但是列表和字典可加可不加。
8.規避命名相同
全局變量和局部變量名字相同，在函數里會使用局部變量，默認是定義，為了規避全局變量和局部變量名字相同，定義全局變量的時候g_a=100。
9. 函數的缺省參數
調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值，帶有默認值的參數一定要位於參數列表的最后面，如print默認是換行，有了end就是就不換行。
10.函數返回多值
如果需要用一個函數返回多個值，但是在函數中只要執行到一個return，就返回結束，所以可以通過列表或元組來封裝變量的值。
11.不定長參數
如test(a,b,c=33, *args, **kwargs)形參，如果實參在傳遞的時候有變量名的賦值就是字典的形式存儲在kwargs中，沒有變量名的就是args里。
12.命名空間
表示標識符的可見范圍，它是對作用域的特殊抽象，它包含處於該作用域的標識符。
13.匿名函數的應用場合
①自己定義函數:函數作為參數傳遞，lambda x,y:x+y。
②作為內置函數的參數:lam = lambda x:x+3 ret = lam(3)。
③如果列表里是字典:infors.sort(key = lambdax:x[‘name’])（按name的首字母來排序）。
六、作用域
1.命名空間
變量命名的范圍（變量起作用的范圍）。
2.LEGB規則
Python 使用 LEGB 的順序來查找一個符號對應的對象，即 locals -> enclosing function -> globals -> builtins 。
①locals，當前所在命名空間（如函數、模塊），函數的參數也屬於命名空間內的變量。
②enclosing，外部嵌套函數的命名空間（閉包中常見）。
③globals，全局變量，函數定義所在模塊的命名空間。
④builtins，內建模塊的命名空間。
在Python中，有一個內建模塊，該模塊中有一些常用函數，在Python啟動后，且沒有執行程序員所寫的任何代碼前，Python會首先加載該內建函數到內存。另外，該內建模塊中的功能可以直接使用，不用在其前添加內建模塊前綴，其原因是對函數、變量、類等標識符的查找是按LEGB法則，其中B即代表內建模塊。
比如：內建模塊中有一個abs()函數，其功能求絕對值，如abs(-20)將返回20。
七、面向對象
1.面向對象和面向過程的區別
①面向過程：根據業務邏輯從上到下寫代碼。
②面向對象：將數據與函數綁定到一起，進行封裝，這樣能夠更快速的開發程序，減少了重復代碼的重寫過程（能讓程序更加簡單，更加緊湊面向對象和面向過程都是解決問題的一種思路而已）。
2.類和對象的關系
①對象是面向對象編程的核心，在使用對象的過程中，為了將具有共同特征和行為的一組對象抽象定義，提出了另外一個新的概念-類。
②類是抽象的,在使用的時候通常會找到這個類的一個具體的存在,使用這個具體的存在，一個類可以找到多個對象。某一個具體事物的存在,在現實世界中可以是看得見摸得着的，可以是直接使用的。
3.新式類和舊式類
①新式類：廣度優先，從最接近的上一個類開始，依次往上尋找相應的繼承屬性。
②舊式類：深度優先，從最開始的類開始，依次往下尋找相應的繼承屬性。
4.類里面的方法和函數的區別
類里的方法和函數外觀很相似，都采用def hanshu():，但是類的方法里必須要有一個形參，可以是self，可以是a,b,c,d等等，但是在調用的時候，實參里不能傳遞任何值。
5.類的內置方法
①__init__方法（給對象添加特定的屬性）
②__str__方法（返回調用對象的信息）
③__del__方法（當刪除一個對象時，Python解釋器會默認調用這個方法，釋放內存）
④__new__方法（__new__必須要有返回值，返回實例化出來的實例，至少要有一個參數cls）
6.測量對象的引用個數
導入sys模塊，采用sys模塊里的sys.getrefcount(對象),就會返回一個值，但是這個值比實際對象多1。
7.單例模式
確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例，這個類稱為單例類，單例模式是一種對象創建模式，__instance = None，沒有這個實例就創建。
8.內置命名空間，全局命名空間，本地命名空間
①內置命名空間:python運行起來，它們就存在了，內置函數的命名空間都屬於內置命名空間。
②全局命名空間:每個模塊創建它自己所擁有的全部命名空間，不同模塊的全局命名空間彼此獨立，不同模塊中相同名稱的命名空間，也會因為模塊的不同步相互干擾。
③本地命名空間:模塊中有函數或者類，每個函數或者類所定義的命名空間就是本地命名空間，如果函數返回了結果或者拋出異常，則本地命名空間也結束了。
9.公有屬性和私有屬性
①公有屬性：可以被對象和方法直接訪問。
②私有屬性：不能通過對象直接訪問，但能通過方法訪問。
10. 類屬性和實例屬性
（1）類屬性
類屬性就是類對象所擁有的屬性，它被所有類對象的實例對象所共有，只存在一個副本。
類屬性，可以被所有類對象和實例對象訪問，就好比是實例對象的共享屬性稱為類屬性。
在給類添加屬性的時候，該屬性被放入類對象的__dict__魔法字典的鍵值對中。
（2）實例屬性
不可變類型：實例屬性不能左右類屬性，但類屬性能影響實例屬性。
可變類型：實例屬性和類屬性之間可以互相改變。
在給實例添加屬性的時候，該屬性被放入實例對象的__dict__魔法字典的鍵值對中。
11. 類方法和靜態方法
（1）類方法
是類對象所擁有的方法，需要用修飾器@classmethod來標識其為類方法。
第一個參數必須是類對象，一般以cls作為第一個參數。
可以對類屬性進行修改，它不能訪問實例屬性。
可以被類對象和實例對象訪問。
（2）靜態方法
要通過修飾器@staticmethod來進行修飾，靜態方法不需要多定義參數。
它無法訪問實例變量，類，和實例屬性。
可以被類對象和實例對象調用。
12.公有方法和私有方法
①公有方法：調用就可以執行，還可以調用私有方法。
②私有方法：一般表示是比較重要的方法，且一般需要獲得一定條件才可調用，稱為是私有方法。
13.繼承與多繼承
①被繼承者稱為父類 (基類)，繼承者稱為子類 (派生類)。
②在繼承的過程中，父類的私有屬性，私有方法，也就是由雙下划線__test():組成的不能繼承。
③繼承的意義與好處
可以實現代碼復用，但也不是全部復用，可能不用。
實現屬性和方法繼承。
④只有父類的公有方法能訪問父類的私有屬性和私有方法，子類的公有方法沒有訪問權限。
14.重寫與調用
①重寫就是把方法與父類同樣的定義一遍。
②如果發現在繼承的時候，父類的方法的名字就是想要的名字，但不是想要的功能的時候，那么這個時候就可以去重寫。
③調用被重寫：類名.方法(self)，super().方法()。
④每次在繼承的時候，要把__init__()方法繼承下來。
15.多態
是指面向對象程序執行時，相同的信息可能會送給多個不同的類別對象，系統可根據對象所屬類別，引發對應類別方法而有不同的行為。
16.面向對象常見問題
（1）邏輯屬性要用方法來賦值
在給對象設置屬性的時候，直接賦予的話，可能某種情況下會發生不合邏輯的情況，如dog.age = -10，如果用方法來賦值，這樣可以引入判斷，如if new_age >0: self.age = new_age
（2）解耦合
如果類與類之間的耦合性過強，也就是一個類改變，另一個類也需要改變，此時可以定義一個函數，把其中一個類的方法形參傳遞到這個函數中，再在這個函數里返回到類中，這種思維叫做解耦。
（3）工廠方法模式
工廠方法模式讓類的實例化推遲到子類，抽象的CarStore提供了一個創建對象的方法createCar，也叫作工廠方法。
八、異常
1.異常的介紹
解釋器無法繼續執行，出現了一些錯誤的提示，這就是所謂"異常">。
2.捕獲異常
①把可能出現問題的代碼，放在try中。
②把處理異常的代碼，放在except中。
③當捕獲多個異常時，可以把要捕獲的異常的名字，放到except 后，並使用元組的方式進行存儲。
3.異常的傳遞
如果一個異常是在一個函數中產生的，例如函數A---->函數B---->函數C，而異常是在函數C中產生的，那么如果函數C中沒有對這個異常進行處理，就會傳遞到函數B中，以此類推。
4.自定義異常
用raise語句來引發一個異常。異常/錯誤對象必須有一個名字，且它們應是Error或Exception類的子類，拋出異常直接默認raise 。
5.assert斷言語句
assret是語句等價於布爾真的判斷，發生異常就意味着表達式為假，當條件不滿需就會報錯。
九、模塊
1.模塊的介紹
模塊就好比是工具包，要想使用這個工具包中的工具(就好比函數)，就需要導入這個模塊。
2.制作模塊
為了讓我們自己寫的模塊被python解釋器知道，需要用sys.path.append("路徑")，但這種情況下，比如在交互模式下，如果關閉了，再開啟，還要重新告知。
常用方法：設置PYTHONPATH環境變量。
vim /etc/profile export PATH = /home/jack/python:$PAT
3.__all__控制模塊的導入行為
from test import *時，為了防止把不需要的模塊導入，在模塊里邊新建一個變量__all__,放上將來要使用的函數，類，全局變量的名字，如果不放，別人就無法使用__all__ =["Tset","test"]。
4. __init__.py控制包的導入行為
①包將有聯系的模塊組織在一起，即放到同一個文件夾下，並且在這個文件夾創建一個名字為__init__.py文件，那么這個文件夾就稱之為包。
②這個__init__.py控制着包的導入行為，在這個文件中， 定義一個__all__變量，它控制着 from 包名 import *時導入的模塊，如__all__ = ["sendmsg"]。
5.模塊發布
①編輯setup.py
from distutils.core import setup setup(name="dongGe", version="1.0", description="dongGe's module"，author="dongGe",py_modules=['test.sendmsg', 'test.recvmsg'])
②構建模塊
python/python3 setup.py build
③生成發布壓縮包
python/python3 setup.py sdist
6.模塊安裝使用
①找到模塊的壓縮包。
②解圧。
③進入文件夾。
④執行命令python setup.py install。
⑤模塊的引入。
from 模塊名 import 模塊名或者*
7.給程序傳參數
import sys name = sys.argv[1]
8.循環導入
①循環導入就是程序在導入某個模塊的過程中，該模塊里的函數又需要導入自身的這個模塊，如此進入死循環。
②避免循環導入:所有在開發的過程中，開發者們寫的模塊不能相互調用，即應該相互隔開，然后由架構師來負責整體的模塊調用使用，也就是上下設計分層，降低耦合。
9.重新導入模塊
模塊被導入后，如果某一方更新了這個模塊，但是import module不能重新導入模塊，重新導入需用from imp import *,然后再使用reload(test)即可重新導入。
十、Python基礎補充
1.常用關鍵字
if/else/for/break/import/class/None/not/in/from/return/elif/and/or/True False/try/except/global/lambda/pass/raise/del/def/continue/finally/as/while
2.靜態語言
先確定功能，再執行。
3.動態語言
寫完代碼，運行的一霎那，功能才被確定。
4.輸入強制轉換為公式
如在轉換輸入類型的時候使用func_new = eval(func_new)就可轉換成公式，即所有的輸入都將轉換為輸入，與int是一個道理。
5.is和==的區別
①判斷兩者內容用＝＝。
②判斷兩者是否指向同一個用is。
③如果是數字則在-5到+125，==和is都為True，過了這個范圍兩者就不指向一個對象了。