文章目錄
基礎語法部分Ⅱ
七、if…elif…else
格式要嚴謹，用法如下：
if x1: #if放在第一個
print(...)
elif x2: #elif可以多個，可有可無，且必須加條件
print(...)
elif x3:
print(...)
else: #else放在最後，可有可無，且不可加條件。當前邊的條件都不滿足時，執行該語句
print(...)
#滿足其中一個條件則執行其條件下的語句，不滿足則一直往下判斷。
八、while循環
while循環每次先判斷 x < N，如果爲True，則執行循環體的代碼塊，否則，退出循環。
x = 0
while x<10:
print(x)
x = x + 1
九、for循環 / 遍歷list、dict
(1) range()函數
python的內置函數，它可以有三個參數：range(a, b, c)
a: 計數從a開始。不填時，默認從0開始。
b: 計數到b結束，不包括b。
c: 計數的間隔，不填時默認爲1。
它最常用來遍歷list、dict等：
list1 = [1, 1, 2.0, '3']
dict1 = {1: 'one', 2: 'two', 3: 'three'}
#遍歷list1中的元素
for i in list1:
print(i)
for i in range(len(list1)): #把list的每個元素迭代出來
print(list1[i])
for i in dict1: #迭代dict1的key值，若要得到value值，還要用dict[key]的方式
print(i,dict1[i])
有沒有更簡單的方法遍歷dict的value？
用range()生成列表
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
條件過濾生成列表
如果我們只想要偶數的平方，不改動 range()的情況下，可以加上 if 來篩選：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
多層表達式生成列表
for循環可以嵌套，因此，在列表生成式中，也可以用多層 for 循環來生成列表。
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
翻譯成循環代碼就像下面這樣：
list2 = []
for m in 'ABC':
for n in '123':
list2.append(m + n)
(2) dict 的 values()方法 / itervalues()方法
這個方法把dict轉換成一個包含所有value的list，這樣，我們迭代的就是 dict的每一個 value：
dict1 = {1: 'one', 2: 'two', 3: 'three'}
for i in dict1.values(): #換成dict1.itervalues()效果一樣
print(i) #打印出來的是dict1中的所有value值
這兩個方法的不同之處是：
values() 方法實際上把一個 dict 轉換成了包含 value 的list。
但是 itervalues()方法不會轉換，它會在迭代過程中依次從 dict 中取出 value，所以 itervalues() 方法比 values() 方法節省了生成 list 所需的內存。
(3) dict的items()方法 / iteritems()方法
此方法可以同時迭代key和value：
>>> dict1 = {1: 'one', 2: 'two', 3: 'three'}
>>> print(dict1.items())
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
可以看到，items() 方法把dict對象轉換成了包含tuple的list，我們對這個list進行迭代，可以同時獲得key和value：
>>> dict1 = {1: 'one', 2: 'two', 3: 'three'}
>>> for k,v in dict1.items():
... print(k,':',v)
1 : one
2 : two
3 : three
和 values() 有一個 itervalues() 類似， items() 也有一個對應的 iteritems()，iteritems() 不把dict轉換成list，而是在迭代過程中不斷給出 tuple，所以， iteritems() 不佔用額外的內存。
十、print()輸出格式
(1) 格式符
| 格式符+類型碼 | 含義 |
|---|---|
| %s | 字符串顯示 |
| %f | 浮點數顯示 |
| %d | 整數顯示 |
這些格式符就是用來佔位置的，str % ()。用法示例：
>>> print('%s%d'%('數字：',0))
數字：0
>>> print('%d，%d，%d'%(0,1,0))
0，1，0
>>> str1 = 'Python'
>>> print('I use %s.'% str1)
I use Python
(2) end參數
print()函數中有一個end參數，實參是’str’類型，默認爲end=’\n’，是用來控制換行行數和結尾字符。所以我們之前print之後都會換行。用法示例：
>>> print(1,end='23')
123
>>> print('我不要換行',end='')
我不要換行
(3) format()格式化函數
format()函數用來佔位的是大括號{}，不用區分類型碼（%+類型碼）。
具體的語法是：str.format()，而不是之前提到的str % ()。
而且，它對後面數據的引用更靈活，不限次數，也可指定對應關係。用法示例：
>>> print('\n{}{}'.format('數字：',0)) # 優勢1：不用擔心用錯類型碼。
數字：0
>>> print('{}，{}'.format(0,1)) # 不設置指定位置時，默認按順序對應。
0，1
>>> print('{1}，{0}'.format(0,1)) # 優勢2：當設置 指定位置 時，按指定的對應。{}裏的數字是format()括號裏參數對應的索引
1，0
>>> x0 = 6
>>> x1 = 7
>>> print('{0}，{1}，{0}'.format(x0,x1)) # 優勢3：可多次調用format後的數據。
6, 7, 6
十一、異常處理：try…except…
爲了不讓一些無關痛癢的小錯影響程序的後續執行，Python給我們提供了一種異常處理的機制，可以在異常出現時即時捕獲，然後內部消化掉，讓程序繼續運行，使用方法及用法示例如下：
try:
<語句> #運行別的代碼
except <名字>：
<語句> #如果在try部份引發了'name'異常
except <名字>，<數據>:
<語句> #如果引發了'name'異常，獲得附加的數據
else:
<語句> #如果沒有異常發生
try:
#先嚐試執行下列代碼
age = int(input('請輸入一個數字：'))
except ValueError:
#除非發生報錯（except後面跟報錯類型）就執行下面的代碼
print('要輸入數字嗷')
關於Python的所有報錯類型，有需要的話可以點擊這裏查閱。
十二、函數
(1) 函數調用
Python內置了很多有用的函數，我們可以直接調用。
要調用一個函數，需要知道函數的名稱和參數，比如求絕對值的函數 abs，它接收一個參數。也可以在交互式命令行通過 help(abs) 查看abs函數的幫助信息。調用函數的時候，要按參數的位置傳參。如果傳入的參數數量不對，會報TypeError的錯誤
>>> abs(-1)
1
>>> abs(1,-1)
TypeError: abs() takes exactly one argument (2 given)
點擊查閱更多python內置函數(#.#)
(2) 變量作用域
在函數內部定義的變量，只在函數內部有效。global語句可以將局部變量聲明爲全局變量。通過例子來說明：
def egg():
quantity = 108
egg()
print(quantity)
#會報錯，不能在函數外部（全局作用域）使用函數內的局部變量
#-------------------------------------------------
quantity = 108
def egg():
print(quantity)
#quantity = 108 也可以在這裏定義全局變量
egg()
#函數內的局部作用域，可以訪問全局變量
#-------------------------------------------------
def egg():
global quantity
quantity = 108
egg()
print(quantity)
#global語句可以將局部變量聲明爲全局變量
(3) 自定義函數
定義一個函數要使用 def 語句，依次寫出函數名、括號、括號中的參數和冒號:，然後，在縮進塊中編寫函數體，函數的返回值用 return 語句返回。
自定義一個求絕對值的 my_abs 函數爲例：
def my_abs(x):
if x >= 0:
return x
else:
return -x
然後就可以直接調用my_abs()函數了。
如果沒有return語句，函數執行完畢後也會返回結果，只是結果爲 None。
return None可以簡寫爲return。
(4) 多返回值
有多個返回值時，實際上也是一個單一值，返回值是一個tuple類型！
def xxx():
x = input()
y = input()
return x, y
x, y = xxx() #多個變量可以同時接收一個tuple，按位置賦給對應的值
(5) 默認參數
如前邊講的print()函數有默認參數end。
由於函數的參數按從左到右的順序匹配，所以默認參數只能定義在必需參數的後面
>>> def xxx(x, y=2):
... print(x,y)
>>> xxx(1) #不傳入默認參數時，y按默認設置的值
1 2
>>> xxx(1,1) #傳入額外的參數來覆蓋默認參數y的值
1 1
(6) 可變參數和關鍵字參數*args和**kwargs
*args：表示就是將實參中按照位置傳值，多餘的值都給args，且以元組的方式呈現。
**kwargs：表示就是形參中按照關鍵字傳值，多餘的值都給kw，且以字典的方式呈現。
同時使用*args和**kwargs時，必須*args參數列要在**kwargs前，否則會報錯。
示例：
def f(x, *args, **kwargs):
x = x
args = args
kw = kwargs
print('x =',x)
print('args =',args)
print('kw =',kw)
print()
f(1, 2, 3)
#x = 1
#args = (2, 3)
#kw = {}
f(0, a=1, b=2, c=3)
#x=0
#args = ()
#kw = {'a': 1, 'b': 2, 'c': 3}
f(0, 1, 2, c=3)
#x=0
#args = (1, 2)
#kw = {'c': 3}
十三、類與對象
這裏只大概整理後邊爬蟲會用到的相關知識。
(1) 定義類、創建實例對象
把具有一類相同屬性的對象封裝成一個類。在Python中，類通過 class 關鍵字定義。
按照 Python 的編程習慣，類名以大寫字母開頭，緊接着是(object)，表示該類是從哪個類繼承下來的。創建實例使用 類名+()。
接下來以一個Person類爲例：
class Person(object):
address = 'Earth' #類屬性
pass
#有了Person類的定義，就可以創建出具體實例
p1 = Person()
p2 = Person()
(2) 初始化實例屬性
類有一個特殊的__init__()方法，當創建實例時，__init__()方法被自動調用。__init__()方法的**第一個參數必須是 **self（也可以用別的名字，但建議使用習慣用法），後續參數則可以自由指定，和定義函數沒有任何區別。
class Person(object):
def __init__(self, name, gender, birth):
self.name = name #實例屬性name
self.gender = gender #實例屬性gender
self.birth = birth #實例屬性birth
#相應地，創建實例時，就必須要提供除 self 以外的參數：
p1 = Person('p1', 'Male', '2000-1-1')
p2 = Person('p2', 'Female', '2001-2-2')
#通過'實例對象名.實例屬性名'來引用實例屬性值
print(p1.name) #輸出p1的名字
print(p2.birth) #輸出p2的出生日期
區別類屬性和實例屬性：
綁定在一個實例上的屬性不會影響其他實例，但是，類本身也是一個對象，如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性，並且，所有實例訪問的類屬性都是同一個！
也就是說，實例屬性每個實例各自擁有，互相獨立，而類屬性有且只有一份！。
(3) 定義實例方法
實例的方法就是在類中定義的函數，它的第一個參數永遠是 self，指向調用該方法的實例本身，其他參數和一個普通函數是完全一樣的：
class Person(object):
def __init__(self, name):
self.__name = name #以__開頭的屬性，無法被類外部訪問
def get_name(self):
return self.__name
p1 = Person('xiaoming')
print p1.get_name() #self不需要顯式傳入
#xiaoming
(4) 類的繼承
如果已經定義了Person類，現在需要定義新的Student類，而它很多屬性和Person都有，所以可以直接從Person類繼承，只需要加上新增的屬性：
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score #新增的score屬性
一定要用 super(Student, self).__init__(name, gender) 去初始化父類，否則，繼承自 Person 的 Student 將沒有 name 和 gender。
函數super(Student, self)將返回當前類繼承的父類，即 Person ，然後調用__init__()方法，注意self參數已在super()中傳入，在__init__()中將隱式傳遞，不需要寫出（也不能寫）。
————————每個人都在抱怨生活不易，可是都在默默爲生活打拼————————