Hexo


  • 首页

  • 标签

  • 分类

  • 归档

用Python玩转数据——Week1

发表于 2018-03-10 | 分类于 用Python玩转数据 |

第一个Python程序

  • 运行方式
    • Shell方式
    • 文件方式

      模块是对象,并且所有的模块都有一个内置属性 name。一个模块的 name 的值取决于您如何应用模块。如果 import 一个模块,那么模块name 的值通常为模块文件名,不带路径或者文件扩展名。但是您也可以像一个标准的程序样直接运行模块,在这 种情况下, name 的值将是一个特别缺省”main“。

  • IO
    • 输入
      var = input();
      Python 3.x中raw_input() 和input()整合成了input(), 返回类型为str
    • 输出
      print语句
  • 代码风格

    • 注释 # comment
    • 续行

      • 续行符
      • 括号内的内容
      • 三引号
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        >>>print('''hello 
        world''')
        hello
        world

        >>> x = '''hello
        ... work'''
        >>> x == 'hello work'
        False

        >>> y = 'hello work'
        >>> z = 'hello \
        ... work'
        >>> y == z
        True
    • 缩进——语句块

基础语法

  • 变量: 标识对象,引用对象
  • 标识符: 合法的变量名称
  • 关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    Python中的对象包含三要素:id、type、value
    其中id用来唯一标识一个对象,type标识对象的类型,value是对象的值

    is判断的是a对象是否就是b对象,是通过id来判断的
    ==判断的是a对象的值是否和b对象的值相等,是通过value来判断的

    >>> a=100
    >>> b=100.0
    >>> a is b
    False
    >>> a==b
    True
    >>> id(a)
    30696848L
    >>> id(b)
    48685000L
    >>> id(a)==id(b)
    False
  • 运算符

    • 算术运算符
    • 位运算符
    • 比较运算符
    • 逻辑运算符
  • 表达式:用运算符连接各种类型数据的式子
  • 赋值:给变量类型和“值”

    • 增量赋值
      m %= 5
      没有 m++ 这样的语句
    • 多重赋值
      PI = pi = 3.14159
    • 多元赋值

      x, y = y, x
      等式俩边是元祖

      多重赋值PI, r = 3.14159, 3的本质由两个步骤构成:
      temp = 3.14159, 3 # 元组打包(Tuple packing)
      PI, r = temp # 序列解包(Sequence unpacking),多重赋值有时也称为序列解包

  • 语句:完整执行一个任务的一行逻辑代码
    • 语句包含表达式

数据类型

必须有明确的数据类型,程序才能分配给常量、变量精确 的存储大小,才能进行精确或高效率的运算

  • Python标准数据类型

    • (长)整型

      Python 3.x中没 有long类型, 整数都是int型
      存储大小跟内存有关,不会发生溢出问题

      1
      2
      3
      4
      5
      6
      7
      >>> x = 100000000000000000000000000000
      >>> x **=2
      >>> x
      10000000000000000000000000000000000000000000000000000000000
      >>> x **=2
      >>> x
      100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
    • 浮点型

      没有double

    • 复数型
    • 布尔型
    • 序列类型
      • 字符串: 不可变
      • 列表:可变
      • 元组:不可变
    • 映射类型
      • 字典

基本运算

  • 算术运算符

    乘方 ** 正负号+ -
    乘除
    / 整除//
    取余% 加减+ -

  • 比较运算

    3 < 4 < 7 # same as ( 3 < 4 ) and ( 4 < 7 )
    True
    4 > 3 == 3 # same as ( 4 > 3 ) and ( 3 == 3 )
    True
    4 < 3 < 5 != 2 < 7
    False

  • 逻辑运算
  • 字符运算符
    • 原始字符串操作符 (r / R)
    • Unicode 字符串操作符( u / U )

函数、模块和包

函数

  • 内建函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    绝对值函数abs(x)
    类型函数type(x)
    四舍五入函数round(x)

    >>> round(3.4)
    3
    >>> round(4.6)
    5
    >>> round(3.5)
    4
    >>> round(2.5)
    2

    四舍六入五成双
  • 非内建函数: 非内建函数的使用需要靠模块引入

模块

一个完整的Python文件即是一个模块

  • 文件:物理上的组织方式 math.py
  • 模块:逻辑上的组织方式 math

包

  • 一个有层次的文件目录结构
  • 定义了一个由模块和子包组成 的 Python 应用程序执行环境

库

  • 库是一组具有相关功 能的模块的集合

RANGE和 XRANGE

  • range():Python3返回的是一个range对象,需要用list(range())方式进行调用

    range (start, end, step=1)
    range (start, end)
    range (end)

  • xrange
    Python3 不支持xrange()

循环

  • while

    1
    2
    3
    4
    5
    6
    while expression: 
    suite_to_repeat

    • 条件表达式
    • 当 expression 值 为 True
    时执行suite_to_repeat代码块
  • for

    1
    2
    for iter_var in iterable_object: 
    suite_to_repeat
    • 可以明确循环的次数

      • 遍历一个数据集内的成员
      • 在列表解析中使用
      • 生成器表达式中使用
    • iterable_object

      • String
      • List
      • Tuple
      • Dictionary
      • File
  • 循环中的else语句
    • 如果循环代码从break处终止,跳出循环
    • 正常结束循环,则执行else中代码

函数

内建函数

自定义函数

1
2
3
def addMe2Me(x):
'apply operation + to argument' #DocString,用来说明文本
return (x+x)

print(fn._doc):查看函数文档

参数

  • 默认参数

    默认参数一般需要放置在参数列表的最后

  • 关键字参数

    关键字参数是让调用 者通过使用参数名区 分参数。允许改变参 数列表中的参数顺序

  • 传递函数

    函数可以像参数一样传递给另外一个函数

  • lamda函数
    1
    2
    3
    4
    5
    lambda     x, y  :  x + y

    my_add = lambda x, y : x + y
    >>> my_add(3, 5)
    8

变量作用域

  • 全局变量
  • 局部变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # Filename: scopeofvar.py
    def f(x):
    print a
    a =5
    print a + x

    a= 3
    f(8)

    UnboundLocalError: local variable 'a' referenced before assignment
    # 在这里 a 为全局变量
  • global语句

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    global语句强调全局变量

    # Filename: scopeofvar.py
    def f(x):
    global a
    print a
    a= 5
    print a + x

    a= 3
    f(8)
    print a


    Output: 3
    13
    5

LeetCode42. Trapping Rain Water

发表于 2018-03-10 | 分类于 LeetCode |

思路构建

满足什么要求才会积水?

必须存在一个左边界left,一个右边界right,且高度大于height[i]

图一
需要明确对积水面积F[i]的定义:

以高度height[i]为底,存在比height[i]高的左右界,围成的面积

对于图一,明显F[i]就是满足该定义的一块积水面积


对于图二:

  • F[1] 满足,其左右边界分别为0,4
  • F[2] 满足,其左右边界为1,3
  • F[3] 满足,其左右边界为0,4

因为F[i]是指,对于特定的左右边界,底高为height[i]的面积,因此F[1],F[3]其实是重复计算

所以我们可以指计算F[3],舍去同一个左右边界中,前面的高度为height[i]的点

"图三"
F[1]对应黄色部分
F[2]对应橙色部分
F[3]对应红色部分

怎么计算这个面积?

num = h * distance;
h = Math.min(height[])

怎么确定F[i]的左右边界?

维护一个递减的栈

对于下标i,值为c,判断c是否小于栈顶元素

  • 如果小于,则已经找到了F[i]的左边界,但是仍未找到右边界,需要在后面确定,因此先放到栈中
  • 如果大于,贼栈顶元素的右边界已经出现了,弹栈
    • 但是可能对于这个c,它同时也是弹完栈后的元素的右边界,因此需要继续判断,直到 c < height[stack.peek()]

代码

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
32
33
34
35
36
37
class Solution {
public int trap(int[] height) {
if(height == null || height.length == 0) return 0;

Stack<Integer> stack = new Stack<>();

int result = 0;

for(int i = 0; i < height.length; i++) {

//维护一个递减栈,只有当height[i] < height[stack.peek()]
//栈内存储的是该值,位于数组中的下标

//对于一个bar,只有当这个bar存在左右边界,才会积水
while(!stack.isEmpty() && height[i] > height[stack.peek()] ) {
//如果height[i] > height[stack.peek()],意味着栈顶元素的右边界出现了

//弹栈
int top = stack.pop();

//如果这个栈为空,意味着 栈顶元素的左边界不存在,不会有积水
if(stack.isEmpty()) break;

int distance = i - stack.peek() - 1;

int h = Math.min(height[stack.peek()], height[i]) - height[top];

result += h * distance;

}
stack.push(i);

}

return result;
}
}

LeetCode20. Valid Parentheses

发表于 2018-03-10 | 分类于 LeetCode |

思路构思

针对这个题目,先想几组input进行分析

输入input

  • (())

    在从左到右遍历过程中input[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
public boolean isValid(String s) {

if(s == null || s.length() == 0) return true;

int len = s.length();
Stack<Character> stack = new Stack<>();
Set<Character> frontSet = new HashSet<>();
Set<Character> endSet = new HashSet<>();
frontSet.add('(');
frontSet.add('[');
frontSet.add('{');
for(int i = 0; i < len; i++) {
Character c = s.charAt(i);
if(frontSet.contains(c)) {
stack.push(c);
}else {
if(stack.isEmpty()) return false;
Character t = stack.pop();
if(c == ')' && t != '(') {
return false;
}else if(c == ']' && t != '[') {
return false;
}else if(c == '}' && t != '{') {
return false;
}
}
}
if(!stack.isEmpty()) return false;
return true;
}

LeetCode32. Longest Valid Parentheses

发表于 2018-03-10 | 分类于 LeetCode |

思考构思

首先针对括号匹配问题:借鉴LeetCode20那题的经验,我们可以想到借助栈,接下来就开始验证栈是否能解决该问题

思路一

  1. 考察第i位字符c
  2. 如果c为左括号,把位置坐标i压栈
  3. 如果c为右括号,对栈进行弹栈,得到index,i-index+1 就是匹配的长度

验证

  • 对于(()),算法有效
  • 对于输入()(),算法无效

需要针对第二种情况,重新构思

思路二

  1. 考察第i位字符c
  2. 如果c为左括号,把位置坐标i压栈
  3. 如果c为右括号,如果栈非空(匹配成功),对栈进行弹栈,访问弹栈后的栈顶元素index
    • 由该算法可知,此时栈顶元素(stack.peek())代表着是最右边不匹配位置,i到index之间的括号都是匹配的,即i-index 就是匹配的长度
  4. 如果c为右括号,栈为空(匹配失败),或者栈顶元素所代表的字符不是’(‘ (匹配失败),将i入栈

验证

  • 对于(()),算法有效
  • 对于(),算法错误,没有考虑边界问题

思路三

在思路二的第3步,在防卫stack.peek()时,需要先判断栈是否为空,如果为空,意味着从0到i都是匹配的,index代表最靠近i的一处不匹配位置,因此这里因设为-1

验证

  • 对于(()),算法有效
  • 对于()(),算法有效

思考边界值

  • s为空

代码

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
class Solution {
public int longestValidParentheses(String s) {
if(s == null || s.length() == 0) return 0;

Stack<Integer> stack = new Stack<>();

stack.push(0);
int len = 0;
int front = 0;
for (int i = 1; i < s.length(); i++) {
if (s.charAt(i) == '(') {
stack.push(i);
} else if (stack.isEmpty() || s.charAt(stack.peek()) != '(') {
stack.push(i);

} else {
stack.pop();
int index = -1;
if(!stack.isEmpty()) {
index = stack.peek();
}
len = Math.max(len, i - index );
}
}

return len;
}
}

机器学习学习路径

发表于 2018-03-09 | 分类于 机器学习 |

学习计算机是一件很幸福的事情,相比其他学科,可以以很低的成本获取非常优质的资源。

在学校,你不需要担心上什么课,看什么书,但是现在自己学习,总想着能把有限的时间,花在最适合自己的课程和书籍中去,以下是我最近的一些思考。

资源

  • 网课
    • Machine Learning —— Coursera(finished,入门课程吧,数学推导要求不高,编程作业好评)
    • 机器学习基石 —— Coursera(很好的课)
    • 机器学习技法 —— Coursera
    • deeplearning.ai —— Coursera(网上一种评价是:最简单的深度学习课)
    • 邹博 机器学习(个人挺喜欢,有很好的数学推导,但需要好好消化,缺少练习)
    • Machine Learning nondegree —— Udacity(偏实战,数学要求很低)
    • MLDS —— NTU 李宏毅(摸索)
    • Neural Networks for Machine Learning —— Coursera(评价很高,但据说难度大,可以当进阶课程)
  • 书籍
    • 《统计学习方法》
    • 《机器学习》—— 周志华
    • 《集体智慧编程》
    • 《TensorFlow 实战Google深度学习框架》

策略

  1. 第一阶段
    • 机器学习基石: 一周俩次课
    • MLDS : 一周俩次课
    • 《统计学习方法》

Hexo配置

发表于 2018-03-07 | 分类于 工具 |

配置步骤

  • 创建github pages
  • 创建本地hexo环境
  • 选择hexo主题
  • 优化配置

创建github pages

登录github,创建一个新的repository,但仓库名的格式必须为:github账号名.github.io

创建hexo环境

  1. hexo需要用到nodejs,因此先去nodejs官网安装nodejs环境
  2. 按照hexo官网按照hexo
  3. 建站,安装完Hexo后,在执行下列命令,Hexo将会在指定文件夹中新建所需要的文件。
    1
    2
    3
    $ hexo init <folder>
    $ cd <folder>
    $ npm install

更多配置信息,可以参考Hexo文档

选择Hexo主题

我使用的是Next,可以从github上下载https://github.com/iissnan/hexo-theme-next

需要注意的是,按照github上指令安装的版本是5.1.2版本,但如果想添加第三方Valine的评论功能,需要安装5.1.3以上的版本

Next具体细节可以参考Next文档

优化配置

  1. 配置git
    因为要将最新的博客,上传到github上,需要输入以下指令

    1
    2
    $ hexo clean
    $ hexo g -d

    而执行hexo g -d 需要用户输入其相应的github账号名和密码,为了避免每次提交,都输入账号和密码,需要设置SSH keys,具体可以参考廖雪峰git教程

  2. 添加评论
    这里用到了next中集成的第三方服务

    Hexo的评论系统有很多,常见的有

    • 多说
    • 网易云跟帖
    • 畅言
    • 来必力(LiveRe)
    • Disqus
    • Hypercomments
    • valine
      其中多说和网易云已经失效,而来必力用的是国外服务器,每次加载都很慢,所以建议使用valine

      具体可以参考
      https://www.bluelzy.com/articles/use_valine_for_your_blog.html

  3. 添加动态效果
    看到别人使用hexo搭建的博客有酷炫的动态效果,上网搜了一下后发现,其实实现起来很方便

    前端效果
    https://segmentfault.com/a/1190000009544924

  4. 代码高亮

    在站点的_config.yml中如下配置

    1
    2
    3
    4
    5
    highlight:
    enable: true
    line_number: true
    auto_detect: true
    tab_replace: true
  5. 代码段折叠
    写LeetCode题解时,发现代码太长了,影响阅读,所以想实现一下代码段的折叠

    具体参考
    https://www.cnblogs.com/woshimrf/p/hexo-fold-block.html

第二周

发表于 2018-03-06 | 分类于 计划 |

周一

  • 邹博算法课——链表、栈、队列
  • LeetCode
    • Merge k Sorted Lists
    • Merge Two Sorted Lists
  • deeplearning.ai week1

周二

  • 用Python玩转数据 week1
  • LeetCode
    • Pow(x, n)
    • Add Two Numbers
    • Median of Two Sorted Arrays
  • Hexo
    • 代码语法高亮
    • 代码块折叠

周三

  • 用Python玩转数据 week2
  • LeetCode
    • Remove Duplicates from Sorted List II
    • Remove Duplicates from Sorted List
    • Swap Nodes in Pairs
    • Remove Nth Node From End of List
    • Reverse Nodes in k-Group
  • 配置git
  • 博客

周四

  • MLDS第二次课:2.5h
  • LeetCode
    • 20 Valid Parentheses
    • 92 Reverse Linked List II
    • 86 Partition List

周五

  • 机器学习——林轩田
  • LeetCode: 这俩题刷新了我对栈的认知,但仔细思考之后,收获良多
    • 84 Largest Rectangle in Histogram
    • 42 Trapping Rain Water

周六

  • 博客: 三篇题解
  • LeetCode
    • 32 Longest Valid Parentheses

刷题记录

发表于 2018-03-06 |

第一阶段

  • 刷题范围:LeetCode 前150题
  • 刷题顺序:按类型刷题
  • 刷题资料
    • 邹博算法课: 一周一节课,难易结合

      字符串 : 难
      树 : 易
      动态规划 : 难
      数组 : 易
      图论

  • 刷题量:每天做1道没有思路的题

秋招备战

发表于 2018-03-06 | 分类于 计划 |

知识点

  • 机器学习
    • Q-learning
    • 朴素贝叶斯
    • 高斯混合模型
    • 隐 Markov 模型
    • 测度论
      • 混淆矩阵
      • ROC 曲线
      • p值
    • SVM
      • 凸优化
      • 梯度下降
      • 二次规划
      • 拉格朗日
      • 偏微分方程
  • 深度学习
    • 深度置信网或者层叠降噪自动编码机 / Deep Belief Nets or Stacked Denoising Autoencoders
    • 卷积神经网络(CNN)
    • 长短记忆(LSTM)时间递归神经网络
    • 结构递归神经网络(通常用于自然语言处理)
    • word2vec 神经网络以及相关通过上下文学习词语的相关算法
    • 单指令流多数据流(SIMD)向量计算(比如说GPU)
  • 概率统计

  • 算法

    • 邹博算法课
    • Stanford Algorithm Specialist
    • LeetCode
  • 数据库
    • 分布式数据库
  • Linux:在服务器上部署,处理数据
    • 《Unix入门经典》
    • cat 、grep 、find 、awk 、sed 、sort 、cut 、tr
  • 编程语言
    • Python
      • Coursera 《用Python玩转数据》
    • Java

学习计划

  • 前三个月
    • LeetCode ,算法题200道题
    • 完成deeplearning.ai
    • 完成《用Python玩转数据》
    • 看完邹傅算法课
    • 完成3门Stanford 算法课
    • 完成李宏毅的深度学习课程
  • 后三个月
    • LeetCode,算法题250道题
    • 实战
      • 《集体智慧编程》
    • 面经
    • 实验室实习

执行情况

  • 第一个月
    • 第一周
      • 搭建hexo
      • 设置搬瓦工
      • LeetCode 分治算法题(9)
    • 第二周
      • 算法
        • 链表 & 栈
        • LeetCode:16
      • MLDS
        • 俩次课
      • Python
        • 俩次课
      • 博客
        • 三篇题解

总结——4.13

  • 林轩田——机器学习基石week8
    • 机器学习模型
    • 感知机算法
    • VC dimension
    • 误差估计
  • Udacity——P2
    • 模型评估
  • 算法
    • 数组
    • 字符串
    • 链表&栈
  • 《用Python玩转数据》: 完成
  • LeetCode——28题

    机器学习基石得搁置,比想象中难,对数学要求比较高,涉及的统计和线性代数知识点,老师不会单独点出,默认上课的同学已经掌握。需要一定的数学基础
    下一阶段打算以Udacity课程为基础,学习算法,Stanford的statistics Learning,凸优化

总结:完成情况不好,

LeetCode4. Median of Two Sorted Arrays

发表于 2018-03-05 | 分类于 LeetCode |

代码思路

  • 转化为查找第K个数
  • 二分查找
点击显/隐代码
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int len1 = nums1.length;
int len2 = nums2.length;

// 分治~二分查找
int low = 0;
int high = len1;

while (true) {
// index1 代表 nums1 在左侧的个数,取值范围 [0,len1];
int index1 = low + (high - low) / 2;
int index2 = (len1 - index1 + len2) / 2;

// 对应的左边下边
int i = index1 - 1;
int j = index2 - 1;

// 边界情况
if (index1 == 0) {
if (nums2[index2 - 1] <= nums1[index1]) {
if(index2 == len2) return (nums1[index1] + nums2[index2-1])/2.0;
return (nums2[index2 - 1] + Math.min(nums1[index1], nums2[index2])) / 2.0;
} else {
low = index1 + 1;
}
} else if (index2 == len2) {
if (nums2[index2 - 1] <= nums1[index1]) {
if(index1 == 0) return (nums1[index1] + nums2[index2-1])/2.0;
return (Math.max(nums1[index1 - 1], nums2[index2 - 1]) + nums1[index1]) / 2.0;
} else {
// index1 取小了
low = index1 + 1;
}
} else if (index2 == 0) {
if (nums1[index1 - 1] <= nums2[index2]) {
if (index1 == len1)
return (nums1[index1 - 1] + nums2[index2]) / 2.0;
return (nums1[index1 - 1] + Math.min(nums1[index1], nums2[index2])) / 2.0;
} else {
high = index1;
}
} else if (index1 == len1) {
if (nums1[index1 - 1] <= nums2[index2]) {
if (index2 == 0)
return (nums1[index1 - 1] + nums2[index2]) / 2.0;
return (Math.max(nums1[index1 - 1], nums2[index2 - 1]) + nums2[index2]) / 2.0;
} else {
high = index1;
}
}

else if (nums1[index1 - 1] <= nums2[index2] && nums2[index2 - 1] <= nums1[index1]) {
return (Math.max(nums1[index1 - 1], nums2[index2 - 1]) + Math.min(nums1[index1], nums2[index2])) / 2.0;
} else if (nums1[index1 - 1] > nums2[index2] || nums2[index2 - 1] > nums1[index1]) {
high = index1;
} else {
low = index1;
}
}

}
1…345
Kai Niu

Kai Niu

Hello World!

41 日志
8 分类
31 标签
GitHub
© 2018 Kai Niu
由 Hexo 强力驱动
|
主题 — NexT.Mist v5.1.4