标签：trace matlab gic var creat 面试 相等 sqrt 包含
寒小阳(2016年6月)
如果你问我没有编程基础，想学习一门语言，我一定会首推给你Python
类似伪代码的书写方式，让你能够集中精力去解决问题，而不是花费大量的时间在开发和debug上
同时得益于Numpy/Scipy这样的科学计算库，使得其有非常高效和简易的科学计算能力。
而活跃的社区提供的各种可视化的库，也使得 机器学习/数据挖掘 的全过程(数据采集，数据清洗，数据处理，建模，可视化)可以非常流畅地完成。
而近年来极其热门的深度学习开源框架，基本都有python接口，google的Tensorflow更是python主导。
这个教程里面的内容包括：
Python确实经常被人像伪代码，下面是一个快排程序，你可以感受一下:
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])
整型和浮点型以及基本的运算大家应该都知道：
x = 4
print x, type(x)
print x + 1 # 加;
print x - 1 # 减;
print x * 2 # 乘;
print x ** 2 # 指数;
x += 1
print x # 自加
x *= 2
print x # 自乘
y = 2.5
print type(y) # 输出类型
print y, y + 1, y * 2, y ** 2 # 连续输出
不过需要提醒一句，用习惯C++和Java的同学，Python真的没有(x++)和(x--)这俩操作
用于指定真假的类型，布尔型，包含真（True）和假（False）:
t, f = True, False
print type(t) # Prints "<type ‘bool‘>"
看看逻辑与或非这些操作
print t and f # Logical AND;
print t or f # Logical OR;
print not t # Logical NOT;
print t != f # Logical XOR;
hello = ‘hello‘ # 实在想不出的时候就用hello world
world = "world"
print hello, len(hello) # 字符串长度
hw = hello + ‘ ‘ + world # 字符串拼接
print hw
hw12 = ‘%s %s %d‘ % (hello, world, 12) # 类似sprintf的格式化输出
print hw12 # prints "hello world 12"
我能说什么，你面试的时候面试官最爱让你写的字符串操作，都是它自带的:
s = "hello"
print s.capitalize() # 首字母大写
print s.upper() # 全大写
print s.rjust(7) # 靠右对齐
print s.center(7) # 居中输出
print s.replace(‘l‘, ‘(ell)‘) # 字符串替换
print ‘ world ‘.strip() # 去掉两侧空白
其他你想要的字符串操作看这里.
内置的容器用得非常非常多，包括: lists, dictionaries, sets, and tuples.
和你学数据结构里面数组长得一样的容器，但是操作可多多了:
xs = [3, 1, 2] # 建一个列表
print xs, xs[2]
print xs[-1] # 用-1表示最后一个元素，输出来
xs[2] = ‘Hanxiaoyang‘ # 有意思的是，Python的list居然可以有不同类型的元素
print xs
xs.append(‘happy‘) # 可以用append在尾部添加元素
print xs
x = xs.pop() # 也可以把最后一个元素“弹射”出来
print x, xs
关于list更多的操作和内容可以看这里.
这是大家最爱python list的原因之一，取东西太方便啦:
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]"
可以对list立面的元素做一个循环:
animals = [‘喵星人‘, ‘汪星人‘, ‘火星人‘]
for animal in animals:
print animal
又要输出元素，又要输出下标怎么办，用 enumerate 函数:
animals = [‘喵星人‘, ‘汪星人‘, ‘火星人‘]
for idx, animal in enumerate(animals):
print ‘#%d: %s‘ % (idx + 1, animal)
如果对list里面的元素都做一样的操作，然后生成一个list，用它最快了，这绝对会成为你最爱的python操作之一:
# 求一个list里面的元素的平方，然后输出，很out的for循环写法
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print squares
用list comprehension可以这么写:
nums = [0, 1, 2, 3, 4]
# 对每个x完成一个操作以后返回来，组成新的list
squares = [x ** 2 for x in nums]
print squares
你甚至可以加条件，去筛出你想要的元素，去做你想要的操作:
nums = [0, 1, 2, 3, 4]
# 把所有的偶数取出来，平方后返回
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print even_squares
存储键值对(key => value)的数据结构, 类似Java中的Map，这真的是我使用频度相当高的数据结构:
d = {‘cat‘: ‘cute‘, ‘dog‘: ‘furry‘} # 建立字典
print d[‘cat‘] # 根据key取value
print ‘cat‘ in d # 查一个元素是否在字典中
d[‘fish‘] = ‘wet‘ # 设定键值对
print d[‘fish‘] # 这时候肯定是输出修改后的内容
print d[‘monkey‘] # 不是d的键，肯定输不出东西
print d.get(‘monkey‘, ‘N/A‘) # 可以默认输出‘N/A‘（取不到key对应的value值的时候）
print d.get(‘fish‘, ‘N/A‘)
del d[‘fish‘] # 删除字典中的键值对
print d.get(‘fish‘, ‘N/A‘) # 这会儿就没有了
同样的，你其他想了解的字典相关的操作和内容可以看 这里.
你可以这样循环python字典取出你想要的内容:
d = {‘person‘: 2, ‘cat‘: 4, ‘spider‘: 8}
for animal in d:
legs = d[animal]
print ‘A %s has %d legs‘ % (animal, legs)
用iteritems函数可以同时取出键值对:
d = {‘person‘: 2, ‘cat‘: 4, ‘spider‘: 8}
for animal, legs in d.iteritems():
print ‘A %s has %d legs‘ % (animal, legs)
Dictionary comprehensions: 和list comprehension有点像啦，但是生成的是字典:
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
你可以理解成没有相同元素的列表（当然，显然和list是不同的）:
animals = {‘cat‘, ‘dog‘}
print ‘cat‘ in animals # Check if an element is in a set; prints "True"
print ‘fish‘ in animals # prints "False"
animals.add(‘fish‘) # 添加元素
print ‘fish‘ in animals
print len(animals) # 元素个数
animals.add(‘cat‘) # 如果元素已经在set里了，操作不会怎么样
print len(animals)
animals.remove(‘cat‘) # 删除一个元素
print len(animals)
循环的方式和list很像啦:
animals = {‘cat‘, ‘dog‘, ‘fish‘}
for idx, animal in enumerate(animals):
print ‘#%d: %s‘ % (idx + 1, animal)
# Prints "#1: fish", "#2: dog", "#3: cat"
Set comprehensions: 熟悉的感觉:
from math import sqrt
print {int(sqrt(x)) for x in range(30)}
和list很像，但是可以作为字典的key或者set的元素出现，但是一整个list不可以作为字典的key或者set的元素的:
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)]
t[0] = 1
用 def 就可以定义一个函数，就像下面这样:
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)
函数名字后面接的括号里，可以有多个参数，你自己可以试试:
def hello(name, loud=False):
if loud:
print ‘HELLO, %s‘ % name.upper()
else:
print ‘Hello, %s!‘ % name
hello(‘Bob‘)
hello(‘Fred‘, loud=True)
Python的类，怎么说呢，比较简单粗暴:
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!"
我们要开始接触高效计算库Numpy了，你要是之前在实验室用MATLAB之类的语法，你会发现Numpy和它们长得不要太像，爱MATLAB的同学，参考文档可以看这里
python里面调用一个包，用import对吧, 所以我们import numpy 包:
import numpy as np
看你数组的维度啦，我自己的话比较简单粗暴，一般直接把1维数组就看做向量/vector，2维数组看做2维矩阵，3维数组看做3维矩阵...
可以调用np.array去从list初始化一个数组:
a = np.array([1, 2, 3]) # 1维数组
print type(a), a.shape, a[0], a[1], a[2]
a[0] = 5 # 重新赋值
print a
b = np.array([[1,2,3],[4,5,6]]) # 2维数组
print b
print b.shape #可以看形状的（非常常用！！！）
print b[0, 0], b[0, 1], b[1, 0]
有一些内置的创建数组的函数:
a = np.zeros((2,2)) # 创建2x2的全0数组
print a
b = np.ones((1,2)) # 创建1x2的全0数组
print b
c = np.full((2,2), 7) # 定值数组
print c
d = np.eye(2) # 对角矩阵（对角元素为1）
print d
e = np.random.random((2,2)) # 2x2的随机数组(矩阵)
print e
Numpy提供了蛮多种取值的方式的.
可以像list一样切片（多维数组可以从各个维度同时切片）:
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
虽然，怎么说呢，不建议你这样去赋值，但是你确实可以修改切片出来的对象，然后完成对原数组的赋值.
print a[0, 1]
b[0, 0] = 77 # b[0, 0]改了，很遗憾a[0, 1]也被修改了
print a[0, 1]
# 创建3x4的2维数组/矩阵
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
print a
你就放心大胆地去取你想要的数咯:
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
# 试试在第2个维度上切片也一样的:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print col_r1, col_r1.shape
print
print col_r2, col_r2.shape
下面这个高级了，更自由地取值和组合，但是要看清楚一点:
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]])
# 再来试试
print a[[0, 0], [1, 1]]
# 还是一样
print np.array([a[0, 1], a[0, 1]])
# 再来熟悉一下
# 先创建一个2维数组
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
print a
# 用下标生成一个向量
b = np.array([0, 2, 0, 1])
# 你能看明白下面做的事情吗？
print a[np.arange(4), b] # Prints "[ 1 6 7 11]"
# 既然可以取出来，我们当然可以对这些元素操作咯
a[np.arange(4), b] += 10
print a
比较fashion的取法之一，用条件判定去取（但是很好用）:
import numpy as np
a = np.array([[1,2], [3, 4], [5, 6]])
bool_idx = (a > 2) # 就是判定一下是否大于2
print bool_idx # 返回一个布尔型的3x2数组
# 用刚才的布尔型数组作为下标就可以去除符合条件的元素啦
print a[bool_idx]
# 其实一句话也可以完成是不是？
print a[a > 2]
那个，真的，其实还有很多细节，其他的方式去取值，你可以看看官方文档。
我们一起来来总结一下，看下面切片取值方式（对应颜色是取出来的结果）：
我们可以用dtype来看numpy数组中元素的类型:
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
更多的内容可以读读文档.
下面这些运算才是你在科学运算中经常经常会用到的，比如逐个元素的运算如下:
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)
# 逐元素作差
print x - y
print np.subtract(x, y)
# 逐元素相乘
print x * y
print np.multiply(x, y)
# 逐元素相除
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print x / y
print np.divide(x, y)
# 逐元素求平方根！！！
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print np.sqrt(x)
那如果我要做矩阵的乘法运算怎么办！！！恩，别着急，照着下面写就可以了:
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)
# 矩阵的乘法
print x.dot(v)
print np.dot(x, v)
# 矩阵的乘法
# [[19 22]
# [43 50]]
print x.dot(y)
print np.dot(x, y)
你猜你做科学运算会最常用到的矩阵内元素的运算是什么？对啦，是求和，用 sum可以完成:
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]"
我想说最基本的运算就是上面这个样子，更多的运算可能得查查文档.
其实除掉基本运算，我们经常还需要做一些操作，比如矩阵的变形，转置和重排等等:
# 转置和数学公式一直，简单粗暴
print x
print x.T
# 需要说明一下，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
这个没想好哪个中文词最贴切，我们暂且叫它“传播吧”:
作用是什么呢，我们设想一个场景，如果要用小的矩阵去和大的矩阵做一些操作，但是希望小矩阵能循环和大矩阵的那些块做一样的操作，那急需要Broadcasting啦
# 我们要做一件事情，给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
这种方法当然可以啦，问题是不高效嘛，如果你的x矩阵行数非常多，那就很慢的咯:
咱们调整一下，先生成好要加的内容
vv = np.tile(v, (4, 1)) # 重复4遍v，叠起来
print vv # Prints "[[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]"
y = x + vv # 这样求和大家都能看明白对吧
print y
Numpy broadcasting allows us to perform this computation without actually creating multiple copies of v. Consider this version, using broadcasting:
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
当操作两个array时，numpy会逐个比较它们的shape，在下述情况下，两arrays会兼容和输出broadcasting结果：
比如求和的时候有：
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 的例子:
# 我们来理解一下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
# 那如果要把一个矩阵的每一行都加上一个向量呢
x = np.array([[1,2,3], [4,5,6]])
v = np.array([1,2,3])
# 恩，其实是一样的啦
print x + v
x = np.array([[1,2,3], [4,5,6]]) # 2x3的
w = np.array([4,5]) # w 形状是 (2,)
# 自己算算看？
print (x.T + w).T
# 上面那个操作太复杂了，其实我们可以直接这么做嘛
print x + np.reshape(w, (2, 1))
# broadcasting当然可以逐元素运算了
print x * 2
总结一下broadcasting，可以看看下面的图：
更多的numpy细节和用法可以查看一下官网numpy指南
标签：trace matlab gic var creat 面试 相等 sqrt 包含
原文地址：http://www.cnblogs.com/wuxiangli/p/7225116.html
