机器学习---笔记----Python基础
一. python简介
1. python 具有丰富强大的库，常被称为胶水语言，能够把用其他语言制作的各种模块很轻松地联结在一起
2. python强制使用空白符（white space）作为语句缩进。
3. 可以使用 py2exe等包转换成系统能够执行的文件。
4. Python的瓶颈不在于自身语言的运行时间，在于一些网络速度等外在因素的影响。
二. Python库
1. python版本
常用的有2.7和3.5两个版本，这两个版本不完全兼容。但就目前Windows的环境而言，Python2.7对于数据分析领域就足够用了，但3.5更多用于web开发。当然，也可以使用 2to3.py 实现两个版本之间的转换。
D:\>python 2to3.py t1.py
RefactoringTool: Skipping optional fixer: buffer
RefactoringTool: Skipping optional fixer: idioms
RefactoringTool: Skipping optional fixer: set_literal
RefactoringTool: Skipping optional fixer: ws_comma
RefactoringTool: Refactored t1.py
--- t1.py (original)
+++ t1.py (refactored)
@@ -1 +1 @@
-print 'all tasks has been finished!'
+print('all tasks has been finished!')
RefactoringTool: Files that need to be modified:
RefactoringTool: t1.py
不推荐大家使用上面这个转换的库，因为官网上说这个库会随着时间发生剧烈的变化。
2. pip
pip是安装python包的推荐工具：https://pypi.python.org/pypi/pip
也可以手动更换pip中的数据源：pip install -l https://pypi.tuna.tsinghua.edu.cn/simple numpy
pip会在数据源中查找符合你系统配置的最新版的安装包进行自动安装。
3. numpy
为Python提供快速的多维数组处理能力
4. pandas
在numpy基础上提供了更多了数据读写工具
5. scipy
在numpy基础上添加了众多科学计算工具包
6.matplotlib
Python丰富的绘图库，主要针对二维绘图，有少数的三维绘图函数
三. 数据生成
1. list, array
标准Python的列表list中，元素本质是对象
如：L=[1,2,3],需要3个指针和三个整数对象，对于数值运算比较浪费内存和CPU。
因此，numpy提供了ndarray(N-dimensional array object)对象:存储单一数据类型的多维数组。
# # 1.使用array创建
# 通过array函数传递list对象
L = [1, 2, 3, 4, 5, 6]
print "L = ", L
a = np.array(L)
print "a = ", a
print type(a), type(L)
# # 若传递的是多层嵌套的list，将创建多维数组
b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print b
2. 改变数组的大小和形状
# # # # # 数组大小可以通过其shape属性获得
print a.shape
print b.shape
#
# # # 也可以强制修改shape
b.shape = 4, 3
print b
# # 注：从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变
#
# # # 当某个轴为-1时，将根据数组元素的个数自动计算此轴的长度
b.shape = 2, -1
print b
print b.shape
#
b.shape = 3, 4
print b
# # # # 使用reshape方法，可以创建改变了尺寸的新数组，原数组的shape保持不变
c = b.reshape((4, -1))
print "b = \n", b
print 'c = \n', c
3. 数组的存储，类型
# # # # 数组b和c共享内存，修改任意一个将影响另外一个
b[0][1] = 20
print "b = \n", b
print "c = \n", c
#
# # # # 数组的元素类型可以通过dtype属性获得
print a.dtype
print b.dtype
# # # # #
# # # # # 可以通过dtype参数在创建时指定元素类型
d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)
f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)
print d
print f
#
# # # 如果更改元素类型，可以使用astype安全的转换
f = d.astype(np.int)
print f
# # #
# # # # 但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型
d.dtype = np.int
print d下面是上面代码中倒数第二个d, 和f的输出
[[ 1. 2. 3. 4.]
[ 5. 6. 7. 8.]
[ 9. 10. 11. 12.]]
[[ 1.+0.j 2.+0.j 3.+0.j 4.+0.j]
[ 5.+0.j 6.+0.j 7.+0.j 8.+0.j]
[ 9.+0.j 10.+0.j 11.+0.j 12.+0.j]] 4. 使用函数创建
# 如果生成一定规则的数据，可以使用NumPy提供的专门函数
# arange函数类似于python的range函数：指定起始值、终止值和步长来创建数组
# 和Python的range类似，arange同样不包括终值；但arange可以生成浮点类型，而range只能是整数类型
np.set_printoptions(linewidth=100, suppress=True)
a = np.arange(1, 10, 0.5)
print a # # # # linspace函数通过指定起始值、终止值和元素个数来创建数组，缺省包括终止值
b = np.linspace(1, 10, 10)
print 'b = ', b # # 可以通过endpoint关键字指定是否包括终值
c = np.linspace(1, 10, 10, endpoint=False)
print 'c = ', c # # # 和linspace类似，logspace可以创建等比数列
# # 下面函数创建起始值为10^1，终止值为10^2，有10个数的等比数列
d = np.logspace(1, 4, 4, endpoint=True, base=2)
print d
# # # # #
# # # # # 下面创建起始值为2^0，终止值为2^10(包括)，有10个数的等比数列
f = np.logspace(0, 10, 11, endpoint=True, base=2)
print f
#
# # # # 使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组
s = 'abcdzzzz'
g = np.fromstring(s, dtype=np.int8)
print g
# #
下面为输出结果：
[ 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]
b = [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
c = [ 1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
[ 2. 4. 8. 16.]
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
[ 97 98 99 100 122 122 122 122] 5. 存取
1）常规办法
# 数组元素的存取方法和Python的标准方法相同
a = np.arange(10)
print a
# # # 获取某个元素
print a[3]
# # # # # 切片[3,6)，左闭右开
print a[3:6]
# # # 省略开始下标，表示从0开始
print a[:5]
# # # 下标为负表示从后向前数
print a[3:]
# # 步长为2
print a[1:9:2]
# # # # # # 步长为-1，即翻转
print a[::-1]
# # 切片数据是原数组的一个视图，与原数组共享内容空间，可以直接修改元素值
a[1:4] = 10, 20, 30
print a
# # 因此，在实践中，切实注意原始数据是否被破坏，如：
b = a[2:5]
b[0] = 200
print a
[0 1 2 3 4 5 6 7 8 9]
3
[3 4 5]
[0 1 2 3 4]
[3 4 5 6 7 8 9]
[1 3 5 7]
[9 8 7 6 5 4 3 2 1 0]
[ 0 10 20 30 4 5 6 7 8 9]
[ 0 10 200 30 4 5 6 7 8 9] 2）整数/布尔数组存取
# 3.2.1
# 根据整数数组存取：当使用整数序列对数组元素进行存取时，
# 将使用整数序列中的每个元素作为下标，整数序列可以是列表(list)或者数组(ndarray)。
# 使用整数序列作为下标获得的数组不和原始数组共享数据空间。
a = np.logspace(0, 9, 10, base=2)
print a
i = np.arange(0, 10, 2)
print i
# # # 利用i取a中的元素
b = a[i]
print b
# # # b的元素更改，a中元素不受影响
b[2] = 1.6
print b
print a # # 3.2.2
# 使用布尔数组i作为下标存取数组a中的元素：返回数组a中所有在数组b中对应下标为True的元素
# 生成10个满足[0,1)中均匀分布的随机数
a = np.random.rand(10)
print a
# # 大于0.5的元素索引
print a > 0.5
# # # 大于0.5的元素
b = a[a > 0.5]
print b
# # # 将原数组中大于0.5的元素截取成0.5
a[a > 0.5] = 0.5
print a
# # # # # b不受影响
print b
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
[0 2 4 6 8]
[ 1. 4. 16. 64. 256.]
[ 1. 4. 1.6 64. 256. ]
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
[ 0.6863079 0.43770902 0.06801346 0.75436358 0.94302857 0.79214232 0.08905118 0.50204237
0.20263459 0.67341405]
[ True False False True True True False True False True]
[ 0.6863079 0.75436358 0.94302857 0.79214232 0.50204237 0.67341405]
[ 0.5 0.43770902 0.06801346 0.5 0.5 0.5 0.08905118 0.5
0.20263459 0.5 ]
[ 0.6863079 0.75436358 0.94302857 0.79214232 0.50204237 0.67341405] 3)切片
# 3.3 二维数组的切片
# [[ 0 1 2 3 4 5]
# [10 11 12 13 14 15]
# [20 21 22 23 24 25]
# [30 31 32 33 34 35]
# [40 41 42 43 44 45]
# [50 51 52 53 54 55]]
a = np.arange(0, 60, 10) # 行向量
print 'a = ', a
b = a.reshape((-1, 1)) # 转换成列向量
print b
c = np.arange(6)
print c
f = b + c # 行 + 列
print f
# # 合并上述代码：
a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
print a
# # # 二维数组的切片
print '++++++++++++++'
print a[[0, 1, 2], [2, 3, 4]]
print a[4, [2, 3, 4]]
print a[4:, [2, 3, 4]]
print '+++++++++++++'
i = np.array([True, False, True, False, False, True])
print i
print a[i]
print a[i, 3]
a = [ 0 10 20 30 40 50]
[[ 0]
[10]
[20]
[30]
[40]
[50]]
[0 1 2 3 4 5]
[[ 0 1 2 3 4 5]
[10 11 12 13 14 15]
[20 21 22 23 24 25]
[30 31 32 33 34 35]
[40 41 42 43 44 45]
[50 51 52 53 54 55]]
[[ 0 1 2 3 4 5]
[10 11 12 13 14 15]
[20 21 22 23 24 25]
[30 31 32 33 34 35]
[40 41 42 43 44 45]
[50 51 52 53 54 55]]
++++++++++++++
[ 2 13 24]
[42 43 44]
[[42 43 44]
[52 53 54]]
+++++++++++++
[ True False True False False True]
[[ 0 1 2 3 4 5]
[20 21 22 23 24 25]
[50 51 52 53 54 55]]
[ 3 23 53] 上面代码中，
a[i]中索引 i 因为是布尔数组，所以它实际上是对对应行的选择，TRUE为选择，FALSE为不选择。
6.numpy与Python数学库的时间比较
for j in np.logspace(0, 7, 8):
x = np.linspace(0, 10, j)
start = time.clock()
y = np.sin(x)
t1 = time.clock() - start x = x.tolist()
start = time.clock()
for i, t in enumerate(x):
x[i] = math.sin(t)
t2 = time.clock() - start
print j, ": ", t1, t2, t2/t1
1.0 : 8.00000000001e-06 9.00000000015e-06 1.12500000002
10.0 : 0.000125 0.000319 2.552
100.0 : 1.20000000001e-05 0.000231 19.2499999998
1000.0 : 0.000138 0.000307 2.22463768116
10000.0 : 0.000383 0.002946 7.69190600522
100000.0 : 0.003997 0.029284 7.32649487115
1000000.0 : 0.038909 0.326851 8.40039579532
10000000.0 : 0.390234 2.951487 7.5633773582
从上面的运行结果可以看出来，一般情况下，numpy的效率比Python数学库要快，平均快7倍左右 7. 元素去重
# 4.2 元素去重
# 4.2.1直接使用库函数
a = np.array((1, 2, 3, 4, 5, 5, 7, 3, 2, 2, 8, 8))
print '原始数组：', a
# # # 使用库函数unique
b = np.unique(a)
print '去重后：', b
# # 4.2.2 二维数组的去重，结果会是预期的么？
c = np.array(((1, 2), (3, 4), (5, 6), (1, 3), (3, 4), (7, 6)))
print '二维数组：\n', c
print '去重后：', np.unique(c)
# # # 4.2.3 方案1：转换为虚数
r, i = np.split(c, (1, ), axis=1)
x = r + i * 1j
x = c[:, 0] + c[:, 1] * 1j
print '转换成虚数：', x
print '虚数去重后：', np.unique(x)
print np.unique(x, return_index=True) # 思考return_index的意义
idx = np.unique(x, return_index=True)[1]
print '二维数组去重：\n', c[idx]
# # 4.2.3 方案2：利用set
print '去重方案2：\n', np.array(list(set([tuple(t) for t in c])))原始数组： [1 2 3 4 5 5 7 3 2 2 8 8]
去重后： [1 2 3 4 5 7 8]
二维数组：
[[1 2]
[3 4]
[5 6]
[1 3]
[3 4]
[7 6]]
去重后： [1 2 3 4 5 6 7]
转换成虚数： [ 1.+2.j 3.+4.j 5.+6.j 1.+3.j 3.+4.j 7.+6.j]
虚数去重后： [ 1.+2.j 1.+3.j 3.+4.j 5.+6.j 7.+6.j]
(array([ 1.+2.j, 1.+3.j, 3.+4.j, 5.+6.j, 7.+6.j]), array([0, 3, 1, 2, 5]))
二维数组去重：
[[1 2]
[1 3]
[3 4]
[5 6]
[7 6]]
去重方案2：
[[1 2]
[5 6]
[7 6]
[1 3]
[3 4]]
从上面输出结果可以看出：
a. 直接使用np.unique(c)为二维数组去重，不能达到理想的结果。因为unique会默认将输入的数组拉成一维的，然后去重。
b. 对于二维数组去重，一般会选择先将其转成虚数去重，然后再还原成二维。但该种方式会打乱数组里面元素的顺序，所以我们可以令参数return_index=true来让其放回各个元素原始的索引。
c. 使用set来去重需要先将数组转成list然后再进行操作。 8.三维数组去重
# 4.3 stack and axis
a = np.arange(1, 7).reshape((2, 3))
b = np.arange(11, 17).reshape((2, 3))
c = np.arange(21, 27).reshape((2, 3))
d = np.arange(31, 37).reshape((2, 3))
print 'a = \n', a
print 'b = \n', b
print 'c = \n', c
print 'd = \n', d
s = np.stack((a, b, c, d), axis=0)
print 'axis = 0 ', s.shape, '\n', s
s = np.stack((a, b, c, d), axis=1)
print 'axis = 1 ', s.shape, '\n', s
s = np.stack((a, b, c, d), axis=2)
print 'axis = 2 ', s.shape, '\n', s a = np.arange(1, 10).reshape(3,3)
print a
b = a + 10
print b
print np.dot(a, b) ###矩阵乘法
print a * b ##矩阵元素相乘 a = np.arange(1, 10)
print a
b = np.arange(20,25)
print b
print np.concatenate((a, b)) ###连接
a =
[[1 2 3]
[4 5 6]]
b =
[[11 12 13]
[14 15 16]]
c =
[[21 22 23]
[24 25 26]]
d =
[[31 32 33]
[34 35 36]]
axis = 0 (4, 2, 3)
[[[ 1 2 3]
[ 4 5 6]] [[11 12 13]
[14 15 16]] [[21 22 23]
[24 25 26]] [[31 32 33]
[34 35 36]]]
axis = 1 (2, 4, 3)
[[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]] [[ 4 5 6]
[14 15 16]
[24 25 26]
[34 35 36]]]
axis = 2 (2, 3, 4)
[[[ 1 11 21 31]
[ 2 12 22 32]
[ 3 13 23 33]] [[ 4 14 24 34]
[ 5 15 25 35]
[ 6 16 26 36]]]
[[1 2 3]
[4 5 6]
[7 8 9]]
[[11 12 13]
[14 15 16]
[17 18 19]]
[[ 90 96 102]
[216 231 246]
[342 366 390]]
[[ 11 24 39]
[ 56 75 96]
[119 144 171]]
[1 2 3 4 5 6 7 8 9]
[20 21 22 23 24]
[ 1 2 3 4 5 6 7 8 9 20 21 22 23 24] 函数stack实现多个数组堆叠的功能。从运行结果可以看出，当
axis=0时， 是将a, b, c, d四个数组分别作为元素组成新的列向量中的元素；
axis=1时，是分别将a, b, c, d四个数组中的第一个元素组成一个新的列元素，第二个元素也是同样的，最后组成一个列向量。
axis=2时，是将a,b,c,d四个数组先拉成一维，然后分别取四个数组中相同位置的元素组成新的列向量中的元素。
机器学习---笔记----Python基础的更多相关文章
- Python学习笔记—Python基础1 介绍、发展史、安装、基本语法
第一周学习笔记: 一.Python介绍 1.Python的创始人为吉多·范罗苏姆.1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言 ...
- 笔记-Python基础教程（第二版）第一章
第一章 快速改造:基础知识 01:整除.乘方 (Python3.0之前 如2.7版本) >>> 1/2 ==>0 1/2整除,普通除法: 解决办法1: 1.0/2.0 ==& ...
- [笔记] Python基础---列表
1.定义列表 列表由数据构成的有限序列,即按照一定的线性顺序排列,排列而成的数据项的集合. 2.创建列表 使用‘[ ]’括起来就已经创建了一个列表,例: my_first_list = [] #空列表 ...
- 学习笔记-python基础
一. 1.python按装 1.1 官网 https://www.python.org 1.2 点 downloads下的 windows下载64位python3.7.3版本 Download Win ...
- Python基础_文件的的处理及异常处理
今天主要讲讲文件读写及异常处理. 一.文件操作 1.1 文件的创建及读 打开文件 open 函数 open(file,[option]) file 是要打开的文件 option是可选择的参数文件的打 ...
- Python机器学习笔记：sklearn库的学习
网上有很多关于sklearn的学习教程,大部分都是简单的讲清楚某一方面,其实最好的教程就是官方文档. 官方文档地址:https://scikit-learn.org/stable/ (可是官方文档非常 ...
- Python机器学习笔记：不得不了解的机器学习面试知识点（1）
机器学习岗位的面试中通常会对一些常见的机器学习算法和思想进行提问,在平时的学习过程中可能对算法的理论,注意点,区别会有一定的认识,但是这些知识可能不系统,在回答的时候未必能在短时间内答出自己的认识,因 ...
- Python机器学习笔记：不得不了解的机器学习知识点（2）
之前一篇笔记: Python机器学习笔记:不得不了解的机器学习知识点(1) 1,什么样的资料集不适合用深度学习? 数据集太小,数据样本不足时,深度学习相对其它机器学习算法,没有明显优势. 数据集没有局 ...
- Python机器学习笔记 集成学习总结
集成学习(Ensemble learning)是使用一系列学习器进行学习,并使用某种规则把各个学习结果进行整合,从而获得比单个学习器显著优越的泛化性能.它不是一种单独的机器学习算法啊,而更像是一种优 ...
随机推荐
- java.io.FileNotFoundException异常,一是“拒绝访问”，二是“系统找不到指定路径”
关于java.io.FileNotFoundException异常 因为这个异常抛出俩种情况:一是“拒绝访问”,二是“系统找不到指定路径” 这里只讲明什么时候抛拒绝访问,什么时候抛找不到指定路径. 原 ...
- Java代码优化，都有哪些常用方法？
Java代码优化是Java编程开发很重要的一个步骤,Java代码优化要注重细节优化,一个两个的细节的优化,产生的效果不大,但是如果处处都能注意代码优化,对代码减少体积.提高代码运行效率是有巨大帮助的, ...
- 学习笔记53—Wilcoxon检验和Mann-whitney检验的区别
Wilcoxon signed-rank test应用于两个related samples Mann–Whitney U test也叫Wilcoxon rank-sum test,应用于两个indep ...
- jfinal集成cas单点认证实践
本示例jfinal集成cas单点认证,采用获取到登录用户session信息后,在本地站点备份一份session信息,主要做以下几个步骤: 1.站点引入响应jar包: 2.在web.xml中配置对应过滤 ...
- Codeforces 1043 F - Make It One
F - Make It One 思路: dp + 容斥 首先, 答案不会超过7, 因为前7个质数的乘积大于3e5(最坏的情况是7个数, 每个数都缺少一个不同的因子) 所以从1到7依次考虑 dp[i][ ...
- web前端名人的博客微博Githu
尤雨溪 vuejs作者 王垠 http://www.yinwang.org/ 20位活跃在Github上的国内技术大牛 1. lifesinger(玉伯) Github主页: ht ...
- lua中pairs 和 ipairs 的区别
1.table中存储值的时候,是按照顺序存储的,存储 k-v 的时候,是按照 k 的哈希值存储的. 2.ipairs --- 只能输出 table 中的值,并且不可输出nil,遇到 ni l就退出 p ...
- Unity --- 纹理压缩基本知识点
1.Unity支持的压缩格式的分类,这里主要指Android平台和IOS平台: DXT格式 --- Nvidia Tegra(图睿)提供ETC --- 安卓原生支持的,OPNEGL2.0都支持,ET ...
- Asp.net core 学习笔记 ( HttpClient )
2018-09-18 core 2.1 之后有新的方案咯 http://www.talkingdotnet.com/3-ways-to-use-httpclientfactory-in-asp-net ...
- MySQL中如何建立主从复制
## 1 概述 ## MySQL内建的复制功能是构建大型,高性能应用程序的基础.将Mysql的数据分布到多个系统上去,这种分布的机制,是通过将Mysql的某一台主机的数据复制到其它主机(slaves) ...