[转]python与numpy基础

来源于：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  # 指数;

5
3
8
16

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. 相等
2. 其中一个为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指南