来源于：https://github.com/HanXiaoyang/python-and-numpy-tutorial/blob/master/python-numpy-tutorial.ipynb

python与numpy基础

寒小阳(2016年6月)

Python介绍

如果你问我没有编程基础，想学习一门语言，我一定会首推给你Python
类似伪代码的书写方式，让你能够集中精力去解决问题，而不是花费大量的时间在开发和debug上
同时得益于Numpy/Scipy这样的科学计算库，使得其有非常高效和简易的科学计算能力。
而活跃的社区提供的各种可视化的库，也使得机器学习/数据挖掘的全过程(数据采集，数据清洗，数据处理，建模，可视化)可以非常流畅地完成。
而近年来极其热门的深度学习开源框架，基本都有python接口，google的Tensorflow更是python主导。

这个教程里面的内容包括：

基本Python语法: 基本数据类型 (Containers, Lists, Dictionaries, Sets, Tuples), 函数, 类
Numpy: Arrays/数组, Array indexing/数组取值, Datatypes, Array math, Broadcasting

基本python语法

Python确实经常被人像伪代码，下面是一个快排程序，你可以感受一下:

In [2]:

def quicksort(arr):
    if len(arr) <= 1: return arr pivot = arr[len(arr) / 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quicksort(left) + middle + quicksort(right) print quicksort([3,6,9, 8,10,1,2,1])

[1, 1, 2, 3, 6, 8, 9, 10]

基本数据类型

数值型

整型和浮点型以及基本的运算大家应该都知道：

In [3]:

x = 4
print x, type(x)

4 <type 'int'>

In [4]:

print x + 1   # 加;
print x - 1 # 减; print x * 2 # 乘; print x ** 2 # 指数;

In [5]:

x += 1
print x  # 自加 x *= 2 print x # 自乘

5
10

In [7]:

y = 2.5
print type(y) # 输出类型 print y, y + 1, y * 2, y ** 2 # 连续输出

<type 'float'>
2.5 3.5 5.0 6.25

不过需要提醒一句，用习惯C++和Java的同学，Python真的没有(x++)和(x--)这俩操作

布尔型

用于指定真假的类型，布尔型，包含真（True）和假（False）:

In [139]:

t, f = True, False print type(t) # Prints "<type 'bool'>"

<type 'bool'>

看看逻辑与或非这些操作

In [140]:

print t and f # Logical AND;
print t or f # Logical OR; print not t # Logical NOT; print t != f # Logical XOR;

False
True
False
True

字符串型

In [142]:

hello = 'hello'   # 实在想不出的时候就用hello world
world = "world" print hello, len(hello) # 字符串长度

hello 5

In [143]:

hw = hello + ' ' + world # 字符串拼接 print hw

hello world

In [144]:

hw12 = '%s %s %d' % (hello, world, 12) # 类似sprintf的格式化输出 print hw12 # prints "hello world 12"

hello world 12

我能说什么，你面试的时候面试官最爱让你写的字符串操作，都是它自带的:

In [26]:

s = "hello"
print s.capitalize() # 首字母大写 print s.upper() # 全大写 print s.rjust(7) # 靠右对齐 print s.center(7) # 居中输出 print s.replace('l', '(ell)') # 字符串替换 print ' world '.strip() # 去掉两侧空白

Hello
HELLO
  hello
 hello 
he(ell)(ell)o
world

其他你想要的字符串操作看这里.

容器

内置的容器用得非常非常多，包括: lists, dictionaries, sets, and tuples.

Lists/列表

和你学数据结构里面数组长得一样的容器，但是操作可多多了:

In [8]:

xs = [3, 1, 2] # 建一个列表 print xs, xs[2] print xs[-1] # 用-1表示最后一个元素，输出来

[3, 1, 2] 2
2

In [9]:

xs[2] = 'Hanxiaoyang' # 有意思的是，Python的list居然可以有不同类型的元素 print xs

[3, 1, 'Hanxiaoyang']

In [10]:

xs.append('happy') # 可以用append在尾部添加元素 print xs

[3, 1, 'Hanxiaoyang', 'happy']

In [11]:

x = xs.pop() # 也可以把最后一个元素“弹射”出来 print x, xs

happy [3, 1, 'Hanxiaoyang']

关于list更多的操作和内容可以看这里.

列表切片

这是大家最爱python list的原因之一，取东西太方便啦:

In [12]:

nums = range(5) # 0-4 print nums # 输出 "[0, 1, 2, 3, 4]" print nums[2:4] # 下标2到4(不包括)的元素，注意下标从0开始 print nums[2:] # 下标2到结尾的元素; prints "[2, 3, 4]" print nums[:2] # 直到下标2的元素; prints "[0, 1]" print nums[:] # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]" print nums[:-1] # 直到倒数第一个元素; prints ["0, 1, 2, 3]" nums[2:4] = [8, 9] # 也可以直接这么赋值 print nums # Prints "[0, 1, 8, 8, 4]"

[0, 1, 2, 3, 4]
[2, 3]
[2, 3, 4]
[0, 1]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 8, 9, 4]

循环

可以对list立面的元素做一个循环:

In [13]:

animals = ['喵星人', '汪星人', '火星人'] for animal in animals: print animal

喵星人
汪星人
火星人

又要输出元素，又要输出下标怎么办，用 enumerate 函数:

In [14]:

animals = ['喵星人', '汪星人', '火星人'] for idx, animal in enumerate(animals): print '#%d: %s' % (idx + 1, animal)

#1: 喵星人
#2: 汪星人
#3: 火星人

List comprehensions:

如果对list里面的元素都做一样的操作，然后生成一个list，用它最快了，这绝对会成为你最爱的python操作之一:

In [15]:

# 求一个list里面的元素的平方，然后输出，很out的for循环写法
nums = [0, 1, 2, 3, 4] squares = [] for x in nums: squares.append(x ** 2) print squares

[0, 1, 4, 9, 16]

用list comprehension可以这么写:

In [16]:

nums = [0, 1, 2, 3, 4] # 对每个x完成一个操作以后返回来，组成新的list squares = [x ** 2 for x in nums] print squares

[0, 1, 4, 9, 16]

你甚至可以加条件，去筛出你想要的元素，去做你想要的操作:

In [17]:

nums = [0, 1, 2, 3, 4] # 把所有的偶数取出来，平方后返回 even_squares = [x ** 2 for x in nums if x % 2 == 0] print even_squares

[0, 4, 16]

字典

存储键值对(key => value)的数据结构, 类似Java中的Map，这真的是我使用频度相当高的数据结构:

In [158]:

d = {'cat': 'cute', 'dog': 'furry'} # 建立字典 print d['cat'] # 根据key取value print 'cat' in d # 查一个元素是否在字典中

cute
True

In [159]:

d['fish'] = 'wet' # 设定键值对 print d['fish'] # 这时候肯定是输出修改后的内容

wet

In [161]:

print d['monkey']  # 不是d的键，肯定输不出东西

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-161-85f0c5ba0fa7> in <module>()
----> 1 print d['monkey'] # KeyError: 'monkey' not a key of d KeyError: 'monkey'

In [162]:

print d.get('monkey', 'N/A') # 可以默认输出'N/A'（取不到key对应的value值的时候） print d.get('fish', 'N/A')

N/A
wet

In [163]:

del d['fish']        # 删除字典中的键值对 print d.get('fish', 'N/A') # 这会儿就没有了

N/A

同样的，你其他想了解的字典相关的操作和内容可以看这里.

你可以这样循环python字典取出你想要的内容:

In [164]:

d = {'person': 2, 'cat': 4, 'spider': 8} for animal in d: legs = d[animal] print 'A %s has %d legs' % (animal, legs)

A person has 2 legs
A spider has 8 legs
A cat has 4 legs

用iteritems函数可以同时取出键值对:

In [165]:

d = {'person': 2, 'cat': 4, 'spider': 8} for animal, legs in d.iteritems(): print 'A %s has %d legs' % (animal, legs)

A person has 2 legs
A spider has 8 legs
A cat has 4 legs

Dictionary comprehensions: 和list comprehension有点像啦，但是生成的是字典:

In [166]:

nums = [0, 1, 2, 3, 4] even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0} print even_num_to_square

{0: 0, 2: 4, 4: 16}

Sets

你可以理解成没有相同元素的列表（当然，显然和list是不同的）:

In [167]:

animals = {'cat', 'dog'} print 'cat' in animals # Check if an element is in a set; prints "True" print 'fish' in animals # prints "False"

True
False

In [170]:

animals.add('fish') # 添加元素 print 'fish' in animals print len(animals) # 元素个数

True
2

In [171]:

animals.add('cat') # 如果元素已经在set里了，操作不会怎么样 print len(animals) animals.remove('cat') # 删除一个元素 print len(animals)

3
2

循环的方式和list很像啦:

In [63]:

animals = {'cat', 'dog', 'fish'} for idx, animal in enumerate(animals): print '#%d: %s' % (idx + 1, animal) # Prints "#1: fish", "#2: dog", "#3: cat"

#1: fish
#2: dog
#3: cat

Set comprehensions: 熟悉的感觉:

In [172]:

from math import sqrt
print {int(sqrt(x)) for x in range(30)}

set([0, 1, 2, 3, 4, 5])

元组

和list很像，但是可以作为字典的key或者set的元素出现，但是一整个list不可以作为字典的key或者set的元素的:

In [173]:

d = {(x, x + 1): x for x in range(10)} # Create a dictionary with tuple keys t = (5, 6) # Create a tuple print type(t) print d[t] print d[(1, 2)]

<type 'tuple'>
5
1

In [176]:

t[0] = 1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-176-0a69537257d5> in <module>()
----> 1 t[0] = 1 TypeError: 'tuple' object does not support item assignment

函数

用 def 就可以定义一个函数，就像下面这样:

In [178]:

def sign(x):
    if x > 0: return 'positive' elif x < 0: return 'negative' else: return 'zero' for x in [-1, 0, 1]: print sign(x)

negative
zero
positive

函数名字后面接的括号里，可以有多个参数，你自己可以试试:

In [179]:

def hello(name, loud=False): if loud: print 'HELLO, %s' % name.upper() else: print 'Hello, %s!' % name hello('Bob') hello('Fred', loud=True)

Hello, Bob!
HELLO, FRED

类

Python的类，怎么说呢，比较简单粗暴:

In [76]:

class Greeter:

    # 构造函数
    def __init__(self, name): self.name = name # Create an instance variable # 类的成员函数 def greet(self, loud=False): if loud: print 'HELLO, %s!' % self.name.upper() else: print 'Hello, %s' % self.name g = Greeter('Fred') # 构造一个类 g.greet() # 调用函数; prints "Hello, Fred" g.greet(loud=True) # 调用函数; prints "HELLO, FRED!"

Hello, Fred
HELLO, FRED!

Numpy

我们要开始接触高效计算库Numpy了，你要是之前在实验室用MATLAB之类的语法，你会发现Numpy和它们长得不要太像，爱MATLAB的同学，参考文档可以看这里

python里面调用一个包，用import对吧, 所以我们import numpy 包:

In [19]:

import numpy as np

Arrays/数组

看你数组的维度啦，我自己的话比较简单粗暴，一般直接把1维数组就看做向量/vector，2维数组看做2维矩阵，3维数组看做3维矩阵...

可以调用np.array去从list初始化一个数组:

In [20]:

a = np.array([1, 2, 3]) # 1维数组 print type(a), a.shape, a[0], a[1], a[2] a[0] = 5 # 重新赋值 print a

<type 'numpy.ndarray'> (3,) 1 2 3
[5 2 3]

In [198]:

b = np.array([[1,2,3],[4,5,6]]) # 2维数组 print b

[[1 2 3]
 [4 5 6]]

In [199]:

print b.shape  #可以看形状的（非常常用！！！）                  
print b[0, 0], b[0, 1], b[1, 0]

(2, 3)
1 2 4

有一些内置的创建数组的函数:

In [186]:

a = np.zeros((2,2)) # 创建2x2的全0数组 print a

[[ 0.  0.]
 [ 0.  0.]]

In [187]:

b = np.ones((1,2)) # 创建1x2的全0数组 print b

[[ 1.  1.]]

In [188]:

c = np.full((2,2), 7) # 定值数组 print c

[[ 7.  7.]
 [ 7.  7.]]

In [190]:

d = np.eye(2) # 对角矩阵（对角元素为1） print d

[[ 1.  0.]
 [ 0.  1.]]

In [192]:

e = np.random.random((2,2)) # 2x2的随机数组(矩阵) print e

[[ 0.09477679  0.79267634]
 [ 0.78291274  0.38962829]]

Array indexing/数组取值

Numpy提供了蛮多种取值的方式的.

可以像list一样切片（多维数组可以从各个维度同时切片）:

In [203]:

import numpy as np

# 创建一个如下格式的3x4数组
# [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]] a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) # 在两个维度上分别按照[:2]和[1:3]进行切片，取需要的部分 # [[2 3] # [6 7]] b = a[:2, 1:3] print b

[[2 3]
 [6 7]]

虽然，怎么说呢，不建议你这样去赋值，但是你确实可以修改切片出来的对象，然后完成对原数组的赋值.

In [202]:

print a[0, 1] b[0, 0] = 77 # b[0, 0]改了，很遗憾a[0, 1]也被修改了 print a[0, 1]

2
77

In [21]:

# 创建3x4的2维数组/矩阵
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) print a

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

你就放心大胆地去取你想要的数咯:

In [22]:

row_r1 = a[1, :] # 第2行，但是得到的是1维输出（列向量） row_r2 = a[1:2, :] # 1x2的2维输出 row_r3 = a[[1], :] # 同上 print row_r1, row_r1.shape print row_r2, row_r2.shape print row_r3, row_r3.shape

[5 6 7 8] (4,)
[[5 6 7 8]] (1, 4)
[[5 6 7 8]] (1, 4)

In [23]:

# 试试在第2个维度上切片也一样的:
col_r1 = a[:, 1] col_r2 = a[:, 1:2] print col_r1, col_r1.shape print print col_r2, col_r2.shape

[ 2  6 10] (3,)

[[ 2]
 [ 6]
 [10]] (3, 1)

下面这个高级了，更自由地取值和组合，但是要看清楚一点:

In [220]:

a = np.array([[1,2], [3, 4], [5, 6]]) # 其实意思就是取(0,0),(1,1),(2,0)的元素组起来 print a[[0, 1, 2], [0, 1, 0]] # 下面这个比较直白啦 print np.array([a[0, 0], a[1, 1], a[2, 0]])

[1 4 5]
[1 4 5]

In [221]:

# 再来试试
print a[[0, 0], [1, 1]] # 还是一样 print np.array([a[0, 1], a[0, 1]])

[2 2]
[2 2]

In [24]:

# 再来熟悉一下
# 先创建一个2维数组
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]) print a

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

In [25]:

# 用下标生成一个向量
b = np.array([0, 2, 0, 1]) # 你能看明白下面做的事情吗？ print a[np.arange(4), b] # Prints "[ 1 6 7 11]"

[ 1  6  7 11]

In [218]:

# 既然可以取出来，我们当然可以对这些元素操作咯
a[np.arange(4), b] += 10 print a

[[21  2  3]
 [ 4  5 26]
 [27  8  9]
 [10 31 12]]

比较fashion的取法之一，用条件判定去取（但是很好用）:

In [223]:

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]]) bool_idx = (a > 2) # 就是判定一下是否大于2 print bool_idx # 返回一个布尔型的3x2数组

[[False False]
 [ True  True]
 [ True  True]]

In [225]:

# 用刚才的布尔型数组作为下标就可以去除符合条件的元素啦
print a[bool_idx] # 其实一句话也可以完成是不是？ print a[a > 2]

[3 4 5 6]
[3 4 5 6]

那个，真的，其实还有很多细节，其他的方式去取值，你可以看看官方文档。

我们一起来来总结一下，看下面切片取值方式（对应颜色是取出来的结果）：

Datatypes

我们可以用dtype来看numpy数组中元素的类型:

In [226]:

x = np.array([1, 2]) # numpy构建数组的时候自己会确定类型 y = np.array([1.0, 2.0]) z = np.array([1, 2], dtype=np.int64)# 指定用int64构建 print x.dtype, y.dtype, z.dtype

int64 float64 int64

更多的内容可以读读文档.

数学运算

下面这些运算才是你在科学运算中经常经常会用到的，比如逐个元素的运算如下:

In [227]:

x = np.array([[1,2],[3,4]], dtype=np.float64) y = np.array([[5,6],[7,8]], dtype=np.float64) # 逐元素求和有下面2种方式 print x + y print np.add(x, y)

[[  6.   8.]
 [ 10.  12.]]
[[  6.   8.]
 [ 10.  12.]]

In [228]:

# 逐元素作差
print x - y
print np.subtract(x, y)

[[-4. -4.]
 [-4. -4.]]
[[-4. -4.]
 [-4. -4.]]

In [229]:

# 逐元素相乘
print x * y
print np.multiply(x, y)

[[  5.  12.]
 [ 21.  32.]]
[[  5.  12.]
 [ 21.  32.]]

In [230]:

# 逐元素相除
# [[ 0.2         0.33333333]
#  [ 0.42857143  0.5       ]]
print x / y print np.divide(x, y)

[[ 0.2         0.33333333]
 [ 0.42857143  0.5       ]]
[[ 0.2         0.33333333]
 [ 0.42857143  0.5       ]]

In [231]:

# 逐元素求平方根！！！
# [[ 1.          1.41421356]
#  [ 1.73205081  2.        ]]
print np.sqrt(x)

[[ 1.          1.41421356]
 [ 1.73205081  2.        ]]

那如果我要做矩阵的乘法运算怎么办！！！恩，别着急，照着下面写就可以了:

In [232]:

x = np.array([[1,2],[3,4]]) y = np.array([[5,6],[7,8]]) v = np.array([9,10]) w = np.array([11, 12]) # 求向量内积 print v.dot(w) print np.dot(v, w)

219
219

In [233]:

# 矩阵的乘法
print x.dot(v) print np.dot(x, v)

[29 67]
[29 67]

In [234]:

# 矩阵的乘法
# [[19 22]
#  [43 50]]
print x.dot(y) print np.dot(x, y)

[[19 22]
 [43 50]]
[[19 22]
 [43 50]]

你猜你做科学运算会最常用到的矩阵内元素的运算是什么？对啦，是求和，用 sum可以完成:

In [235]:

x = np.array([[1,2],[3,4]]) print np.sum(x) # 数组/矩阵中所有元素求和; prints "10" print np.sum(x, axis=0) # 按行去求和; prints "[4 6]" print np.sum(x, axis=1) # 按列去求和; prints "[3 7]"

10
[4 6]
[3 7]

我想说最基本的运算就是上面这个样子，更多的运算可能得查查文档.

其实除掉基本运算，我们经常还需要做一些操作，比如矩阵的变形，转置和重排等等:

In [236]:

# 转置和数学公式一直，简单粗暴
print x
print x.T

[[1 2]
 [3 4]]
[[1 3]
 [2 4]]

In [26]:

# 需要说明一下，1维的vector转置还是自己
v = np.array([1,2,3]) print v print v.T # 2维的就不一样了 w = np.array([[1,2,3]]) print w print w.T

[1 2 3]
[1 2 3]
[[1 2 3]]
[[1]
 [2]
 [3]]

Broadcasting

这个没想好哪个中文词最贴切，我们暂且叫它“传播吧”:
作用是什么呢，我们设想一个场景，如果要用小的矩阵去和大的矩阵做一些操作，但是希望小矩阵能循环和大矩阵的那些块做一样的操作，那急需要Broadcasting啦

In [238]:

# 我们要做一件事情，给x的每一行都逐元素加上一个向量，然后生成y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]) v = np.array([1, 0, 1]) y = np.empty_like(x) # 生成一个和x维度一致的空数组/矩阵 # 比较粗暴的方式是，用for循环逐个相加 for i in range(4): y[i, :] = x[i, :] + v print y

[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

这种方法当然可以啦，问题是不高效嘛，如果你的x矩阵行数非常多，那就很慢的咯:
咱们调整一下，先生成好要加的内容

In [240]:

vv = np.tile(v, (4, 1)) # 重复4遍v，叠起来 print vv # Prints "[[1 0 1] # [1 0 1] # [1 0 1] # [1 0 1]]"

[[1 0 1]
 [1 0 1]
 [1 0 1]
 [1 0 1]]

In [241]:

y = x + vv  # 这样求和大家都能看明白对吧 print y

[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

Numpy broadcasting allows us to perform this computation without actually creating multiple copies of v. Consider this version, using broadcasting:

In [242]:

import numpy as np

# 因为broadcasting的存在，你上面的操作可以简单地汇总成一个求和操作
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]) v = np.array([1, 0, 1]) y = x + v # Add v to each row of x using broadcasting print y

[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

当操作两个array时，numpy会逐个比较它们的shape，在下述情况下，两arrays会兼容和输出broadcasting结果：

相等
其中一个为1，（进而可进行拷贝拓展已至，shape匹配）

比如求和的时候有：

Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 15 x 3 x 5 B (1d array): 15 x 1 x 5 Result (2d array): 15 x 3 x 5

下面是一些 broadcasting 的例子:

In [243]:

# 我们来理解一下broadcasting的这种用法
v = np.array([1,2,3]) # v 形状是 (3,) w = np.array([4,5]) # w 形状是 (2,) # 先把v变形成3x1的数组/矩阵，然后就可以broadcasting加在w上了: print np.reshape(v, (3, 1)) * w

[[ 4  5]
 [ 8 10]
 [12 15]]

In [244]:

# 那如果要把一个矩阵的每一行都加上一个向量呢
x = np.array([[1,2,3], [4,5,6]]) v = np.array([1,2,3]) # 恩，其实是一样的啦 print x + v

[[2 4 6]
 [5 7 9]]

In [245]:

x = np.array([[1,2,3], [4,5,6]]) # 2x3的 w = np.array([4,5]) # w 形状是 (2,) # 自己算算看？ print (x.T + w).T

[[ 5  6  7]
 [ 9 10 11]]

In [246]:

# 上面那个操作太复杂了，其实我们可以直接这么做嘛
print x + np.reshape(w, (2, 1))

[[ 5  6  7]
 [ 9 10 11]]

In [247]:

# broadcasting当然可以逐元素运算了
print x * 2

[[ 2  4  6]
 [ 8 10 12]]

总结一下broadcasting，可以看看下面的图：

更多的numpy细节和用法可以查看一下官网numpy指南

[转]python与numpy基础