通知：这篇文章主要简单介绍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)) # 打印 "<class 'int'>"
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)) # 打印 "<class 'float'>"
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)) # 打印 "<class 'bool'>"
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)) # 打印 "<class 'tuple'>"
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公众号！