本篇使用方法：
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': '[email protected]', /
'Bill Gates': '[email protected]'}
x['Christopher Brooks']
# Retrieve a value by using the indexing operator
>>> '[email protected]'
- 在字典中用于索引或值的类型可以是任何类型。
- 可能是一个混合的类型。
- 可以将新项目添加到字典中，使用相同的索引运算符
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', '[email protected]')
fname, lname, email = x
这是另一个例子，有一个元组(tuple)，有名字， 姓氏和电子邮件地址。
声明三个变量并将它们指派给元组(tuple)。
在内部，Python已经拆解了元组， 并按顺序分配了这些变量。
可以看到，如果向元组添加第四个项目， Python不知道如何拆解，所以我们有一个错误。
Python Map
| Python | map |
|---|---|
| 含义 | |
| 返回 | object |
| 参数 | 第一个参数是想要执行的函数，第二个参数和下面的每个参数，是可以反覆运算后的东西。 |
| 备注 | map函数返回给你一个map物件(object)。实际上并没有尝试在两个项目上运行min函数， 直到你查看里面的值。 |
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 | range |
|---|---|
| 含义 | |
| 返回 | x |
| 参数 | x |
| 备注 | python2.7中有xrange函数和range函数 python3中把range优化了，合并了xrange和range函数 用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
| Python | split |
|---|---|
| 含义 | 用于分割 |
| 返回 | 返回string |
| 参数 | 输入string |
| 备注 | .split(' ')[0] [0] selects the first element of the list |
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
| numpy | arange |
|---|---|
| 含义 | 返回固定间隔的array |
| 返回 | array([]) |
| 参数 | 传递一个开始start，一个停止stop和一个跨步step的值， 并在给定的间隔内返回均匀跨步的值。 |
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
| numpy | diag |
|---|---|
| 含义 | diag构造一个对角阵列 |
| 返回 | array |
| 参数 | array |
y = np.array([4, 5, 6])
np.diag(y)
>>>
array([[4, 0, 0],
[0, 5, 0],
[0, 0, 6]])
Numpy Floor
| numpy | floor |
|---|---|
| 含义 | 计算比每一个元素小或相等的最大的整数. |
| 返回 | |
| 参数 | x |
11/0.3
>>> 36.66666666666667
np.floor(11/0.3)
>>> 36.0
Numpy Linalg.Solve
| numpy | linalg.solve |
|---|---|
| 含义 | 设解线性方程组形如 Ax=b，其中 A 是系数矩阵，b 是一维(n 维也可以)，x 是未知变量. 再拿上面地最简单的二元一次方程组为例，用 numpy.linalg.solve 可以这样写成下面的。 |
| 返回 | 求解 |
| 参数 | 矩阵A，矩阵b |
| 备注 | scipy.optimize import fsolve 也可以解决方程组问题，还可以是非线性方程组 |
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
| numpy | linspace |
|---|---|
| 含义 | linspace函数类似于arange，除了告诉需要返回多少个数字，它会相应地分隔间隔。 |
| 返回 | array |
| 参数 | 起点，重点，均分个数 |
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
| numpy | meshgrid |
|---|---|
| 含义 | 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()
| numpy | numpy.random.uniform(low,high,size) |
|---|---|
| 含义 | 从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high |
| 返回 | ndarray类型，其形状和参数size中描述一致 |
| 参数 | (low,high,size) |
| low | 采样下界，float类型，默认值为0； |
| high | 采样上界，float类型，默认值为1； |
| size | 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。 |
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
| Python | Fraction |
|---|---|
| 含义 | 分数 |
| 返回 | fraction |
| 参数 | fraction float， string，Decimla |
| 备注 | limit_denominator(max=1000)：可以截取想要得到的分母最大值；这个非常有用，也就是简化了分数的形式，一般可以化简成我们真实想要的分数。 |
#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