卡瓦邦噶！ | 无法自制的人得不到自由。

Git的pull和fetch

Posted on 2016年10月19日 by laixintao 7 Comments

初学Git的时候，pull和fetch让我迷惑了很久，两者都说是从远程分支取回数据到本地分支，今天，总算是搞懂了他们的区别。

fetch

在第一次clone远程仓库的时候，在本地会有一个不可移动的origin/master分支，以及一个可以移动的本地master分支。

在本地的master工作的时候，本地的master会向前移动，而origin/master是不可以移动的。如上图所示。

git fetch [远程仓库名] /[仓库名]是取回远程分支，更新本地的origin/master分支到最新的位置。这个时候，我们的本地master分支是不变的。如果要得到最新的数据，还要git merge origin/master。

pull

上面提到了，本地的origin/master分支是不可以移动的，如果想要直接在origin/master分支的最新状态上改动，可以在这个地方新开分支，然后在新分支上改动。

从远程分支 checkout 出来的本地分支，称为 跟踪分支 (tracking branch)。跟踪分支是一种和某个远程分支有直接联系的本地分支。在跟踪分支里输入 git push，Git 会自行推断应该向哪个服务器的哪个分支推送数据。同样，在这些分支里运行 git pull 会获取所有远程索引，并把它们的数据都合并到本地分支中来。

所以git pull命令，就是先fetch远程的分支，然后将远程分支合并到本地分支。

在克隆仓库时，Git 通常会自动创建一个名为 master 的分支来跟踪 origin/master。这正是 git push和 git pull 一开始就能正常工作的原因。

参考

git-scm 我发现这真是一个好东西，从这里能学到几乎所有用到的git知识。
我整理的一个git命令速查表：https://gist.github.com/laixintao/81079c85a5e4988f21a918a3af643e47

使用iPhone一个月的感受

Posted on 2016年10月18日 by laixintao 3 Comments

iPhone 6入手已经一个月了，已经完全适应了iOS。来说说这个月的使用体验吧。

这是我第一部iOS系统的手机，因为价格原因，前面用过的两部手机都是安卓的。在德国的时候我的摩托罗拉1085摔坏了，期间经历了不使用手机的两个月（也没觉得有什么不方便的）。等9月的发布会之后的第二天，打算去南京东路买个iPhone SE。结果那天店员告诉我，SE才降价了300元，iPhone 6S 64G降价了1100元，买iPhone 6S算了，正好那时候兼职做了个网站，有点收入，就入手了。顺便在官方店买了个苹果自家的手机壳，非常喜欢。之前都是不使用手机壳的，这个手机壳给了我比没有壳子还要好的手感。

关于从Android换到iOS，基本上是没有障碍的。不得不说，iOS确实流畅的多，我觉得主要是内存管理的好吧。比如在网上看到说使用第三方的输入法会卡，是因为系统为输入法分配的内存有限，这要是在Android上，输入法都能占内存无法无天，当然会卡了。话说应用打开很快，加上我有5G的流量，所以能用手机的地方我都会用手机，这个月一直在用支付宝，花的现金应该不超过100块吧。

系统功能的可用性相比于Android，要高很多。比如说，屏幕的自动调节亮度，我之前的两部Android手机老是变来变去的，而iPhone几乎让你感受不到屏幕亮度的变化；比如提醒事项和日历，系统的非常好用，所以我没有考虑过第三方的产品。而且配合Siri，有什么事情基本上都不会忘了，顺手就能方便的加到日程里面。哦，Android也有不错的Google日历，觉得不方便的原因大概是因为墙吧！如果没有墙，相信Android的用户体验也能上升一个档次。

付费应用问题，之前在Android上，要付费买个东西简直实在太麻烦了，而盗版的动动手指就能下载下来，所以我没有花心思去买过东西，而换了iPhone的一个月，我已经买了很多精品游戏和app了，之前玩过的Android版的也都买了一些。有一点心理作用，就是花钱买过的游戏比免费的好玩，嘿嘿。应用我买游戏比较多，因为系统的邮件、日历、提醒、相册等都非常棒，能完美地满足我的需求了。

关于用电。我上班和在家都可以充电，所以一般能充电的时候就会插着电源，对电量的要求很低。刚买的时候试了试，正常用下午三点就没电了。

综上，买了iPhone之后，感觉生活质量提高了。你感受不到有个手机的存在，能在无聊的时候看看新闻，玩玩游戏，它掉链子的时候很少，所以不会花你很多精力。

听说Google要出Pixel Phone了，但是在国内不能用还是一大硬伤啊。苹果的在国内限制也比国外多，很多应用国内的商店下载不到，唉。

维护了一下博客

Posted on 2016年10月14日 by laixintao Leave a comment

最近收到提示，博客的服务器马上就要到期了。

算起来，写博客也三年多了。最初用新浪的博客，后来用了一年godaddy，然后换了台湾的服务器（备案系统太坑了），用了两年。域名换了一次，最开始买的laixintao.com,，觉得名字的域名所有的字母都是占中上格(指的是英文三线)，挺好的。一年到期了之后，还没续费，域名被抢注了两年，只要换了一个。不过感觉还是使用kawabangga.com的时候流量多，就用这个吧，还好记一点。

之前，总觉得一下子买几年的是不划算的，因为说不定明年就有个什么云出来，空间一下子就很便宜了。三年过去了，现在续费还是一个价，我已经没有这个想法了。这次就一下子买了三年的，还送了两年。让博客稳定一点，好好写吧。

打开这个博客，发现又变慢了。国内的墙真是反人类啊！Google字体不能用，换上了useso的，今天发现有人说他们服务停掉了，好坑。现在用的是“WP Acceleration for China”插件，换上了新浪的库。

图片虽然加载挺快的，但是我看了看地址，发现不是从七牛那边拉过来的。原来是之前的域名没有配置好，要是今天不发现，说不定还一直耗本站流量呢。

这两个都改了之后，速度果然提升了好多，现在加载最耗时的是disqus评论系统，唉，不得不再吐槽一下墙，真是坑。翻墙没问题，但是不翻墙就可能无法评论。这个没什么办法，我还是喜欢这个评论系统，就这样吧。说不定也可以过滤到一些我不想看到的评论呢，嘿嘿。

博客写到现在，我觉得好处还是挺多的。可以记录下来自己的生活，可以让别人认识自己，可以整理自己的想法，可以学习地更加系统。最近找工作，已经有好几次面试官告诉我说“我看了你的博客，我觉得……”

认真地继续写下去吧。

Java优先队列(PriorityQueue)介绍

Posted on 2016年10月8日 by laixintao Leave a comment

队列(Queue)这种数据结构，是”先来先服务”(FIFO)的。但是有的时候，我们需要对“优先级”高的对象先处理。或者说，我们想在队列中按照我们喜欢的样子排序。

Java 1.5，开始引入了优先队列（PriorityQueue）。

继承自 AbstractQueue
泛型要实现Java Comparable或使用Comparator比较
大小不固定
非线程安全的(线程安全的是PriorityBlockingQueue)

简单来说，要使用这个队列，那么放入队列的对象要实现Comparable接口。之后，队列在添加元素的时候，就会根据这个方法，放入合适的位置。取出的时候，会弹出排在最前面的元素。

下面，我们通过一个例子体会一下优先队列的作用和用法。

这个练习题来自HackkerRank：Java Priority Queue

题目要求

学生有token，成绩，名字。每次输入一个命令，如果是“ENTER”，就添加新的学生进来，按照成绩排序放入。如果成绩相同，按照名字字母序放入。如果名字也相同，就按照token放。如果命令是“SERVED”，就弹出最前面的同学。最后，打印剩下的队列，如果为空，打印“EMPTY”。

输入示例

12
ENTER John 3.75 50
ENTER Mark 3.8 24
ENTER Shafaet 3.7 35
SERVED
SERVED
ENTER Samiha 3.85 36
SERVED
ENTER Ashley 3.9 42
ENTER Maria 3.6 46
ENTER Anik 3.95 49
ENTER Dan 3.95 50
SERVED

1

2

3

4

5

6

7

8

9

10

11

12

13

12

ENTER John 3.75 50

ENTER Mark 3.8 24

ENTER Shafaet 3.7 35

SERVED

ENTER Samiha 3.85 36

SERVED

ENTER Ashley 3.9 42

ENTER Maria 3.6 46

ENTER Anik 3.95 49

ENTER Dan 3.95 50

SERVED

输出示例

Dan
Ashley
Shafaet
Maria

1

2

3

4

Dan

Ashley

Shafaet

Maria

我的代码：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

class Student implements Comparable<Student>{
    private int token;
    private String fname;
    private double cgpa;
    public Student(int id, String fname, double cgpa) {
        super();
        this.token = id;
        this.fname = fname;
        this.cgpa = cgpa;
    }
    public int getToken() {
        return token;
    }
    public String getFname() {
        return fname;
    }
    public double getCgpa() {
        return cgpa;
    }

    @Override
    public String toString() {
        return this.fname;
    }

    @Override
    public int compareTo(Student student) {
        int result;
        if(this.cgpa!=student.getCgpa()){
            result = this.cgpa < student.getCgpa() ? 1:-1;
        }else if(!this.fname.equals(student.getFname())){
            result = this.fname.compareTo(student.getFname());
        }else{
            result = -(this.token - student.getToken());
        }
        return result;
    }
}

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int totalEvents = Integer.parseInt(in.nextLine());
        Queue<Student> queue = new PriorityQueue<Student>();

        while(totalEvents>0){
            String cmd = in.next();
            if(cmd.equals("ENTER")){
                String name = in.next();
                double cgpa = in.nextDouble();
                int id = in.nextInt();
                queue.add(new Student(id,name,cgpa));
            }else if(cmd.equals("SERVED")){
                queue.poll();
            }
            totalEvents--;
        }
        if(queue.isEmpty()){
            System.out.println("EMPTY");
        }else{
            while (!queue.isEmpty()){
                System.out.println(queue.poll());
            }
        }
    }
}

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

62

63

64

65

66

67

68

69

70

71

72

73

import java.io.*;

import java.util.*;

import java.text.*;

import java.math.*;

import java.util.regex.*;

class Student implements Comparable<Student>{

private int token;

private String fname;

private double cgpa;

public Student(int id, String fname, double cgpa) {

super();

this.token = id;

this.fname = fname;

this.cgpa = cgpa;

}

public int getToken() {

return token;

}

public String getFname() {

return fname;

}

public double getCgpa() {

return cgpa;

}

@Override

public String toString() {

return this.fname;

}

@Override

public int compareTo(Student student) {

int result;

if(this.cgpa!=student.getCgpa()){

result = this.cgpa < student.getCgpa() ? 1:-1;

}else if(!this.fname.equals(student.getFname())){

result = this.fname.compareTo(student.getFname());

}else{

result = -(this.token - student.getToken());

}

return result;

}

public class Solution {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int totalEvents = Integer.parseInt(in.nextLine());

Queue<Student> queue = new PriorityQueue<Student>();

while(totalEvents>0){

String cmd = in.next();

if(cmd.equals("ENTER")){

String name = in.next();

double cgpa = in.nextDouble();

int id = in.nextInt();

queue.add(new Student(id,name,cgpa));

}else if(cmd.equals("SERVED")){

queue.poll();

}

totalEvents--;

}

if(queue.isEmpty()){

System.out.println("EMPTY");

}else{

while (!queue.isEmpty()){

System.out.println(queue.poll());

}

通过这个例子，可以很好地理解优先队列了。

参考资料

Java优先队列（PriorityQueue）示例

详解 Python 的 “==” 和 “is”

Posted on 2016年10月6日 by laixintao Leave a comment

Python中比较两个对象是否相等，一共有两种方法，简单来说，它们的区别如下：

is是比较两个引用是否指向了同一个对象（引用比较）。
==是比较两个对象是否相等。

>>> a = [1, 2, 3]
>>> b = a
>>> b is a # a的引用复制给b，他们在内存中其实是指向了用一个对象
True 
>>> b == a # 当然，他们的值也是相等的
True
>>> b = a[:] # b通过a切片获得a的部分，这里的切片操作重新分配了对象，
>>> b is a # 所以指向的不是同一个对象了
False
>>> b == a # 但他们的值还是相等的
True

1

2

3

4

5

6

7

8

9

10

11

>>> a = [1, 2, 3]

>>> b = a

>>> b is a # a的引用复制给b，他们在内存中其实是指向了用一个对象

True

>>> b == a # 当然，他们的值也是相等的

True

>>> b = a[:] # b通过a切片获得a的部分，这里的切片操作重新分配了对象，

>>> b is a # 所以指向的不是同一个对象了

False

>>> b == a # 但他们的值还是相等的

True

实现原理

is比较的是两者是否是同一个对象，所以比较的是内存地址（id是否相同）。

Python文档3.1 对象、值和类型中是这样说的：

每个变量都有标识、类型和值。对象一旦创建，它的标识绝不会变；你可以把标识理解为对象在内存中的地址。is运算符比较两个对象的标识；id()返回对象标识的证书标识。

对象ID真正的意义在不同的实现中也不同，在CPython中，id()返回的对象的内存地址，在其他解释器中可能是别的意义。但重要的是，它一定能表示唯一的对象并且在对象的生命周期内不变，不同对象的标识一定是不一样的。

==是值比较。不可变对象，例如int，str，它会直接进行值比较。对于Python已知的对象，会调用他们的__eq__函数来比较。（其实已知的对象应该也是通过内置的__eq__函数来比较的）。对于自定义的对象，如果实现了__eq__函数，就会使用它比较，如果没有实现，效果和==是一样的。

对象缓存机制

Python会对比较小的对象缓存，下次用到比较小的对象时，会去缓存区查找，如果找到，不会再开辟新的内存，而是继续把小对象的地址赋给新的值。例子：

>>> c = 1
>>> d = 1
>>> print(c is d) 
True

>>> 1000 is 10**3
False
>>> 1000 == 10**3
True

1

2

3

4

5

6

7

8

9

>>> c = 1

>>> d = 1

>>> print(c is d)

True

>>> 1000 is 10**3

False

>>> 1000 == 10**3

True

通过计算得到的赋值，不会使用缓存区。从第一个代码示例中可以看出。

对于字符串，你可以通过使用intern函数强制使用缓存区。

总结

这一段总结引用自《Fluent Python》，我觉得写的非常好：

is运算符比==快，因为它不能被重载，所以Python不必寻找并调用特殊方法，而是直接比较两个证书id。而a == b 则是一个语法糖，等同于a.__eq__(b)。继承自object的__eq__方法比较两个对象的id，结果与is一样。但是多数内置类型使用更有意义的方法覆盖了__eq__方法，会考虑对象属性的值。相等性测试可能涉及大量处理工作，例如，比较大型集合或嵌套层级深的结构时。

参考

Is there a difference between `==` and `is` in Python?
python源码学习（八）——string对象的intern机制
比较python类的两个instance(对象) 是否相等
《Fluent Python》8.2 标志、相等性和别名

2026 年 11 月
一	二	三	四	五	六	日
						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