本篇使用方法：
Control + F 可以找到所有我日常积累常用的python解释

Python是一种高级程式语言，这意味着它是针对人能够理解，而不是机器来进行优化的。它也是一种直译语言，这意味着它不直接编译为机器码，更重要的是，它通常以互动方式来使用。这可能会有很大差异，如果你习惯于像Java或C这类的程式，你写程式，编译它，运行并查看它的输出。在Python中，你可以启动互动式直译器，开始编写程式，直译器会进行评估你编写的每一行程式。在对于需要大量调查研究的程式工作来说，而不是需要大量设计的程式工作，这是非常有用的。Shell脚本就是其中的一个例子，数据清理是另一个。

Python是一种动态类型的语言，类似于JavaScript等语言。
这意味着当你声明一个变数时，你可以在上一行将其定义为整数，并在下一行将其指定为字符串。
Python的动态类型是特别有益的，当以互动方式使用时，因为它允许你快速的设置和修改变量内容，而无需担心变数的底层语法定义。

Jupyter

点击shift+enter来运行单元
程式的输出会立即印出来。如果你在非互动模式下使用Python，则不会印出任何结果。
但是，由于我们以互动模式使用它，我们立即获得该值。
真正发生的是浏览器将Python程式 发送到云端中的一台电脑机器， 该电脑机器执行Python 3直译器的代码，并将结果发送回来。

• Python不需要使用 关键字，诸如用var来声明一个变数名称，或 用分号在行末尾，在其他程式语言中常用的。 Python利用空白来理解函数和回路的范畴， 以及行尾符号来理解程式语句的结尾。

• 'def'语句，表明我们正在写一个函数。
  作为函数的一部分，每一行都需要 使用制表符(Tab)或缩进几个

• 不同于 其他语言，这里有一些微妙之处。首先，由于没有类型，你不需要设置返回的类型。

• 其次，你实际上不必使用return语句。有一个名为'None'的特殊值返回。 None与Java中的null类似，表示缺少或者没有值。

• 在Python中，你可以设置参数的预设值。例子中，我们可以重写add_numbers函数来接受三个参数， 但我们可以设最后的参数为预设的None 这意味着你可以使用两个值或三个值来调用add_numbers，而不必重写函数来重载(Overloading)它。

• 这里有一个重要的暗示含义。所有可选用的参数，那些有预设值的， 都需要放在函数声明的最末尾。这也意味着你可以传递可选参数为一个标记值。以下是有标记参数的例子。

def add_numbers(x,y,z=None):
    if (z==None):
        return x+y
    else:
        return x+y+z

• 关于基本的Python函数最后一句话。在 Python 中，可以将一个variable分配给一个函数。这可能看起来 完全奇怪。通过指定一个函数到一个变数，你可以将该变数传递给 其他函数，这会允许一些基本的功能程式。

Python Types and Sequences

Python没有静态类型并不意味着Python中没有类型。 Python语言有一个内置的函数，称为type，它将显示类型。一些常见的类型包括字串(string)，None类型，整数(interger)和浮点(floating-point)变数。

许多Python构建于不同的序列或集合类型。有三种原始的集合类型，元组(tuple)，列表(list)和字典(dictionary)。

元组(tuple)是一个本身不可变的变数序列。这意味着元组(tuple)含有次序的项目， 而且一旦创建就不能更改。我们使用括号来表示元组(tuple)，我们可以混合不同的类型 在元组里。这是一个有四个项目的元组(tuple)。两个是数字，两个是字串(string)。

x = (1, 'a', 2, 'b')
type(x)
>>> tuple

单引号或双引号都可用于表示字串(string)

列表(list)和tuple非常相似，但它们可以是可以改变的， 因此你可以更改其长度，元件的数量和更改元件。

x = [1, 'a', 2, 'b']
type(x)
>>>list

• 使用方括号来表示列表(list)。
• 有几种不同的方式来更改列表的内容。一个是通过附加功能，允许你将新项目附加到 列表的末尾。

x.append(3.3)

• 列表(list)和元组(tuple)都是可以反覆迭代的类型，因此可以写loop去遍历它的每个元件。
  通常的标准是，如果想查看列表中的每个项目，是使用一个for语句。
  这与Java和C＃等语言中的for-each回圈类似， 但请注意，不需要指定类型。

for item in x:
    print(item)

• 列表(list)和元组(tuple)的数组也可以存取，类似存取阵列(array)在其他语言， 通过使用方括号运算程序，它叫做索引运算程序。列表(list)的第一个项目从零开始， 要获取列表的长度，我们使用内置的len函数。还有一些其他常见的功能，你可能会料想到，像最小(min)和最 大值(max)，它会找到列表或元组中的最小值或最大值。

i=0
while( i != len(x) ):
    print(x[i])
    i = i + 1

Python列表(list)和 元组(tuple)也可以允许有一些基本的数学运算。

• 加号(+)把列表(list)连接起来。星号(*乘号)重复列表的值。
• 一个非常常见的运算符是in运算符。这将查看项目是否隶属在组合中，并返回一个布尔值(boolean-value)，true或false， 根据一个项目是否在给定的列表中。

最有趣的操作可以使用在列表称为切片(slicing)。其中用于存取元素的方括号阵列语法，
在Python中，索引操作允许你使用多个数值。第一个参数是起始位置， 如果这是唯一的元素，然后一个项目从列表中返回。第二个参数是切片的结尾。Python的一个方便之处在于，所有的字串(string)实际上 只是字的列表(list)，所以对它们用切片是很容易的。

• 运行x[0]或x[0：1]时，得到字串的第一个字。
• 运行x[0：2]时，得到字串的前两个字。

x = 'This is a string'
print(x[0]) #first character
print(x[0:1]) #first character, but we have explicitly set the end character
print(x[0:2]) #first two characters
x[-4:-2]          #读取从最后的第4个到最后第2个位置的所有的字
x[:3]             #从第一个字开始，直到位置3
x[3：]            #从第四个字开始，因为索引总是从 零开始，一直到列表的末尾。

• 索引值也可以是负数
• x[-1]得到字串的最后一个字
• x[-4：-2] 读取从最后的第4个到最后第2个位置的所有的字。
• 想要引用到字串的开端或 结尾，可以通过只将参数留空白。
• x[：3]从第一个字开始，直到位置3。
• x[3：]从第四个字开始，因为索引总是从 零开始，一直到列表的末尾。

字串只是字的列表。所以你可以在列表(list)中执行的操作，也可以在字串(string)上执行。

• 可以使用加号运算(+)将两个字串连接起来。
• 用乘法运算(*)来重复给定的字串。
• 也可以搜索字串使用in操作符。

firstname = 'Kaiwei'
lastname = 'Zhang'

print(firstname + ' ' + lastname)
print(firstname*3)
print('Kaiwei' in firstname)
>>> True

字串(string)类型具有关联的函数称为拆分(split)。

此函数将字串分解成 子字串基于简单的模式 例如这里

firstname = 'Christopher Arthur Hansen Brooks'.split(' ')[0] 
lastname = 'Christopher Arthur Hansen Brooks'.split(' ')[-1] 
print(firstname)
print(lastname)

根据空格字符的存在来分割我的全名。结果是四个元件的列表。我们可选择索引运算的第一个元素作为名字， 最后一个元素姓氏。

字典(dictionaries)类似于列表和元组，它们包含一些集合 的项目

• 是有标记而没有排序的集合。这意味着每一个插入字典的值， 还必须要提供一个键(key)来获取该值。
• 在其他语言中，这种结构通常被称为map.
• 在Python中，使用大括号{}表示字典。
• 表示一个创建的字典项目时， 会使用一个冒号(:)来分隔一对值。然后，你可以检索给定标记的值，使用索引运算。

# Dictionaries associate keys with values.
x = {'Christopher Brooks': 'brooksch@umich.edu', /
'Bill Gates': 'billg@microsoft.com'}
x['Christopher Brooks'] 
# Retrieve a value by using the indexing operator
​>>> 'brooksch@umich.edu'

• 在字典中用于索引或值的类型可以是任何类型。
• 可能是一个混合的类型。
• 可以将新项目添加到字典中，使用相同的索引运算符

x['Kevyn Collins-Thompson'] = None
x['Kevyn Collins-Thompson']
>>> # 什么也不返回

• 可以通过多种方式反覆迭代字典中的所有项目。
• 可以迭代所有的键keys， 只挑出适合你的需要的内容即可。

for name in x:
    print(x[name])

• 可以反覆迭代值(value)，而忽略不理键(key)。

for email in x.values():
    print(email)

• 可以同时迭代value和key两者， 使用item的功能。

for name, email in x.items():
    print(name)
    print(email)

拆解的例子：
可以有序列sequence-亦即有数据的list或tuple， 可以将这些项目分解成不同的变数, 用一个指定(assignment)语句。

x = ('Christopher', 'Brooks', 'brooksch@umich.edu')
fname, lname, email = x

这是另一个例子，有一个元组(tuple)，有名字， 姓氏和电子邮件地址。
声明三个变量并将它们指派给元组(tuple)。
在内部，Python已经拆解了元组， 并按顺序分配了这些变量。
可以看到，如果向元组添加第四个项目， Python不知道如何拆解，所以我们有一个错误。

Python Map

People = ['Dr. Christopher Brooks', 'Dr. Kevyn Collins-Thompson', 
'Dr. VG Vinod Vydiswaran', 'Dr. Daniel Romero']

def split_title_and_name(person):
    return person.split(' ')[0] + person.split(' ')[2]

list(map(split_title_and_name, people))

Python Range

Python Reshape

n = np.arange(0, 30, 2)
n = n.reshape(3, 5) # reshape array to be 3x5
#output
array([[ 0,  2,  4,  6,  8],
       [10, 12, 14, 16, 18],
       [20, 22, 24, 26, 28]])

Python Shape

m = np.array([[7, 8, 9], [10, 11, 12]])
m.shape
>>> (2, 3)

Python Split

firstname = 'Christopher Arthur Hansen Brooks'.split(' ')[0] 
lastname = 'Christopher Arthur Hansen Brooks'.split(' ')[-1] 
print(firstname)
print(lastname)

Python Type

Python | type

type('This is a string')
>>>str
type(None)
>>>NoneType
type(add_numbers)
>>>function

Numpy

Numpy Arange

n = np.arange(0, 30, 2) # start at 0 count up by 2, stop before 30
>>>
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

Numpy Diag

y = np.array([4, 5, 6])
np.diag(y)
>>>
array([[4, 0, 0],
       [0, 5, 0],
       [0, 0, 6]])

Numpy Floor

11/0.3
>>> 36.66666666666667
np.floor(11/0.3)
>>> 36.0

Numpy Linalg.Solve

A = np.mat('1,2; 4,5')    # 构造系数矩阵 A                matrix([[1, 2],[4, 5]])
b = np.mat('3,6').T       # 构造转置矩阵 b 这里必须为列向量  matrix([[3],[6]])
                          # 不转置之前是                     matrix([[3, 6]])
r = np.linalg.solve(A,b)  # 调用 solve 函数求解              A.dot(r)验证

#多一个元
A = np.mat('3,-2,1; 1,1,1;3,-2,-1')    
b = np.mat('7,2,3').T      
r = np.linalg.solve(A,b) 

#多一个维度
A = np.mat('1,2; 4,5')          
b = np.array([[3,6], [7,8]]).T    #这里用了array注意一下
r = np.linalg.solve(A,b)   

Numpy Linspace

o = np.linspace(0, 4, 9) # return 9 evenly spaced values from 0 to 4
o
>>> array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ])

Numpy Meshgrid

import numpy as np  
x = [1,2,3,4]
y = [5,6,8,9]
xm, ym = np.meshgrid(x, y)


figure(figsize=[12, 4])
subplot(1, 2, 1)
plot(xm, ym, '.');
xlabel('x')
ylabel('y')
title('100 Grid Samples');

x = np.arange(0, 10)*.1
y = np.arange(0, 10)*.1
a, b = np.meshgrid(x, y)
subplot(1, 2, 2)
plot(a, b, '.');
xlabel('x')
ylabel('y')
title('100 Grid Samples');

Numpy Random.uniform()

xs = np.random.uniform(size=[2, 100])
# xs.shape = (2, 100)

subplot

import numpy as np  
import matplotlib.pyplot as plt  
x = linspace(0,10); 
y1 = sin(x); 
y2 = sin(5*x);
a=subplot(321);
b=subplot(324);

# subplot(nrows, ncols, index, **kwargs)
# subplot(numRows, numCols, plotNum)
# subplot将整个绘图区域等分为numRows行* numCols列个子区域
# 然后按照从左到右，从上到下的顺序对每个子区域进行编号，左上的子区域的编号为1。
# 如果numRows，numCols和plotNum这三个数都小于10的话，可以把它们缩写为一个整数，
# 例如subplot(323)和subplot(3,2,3)是相同的。

subplot(a);
plot(y1);
subplot(b);
plot(y1);

fraction模块提供有关有理数的算术表达和计算，实际上就是分数的表达和计算

import fractions

Python Fraction

#Construct a Fraction by numerator and denominator  
print (Fraction(3))      #3  
print (Fraction())       #0  
print (Fraction(10,8))   #5/4  
  
#construct by other fraction  
print (Fraction(5/4))    #5/4  
  
#construct by float  
print (Fraction(2.5))    #5/2  
print (Fraction(1.1))    #2476979795053773/2251799813685248  
  
#construct by decimal  
print (Fraction(Decimal('2.5')))  #5/2  
  
#construct by string  
print (Fraction('12/23'))         #12/23  

a = 5/46
Fraction(a).limit_denominator(1000)
#如果做这一步，结果不是 5/46
# 而是 Fraction(7832347178035645, 72057594037927936)

csv module

csv.DictReader()

相关链接：

numpy linalg.solve
numpy meshgrid
numpy random.uniform