2020年六月第一周

阅读数:0次

天气

今天（2020-06-07）特别特别热，身上总是有点潮湿，早上跑步也是，出汗特别多

学习

没什么好学的，自闭

生活

现在的心态很成问题，每天似乎没了一股冲劲儿，不知道怎么回事。

还是要多做plan，一定要有plan。

时事

美国乱起来了，骑马践踏，推搡，川普连任似乎希望又不那么大了。

展开全文 >>

2020年5月最后一周

阅读数:0次

天气

五月的尾巴，已经很热了，总是会下一些阵雨，会搞的鞋子很脏

学习

这周学习个啥，啥也没学。

小程序功能差不多做完了

UML大概摸清结构了

目前的进度

课程

  • 软件工程（小程序结课，问题不大）
  • 分布式（开学前考试，现在不急）
  • 云应用开发（每次做实验就行）
  • 机器学习（开学前考试，现在不急）
  • 面向对象（大作业结课，有些紧张）

项目

  • DeepDDI，6月底完成，有些急
  • 推荐信，一周内
  • 报名
  • PPT制作，一周内

生活

减肥到72kg出现了困难，现在再向下减有点困难，但是跑步和keep还是接着练下去吧

展开全文 >>

2020年五月倒数第二周

阅读数:0次

天气

周四下了一场非常非常怪异的雨，从早晨开始阴天，晚上闪电交加，一直不停。

其他时间的天气已经完全接近夏天了。

学习

这一周除了上课基本上都在准备Grab Cut，18.06也落下了一集，下一周补上吧。

生活

F & S开始差不多有一个半月了，当时插下的flag现在完成的也还算可以

体重从当时的

tScpfP.jpg

减到了现在的

tScCSf.jpg

跑步计划也在进行当中

tSwLUf.png

三个月来已经跑了181公里，平均下来每天有两公里的跑量

另外书法也在一直坚持着，玄秘塔碑现在甚至写起来有一点点顺手

tS0VGF.jpg
tS0EPU.jpg

其实跳出圈来想一想的话，每天可以跑跑步，写写字，闲暇时候斗斗地主，看看小说，生活还是蛮有趣味的

时事

最近没有关注时事方面的动态，只知道一个玩翼装飞行的女孩子不幸去世了。

其实这个话题可以聊的地方很多，比如什么叫“有意义的事情”，谁有资格定义“意义”，乃至更深层次的，“我是谁”，“我从哪里来”，“我要到哪去”，哲学三问，但是这次只想说一说翼装飞行。

小时候读过一篇作文，说是一个小姑娘想要飞，没错，很简单的“飞”，家长不理解，让她好好学习，废话是个脑子正常的家长就不会理解啊，然后这个小女孩就跳楼了、跳楼了……

当然，这只是一篇作文。

我记得很清楚是因为当时给我的印象太深刻了，以至于我又在班里上课时候跟大家分享了这篇作文。

人类的欲望是个很奇怪的东西，叔本华的观点不一定对，但是够犀利，人从出生到死亡，一直就在和“意欲”（will）作伴，所谓“要么痛苦，要么无聊”，而经济实力到了一定程度之后，肯定会想出越来越多的办法来对抗“无聊”。

于是这些看起来毫无意义的活动，被赋予了新的使命。

所以现在想一想，时间管理大师的私生活问题，不一定是他道德水准不够，我们普通人所谓的兢兢业业、恪守底线，也许只是没有经历过同等级别的诱惑。

阅读

这里礼拜没有进行阅读活动，检讨，下礼拜一定再和阿辽沙见面。

展开全文 >>

2020年5月第三周

阅读数:0次

天气

天气很棒，没有非常晒，气温很合适，清晨起来去跑几公里，感觉非常棒

学习

梳理一下现在要做的事情

  • 软件工程大作业——小程序（6月15日）
  • DDI论文（5月29）
  • 阅读视觉相关论文（5月23日）

生活

周六和“笑傲江湖”聚了聚，有这样一帮人，可以毫无拘束的嘴炮是真的太棒了，好久没有那么多次嗨了。

周日早晨的晨跑失败了。

李紫萱好像真的找不到了，有一点恐怖，所有认识她的人，似乎都找不到了。

因为便宜，买了一个4.9的三插头（typec usbc lighting），然后好评返现三元，等于只花2元，然后惊讶的发现，用这个充电线，我的小米6的续航有回来了，发热现象好了很多很多。

unexpected bonus

反思，这一周的生活，不是很规律，在上半周，还可以保持至少半天的高效率学习，但是下半周已经不行了，原因我觉得可能是因为聚会吸引了很大部分精力，另一个是最近事情实在是太多。

下一周还是要今早把每一天计划清楚，娱乐点控制在微信阅读和人人视频，不要拓展新的。

anki放在早上是可以的。

体重减到73.90kg了，距离第一周79.9已经减了12斤了，good for me

时事

华为又遭到了新的一轮制裁，但是该问题只获得了不到12小时的热度，到今天上午（5.17）已经消失无影无踪了，取而代之的是“光刻机”相关问题登顶热榜。

阅读

卡拉马佐夫兄弟

这本书的（上）读完了，印象最深刻的就是二哥讲的大法官与耶稣的诗，和最后阿辽沙亲吻大地的场景，这本书要阐述的主题，远比我想象的要深奥，以后还要再细匝么。

展开全文 >>

2020五月第二周

阅读数:0次

天气

经过上一周的爆热，这周天气似乎又冷了回去。

说起来，从小学开始，这好像是第一次在家里从3月分一致待到五月份。

学习

学习上，anki搭配公众号编辑器还是很好用的，要坚持下去。

专业知识，该复习复习了，不能到时候写的时候啥也不会。

生活

家里大多时间是一个人了，越发体会到之前读的观点“人是社会的动物”，孤独是一种比较奇妙的感觉，可能大多是天才或者智者会比较享受，我还是不很喜欢。

人多一点，有趣一点，才更好嘛。

李紫萱联系不到了，which is odd，very odd。

年前还可以微信联系得到，那时还一起计划着考完试出去玩，各种原因没有去成，现在是真的联系不到了，微信电话也打不通，好奇怪。

vlog素材其实已经都拍的差不多了，就是还没有时间剪出来。

阅读

诡秘之主

这本书终于完结了，但是听说还有2，所以还是慢慢重刷，不可多得的好书

卡拉马佐夫兄弟

二哥开始讨厌那个仆人，并且开始说老头子给他说了暗号，防止大儿子突然进来图谋不轨。

世纪三部曲

就是一个矿工下井的故事，太平淡了，现在只是能看到英国阶级的分层严重，底层人民比较惨烈，没有其他吸引人的地方。

亲密关系

第一章读完了，感觉还好，没有看论文那么痛苦，里面一些观点非常有趣。

娱乐

终于又重新看完了一遍《绝命毒师》，感慨颇深。

不说故事的社会价值，角色的塑造，更不提一些专业的手法，只说一点。

teaser

AMC的电视剧至少有“集”的概念，会直到自己有多少集，每一集有它自己的开头结尾呼应等等，会有一个完整的结构，他妈中国电视剧，开头就要重复上一集结尾至少三分钟，甚至还会区分TV版和DVD版本，甚至两个版本的集数都不一样，太可笑了。

但是没办法，看似创作自由越来越大，其实，呵呵，又出了阅文这档子事儿。

“百家争鸣”在高中其实是我不喜欢的一个部分，因为马上跟着文化大革命，惨痛的教训，但是现在，似乎“百家争鸣”的口号都不敢喊出来，这是我不能想到的。

whatever，还好可以翻墙。

展开全文 >>

数据结构: 数组

阅读数:0次

26. 删除排序数组中的重复项

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

It doesn't matter what values are set beyond the returned length.

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty())return 0;
        int index = 0;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[index] != nums[i]) {
                index++;
                nums[index] = nums[i];
            } 
        }
        return index + 1;
    }
};

66. 加一

大数加一

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
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        if (digits[digits.size() - 1] != 9) {
            digits[digits.size() - 1] = digits[digits.size() - 1] + 1;
            return digits;
        }
        int carry = 1;
        for (int i = digits.size() - 1; i >= 0; i--) {
            int current = carry + digits[i];
            if (current < 10) {
                digits[i] = current;
                carry = 0;
                break;
            }
            else {
                digits[i] = current % 10;
                carry = 1;
            }
        }
        if (carry == 1) {
            digits.insert(digits.begin(), 1);
        }
        return digits;
    }
};

969. 数组形式的整数加法

都变成数组：

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
class Solution {
public:
    vector<int> addToArrayForm(vector<int>& A, int K) {
        vector<int>k = change(K);
        int index;
        if(k.size() > A.size())
            index = k.size() - A.size();
        else {
            index = A.size() - k.size();
        }
        int flag = k.size() > A.size() ? 1:0;
        while(index--) {
            if (flag) {
                A.insert(A.begin(), 0);
            }
            else {
                k.insert(k.begin(), 0);
            }
        }
        int carry = 0;
        vector<int>ans(A.size(), 0);
        for(int i = A.size() - 1;i >= 0; i-- ){
            int current = A[i] + k[i] + carry;
            ans[i]  = current % 10;
            carry = current / 10;
        }
        if (carry) {
            ans.insert(ans.begin(), 1);
        }
        return ans;
    }
    vector<int> change(int k) {
        vector<int>ans;
        while(k) {
            ans.push_back(k%10);
            k = k / 10;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

118. 杨辉三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> res(numRows);
        for (int i = 0; i < numRows; i++) {
            res[i].resize(i + 1, 1);
            for (int j = 1; j < i; j++) {
                res[i][j] = res[i - 1][j - 1] + res[i - 1][j];
            }
        }
        return res;
    }
};

169. 多数元素

找一个数组中出现最多的元素，（出现次数>n/2）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int candidate = -1;
        int count = 0;
        for (int num : nums) {
            if (num == candidate) {
                count++;
            } else if (--count < 0) {
                candidate = num;
                count = 1;
            }
        }
        return candidate;
    }
};

219. 存在重复元素Ⅱ

这其实是一个hash问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        if (nums.empty()) {
            return false;
        }
        unordered_map<int, int>M;
        for (int i = 0; i < nums.size(); i++) {
            unordered_map<int, int>::iterator iter = M.find(nums[i]);
            if (iter == M.end()) {
                M[nums[i]] = i;
            }
            else{
                if (i - iter->second <= k) {
                    return true;
                }
                M[nums[i]] = i;
            }
        }
        return false;
    }
};

283. 移动零

其他元素不变，把零放到最后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int count = 0;
        for (int i = 0 ; i < nums.size(); i++) {
            if (nums[i] == 0) {
                nums.erase(nums.begin()+i);
                i--;
                count++;
            }
        }
        while(count--) {
            nums.push_back(0);
        }
    }
};

54. 螺旋矩阵

把矩阵顺时针输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty() || matrix[0].empty())return {};
        vector<int>ans;
        
        int m = matrix.size(), n = matrix[0].size();
        int up = 0, down = m - 1, left = 0, right = n - 1;
        while(true) {
            for (int i = left; i <= right; i++) ans.push_back(matrix[up][i]);
            if (++up > down)break;
            for (int i = up; i <= down; i++) ans.push_back(matrix[i][right]);
            if (--right < left)break;
            for (int i = right; i >= left; i--) ans.push_back(matrix[down][i]);
            if (--down < up)break;
            for (int i = down; i >= up; i--) ans.push_back(matrix[i][left]);
            if (++left > right)break;
        }
        return ans;
    }
};

215 第K大的元素

完全二叉树

若设二叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最大个数，第k 层所有的结点都连续集中在最左边，这就是完全二叉树。

image-20200508193706731

自己实现小顶堆：

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
#define ElemType pair<int,int>
class CMaxHeap {  //小顶堆
private:
	ElemType *heap;
	int heapSize, MaxHeapSize;
public:
    CMaxHeap(int size) {
        heapSize = 0;
        MaxHeapSize = size;
        heap = new ElemType[size + 1];
    }
    ~CMaxHeap() { delete[] heap; }
    void ClearHeap() { heapSize = 0; }
    bool IsEmpty() { return heapSize == 0; }
    bool IsFull() { return heapSize == MaxHeapSize; }
    int getLength() { return heapSize; }
    ElemType top() { return heap[0]; }
    void push(ElemType e);
	ElemType pop();	//去堆顶元素
	void FixUp(int k);
	void FixDown(int k);
};

void CMaxHeap::FixDown(int k) {
	int i;
	i = 2 * k + 1;
	while (i < heapSize) {
		if (i < heapSize - 1 && heap[i] > heap[i + 1])
			i++;			//取孩子结点中较小者
		if (heap[k] < heap[i])
			break;
		swap(heap[k], heap[i]);
		k = i;
		i = 2 * k + 1;
	}
}
void CMaxHeap::FixUp(int k) {
	int i;
	i = (k - 1) / 2;
	while (k > 0 && heap[i] > heap[k]) {
		swap(heap[k], heap[i]);
		k = i;
		i = (k - 1) / 2;
	}
}
void CMaxHeap::push(ElemType e) {
	heap[heapSize] = e;
	heapSize++;
	FixUp(heapSize - 1);
}
ElemType CMaxHeap::pop() { //去掉堆顶
	swap(heap[0], heap[heapSize - 1]);
	heapSize--;
	FixDown(0);
	return heap[heapSize];
}

展开全文 >>

贪心算法

阅读数:0次

综述

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

题库

984. String Without AAA or BBB

生成字符串没有‘aaa’和’bbb’。

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
Input: A = 1, B = 2
Output: "abb"
Explanation: "abb", "bab" and "bba" are all correct answers.


class Solution {
public:
    string strWithout3a3b(int A, int B) {
       char a = 'a';
       char b = 'b';
       if (A < B) { // 保证A >= B，同时默认a是大的
           swap(A, B);
           swap(a, b);
       }
       string ans = "";
       while(A > 0 || B > 0) {
           if (A > 0) {
               ans += a;
               A--;
           }
           if (A > B) { //如果我比你还多，那我就多放一个
               ans += a;
               A--;
           }
           if (B > 0) {
               ans += b;
               B--;
           }
       }
       return ans;
    }
};

860. Lemonade Change

柠檬找零，每人买一个柠檬，（价值5）可能付5, 10, 20面值的钞票，问零钱是否能找开。

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
class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int fives = 0; //考虑所有情况，简单模拟
        int tens = 0;
        for (int i = 0; i < bills.size(); i++) {
            if (bills[i] == 5)
                fives++;
            else if (bills[i] == 10) {
                if (fives >= 1) {
                    fives--;
                    tens++;
                }
                else
                    return false;
            }
            else {
                if (fives >= 1 && tens >= 1) {
                    fives--;
                    tens--;
                }
                else if (fives >= 3) {
                    fives -= 3;
                }
                else {
                    return false;
                }
            }
        }
        return true;
    }
};

55. Jump Game

跳跃游戏，数组中每个元素表示下一步的距离，问是否能跳到最后索引位置。

思路一

从倒数第一个开始，如果可以到最后一个，那么从这里截断，如果最后所剩只有一个元素，那么成功，反之失败

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Input: [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = 1;
        for (int i = nums.size() - 2; i >= 0; i--) {
            if (nums[i] >= n) {
                n = 1;
            }
            else {
                n++;
            }
            if (i == 0 && n > 1) {
                return false;
            }
        }
        return true;
    }
};

思路二：

考虑每次更新可否到达当前位置

1
2
3
4
5
6
7
8
9
10
11
class Solution {
public:
    bool canJump(vector<int>& nums) {
        int k = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (k < i) return false;
            k = max(k, nums[i] + i);
        }
        return true;
    }
};

1029. Two City Scheduling

2N个人，分别去A，B两地，花费不同价格，要求A总共去N人，B也要去N人，总价最低：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Input: [[10,20],[30,200],[400,50],[30,20]]
Output: 110
Explanation: 
The first person goes to city A for a cost of 10.
The second person goes to city A for a cost of 30.
The third person goes to city B for a cost of 50.
The fourth person goes to city B for a cost of 20.

The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.

class Solution {
public:
    int twoCitySchedCost(vector<vector<int>>& costs) {
        if (costs.empty())return 0;
        sort(costs.begin(), costs.end(), [](vector<int>a, vector<int>b){return a[1] - a[0] > b[1] - b[0];}); //每人只和自己比，去A比去B便宜更多的时候，肯定去A。
        int n = costs.size() / 2;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += costs[i][0] + costs[i+n][1];
        }
        return ans;
    }
};

1042. Flower Planting With No Adjacent

联通图染色问题，paths表示相邻的花园，相邻的花园中不能种同一种花，一种有四种花。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
        vector<int>G[N];
        for (int i = 0; i < paths.size(); i++) { //建立邻接表
            G[paths[i][0] - 1].push_back(paths[i][1] - 1);
            G[paths[i][1] - 1].push_back(paths[i][0] - 1); 
        }
        vector<int>answer(N, 0); //初始化全部未染色
        for (int i = 0; i < N; i++) {
            set<int>color{1, 2, 3, 4};
            for (int j=0; j < G[i].size(); j++) {
                color.erase(answer[G[i][j]]);
            }
            answer[i] = *(color.begin());
        }
        return answer;
    }
};

1090. Largest Values From Labels

给一个集合，每个元素有一个值values[i]与标签labels[i]。这里要选择一个子集，使得子集的元素个数不超过num_wanted，而且相同标签的元素个数不超过use_limit。求子集的最大和。

1
2
3
Input: values = [5,4,3,2,1], labels = [1,1,2,2,3], num_wanted = 3, use_limit = 1
Output: 9
Explanation: The subset chosen is the first, third, and fifth item.
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
class Solution {
public:
    struct term {
        int value, label;
    };
    static bool cmp(term a, term b) {
        return a.value > b.value;
    }
    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int num_wanted, int use_limit) {
        vector<term> data;
        data.resize(values.size());
        int ml = 0;
        for (int i = 0; i < values.size(); i++) {
            data[i].value = values[i];
            data[i].label = labels[i];
            ml = max(ml, labels[i]);
        }
        sort(data.begin(), data.end(), cmp);

        vector<int> bucket;
        bucket.resize(ml+1);
        int num = 0;
        int sum = 0;
        for (int i = 0; i < data.size(); i++) {
            int lab = data[i].label;
            if (bucket[lab] < use_limit) {
                num++;
                bucket[lab]++;
                sum += data[i].value;
                if (num >= num_wanted) return sum;
            }
        }
        return sum;
    }
};

1094. Car Pooling

一辆车接旅客，根据旅客的人数，上下车位置，判断是否可以载完所有的旅客。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Input: trips = [[2,1,5],[3,3,7]], capacity = 4
Output: false
    
class Solution {
public:
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        map<int, int> m;
        for(auto & t: trips){
            m[t[1]] += t[0];  // pick up
            m[t[2]] -= t[0];  // drop off
        }
        int passengers = 0;
        for(auto it: m){
            passengers += it.second;
            if(passengers > capacity) return false;
        }
        return true;
    }
};

1282. Group the People Given the Group Size They Belong To

用户分组归属问题。

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
Input: groupSizes = [3,3,3,3,3,1,3]
Output: [[5],[0,1,2],[3,4,6]]
Explanation: 
Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].

class Solution {//显示粗粒度分开，然后再按大小切分
public:
    vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
        unordered_map<int, vector<int>> groups;
        for (int i = 0; i < groupSizes.size(); ++i) {
            groups[groupSizes[i]].push_back(i);
        }

        vector<vector<int>> ans;
        for (auto group = groups.begin(); group != groups.end(); ++group) {
            const int& gsize = group->first;
            vector<int>& users = group->second;
            for (auto iter = users.begin(); iter != users.end(); iter = next(iter, gsize)) {
                cout << *iter << endl;
                
                vector<int> dummy(iter, next(iter, gsize));
                ans.push_back(dummy);
            }
        }
        return ans;
    }
};

展开全文 >>

2020年5月第一周

阅读数:0次

天气

天气突然变得特别特别热

学习

乏善可陈

生活

开始减肥，早上只吃两个鸡蛋，中午吃好，晚上少吃主食，一周下来减了3Kg，效果还可以

时事

阅文的换水和新合同算是一个新闻，不过这个事情写开要太久，不展开了

阅读

这周开始《亲密关系》的阅读

还是非常精彩的

展开全文 >>

python 数据处理速查

阅读数:0次

读取csv

方法一

1
reader_cross_table = csv.reader(open(data_idx_two_sides, 'r'))

这样后面可以直接用中括号引用

1
2
3
rows = [item for item in reader_cross_table]
rows = rows[1:len(rows)]
name2bank = {item[1].lower(): item[0] for item in rows}

方法二

用pandas，也很简单：

1
stich_names = pd.read_csv(stich_id2name_path, sep='\t', header=-1)

引用的话，要使用loc：

1
2
3
4
stich2drugbank = {}
for i in range(stich_names.shape[0]):
    if stich_names.loc[i, 1].strip('\'') in name2bank:
        stich2drugbank[stich_names.loc[i, 0].strip('\'')] = name2bank[stich_names.loc[i, 1].strip('\'')]

写入csv

这个更简单：

1
2
3
4
5
f_decagon = open('decagon_relations.csv', 'w')
decagon_writer = csv.writer(f_decagon)

...
decagon_writer.writerows([item for item in decagon_relations])

判断字典是否包含某个key：

1
if reader_decagon.loc[i][0] in stich2drugbank

展开全文 >>

#上面是 yilia 主题配置自带 下面是我自己添加的js代码 //这是自定一个js文件,放在 layout\_parial\post 目录 leancloud.ejs中

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

试问岭南应不好，<br><br>却道：此心安处是吾乡。<br><br>