python

時間 2019-11-18

標籤 python 欄目 Python 简体版

原文原文鏈接

01_python_(python語言_數據類型詳解)python

python數據類型詳解

內容大綱

一、字符串linux

二、布爾類型程序員

三、整數web

四、浮點數redis

五、數字算法

六、列表shell

七、元組express

八、字典編程

九、日期json

一、字符串

1.一、如何在Python中使用字符串

a、使用單引號(')

用單引號括起來表示字符串，例如：

str='this is string';

print str;

b、使用雙引號(")

雙引號中的字符串與單引號中的字符串用法徹底相同，例如：

str="this is string";

print str;

c、使用三引號(''')

利用三引號，表示多行的字符串，能夠在三引號中自由的使用單引號和雙引號，例如：

str='''this is string

this is pythod string

this is string'''

print str;

二、布爾類型

bool=False;

print bool;

bool=True;

print bool;

三、數字類型

3.一、基本使用

整數

int=20;

print int;

浮點數

float=2.3;

print float;

3.二、刪除數字對象引用，例如：

a=1;

b=2;

c=3;

del a;

del b, c;

#print a; #刪除a變量後，再調用a變量會報錯

3.三、數字類型轉換

int(x [,base]) 將x轉換爲一個整數

float(x ) 將x轉換到一個浮點數

complex(real [,imag]) 建立一個複數

str(x) 將對象x轉換爲字符串

repr(x) 將對象x轉換爲表達式字符串

eval(str) 用來計算在字符串中的有效Python表達式,並返回一個對象

tuple(s) 將序列s轉換爲一個元組

list(s) 將序列s轉換爲一個列表

chr(x) 將一個整數轉換爲一個字符

unichr(x) 將一個整數轉換爲Unicode字符

ord(x) 將一個字符轉換爲它的整數值

hex(x) 將一個整數轉換爲一個十六進制字符串

oct(x) 將一個整數轉換爲一個八進制字符串

3.四、數學函數

abs(x) 返回數字的絕對值，如abs(-10) 返回 10

ceil(x) 返回數字的上入整數，如math.ceil(4.1) 返回 5

cmp(x, y) 若是 x < y 返回 -1, 若是 x == y 返回 0, 若是 x > y 返回 1

exp(x) 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045

fabs(x) 返回數字的絕對值，如math.fabs(-10) 返回10.0

floor(x) 返回數字的下舍整數，如math.floor(4.9)返回 4

log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 返回以10爲基數的x的對數，如math.log10(100)返回 2.0

max(x1, x2,...) 返回給定參數的最大值，參數能夠爲序列。

min(x1, x2,...) 返回給定參數的最小值，參數能夠爲序列。

modf(x) 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。

pow(x, y) x**y 運算後的值。X的y次方

round(x [,n]) 返回浮點數x的四捨五入值，如給出n值，則表明舍入到小數點後的位數。

sqrt(x) 返回數字x的平方根，數字能夠爲負數，返回類型爲複數，如math.sqrt(4)返回 2+0j

四、列表

4.一、初始化列表，例如：
list=['physics', 'chemistry', 1997, 2000];
nums=[1, 3, 5, 7, 8, 13, 20];

4.二、訪問列表中的值，例如：

'''nums[0]: 1'''

print "nums[0]:", nums[0]

'''nums[2:5]: [5, 7, 8] 從下標爲2的元素切割到下標爲5的元素，但不包含下標爲5的元素'''

print "nums[2:5]:", nums[2:5]

'''nums[1:]: [3, 5, 7, 8, 13, 20] 從下標爲1切割到最後一個元素'''

print "nums[1:]:", nums[1:]

'''nums[:-3]: [1, 3, 5, 7] 從最開始的元素一直切割到倒數第3個元素，但不包含倒數第三個元素'''

print "nums[:-3]:", nums[:-3]

'''nums[:]: [1, 3, 5, 7, 8, 13, 20] 返回全部元素'''

print "nums[:]:", nums[:]

4.三、更新列表，例如：

nums[0]="ljq";

print nums[0];

4.四、刪除列表元素

del nums[0];'''nums[:]: [3, 5, 7, 8, 13, 20]'''

print "nums[:]:", nums[:];

4.五、列表腳本操做符
列表對+和*的操做符與字符串類似。+號用於組合列表，*號用於重複列表，例如：

print len([1, 2, 3]); #3

print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]

print ['Hi!'] * 4; #['Hi!', 'Hi!', 'Hi!', 'Hi!']

print 3 in [1, 2, 3] #Truefor x in [1, 2, 3]: print x, #1 2 3

4.六、列表截取

L=['spam', 'Spam', 'SPAM!'];

print L[2]; #'SPAM!'

print L[-2]; #'Spam'

print L[1:]; #['Spam', 'SPAM!']

4.七、列表函數&方法

list.append(obj) 在列表末尾添加新的對象

list.count(obj) 統計某個元素在列表中出現的次數

list.extend(seq) 在列表末尾一次性追加另外一個序列中的多個值(用新列表擴展原來的列表)

list.index(obj) 從列表中找出某個值第一個匹配項的索引位置，索引從0開始

list.insert(index, obj) 將對象插入列表

list.pop() 移除列表中的一個元素(默認最後一個元素)，而且返回該元素的值

list.remove(obj) 移除列表中某個值的第一個匹配項

list.reverse() 反向列表中元素，倒轉

list.sort([func]) 對原列表進行排序

五、元組(tuple)

Python的元組與列表相似，不一樣之處在於元組的元素不能修改；元組使用小括號()，列表使用方括號[]；元組建立很簡單，只須要在括號中添加元素，並使用逗號(,)隔開便可，例如：

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

tup3 = ("a", "b", "c", "d");

建立空元組，例如：tup = ();

元組中只有一個元素時，須要在元素後面添加逗號，例如：tup1 = (50,);

元組與字符串相似，下標索引從0開始，能夠進行截取，組合等。

5.一、訪問元組

tup1 = ('physics', 'chemistry', 1997, 2000);

#tup1[0]: physics

print "tup1[0]: ", tup1[0]

#tup1[1:5]: ('chemistry', 1997)

print "tup1[1:5]: ", tup1[1:3]

5.二、修改元組
元組中的元素值是不容許修改的，但咱們能夠對元組進行鏈接組合，例如:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# 如下修改元組元素操做是非法的。
# tup1[0] = 100;

# 建立一個新的元組

tup3 = tup1 + tup2;

print tup3; #(12, 34.56, 'abc', 'xyz')

5.三、刪除元組
元組中的元素值是不容許刪除的，可使用del語句來刪除整個元組，例如:

tup = ('physics', 'chemistry', 1997, 2000);

print tup;

del tup;

5.四、元組運算符
與字符串同樣，元組之間可使用+號和*號進行運算。這就意味着他們能夠組合和複製，運算後會生成一個新的元組。

5.五、元組索引&截取

L = ('spam', 'Spam', 'SPAM!');

print L[2]; #'SPAM!'

print L[-2]; #'Spam'

print L[1:]; #['Spam', 'SPAM!']

5.六、元組內置函數

cmp(tuple1, tuple2) 比較兩個元組元素。

len(tuple) 計算元組元素個數。

max(tuple) 返回元組中元素最大值。

min(tuple) 返回元組中元素最小值。

(seq) 將列表轉換爲元組。

六、字典

6.一、字典簡介
字典(dictionary)是除列表以外python中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。

字典由鍵和對應的值組成。字典也被稱做關聯數組或哈希表。基本語法以下：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};

也可如此建立字典：

dict1 = { 'abc': 456 };

dict2 = { 'abc': 123, 98.6: 37 };

每一個鍵與值必須用冒號隔開(:)，每對用逗號分割，總體放在花括號中({})。鍵必須獨一無二，但值則沒必要；值能夠取任何數據類型。

6.二、訪問字典裏的值

#!/usr/bin/python

dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

print "dict['name']: ", dict['name'];

print "dict['age']: ", dict['age'];

6.三、修改字典
向字典添加新內容的方法是增長新的鍵/值對，修改或刪除已有鍵/值對以下實例:

#!/usr/bin/python

dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

dict["age"]=27; #修改已有鍵的值

dict["school"]="wutong"; #增長新的鍵/值對

print "dict['age']: ", dict['age'];

print "dict['school']: ", dict['school'];

6.四、刪除字典
del dict['name']; # 刪除鍵是'name'的條目
dict.clear(); # 清空詞典全部條目
del dict ; # 刪除詞典
例如：

#!/usr/bin/python

dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

del dict['name'];

#dict {'age': 7, 'class': 'First'}

print "dict", dict;

注意：字典不存在，del會引起一個異常

6.五、字典內置函數&方法

cmp(dict1, dict2) 比較兩個字典元素。

len(dict) 計算字典元素個數，即鍵的總數。

str(dict) 輸出字典可打印的字符串表示。

type(variable) 返回輸入的變量類型，若是變量是字典就返回字典類型。
clear() 刪除字典內全部元素

copy() 返回一個字典的深拷貝(在python中，函數的參數傳遞是：引用傳遞)

fromkeys(seq) 建立一個新字典，以序列seq中元素作字典的鍵，val爲字典全部鍵對應的初始值

get(key, None) 返回指定鍵的值，若是值不在字典中返回default值

has_key(key) 若是鍵在字典dict裏返回true，不然返回false

items() 以列表返回可遍歷的(鍵, 值) 元組數組

keys() 以列表返回一個字典全部的鍵

setdefault(key, default=None) 和get()相似, 但若是鍵不已經存在於字典中，將會添加鍵並將值設爲default

dict1.update(dict2) 把字典dict2的鍵/值對更新到dict1裏

values() 以列表返回字典中的全部值

七、日期和時間

7.一、獲取當前時間，例如：
import time, datetime;

#當前時間:

localtime = time.localtime(time.time())

print "Local current time :", localtime

## 結構化時間
time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)
說明：time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)屬於struct_time元組，struct_time元組具備以下屬性：

7.二、獲取格式化的時間
能夠根據需求選取各類格式，可是最簡單的獲取可讀的時間模式的函數是asctime():
一、日期轉換爲字符串

首選：print time.strftime('%Y-%m-%d %H:%M:%S');

其次：print datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')

最後：print str(datetime.datetime.now())[:19]

二、字符串轉換爲日期

expire_time = "2013-05-21 09:50:35"

d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

print d;

7.三、獲取日期差

## 定義時差步長

oneday = datetime.timedelta(days=1)

#今天，2014-03-21

today = datetime.date.today()

#昨天，2014-03-20

yesterday = datetime.date.today() - oneday

#明天，2014-03-22

tomorrow = datetime.date.today() + oneday

#獲取今天零點的時間，2014-03-21 00:00:00

today_zero_time = datetime.datetime.strftime(today, '%Y-%m-%d %H:%M:%S')

#0:00:00.001000

print datetime.timedelta(milliseconds=1), #1毫秒

#0:00:01

print datetime.timedelta(seconds=1), #1秒

#0:01:00

print datetime.timedelta(minutes=1), #1分鐘

#1:00:00

print datetime.timedelta(hours=1), #1小時

#1 day, 0:00:00

print datetime.timedelta(days=1), #1天

#7 days, 0:00:00

print datetime.timedelta(weeks=1)

7.四、獲取時間差

#1 day, 0:00:00

oneday = datetime.timedelta(days=1)

#今天，2014-03-21 16:07:23.943000

today_time = datetime.datetime.now()

#昨天，2014-03-20 16:07:23.943000

yesterday_time = datetime.datetime.now() - oneday

#明天，2014-03-22 16:07:23.943000

tomorrow_time = datetime.datetime.now() + oneday

注意時間是浮點數，帶毫秒。

那麼要獲取當前時間，須要格式化一下：

print datetime.datetime.strftime(today_time, '%Y-%m-%d %H:%M:%S')

print datetime.datetime.strftime(yesterday_time, '%Y-%m-%d %H:%M:%S')

print datetime.datetime.strftime(tomorrow_time, '%Y-%m-%d %H:%M:%S')

7.五、獲取上個月最後一天

last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)

7.六、字符串日期格式化爲秒數，返回浮點類型：

expire_time = "2013-05-21 09:50:35"

d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

time_sec_float = time.mktime(d.timetuple())

print time_sec_float

7.七、日期格式化爲秒數，返回浮點類型：

d = datetime.date.today()

time_sec_float = time.mktime(d.timetuple())

print time_sec_float

7.八、秒數轉字符串

time_sec = time.time()

print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))

01_python_(python語言與numpy庫)

機器學習算法day01_python快速上手

課程大綱

Python快速上手	Python簡介
	Python集成開發環境
	Python基本語法
	Python的變量和集合
	Python流程控制語法
	Python函數
	Python模塊
Numpy矩陣運算包	Numpy簡介
	Numpy中的多維數組ndarray
	Ndarray經常使用方法
	數組的基本運算
	數組的形狀操做
數據挖掘與機器學習導論	數據挖掘概念
	數據挖掘與機器學習的關係
	機器學習簡介
	機器學習的應用步驟

課程目標：

一、在已有JAVA語言的基礎上迅速實現python上手開發

二、掌握Numpy矩陣算法包的核心功能

三、瞭解數據挖掘與機器學習算法的概念及其關係

四、

1 Python快速上手

1.1.Python簡介

Python 是一個高層次的結合瞭解釋性、編譯性、互動性和麪向對象的腳本語言。

Python 的設計具備很強的可讀性，相比其餘語言常用英文關鍵字，其餘語言的一些標點符號，它具備比其餘語言更有特點語法結構。

l Python是一種解釋型語言：這意味着開發過程當中沒有了編譯這個環節。相似於PHP和Perl語言。

l Python是交互式語言：這意味着，您能夠在一個Python提示符，直接互動執行寫你的程序。

l Python是面嚮對象語言: 這意味着Python支持面向對象的風格或代碼封裝在對象的編程技術。

l Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持普遍的應用程序開發，從簡單的文字處理到WWW瀏覽器再到遊戲

12.Python集成開發環境

1.2.1 Python安裝

Python已經被移植在許多平臺上（通過改動使它可以工做在不一樣平臺上）。

能夠直接下載相應平臺的二進制代碼，而後安裝Python，或者使用C編譯器手動編譯源代碼。編譯的源代碼，功能上有更多的選擇性，爲python安裝提供了更多的靈活性。

Python版本的選擇：

有兩大系列 python 2.x

Python 3.x

如下爲不一樣平臺上安裝Python的方法：

1、Unix & Linux 平臺安裝 Python:

打開WEB瀏覽器訪問http://www.python.org/download/

選擇適用於Unix/Linux的源碼壓縮包。

下載及解壓壓縮包。

若是你須要自定義一些選項修改Modules/Setup

執行 ./configure 腳本

make

make install

執行以上操做後，Python會安裝在 /usr/local/bin目錄中，Python庫安裝在/usr/local/lib/pythonXX，XX爲你使用的Python的版本號。

2、Window 平臺安裝 Python:

打開WEB瀏覽器訪問http://www.python.org/download/

在下載列表中選擇Window平臺安裝包，包格式爲：python-XYZ.msi 文件， XYZ 爲你要安裝的版本號。

下載後，雙擊下載包，進入Python安裝嚮導，安裝很是簡單，你只須要使用默認的設置一直點擊"下一步"直到安裝完成便可。

3、環境變量配置

程序和可執行文件能夠在許多目錄，而這些路徑極可能不在操做系統提供可執行文件的搜索路徑中。

path(路徑)存儲在環境變量中，這是由操做系統維護的一個命名的字符串。這些變量包含可用的命令行解釋器和其餘程序的信息。

Unix或Windows中路徑變量爲PATH（UNIX區分大小寫，Windows不區分大小寫）。

vi /etc/profile

export PATH="$PATH:/usr/local/bin/python"

在 Windows 設置環境變量

在環境變量中添加Python目錄：

在命令提示框中(cmd) : 輸入

path %path%;C:\Python , 按下"Enter"。

注意: C:\Python 是Python的安裝目錄。

4、運行Python

有三種方式能夠運行Python：

(一) 交互式解釋器：

你能夠經過命令行窗口進入python並開在交互式解釋器中開始編寫Python代碼。

你能夠在Unix，DOS或任何其餘提供了命令行或者shell的系統進行python編碼工做。

$python # Unix/Linux

或者

C:>python # Windows/DOS

如下爲Python命令行參數：

選項描述

-d 在解析時顯示調試信息

-O 生成優化代碼 ( .pyo 文件 )

-S 啓動時不引入查找Python路徑的位置

-v 輸出Python版本號

-X 從 1.6版本以後基於內建的異常（僅僅用於字符串）已過期。

-c cmd 執行 Python 腳本，並將運行結果做爲 cmd 字符串。

file 在給定的python文件執行python腳本。

(二) 命令行腳本

在你的應用程序中經過引入解釋器能夠在命令行中執行Python腳本，以下所示：

#在 Unix/Linux下

$python script.py

# 在Windows下

C:>python script.py

注意：在執行腳本時，請檢查腳本是否有可執行權限。

(三) 集成開發環境（IDE：Integrated Development Environment）

您可使用圖形用戶界面（GUI）環境來編寫及運行Python代碼。如下推薦各個平臺上使用的IDE：

IDLE 是 Linux上最先的 Python IDE。

Pycharm 是jetbrain出品的Python 集成開發環境

1.2.2 python依賴庫管理工具pip

pip 是一個安裝和管理 Python 包的工具，python安裝包的工具備easy_install, setuptools, pip，distribute。使用這些工具都能下載並安裝python依賴包

1、安裝pip

安裝和升級以前，先下載get-pip.py

而後使用下面的命令：

python get-pip.py

不過注意一下，linux或osX下，須要權限，使用下面的命令，輸入密碼後便可。

sudo python get-pip.py

windows下須要管理員權限啓動終端。

2、安裝setuptools

若是你尚未安裝了setuptools，get-pip.py 會幫你安裝。

若是你已經安裝了setuptools，能夠運行下面的命令進行升級。

pip install -U setuptools

windows下，注意將pip路勁加到系統的path中。

3、升級pip

Linux or OS X系統，運行下面的命令:

pip install -U pip

windows系統運行下面的命令：

python -m pip install -U pip

4、安裝依賴包

使用下面的命令來安裝包

pip install SomePackage # 默認下載安裝最新版本

pip install SomePackage==1.0.4 # 指定安裝版本

pip install 'SomePackage>=1.0.4' # 指定最低版本

要看更多地例子，能夠看這裏pip install

例如要安裝web開發框架庫 Django，用下面的一條命令便可，方便快捷：

pip install Django==1.7

1.2.3 python環境一鍵安裝

在用python作科學計算的場景中，須要安裝的依賴庫很是多且很是麻煩，建議用python科學計算集成環境 anaconda

一句話點評：省事！！！給力！！！

請see官方介紹：

Anaconda is a completely free Python distribution (including for commercial use and redistribution). It includes more than 400 of the most popular Python packages for science, math, engineering, and data analysis.

官網下載地址

https://www.continuum.io/downloads

WINDOW版本：

LINUX版本：

MAC OS版本：

1.3.Python基本語法

1.3.1 行和縮進

Python中，不使用括號來表示代碼的類和函數定義塊或流程控制。

代碼塊是由行縮進，縮進位的數目是可變的，可是在塊中的全部語句必須縮進相同的量。

以下所示：

if True:

print "True"[dht1]

else:

print "False"

然而，在本實施例中的第二塊將產生一個錯誤：

if True:

print "Answer"

print "True"

else:

print "Answer"

print "False"

1.3.2 Python引號

Python接受單引號（'），雙引號（「）和三（''或」「」）引用，以表示字符串常量，只要是同一類型的引號開始和結束的字符串。

三重引號能夠用於跨越多個行的字符串。例如，全部下列是合法的：

word = 'word'

sentence = "This is a sentence."

paragraph = """This is a paragraph. It is

made up of multiple lines and sentences."""

1.3.3 Python註釋

「＃」號以後字符和到物理行是註釋的一部分，Python解釋器會忽略它們。

#!/usr/bin/python

# First comment

print "Hello, Python!"; # second comment

這將產生如下結果：

Hello, Python!

註釋可能會在聲明中表達或同一行以後：

name = "Madisetti" # This is again comment

你可使用多行註釋以下：

# This is a comment.

# This is a comment, too.

# I said that already.

1.3.4 分號的使用

python中一個語句的結束不須要使用分號

若是想在一行中輸入多個語句，可以使用分號：

import sys; x = 'foo'; sys.stdout.write(x+"""

""")

1.4.Python的變量和集合

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

a) 數字

b) 字符串

c) 列表

d) 元組

e) 字典

f) set

python中定義變量時不須要顯示指定變量類型，如下爲python中變量使用的典型語法：

1.4.1變量定義和賦值

#基本使用

counter = 100 # 整型

miles = 1000.0 # 浮點

name = "John" # 字符串

print counter

print miles

print name

#多重賦值

a = b = c = 1

d, e, f = 1, 2, "john"

1.4.2字符串的使用

str = 'Hello World!' #字符串在python中本質上是一個字符序列Seq

print str # 打印整個字符串

print str[0] # 打印字符串第一個字母

print str[2:5] # 打印第3到第5個字母

print str[2:] # 打印從第3個字母到末尾

print str * 2 # 字符串重複2次

print str + "TEST" # 字符串拼接

1.4.3列表的使用

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print list # 打印整個列表

print list[0] # 打印第一個元素

print list[1:3] # 打印第二和第三個元素

print list[2:] # 打印第三個元素到末尾

print tinylist * 2 # 打印2次

print list + tinylist # 拼接兩個list

#修改list中的元素

list[0]=」python」

print(list)

將輸出如下結果：

['abcd', 786, 2.23, 'john', 70.200000000000003]

abcd

[786, 2.23]

[2.23, 'john', 70.200000000000003]

[123, 'john', 123, 'john']

['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

1.4.4元組使用

元組是相似於列表中的序列數據類型，一個元組由數個逗號分隔的值組成。

列表和元組之間的主要區別是：列表用方括號[]，列表的長度和元素值是能夠改變的

而元組用圓括號()，不能被更新。

元組能夠被認爲是隻讀列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2)

tinytuple = (123, 'john')

print tuple # 打印整個元組

print tuple[0] # 打印第一個元素

print tuple[1:3] # 打印第二、3兩個元素

print tuple[2:] #

print tinytuple * 2 # 重複2遍

print tuple + tinytuple # 拼接

這將產生如下結果：

('abcd', 786, 2.23, 'john', 70.200000000000003)

abcd

(786, 2.23)

(2.23, 'john', 70.200000000000003)

(123, 'john', 123, 'john')

('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

1.4.5字典

Python字典是一種哈希表型。由「鍵-值」對組成。

鍵能夠是任何Python類型，但一般是數字或字符串。

值能夠是任意Python的對象。

字典是由花括號括號{}，可分配值，並用方括號[]訪問。例如：

dict = {}

dict['one'] = "This is one"

dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # Prints value for 'one' key

print dict[2] # Prints value for 2 key

print tinydict # Prints complete dictionary

print tinydict.keys() # Prints all the keys

print tinydict.values() # Prints all the values

這將產生如下結果：

This is one

This is two

{'dept': 'sales', 'code': 6734, 'name': 'john'}

['dept', 'code', 'name']

['sales', 6734, 'john']

1.4.6 set

定義一個set：

a={1,2,3,4,5}

print a

a.remove(3)

a.add(6)

a.union(b)

1.4.7數據類型轉換

有時候，可能須要執行的內置類型之間的轉換。

類型之間的轉換，只需使用類名做爲函數。

int(x [,base])	將x轉換爲整數。基數指定爲base（進制）
long(x [,base] )	將x轉換爲一個長整數。基數指定爲base，
float(x)	將x轉換到一個浮點數。
complex(real [,imag])	建立一個複數。
str(x)	轉換對象x爲字符串表示形式。
eval(str)	計算一個表達式字符串，並返回一個對象。
tuple(s)	把s（序列）轉換爲一個元組。
list(s)	把s（序列）轉換爲一個列表。
set(s)	把s（序列）轉換爲一個set集合。
dict(d)	轉成字典,d必須是（鍵，值）元組序列。

例如：

a=int(‘A’,16)

print(a)

結果爲: 10

a=tuple(range(1,10,2))

print(a)

b=tuple("hello")

print b

c=complex(1,2)

print c

x=1

e=eval('x+1')

print e

f=dict([(1,2),(3,4),('a',100)])

print f

結果爲：

(1, 3, 5, 7, 9)

('h', 'e', 'l', 'l', 'o')

(1+2j)

{'a': 100, 1: 2, 3: 4}

1.5.Python流程控制語法

1.5.1 if語句

var1 = 100

if var1:

print "1 - Got a true expression value"

print var1

var2 = 0

if var2:

print "2 - Got a true expression value"

print var2

print "Good bye!"

#if的條件能夠是數字或字符串或者布爾值True和False（布爾表達式）

#若是是數字，則只要不等於0，就爲true

#若是是字符串，則只要不是空串，就爲true

if else

var = 100

if var == 200:

print "1 - Got a true expression value"

print var

elif var == 150:

print "2 - Got a true expression value"

print var

elif var == 100:

print "3 - Got a true expression value"

print var

else:

print "4 - Got a false expression value"

print var

print "Good bye!"

嵌套if else

var = 100

if var < 200:

print "Expression value is less than 200"

if var == 150:

print "Which is 150"

elif var == 100:

print "Which is 100"

elif var == 50:

print "Which is 50"

elif var < 50:

print "Expression value is less than 50"

else:

print "Could not find true expression"

print "Good bye!"

1.5.2 while循環

count = 0

while count < 5:

print count, " is less than 5"

count = count + 1

else:

print count, " is not less than 5"

1.5.3 for循環

# 求素數

for num in range(10,20):

for i in range(2,num):

if num%i == 0:

j=num/i

print '%d equals %d * %d' % (num,i,j)

break

else:

print num, 'is a prime number'

#遍歷集合

r=range(10,20)

r={1,2,3,4,5} #set類型

r=["aaa",3,"c"]

print(r)

for num in r:

print(num)

r={"a":9,"b":10}

print(r)

for num in r.values():

print(num)

當執行上面的代碼，產生如下結果：

10 equals 2 * 5

11 is a prime number

12 equals 2 * 6

13 is a prime number

14 equals 2 * 7

15 equals 3 * 5

16 equals 2 * 8

17 is a prime number

18 equals 2 * 9

19 is a prime number

1.6.Python函數

1.6.1 基本形式[M2]

#定義函數

def changeme( mylist ):

"This changes a passed list into this function"

mylist.append([1,2,3,4]);

print "Values inside the function: ", mylist

return (mylist,"haha")

# 調用函數

mylist = [10,20,30];

changeme( mylist );

print "Values outside the function: ", mylist

python的函數調用是引用傳遞，這將產生如下結果：

Values inside the function: [10, 20, 30, [1, 2, 3, 4]]

Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

默認參數和可變參數

# 默認參數

#有默認值的參數後面不能再跟無默認值的參數

def printinfo( name, age = 35 ):

"This prints a passed info into this function"

print "Name: ", name;

print "Age ", age;

return;

#調用

#若是調換了參數的順序，則必須把參數名都帶上

printinfo( age=50, name="miki" );

printinfo( name="miki" );

#可變參數

def printinfo( arg1, *vartuple ):

"This prints a variable passed arguments"

print "Output is: "

print arg1

for var in vartuple:

print var

return;

# 調用

printinfo( 10 );

printinfo( 70, 60, 50 );

1.6.2 匿名函數

² 可使用lambda關鍵字來建立小的匿名函數。這些函數被稱爲匿名，由於它們不是以標準方式經過使用def關鍵字聲明。

² Lambda形式能夠採起任何數量的參數，但在表現形式上只返回一個值。它們不能包含命令或多個表達式。

² 匿名函數不能直接調用打印，由於須要lambda表達式。

² lambda函數都有本身的命名空間，而且不能訪問變量高於在其參數列表和那些在全局命名空間的變量。

示例：

# 定義

sum = lambda arg1, arg2: arg1 + arg2 #lambda表達式

# 調用

print "Value of total : ", sum( 10, 20 )

print "Value of total : ", sum( 20, 20 )

##返回多個值

tup=lambda x,y:(x+1,y+1)

c=tup(2,3)

print c[0],c[1]

(a,b)=tup(2,3)

  

  print a,b

  print c[0],c[1]

利用lambda能夠實現相似於scala中的高階函數效果：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def outfunc(func,x,y):

c=func(x,y)

print(c)

outfunc(lambda x,y:x+y,1,2)

1.7.Python模塊

簡單地說，一個模塊是由Python代碼的文件。一個模塊能夠定義函數，類和變量。模塊還能夠包括可運行的代碼。

1.7.1 模塊的定義和導入

例：如下代碼定義在support.py文件中

def print_func( par ):

print "Hello : ", par

return

在別的模塊好比(hello.py)中能夠導入已定義好的模塊

#!/usr/bin/python

#導入模塊

import cn.itcast.test.support

# 使用導入的模塊中的函數

cn.itcast.test.support.print_func("Zara")

#------------------------------------------------

#或者

from cn.itcast.test.support import print_func

print_func("Zara")

1.7.2 模塊和包

在python中一個文件能夠被當作一個獨立模塊，而包對應着文件夾，模塊把python代碼分紅一些有組織的代碼段，經過導入的方式實現代碼重用。

1.7.1 模塊搜索路徑

導入模塊時，是按照sys.path變量的值搜索模塊，sys.path的值是包含每個獨立路徑的列表，包含當前目錄、python安裝目錄、PYTHONPATH環境變量，搜索順序按照路徑在列表中的順序（通常當前目錄優先級最高）。

[‘/home/zhoujh/study_workspace/studynotes/python/python_base’, ‘/usr/local/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/redis-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Flask-0.8-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Jinja2-2.6-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Werkzeug-0.8.3-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/tornado-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/MySQL_python-1.2.3-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/PIL-1.1.7-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/SQLAlchemy-0.7.8-py2.6-linux-x86_64.egg’, ‘/home/zhoujh/python_workspace/python_app’, ‘/usr/local/lib/python26.zip’, ‘/usr/local/lib/python2.6’, ‘/usr/local/lib/python2.6/plat-linux2’, ‘/usr/local/lib/python2.6/lib-tk’, ‘/usr/local/lib/python2.6/lib-old’, ‘/usr/local/lib/python2.6/lib-dynload’, ‘/usr/local/lib/python2.6/site-packages’]

1.7.2 導入模塊

1.7.2.1 使用import語句導入模塊

有下面兩種方式

import module1

import module2

import module3

import module1,module2,module3

這兩種方式的效果是同樣的，可是第一種可讀性比第二種好，推薦按照下面的順序導入模塊，而且通常在文件首部導入全部的模塊：

v python標準庫

v 第三方模塊

v 應用程序自定義模塊

也能夠在函數內部導入模塊，這樣被導入的模塊做用域是局部的

1.7.2.2 使用from-import語句導入模塊的屬性

單行導入

from module import name1,name2,name3

多行導入

from module import name1,name2,\

name3

導入所有屬性（因爲容易覆蓋當前名稱空間中現有的名字，因此通常不推薦使用，適合模塊中變量名很長而且變量不少的狀況）

from module import *

若是你不想某個模塊的屬性被以上方法導入，能夠給該屬性名稱前加一個下劃線(_test)，若是須要取消隱藏，能夠顯示的導入該屬性（from module import _test）

1.7.2.3 擴展的import語句

使用自定義的名稱替換模塊的原始名稱

import simplejson as json

模塊被導入時，加載的時候模塊頂層代碼會被執行，如：設定全局變量、類和函數的聲明等，因此應該把代碼儘可能封裝到類和函數中。一個模塊不管被導入多少次，只加載一次，能夠防止屢次導入時代碼被屢次執行。

1.7.2.4 從新導入模塊

reload(module)

內建函數reload能夠從新導入一個已經存在的模塊

1.7.3.包結構

1.包定義結構

包將有聯繫的模塊組織在一塊兒，有效避免模塊名稱衝突問題，讓應用組織結構更加清晰。

一個普通的python應用程序目錄結構：

app/

__init__.py

a.py

__init__.py

b.py

app是最頂層的包，a和b是它的子包，能夠這樣導入：

from app.a import a

from app.b.b import test

a.test()

test()

上面代碼表示：導入app包的子包a和子包b的屬性test，而後分別調用test方法。

2. __init__.py的做用

每一個目錄下都有__init__.py文件，這個是初始化模塊，from-import語句導入子包時須要它，能夠在裏面作一些初始化工做，也能夠是空文件。

ps：__init__.py定義的屬性直接使用頂層包.子包的方式導入，如在目錄a的__init__.py文件中定義init_db()方法，調用以下：

from app import a

a.init_db()

3. 指定python文件編碼方式

python默認是使用ASCII編碼，能夠指定編碼方式，如

#!/usr/bin/env python

#coding=utf-8

或者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

4. 解決導入循環問題

有下面兩個模塊，a.py和b.py

a.py

#!/usr/bin/env python

#coding=utf-8

import b

if __name__ == '__main':

print 'hello,I'm a'

b.py

#!/usr/bin/env python

#coding=utf-8

import a

if __name__ == '__main':

print 'hello,I'm b'

在這裏a嘗試導入b，而b也嘗試導入a，導入一個先前沒有徹底導入的模塊，會致使導入失敗。解決辦法：移除一個導入語句，把導入語句放到函數內部，在須要的時候導入。

b.py

#!/usr/bin/env python

#coding=utf-8

if __name__ == '__main':

import a

print 'hello,I'm b'

1.8.Python文件IO

1.8.1 文件讀寫

Python進行文件讀寫的函數爲open或file:

file_handler = open(filename,,mode）

open mode

w	以寫方式打開文件，可向文件寫入信息。如文件存在，則清空該文件，再寫入新內容
a	以追加模式打開文件（即一打開文件，文件指針自動移到文件末尾），若是文件不存在則建立
r+	以讀寫方式打開文件，可對文件進行讀和寫操做。
w+	消除文件內容，而後以讀寫方式打開文件。
a+	以讀寫方式打開文件，並把文件指針移到文件尾。
b	以二進制模式打開文件，而不是以文本模式。該模式只對Windows或Dos有效，類Unix的文件是用二進制模式進行操做的。

操做文件對象方法

f.close()	關閉文件，記住用open()打開文件後必定要記得關閉它，不然會佔用系統的可打開文件句柄數。
f.fileno()	得到文件描述符，是一個數字
f.flush()	刷新輸出緩存
f.isatty()	若是文件是一個交互終端，則返回True，不然返回False。
f.read([count])	讀出文件，若是有count，則讀出count個字節。
f.readline()	讀出一行信息。
f.readlines()	讀出全部行，也就是讀出整個文件的信息。
f.seek(offset[,where])	把文件指針移動到相對於where的offset位置。where爲0表示文件開始處，這是默認值；1表示當前位置；2表示文件結尾。
f.tell()	得到文件指針位置。
f.truncate([size])	截取文件，使文件的大小爲size。
f.write(string)	把string字符串寫入文件。
f.writelines(list)	把list中的字符串一行一行地寫入文件，是連續寫入文件，沒有換行。

例1：從文本文件中每讀取一行文本便輸出

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = open('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

line = fileHandler.readline()

while line:

print line

line = fileHandler.readline()

fileHandler.close

例2:其餘文件IO函數的使用

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = open('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

#讀取整個文件

contents = fileHandler.read()

print contents

#讀取全部行,再逐行輸出

fileHandler.seek(0)

lines = fileHandler.readlines()

for line in lines:

print line

#當前文件指針的位置

print fileHandler.tell()

fileHandler.close

例3:用file(...)替換open(...)

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = file('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

line = fileHandler.readline()

while line:

print line

line = fileHandler.readline()

例4:文件的寫操做

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = file('/root/a.txt','a+') #或者調用open()函數

fileHandler.write("\r\n")

fileHandler.write("thank you")

fileHandler.seek(0)

contents = fileHandler.read()

print contents

fileHandler.close

1.8.2 文件夾相關操做

Python中對文件、文件夾（文件操做函數）的操做須要涉及到os模塊和shutil模塊。

獲得當前工做目錄，即當前Python腳本工做的目錄路徑: os.getcwd()

返回指定目錄下的全部文件和目錄名:os.listdir()

刪除一個文件:os.remove()

刪除多個目錄（只能刪除空目錄）：os.removedirs（r」c：\python」）

檢驗給出的路徑是不是一個文件：os.path.isfile()

檢驗給出的路徑是不是一個目錄：os.path.isdir()

判斷是不是絕對路徑：os.path.isabs()

檢驗給出的路徑是否存在:os.path.exists()

返回一個路徑的目錄名和文件名:os.path.split()

Eg：

os.path.split('/home/swaroop/byte/code/poem.txt')

結果：('/home/swaroop/byte/code', 'poem.txt')

分離擴展名：os.path.splitext()

獲取路徑名：os.path.dirname()

獲取文件名：os.path.basename()

運行shell命令: os.system()

讀取和設置環境變量:os.getenv() 與os.putenv()

給出當前平臺使用的行終止符:os.linesep Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

指示你正在使用的平臺：os.name 對於Windows，它是'nt'，而對於Linux/Unix用戶，它是'posix'

重命名：os.rename（old， new）

建立多級目錄：os.makedirs（r「c：\python\test」）

建立單個目錄：os.mkdir（「test」）

獲取文件屬性：os.stat（file）

修改文件權限與時間戳：os.chmod（file）

終止當前進程：os.exit（）

獲取文件大小：os.path.getsize（filename）

1.9 Python多線程

Python中的多線程是僞線程；不能充分利用cpu中的多核，可是在io等待型的場景下多線程仍是能夠提升效率

Python中的多線程有多種實現方式，利用threading包實現是比較廣泛的作法

示例代碼以下：

import threading

from time import ctime,sleep

def music(func):

for i in range(2):

print("i was listening to %s. %s" %(func,ctime()))

sleep(1)

def movie(func):

for i in range(2):

print("i was at the %s! %s" %(func,ctime()))

sleep(5)

threads=[]

t1=threading.Thread(target=music,args=(u'愛情買賣'))

threads.append(t1)

t2=threading.Thread(target=movie,args=(u'阿凡達',))

threads.append(t2)

# if __name__ == '__main__' :

for t in threads:

# t.setDaemon(True)

t.start()

# t.join()

print("all over %s" %ctime())

1.10面向對象

1.10.1 建立類

使用class語句來建立一個新類，class以後爲類的名稱並以冒號結尾，以下實例:

class ClassName:

'類的幫助信息' #類文檔字符串

class_suite #類體

類的幫助信息能夠經過ClassName.__doc__查看。

class_suite 由類成員，方法，數據屬性組成。

1.10.2 實例

如下是一個簡單的Python類實例:

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'全部員工的基類'

empCount = 0

#構造函數

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

empCount變量是一個類變量，它的值將在這個類的全部實例之間共享。你能夠在內部類或外部類使用Employee.empCount訪問。

第一個方法__init__()方法是一種特殊的方法，被稱爲類的構造函數或初始化方法，當建立了這個類的實例時就會調用該方法

類的方法

使用def關鍵字能夠爲類定義一個方法，與通常函數定義不一樣，類方法必須包含參數self,且爲第一個參數

1.10.3 建立實例對象

要建立一個類的實例，你可使用類的名稱，並經過__init__方法接受參數。

"建立 Employee 類的第一個對象"

emp1 = Employee("Zara", 2000)

"建立 Employee 類的第二個對象"

emp2 = Employee("Manni", 5000)

訪問屬性

可使用點(.)來訪問對象的屬性。使用以下類的名稱訪問類變量:

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

完整實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'全部員工的基類'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

"建立 Employee 類的第一個對象"

emp1 = Employee("Zara", 2000)

"建立 Employee 類的第二個對象"

emp2 = Employee("Manni", 5000)

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

執行以上代碼輸出結果以下：

Name : Zara ,Salary: 2000

Name : Manni ,Salary: 5000

Total Employee 2

你能夠添加，刪除，修改類的屬性，以下所示：

emp1.age = 7 # 添加一個 'age' 屬性

emp1.age = 8 # 修改 'age' 屬性

del emp1.age # 刪除 'age' 屬性

你也可使用如下函數的方式來訪問屬性：

getattr(obj, ‘name’[, default]) : 訪問對象的屬性。

hasattr(obj,’name’) : 檢查是否存在一個屬性。

setattr(obj,’name’,value) : 設置一個屬性。若是屬性不存在，會建立一個新屬性。

delattr(obj, ‘name’) : 刪除屬性。

hasattr(emp1, 'age') # 若是存在 'age' 屬性返回 True。

getattr(emp1, 'age') # 返回 'age' 屬性的值

setattr(emp1, 'age', 8) # 添加屬性 'age' 值爲 8

delattr(empl, 'age') # 刪除屬性 'age'

1.10.4 Python內置類屬性

__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）

__doc__ :類的文檔字符串

__name__: 類名

__module__: 類定義所在的模塊（類的全名是'__main__.className'，若是類位於一個導入模塊mymod中，那麼className.__module__ 等於 mymod）

__bases__ : 類的全部父類構成元素（包含了以個由全部父類組成的元組）

Python內置類屬性調用實例以下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'全部員工的基類'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__

print "Employee.__name__:", Employee.__name__

print "Employee.__module__:", Employee.__module__

print "Employee.__bases__:", Employee.__bases__

print "Employee.__dict__:", Employee.__dict__

執行以上代碼輸出結果以下：

Employee.__doc__: 全部員工的基類

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

1.10.5 私有屬性

一、類的私有屬性

__private_attrs：兩個下劃線開頭，聲明該屬性爲私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs

二、類的私有方法

__private_method：兩個下劃線開頭，聲明該方法爲私有方法，不能在類地外部調用。在類的內部調用 self.__private_methods

三、實例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class JustCounter:

__secretCount = 0 # 私有變量

publicCount = 0 # 公開變量

def count(self):

self.__secretCount += 1

self.publicCount += 1

print self.__secretCount

counter = JustCounter()

counter.count()

print counter.publicCount

print counter.__secretCount # 報錯，實例不能訪問私有變量

運行結果會報錯：

Traceback (most recent call last):

File "test.py", line 17, in <module>

print counter.__secretCount # 報錯，實例不能訪問私有變量

AttributeError: JustCounter instance has no attribute '__secretCount'

Python不容許實例化的類訪問私有數據，但你可使用 object._className__attrName 訪問屬性，將以下代碼替換以上代碼的最後一行代碼：

.........................

print counter._JustCounter__secretCount

執行以上代碼，執行結果以下：

1.10.6 python對象銷燬(垃圾回收)

同Java語言同樣，Python使用了引用計數這一簡單技術來追蹤內存中的對象。

在Python內部記錄着全部使用中的對象各有多少引用。

一個內部跟蹤變量，稱爲一個引用計數器。

當對象被建立時，就建立了一個引用計數，當這個對象再也不須要時，也就是說，這個對象的引用計數變爲0 時，它被垃圾回收。可是回收不是"當即"的，由解釋器在適當的時機，將垃圾對象佔用的內存空間回收。

a = 40 # 建立對象 <40>

b = a # 增長引用， <40> 的計數

c = [b] # 增長引用. <40> 的計數

del a # 減小引用 <40> 的計數

b = 100 # 減小引用 <40> 的計數

c[0] = -1 # 減小引用 <40> 的計數

垃圾回收機制不只針對引用計數爲0的對象，一樣也能夠處理循環引用的狀況。循環引用指的是，兩個對象相互引用，可是沒有其餘變量引用他們。這種狀況下，僅使用引用計數是不夠的。Python 的垃圾收集器其實是一個引用計數器和一個循環垃圾收集器。做爲引用計數的補充，垃圾收集器也會留心被分配的總量很大（及未經過引用計數銷燬的那些）的對象。在這種狀況下，解釋器會暫停下來，試圖清理全部未引用的循環。

實例

析構函數 __del__

__del__在對象銷燬的時候被調用，當對象再也不被使用時，__del__方法運行：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Point:

def __init__( self, x=0, y=0):

self.x = x

self.y = y

def __del__(self):

class_name = self.__class__.__name__

print class_name, "銷燬"

pt1 = Point()

pt2 = pt1

pt3 = pt1

print id(pt1), id(pt2), id(pt3) # 打印對象的id

del pt1

del pt2

del pt3

以上實例運行結果以下：

3083401324 3083401324 3083401324

Point 銷燬

1.10.7 類的繼承

面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是經過繼承機制。繼承徹底能夠理解成類之間的類型和子類型關係。

一、語法：

派生類的聲明，與他們的父類相似，繼承的基類列表跟在類名以後，以下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):

'Optional class documentation string'

class_suite

二、實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定義父類

parentAttr = 100

def __init__(self):

print "調用父類構造函數"

def parentMethod(self):

print '調用父類方法'

def setAttr(self, attr):

Parent.parentAttr = attr

def getAttr(self):

print "父類屬性 :", Parent.parentAttr

class Child(Parent): # 定義子類

def __init__(self):

print "調用子類構造方法"

def childMethod(self):

print '調用子類方法 child method'

c = Child() # 實例化子類

c.childMethod() # 調用子類的方法

c.parentMethod() # 調用父類方法

c.setAttr(200) # 再次調用父類的方法

c.getAttr() # 再次調用父類的方法

以上代碼執行結果以下：

調用子類構造方法

調用子類方法 child method

調用父類方法

父類屬性 : 200

你能夠繼承多個類

class A: # 定義類 A

.....

class B: # 定義類 B

.....

class C(A, B): # 繼承類 A 和 B

.....

可使用issubclass()或者isinstance()方法來檢測。

issubclass() - 布爾函數判斷一個類是另外一個類的子類或者子孫類，語法：issubclass(sub,sup)

isinstance(obj, Class) 布爾函數若是obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。

三、方法重寫

若是你的父類方法的功能不能知足你的需求，你能夠在子類重寫你父類的方法：

實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定義父類

def myMethod(self):

print '調用父類方法'

class Child(Parent): # 定義子類

def myMethod(self):

print '調用子類方法'

c = Child() # 子類實例

c.myMethod() # 子類調用重寫方法

執行以上代碼輸出結果以下：

四、基礎重載方法

下表列出了一些通用的功能，你能夠在本身的類重寫：

1/ __init__ ( self [,args...] )

構造函數

簡單的調用方法: obj = className(args)

2/ __del__( self )

析構方法, 刪除一個對象

簡單的調用方法 : dell obj

3/ __str__( self )

用於將值轉化爲適於人閱讀的形式

簡單的調用方法 : str(obj)

4/ __cmp__ ( self, x )

對象比較

簡單的調用方法 : cmp(obj, x)

#!/usr/bin/python

class Vector:

def __init__(self, a, b):

self.a = a

self.b = b

def __str__(self):

return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):

return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)

v2 = Vector(5,-2)

print v1 + v2

以上代碼執行結果以下所示:

Vector(7,8)

2 Numpy快速上手

2.1. 什麼是Numpy

Numpy是Python的一個科學計算的庫

主要提供矩陣運算的功能，而矩陣運算在機器學習領域應用很是普遍

Numpy通常與Scipy、matplotlib一塊兒使用。

雖然python中的list已經提供了相似於矩陣的表示形式，不過numpy爲咱們提供了更多的函數。

2.1.2 安裝導入了Numpy

（通用作法import numpy as np 簡單輸入）

>>> import numpy as np

>>> print np.version.version

1.6.2

2.1.3 Numpy組成

Numpy基礎部分中，有兩個主要內容，以下：

任意維數的數組對象（ndarray，n-dimensional array object）

通用函數對象（ufunc，universal function object）

2.2. 多維數組

2.2.1 Numpy中的數組<矩陣>

Numpy中，最重要的數據結構是：多維數組的類型（numpy.ndarray）

ndarray由兩部分組成：

實際所持有的數據；

描述這些數據的元數據（metadata）

與Python原生支持的List類型不一樣，數組的全部元素必須一樣的類型。

數組（即矩陣）的維度被稱爲axes，維數稱爲 rank

ndarray 的重要屬性包括:

² ndarray.ndim：數組的維數，也稱爲rank

² ndarray.shape：數組各維的大小，對一個n行m列的矩陣來講， shape 爲 (n,m)

² ndarray.size：元素的總數。

² ndarray.dtype：每一個元素的類型，能夠是numpy.int32, numpy.int16, and numpy.float64等

² ndarray.itemsize：每一個元素佔用的字節數。

² ndarray.data：指向數據內存。

2.2.2 ndarray經常使用方法示例

2.2.2.2 使用numpy.array方法

以list或tuple變量爲參數產生一維數組：

>>> print np.array([1,2,3,4])

[1 2 3 4]

>>> print np.array((1.2,2,3,4))

[ 1.2 2. 3. 4. ]

>>> print type(np.array((1.2,2,3,4)))

以list或tuple變量爲元素產生二維數組或者多維數組：

>>> x = np.array(((1,2,3),(4,5,6)))

>>> x

array([[1, 2, 3],

[4, 5, 6]])

>>> y = np.array([[1,2,3],[4,5,6]])

>>> y

array([[1, 2, 3],

[4, 5, 6]])

index 和slicing ：第一數值相似數組橫座標，第二個爲縱座標

>>> x[1,2]

>>> y=x[:,1] #取第二列

>>> y

array([2, 5])

涉及改變相關問題，咱們改變上面y是否會改變x？這是特別須要關注的！

>>> y[0] = 10

>>> y

array([10, 5])

>>> x

array([[ 1, 10, 3],

[ 4, 5, 6]])

經過上面能夠發現改變y會改變x ，於是咱們能夠推斷，y和x指向是同一塊內存空間值，系統沒有爲y 新開闢空間把x值賦值過去。

2.2.2.3 使用numpy.arange方法

>>> print np.arange(15)

[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]

>>> print type(np.arange(15))

>>> print np.arange(15).reshape(3,5)

[[ 0 1 2 3 4]

[ 5 6 7 8 9]

[10 11 12 13 14]]

>>> print type(np.arange(15).reshape(3,5))

2.2.2.4 使用numpy.linspace方法

例如，在從1到10中產生20個數：

>>> print np.linspace(1,10,20)

[ 1. 1.47368421 1.94736842 2.42105263 2.89473684

3.36842105 3.84210526 4.31578947 4.78947368 5.26315789

5.73684211 6.21052632 6.68421053 7.15789474 7.63157895

8.10526316 8.57894737 9.05263158 9.52631579 10. ]

使用numpy.zeros，numpy.ones，numpy.eye等方法能夠構造特定的矩陣

構造「0」矩陣：

>>> print np.zeros((3,4))

[[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]]

構造「1」矩陣

>>> print np.ones((3,4))

[[ 1. 1. 1. 1.]

[ 1. 1. 1. 1.]

[ 1. 1. 1. 1.]]

構造單位矩陣(E矩陣)

>>> print np.eye(3)

[[ 1. 0. 0.]

[ 0. 1. 0.]

[ 0. 0. 1.]]

2.2.2.5 獲取數組的屬性：

>>> a = np.zeros((2,2,2))

>>> print a.ndim #數組的維數

>>> print a.shape #數組每一維的大小

(2, 2, 2)

>>> print a.size #數組的元素數

>>> print a.dtype #元素類型

float64

>>> print a.itemsize #每一個元素所佔的字節數

2.2.3 數組的基本運算

數組的算術運算是按元素逐個運算。數組運算後將建立包含運算結果的新數組。

與其餘矩陣語言不一樣，NumPy中的乘法運算符*按元素逐個計算，矩陣乘法可使用dot函數或建立矩陣對象實現（後續介紹）

2.2.3.1 數組的加減運算

>>> a= np.array([20,30,40,50])

>>> b= np.arange( 4)

>>> b

array([0, 1, 2, 3])

>>> c= a-b

>>> c

array([20, 29, 38, 47])

將運算結果更新原數組，不建立新數組

>>> a= np.ones((2,3), dtype=int)

>>> b= np.random.random((2,3)) ##生成2*3矩陣，元素爲[0,1)範圍的隨機數

>>> a*= 3

>>> a

array([[3, 3, 3],

　　 [3, 3, 3]])

>>> b+= a #a轉換爲浮點類型相加

>>> b

array([[ 3.69092703, 3.8324276, 3.0114541],

　　　 [ 3.18679111, 3.3039349, 3.37600289]])

>>> a+= b # b轉換爲整數類型報錯

TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'

當數組中存儲的是不一樣類型的元素時，數組將使用佔用更多位（bit）的數據類型做爲其自己的數據類型，也就是偏向更精確的數據類型(這種行爲叫作upcast)。

>>> a= np.ones(3, dtype=np.int32)

>>> b= np.linspace(0,np.pi,3)

>>> b.dtype.name

'float64'

>>> c= a+b

>>> c

array([ 1., 2.57079633, 4.14159265])

>>> 'float64'

2.2.3.2 數組乘法運算

>>> b**2

array([0, 1, 4, 9])

>>> 10*np.sin(a)

array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854])

>>> a<35

array([True, True, False, False], dtype=bool)

2.2.3.3 數組內部運算

許多非數組運算，如計算數組全部元素之和，都做爲ndarray類的方法來實現，使用時須要用ndarray類的實例來調用這些方法。

二維數組：

>>> np.sum([[0, 1], [0, 5]])

>>> np.sum([[0, 1], [0, 5]], axis=0)

array([0, 6])

>>> np.sum([[0, 1], [0, 5]], axis=1)

array([1, 5])

>>> b= np.arange(12).reshape(3,4)

>>> b

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>> b.sum(axis=0) # 計算每一列的和

array([12, 15, 18, 21])

>>> b.min(axis=1) # 獲取每一行的最小值

array([0, 4, 8])

>>> b.cumsum(axis=1) # 計算每一行的累積和

array([[ 0, 1, 3, 6],

[ 4, 9, 15, 22],

[ 8, 17, 27, 38]])

三維數組：

>>> x

array([[[ 0, 1, 2],

[ 3, 4, 5],

[ 6, 7, 8]],

[[ 9, 10, 11],

[12, 13, 14],

[15, 16, 17]],

[[18, 19, 20],

[21, 22, 23],

[24, 25, 26]]])

>>> x.sum(axis=1)

array([[ 9, 12, 15],

[36, 39, 42],

[63, 66, 69]])

>>> x.sum(axis=2)

array([[ 3, 12, 21],

[30, 39, 48],

[57, 66, 75]])

求元素最值

>>> a= np.random.random((2,3))

>>> a

array([[ 0.65806048, 0.58216761, 0.59986935],[ 0.6004008, 0.41965453, 0.71487337]])

>>> a.sum()

　 3.5750261436902333

>>> a.min()

0.41965453489104032

>>> a.max()

0.71487337095581649

2.2.3.4 數組的索引、切片

和列表和其它Python序列同樣，一維數組能夠進行索引、切片和迭代操做。

>>> a= np.arange(10)** 3 #記住，操做符是對數組中逐元素處理的！

>>> a

array([0, 1, 8, 27, 64, 125, 216, 343, 512, 729])

>>> a[2]

>>> a[2:5]

array([ 8, 27, 64])

>>> a[:6:2]= -1000 # 等同於a[0:6:2]= -1000，從開始到第6個位置，每隔一個元素將其賦值爲-1000

>>> a

array([-1000, 1,-1000, 27,-1000, 125, 216, 343, 512, 729])

>>> a[: :-1] # 反轉a

array([ 729, 512, 343, 216, 125,-1000, 27,-1000, 1,-1000])

>>>for i in a:

... print i**2,

...

1000000 1 1000000 729 1000000 15625 46656 117649 262144 531441

多維數組能夠每一個軸有一個索引。這些索引由一個逗號分割的元組給出。

>>>def f(x,y):

... return 10*x+y

...

>>> b= np.fromfunction(f,(5,4),dtype=int) #fromfunction[dht3] 是一個函數

>>> b

array([[ 0, 1, 2, 3],

[10, 11, 12, 13],

[20, 21, 22, 23],

[30, 31, 32, 33],

[40, 41, 42, 43]])

>>> b[2,3]

>>> b[0:5, 1] # 每行的第二個元素

array([ 1, 11, 21, 31, 41])

>>> b[: ,1] # 與前面的效果相同

array([ 1, 11, 21, 31, 41])

>>> b[1:3,: ] # 每列的第二和第三個元素

array([[10, 11, 12, 13],

[20, 21, 22, 23]])

當少於提供的索引數目少於軸數時，已給出的數值按秩的順序複製，缺失的索引則默認爲是整個切片：

>>> b[-1] # 最後一行，等同於b[-1,:]，-1是第一個軸，而缺失的認爲是：，至關於整個切片。

array([40, 41, 42, 43])

b[i]中括號中的表達式被看成i和一系列"："，來表明剩下的軸。NumPy也容許你使用「點」像b[i,...]。

點(…)表明許多產生一個完整的索引元組必要的冒號。若是x是秩爲5的數組(即它有5個軸)，那麼:　　

l x[1,2,…] 等同於 x[1,2,:,:,:],

l x[…,3] 等同於 x[:,:,:,:,3]

l x[4,…,5,:] 等同 x[4,:,:,5,:]　

>>> c= array( [ [[ 0, 1, 2], #三維數組（n個2維數組疊加而成）

...[ 10, 12, 13]],

...

...[[100,101,102],

...[110,112,113]]] )

>>> c.shape

(2, 2, 3)

>>> c[1,...] #等同於c[1,:,:]或c[1]

array([[100, 101, 102],

[110, 112, 113]])

>>> c[...,2] #等同於c[:,:,2]

array([[ 2, 13],

[102, 113]])

2.2.3.5 矩陣的遍歷

>>>for row in b:

... print row

...

[0 1 2 3]

[10 11 12 13]

[20 21 22 23]

[30 31 32 33]

[40 41 42 43]

若是想對數組中每一個元素都進行處理，可使用flat屬性，該屬性是一個數組元素迭代器：

>>>for element in b.flat:

... print element,

...

0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

2.2.3.6 合併數組

使用numpy下的vstack（垂直方向）和hstack（水平方向）函數：

>>> a = np.ones((2,2))

>>> b = np.eye(2)

>>> print np.vstack((a,b))

[[ 1. 1.]

[ 1. 1.]

[ 1. 0.]

[ 0. 1.]]

>>> print np.hstack((a,b))

[[ 1. 1. 1. 0.]

[ 1. 1. 0. 1.]]

看一下這兩個函數有沒有涉及到淺拷貝這種問題：

>>> c = np.hstack((a,b))

>>> print c

[[ 1. 1. 1. 0.]

[ 1. 1. 0. 1.]]

>>> a[1,1] = 5

>>> b[1,1] = 5

>>> print c

[[ 1. 1. 1. 0.]

[ 1. 1. 0. 1.]]

經過上面能夠知道，這裏進行是深拷貝，而不是引用指向同一位置的淺拷貝。

2.2.3.7 深度拷貝

數組對象自帶了淺拷貝和深拷貝的方法，可是通常用深拷貝多一些：

>>> a = np.ones((2,2))

>>> b = a

>>> b is a

True

>>> c = a.copy() #深拷貝

>>> c is a

False

2.2.3.8 矩陣轉置運算

>>> a = np.array([[1,0],[2,3]])

>>> print a

[[1 0]

[2 3]]

>>> print a.transpose()

[[1 2]

[0 3]]

2.2.4 數組的形狀操做

2.4.1 reshape更改數組的形狀

數組的形狀取決於其每一個軸上的元素個數：

>>> a= np.floor(10*np.random.random((3,4)))

>>> a

array([[ 7., 5., 9., 3.],

[ 7., 2., 7., 8.],

[ 6., 8., 3., 2.]])

>>> a.shape

(3, 4)

能夠用多種方式修改數組的形狀：

>>> a.ravel() # 平坦化數組

array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.])

>>> a.shape= (6, 2)

>>> a.transpose()

array([[ 7., 9., 7., 7., 6., 3.],

[ 5., 3., 2., 8., 8., 2.]])

由ravel()展平的數組元素的順序一般是「C風格」的，就是以行爲基準，最右邊的索引變化得最快，因此元素a[0,0]以後是a[0,1]。若是數組改變成其它形狀(reshape)，數組仍然是「C風格」的。NumPy一般建立一個以這個順序保存數據的數組，因此ravel()一般不須要建立起調用數組的副本。但若是數組是經過切片其它數組或有不一樣尋常的選項時，就可能須要建立其副本。還能夠同過一些可選參數函數讓reshape()和ravel()構建FORTRAN風格的數組，即最左邊的索引變化最快。

2.4.2 resize更改數組形狀

reshape函數改變調用數組的形狀並返回該數組，而resize函數改變調用數組自身。

>>> a

array([[ 7., 5.],

[ 9., 3.],

[ 7., 2.],

[ 7., 8.],

[ 6., 8.],

[ 3., 2.]])

>>> a.resize((2,6))

>>> a

array([[ 7., 5., 9., 3., 7., 2.],

[ 7., 8., 6., 8., 3., 2.]])

##若是調用reshape，則會返回一個新矩陣

>>> a.reshape((2,6))

array([[ 7., 5., 9., 3., 7., 2.],

[ 7., 8., 6., 8., 3., 2.]])

3 數據挖掘與機器學習導論

----機器學習算法最適用的場景就是：不便用規則處理的場合

3.1數據挖掘

簡而言之，數據挖掘（Data Mining）是有組織有目的地收集數據，經過分析數據使之成爲信息，從而在大量數據中尋找潛在規律以造成規則或知識的技術。

3.2 數據挖掘與機器學習的關係

機器學習能夠用來做爲數據挖掘的一種工具或手段；

數據挖掘的手段不限於機器學習，譬如還有諸如統計學等衆多方法；

但機器學習的應用也遠不止數據挖掘，其應用領域很是普遍，譬如人工智能；

3.2機器學習

3.2.1定義

機器學習(Machine Learning, ML)是一門多領域交叉學科，涉及機率論、統計學、逼近論、凸分析、算法複雜度理論等多門學科。專門研究計算機怎樣模擬或實現人類的學習行爲，以獲取新的知識或技能，從新組織已有的知識結構使之不斷改善自身的性能。

它是人工智能的核心，是使計算機具備智能的根本途徑，其應用遍佈人工智能的各個領域。目前，世界上共有幾百種不一樣的機器學習算法。

3.2.2機器學習算法類別

分類與聚類

l Classification (分類)[dht4] ：

給定一堆樣本數據，以及這些數據所屬的類別標籤，經過算法來對預測新數據的類別

有先驗知識

l Clustering(聚類[dht5] )：

事先並不知道一堆數據能夠被劃分到哪些類，經過算法來發現數據之間的類似性，從而將類似的數據劃入相應的類，簡單地說就是把類似的東西分到一組

沒有先驗知識

常見的分類與聚類算法

經常使用的分類算法：k-最近鄰法(k-nearest neighbor，kNN)，決策樹分類法，樸素貝葉斯分類算法(native Bayesian classifier)、支持向量機(SVM)的分類器，神經網絡法，模糊分類法等等。

常見聚類算法： K均值(K-means clustering)聚類算法、K-MEDOIDS算法、CLARANS算法；BIRCH算法、CURE算法、CHAMELEON算法等；基於密度的方法：DBSCAN算法、OPTICS算法、DENCLUE算法等；基於網格的方法：STING算法、CLIQUE算法、WAVE-CLUSTER算法；

監督學習與無監督學習

機器學習按照訓練數據是否有「先驗知識」，通常劃分爲三類：

1) 監督學習(supervised learning)

2) 無監督學習(unsupervised learning)

3) 半監督學習(semi-supervised learning)

ü 監督式學習技術須要關於結果的先驗知識

例如，若是咱們正在研究一個市場活動的歷史數據，咱們能夠根據市場是否產生預期的反應來對數據進行分類，或決定下一步要花多少錢。監督式學習技術爲預測和分類提供了強大的工具。

ü 無監督學習技術不須要先驗知識。

例如，在某些欺詐的案例中，只有當事情發生好久之後，咱們纔可能知道某次交易是否是欺詐。在這種狀況下，與其試圖預測哪些交易是欺詐，咱們不如使用機器學習來識別那些可疑的交易，並作出標記，以備後續觀察。咱們對某種特定的結果缺少先驗知識、但仍但願從數據中汲取有用的洞察時，就要用到無監督式學習。

3.3 機器學習的應用步驟

1) 需求分析

2) 收集數據

3) 探索數據特性

4) 提取數據特徵並建模[dht6]

5) 開發代碼（經常使用語言：R語言，Python語言，spark mllib庫）

6) 訓練模型[dht7]

7) 應用系統集成（好比將訓練好的算法模型集成到推薦系統中）

通用機器學習算法應用工程技術架構

3.4 機器學習必需數學知識

在數據挖掘所用的機器學習算法中，很大一部分問題均可以歸結爲如下三個方面的數學知識：機率、距離、線性方程

3.4.1 機率

基本概念：

機率描述的是隨機事件發生的可能性

好比，拋一枚硬幣，出現正反兩面的機率各爲50%

基本計算：

設一個黑箱中有8個黑球2個紅球，現隨機抽取一個球，則

取到黑球的機率爲：8/(8+2) =0.8

取到紅球的機率：2 /(8+2) =0.2

條件機率：

假若有兩個黑箱A/B，A中有7黑球+1紅球，B中有1黑球+1紅球，假如隨機抽取到一個球爲紅球，問，球來自A箱的機率——這就是條件機率問題

所求機率可表示爲： p(A|紅球) 即在已知結果是紅球的條件下，是來自A的機率

條件機率的計算：

P(A|紅球) = P(A,紅球)/P(A)

<補充：具體運算過程>[dht8]

3.4.2 距離（類似度）

在機器學習中，距離一般用來衡量兩個樣本之間的類似度，固然，在數學上，距離這個概念很豐滿，有不少具體的距離度量，最直白的是「歐氏距離」，即幾何上的直線距離

v 圖示：

如圖，在二維平面上有兩個點(x1,y1) , (x2,y2)，求兩點之間的距離

v 計算方法：

D₁₂ =

而在機器學習中，一般涉及的是多維空間中點的距離計算，計算方式同樣：

Dn =

3.4.3 線性方程

機器學習中的線性擬合或迴歸分類問題都須要理解線性方程

v 圖示

線性方程用來描述二維空間中的直線或多維空間中的平面，好比在二維空間中，如圖

y=ax+b便是圖中直線的線性方程：

u x是自變量，y是因變量

u a b 是參數，決定直線的斜率和截距

若是在多維空間中，線性方程則是表示平面，方程形式如：ax+by+cz+d=0

v 計算方法

初等數學常常已知a, b求解x y，而在高等數學中，咱們每每是知道大量的(y,x)樣本好比(x1,y1)，(x2,y2),(x3,y3)要求反推參數列表(a,b,..)

在維度小，樣本數據都「正確+精確」的狀況下，能夠經過線性方程求解的方式來解出a,b,....

但在機器學習中，咱們拿到的大量樣本數據自己都是「不精確且充滿噪點」的，因此代入方程來求解a,b...顯然不可行，此時，通常都是採用逼近的思想[dht9] 來求解：

1) 設定參數的初始值——>代入樣本試探——>根據試探結果調整參數——>再次代入樣本試探——>再調整參數

2) 一直循環迭代直到得到一組滿意的參數

<補充：一個運算實例>[dht10]

3.4.5 向量和矩陣

在以上3大數學問題中，都涉及到大量樣本數據大量特徵值的「批量運算」，此時，可運用數學中的工具：「向量和矩陣」

N維向量：就是一個一維的數組(x1,x2,x3,x4,.....)，數組中的元素個數即爲向量的「維度數」

矩陣：將多個(好比M個) N維向量寫在一塊兒，就是矩陣（M*N）：

x11,x12,x13,x14,.....

x21,x22,x23,x24,.....

x31,x32,x33,x34,.....

x41,x42,x43,x44,.....

矩陣和向量的意義主要在哪呢？就是爲了方便快速地進行大量數據（尤爲是線性方程問題）的批量運算

如：

矩陣相加

矩陣相乘

Python2中，print是一個關鍵字

Python3中，print是一個函數，必須使用print(arg)

1) 函數塊以關鍵字def後跟函數名爲定義頭

2) 任何輸入參數或參數應該放在這些括號內。還能夠定義這些括號內的參數。

3) 函數的第一個語句能夠是一個可選的聲明 - 該函數或文檔字符串的文檔字符串。

4) 每一個函數中的代碼塊以冒號(:)開頭並縮進。

5) 該語句返回[表達式]退出功能，可選地傳遞迴一個表達式給調用者。不帶參數return語句返回None。

造成一個數組

行i：0~4

列j：0~3

Cij = i*10 + j

0*10+0 0*10+1 0*10+2 0*10+3

1*10+0 1*10+1 1*10+2 1*10+3

2*10+0 2*10+1 2*10+2 2*10+3

......

對於一個 classifier ，一般須要你告訴它「這個東西被分爲某某類」這樣一些例子，理想狀況下，一個 classifier 會從它獲得的訓練集中進行「學習」，從而具有對未知數據進行分類的能力，這種提供訓練數據的過程一般叫作 supervised learning (監督學習)

聚類的時候，咱們並不關心某一類是什麼，咱們須要實現的目標只是把類似的東西聚到一塊兒，所以，一個聚類算法一般只須要知道如何計算類似度就能夠開始工做了，所以 clustering 一般並不須要使用訓練數據進行學習，這在 Machine Learning 中被稱做 unsupervised learning (無監督學習).

這一部分須要工具的嫺熟和豐富的經驗，必定的抽象能力和對數據的敏感

這一部分須要熟練的開發能力

[dht8]

機器學習中怎麼強調都不爲過的一個核心思想

甚至能夠提高爲「逼近論」

[dht10]