作用域

只要內存中存在就可以使用，在有函數棧的情況下，還需要加一個條件。

name = {‘name1‘:‘Carrick‘,‘name2‘,‘Tina‘}

for item in name:

print item -->僅僅是打印，沒有將變量指向item內存空間

print item -->無法打印，沒有變量指向item的內存空間，print不知道該打印哪個內存空間

name = {‘name1‘:‘Carrick‘,‘name2‘,‘Tina‘}

for item in name:

a = item

print a -->可以打印，因為有變量a指向item的內存空間

這個僅僅可以打印name字典的最後一個變量

註意事項：這種for循環中賦值，僅僅可以在python中使用，在其他語言中，for循環的字典會被壓入棧中，當for循環執行完畢，棧會被清空，即使a = item，因為item的內存空間被清空，a找不到內存中的位置，print a也不會成功。因此不要在python的for循環中使用賦值。

三目運算

三目運算是if...else結構的簡寫

if a > b:

name = ‘Carrick‘

else

name = ‘Tina‘

寫為三目運算：

name = ‘Carrick‘ if a > b else ‘Tina‘

PyCharm

PyCharm用專業版，社區版不支持Django

PyCharm使用步驟：

第一步：指定Python解釋器

PyCharm本身沒有自帶解釋器，必須指定Python解釋器，才能正常運行Python程序

第二步：

New Project --> Pure Python --> New --> Python File

第三步：

打斷點，dubug模式運行

run正常模式運行

Python中一切皆對象，對象是由類創建的，對象可以調用相關類的屬性和方法

查找類提供哪些方法：

>>> li = [11,22,33]

>>> type(li) -->查看li所屬類型

<type ‘list‘>

>>> dir(list) -->查看類型提供哪些方法

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__delsli

ce__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getit

em__‘, ‘__getslice__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘,

‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__r

educe__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘

, ‘__setitem__‘, ‘__setslice__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘a

ppend‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘

]

__X__是內置方法，有至少一種執行方法，沒有下劃線的方法是非內置方法，只有一種執行方式

>>> help(list.append) -->查看具體函數的使用方法

Help on method_descriptor:

append(...)

L.append(object) -- append object to end

PyCharm查看python方法的源碼：

敲list，按ctrl點擊list，即可看到python的list的源碼

int類型常用內置方法

int類型賦值

方法一： i = 10

方法二： i = int(10)

方法三：

>>>i = int("F",base=16) --> 16進制賦值

>>> print i

15

加法

>>> n1 = 1

>>> n2 = 2

>>> n1.__add__(n2) ==>等價於n1 + n2

3

另外：

1. 減法，乘法，除法，冪和取模等運算，只要記住n1-n2，n1*n2，n1/n2，n1**n2和n1%n2，不用記具體的函數

2. int還有radd，add相當於n1+n2，radd相當於n2+n1，int類型還有很多r開頭的函數，都是將兩個數字掉個

絕對值

>>> n1 = -9

>>> n1.__abs__() ==>等價於abs(n1)

9

大小比較

>>> n1 = 9

>>> n2 = 8

>>> n1.__cmp__(n2) ==>等價於cmp(n1,n2)

1

返回值為1，說明n1大於n2，返回值為0，說明n1等於n2，返回值為-1，說明n1小於n2

生成商和余數的元組 -->用於網站分頁顯示

>>> n1 = 10

>>> n2 = 3

>>> n1.__divmod__(n2) ==>等價於divmod(n1,n2)

(3, 1)

除法

>>> n1 = 10

>>> n1.__div__(3)

3

int類型轉換為float類型

>>> n1 = 10

>>> type(n1)

<type ‘int‘>

>>> new_n1 = n1.__float__() ==>等價於float(n1)

>>> type(new_n1)

<type ‘float‘>

獲得屬性

只有類中寫有__getatrribute__屬性，敲“.”才能顯示出類中可用的屬性

獲得哈希

x.__hash__() ==>等價於hash(x)

爬蟲中URL很長，一般將URL做hash或者md5，形成一個較短的字符串，便於存放在數據庫中。

在字典中，如果key很長，哈希值用於快速比較key的值

獲得n進制數字

>>> n = 18

>>> n.__hex__() ==>等價於hex(n),獲得十六進制數字

‘0x12‘

>>> n.__oct__() ==>等價於oct(n),獲得八進制數字

‘022‘

整數部分截取 -->對整數無意義

>>> n = 5.2

>>> n.__trunc__()

5

long型和float型的方法和int型方法幾乎一樣

str類型

str定義

str1 = "Carrick" 或者

str1 = str("Carrick")

字符串首字母大寫

>>> name = ‘Carrick‘

>>> name.capitalize()

‘Carrick‘

字符串居中

>>> name = ‘Carrick‘

>>> name.center(20,"*")

‘******Carrick*******‘

查找子串的個數

>>> name = "djkajs;kfljdaksjkds"

>>> name.count("s")

3

>>> name.count("s",8,20) -->指定起始位置和結束位置

2

字符串結尾判斷

>>> name = ‘Carrick‘

>>> name.endswith(‘ck‘)

True

>>> name.endswith(‘ck‘,2,) -->第二個字符到最後一個字符，以ck結尾

True

**將tab轉換為空格

默認情況下一個tab轉換為8個空格

將tab轉換為空格，然後用strip()函數將所有空格去掉，就可以取到配置文件中的參數

>>> name = ‘Carri ck‘ -->中間有tab鍵

>>> name.expandtabs()

‘Carri ck‘

>>> name.expandtabs(1) -->轉換成一個空格

‘Carri ck‘

查找子串的位置：find和index

>>> name = ‘Carrick‘

>>> name.find(‘ri‘)

3

>>> name.find(‘Fairy‘)

-1

>>> name = ‘Carrick‘

>>> name.index(‘ri‘)

3

>>> name.index(‘Fairy‘)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: substring not found

>>>

find找到返回子串第一個字符的位置，找不到返回-1；如果有相同的子串，會返回第一個子串的位置

index找到返回子串第一個字符的位置，找不到報錯

判斷字符串是否為數字或者字母

>>> name = ‘Carrick‘

>>> name.isalnum()

True

>>> name = ‘老畢‘

>>> name.isalnum()

False

是數字或者字符返回True，是其它值返回False

判斷字符串是否為字母

>>> name = ‘Carrick‘

>>> name.isalpha()

True

>>> name = 123

>>> name.isalpha()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: ‘int‘ object has no attribute ‘isalpha‘

>>>

是字母返回True，是其它值報錯

判斷字符串是否為數字

>>> name = 123

>>> name.isdigit()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: ‘int‘ object has no attribute ‘isdigit‘

>>> name = ‘123‘

>>> name.isdigit()

True

是數字返回True，是其它值報錯

判斷字符串是否全是小寫

>>> name = ‘carrick‘

>>> name.islower()

True

>>> name = ‘Carrick‘

>>> name.islower()

False

isupper() 判斷字符串是否全為大寫

isspace() 判斷字符串是否全為空格

轉換為標題

>>> name = ‘hello carrick‘

>>> name.istitle()

False

>>> name.title()

‘Hello Carrick‘

>>> name = ‘Hello Carrick‘

>>> name.istitle()

True

istitle() 判斷字符串是否標題

>>> name = ‘hello carrick‘

>>> name.istitle()

False

>>> name = ‘Hello Carrick‘

>>> name.istitle()

True

標題就是每個單詞首字母大寫

**字符串連接

>>> L = [‘s1‘,‘s2‘]

>>> "_".join(L)

‘s1_s2‘

左對齊ljust()

>>> name = ‘Carrick‘

>>> name.ljust(20,"+")

‘Carrick+++++++++++++‘

右對齊：rjust()

大寫變小寫lower()；小寫變大寫upper()

>>> name = ‘Carrick‘

>>> name.lower()

‘carrick‘

>>> name.upper()

‘CARRICK‘

大寫變小寫，小寫變大寫swapcase()

>>> name = ‘Carrick‘

>>> name.swapcase()

‘cARRICK‘

字符串分割paritition()

>>> name = ‘Carrick‘

>>> name.partition(‘rr‘)

(‘Ca‘, ‘rr‘, ‘ick‘)

**字符替換replace()

>>> name = ‘Carrick‘

>>> name.replace(‘Ca‘,‘ca‘)

‘carrick‘

>>> name = ‘Carrick‘

>>> name.replace(‘r‘,‘hhhh‘)

‘Cahhhhhhhhick‘

replace()會替換所有的字符，不僅僅替換第一個字符
字符轉相乘（python特有的）

>>> name = ‘Carrick‘

>>> name*6

‘CarrickCarrickCarrickCarrickCarrickCarrick‘

字符串格式化

方法一：

>>> name = "I am {0}, I am {1} years old."

>>> name.format(‘Carrick‘,‘34‘)

‘I am Carrick, I am 34 years old.‘

方法二：

>>> name = "I am {ss}, I am {dd} years old."

>>> name.format(dd="34", ss="Carrick")

‘I am Carrick, I am 34 years old.‘

方法三：元組，列表傳參，需要加“*”

>>> L = [‘Carrick‘,34]

>>> name = "I am {0},aged {1}"

>>> name.format(*L)

‘I am Carrick,aged 34‘

方法四：字典傳參，需要加“**”

>>> D = {‘ss‘:‘Carrick‘,‘dd‘:34}

>>> name = "I am {ss},aged {dd}"

>>> name.format(**D)

‘I am Carrick,aged 34‘

解碼和編碼

utf-8和GBK可以通過unicode來相互轉換，不可以直接轉換

>>> ‘無‘

‘\xce\xde‘

>>> str1 = ‘\xce\xde‘

>>> print str1

無

>>> print str1.decode(‘gbk‘) -->指定從哪個編碼解碼

無

>>> print str1.decode(‘gbk‘).encode(‘utf-8‘)

鏃

列表的方法（二）

列表元素出現的次數

>>> L = [66,77,88]

>>> L.count(88)

1

>>> L.count(22)

0

列表擴展

>>> L = [66,77,88]

>>> L.extend([‘Carrick‘,‘Tina‘])

>>> L

[66, 77, 88, ‘Carrick‘, ‘Tina‘]

>>> L.extend(L)

>>> L

[66, 77, 88, ‘Carrick‘, ‘Tina‘, 66, 77, 88, ‘Carrick‘, ‘Tina‘]

列表可以自己擴展自己

列表元素查找

>>> L = [66,77,88]

>>> L.index(66)

0

>>> L.index(22)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: 22 is not in list

列表指定位置插入

>>> L = [66,77,88]

>>> L.insert(0,88)

>>> L

[88, 66, 77, 88]

刪除並返回指定下標的值，不指定下標就彈出最後一個元素

>>> L

[88, 66, 77, 88]

>>> L.pop()

88

>>> L

[88, 66, 77]

>>> L.pop(1)

66

>>> L

[88, 77]

刪除列表第一個值

>>> L = [66,77,88,66]

>>> L.remove(66)

>>> L

[77, 88, 66]

列表翻轉

>>> L = [66,77,88]

>>> L.reverse()

>>> L

[88, 77, 66]

列表元素排序

字母比較ASCII，中文比較Unicode，數字比較大小

>>> ‘無‘

‘\xce\xde‘

>>> str1 = ‘\xce\xde‘

>>> str1.decode(‘gbk‘)

u‘\u65e0‘

>>> str2 = u‘\u65e2‘

>>> print str2

既

>>> li = [‘無‘,‘既‘]

>>> li.sort()

>>> li

[‘\xbc\xc8‘, ‘\xce\xde‘]

unicode的編碼，‘\xce\xde‘是u‘\u65e0‘，‘\xbc\xc8‘是u‘\u65e2‘，因此sort()將大的排在前面

>>> for i in li:

... print i

...

既

無

列表元素刪除

del name[1]是調用__delitem__()方法來執行的

元組和列表的唯一區別，就是列表可以被修改，而元組不能被修改

列表和元組的元素都可以是重復的

元組的元素不能被修改，但是元組的元素的元素可以被修改

字典的key不能重復，value可以重復

元組方法：index(),count()

字典

修改字典，不會在內存中重新開辟一塊空間，只有字符串會

字符串，數字可以作為字典的key，列表不能作為字典的key，元組可以作為字典的key，但是不要這麽做

字符串，數字和類的實例當做字典的key沒有問題

字典根據key獲得value

方法一：字典中沒有值會報錯

>>> d = {‘k1‘:1234}

>>> d[‘k1‘]

1234

>>> d[‘k2‘]

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

KeyError: ‘k2‘

***方法二：字典中沒有值不會報錯

>>> d = {‘k1‘:1234}

>>> d.get(‘k1‘)

1234

>>> d.get(‘k2‘)

>>> print d.get(‘k2‘) -->默認返回值

None

>>> print d.get(‘k2‘,‘OK‘) -->指定返回值

OK

判斷是否為字典

>>> d = {‘k1‘:1234}

>>> type(d) is dict

True

清空字典

>>> D = {1:‘a‘}

>>> D.clear()

>>> D

{}

第一個列表作為字典的key，生成字典

>>> D = {}

>>> D.fromkeys([1,2,3],[4,5,6])

{1: [4, 5, 6], 2: [4, 5, 6], 3: [4, 5, 6]}

有時有個列表，想以列表為key生成字典，就可以

>>> D.fromkeys([1,2,3],[])

{1: [], 2: [], 3: []}

生成一個value為空的字典，然後往裏面插入value即可

判斷key是否在字典中

方法一

>>> D = {1:‘a‘}

>>> D.has_key(1)

True

方法二

>>> 1 in D

True

循環字典

方法一：數據量小的時候可以用，幾萬條數據之內可以用

>>> D = {1:‘a‘,2:‘b‘,3:‘c‘}

>>> for k,v in D.items():

... print k,v

...

1 a

2 b

3 c

方法二：數據量大時用

>>> for k in D:

... print k,D[k]

...

1 a

2 b

3 c

根據key刪除字典元素

方法一：

>>> D = {1:‘a‘,2:‘b‘,3:‘c‘}

>>> D.pop(2)

‘b‘

>>> D

{1: ‘a‘, 3: ‘c‘}

方法二：

>>> D

{1: ‘a‘, 3: ‘c‘}

>>> del D[3]

>>> D

{1: ‘a‘}

隨機刪除字典元素：popitems()，不要使用

根據key查找元素,如果沒有就生成一個None

>>> D = {1:‘a‘,2:‘b‘,3:‘c‘}

>>> D.setdefault(2)

‘b‘

>>> D

{1: ‘a‘, 2: ‘b‘, 3: ‘c‘}

>>> D.setdefault(4)

>>> D

{1: ‘a‘, 2: ‘b‘, 3: ‘c‘, 4: None}

將另一個字典的元素加入到當前字典，如果有相同的key，取另一個字典的key和value（偶爾用）

>>> C = {1:‘a‘,2:‘b‘,3:‘c‘}

>>> D = {4:‘d‘,5:‘e‘,3:‘f‘}

>>> C.update(D)

>>> C

{1: ‘a‘, 2: ‘b‘, 3: ‘f‘, 4: ‘d‘, 5: ‘e‘}

字典淺copy

>>> D = {}

>>> for i in range(5):

... D[i] = []

...

>>> D

{0: [], 1: [], 2: [], 3: [], 4: []}

>>> D[1].append({"b":1})

>>> D

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}

>>> C = D

>>> C

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}

>>> D

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}

>>> D[‘Rain‘] = ‘test‘

>>> D

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: [], ‘Rain‘: ‘test‘}

>>> C

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: [], ‘Rain‘: ‘test‘}

D修改了，C也跟這個修改；如果是字符串，D修改了，C不會隨著修改

>>> E = D.copy()

>>> D.pop(‘Rain‘)

‘test‘

>>> D

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}

>>> E

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: [], ‘Rain‘: ‘test‘}

>>> C

{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}

如果使用copy()，E會是另外一個字典，D刪除一個元素，E不會隨著刪除

>>> D[1][0][‘b‘] = ‘Carrick‘

>>> D

{0: [], 1: [{‘b‘: ‘Carrick‘}], 2: [], 3: [], 4: []}

>>> C

{0: [], 1: [{‘b‘: ‘Carrick‘}], 2: [], 3: [], 4: []}

>>> E

{0: [], 1: [{‘b‘: ‘Carrick‘}], 2: [], 3: [], 4: [], ‘Rain‘: ‘test‘}

註意：淺copy只復制字典的第一層

深copy：需要借助第三方模塊

>>> import copy

>>> F = copy.deepcopy(D)

>>> F

{0: [], 1: [{‘b‘: ‘Carrick‘}], 2: [], 3: [], 4: []}

>>> D[1][0][‘b‘] = ‘Fairy‘

>>> D

{0: [], 1: [{‘b‘: ‘Fairy‘}], 2: [], 3: [], 4: []}

>>> E

{0: [], 1: [{‘b‘: ‘Fairy‘}], 2: [], 3: [], 4: [], ‘Rain‘: ‘test‘}

>>> C

{0: [], 1: [{‘b‘: ‘Fairy‘}], 2: [], 3: [], 4: []}

>>> F

{0: [], 1: [{‘b‘: ‘Carrick‘}], 2: [], 3: [], 4: []}

集合：去重，交集，差集，並集等的運算

集合/字典是無序的，列表/元組是有序的

列表/字典/集合可以修改，元組不能修改

>>> a = range(5,10)

>>> b = range(7,12)

>>> a

[5, 6, 7, 8, 9]

>>> b

[7, 8, 9, 10, 11]

>>> c = set(a)

>>> c

set([8, 9, 5, 6, 7])

>>> a.append(6)

>>> a

[5, 6, 7, 8, 9, 6]

>>> c

set([8, 9, 5, 6, 7])

>>> d = set(b)

>>> d

set([8, 9, 10, 11, 7])

>>> c

set([8, 9, 5, 6, 7])

>>> c & d -->交集

set([8, 9, 7])

>>> c | d -->並集

set([5, 6, 7, 8, 9, 10, 11])

>>> c ^ d -->交集取反

set([5, 6, 10, 11])

>>> c - d -->c有d沒有的元素

set([5, 6])

>>> d - c -->d有c沒有的元素

set([10, 11])

intersection --> &

union --> |

symmetric_difference --> ^

子集和父集

>>> e = set([8,10])

>>> e

set([8, 10])

>>> d

set([8, 9, 10, 11, 7])

>>> e.issubset(d)

True

>>> d.issuperset(e)

True

彈出集合第一個元素

>>> c

set([8, 9, 5, 6, 7])

>>> c.pop()

8

>>> c.pop()

9

刪除集合指定元素

set([5, 6, 7])

>>> c.remove(6)

>>> c

set([5, 7])

加入另外一個集合的元素

>>> c = set([5, 7, 8, 10])

>>> f = set([10,11])

>>> c.update(f)

>>> c

set([5, 7, 8, 10, 11])

集合不能有重復元素

集合使用場景：資產管理統計硬盤數量

硬盤使用S/N號來識別，這裏用1,2簡單說明一下

diskset = set([1,2])

壞掉一塊硬盤後

diskset1 = set([1])

可以發現硬盤2是壞掉的，寫入到數據庫中

>>> diskset - diskset1

set([2])

增加了硬盤後：

diskset2 = set([1,3,4,5])

可以發現硬盤3,4,5是新增加的硬盤，寫入到數據庫中

>>> diskset2 - diskset1

set([3, 4, 5])

python筆記day2