在學習一段時間Python后，對Python基礎知識有了一定了解。下面對日常基礎知識進行簡單總結：
1. 避免‘\n’等特殊字符的兩種方式:
1）利用轉義字符'\' 2）利用原始字符'r/R' print r'This is \n and \now'
2. 單行注釋，使用一個#
#hello Python 多行注釋，使用三個單引號（或三個雙引號），如： '''hello python hello world''' 或 """hello python hello world""" 另外跨越多行的字符串。也可以使用三個單引號或三個雙引號，如： '''......''' 或者 """......"""
3. 字符串中嵌入雙引號等特殊符號
1）利用轉義字符'\'
2）使用單引號括起這個字符串。
print ('i l"o"ve fis.com')
4. 條件分支
if condition: 條件為真執行的操作 else: 條件為假執行的操作 if condition: action elif condition: action else: action python可以有效避免"懸掛else"（if else對應關系出錯） 條件表達式（三元操作符） small = x if x<y else y 如果x<y ,small=x.否則small=y 斷言assert：當這個關鍵字后面的條件為假，程序自動崩潰並拋出異常 assert 3>4 可以利用他置入檢查點
5. while條件
條件為真執行的操作
for 目標 in 表達式：
循環體, 例：
favorite='fishc'
for i in favorite:
print(i,end='')
range([start,] stop[,step=1])
生成一個從start參數的值到stop參數值的數字序列
break：終止當前循環體。跳到外層程序
continue:終止本輪循環，開始下一輪循環（if condition true）
6. and邏輯操作符可以將任意表達式連接在一起，並得到一個布爾類型值
7. 引入外援
1）random模塊 2）randint(),返回一個隨機的整數 import random 或 from random import randint() secret=random.randint(1,10)
8. python數據類型
1）數值類型:整型、布爾類型、浮點型、e記法（1.5e10）
2）類型轉換：
int()轉換為整數
str()轉換為字符串
float()轉換為浮點數
3）獲取關於類型的信息：
type()函數
a=520
type(a)
isinstance()函數
a=12
isinstance(a,int) --->返回true
isinstance(a,str) -->返回false
9. Python值常用操作符
+ - * / % **（冪運算） //(地板除法,結果偏小)
比較操作符 > < >= <=
邏輯操作符 and or not
優先級：
冪運算**
正負號 + -
算術操作符 * / //
+ -
比較操作符 < > =
邏輯擦作福 not and or
10. 列表可以把整數、浮點數、字符串等打包在一起。數組卻不能！
創建一個普通列表：
member = ['小白兔','小布丁','黑夜']
創建一個混合列表：
MyList=[1,'小白兔'，3.12，[1,2,3]]
創建空列表：
empty=[]
向列表添加元素：
append():
member.append('福祿娃') #只能添加一個。末尾添加
extend():
member.extend(['test','test1']) #只能以列表形式添加.末尾添加
insert():
member.insert(1,'牡丹') #第一位插入牡丹
列表中獲取元素：使用索引index。
MyList[1]
列表中刪除元素：使用remove()。
MyList.remove('小白兔')
使用del刪除元素
del MyList[3]
使用pop()刪除元素(根據元素的index索引值刪除)
MyList.pop(1)
列表切片：
使用slice, 如下截取MyList列表中第2到到第5個元素
MyList[1:4]
列表操作符：
>,and,+,*,in/not in
列表的小伙伴：dir(list)
MyList.count('小白兔') #統計元素"小白兔"出現的次數
MyList.index('小白兔') #計算元素"小白兔"所在的索引值（默認從前面開始計算）
列表逆序：使用reverse。
MyList.reverse() #即將列表中的元素全部反過來
列表排序：使用sort。
MyList.sort() #默認升序
采用MyList.sort(func,key)
MyList.sort(reverse=True) #降序
MyList.sort(reverse=False) #升序。相當於MyList.sort()
11. 元組不可改變的列表
和列表的主要不同點：
1）創建和訪問一個元組： MyTuple=("ha","he","hei")
列表用 Mylit=["ha","he","hei"]
2）元組不可修改數值
3）更新和刪除一個元組：MyTuple=("ha","he","hei")+("qq","vv","uj")
del MyTuple
4）IN/NOT IN，關系操作符，邏輯操作符，乘號操作符，連接操作符
12）字符串的各種內置方法
str1='i love fishc.com'
a=str1[:6] + '插入的字符串'+str1[6:]
capitalize()： str2.capitalize()
casefold()--->全部小寫 str2.casefold()
center(width)-->居中，不足空格填充
count(sub[,start[,end]])-->返回sub在string中出現的次數
endswith(sub[,start[,end]])-->以sub結束？
startswith(prefix[,start[,end]])-->以prefix開頭
expandtabs([tabsize=8])-->將tab鍵轉換為空格
find(sub[,start[,end]])-->sub是否在字符串中出現
rfind(sub)...
index(sub[,start[,end]])-->跟sub一樣，不過會產生異常
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)-->不帶參數以空格做分隔符
swapcase()-->字符串大小寫翻轉
zfill(width)-->返回長度為width的字符串，不夠補充空格
13）字符串格式化 replacement
"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)
"{a} love {b}.{c}".format(a="i",b="fishc",c="com")
"{0} love {b}.{c}".format("i",b="fishc",c="com")
格式化符號含義：
%c:格式化字符及其ASCII碼
'%c %c %c' % (97,98,99)
%s:格式化字符串
%d:格式化整數
%o:格式化無符號八進制數
%x:格式化無符號十六進制數 %X:...(大寫)
%f:格式化定點數，可指定小數點后的精度
%e:用科學技術發格式化定點數===%E
%g:根據值的大小決定使用%f或%e===%G
格式化操作符輔助命令：
m.n ：m是顯示的最小總寬度，n是小數位精度
- ：用於左對齊
+ ：在正數面前添加正號
# ：在八進制面前顯示0，在十六進制面前顯示0x
0 ：空格用0填充
字符串轉義字符
\a:發出系統響鈴聲
\b、\t、\n
14）序列
列表、元組和字符串的共同點：
a）都可以通過索引
b）索引值從零開始
內置方法：
list（）-->help-->轉換為序列
list()
a=list()
list(iterable)
b='i love fishc.com'
b=list(b)
tuple([iterable])-->把一個可迭代對象轉換為元組
b=tuple(b)
str(obj)-->把obj對象轉換為字符串
len(obj)-->返回obj的長度
max(序列/元組) / min(序列/元組)
sum(iterable[,start=0])-->返回序列iterable。。的總和
sorted(序列/元組)-->排序
reversed(序列/元組)-->返回一個迭代器對象
list(reversed(序列/元組))-->返回序列
enumerate(序列/元組)-->返回一個迭代器對象
list(enumerate(序列/元組))-->返回數組形式列表
zip（a,b）-->合並成以元組形式的列表
list(zip(a,b))
15）函數
定義：def Myfunction():
print('this is my first function')
調用：Myfunction()
函數的參數：
def Myfunction(name,age):
print(name+age+'test')
Myfunction('gncao'，‘age’)
函數的返回值:
return value
形參（parameter）：函數定義時的參數
實參（argument）：實際傳遞的參數
函數文檔：在函數中實現
在函數體中用 '' 或 #
查看函數文檔: a） functionname.__doc__ （四個下划線）
b） help(functionname)
關鍵字參數：避免參數出亂
def Myfunction(words,name):
......
Myfunction(words='words123',name='name123')
默認參數:
def Myfunction(name='name123',words='words123')
......
收集參數：在參數前面加上*號
def test(*params):
print('參數的長度是:',len(params))
print('第二個參數是:',params[1])
test(1,'小甲魚',2,4,5,6,7)
def test(*params,exp):
print('參數的長度是:',len(params),exp)
print('第二個參數是:',params[1])
test(1,'小甲魚',23,4,2,5,7,exp=0)
16）函數有返回值，過程沒有返回值
17）函數變量作用域（可見性）
局部：local-->函數內部定義的變量，局部可用 全局：global-->全局可訪問 當在函數內部試圖修改全局變量時，則會在函數內部新建一個跟 全局變量名相同的局部變量
18）內嵌函數和閉包
global關鍵字：
def myfun():
global count ->>>全局變量
count=10
print(count)
內嵌函數:
def fun1():
print('fun1()正在被調用...')
def fun2():
print('fun2()正在被調用')
fun2()
只能通過fun1()訪問fun2()
閉包:在一個內部函數中，對外部函數的變量的引用。成內部函數為閉包
def funx(x):
def funy(y):
return x * y
return funy
調用方式:
i=funx(8)
i(5)
或
funx(4)(5)
通過關鍵字nonlocal可以使得內部函數調用外部函數變量。
def fun1():
x=5
def fun2():
nonlocal x
x*=x
return x
return fun2()
19，遞歸：
recursion（）
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
number=int(input('請輸入一個整數:'))
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)
但是遞歸的效率比較低
20）字典（key-value）
映射/序列
例1：
dict1={'李寧':'一切皆有可能','耐克':'just do it','阿迪達斯':'impossible is nothing'}
print('李寧的口號是:',dict1['李寧'])
例2:
dict3=dict((('f',70),('i',105)))
例3:
dict4=dict(小甲魚='編程改變世界',test='test')
dict4['小甲魚']='修改小甲魚對應的value' -->如果沒有該KEY，則會自動添加一個KEY
字典的內建方法:
a）
dict2['key']-->訪問字典的元素
b）
fromkeys(s[,v]) -->創建或查詢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對應的value
dict.get(key,'text')-->打印key對應的value，如果不存在，則打印text
in操作符 --> key in dict2
clear() -->dict.clear() -->清空dict的數據
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) -->更新字典
21）集合 --->唯一性
num={1,2,3,4,5}
set()-->set1=set(列表/元組/字符串)
不支持索引
訪問集合中的值:
使用for循環一一查找
使用IN 或者 NOT IN
add()-->set1.add(value)
remove()-->set1.remove(value)
不可變集合:
num3=frozenset(元組/列表)
22）文件
輸入-->處理-->輸出
內存--->磁盤
open()打開文件:
open('filename/path',mode='rwxabt+U')
文件對象方法:
f.close() -->關閉文件
f.read(size=-1) -->從文件讀取size個字符
f.readline() -->以寫入模式打開，如果文件存在，則在末尾添加
f.write(str) -->將str寫入文件
f.writelines(seq) ->向文件寫入seq序列。seq應該是一個返回字符串序列
f.tell() -->返回當前的位置。書簽
f.seek(offset,from) -->在文件中移動文件指針，從from偏移offset字節
for each in f: ---->瀏覽整個文件
print(each)
23）文件系統
模塊：打包的文件系統 os模塊： 常用方法： os.getcwd():返回工作目錄 os.chdir(path):改變工作目錄 os.listdir(path=''):列出文件目錄 os.mkdir(path):創建目錄 os.makedirs(path):創建遞歸目錄 os.remove(path):刪除文件 os.removedirs(path):遞歸刪除 os.rename(old,new):文件重命名 os.system(command):運行系統的shell命令 os.curdir:指代當前目錄.等價於‘。’ os.pardir:指代上一級目錄 os.sep:輸出操作系統的路徑分隔符 os.linesep:當前平台使用的行終止符 os.name:指出當前使用的操作系統
24）永久存儲
存放：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
25）異常處理
常見標准異常:
AssertionErron/AttributeError/EOFError/IndexError/KeyError
/NameError/OSError/OverflowError/SyntaxError/TypeError/ZeroDivisionError
捕獲異常：
try:
檢測范圍
except Exception[as reason]:
出現異常后的處理代碼 print('代碼')
except Exception[as reason]；
出現異常后的處理代碼 print('daimai'+ str(reason))
except (Error1,Error2):
處理異常的代碼
try:
檢測范圍
except Exception[as reason]:
處理異常的代碼
finally:
無論如何都會處理的代碼
raise語句拋出異常
raise Exception('指示代碼')
26）豐富的else語句和簡潔的with語句
else配合其他語句產生更多的功能
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))
27）圖形用戶界面編程:EasyGui
導入模塊三種方式:
a）import easygui
easygui.msgbox('test')
b）from easygui import *
msgbox('test')
c）import easygui as g
g.msgbox('test')
建議不要再IDLE上運行EASYGUI
28）類和對象
關鍵詞class
class Turtle:
#屬性
color='green'
weight=10
#方法:
def climb(self)
print('climb tree')
調用:
tt=Turtle() -->創建對象
tt.climb() -->調用方法
oo=面向對象
oo的特征：
1，封裝
2，繼承
class mylist(list):
pass --->表示只繼承父類，不做其他任何改動
list2=mylist()
3，多態
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) --->構造方法
>>> 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 --->名字改編，名字重整
私有變量:在變量名或函數名前加上'__'雙下划線
訪問私有變量方法:
1,在類內定義方法，間接訪問私有變量
2,._類名__變量名
6，繼承
class derivedclassname(basename):
....
如果子類中出現和父類相同的方法，則覆蓋掉父類的方法
不想覆蓋掉父類的方法：
1，調用未綁定的父類方法
def __init__(self):
fish.__init__(self) ----》先調用父類同名的方法
self.hungry=True
2，使用super函數
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，一些相關的BIF：
issubclass(class,classinfo)
1,一個類被認為是自己的子類
2，classinfo可以是類對象組成的元祖，只要class與其中任何一個候選類的子類，則返回TRUE
isinstance(object,classinfo)
檢查對象是否屬於classinfo類
1，如果第一個參數不是對象，則永遠返回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)設置屬性，設置定義好的屬性
獲取屬性的方法，設置屬性的方法，刪除屬性的方法
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
29）魔法方法（構造和析構）
特點：
1，魔法方法總是被雙下划線包圍，例如__init__
2，魔法方法是面向對象python的一切
3，魔法方法的魔力體現在他們總能夠在適當的時候被自動調用
構造方法：
__init__(self[,...]) -->返回值一定是NONE
用在實例初始化
__new__(cls[,...]) --->第一個初始化的方法
當繼承一個不可修改屬性的類時，則調用此方法修改屬性
class capstr(str):
def __new__(cls,string):
string=string.upper()
return str.__new__(cls,string)
析構方法：
__del__(self) 當數據不適用時，調用此方法
只有在調用了該對象的所有實例都消失時才會產生此方法
30）魔法方法：算術運算
__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)
31）網絡socket
socket提供較為底層的網絡連接及數據傳輸功能
tcp socket/udp socket/unix socket
整個通信過程三步走：
a）客戶端連接服務器：
導入模塊：
import socket
創建tcp類型的socket:
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
建立到指定ip地址、端口的tcp連接
c.connect(('211.121.12.43',80))
在系統上使用netstat命令查看新建的連接:
關閉連接：
c.close()
b）服務器端監聽：
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() -->創建socket和客戶端通信
cs.sendall('replay')
cs.close()
c）客戶端收發數據:
import socket
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
c.connect(('211.121.12.43',80))
向服務端發送‘hello’
c.send('hello')
讀取服務端回復數據:
c.recv(1024)
c.close()
32）HTTP庫實現HTTP協議
導入httplib模塊：
import httplib
創建http實例，指定連接主機名和端口：
http=httplib.HTTPConnection('itercast.com',80)
指定要獲取的URI:
http.request('GET','/ask') -->get方法獲取指定數據，ask表示要訪問的頁面
輸出返回的網頁body內容：
print http.getresponse().read()
關閉連接：
http.close()
更簡單的urllib庫：
導入urllib模塊
import urllib
創建一個opener的實例
opener=urllib.build_opener()
打開指定的url
f=opener.open('http://www.baidu.com/ask')
讀取返回內容
f.read()
33）python連接mysql的模塊
import MySQLdb
conn=MySQLdb.connect(user='root',passwd='',host='127.0.0.1') --->連接mysql，默認是localhost
創建游標，通過游標發送sql指令
cur=conn.cursor()
conn.select_db('database-name') --》連接數據庫,本例用week
cur.execute('insert into userinfo(name,age) value('milo',20)') --》執行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') -->刪除數據
cur.execute('select * from userinfo') -->查詢數據，但是不能直接顯示，使用以下方法可以查看
cur.fetchone()-->在python上顯示一行數據
cur.scroll(0,'absolute')-->移動指標,此為絕對方式
cur.fetchmany(15)-->在python上顯示15條數據.需要輸入數據。必須先查詢
cur.fetchmany(cur.execute('select * from userinfo')) -->通過一條命令顯示數據
cur.close() -->關閉游標的連接
conn.close() --->關閉數據庫連接
34. Python腳本中 if __name__ == '__main__' 的正確理解
if __name__ == '__main__': 代碼的功能(作用)
一個python文件通常有兩種使用方法，第一是作為腳本直接執行，第二是 import 到其他的 python 腳本中被調用（模塊重用）執行。因此 if __name__ == '__main__'的作用就是控制這兩種情況執行代碼的過程，在 if __name__ == '__main__'下的代碼只在第一種情況下才會被執行，而 import 到其他腳本中是不會被執行的。如下示例：
1）直接執行python腳本
[root@xiaobao ~]# cat kevin.py
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
print("My Name Is RuXiaoBao")
if __name__ == '__main__':
print ("This is Test")
直接執行這個kevin.py腳本，如下可以看到：成功打印了兩行字符串。
即，if __name__=="__main__": 語句之前和之后的代碼都被執行。
[root@xiaobao ~]# python kevin.py
My Name Is RuXiaoBao
This is Test
2）import到其他python腳本中執行
[root@xiaobao ~]# cat bobo.py
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
import kevin
print "hahaha"
將kevin模塊import導入到bobo.py腳本中，接着執行bobo.py腳本
可以看到kevin模塊中if __name__=="__main__": 后的代碼塊內容沒有被執行！只執行了它之前的代碼塊內容。
[root@xiaobao ~]# python bobo.py
My Name Is RuXiaoBao
hahaha
if __name__ == '__main__': 的運行原理
每個python模塊（python文件，也就是此處的kevin.py和import kevin）都包含內置的變量 __name__, 當該模塊被直接執行的時候，__name__ 等於文件名（包含后綴.py ）； 如果該模塊 import 到其他模塊中，則該模塊的 __name__ 等於模塊名稱（不包含后綴.py）。而 "__main__" 始終指當前執行模塊的名稱（包含后綴.py）。 進而當模塊被直接執行時，__name__ == 'main' 結果為真。為了進一步說明，可以在 kevin.py 腳本的 if __name__=="__main__": 之前加入 print(__name__)， 即將 __name__ 打印出來。
結論：
if __name__ == '__main__': 這句代碼：
1. 多用在入口文件中，控制用戶必須執行入口文件才會把整個程序跑起來，如果去執行別的文件啟動程序就不會正常啟動導致出現錯誤！ 2. 獲取引入模塊的文件名