2018-04-12 开胃学习Python系列 - Python

作者: Kaiweio | 来源:发表于2018-04-13 12:41 被阅读0次

本篇使用方法：
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

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()