a）利用轉(zhuǎn)義字符‘\' 
b）利用原始字符‘r' print r'c:\now' 

#hello Python 
多行注釋，使用三個單引號（或三個雙引號），如： 
'''hello python 
hello world''' 
或 
"""hello python 
hello world""" 
另外跨越多行的字符串。也可以使用三個單引號或三個雙引號，如： 
'''......'''
或者 
"""......""" 

a）利用轉(zhuǎn)義字符‘\' 
b）使用單引號括起這個字符串。print ('i l"o"ve fis.com') 

if condition: 
     條件為真執(zhí)行的操作 
  else: 
     條件為假執(zhí)行的操作 
 
  if condition: 
     action 
  elif condition: 
     action 
  else: 
    action 
 
python可以有效避免“懸掛else”（if else對應(yīng)關(guān)系出錯） 
條件表達式（三元操作符） 
    small = x if x<y else y 
    如果x<y ,small=x.否則small=y 
斷言assert：當這個關(guān)鍵字后面的條件為假，程序自動崩潰并拋出異常 
   assert 3>4 
   可以利用他置入檢查點

條件為真執(zhí)行的操作 
 
for 目標 in 表達式： 
循環(huán)體 
 例：favorite='fishc'
    for i in favorite: 
       print(i,end='') 
 
range([start,] stop[,step=1]) 
生成一個從start參數(shù)的值到stop參數(shù)值的數(shù)字序列 
 
break：終止當前循環(huán)體。跳到外層程序 
continue:終止本輪循環(huán)，開始下一輪循環(huán)（if condition true） 

a）random模塊 
b）randint(),返回一個隨機的整數(shù) 
import random 或 from random import randint() 
secret=random.randint(1,10) 

a）數(shù)值類型:整型、布爾類型、浮點型、e記法（1.5e10） 
b）類型轉(zhuǎn)換： 
   int()轉(zhuǎn)換為整數(shù) 
   str()轉(zhuǎn)換為字符串 
   float()轉(zhuǎn)換為浮點數(shù) 
c）獲取關(guān)于類型的信息： 
   type()函數(shù) 
    a=520 
    type(a) 
   isinstance()函數(shù) 
    a=12 
    isinstance(a,int) --->返回true
    isinstance(a,str) -->返回false

+ - * / % **（冪運算） //(地板除法,結(jié)果偏小) 
比較操作符 > < >= <= 
邏輯操作符 and or not 
   優(yōu)先級： 
     冪運算** 
     正負號 + - 
     算術(shù)操作符 * / // 
         + - 
     比較操作符 < > = 
     邏輯擦作福 not and or 

創(chuàng)建一個普通列表： 
   member = ['小甲魚','小布丁','黑夜'] 
創(chuàng)建一個混合列表： 
   mix=[1,'小甲魚'，3.12，[1,2,3]] 
創(chuàng)建空列表： 
   empty=[] 
向列表添加元素： 
   append(): member.append('福祿娃')-->只能添加一個。末尾添加 
   extend(): member.extend(['test','test1'])-->只能以列表形式添加.末尾添加 
   insert(): member.insert(1,'牡丹')-->第一位插入牡丹 
列表中獲取元素：使用索引index。    mix[1] 
列表中刪除元素：使用remove()。     mix.remove('小甲魚') 
           使用del。         del mix[3]/mix
           使用pop()。        mix.pop()/mix.pop(1) 
列表切片：使用slice。 mix[1:4]/mix[1:]/mix[:4] 
列表操作符：>,and,+,*,in/not in
列表的小伙伴：dir(list) 
          mix.count('小甲魚') 
          mix.index('小甲魚') 
列表逆序：使用reverse。   mix.reverse() 
列表排序：使用sort。     mix.sort() 
       mix.sort(func,key) 
       mix.sort(reverse=True) 

和列表的主要不同點： 
a）創(chuàng)建和訪問一個元組： 大部分用（）/, ；列表用[] 
b）元組不可修改數(shù)值 
c）更新和刪除一個元組：temp = temp[:2] + ('test3',) + temp[2:] 
  del temp 
d）IN/NOT IN，關(guān)系操作符，邏輯操作符，乘號操作符，連接操作符 

str1='i love fishc.com'
a=str1[:6] + '插入的字符串'+str1[6:] 
capitalize()： str2.capitalize() 
casefold()--->全部小寫 str2.casefold() 
center(width)-->居中，不足空格填充 
count(sub[,start[,end]])-->返回sub在string中出現(xiàn)的次數(shù) 
endswith(sub[,start[,end]])-->以sub結(jié)束？ 
startswith(prefix[,start[,end]])-->以prefix開頭 
expandtabs([tabsize=8])-->將tab鍵轉(zhuǎn)換為空格 
find(sub[,start[,end]])-->sub是否在字符串中出現(xiàn) 
rfind(sub)... 
index(sub[,start[,end]])-->跟sub一樣，不過會產(chǎn)生異常 
rindex(sub..)..... 
istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower() 
join(sub):以字符串做分隔符，分割sub 
partion(sub):找到子字符串sub，把字符串分成一個3元組 
replace(old,new[,count]) 
split(sep=none,maxsplit=-1)-->不帶參數(shù)以空格做分隔符 
swapcase()-->字符串大小寫翻轉(zhuǎn) 
zfill(width)-->返回長度為width的字符串，不夠補充空格

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424) 
"{a} love .{c}".format(a="i",b="fishc",c="com") 
"{0} love .{c}".format("i",b="fishc",c="com") 
格式化符號含義： 
  %c:格式化字符及其ASCII碼 
  '%c %c %c' % (97,98,99) 
  %s:格式化字符串 
  %d:格式化整數(shù) 
  %o:格式化無符號八進制數(shù) 
  %x:格式化無符號十六進制數(shù) %X:...(大寫) 
  %f:格式化定點數(shù)，可指定小數(shù)點后的精度 
  %e:用科學技術(shù)發(fā)格式化定點數(shù)===%E 
  %g:根據(jù)值的大小決定使用%f或%e===%G 
格式化操作符輔助命令： 
  m.n ：m是顯示的最小總寬度，n是小數(shù)位精度 
  - ：用于左對齊 
  + ：在正數(shù)面前添加正號 
  # ：在八進制面前顯示0，在十六進制面前顯示0x 
  0 ：空格用0填充 
字符串轉(zhuǎn)義字符 
  \a:發(fā)出系統(tǒng)響鈴聲 
  \b、\t、\n

列表、元組和字符串的共同點： 
  a）都可以通過索引 
  b）索引值從零開始 
內(nèi)置方法： 
   list（）-->help-->轉(zhuǎn)換為序列 
     list() 
       a=list() 
     list(iterable) 
       b='i love fishc.com'
       b=list(b) 
   tuple([iterable])-->把一個可迭代對象轉(zhuǎn)換為元組 
       b=tuple(b) 
   str(obj)-->把obj對象轉(zhuǎn)換為字符串 
   len(obj)-->返回obj的長度 
   max(序列/元組) / min(序列/元組) 
   sum(iterable[,start=0])-->返回序列iterable。。的總和 
   sorted(序列/元組)-->排序 
   reversed(序列/元組)-->返回一個迭代器對象 
   list(reversed(序列/元組))-->返回序列 
   enumerate(序列/元組)-->返回一個迭代器對象 
   list(enumerate(序列/元組))-->返回數(shù)組形式列表 
   zip（a,b）-->合并成以元組形式的列表 
   list(zip(a,b))

定義：def Myfunction(): 
   print('this is my first function') 
調(diào)用：Myfunction() 
函數(shù)的參數(shù)： 
   def Myfunction(name,age): 
   print(name+age+'test') 
   Myfunction('gncao'，‘a(chǎn)ge') 
函數(shù)的返回值: 
   return value 
形參（parameter）：函數(shù)定義時的參數(shù) 
實參（argument）：實際傳遞的參數(shù) 
函數(shù)文檔：在函數(shù)中實現(xiàn) 
在函數(shù)體中用 '' 或 # 
查看函數(shù)文檔: a） functionname.__doc__ （四個下劃線） 
          b） help(functionname) 
關(guān)鍵字參數(shù)：避免參數(shù)出亂 
   def Myfunction(words,name): 
   ...... 
   Myfunction(words='words123',name='name123') 
 默認參數(shù): 
   def Myfunction(name='name123',words='words123') 
   ...... 
 收集參數(shù)：在參數(shù)前面加上*號 
  def test(*params): 
  print('參數(shù)的長度是:',len(params)) 
  print('第二個參數(shù)是:',params[1]) 
  test(1,'小甲魚',2,4,5,6,7) 
 
  def test(*params,exp): 
  print('參數(shù)的長度是:',len(params),exp) 
  print('第二個參數(shù)是:',params[1]) 
  test(1,'小甲魚',23,4,2,5,7,exp=0)

局部：local-->函數(shù)內(nèi)部定義的變量，局部可用 
全局：global-->全局可訪問 
當在函數(shù)內(nèi)部試圖修改全局變量時，則會在函數(shù)內(nèi)部新建一個跟 全局變量名相同的局部變量 

global關(guān)鍵字： 
   def myfun(): 
     global count ->>>全局變量 
     count=10 
     print(count) 
內(nèi)嵌函數(shù): 
   def fun1(): 
     print('fun1()正在被調(diào)用...') 
     def fun2(): 
        print('fun2()正在被調(diào)用') 
     fun2() 
只能通過fun1()訪問fun2() 
閉包:在一個內(nèi)部函數(shù)中，對外部函數(shù)的變量的引用。成內(nèi)部函數(shù)為閉包 
   def funx(x): 
     def funy(y): 
       return x * y 
     return funy 
調(diào)用方式: 
   i=funx(8) 
   i(5) 
   或 
   funx(4)(5) 
 
通過關(guān)鍵字nonlocal可以使得內(nèi)部函數(shù)調(diào)用外部函數(shù)變量。 
   def fun1(): 
     x=5 
     def fun2(): 
       nonlocal x 
       x*=x 
       return x 
   return fun2()

recursion（） 
        def fac(n): 
              if n==1: 
                    return 1 
              else: 
                    return n*fac(n-1) 
        number=int(input('請輸入一個整數(shù):')) 
        result=fac(number) 
        print('%d 的階乘是：%d' % (number,result)) 
 
迭代方法： 
def fab(n): 
  n1=1 
  n2=1 
  n3=1 
 
  if n <1: 
    print('輸入有錯') 
    return -1 
  while ( n-2>0 ): 
    n3=n2+n1 
    n1=n2 
    n2=n3 
    n-=1 
  return n3 
 
result=fab(20) 
if result != -1: 
  print('總共有%d對小兔子誕生：' % result) 
 
遞歸方法： 
def fab(n): 
  if n < 1: 
    print('error') 
    return -1 
 
  if n==1 or n==2: 
    return 1 
  else: 
    return fab(n-1) + fab(n-2) 
 
result=fab(20) 
print('總共有%d對兔子誕生' % result) 
 
但是遞歸的效率比較低

映射/序列 
例1： 
dict1={'李寧':'一切皆有可能','耐克':'just do it','阿迪達斯':'impossible is nothing'} 
 
print('李寧的口號是:',dict1['李寧']) 
 
例2: 
dict3=dict((('f',70),('i',105))) 
 
例3: 
dict4=dict(小甲魚='編程改變世界',test='test') 
dict4['小甲魚']='修改小甲魚對應(yīng)的value'   -->如果沒有該KEY，則會自動添加一個KEY 
 
字典的內(nèi)建方法: 
a） 
dict2['key']-->訪問字典的元素 
b） 
fromkeys(s[,v]) -->創(chuàng)建或查詢key 
dict1.fromkeys((1,2,3)) 
{1: None, 2: None, 3: None} 
dict1.fromkeys((1,2,3),'number') 
{1: 'number', 2: 'number', 3: 'number'} 
c） 
keys()-->dict.keys() -->打印出dict的所有key 
values()-->dict.values() -->打印出dict的所有value 
items()-->dict.items() -->打印出dict所有(key,value) 
get()--> dict.get(key) -->打印key對應(yīng)的value 
dict.get(key,'text')-->打印key對應(yīng)的value，如果不存在，則打印text 
in操作符 --> key in dict2 
clear() -->dict.clear() -->清空dict的數(shù)據(jù) 
copy() -->b=a.copy()  -->拷貝字典 
id(a)-->查看id
pop(key) --> dict.pop(key) -->彈出key 
popitem() -->dict.popitem() -->隨機彈出key 
setdefault() -->dict.setdefault(key) -->新建key 
update()  -->dict.update(dict)  -->更新字典

num={1,2,3,4,5} 
set()-->set1=set(列表/元組/字符串) 
不支持索引 
訪問集合中的值: 
    使用for循環(huán)一一查找     
    使用IN 或者 NOT IN 
add()-->set1.add(value) 
remove()-->set1.remove(value) 
不可變集合: 
num3=frozenset(元組/列表) 

輸入-->處理-->輸出 
內(nèi)存--->磁盤 
open()打開文件: 
open('filename/path',mode='rwxabt+U') 
 
文件對象方法: 
f.close() -->關(guān)閉文件 
f.read(size=-1) -->從文件讀取size個字符 
f.readline() -->以寫入模式打開，如果文件存在，則在末尾添加 
f.write(str) -->將str寫入文件 
f.writelines(seq) ->向文件寫入seq序列。seq應(yīng)該是一個返回字符串序列 
f.tell() -->返回當前的位置。書簽 
f.seek(offset,from) -->在文件中移動文件指針，從from偏移offset字節(jié) 
for each in f:  ---->瀏覽整個文件 
print(each) 

模塊：打包的文件系統(tǒng) 
os模塊： 
常用方法： 
os.getcwd():返回工作目錄 
os.chdir(path):改變工作目錄 
os.listdir(path=''):列出文件目錄 
os.mkdir(path):創(chuàng)建目錄 
os.makedirs(path):創(chuàng)建遞歸目錄 
os.remove(path):刪除文件 
os.removedirs(path):遞歸刪除 
os.rename(old,new):文件重命名 
os.system(command):運行系統(tǒng)的shell命令 
os.curdir:指代當前目錄.等價于‘。' 
os.pardir:指代上一級目錄 
os.sep:輸出操作系統(tǒng)的路徑分隔符 
os.linesep:當前平臺使用的行終止符 
os.name:指出當前使用的操作系統(tǒng) 

存放：pickling 
讀取:unpickling 
首先要導入模塊pickle 
import pickle 
>>> my_list=[1,2,3,'test',[23,43]] 
>>> pickle_file=open('my_list.pkl','wb') --》打開一個pickle文件 
>>> pickle.dump(my_list,pickle_file) --》把my_list導入到pickle_file 
>>>pickle_file.close() 
 
>>> pickle_file=open('my_list.pkl','wb') 
>>> my_list2=pickle.load(pickle_file) -->把pickle_file導入到my_list2 

常見標準異常: 
AssertionErron/AttributeError/EOFError/IndexError/KeyError
/NameError/OSError/OverflowError/SyntaxError/TypeError/ZeroDivisionError
 
捕獲異常： 
try: 
    檢測范圍 
except Exception[as reason]: 
    出現(xiàn)異常后的處理代碼 print('代碼') 
except Exception[as reason]； 
    出現(xiàn)異常后的處理代碼 print('daimai'+ str(reason))     
except (Error1,Error2): 
    處理異常的代碼 
 
try: 
    檢測范圍 
except Exception[as reason]: 
    處理異常的代碼 
finally: 
    無論如何都會處理的代碼 
 
raise語句拋出異常 
raise Exception('指示代碼')

else配合其他語句產(chǎn)生更多的功能 
with語句：縮小工作量: 
沒有使用with前: 
try: 
  f=open('data.txt','r') 
  for each in f: 
    print(each) 
except OSError as reason: 
  print('出錯啦:'+str(reason)) 
finally: 
  f.close() 
使用with后: 
try: 
  with open('data.txt','w') as f: 
    for each in f: 
      print(each) 
except OSError as reason: 
  print('出錯啦:'+str(reason)) 

導入模塊三種方式: 
a）import  easygui 
easygui.msgbox('test') 
b）from easygui import * 
msgbox('test') 
c）import easygui as g 
  g.msgbox('test') 
 
建議不要再IDLE上運行EASYGUI 

關(guān)鍵詞class 
class Turtle: 
    #屬性 
    color='green'
    weight=10 
    #方法: 
    def climb(self) 
        print('climb tree') 
 
調(diào)用: 
tt=Turtle() -->創(chuàng)建對象 
tt.climb() -->調(diào)用方法 
 
 
oo=面向?qū)ο?
oo的特征： 
1，封裝 
2，繼承 
    class mylist(list): 
        pass --->表示只繼承父類，不做其他任何改動     
    list2=mylist() 
3，多態(tài) 
 
 
self-->相當于c++的this指針 
>>> class ball: 
    def setname(self,name): 
        self.name=name 
    def kick(self): 
        print('i am %s,who kicked me????' % self.name) 
a=ball() 
a.setname('test') 
 
 
4，_init_(self) --->構(gòu)造方法 
 
>>> class ball: 
    def __init__(self,name): 
        self.name=name 
    def kick(self): 
        print('i am %s,who kicked me????' % self.name) 
b=ball('test') 
 
 
5,公有和私有 
 
類屬性和方法默認都是公有的 
name mangling --->名字改編，名字重整 
私有變量:在變量名或函數(shù)名前加上'__'雙下劃線      
訪問私有變量方法: 
1,在類內(nèi)定義方法，間接訪問私有變量 
2,._類名__變量名 
 
 
6，繼承 
class derivedclassname(basename): 
    .... 
如果子類中出現(xiàn)和父類相同的方法，則覆蓋掉父類的方法 
不想覆蓋掉父類的方法： 
1，調(diào)用未綁定的父類方法 
     def __init__(self): 
        fish.__init__(self)  ----》先調(diào)用父類同名的方法 
            self.hungry=True 
2，使用super函數(shù) 
     def __init__(self): 
            super().__init__() 
         self.hungry=True     
7，多重繼承 
class derivedclass(base1,base2,base3): 
    ...... 
 
8，拾遺 
Mix-in編程機制 
 
類，類對象，實例對象,實例屬性（static） 
如果屬性的名字和方法的名字相同，則屬性會覆蓋掉方法 
綁定: 
class bb: 
    def printbb(): 
        print('no zuo no die') 
b1=bb() 
b1.printbb() ---->會出錯誤 
 
 
9，一些相關(guān)的BIF： 
 
issubclass(class,classinfo) 
1,一個類被認為是自己的子類 
2，classinfo可以是類對象組成的元祖，只要class與其中任何一個候選類的子類，則返回TRUE 
 
isinstance(object,classinfo) 
檢查對象是否屬于classinfo類 
1，如果第一個參數(shù)不是對象，則永遠返回fasle 
2，如果第二個不是類，則會拋出typeerror的異常 
 
hasattr(object,name) -->測定object中是否有'name‘屬性 
hasattr(c1,'x') 
 
getattr(object,name[,default]) -->如果有屬性返回1，否則返回default 
 
setattr(object,name,value) -->給object中的name屬性賦值vlalue 
 
delattr(object,name) -->刪除object中的name屬性 
 
property(fget=none,fset=none,fdel=none,doc=none)設(shè)置屬性，設(shè)置定義好的屬性 
獲取屬性的方法，設(shè)置屬性的方法，刪除屬性的方法 
class c: 
    def __init__(self,size=10): 
        self.size=size 
    def getsize(self): 
        return self.size 
    def setsize(self,value): 
        self.size=value 
    def delsize(self): 
        del self.size 
    x=property(getsize,setsize,delsize) 
c1=c() 
c1.x    /  c1.x=19   /c1.size

特點： 
1，魔法方法總是被雙下劃線包圍，例如__init__ 
2，魔法方法是面向?qū)ο髉ython的一切 
3，魔法方法的魔力體現(xiàn)在他們總能夠在適當?shù)臅r候被自動調(diào)用 
 
構(gòu)造方法： 
 
__init__(self[,...]) -->返回值一定是NONE 
用在實例初始化 
 
__new__(cls[,...])  --->第一個初始化的方法 
當繼承一個不可修改屬性的類時，則調(diào)用此方法修改屬性 
class capstr(str): 
    def __new__(cls,string): 
        string=string.upper() 
        return str.__new__(cls,string) 
 
析構(gòu)方法： 
 
__del__(self)  當數(shù)據(jù)不適用時，調(diào)用此方法 
只有在調(diào)用了該對象的所有實例都消失時才會產(chǎn)生此方法

__add__(self,other):定義加法的行為'+'
例子： 
>>> class new_int(int): 
    def __add__(self,other): 
        return int.__sub__(self,other) 
    def __sub__(self,other): 
        return int.__add__(self,other) 
 
     
>>> a=new_int(3) 
>>> b=new_int(8) 
>>> a+b  ---->此時a是self，b是other 
-5 
 
__sub__(sub,other):減法 
__mul__(sub,other):乘法 
truediv/floordiv/mod/divmod/pow/lshift/rshift/and/xor/or
divmod(a,b)返回的值是一個元祖：(a//b,a%b)

socket提供較為底層的網(wǎng)絡(luò)連接及數(shù)據(jù)傳輸功能 
tcp socket/udp socket/unix socket 
 
整個通信過程三步走： 
a）客戶端連接服務(wù)器： 
導入模塊： 
import socket 
創(chuàng)建tcp類型的socket: 
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
建立到指定ip地址、端口的tcp連接 
c.connect(('211.121.12.43',80)) 
在系統(tǒng)上使用netstat命令查看新建的連接: 
關(guān)閉連接： 
c.close() 
 
b）服務(wù)器端監(jiān)聽： 
import socket 
s=socket.socket(socket.AF_INET,socket.sock.SOCK_STREAM) 
s.bind(('127.0.0.1',80)) 
s.listen(1) 
while True: 
    cs,ca=s.accept() -->創(chuàng)建socket和客戶端通信 
    cs.sendall('replay') 
    cs.close() 
 
c）客戶端收發(fā)數(shù)據(jù): 
import socket 
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
c.connect(('211.121.12.43',80)) 
向服務(wù)端發(fā)送‘hello' 
c.send('hello') 
讀取服務(wù)端回復數(shù)據(jù): 
c.recv(1024) 
c.close()

導入httplib模塊： 
import httplib 
創(chuàng)建http實例，指定連接主機名和端口： 
http=httplib.HTTPConnection('itercast.com',80) 
指定要獲取的URI: 
http.request('GET','/ask') -->get方法獲取指定數(shù)據(jù)，ask表示要訪問的頁面 
輸出返回的網(wǎng)頁body內(nèi)容： 
print http.getresponse().read() 
關(guān)閉連接： 
http.close() 
 
更簡單的urllib庫： 
導入urllib模塊 
import urllib 
創(chuàng)建一個opener的實例 
opener=urllib.build_opener() 
打開指定的url 
f=opener.open('http://www.baidu.com/ask') 
讀取返回內(nèi)容 
f.read()

import MySQLdb 
conn=MySQLdb.connect(user='root',passwd='',host='127.0.0.1') --->連接mysql，默認是localhost 
創(chuàng)建游標，通過游標發(fā)送sql指令 
cur=conn.cursor() 
conn.select_db('database-name') --》連接數(shù)據(jù)庫,本例用week 
cur.execute('insert into userinfo(name,age) value('milo',20)') --》執(zhí)行sql語句。insert 
簡單化操作方式: 
sqli='insert into userinfo(name,age,gender) value(%s,%s,%s)'
cur.execute(sqli,('a',37,'male')) 
cur.executemany(sqli,[('test',34,'male'),('test2',36,'female')]) 
cur.execute('delete from userinfo where id=20') -->刪除數(shù)據(jù) 
cur.execute('select * from userinfo') -->查詢數(shù)據(jù)，但是不能直接顯示，使用以下方法可以查看 
cur.fetchone()-->在python上顯示一行數(shù)據(jù) 
cur.scroll(0,'absolute')-->移動指標,此為絕對方式 
cur.fetchmany(15)-->在python上顯示15條數(shù)據(jù).需要輸入數(shù)據(jù)。必須先查詢 
cur.fetchmany(cur.execute('select * from userinfo')) -->通過一條命令顯示數(shù)據(jù) 
cur.close() -->關(guān)閉游標的連接 
conn.close()  --->關(guān)閉數(shù)據(jù)庫連接