Python Numpy学习教程（一）Python篇

通知：这篇文章主要简单介绍Python的基本数据结构、容器、列表、字典、集合、元组、函数和类等知识点

Python Numpy学习教程

Author:     Justin Johnson

Interpreter：Amusi

Date:   2018-03-24

Reference:

[1]：http://cs231n.github.io/python-numpy-tutorial/ 

[2]：https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb

注：Amusi是一名Python初学者，本教程是对CS231n课程中的python-numpy-tutorial进行翻译、注释并做部分修改攥写而来的。若文章存在翻译错误或者语法问题，还请及时指出。

Python Numpy学习教程目录

Python

• 基本数据结构

• 容器

  • 列表

  • 字典

  • 集合

  • 元组

• 函数

• 类

Numpy

• 数组

• 数组索引

• 数据类型

• 数组数学（Array math）

• 广播

SciPy

• 图像处理

• MATLAB文件

• 点之间的距离

Matplotlib

• 绘制

• 子图

• 图像

Python Numpy教程将分四篇内容来介绍：

• Python篇

• Numpy篇

• SciPy篇

• Matplotlib篇

本文只介绍（一）Python篇的内容，其它三篇会陆续更新。

Python

Python是一种高级动态类型的多参数编程语言。Python代码经常被认为和伪代码(pseudocode)一样，因为它允许你在非常少的几行代码中表达非常强大的想法，同时可读性很高。举个例子，下面是Python中经典的快速排序算法的实现：

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

Python版本

目前有两种不同的Python支持版本，2.7和3.5（截至2018-02-07，还有3.6）。 令人有些困惑的是，Python3.5引入许多向后不兼容的语言变化，因此用2.7编写的代码可能不能在3.5下工作，反之亦然。针对这个原因和趋势（官方通知Python2.7版本将在2020停止维护），本教程所有代码都将基于Python3.5编写。

你可以通过在命令行运行python --version来检查你的Python版本。

1python --version                                                                                                      

基本数据类型

像大多数语言一样，Python有许多基本类型，包括整数，浮点数，布尔型和字符串。这些数据类型的用法与其他编程语言相似。

数值(Numbers)

整数(Integers)和浮点数(floats)按照您从其他语言期望的方式工作：

 1# 基本数据类型
 2x = 3
 3print(type(x))  # 打印 ""
 4print(x)        # 打印 "3"
 5print(x + 1)    # 加法: 打印 "4"
 6print(x - 1)    # 减法: 打印 "2"
 7print(x * 2)    # 乘法: 打印 "6"
 8print(x ** 2)   # 取幂: 打印 "9"
 9print(x / 2)    # 除法: 打印 "1.5"
10print(x // 2)   # 取整除: 打印 "1"
11x += 1          # 自增
12print(x)        # 打印 "4"
13x *= 2          # 自乘
14print(x)        # 打印 "8"
15y = 2.5
16print(type(y))  # 打印 ""
17print(y, y+1, y*2, y ** 2)  # 打印 "2.5, 3.5, 5.0, 6.25"

注意：与其他语言不同，Python没有一元自增运算符(x++)或者一元自减运算符(x--)。

Python也有复杂数字的内置(built-in)类型; 你可以在Numeric Types文档中找到所有内置类型的详细介绍。

布尔型(Booleans)

Python实现了布尔逻辑的所以常用运算符，但使用英语单词而不是符号(&&,||等):

1# 布尔型
2t = True
3f = False
4print(type(t))  # 打印 ""
5print(t and f)  # 逻辑与: 打印 "False"
6print(t or f)   # 逻辑或: 打印 "True"
7print(not t)    # 逻辑非: 打印 "False"
8print(not f)    # 逻辑非: 打印 "True"
9print(t != f)   # 逻辑异或: 打印 "True"

字符串(String)

Python对字符串有很好的支持:

 1# 字符串
 2hello = 'hello' # 字符串可以使用单引号'' 
 3world = "world" # 或者使用双引号""
 4print(hello)    # 打印 "hello"
 5print(world)    # 打印 "world"
 6print(len(hello))   # 字符串长度: 打印 "5"
 7hw = hello + ' ' + world    # 字符串连接(concatenation)
 8print(hw)       # 打印 "hello world"
 9hw12 = '%s %s %d' % (hello, world, 12)  # sprintf 类型-字符串格式化
10print(hw12)     # 打印 "hello world 12"

字符串对象有许多有用的方法，如:

1s = "hello"
2print(s.title())        # 将字符串标题化，即首字母变成大写，其它字母变成小写: 打印 "Hello"
3print(s.capitalize())   # 与title方法作用一直: 打印 "Hello"
4print(s.upper())        # 将字符串转换为大写; 打印 "HELLO"
5print(s.lower())        # 将字符串转换成小写: 打印 "hello"
6print(s.rjust(7))       # 右对齐字符串, 用空格填充; 打印 "  hello"
7print(s.center(7))      # 将字符串居中, 用空格填充: 打印 " hello "
8print(s.replace('l', '(ell)'))  # 子字符串替换: 打印 "he(ell)(ell)0"
9print('  world '.strip()) # 删除首尾空格: 打印 "world"

你可以在String Methods文档中找到关于字符串方法的更多内容。

容器(Containers)

Python包含几个内置的容器(container)类型: 

• 列表(lists)

• 字典(dictionaries)

• 集合(sets)

• 元组((tuples)

列表(Lists)

列表在Python中等价于数组，但是调整大小，并且可以包含不同类型的元素:

 1# 列表
 2xs = [3, 1, 2]  # 创建列表
 3print(xs, xs[2])# 打印 "[3, 1, 2] 2"
 4print(xs[-1])   # 负数索引值是指向列表中的尾部: 打印 "2"
 5xs[2] = 'foo'   # 列表可以包含不同类型的元素
 6print(xs)       # 打印 "[3 1 'foo']"
 7xs.append('bar')# 在列表的尾部添加新元素
 8print(xs)       # 打印 "[3 1 'foo' 'bar']"
 9x = xs.pop()    # 删除并返回列表中的尾部元素
10print(x, xs)    # 打印 "bar [3, 1. 'foo']"

你可以在More on Lists文档中找到关于列表的更多内容。

切片(Slicing)

除了每次访问一个列表元素外，Python还提供简介的语法来访问子列表；其被称为切片(slicing):

 1# 切片(slicing)
 2nums = list(range(5))
 3print(nums)     # 打印 "[0, 1, 2, 3, 4]"
 4print(nums[2:4])# 将索引2到4(不包括4)的列表元素作为片(slice): 打印 "[2, 3]"
 5print(nums[2:]) # 将索引2到尾部的列表元素作为片(slice): 打印 "[2, 3, 4]"
 6print(nums[:2]) # 将首部到索引2(不包括2)的列表元素作为片(slice): 打印 "[0, 1]"
 7print(nums[:])  # 将整个列表作为片(slice): 打印 "[0, 1, 2, 3, 4]"
 8print(nums[:-1])# 切片的索引可以是负数: 打印 "[0, 1, 2, 3]"
 9nums[2:4] = [8, 9]  # 为片分配给新的子列表
10print(nums)     # 打印 "[0, 1, 8, 9, 4]"

循环(Loops)

你可以像这样循环列表中的元素:

 1# 循环(Loops)
 2animals = ['cat', 'dog', 'monkey']
 3for animal in animals:
 4  print(animal)
 5# 逐行打印 "cat", "dog", "monkey"
 6如果要访问循环体内每个元素的索引，请使用内置的enumerate枚举函数：
 7animals = ['cat', 'dog', 'monkey']
 8for idx, animal in enumerate(animals):
 9  print('#%d: %s' % (idx+1, animal))
10# 逐行打印 "#1: cat", "#2: dog", "#3: monkey"

列表推导式(List comprehensions)

编程时，我们经常要将一种类型的数据转换成另一种类型的数据(可以是类型，也可以是数值)。举个简单示例，用下面的代码计算平方数:

 1# 列表推导式(List comprehensions)
 2nums = [0, 1, 2, 3, 4]
 3squares = []
 4for x in nums:
 5  squares.append(x ** 2)
 6print(squares)  # 打印 [0, 1, 4, 9, 16]
 7你可以使用列表推导式简化上述代码:
 8# 用列表推导式(List comprehensions)计算平方数
 9nums = [0, 1, 2, 3, 4]
10squares = [x ** 2 for x in nums]
11print(squares)

列表推倒式也可以包含条件:

1nums = [0, 1, 2, 3, 4]
2even_squares = [x ** 2 for x in nums if x % 2 == 0]
3print(even_squares) # 打印 "[0, 4, 16]"

字典(Dictionaries)

字典存储(键key，值value)对，类似于Java中的Map或者Javascript中的对象。你可以像这样使用它:

 1d = {'cat':'cute', 'dog':'furry'}   # 创建含有数据的新字典
 2print(d['cat'])     # 从字典中根据键寻找对应值; 打印 "cute"
 3print('cat' in d)   # 判断字典中是否有给定的键; 打印 "True"
 4d['fish'] = 'wet'   # 在字典中添加新的对
 5print(d['fish'])    # 打印 "wet"
 6# print(d['monkey'])# KeyError: 'monkey'不是d中的键
 7print(d.get('monkey'), 'N/A')   # 获取一个默认的元素; 打印 "N/A"
 8print(d.get('fish'), 'N/A')     # 获得一个默认的元素; 打印 "wet"
 9del d['fish']       # 删除字典中的元素
10print(d.get('fish'), 'N/A')     # "fish"已经被删除所以不是键了; 打印 "N/A"

你可以在Mapping Types——dict文档中找到关于字典的更多内容。

循环(Loops)

通过键很容易遍历字典:

1d = {'person':2, 'cat':4, 'spider':8}
2for animal in d:
3  legs = d[animal]
4  print('A %s has %d legs' % (animal, legs))
5# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

如果你想访问keys和对应的值，可以使用items方法:

1d = {'person':2, 'cat':4, 'spider':8}
2for animal, legs in d.items():
3  print('A %s has %d legs' % (animal, legs))
4# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

字典推导式(Dictionary comprehensions)

与列表推导式类似，但允许你很容易构建字典。如:

1num = [0, 1, 2, 3, 4]
2even_num_to_square = {x:x**2 for x in nums if x % 2 == 0}
3print(even_num_to_square)   # 打印 "{0:0, 2:4, 4:16}"

集合(Sets)

集合是特殊元素的无序集合。简单的示例如下:

 1animals = {'cat', 'dog'}    # 创建集合
 2print('cat' in animals)     # 判断元素是否在集合中; 打印 "True"
 3print('fish' in animals)    # 打印 "False"
 4animals.add('fish')         # 添加新元素
 5print('fish' in animals)    # 打印 "True"
 6print(len(animals))         # 集合中的元素数量; 打印 "3"
 7animals.add('cat')          # 添加已经存在的元素: 无变化
 8print(len(animals))         # 打印 "3"
 9animals.remove('cat')    # 删除元素
10print(len(animals))         # 打印 "2"

你可以在Set Types文档中找到关于集合的更多内容。

循环(Loops)

遍历集合与遍历列表有相同的语法；然而因为集合是无序的，所以你不能猜测你访问集合中元素的次序:

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

集合推导式(Set comprehensions)

与列表和字典相似，我们可以很容易使用集合推导式来创建集合:

1from math import sqrt
2nums = {int(sqrt(x)) for x in range(30)}
3print(nums) # 打印 "{0, 1, 2, 3, 4, 5}"

元组(Tuples)

元组是一个(不可变的)有序的值列表。元组在很多方面与列表类似；最重要的不同是元组可以用作字典的键和集合的元素，然而列表都不可以。这里有个简单示例:

1d = {(x, x + 1): x for x in range(10)} # 创建含有元组键的字典
2t = (5, 6)      # 创建元组
3print(type(t))  # 打印 ""
4print(d[t])     # 将元组作为键在字典中获得对应的值: 打印 "5"
5print(d[(1, 2)])# 打印 "1"

你可以在Tuples and Sequences文档中找到关于元组的更多内容。

函数(Functions)

Python函数是使用def关键字定义的。例如:

 1def sign(x):
 2  if x > 0:
 3      return 'positive'
 4  elif x < 0:
 5      return 'negative'
 6  else:
 7      return 'zero'
 8for x in [-1, 0, 1]:
 9  print(sign(x))
10# 打印 "negative", "zero", "positive"

我们经常采用可选的关键字参数来定义函数(含参函数)，例如:

1def hello(name, loud = False):
2  if loud:
3      print('HELLO, %s!' % name.upper())
4  else:
5      print('Hello, %s' % name)
6hello('Bob')    # 使用默认参数; 打印 "Hello, Bobs"
7hello('Freb', loud = True)  # 使用输入参数; 打印 "HELLO, FREB!"

你可以在Defining Functions文档中找到关于Python函数的更多内容。

类(Classes)

在Python中定义类的语法很简单:

 1class Greeter(object):
 2  # Constructor
 3  def __init__(self, name):
 4      self.name = name  # 创建一个实例变量
 5
 6  # 实例方法
 7  def greet(self, loud = False):
 8      if loud:
 9          print('HELLO, %s!' % self.name.upper())
10      else:
11          print('Hello, %s' % self.name)
12
13g = Greeter('Fred') # 构建Greeter类的实例
14g.greet()           # 调用实例的方法; 打印 "Hello, Fred"
15g.greet(loud = True)# 调用实例的方法; 打印 "HELLO, FRED!"

你可以在Classes文档中找到关于Python类的更多内容。

------我是可爱的分割线-------    

若喜欢Amusi写的文章，可以扫描下方二维码关注CVer公众号！