Python快速上手

1 Python快速上手
1.1.Python简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到WWW浏览器再到游戏

12.Python集成开发环境
1.2.1 Python安装
Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。
可以直接下载相应平台的二进制代码，然后安装Python，或者使用C编译器手动编译源代码。编译的源代码，功能上有更多的选择性，为python安装提供了更多的灵活性。

以下为不同平台上安装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的安装目录。

Python 环境变量
下面几个重要的环境变量，它应用于Python：
变量名 描述
PYTHONPATH PYTHONPATH是Python搜索路径，默认我们import的模块都会从PYTHONPATH里面寻找。
PYTHONSTARTUP Python启动后，先寻找PYTHONSTARTUP环境变量，然后执行此文件中变量指定的执行代码。
PYTHONCASEOK 加入PYTHONCASEOK的环境变量, 就会使python导入模块的时候不区分大小写.
PYTHONHOME 另一种模块搜索路径。它通常内嵌于的PYTHONSTARTUP或PYTHONPATH目录中，使得两个模块库更容易切换。

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：
Linux: IDLE 是 Linux上最早的 Python IDE 。
Windows: Pycharm 是jetbrain出品的Python 集成开发环境
1.3.Python基本语法
1.3.1 行和缩进
Python中，不使用括号来表示代码的类和函数定义块或流程控制。
代码块是由行缩进，缩进位的数目是可变的，但是在块中的所有语句必须缩进相同的量。
如下所示：
if True:
print “True”
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.

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)字典

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!’

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 # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 3rd
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists

将输出以下结果：
[‘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 # Prints complete list
print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 2nd till 3rd
print tuple[2:] # Prints elements starting from 3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated lists
这将产生以下结果：
(‘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数据类型转换
有时候，可能需要执行的内置类型之间的转换。
类型之间的转换，只需使用类名作为函数。
int(x [,base]) 将x转换为一个整数。基数指定为base
long(x [,base] ) 将x转换为一个长整数。基数指定为base，
float(x) 将x转换到一个浮点数。
complex(real [,imag]) 创建一个复数。
str(x) 转换对象x为字符串表示形式。
repr(x) 对象x转换为一个表达式字符串。
eval(str) 计算一个字符串，并返回一个对象。
tuple(s) 把s转换为一个元组。
list(s) 把s转换为一个列表。
set(s) 把s转换为一个集合。
dict(d) 转成字典,d必须是（键，值）元组序列。

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 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): #to iterate between 10 to 20
for i in range(2,num): #to iterate on the factors of the number
if num%i == 0: #to determine the first factor
j=num/i #to calculate the second factor
print ‘%d equals %d * %d’ % (num,i,j)
break #to move to the next number, the #first FOR
else: # else part of the loop
print num, ‘is a prime number’
当执行上面的代码，产生以下结果：
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 基本形式
#定义函数
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 = [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]]

5.2默认参数和可变参数

默认参数

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 )

1.7.Python模块
简单地说，一个模块是由Python代码的文件。一个模块可以定义函数，类和变量。模块还可以包括可运行的代码。

1.7.1 模块的定义和导入
例：以下代码定义在support.py文件中
def print_func( par ):
print "Hello : ", par
return
在别的模块比如(hello.py)中可以导入以定义好的模块
#!/usr/bin/python

#导入模块
import support

使用导入的模块中的函数

support.print_func(“Zara”)

#------------------------------------------------
#或者
from support import print_func

print_func(“Zara”)

1.7.2 模块的定位
当导入一个模块，由Python解释器搜索按如下顺序搜索模块：
1)当前目录
2)然后shell变量PYTHONPATH中搜索
3)如果这些方法都失败，Python会检查默认路径：
在Linux上，默认路径是正常是/usr/local/lib/python/

PYTHONPATH是一个环境变量:
Windows系统的典型PYTHONPATH：
set PYTHONPATH=c:python20lib;

Linux系统的典型PYTHONPATH：
set PYTHONPATH=/usr/local/lib/python

1.8.Python文件IO

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)))
<type ‘numpy.ndarray’>

以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]
6
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))
<type ‘numpy.ndarray’>
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))
<type ‘numpy.ndarray’>

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.]]

构造单位矩阵

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 #数组的维数
3
print a.shape #数组每一维的大小
(2, 2, 2)
print a.size #数组的元素数
8
print a.dtype #元素类型
float64
print a.itemsize #每个元素所占的字节数
8

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))
a*= 3
a
array([[3, 3, 3],
　　 [3, 3, 3]])
b+= a
b
array([[ 3.69092703, 3.8324276, 3.0114541],
　　　 [ 3.18679111, 3.3039349, 3.37600289]])
a+= b # b转换为整数类型
a
array([[6, 6, 6],
[6, 6, 6]])

当数组中存储的是不同类型的元素时，数组将使用占用更多位（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])
c.dtype.name
‘float64’
d= exp(c*1j)
d
array([ 0.54030231+0.84147098j,-0.84147098+0.54030231j,
　　　 -0.54030231-0.84147098j])
d.dtype.name
‘complex128’

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]])
6
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]
8
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(1/3.),
…
nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0

多维数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。

def f(x,y):
… return 10*x+y
…
b= np.fromfunction(f,(5,4),dtype=int) #fromfunction是一个函数
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]
23
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个轴)，那么:　　
x[1,2,…] 等同于 x[1,2,:,:,:],  
x[…,3] 等同于 x[:,:,:,:,3]
x[4,…,5,:] 等同 x[4,:,:,5,:]　
c= array( [ [[ 0, 1, 2], #三维数组（两个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操作中指定一个维度为-1，那么其准确维度将根据实际情况计算得到

3 数据挖掘与机器学习导论
3.1数据挖掘
简而言之，数据挖掘（Data Mining）是有组织有目的地收集数据，通过分析数据使之成为信息，从而在大量数据中寻找潜在规律以形成规则或知识的技术。

3.2 数据挖掘与机器学习的关系
机器学习可以用来作为数据挖掘的一种工具或手段；
但机器学习的应用远不止数据挖掘，其应用领域非常广泛；
3.2机器学习
3.2.1定义
机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域。目前，世界上共有几百种不同的机器学习算法。
3.2.2机器学习算法类别
分类与聚类
Classification (分类)：
给定一堆样本数据，以及这些数据所属的类别，通过算法来对预测新数据的类别

Clustering(聚类)：
事先并不知道一堆数据可以被划分到哪些类，通过算法来发现数据之间的相似性，从而将相似的数据划入相应的类，简单地说就是把相似的东西分到一组

常见的分类与聚类算法
常用的分类算法：决策树分类法，朴素贝叶斯分类算法(native Bayesian classifier)、基于支持向量机(SVM) 的分类器，神经网络法，k-最近邻法(k-nearest neighbor，kNN)，模糊分类法等等。

常见聚类算法： K均值(K-means clustering)聚类算法、K-MEDOIDS算法、CLARANS算法；BIRCH算法、CURE算法、CHAMELEON算法等；基于密度的方法：DBSCAN算法、OPTICS算法、DENCLUE算法等；基于网格的方法：STING算法、CLIQUE算法、WAVE-CLUSTER算法；
监督学习与无监督学习
机器学习按照训练数据是否有“先验知识”，一般划分为三类：
1)监督学习(supervised learning)
2)半监督学习(semi-supervised learning)
3)无监督学习(unsupervised learning)

监督式学习技术需要关于结果的先验知识
例如，如果我们正在研究一个市场活动的历史数据，我们可以根据市场是否产生预期的反应来对数据进行分类，或决定下一步要花多少钱。监督式学习技术为预测和分类提供了强大的工具。

无监督学习技术不需要先验知识。
例如，在某些欺诈的案例中，只有当事情发生很久以后，我们才可能知道某次交易是不是欺诈。在这种情况下，与其试图预测哪些交易是欺诈，我们不如使用机器学习来识别那些可疑的交易，并做出标记，以备后续观察。但我们对某种特定的结果缺乏先验知识、但仍希望从数据中汲取有用的洞察时，就要用到无监督式学习。
3.3 机器学习的应用步骤
1)需求分析
2)收集数据
3)探索数据特性
4)提取数据特征并建模
5)开发代码（常用语言：R语言，Python语言）
6)训练模型
7)应用系统集成（比如将训练好的算法模型集成到推荐系统中）

3.4 机器学习必需数学知识
在数据挖掘所用的机器学习算法中，几乎所有问题都可以归结为以下三个方面的数学知识：概率、距离、线性方程
3.4.1 概率
基本概念：
概率描述的是随机事件发生的可能性
比如，抛一枚硬币，出现正反两面的概率各为50%

基本计算：
设一个黑箱中有8个黑球2个红球，现随机抽取一个球，则
取到黑球的概率为：8/(8+2) =0.9
取到红球的概率：2 /(8+2) =0.2

条件概率：
假如有两个黑箱A/B，A中有7黑球+1红球，B中有1黑球+1红球，假如随机抽取到一个球为红球，问，球来自A箱的概率——这就是条件概率问题
所求概率可表示为： p(A|红球) 即在已知结果是红球的条件下，是来自A的概率

条件概率的计算：
P(A|红球) = P(A,红球)/P(A)
<补充：具体运算过程>
3.4.2 距离（相似度）
在机器学习中，距离通常用来衡量两个样本之间的相似度，当然，在数学上，距离这个概念很丰满，有很多具体的距离度量，最直白的是“欧氏距离”，即几何上的直线距离

图示：
如图，在二维平面上有两个点(x1,y1) , (x2,y2)，求两点之间的距离

计算方法：
D12 =
而在机器学习中，通常涉及的是多维空间中点的距离计算，计算方式一样：
Dn =

3.4.3 线性方程
机器学习中的线性拟合或回归分类问题都需要理解线性方程

图示
线性方程用来描述二维空间中的直线或多维空间中的平面，比如在二维空间中，如图

y=ax+b即是图中直线的线性方程：
x是自变量，y是因变量
a b 是参数，决定直线的斜率和截距
如果在多维空间中，线性方程则是表示平面，方程形式如：ax+by+cz+d=0

计算方法
初等数学经常已知a, b求解x y，而在高等数学中，我们往往是知道大量的(y,x)样本比如(x1,y1)，(x2,y2),(x3,y3)要求反推参数列表(a,b,…)
在维度小，样本数据都“正确+精确”的情况下，可以通过线性方程求解的方式来解出a,b,…
但在机器学习中，我们拿到的大量样本数据本身都是“不精确且充满噪点”的，所以代入方程来求解a,b…显然不可行，此时，一般都是采用逼近的思想来求解：
1)设定参数的初始值——>代入样本试探——>根据试探结果调整参数——>再次代入样本试探——>再调整参数
2)一直循环迭代直到获得一组满意的参数
<补充：一个运算实例>

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,…

矩阵和向量的意义主要在哪呢？就是为了方便快速地进行大量数据（尤其是线性方程问题）的批量运算

如：
矩阵相加

矩阵相乘