python小學日誌

若是沒有特殊業務要求，請牢記僅使用UTF-8編碼。

在Mac和Linux上是能夠的，方法是在.py文件的第一行加上一個特殊的註釋：

#!/usr/bin/env python3

print('hello, world')

而後，經過命令給hello.py以執行權限：

$ chmod a+x hello.py

就能夠直接運行hello.py了

若是字符串裏面有不少字符都須要轉義，就須要加不少\，爲了簡化，Python還容許用r''表示''內部的字符串默認不轉義

布爾值能夠用and、or和not運算。

and運算是與運算，只有全部都爲True，and運算結果纔是True：

or運算是或運算，只要其中有一個爲True，or運算結果就是True：

not運算是非運算，它是一個單目運算符，把True變成False，False變成True

 

空值是Python裏一個特殊的值，用None表示。None不能理解爲0，由於0是有意義的，而None是一個特殊的空值。

a = 'ABC'

時，Python解釋器幹了兩件事情：

1. 在內存中建立了一個'ABC'的字符串；

2. 在內存中建立了一個名爲a的變量，並把它指向'ABC'。

也能夠把一個變量a賦值給另外一個變量b，這個操做其實是把變量b指向變量a所指向的數據

 

數據類型

Python 定義了一些標準類型，用於存儲各類類型的數據。

Python有五個標準的數據類型：

• Numbers（數字）
• String（字符串）
• List（列表）
• Tuple（元組）
• Dictionary（字典)

Python數字

數字數據類型用於存儲數值。

他們是不可改變的數據類型，這意味着改變數字數據類型會分配一個新的對象。

當你指定一個值時，Number對象就會被建立：

var1 = 1
var2 = 10

也可使用del語句刪除一些對象的引用。

del語句的語法是：

del var1[,var2[,var3[....,varN]]]]

您能夠經過使用del語句刪除單個或多個對象的引用。例如：

del var
del var_a, var_b

Python字符串

字符串或串(String)是由數字、字母、下劃線組成的一串字符。

若是你要實現從字符串中獲取一段子字符串的話，可使用變量 [頭下標:尾下標]，就能夠截取相應的字符串，其中下標是從 0 開始算起，能夠是正數或負數，下標能夠爲空表示取到頭或尾。

好比:

s = 'ilovepython'

s[1:5]的結果是love。

當使用以冒號分隔的字符串，python返回一個新的對象，結果包含了以這對偏移標識的連續的內容，左邊的開始是包含了下邊界。

上面的結果包含了s[1]的值l，而取到的最大範圍不包括上邊界，就是s[5]的值p。

加號（+）是字符串鏈接運算符，星號（*）是重複操做。以下實例(paython2.0+)：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
str = 'Hello World!'
 
print str           # 輸出完整字符串
print str[0]        # 輸出字符串中的第一個字符
print str[2:5]      # 輸出字符串中第三個至第五個之間的字符串
print str[2:]       # 輸出從第三個字符開始的字符串
print str * 2       # 輸出字符串兩次
print str + "TEST"  # 輸出鏈接的字符串

 

Python列表

List（列表） 是 Python 中使用最頻繁的數據類型。

列表能夠完成大多數集合類的數據結構實現。它支持字符，數字，字符串甚至能夠包含列表（即嵌套）。

列表用 [ ] 標識，是 python 最通用的複合數據類型。

列表中值的切割也能夠用到變量 [頭下標:尾下標] ，就能夠截取相應的列表，從左到右索引默認 0 開始，從右到左索引默認 -1 開始，下標能夠爲空表示取到頭或尾。

若是要取最後一個元素，除了計算索引位置外，還能夠用-1作索引，直接獲取最後一個元素

加號 + 是列表鏈接運算符，星號 * 是重複操做

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 輸出完整列表
print list[0]            # 輸出列表的第一個元素
print list[1:3]          # 輸出第二個至第三個元素 
print list[2:]           # 輸出從第三個開始至列表末尾的全部元素
print tinylist * 2       # 輸出列表兩次
print list + tinylist    # 打印組合的列表

Python元組

元組是另外一個數據類型，相似於List（列表）,可是tuple一旦初始化就不能修改,tuple所謂的「不變」是說，tuple的每一個元素，指向永遠不變。即指向'a'，就不能改爲指向'b'，指向一個list，就不能改爲指向其餘對象，但指向的這個list自己是可變的！

元組用"()"標識。內部元素用逗號隔開。

>>> t = (1, 2)
>>> t
(1, 2)

若是要定義一個空的tuple，能夠寫成()：

>>> t = ()
>>> t
()

可是，要定義一個只有1個元素的tuple，若是你這麼定義：

>>> t = (1)
>>> t
1

定義的不是tuple，是1這個數！這是由於括號()既能夠表示tuple，又能夠表示數學公式中的小括號，這就產生了歧義，所以，Python規定，這種狀況下，按小括號進行計算，計算結果天然是1。

因此，只有1個元素的tuple定義時必須加一個逗號,，來消除歧義

>>> t = (1,)
>>> t
(1,)

可是元組不能二次賦值，至關於只讀列表。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 輸出完整元組
print tuple[0]            # 輸出元組的第一個元素
print tuple[1:3]          # 輸出第二個至第三個的元素 
print tuple[2:]           # 輸出從第三個開始至列表末尾的全部元素
print tinytuple * 2       # 輸出元組兩次
print tuple + tinytuple   # 打印組合的元組

Python 字典

字典(dictionary)是除列表之外python之中最靈活的內置數據結構類型。列表是有序的對象集合，字典是無序的對象集合。

二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。

字典用"{ }"標識。字典由索引(key)和它對應的值value組成。

須要牢記的第一條就是dict的key必須是不可變對象

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 輸出鍵爲'one' 的值
print dict[2]              # 輸出鍵爲 2 的值
print tinydict             # 輸出完整的字典
print tinydict.keys()      # 輸出全部鍵
print tinydict.values()    # 輸出全部值

把數據放入dict的方法，除了初始化時指定外，還能夠經過key放入,若是key不存在，dict就會報錯,要避免key不存在的錯誤，有兩種辦法，

一是經過in判斷key是否存在

>>> 'Thomas' in d
False

二是經過dict提供的get()方法，若是key不存在，能夠返回None，或者本身指定的value

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

要刪除一個key，用pop(key)方法，對應的value也會從dict中刪除：

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

 

set

set能夠當作數學意義上的無序和無重複元素的集合，所以，兩個set能夠作數學意義上的交集、並集等操做

set和dict的惟一區別僅在於沒有存儲對應的value，可是，set的原理和dict同樣，因此，一樣不能夠放入可變對象，由於沒法判斷兩個可變對象是否相等，也就沒法保證set內部「不會有重複元素」

要建立一個set，須要提供一個list做爲輸入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

注意，傳入的參數[1, 2, 3]是一個list，而顯示的{1, 2, 3}只是告訴你這個set內部有1，2，3這3個元素，顯示的順序也不表示set是有序的。。

重複元素在set中自動被過濾：

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

 

函數

在Python中，定義一個函數要使用def語句，依次寫出函數名、括號、括號中的參數和冒號:，而後，在縮進塊中編寫函數體，函數的返回值用return語句返回

空函數

若是想定義一個什麼事也不作的空函數，能夠用pass語句：

def nop():
    pass

返回多個值

原來返回值是一個tuple！可是，在語法上，返回一個tuple能夠省略括號，而多個變量能夠同時接收一個tuple，按位置賦給對應的值，因此，Python的函數返回多值其實就是返回一個tuple

11.函數參數

位置參數

默認參數

設置默認參數時，有幾點要注意：

一是必選參數在前，默認參數在後，不然Python的解釋器會報錯（思考一下爲何默認參數不能放在必選參數前面）；

二是如何設置默認參數。

當函數有多個參數時，把變化大的參數放前面，變化小的參數放後面。變化小的參數就能夠做爲默認參數。

有多個默認參數時，調用的時候，既能夠按順序提供默認參數，好比調用enroll('Bob', 'M', 7)，意思是，除了name，gender這兩個參數外，最後1個參數應用在參數age上，city參數因爲沒有提供，仍然使用默認值。

也能夠不按順序提供部分默認參數。當不按順序提供部分默認參數時，須要把參數名寫上。

默認參數必須指向不變對象

可變參數

定義可變參數和定義一個list或tuple參數相比，僅僅在參數前面加了一個*號。在函數內部，參數numbers接收到的是一個tuple

Python容許你在list或tuple前面加一個*號，把list或tuple的元素變成可變參數傳進去

關鍵字參數

可變參數容許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝爲一個tuple。而關鍵字參數容許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝爲一個dict

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

**extra表示把extra這個dict的全部key-value用關鍵字參數傳入到函數的**kw參數，kw將得到一個dict，注意kw得到的dict是extra的一份拷貝，對kw的改動不會影響到函數外的extra

若是要限制關鍵字參數的名字，就能夠用命名關鍵字參數，例如，只接收city和job做爲關鍵字參數。這種方式定義的函數以下：

def person(name, age, *, city, job):
    print(name, age, city, job)

和關鍵字參數**kw不一樣，命名關鍵字參數須要一個特殊分隔符*，*後面的參數被視爲命名關鍵字參數。

調用方式以下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

若是函數定義中已經有了一個可變參數，後面跟着的命名關鍵字參數就再也不須要一個特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名關鍵字參數必須傳入參數名，這和位置參數不一樣。若是沒有傳入參數名，調用將報錯：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

使用命名關鍵字參數時，要特別注意，若是沒有可變參數，就必須加一個*做爲特殊分隔符。若是缺乏*，Python解釋器將沒法識別位置參數和命名關鍵字參數：

def person(name, age, city, job):
    # 缺乏 *，city和job被視爲位置參數
    pass

參數組合

在Python中定義函數，能夠用必選參數、默認參數、可變參數、關鍵字參數和命名關鍵字參數，這5種參數均可以組合使用。可是請注意，參數定義的順序必須是：必選參數、默認參數、可變參數、命名關鍵字參數和關鍵字參數。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

 

高級特性

列表生成式

列表生成式即List Comprehensions,Python內置的能夠用來建立list的生成式

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

寫列表生成式時，把要生成的元素x * x放到前面，後面跟for循環，就能夠把list建立出來

for循環後面還能夠加上if判斷，這樣咱們就能夠篩選出僅偶數的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

還可使用兩層循環，能夠生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

生成器

Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。

要建立一個generator，有不少種方法。

1、第一種方法很簡單，只要把一個列表生成式的[]改爲()，就建立了一個generator：

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

咱們建立了一個generator後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤

2、

若是一個函數定義中包含yield關鍵字，那麼這個函數就再也不是一個普通函數，而是一個generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

這裏，最難理解的就是generator和函數的執行流程不同。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

函數改爲generator後，咱們基本上歷來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代

可是用for循環調用generator時，發現拿不到generator的return語句的返回值。若是想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done