猫狗窝

Python2 vs. Python3

Sat, 07 Jan 2017 00:00:00 +0800

Ch0—探索学习节奏

1. Python2 vs. Python3

版本差异简述

最新的更新默认只在 py3 中可用。
py3 不向下兼容。
py3 对 unicode 有更好的支持，默认使用utf-8（之前尝试使用lxml读取网页信息时，py2 中文字符输出为unicode编码，要再转换；py3 可直接输出为中文字符）。
py3 语言一致性更强，对初学者更友好（例如：print、exec 语句改为函数print()、exec()；xrange()被range()替代；整数相除，保留小数部分，可以是浮点数等）。

具体差异整理的参考链接：

What’s New In Python 3.0
中文资料：link1, link2

（除了函数的改变其他改变大部分没看懂……先放上链接，任务中遇到困难再去解决）

如何选择版本？

	优势	劣势
Py3		1.有的库支持略差；2. 部分 Linux，Macs 默认py2
Py2	1.兼容更多的包；

所以当操作环境不可改变，只能使用 py2，以及使用的 package 不支持 py3 时，选择 py2。

Py3 支持较好的主要 package：

用图	package
数字处理与科学计算	NumPy，SciPy
网站	Django, Flask, CherryPy and Pyramid
图像处理	PIL(was superseded by its fork Pillow)
应用程序打包	cx_Freeze
应用程序打包（Windows）	py2exe
开放源代码视觉处理与机器学习	OpenCV 3
HTTP	Requests
XML	lxml
HTML,XML 解析	BeautifulSoup4
交互计算环境	IPython/Jupyter

只能在 Py3 应用的特征的不完全清单（很多意义不明，所以不做翻译，先留下）：
- strings are Unicode by default
- clean Unicode/bytes separation
- exception chaining
- function annotations
- syntax for keyword-only arguments
- extended tuple unpacking
- non-local variable declarations

如何同时兼容 py2/3

Python 多版本共存之 pyenv：link
3 中安装 2 的代码：Porting Python 2 Code to Python 3
PY2 到 3 的自动转换：使用命令行 2to3 -w <stuff to convert>（link）

2. 夯实 Python 基础

80% Python 的常用场景

从 LPTHW 选取 7 个练习，用 py3.x 改写，包括了上面提到的80%的常用场景以及类和对象，分别是：

练习3：数字与数字计算
练习6：变量、字符串、文本与打印
练习17：提示、输入与文件操作
练习24：函数综合练习
练习35：if 语句、循环、列表综合练习
练习39：列表与字典
练习42：物以类聚（对象、类、从属关系）

练习3：数字与数字计算

print 更改为 print()

print("I will now count my chickens:")
print("Hens", 25 + 30 / 6) # py2结果为30
print("Roosters", 100 - 25 * 3 % 4)

print("Now I will count the eggs:")
print(3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6) ＃ py2结果为整数

print("Is it true that 3 + 2 < 5 - 7?")
print(3 + 2 < 5 - 7)

print("What is 3 + 2?", 3 + 2)
print("What is 5 - 7?", 5 - 7)

print("Oh, that's why it's False.")

print("How about some more.")

print("Is it greater?", 5 > -2)
print("Is it greater or equal?", 5 >= -2)
print("Is it less or equal?", 5 <= -2)

I will now count my chickens:
Hens 30.0
Roosters 97
Now I will count the eggs:
6.75
Is it true that 3 + 2 < 5 - 7?
False
What is 3 + 2? 5
What is 5 - 7? -2
Oh, that's why it's False.
How about some more.
Is it greater? True
Is it greater or equal? True
Is it less or equal? False

练习6：变量、字符串、文本与打印

x = "There are %d types of people." % 10
binary = "binary"
do_not = "don't"
y = "Those who know %s and those who %s." % (binary, do_not)

print(x)
print(y)

print("I said: %r." % x)
print("I also said: '%s'." % y)

hilarious = False
joke_evaluation = "Isn't that joke so funny?! %r"

print(joke_evaluation % hilarious)

w = "This is the left side of..."
e = "a string with a right side."

print(w + e)

There are 10 types of people.
Those who know binary and those who don't.
I said: 'There are 10 types of people.'.
I also said: 'Those who know binary and those who don't.'.
Isn't that joke so funny?! False
This is the left side of...a string with a right side.

练习17：提示、输入与文件操作

from sys import argv
from os.path import exists

script, from_file, to_file = argv

print("Copying from %s to %s" % (from_file, to_file))

in_file = open(from_file)
indata = in_file.read()

print("The input file is %d bytes long" % len(indata))

print("Does the output file exist? %r" % exists(to_file))
print("Ready, hit RETURN to continue, CTRL-C to abort.")
raw_input()

out_file = open(to_file, 'w')
out_file.write(indata)

print("Alright, all done.")

out_file.close()
in_file.close()

Copying from -f to /Users/lixin/Library/Jupyter/runtime/kernel-9433043b-c72c-45ea-a85e-5feb7f59dc62.json

---------------------------------------------------------------------------

FileNotFoundError                         Traceback (most recent call last)

<ipython-input-3-a30bf329e718> in <module>()
      7 
      8 # we could do these two on one line, how?
----> 9 in_file = open(from_file)
     10 indata = in_file.read()
     11 

FileNotFoundError: [Errno 2] No such file or directory: '-f'

!echo "This is a test file." > test.txt

!cat test.txt

This is a test file.

%run ex17.py test.txt new_file.txt

Copying from test.txt to new_file.txt
The input file is 21 bytes long
Does the output file exist? False
Ready, hit RETURN to continue, CTRL-C to abort.



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

/Users/lixin/Documents/Py103/Chap0/note/ex17.py in <module>()
     14 print("Does the output file exist? %r" % exists(to_file))
     15 print("Ready, hit RETURN to continue, CTRL-C to abort.")
---> 16 raw_input()
     17 
     18 out_file = open(to_file, 'w')


NameError: name 'raw_input' is not defined

raw_input() 改为 input()

%run ex17.py test.txt new_file.txt

Copying from test.txt to new_file.txt
The input file is 21 bytes long
Does the output file exist? False
Ready, hit RETURN to continue, CTRL-C to abort.
Alright, all done.

练习24：函数综合练习

print("Let's practice everything.")
print('You\'d need to know \'bout escapes with \\ that do \n newlines and \t tabs.')

poem = """
\tThe lovely world
with logic so firmly planted
cannot discern \n the needs of love
nor comprehend passion from intuition
and requires an explanation
\n\t\twhere there is none.
"""

print("--------------")
print(poem)
print("--------------")


five = 10 - 2 + 3 - 6
print("This should be five: %s" % five)

def secret_formula(started):
    jelly_beans = started * 500
    jars = jelly_beans / 1000
    crates = jars / 100
    return jelly_beans, jars, crates


start_point = 10000
beans, jars, crates = secret_formula(start_point)

print("With a starting point of: %d" % start_point)
print("We'd have %d beans, %d jars, and %d crates." % (beans, jars, crates))

start_point = start_point / 10

print("We can also do that this way:")
print("We'd have %d beans, %d jars, and %d crates." % secret_formula(start_point))

Let's practice everything.
You'd need to know 'bout escapes with \ that do 
 newlines and 	 tabs.
--------------

	The lovely world
with logic so firmly planted
cannot discern 
 the needs of love
nor comprehend passion from intuition
and requires an explanation

		where there is none.

--------------
This should be five: 5
With a starting point of: 10000
We'd have 5000000 beans, 5000 jars, and 50 crates.
We can also do that this way:
We'd have 500000 beans, 500 jars, and 5 crates.

练习35：if 语句、循环、列表综合练习

from sys import exit

def gold_room():
    print("This room is full of gold.  How much do you take?")

    choice = input("> ")
    if "0" in choice or "1" in choice:
        how_much = int(choice)
    else:
        dead("Man, learn to type a number.")

    if how_much < 50:
        print("Nice, you're not greedy, you win!")
        exit(0)
    else:
        dead("You greedy bastard!")


def bear_room():
    print("There is a bear here.")
    print("The bear has a bunch of honey.")
    print("The fat bear is in front of another door.")
    print("How are you going to move the bear?")
    bear_moved = False

    while True:
        choice = input("> ")

        if choice == "take honey":
            dead("The bear looks at you then slaps your face off.")
        elif choice == "taunt bear" and not bear_moved:
            print("The bear has moved from the door. You can go through it now.")
            bear_moved = True
        elif choice == "taunt bear" and bear_moved:
            dead("The bear gets pissed off and chews your leg off.")
        elif choice == "open door" and bear_moved:
            gold_room()
        else:
            print("I got no idea what that means.")


def cthulhu_room():
    print("Here you see the great evil Cthulhu.")
    print("He, it, whatever stares at you and you go insane.")
    print("Do you flee for your life or eat your head?")

    choice = input("> ")

    if "flee" in choice:
        start()
    elif "head" in choice:
        dead("Well that was tasty!")
    else:
        cthulhu_room()


def dead(why):
    print(why, "Good job!")
    exit(0)

def start():
    print("You are in a dark room.")
    print("There is a door to your right and left.")
    print("Which one do you take?")

    choice = input("> ")

    if choice == "left":
        bear_room()
    elif choice == "right":
        cthulhu_room()
    else:
        dead("You stumble around the room until you starve.")


start()

You are in a dark room.
There is a door to your right and left.
Which one do you take?
> left
There is a bear here.
The bear has a bunch of honey.
The fat bear is in front of another door.
How are you going to move the bear?
> take honey
The bear looks at you then slaps your face off. Good job!



An exception has occurred, use %tb to see the full traceback.


SystemExit: 0



/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/interactiveshell.py:2889: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

练习39：列表与字典

states = {
    'Oregon': 'OR',
    'Florida': 'FL',
    'California': 'CA',
    'New York': 'NY',
    'Michigan': 'MI'
}

cities = {
    'CA': 'San Francisco',
    'MI': 'Detroit',
    'FL': 'Jacksonville'
}

cities['NY'] = 'New York'
cities['OR'] = 'Portland'

print('-' * 10)
print("NY State has: ", cities['NY'])
print("OR State has: ", cities['OR'])

print('-' * 10)
print("Michigan's abbreviation is: ", states['Michigan'])
print("Florida's abbreviation is: ", states['Florida'])

print('-' * 10)
print("Michigan has: ", cities[states['Michigan']])
print("Florida has: ", cities[states['Florida']])

print('-' * 10)
for state, abbrev in states.items():
    print("%s is abbreviated %s" % (state, abbrev))

print('-' * 10)
for abbrev, city in cities.items():
    print("%s has the city %s" % (abbrev, city))

print('-' * 10)
for state, abbrev in states.items():
    print("%s state is abbreviated %s and has city %s" % (
        state, abbrev, cities[abbrev]))

print('-' * 10)
state = states.get('Texas')

if not state:
    print("Sorry, no Texas.")

city = cities.get('TX', 'Does Not Exist')
print("The city for the state 'TX' is: %s" % city)

----------
NY State has:  New York
OR State has:  Portland
----------
Michigan's abbreviation is:  MI
Florida's abbreviation is:  FL
----------
Michigan has:  Detroit
Florida has:  Jacksonville
----------
Oregon is abbreviated OR
New York is abbreviated NY
Florida is abbreviated FL
California is abbreviated CA
Michigan is abbreviated MI
----------
FL has the city Jacksonville
CA has the city San Francisco
NY has the city New York
OR has the city Portland
MI has the city Detroit
----------
Oregon state is abbreviated OR and has city Portland
New York state is abbreviated NY and has city New York
Florida state is abbreviated FL and has city Jacksonville
California state is abbreviated CA and has city San Francisco
Michigan state is abbreviated MI and has city Detroit
----------
Sorry, no Texas.
The city for the state 'TX' is: Does Not Exist

练习42：物以类聚（对象、类、从属关系）

class Animal(object): 
    pass

class Dog(Animal):
    def __init__(self, name):
        self.name = name

class Cat(Animal):
    def __init__(self, name):
        self.name = name

class Person(object):
    def __init__(self, name):
        self.name = name
        self.pet = None

class Employee(Person):
    def __init__(self, name, salary):
        super(Employee, self).__init__(name) # 初始化name为父类的name
        self.salary = salary

class Fish(object):
    pass

class Salmon(Fish):
    pass

class Halibut(Fish):
    pass


rover = Dog("Rover")
satan = Cat("Satan")
mary = Person("Mary")
mary.pet = satan
frank = Employee("Frank", 120000)
frank.pet = rover
flipper = Fish()
crouse = Salmon()
harry = Halibut()

3. CLI

CLI 笔记

4. Gitbook

配置 GitBook 简易指南

Numpy 小教程

Sun, 18 Sep 2016 00:00:00 +0800

Numpy 笔记

学习Numpy 的重点就是学习如果通过数组批量地对数据进行操作。Numpy 数组使我们可以将许多种数据处理任务表达为简洁的数组表达式（否则需要编写循环）。用数组表达代替循环的做法，通常被称为 矢量化。

输入Numpy

import numpy as np

1. 基础操作——创建、基本属性、变形

ndarray（数组）要求所有元素都是同质的

1.1 创建

创建数组

函数	说明
np.array	将输入数据（列表、元组、数组或其他序列类型）转换为数组。要么推断出dtype（数据类型），要么显示指定dtype。默认直接复制输入数据。
np.arange	类似于内置的range，但返回的是一个数组而不是列表。
np.zeros	创建一个全是0的数组。
np.ones	创建一个全是1的数组。
np.empty	创建新数组，只分配内容空间但不填充任何值。但是返回并不是全是0，大多数情况返回的是一些未初始化的垃圾值。
np.diag	创建对角线是特殊值的数组，对角线外都是0。
np.linspace	创建给定的上下限范围之间平均分布的数组。
np.logspace	创建10的给定次方之间对数分布的数组。
np.meshgrid	根据一维向量创建矩阵（高维数组）。
np.random	创建随机数组。

np.array

data = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr = np.array(data)
arr

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

np.arange

np.arange(15)

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

np.zeros

np.zeros((3,6))

array([[ 0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.]])

np.ones

np.ones((2, 3, 2))

array([[[ 1.,  1.],
        [ 1.,  1.],
        [ 1.,  1.]],

       [[ 1.,  1.],
        [ 1.,  1.],
        [ 1.,  1.]]])

np.empty

empty = np.empty(4)
empty

array([  0.00000000e+000,  -1.34572688e-315,   2.12264337e-314,
         2.12269460e-314])

empty.fill(5.5)
empty

array([ 5.5,  5.5,  5.5,  5.5])

np.diag

np.diag((1, 2, 3))

array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])

也可用来做对角切片

x = np.arange(1, 10).reshape((3, 3))
x

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

np.diag(x)

array([1, 5, 9])

np.diag(x, 1)

array([2, 6])

np.diag(x, -1)

array([4, 8])

np.linspace

np.linspace(1, 10, 5)

array([  1.  ,   3.25,   5.5 ,   7.75,  10.  ])

np.logspace

np.logspace(1, 3, 5)

array([   10.        ,    31.6227766 ,   100.        ,   316.22776602,
        1000.        ])

np.meshgrid

x = np.array([-1, 0, 1])
y = np.array([-2, 0, 2])
# 变量xs，ys 分别是在延0轴重复数组x，延1轴重复数组y
xs, ys = np.meshgrid(x, y)

xs

array([[-1,  0,  1],
       [-1,  0,  1],
       [-1,  0,  1]])

ys

array([[-2, -2, -2],
       [ 0,  0,  0],
       [ 2,  2,  2]])

创建随机数组 np.random

函数	说明
rand	产生均匀分布的样本值。
randint	从给定的上下限范围内随机选取整数。
randn	产生标准正态分布（平均值为0，标准差为1）的样本值。
normal	产生正态分布的样本值。

rand

np.random.rand(5)

array([ 0.90079451,  0.90221624,  0.15606323,  0.88626912,  0.77039811])

randint

np.random.randint(0, 3)

np.random.randint(0, 3)

np.random.randint(0, 3)

np.random.randint(0, 3, size=(3, 2))

array([[1, 1],
       [0, 2],
       [2, 0]])

randn

np.random.randn(5)

array([ 1.5874802 ,  0.1310511 , -0.80181936,  0.57206609, -0.94692264])

np.random.randn(2, 3)

array([[ 1.5156661 ,  0.28188904, -2.25781227],
       [-0.78977321, -1.3286388 , -0.35938401]])

normal

产生期望为4，标准差为7的正态分布的6个随机数值

np.random.normal(4, 7, 4)

array([ 8.15897305, -0.24364705,  6.93085358,  2.58621645])

np.random.normal(4, 7, (2, 3))

array([[  4.71287819,  -2.7068944 ,  15.77077204],
       [ 11.82380706,  11.49019428,   2.02487055]])

1.2 基本属性

数据类型

类型	类型代码	说明
int	int8, int16, int32, int64	整数
float	float16, float32, float64, float128	浮点数
complex	complex64, complex128, complex256	浮点数表示的复数
bool	bool	存储 true 和 false 值的布尔类型

数组属性

函数	说明
dtype	数组的数据类型
astype(类型代码)	用来转换数值类型
shape	查看数组每个维度的元素数量
size	数组的总元素数
ndim	数组的维度数
nbytes	数组的字符数

arr

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

print("数据类型（dtype）          :", arr.dtype)
print("各个维度上的元素数量（shape）:", arr.shape)
print("元素总数量（size）         :", arr.size)
print("维度数（ndim）             :", arr.ndim)
print("占用字符数（nbytes）       :", arr.nbytes)

数据类型（dtype）          : int64
各个维度上的元素数量（shape）: (5, 4)
元素总数量（size）         : 20
维度数（ndim）             : 2
占用字符数（nbytes）       : 160

dtype

np.zeros(5, dtype=int)

array([0, 0, 0, 0, 0])

np.zeros(5, dtype=float)

array([ 0.,  0.,  0.,  0.,  0.])

np.zeros(5, dtype=complex)

array([ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j])

np.array([1, 2, 3, 4], dtype=np.float64)

array([ 1.,  2.,  3.,  4.])

astype

arr.astype(complex)

array([[ 1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j],
       [ 5.+0.j,  6.+0.j,  7.+0.j,  8.+0.j]])

2. 索引与切片

数组的切片只是原数组的 __视图__。这意味着数据不回被复制，视图上的任何修改都会直接反应到源数组上。
如果想要得到切片的一份副本而非视图，就需要进行复制操作，例如arr[5:8].copy()

2.1 切片索引

一维索引

|表达|说明| |—|—| |a[m]|选取第 m 个元素，从0开始计算| |a[-m]|选取倒数第 m 个元素，从－1 开始计算| |a[m:n]|选取第 m 到 n-1 的元素（m、n 为整数）| |a[:] or a[0:-1]|选取轴上的全部元素| |a[:n]|选取第 0 到 n-1 的元素| |a[m:] or a[m:-1]|选取第 m 到最后的所有元素| |a[::-1]|倒序选区所有元素|

多维索引

索引方式：a[y][x] 或 a[y, x]

索引数字顺序从高维向低维：
一维——索引x轴（1轴）
二维——先索引y轴（0轴），再索x轴（1轴）
三维——先索引z轴，再索引y轴（0轴），然后索引x轴（1轴）

arr3d = np.arange(1,13).reshape(2, 2, 3)
arr3d

array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

arr3d[1]

array([[ 7,  8,  9],
       [10, 11, 12]])

arr3d[1][1]

array([10, 11, 12])

arr3d[1, 1, 1:2]

array([11])

切片赋值

arr3d[0]

array([[1, 2, 3],
       [4, 5, 6]])

old_values = arr3d[0].copy()
old_values

array([[1, 2, 3],
       [4, 5, 6]])

arr3d[0] = 100
arr3d

array([[[100, 100, 100],
        [100, 100, 100]],

       [[  7,   8,   9],
        [ 10,  11,  12]]])

arr3d[0] = old_values
arr3d

array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

2.2 布尔型索引

将判断（>/>=/</<=/==/!=）返回的布尔值作为索引条件选区数据。多个判断可以用&（和）、

（或）等逻辑关联。

data = np.random.randn(7,4)
data

array([[ 2.02121853, -0.3417102 , -0.55666994, -1.86032535],
       [ 1.73476976, -2.45039007,  0.14603374,  0.66659723],
       [ 0.72585888, -0.52163889,  0.32900547, -0.09850365],
       [-1.09943129,  0.48831424, -0.02574601,  0.84756898],
       [ 1.96597553,  1.39159752, -0.51778462,  0.25498703],
       [-1.04308369,  0.13513272, -1.15460956,  0.63697499],
       [-0.51813368, -1.06168638, -2.25424698, -0.19589059]])

names = np.array(["Bob", "Joe", "Will", "Bob", "Will", "Joe", "Joe"])
names

array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], 
      dtype='|S4')

判断条件

names == "Bob"

array([ True, False, False,  True, False, False, False], dtype=bool)

布尔索引

0轴

data[names == "Bob"]

array([[ 2.02121853, -0.3417102 , -0.55666994, -1.86032535],
       [-1.09943129,  0.48831424, -0.02574601,  0.84756898]])

0轴、1轴

data[names == "Bob", 2]

array([-0.55666994, -0.02574601])

否定条件

data[names != "Bob"]

array([[ 1.73476976, -2.45039007,  0.14603374,  0.66659723],
       [ 0.72585888, -0.52163889,  0.32900547, -0.09850365],
       [ 1.96597553,  1.39159752, -0.51778462,  0.25498703],
       [-1.04308369,  0.13513272, -1.15460956,  0.63697499],
       [-0.51813368, -1.06168638, -2.25424698, -0.19589059]])

data[-(names == "Bob")]

/Users/lixin/anaconda/lib/python2.7/site-packages/ipykernel/__main__.py:1: DeprecationWarning: numpy boolean negative, the `-` operator, is deprecated, use the `~` operator or the logical_not function instead.
  if __name__ == '__main__':

array([[ 1.73476976, -2.45039007,  0.14603374,  0.66659723],
       [ 0.72585888, -0.52163889,  0.32900547, -0.09850365],
       [ 1.96597553,  1.39159752, -0.51778462,  0.25498703],
       [-1.04308369,  0.13513272, -1.15460956,  0.63697499],
       [-0.51813368, -1.06168638, -2.25424698, -0.19589059]])

多个布尔条件索引

mask = (names == "Bob") | (names == "Will")
data[mask]

array([[ 2.02121853, -0.3417102 , -0.55666994, -1.86032535],
       [ 0.72585888, -0.52163889,  0.32900547, -0.09850365],
       [-1.09943129,  0.48831424, -0.02574601,  0.84756898],
       [ 1.96597553,  1.39159752, -0.51778462,  0.25498703]])

索引赋值

data[data < 0] = 0
data

array([[ 2.02121853,  0.        ,  0.        ,  0.        ],
       [ 1.73476976,  0.        ,  0.14603374,  0.66659723],
       [ 0.72585888,  0.        ,  0.32900547,  0.        ],
       [ 0.        ,  0.48831424,  0.        ,  0.84756898],
       [ 1.96597553,  1.39159752,  0.        ,  0.25498703],
       [ 0.        ,  0.13513272,  0.        ,  0.63697499],
       [ 0.        ,  0.        ,  0.        ,  0.        ]])

2.3 花式索引

利用循环索引

arr = np.empty((8,4))
arr

array([[  0.00000000e+000,   1.34581569e-315,   1.13635099e-322,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          8.37170573e-144],
       [  0.00000000e+000,   0.00000000e+000,   7.41098469e-323,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          0.00000000e+000],
       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000,
          2.81617418e-322]])

for i in range(8):
    arr[i] = i

arr

array([[ 0.,  0.,  0.,  0.],
       [ 1.,  1.,  1.,  1.],
       [ 2.,  2.,  2.,  2.],
       [ 3.,  3.,  3.,  3.],
       [ 4.,  4.,  4.,  4.],
       [ 5.,  5.,  5.,  5.],
       [ 6.,  6.,  6.,  6.],
       [ 7.,  7.,  7.,  7.]])

利用整数组进行索引

arr = np.arange(32).reshape(8, 4)
arr

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23],
       [24, 25, 26, 27],
       [28, 29, 30, 31]])

正整数

arr[[4, 3, 0]]

array([[16, 17, 18, 19],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3]])

负整数

arr[[-1,-7,-5]]

array([[28, 29, 30, 31],
       [ 4,  5,  6,  7],
       [12, 13, 14, 15]])

选取元素 (4,1)、(3,3)、(0,0)

arr[[4, 3, 0], [1, 3, 0]]

array([17, 15,  0])

按照一定顺序索引

arr[[4, 3, 0]][:, [0, 3, 1, 2]]

array([[16, 19, 17, 18],
       [12, 15, 13, 14],
       [ 0,  3,  1,  2]])

3. 数组计算

大小相同 的数组之间的任何运算都会将运算应用到 __元素级__。

3.1 基础计算

符号	运算
+, +=	加法
-, -=	减法
, =	乘法
/, /=	除法
, =	幂运算，乘方
//, //=	整除（丢弃余数）
%	求余数

arr = np.arange(1,7).reshape(2, 3)
arr

array([[1, 2, 3],
       [4, 5, 6]])

arr * arr

array([[ 1,  4,  9],
       [16, 25, 36]])

arr ** arr

array([[    1,     4,    27],
       [  256,  3125, 46656]])

arr//2

array([[0, 1, 1],
       [2, 2, 3]])

arr%2

array([[1, 0, 1],
       [0, 1, 0]])

3.2 通用函数(ufunc)

一元通用函数(ufunc)

函数(np.ufunc)	说明
abs、fabs	绝对值
sqrt	平方根$\sqrt{arr}$
square	平方
exp	指数$e^{x}$
log, log10, log2	分别为自然对数（底数为e），底数为10的log，底数为2的log
cos, sin, tan	普通的三角函数
cosh, sinh, tanh	双曲型三角函数
arccos, arccosh, arcsin, arcsinh, arctan, arctanh	反三角函数

arr

array([[1, 2, 3],
       [4, 5, 6]])

np.sqrt(arr)

array([[ 1.        ,  1.41421356,  1.73205081],
       [ 2.        ,  2.23606798,  2.44948974]])

np.exp(arr)

array([[   2.71828183,    7.3890561 ,   20.08553692],
       [  54.59815003,  148.4131591 ,  403.42879349]])

二元通用函数(ufunc)

两个大小相等的数组内对应元素间进行计算

函数（np.ufunc）	说明
add	对应元素相加
subtract	第一个数组元素减去第二个数组对应元素
multiple	对应元素相乘
divide，floor_divide	对应元素相除，或整除（丢弃余数）
power	第一组元素为a,第二组元素为b，计算$a^{b}$
maximum, fmax	对应元素比较，取最大
minimum, fmin	对应元素比较，取最小
mod	对应元素相除求余数
copysign	将第二组元素的符号复制给第一组的元素
greater, greater_equal, less, less_equal, equal, not_equal	对应元素比较，产生布尔行数组
logical_and, logical_or, logical_xor	元素级的真值逻辑运算，相当于&, ｜, ^

x = np.random.randn(5)
x

array([ 0.12569472,  0.14965116, -0.62228971,  0.26996402, -1.14998285])

y = np.random.randn(5)
y

array([-0.26796225, -0.19031185,  0.52450819, -0.93463122, -1.64192667])

np.maximum(x, y)

array([ 0.12569472,  0.14965116,  0.52450819,  0.26996402, -1.14998285])

$\sqrt{x^{2}+y^{2}}$

np.sqrt(x**2 + y**2)

array([ 0.29597792,  0.24210343,  0.81385092,  0.97283919,  2.00459067])

3.3 数组统计

利用数学函数对整个数组或某个轴向的数据进行统计计算。

函数	说明
sum	对数组中全部或某轴向的元素求和
mean	算数平均数
std, var	分别为标准差和方差
max, min	最大值，最小值
argmax, argmin	分别为首个最大和最小元素的索引，返回布尔值
cumsum	所有元素的累计和
cumprod	所有元素的累计积
sort	从小到大排序
unique	返回数组中的唯一值，并排序
any	判断数组中是否存在true，返回布尔值
all	判断数组中元素是否都是true，返回布尔值

arr = np.arange(1,21).reshape(5,4)
arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16],
       [17, 18, 19, 20]])

arr.mean()

10.5

arr.mean(axis=1)

array([  2.5,   6.5,  10.5,  14.5,  18.5])

arr.cumsum(axis=0)

array([[ 1,  2,  3,  4],
       [ 6,  8, 10, 12],
       [15, 18, 21, 24],
       [28, 32, 36, 40],
       [45, 50, 55, 60]])

排序

sort( )

data = np.random.rand(4,5)
data

array([[ 0.09270272,  0.74430856,  0.81803084,  0.687264  ,  0.85338947],
       [ 0.83754576,  0.98844061,  0.24495832,  0.62303181,  0.57159207],
       [ 0.53200281,  0.21076207,  0.89044152,  0.29566154,  0.6730768 ],
       [ 0.63042717,  0.97308461,  0.35606836,  0.07726935,  0.83092571]])

data.sort(axis=0)
data

array([[ 0.09270272,  0.21076207,  0.24495832,  0.07726935,  0.57159207],
       [ 0.53200281,  0.74430856,  0.35606836,  0.29566154,  0.6730768 ],
       [ 0.63042717,  0.97308461,  0.81803084,  0.62303181,  0.83092571],
       [ 0.83754576,  0.98844061,  0.89044152,  0.687264  ,  0.85338947]])

np.unique( )

ints = np.array([3, 3, 3, 4, 2, 2, 4, 1, 1])
np.unique(ints)

array([1, 2, 3, 4])

布尔数组

bools = np.array([False, False, True, False])
bools

array([False, False,  True, False], dtype=bool)

any( )

bools.any()

True

all( )

bools.all()

False

3.4 条件逻辑表达式

numpy.where 函数是三元表达式x if condition else y 的矢量化版本。
xarr，yarr 为数组。
cond 为布尔型数组。
numpy.where 表示 cond 为真时，执行xarr，否则执行yarr。

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])

np.where(cond, xarr, yarr)

array([ 1.1,  2.2,  1.3,  1.4,  2.5])

利用条件逻辑表达式进行赋值

arr = np.random.randn(4,4)
arr

array([[-0.97170106,  0.39422479, -0.87202839,  0.95650709],
       [ 0.01440846,  1.57808512, -0.31303884,  0.1833287 ],
       [ 0.61855283, -0.39369561,  0.39966876, -0.29794251],
       [ 0.34755575,  1.91619738,  1.65520593, -0.32377046]])

np.where(arr>0, 2, -2)

array([[-2,  2, -2,  2],
       [ 2,  2, -2,  2],
       [ 2, -2,  2, -2],
       [ 2,  2,  2, -2]])

原数组未变

arr

array([[-0.97170106,  0.39422479, -0.87202839,  0.95650709],
       [ 0.01440846,  1.57808512, -0.31303884,  0.1833287 ],
       [ 0.61855283, -0.39369561,  0.39966876, -0.29794251],
       [ 0.34755575,  1.91619738,  1.65520593, -0.32377046]])

np.where(arr>0, 2, arr)

array([[-0.97170106,  2.        , -0.87202839,  2.        ],
       [ 2.        ,  2.        , -0.31303884,  2.        ],
       [ 2.        , -0.39369561,  2.        , -0.29794251],
       [ 2.        ,  2.        ,  2.        , -0.32377046]])

利用 cond1，cond2 的四种不同布尔值组合实现赋值操作

result=[]
for i in range(n):
    if cond1[i] and cond2[2]:
        result.append[o]
    elif cond1[i]:
        result.append[1]
    elif cond2[i]:
        result.append[2]
    else:
        result.append[3]

np.where(cond1 & cond2, o,   
          np.where(cond1, 1,  
                     np.where(cond2, 2, 3)))

4. 广播

广播是指：不同大小的数组之间的算数运算的执行方式。

广播的原则

如果两个数组的后缘维度（从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为他们是广播兼容。广播会在缺失和（或）长度为1的维度上进行。

arr = np.arange(5)
arr + 5

array([5, 6, 7, 8, 9])

np.ones((3, 3))

array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

np.ones((3, 3)) + np.arange(3)

array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])

np.arange(3).reshape(3, 1)

array([[0],
       [1],
       [2]])

np.arange(3).reshape(3, 1) + np.arange(3)

array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])

5. 线性代数计算

函数	说明
dot	矩阵乘法
trace	对角线元素的和
det	矩阵行列式
eig	方针的本征值和本征向量
inv	方针的逆

转置矩阵

arr

array([0, 1, 2, 3, 4])

arr.T

array([0, 1, 2, 3, 4])

矩阵乘法

arr = np.arange(3)
arr

array([0, 1, 2])

np.dot(arr, arr.T)

6. 数组存储

文本保存

arr = np.arange(10).reshape(2, 5)
np.savetxt('test.out', arr)
!cat test.out

0.000000000000000000e+00 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00 4.000000000000000000e+00
5.000000000000000000e+00 6.000000000000000000e+00 7.000000000000000000e+00 8.000000000000000000e+00 9.000000000000000000e+00

arr2 = np.loadtxt('test.out')
arr2

array([[ 0.,  1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.,  9.]])

二进制保存

arr = np.arange(10)
np.save('some_array', arr)

np.load('some_array.npy')

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

多个数组保存在一个压缩文件中

np.savez('array_archive.npz', a=arr, b=arr)

arch = np.load('array_archive.npz')

arch['b']

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

IPython 小教程

Sun, 11 Sep 2016 00:00:00 +0800

IPython 笔记与练习

学习资源

IPython官网
 Stackoverflow, tag it “ipython”
Notebook Gallery

常用快捷键整理

查看快捷键清单：Ctrl + M + H （先同时按住 Ctrl + m ，再按 h ）
cell 切换成 code 模式：Y
cell 切换成 markdown 模式：M
删除 cell：X
撤销 cell 的删除：Z
复制 cell：C
上方添加 cell：A
下方添加 cell：B
下方黏贴 cell：V
上方粘贴 cell：Shift + V
运行 cell：Ctrl + Return
运行 cell 并打开一个新 cell：Shift + Return
撤销上一步：Command + Z
保存：Command + S

代码运行

在cell 中输入代码后，点击“run cell”（图标如下所示），或快捷键 Shift + Return／Ctrl + Return

print ("Hellot world!")

Hellot world!

帮助

变量前或后加上问号（?）可以显示有关该对象的通用信息

import numpy as np

?np

如果该对象是一个函数或实例，则其docstring（如果有的话）会被显示出来：

def add_numbers(a, b):
    return a + b

?add_numbers

双问号（??）:显示出该函数的源代码（如果有的话）：

??add_numbers

搜索IPython 命名空间：问号（?）与通配符（*）配合，可显示出所有与该通配符表达匹配的名称，列出所有相关函数。
注：前面已执行过“import numpy as np”，否则，无反应

np.*load*?

快速参考手册（Quick Reference Card）：

%quickref

Tab 键自动补全

输入表达式时，按下Tab键，命名空间中任何与已输入字符串相匹配的变量都会被找出。

b = [1, 2, 3]

b.

输入与输出

最近的输出变量：_ （一个下划线）
倒数第二的输出变量：__ （两个下划线）

2 + 10

_ + 10

__ + 10

X 行的输出变量：_X ／ Out[X]
X 行的输入变量：_iX / In[X]

foo = 'bar'

foo

'bar'

_14

'bar'

_i14

'foo'

Out[16]

'foo'

In[17]

'Out[16]'

抑制输出，抑制之后没有输出：;

10 + 20;

'Out[16]'

查看历史记录（输入）：%history

%history

print ("Hellot world!")
import numpy as np
?np
def add_numbers(a, b):
    return a + b
?add_numbers
??add_numbers
np.*load*?
%quickref
b = [1, 2, 3]
2 + 10
_ + 10
__ + 10
foo = 'bar'
foo
_14
_i14
Out[16]
In[22]
In[17]
10 + 20;
_
%history

输入集合：In

In

['',
 'print ("Hellot world!")',
 'import numpy as np',
 "get_ipython().magic('pinfo np')",
 'def add_numbers(a, b):\n    return a + b',
 "get_ipython().magic('pinfo add_numbers')",
 "get_ipython().magic('pinfo2 add_numbers')",
 "get_ipython().magic('psearch np.*load*')",
 "get_ipython().magic('quickref')",
 'b = [1, 2, 3]',
 '2 + 10',
 '_ + 10',
 '__ + 10',
 "foo = 'bar'",
 'foo',
 '_14',
 '_i14',
 'Out[16]',
 'In[22]',
 'In[17]',
 '10 + 20;',
 '_',
 "get_ipython().magic('history')",
 'In']

输出集合：Out

Out

{10: 12,
 11: 22,
 12: 22,
 14: 'bar',
 15: 'bar',
 16: 'foo',
 17: 'foo',
 19: 'Out[16]',
 21: 'Out[16]',
 23: ['',
  'print ("Hellot world!")',
  'import numpy as np',
  "get_ipython().magic('pinfo np')",
  'def add_numbers(a, b):\n    return a + b',
  "get_ipython().magic('pinfo add_numbers')",
  "get_ipython().magic('pinfo2 add_numbers')",
  "get_ipython().magic('psearch np.*load*')",
  "get_ipython().magic('quickref')",
  'b = [1, 2, 3]',
  '2 + 10',
  '_ + 10',
  '__ + 10',
  "foo = 'bar'",
  'foo',
  '_14',
  '_i14',
  'Out[16]',
  'In[22]',
  'In[17]',
  '10 + 20;',
  '_',
  "get_ipython().magic('history')",
  'In',
  'Out']}

与操作系统交互

跟系统相关的常用命令：

命令	说明
!pwd	查看当前位置
%cd directory	更改位置到directory
!ls	查看当前目录
%bookmark	制作目录书签
%bookmark -1	列出所有书签

!pwd

/Users/lixin/Documents/Data103

%cd assignment

/Users/lixin/Documents/Data103/assignment

files = !ls
print ("My current directory's files:")
print (files)

My current directory's files:
['0w', '1w', '2w', '3w', '4w', '5w', '6w', '7w', '8w', '9w', 'README.md']

foo = "*w"
!ls $foo

0w:
0w-homework-ollie.md
README.md
ec.png
ec－time.png
interaction-mfsd.png
interaction-mftc.png
interaction.png
lgbt－ae.png
lgbt－be.png
lgbt－china.png
lgbt－e.png
sp－sample.png
中国统计年鉴2014城乡居民人均收入及恩格尔系数.xls

1w:
**?.png      ?.png        ??.png       README.md    run_cell.png tab.png

2w:
README.md

3w:
README.md

4w:
README.md

5w:
README.md

6w:
README.md

7w:
README.md

8w:
README.md

9w:
README.md

%bookmark data /Users/lixin/Documents/Data103

%cd data

(bookmark:data) -> /Users/lixin/Documents/Data103
/Users/lixin/Documents/Data103

%bookmark -l

Current bookmarks:
data -> /Users/lixin/Documents/Data103

魔法命令

常用魔法命令：

命令	说明
%quickref	显示IPython的快速参考
%magic	显示所有魔法命令的详细文档
%lsmagic	罗列所有魔法命令
%time	执行一行代码一次，显示执行时间
%timeit	多次执行一行代码，以计算系统平均执行时间
%%timeit	多次执行cell内代码，以计算系统平均执行时间
%%bash	在cell内打开bash
%%file x.x	cell内容写入文件x.x中
%run script.py	在IPython中执行一个python脚本文件

%magic

%lsmagic

Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %install_default_config  %install_ext  %install_profiles  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

%time range(100)

CPU times: user 5 µs, sys: 0 ns, total: 5 µs
Wall time: 10 µs

range(0, 100)

%timeit range(100)

The slowest run took 15.53 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 351 ns per loop

%%timeit
range (10)
range (100)

1000000 loops, best of 3: 694 ns per loop

%%bash
pwd
ls

/Users/lixin/Documents/Data103
ISSUE_TEMPLATE.md
README.md
assignment
assignment_sample_answer
code
note

%%file text.py
print ("World")

Writing text.py

%run text.py

World

绘图表示数据的走向

调用matplotlib

%matplotlib inline

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-54-e27d371d6baa> in <module>()
----> 1 get_ipython().magic('matplotlib inline')


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/interactiveshell.py in magic(self, arg_s)
   2161         magic_name, _, magic_arg_s = arg_s.partition(' ')
   2162         magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
-> 2163         return self.run_line_magic(magic_name, magic_arg_s)
   2164 
   2165     #-------------------------------------------------------------------------


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/interactiveshell.py in run_line_magic(self, magic_name, line)
   2082                 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
   2083             with self.builtin_trap:
-> 2084                 result = fn(*args,**kwargs)
   2085             return result
   2086 


<decorator-gen-106> in matplotlib(self, line)


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/magic.py in <lambda>(f, *a, **k)
    191     # but it's overkill for just that one bit of state.
    192     def magic_deco(arg):
--> 193         call = lambda f, *a, **k: f(*a, **k)
    194 
    195         if callable(arg):


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/magics/pylab.py in matplotlib(self, line)
     98             print("Available matplotlib backends: %s" % backends_list)
     99         else:
--> 100             gui, backend = self.shell.enable_matplotlib(args.gui)
    101             self._show_matplotlib_backend(args.gui, backend)
    102 


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/interactiveshell.py in enable_matplotlib(self, gui)
   2937         """
   2938         from IPython.core import pylabtools as pt
-> 2939         gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
   2940 
   2941         if gui != 'inline':


/Users/lixin/anaconda/lib/python3.5/site-packages/IPython/core/pylabtools.py in find_gui_and_backend(gui, gui_select)
    258     """
    259 
--> 260     import matplotlib
    261 
    262     if gui and gui != 'auto':


/Users/lixin/anaconda/lib/python3.5/site-packages/matplotlib/__init__.py in <module>()
   1129 
   1130 # this is the instance used by the matplotlib classes
-> 1131 rcParams = rc_params()
   1132 
   1133 if rcParams['examples.directory']:


/Users/lixin/anaconda/lib/python3.5/site-packages/matplotlib/__init__.py in rc_params(fail_on_error)
    973         return ret
    974 
--> 975     return rc_params_from_file(fname, fail_on_error)
    976 
    977 


/Users/lixin/anaconda/lib/python3.5/site-packages/matplotlib/__init__.py in rc_params_from_file(fname, fail_on_error, use_default_template)
   1098         parameters specified in the file. (Useful for updating dicts.)
   1099     """
-> 1100     config_from_file = _rc_params_in_file(fname, fail_on_error)
   1101 
   1102     if not use_default_template:


/Users/lixin/anaconda/lib/python3.5/site-packages/matplotlib/__init__.py in _rc_params_in_file(fname, fail_on_error)
   1016     cnt = 0
   1017     rc_temp = {}
-> 1018     with _open_file_or_url(fname) as fd:
   1019         try:
   1020             for line in fd:


/Users/lixin/anaconda/lib/python3.5/contextlib.py in __enter__(self)
     57     def __enter__(self):
     58         try:
---> 59             return next(self.gen)
     60         except StopIteration:
     61             raise RuntimeError("generator didn't yield") from None


/Users/lixin/anaconda/lib/python3.5/site-packages/matplotlib/__init__.py in _open_file_or_url(fname)
    998     else:
    999         fname = os.path.expanduser(fname)
-> 1000         encoding = locale.getdefaultlocale()[1]
   1001         if encoding is None:
   1002             encoding = "utf-8"


/Users/lixin/anaconda/lib/python3.5/locale.py in getdefaultlocale(envvars)
    556     else:
    557         localename = 'C'
--> 558     return _parse_localename(localename)
    559 
    560 


/Users/lixin/anaconda/lib/python3.5/locale.py in _parse_localename(localename)
    484     elif code == 'C':
    485         return None, None
--> 486     raise ValueError('unknown locale: %s' % localename)
    487 
    488 def _build_localename(localetuple):


ValueError: unknown locale: UTF-8

出现错误

ValueError: unknown locale: UTF-8

尝试在stackoverflow搜索错误名称，找到解决方案，是.bash_profile 需要更新。
.bash_profile的更新方法

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import gcf

x = np.linspace(0, 2*np.pi, 300)
y = np.sin(x**2)
plt.plot(x, y)
plt.title("A little chirp")
f = gcf() 

数学公式输入

IPython 使用MathJax 引擎渲染数学符号的输出。IPython 中的Cell 可以在Markdown 模式下直接使用 LaTex 语法输出数学公式。

公式的几种输出方式：

命令	说明
$数学公式$	公式在行中显示
`$$数学公式$$`	公式独占一行显示
`\begin{equation}数学公式\end{equation}`	公式独占一行显示
`\begin{equation}数学公式\end{equation}`	公式独占一行显示

$10^{10}$

$$10^{10}$$

$10^{10}$

\begin{equation}10^{10}\end{equation}

\begin{equation}10^{10}\end{equation}

\begin{equation*}10^{10}\end{equation*}

\begin{equation}10^{10}\end{equation}

具体数学公式，可以在前往网站自动生成

尝试通过该网站，输入公式：

$\sum_{i=0}^{n}i^{2}=\frac{\mathrm{(n^{2}+n)(2n+1)} }{\mathrm{6} }$

CLI 小教程

Thu, 09 Jun 2016 00:00:00 +0800

基本概念

Shell：从输入源（键盘）接受命令，传递给系统执行
Terminal：与Shell 系统交互时使用的交互界面，程序外壳
目录结构：Linux 系统没有分区概念，在系统根目录下各目录随具体的层级再展开。指示符：「/」。
字符含义：
- 「.」指代工作目录
- 「..」指代父目录
- 「~」指代home 目录，即 Users/Users_ID
路径名：通向文件的路径
绝对路径与相对路径
- 绝对路径：从根目录到目的地（当前目录）
- 相对路径：开始于当前工作目录
文件名
- 大小写敏感
- 文件名标点仅限「.」、「_」、「-」，不要用“空格”
丰富命令：command -options 例如：ls -a;mv -i item item2

常用命令

查看当前位置：pwd
更改位置：cd 路径
返回
- 返回主目录：cd
- 返回上一个操作的目录：cd -（中间空格）
- 返回上一级目录：cd ..（中间空格）
查看目录文件列表
- 查看当前目录：ls
- 查看指定目录：ls 路径
- 显示隐藏文件：ls -a
- 长格式输出：ls -l
- 修改时间排列：ls -t
查看文件属性：file file_name
查看文档内容：cat 路径
创建目录
- 创建一个子目录：mkdir directory
- 创建多个子目录：mkdir dire
- 创建与当前目录同级的目录：mkdir ../directory
创建文件：touch file_name
复制
- 复制到某目录：cp item directory
- 复制多个文件：cp item1 item2 item3 directory
- 确认并复制已存在文件： cp -i
- 递归复制：cp -r
移动
- 移动到某目录：mv item directory
- 移动多个：mv item1 item2 item3 directory
重命名
- 将item改名为item2：mv item1 item2
- 隐藏文件：mv item .item
删除文件
- 删除一个或多个文件：rm item item2
- 确认后删除：rm -i item
- 显示操作信息删除：rm -v item
删除目录
- 删除空目录：rm directory
- 删除含文件目录：rm -rf directory
- 删除多个文件和目录：rm -r item directory
- 文件和目录不存在，依旧执行删除：rm -rf item directory
查看执行过的命令（历史）：history
查看命令属性
- 类型：type command_name
- 执行程序的位置：which command_name
- 命令用法提示（帮助）：command_name –help
- 命令手册（帮助）：man command_name
- 简介版命令说明：whatis command_name
剪贴板内容保存为文本：pbpaste > file_name
查看文件行数：wc -l file_name
- 统计字数：-w
- 最长的行长度：-l
安装程序
- 第一步：brew search program_name
- 第二步：brew install program_name
- 第三步：man program_name
查看进程
- 实时动态进程＋占用资源最多进程列表：top
- 静态进程：ps -A
- 搜索某进程：pgrep program_name
- 所有进程：ps A
终止进程
- pid号：kill -9 pid_number
- 进程名称：pkill progrom_name
- 关键词：kill $(pgrep program_name)
执行前一条命令：sudo !!

小工具

时间
- 显示日期：date +%y/%m/%d
- 显示钟点：date +%H:%M
日历
- 当月日历：cal
- 年历：cal 「year」
  eg:cal 1992
- 某月月历：cal 「month」「year」
  eg:cal 8 1998
计算器：bc «< 算式
- 加法：+
- 减法：-
- 乘法：*
- 除法：/
- 指数：^
- 余数：%
- 退出计算：quit
识别词汇：say words
打开当前目录：open .

快捷键

调取历史记录里的命令：键盘上下箭头
窗口字符大小缩放：Command +/-
目录和命令的自动补全：Tab 键
查找历史命令：Ctrl + R
终止程序：Ctrl + c
离开（关闭）终端：exit
- Ctrl + D
- Ctrl + W
清屏：clear
- 清屏＋内容可以上翻查看：Ctrl + L
- 清屏＋原内容不在显示：Ctrl + K

短命令

自定义短命令：alias short_line=’command_line’
取消短命令：unalias short_line（关闭终端，会自动失效）
永久配置短命令
- 第一步：打开终端工具：vi ~/.bashrc 或 vi ~/.zshrc
- 第二步：进入编辑模式：上下箭头移至文档末尾，点击「i」
- 第三步：填写：alias short_command=”command”
- 第四步：退出：点击「esc」，然后Shift + : ，输入wq 并敲击「Enter」
- 第五步：看适配文档：source ~/.bashrc 或 source ~/.zshrc

Search 小指南

Sat, 04 Jun 2016 00:00:00 +0800

搜索技巧

” “ 限定：限定某个内容为关键词，搜索结果无关键词外延
* 模糊搜索: 关键词的省略替代
- 排除：减去不想要的结果
「site:xxx.com Keyword」限定站点搜索：站内搜索关键词，但需接口开放，例如微信只对搜狐开放API
形容词限定搜索范围
「filetype:pdf/word/ppt/jpg/git Keyword」类别搜索：搜索特定的文档类型
「or」多重搜索：类似于“或”；默认情况下空格类似于“和”

搜索技巧扩展

google 算术
- 加＝「+」
- 减＝「+」
- 乘＝「＊」
- 除＝「/」
输入框技巧
- 货币兑换＝「1 dollar in rmb」
- 度量衡＝「mile in km」
- 城市时间＝「time Beijing」
- 城市天气＝「weather Beijing」
tab 搜索
- 第一步：输入网站的开头
- 第二步：点击Tab 键，激活Tab 搜索
- 第三步：输入搜索关键词
- 第四步：跳转至站点搜索结果页
添加自定义搜索
- 第一步：保留地址搜索关键词之前的部分，关键词用%s 替换
- 第二步：打开Chrome 设置（Settiing）菜单中搜索（Search）选项中的管理搜索隐形（Manage Search Engines）窗口
- 第三步：输入搜索引擎名称、搜索代号以及第一步中的地址

窗口快捷键

打开新窗口：Ctrl+N
打开新标签页：Ctrl+Y
隐身模式打开窗口：Ctrl+Shift+N
关闭标签：Ctrl+W
重新加载刚刚关闭的标签：Ctrl+Shift+T
隐藏书签栏：Ctrl+Shift+Delete
放大／缩小网页字体：Ctrl+(+/-)
重置原页面：Ctrl+0

杜宾宝宝招募领养人请认真阅读以下条件，才能带它回家

Fri, 03 Jun 2016 00:00:00 +0800

什么是杜宾犬

我家杜宾属于中型犬，产地德国，是所有品系中极富智慧的并且身体结构最为优秀，气质最为高贵的一种。如果你喜欢打扮它，可以把它变成这样:

只是剪耳有些小残忍，而且个人喜欢它平易近人一点。所以我家的两只是这样:

当然啦，大多时候是这样

和这样。

他们一只叫Seven，一只叫Lisa，从小就在庄园里长大，地方大、吃得好，又有些娇惯！所以是有幸福感的狗狗，我们也希望，他们的宝宝们有幸福的归宿。

首先，你的一时高兴，可是它一辈子的依靠，你要想好再行动。

一只狗大约要活十几年，从小到大到老到死去，你都是它唯一的亲人。它永远不会把痛苦变成语言来跟你说，但你会每天有一种陪伴叫“它爱你”。

而且你要习惯有一种痴情的“等待”在你离开的家门口。

接下来，你能给到它的空间环境，我真的希望是大一点、再大一点。

因为杜宾是猎犬出身，善于奔跑、天性好动，所以地方越大它就越开心！

最后，你一定要出钱领养，原因很简单。

第一，它值钱。

第二，即使有一天它身陷灭顶之灾，“它是花钱买的”，或者“它很值钱”这样的话，可能会救它一命。

那要出多少钱？等你决定要了，我会根据你的实际情况出价的，你的条件越好，出的越少！

再说一点养杜宾的重要好处：

镇宅！

前方高能！哔哔哔哔~

看看宝宝的照片吧：