LuSuZi

从人口结构看房价

2024-04-03T03:40:26+00:00

中国的房价和人口结构有关系吗？ - 知乎 (zhihu.com)

1979年新生人口触底，1715万人，1997年时他们18岁，开始提供劳动力，那时成年人口结构大概是这样的：

从1998年开始，每年年轻劳动力开始提升

同时30多岁这个平均买房年龄人口居高不下。

而且老年人少，建国第一代才48岁。

房地产黄金10年开启。

也就是直到1987-1989年生年满18岁的2005-2007年。

转眼到了2022年，人口结构如下：

有一大批老年人，抚养比已经很离谱了。

而且这个年份很奇特，最多的有资金买房的30多岁人口见顶，之后将越来越少，而且正好人口增长率首次为负。而且，正好是房地产的顶峰。

劳动力无法保存，只能借助资产，当然他们也自然而然会去买资产，或者更确切地说他们持续买什么，什么就有了市场共识就成了“资产”。当然他们不约而同地选择了房子。

劳动力越多，越不值钱，而对应的资产价格越高；

劳动力越少，就越值钱，而对应的资产价格越低。

果然婴儿潮的人最惨，年轻时同龄人多，资产价格高，要用更多劳动力换资产，等其老了，集体需要用资产换劳动力时，资产相对劳动力非常低贱。

87-89年生的最惨（除了20多岁就早赚到钱或早上杠杆的少部分），其集体买房之年就是房价顶峰，其用金融工具跨期梭哈30年劳动力买的房，等其退休时即便不考虑折旧，在新的供求市场下只能换到大概10年的劳动力了，被自然而然早买房的前辈们、早赚到钱的同龄人、炒房客以及整个产业链收割了20年的劳动力。

社保基金一直处于收不抵支的亏空状态

2024-04-03T03:40:26+00:00

社保基金一直以来都处于收不抵支的状态，保费收入远远不足以支撑保费支出。

根据财政部发布的2022年社保基金的收入决算表：

可以看到2022年全国社保基金总收入10.24万亿，其中中央的为四项相加，但是其中由老百姓真正缴纳的保费收入是7.5万亿，而由财政补贴的收入是2.3万亿，占社保基金总收入的比值为22.4%。至于利息和投资收益数据，都不算高，合起来2149亿，如果扣除财政补贴收入的话，2022年社保基金的真实收入其实就是74982亿+2149亿=77131亿。

而根据其支出表：

2022年社保基金社保待遇支出为为87655亿，于是，我们就知道了，2022年，中国社保基金77131亿的包含保费极其利息投资收入的真实收入减去87655亿的社保待遇支出，由保费收支导致的亏空规模达到了惊人的10524亿（半个恒大了都）。而整体的真实亏空规模我们也可以用总收支差额减去财政补贴算出来是亏空11099亿。

依据刚才这个思路，在财政部公开数据的加成下，我们可以得出近年来每一年的亏空和存量规模数据：

在扣除政府补贴之后，所有年份的社保基金真实收入都大幅低于支出，每一年都是收不抵支的亏空状态，近年来的亏空规模已经达到了1万多亿。但其存续规模一直在上升，只是因为财政部需要每年往里面填钱，多出来的部分，就形成了滚存结余。2020年这个特殊年份，新冠封控的第一年，因为实施了企业部分的社保费用缓缴政策，负得最为厉害。

注意，公开数据显示的是，社保基金的真实收支水平是收不抵支的亏空状态，社保基金的余额可以增长的唯一原因就是财政的大规模补贴，年补贴规模已经超过了2万亿，一旦财政停止这种大规模补贴，那么以社保基金每年亏空一万多亿的速度来说，只需要11年时间，就可以把之前累积的保费和补贴全部清零了。

如何看待2024年的房地产市场，房价走势?

2024-04-03T03:40:26+00:00

如何看待2024年的房地产市场，房价走势? - 知乎 (zhihu.com)

走势分析

阁下的问题落在「房价」也就是房子的「价格」上。首先，我要说明一点——价格是二维的，不是一维的。

换个角度说，加上时间维度，**真正的价格走势不是二维的「价格-时间图」，即类似K线图的东西。而是三维的「价格-成交量-时间图」，类似一座山一样。**字面价格一样，成交量不一样，价格深度不一样，真正的价格也不一样。

也就是说，带成交量的价格才是真正的反映其全貌的价格。

另外，由于正负反馈，价格走势一般具有延续性，价格上升的，一般会继续上升，价格下降的，一般会继续下降。也就是索罗斯的反身性理论。

我们可以先不用去研究宏观形势与数据，单从感觉上的盘面上的三维价格走势以及反身性理论，就已经可以给出一个很靠谱的推测了——大概率继续下降。

接下来我将进行更为细致的宏观分析。

宏观分析

先根据国家统计局的数据看下整体情况：

从价格上看，似乎房价好像稳中向好：

但是综合成交量看，却已经崩了两年了，价格不过是高位盘整罢了：

二者相乘的结果如下：

这个情况拿给任何一个懂价量关系的人看都是妥妥的泡沫破灭，叠加地产商爆雷的事实能看得更清楚。

你说一餐馆菜品售价不变，但越来越少的人来吃了，总收入是下降的，能自欺欺人地说我的菜品价格还维持稳定所以「稳中向好」吗？

好了，不容争辩的量价事实摆在这了，但还没完，借用那句「如履薄冰」的梗的口吻问就是：「房价飞了二十多年了，你说它能平稳着陆吗？」

我们越是长期依赖一个东西，那个东西一旦出问题，破坏越大。

该泡沫的破灭在居民端留下的是庞大的居民负债，在企业端留下的是庞大的企业负债，这些债务背后的银行们随时都有可能因为大规模坏账而陷入债务危机。

根据央行的数据，截止2023年末，居民贷款余额为80.1万亿元，这些债务的借款主体基本上都是城镇户籍的成年劳动力，农村户籍和退休人士都不太有资格贷款。而2022年城镇户籍成年劳动力是4.05亿，即城镇成年劳动力人均负债大约是19.78万。也就是说，城镇的劳动力人均负债大约是20万，一个家庭一般至少有两个成年人，也就是负债40万，大致相当于买一套房的按揭贷款规模。也就是说购买力在房子方面基本满上了。

再看企业端，这里给出的是2000年至2023年末房地产企业的现金流量表，之所以从2000年开始，是因为我国的商品房就开始于2000年，在此之前都是福利分房。

销售金额的口径是建设部的口径，也就是在房管部门完成预售登记，完成预售登记是银行发放按揭贷款的前提，这个数据是相对准确的。

地产公司的综合税负这里按销售额的15%估算，这是行业规律，不会有太大偏差。

「开发投资实际到位资金」是由每一家地产公司逐月填报并由统计部门汇总的数据，包含卖地、建安和管理等方面的实际现金支出，这个数据也是相对准确的数据。

有了这三个数据，我们就能算出房地产企业的经营净现金流，就会发现一个非常有意思的事实：**我国房地产企业的经营净现金流从来都是负值，从来都没有转正过。**这意味着一件特别搞笑的事情——**中国房地产业从来没有提取过利润，地产商们会把挣来的每一分钱重新投入到买地开发的循环中，并且仅仅是利润再投入还不够，他们还要大规模借债再投入，将企业的经营杠杆拉到极致。**因此每一年的房地产开发实际投资金额都远大于销售额，这中间的差值都得靠借债来填。

2021年实际到位资金达到顶峰后，2022年房地产市场泡沫破灭，但是在庞大的历史负担下，地产商的净现金流想要在短期内转正是不可能的，2022年依旧是-35667亿，2023年在地产商持续压缩经营支出减少买地投入的情况下依旧是-28330亿，才大致回到2010年的水平，但是想要在5年内转正没有任何可能性。

**从2000年至2023年末，地产商持续负债经营的结果，就是整整累计了67.8万亿的债务！**这些债务什么形式都有，银行贷款、债券、商票、经营往来欠款等，而他们所换来的，就是上面表格最后一列——**838364亿平米的在建工程，基本就是地产商的所有家底。**因为近十年来，所有的土地出让合同都有在3个月到半年内开工的条款，所以地产商就算打定了主意要囤地，也会假模假样地完成报建手续，然后弄几台机器来挖挖土试试桩，以达成所谓开工的条件，在统计规则上，这块地就算再闲置下去，也是「在建工程停工」，也要纳入在建工程统计。

现在房价售价约1万每平米，这83.8万亿平米的在建工程，能不能覆盖地产商67.8万亿的债务？想想吧，在建工程不仅要投入资金把它们盖起来，还要向政府纳税，而且还有不少的在建工程已经预售完了，而且1万每平米的价格在大厦将倾下难以维持，想覆盖这么多债务估计是不太可能的。

这些在建工程还需要投入建安成本才能变成房子。我假设这些工程的平均施工进度是50%，这个假设甚至已经极度偏乐观了。单方建安成本就按全国平均4000元算。建安成本投入等于83.8✖️4000✖️50%等于16.76万亿元，这是极度乐观的刚性投入，无论如何都必须投入的资金，不然这些在建工程就要烂尾。

注意，这里的83.8万亿的在建工程事实上还有很大一部分已经完成了预售，不可以再销售，但是在这里我们简单粗暴点，就假设它们全都是地产商的存货依然可以销售好了。

对于这些存货，全部要按目前的均价1万元每平米销售是不可能的，成交量暴跌后成交价是非常虚的，价格深度大大降低，没有足够的潜在订单「托盘」，也就是所谓的流动性降低。全国范围内的房价在这种供需下极大概率会继续坚定下行，拉高出货（即涨价去库存）已经做过一次了，购买力枯竭了，没法再进行一次，即便强力进行成交量也不会太高了。

事实上，近两年北上广深都在下跌，深圳现在的房价跌幅甚至达到了巅峰时腰斩的程度，但我们这里乐观一点，假设地产商可以总体的85折清理「全部」存货，也就是8500元每平米。那么，这些存货销售收入就是83.8万亿乘以8500等于71.23万亿元。那么，预计税负就是71.23✖️15%等于10.68万亿。

71.23万亿的预估销售额-16.76万亿的预估建安成本-10.68万亿的预估税负，等于撑死了的43.79万亿的净收入，如何去填67.8万亿的债务？债务缺口达到了24.01万亿，债务缺口率已经达到了35.4%，整个房地产行业已经处于事实上资不抵债的状态，也就是整体上已经破产。

这个高达35.4%的刚性债务缺口，依靠银行向地产商提供更多借款已经没有任何意义，只不过将银行拖入更深的深渊，酝酿出更大的债务风暴而已。而要覆盖这个刚性债务缺口，唯一的办法就是再来一次涨价去库存，房价再涨个百分之三四十，但上一次的涨价去库存已经让购买力几乎耗尽了，让城镇家庭累计到了户均负债40万，再来一次涨价去库存只能是更可怕的噩梦。

这出戏让绝大多数人根本没有积累出正的财富净值，即反而处于负债总值大于资产总值的状况，长期从事劳动不仅没有劳动剩余，还欠着劳动剩余呢！那正的财富净值哪去了？哈哈哈，就在「那里」，金融玩的就是财富转移的游戏。

聊到这里，不仅2024年的房价走势有了，后面好多年的都有了呢。

参考：某位数据大佬

只要考了注册会计师就下半辈子都不用努力了吗？

2024-04-03T03:40:26+00:00

只要考了注册会计师就下半辈子都不用努力了吗？ - 知乎 (zhihu.com)

阁下幼稚。

先看看存量对比。

根据注快协会的数据，截止2022年12月31日，我国获取注会资格的人达到了约33.5万人，其中执业的才约9.8万人，剩下的约23.7万人（70.7%），由于各种原因「放弃」了执业。而且，这个官方给出的执业人数无法区分真正的执业人数和单纯的挂证（将已拥有资格证书挂靠在其他会计师事务所中，但其持证人实际上没有在该会计师事务所中任职*）*人数，因此实际上真实的执业人数其实小于9.8万人的。

继续，让我们往前看几年，看看增量对比：

这五年在经济下行下，执业人数减少7471位，非执业人数却增加了105166位（从百万报考人中幸苦考过来的），也就是竞争对手增长了接近80%。

其实不光这5年，这十多年的执业人数都是大概10万人上下，新增的净岗位几乎没有，但是报考人数以及通过考试的人数却是每年激增的。这种在本国没落的行业，竟然成了大学生们争相跨入的行业。为什么会这样呢？是各色注会考试培训机构灌输洗脑懵懂大学生的结果吗？这个就不得而知了。

注会们的日常主要工作不是我们以为的记账，而是财务审计，也就是所谓的查账。查账这么费力不讨好的事情什么情况才有人原因花大价钱读呢？只有当金融市场上的公司并购、收购非常活跃的时候，注会的需求才能大增，行业才能获得发展机会。也就是只有我国的金融业发展起来，注会们才能吃香喝辣。这十几年的零星审计需求，10万注会一直是完全够了。

金融？我国几千年来一直是「以末致财，用本守之」，财富会集中在哪里就不用多说了吧？“金融不过是舶来品罢了”。

目前无解。

如果我还没有成功，是不是一定还不够努力？

2024-04-03T03:40:26+00:00

如果我还没有成功，是不是一定还不够努力？ - 知乎 (zhihu.com)

我认为对绝大多数事情的竞争成败问题，本质上，几乎不存在聪明不聪明的问题，努不努力也不太重要，主要存在的是信息差的问题，失败者只是比别人懂得晚而已。他人的成功或失败提供信息，自己的成功或失败也提供信息，绝大多数成功者成功的秘诀是学他人经验，同时积自己经验，并进行快速迭代，比失败者早失败，也早成功。

世界上几乎所有的路都被人走过了，只存在极少数路尚未踏足，因此绝大多数问题都有已有的标准解法，数学上叫通解，信息差就是别人不知道通解，你知道。

进一步讲，信息差导致认知差，认知差就是信息差的吸收结果，但我们的大脑是固执的，不会轻易相信他人的成功经验，不会像打游戏一样得到了秘籍就咻的一下获得对应技能，于是就需要自我洗脑，大脑更更倾向于相信自己的话。

而执行差主要取决于人的欲望格局，欲望才是人持续行动的根源，我们无法与大脑作对，只能循循善诱，让它逐渐喜欢某些东西，以提供前进的动力，这个动力是顺着人性的，例如想象成功后的情景、带大脑提前感受一下成功后可以获得的“装备”等。执行差的头号天敌是“完美主义”，它可以让一切美好毁于一旦。至于「努力」这个词，它比较模糊，我理解的是「逆着人性向前的力量」的意思。例如，我们不会把我们执行的「打游戏」的顺人性的动作叫做「努力打游戏」。所以，有了方向之后，总动力 = 顺人性的正向力量 + 逆人性向前的力量。成功者在这一步一般顺人性的力量更多，失败者一般过多依靠自制力了。

竞争差指「你我都做，我做的比你好」，比的是认真程度，认真来自于习惯、来自于态度。

所以，成功的捷径就是：不要自恃聪明、闭门造车、想法太多，直接从成功者前辈获取秘籍，想办法对自己洗脑，并认真照做。做之前要像得到秘籍一样信念坚定，做的过程不要有任何怀疑，做完了看到结果后才用脑袋去思考。有没有效的结论不是想出来的，而是做出来的。

不去拿秘籍的人就是「做得太多，想得太少」，拿了秘籍的人大多却又陷入「想得太多，做得太少」。

写作平台还得是知乎

2024-04-03T03:40:26+00:00

最近几天开始重新在网上写作，以消化吸收自己学到的一些知识或道理，因为人如果对自己学到的东西不进行复述，大脑就认为那是别人的东西，就难以改变自己的行为。注册了简书、知乎、微博，之前还写过公众号，相比而言，我发现知乎才能让写作输出最大化。

首先，我们写作得有个目的，很多人不是不会写，而是压根不知道要写什么。其他平台都没有这个问题机制，而知乎的内容本身就是用问题组织起来的，在创作中心里有各种推荐的问题，而且消息中不断有人提问，最大化让用户知道要写什么。这种提问加解答的机制，形成了一种探究型内容社区。带着问题读书，带着问题思考，带着问题写作。

其次，知乎还以文章和想法组织内容，长点的发文章，这个与简书、公众号一样；如果是碎片则可以发想法，这就完全替代了微博的用途了。而且问题还可以匿名回答，不浪费那些本可以输出的机会。知乎的这些机制，可以最大化用户的输出。

最后，知乎还可以开live，可以付费咨询等，这为进阶写作者提供了很好的变现手段。

不用手机一个月的感悟

2024-04-03T03:40:26+00:00

根据2022年的一份调查显示，成年人平均不到2分钟需要点击一次手机开关键，也就是说，现在手机使用者的单次注意时长也就是「注意广度」已经下降到不到2分钟了，大概与三岁儿童一样，而及格的注意广度需要起码20分钟以上，否则难以做成事，因为大多复杂的事都要一定时长的专注时间。

我也深有体会，过去我能冥想15-30分钟，随着几年用智能手机下来，我冥想时间只剩5分钟左右了，而且专注时长下降到了10分钟。

通过一段时间的戒断智能手机，我的专注时间才勉强恢复到15分钟左右了，很多次我设置一个25分钟到番茄钟，感觉差不多了时，才发现时间才过了15分钟，而过去我的专注时长大概能有30分钟。手机劫持了我的多巴胺系统太久了，恢复需要时间。

我是如何不用手机但还能保持生活不受影响的呢？首先，我买了个智能手表，里面可以插卡打电话以及用手表版微信，以及一些例如看天气这样的基础实用性的功能，其他啥也干不了。这样，联系我的人其实没感觉到我不用手机了的，除非我告诉他们。其次，我在电脑上安装了个安卓虚拟机，相当于将手机内置在了电脑里面，以满足一些app的使用，例如有些app没有网页版就需要用虚拟机里的手机安装了。如果要用微信发些图片、文稿之类的，也可以用虚拟手机发。将手机装在电脑里的好处是手机不再像长在人身上的「器官」一样形影不离，而是变成了一个要用时使用的「工具」。

手机在某个时间节点之前，益处是大于坏处的，大概就是微信刚出的时候，那时候的手机及软件等刚有点智能，但智能又不过头，例如那时候的微信才是真的小而美，该有的功能都有，不该有的都没有；例如那时没有智能推荐算法将人束缚起来；例如那时候流量费挺贵，恰好限制了人过多使用手机。时间就在2013年左右。

而我现在使用的手机就是2013年出的三星盖乐世，只有100多克非常轻便，我用它来做闹钟、拍照、录音、备忘录、安装了个小巧的时间管理app。它的RAM只有768M，杜绝了使用如今绝大多数app的可能，真正做到了手机只为人的发展服务，只有益处而几乎没有任何害处。

看很多前辈说，人上了年纪才会发现，过去的新闻全都与自己无关，但越是年轻，会越有与自己有关的幻觉。我如今基本上不会漫无目的地看新闻了，它们的确是与自己无关的，真正重要的新闻一定在交际中被传达的，只要你有关心你的人，哪怕一位，与你有关的新闻一定会传达给你。

除了不用手机，起居的地方我是断网的，只在需要网络的地方才设有无线网络，这样解决了大多意志力不强的时候把大量时间用于漫无目的地用电脑上网上，不仅节约了大量时间，而且有助于养成好的生活习惯。

我是之前断断续续地不用手机，那时手有个习惯，就是一闲下来就往裤子里掏手机，结果掏了个空。现在几乎完全不用手机才一个月，这个习惯已经消失了。现在注意力和感知能力在逐渐恢复，能在生活中注意到以前注意不到的细节，过去被屏蔽的感官也逐渐恢复敏锐。人的内心世界是怎样的只取决于我们的注意力在哪，那些我们注意不到的事情本质上不属于我们。我会发现新鲜空气越来越清爽了，吃的食物能品尝出细致、微妙的味道，路上行人距离感变小、不再那么陌生，能体察到花草树木的纹理与颜色变化……没有了爆炸的信息的干扰，内心变得越来越平静，目标变得更加坚定，行动上更加果断……

有句话说得好，“以前网络是现实的避风港，如今现实成了网络的避风港”。很多人现在还没意识到，自己的注意力正在被廉价“卖给”了系统，然后被系统高价卖出了。能量守恒定律一直存在，平台利用人性的弱点，雇佣几千名工程师创造一系列强大的算法，让大多数人内容消费者心甘情愿、“快乐地”将宝贵的注意力几乎免费地送给了平台，而平台以及提供“感官服务”的内容生产者将注意力打包成广告、商品等形式高价卖出。否则估值高达成百上千亿的公司怎么来的？市值等于注意力价差乘以人群规模，一将功成万骨枯啊。

未来的世界将会越来越两极分化，人与人的最大的差距将变成注意力上的贫富差距。一方面，精英将越发充分利用互联网为自己的生产提高效率、利用人工智能等打造一个个强有力的赚钱系统等，而普通人则被一个个算法系统捕获，难以逃脱，成为“快乐地主动遵守规则”的小白鼠。

构建写作输出体系

2024-04-03T03:40:26+00:00

写作的坡道

之前看到二小姐的文章有段话，挺有感触的：

大部分工种只能输出30年，程序员之类的职业寿命甚至短至10年，就算你宦海浮沉，官拜副宰相，也只能输出40年，不能再多了。但是写作不一样，写作的优势在于：可以持续输出到死。

黄永玉99岁辞世前还在写，还在画，还能为荣宝斋350周年创作巨幅画作当贺礼。胡锡进当环球时报总编时没什么名气，但是退休后反而成了中国互联网的顶流……

这是其它任何一个职业都无法比拟的优势。

写作的雪足够湿，坡道足够长，长线能够滚出很大的雪球。只是刚开始，我们大多都不愿意把手打湿。而少数人，从年轻时的写日记就开始搓出小雪球开始滚了，默默无声地不断翻滚，滚过博客时代的积累期、微信公众号时代的爆发期，直到现在短/长视频时代的成熟期，一往无前。

从本质上讲，视频创作者算得上半个写作者，剧本、稿子、提示词等文字内容加上声音与图片的表现形式，就是视频。文章与视频的仅有的界限也正在被打通，如今利用AI，文章可以非常快速地转为视频。也就是说，人类学会使用文字之后直到现在，不管内容载体如何变化，文字依然是灵魂，视频时代不过是写作坡道的延伸。

先把手打湿

一切都是积累的结果，大多数擅长文字的人，他们的累积输出量一定是积累到了一定的阈值。他们甚至用输出倒逼输入，阅读量也是不有意识积累的人的好多好多倍。

写作能力的提升核心在于用数量堆死质量，大量输出，尽快积累到从量变到质变的阈值。至于好文章，少部分情况是大量输出的概率性成果，大部分情况则是一般文章的迭代与修改的结果。

所以我们需要先进行低门槛创作，先写起来发表起来，先把文字输出养成习惯，把手打湿。

构建输出体系

我搜索了下写作平台，推荐的多是微博、简书、微信公众号、知乎等。刚开始一定要纯粹点，简单点，而且尽量少受干扰。

微博的优点是不需要很多字数就算得上输出，是碎片整理、灵感收集的好工具。但是上微博会受到「凑热闹的天性」的影响，例如热搜榜，不看它对我们的生活毫无影响，但看了它反而浪费了我们宝贵的注意力。

要想享受微博的好处，就需要把输入与输出隔离开，我们可以另外注册一个微博专门用于输出，或者干脆把已有的取关所有人，做纯输出。然后，屏蔽热搜榜、广告之类的干扰项。

如果用网页版微博，只需要简单地下载个ADGUARD的屏蔽广告的插件，然后在用户过滤器里写上这样一句，就能屏蔽首页的热搜榜了。

ADGUARD用户过滤器

屏蔽热搜榜的微博界面

也可以用微博的第三方客户端代替网页版，例如，我喜欢用一款叫做「Maipo」的MacOS系统的APP，它让微博变得非常纯粹，我们只管输出。

Maipo界面

简书也是非常纯粹的输出工具，微信公众号相比而言显得非常麻烦，不利于新手的习惯养成。简书直接用网页版就行，或者如果你用MacOS可以用「Unite」把它做成APP，这样就非常方便了。

简书输出端界面

以后还有其他目的，就可以进阶选择其他平台了，甚至是从文字创作转为视频创作。

最后，这些商业化平台的坡道恐怕不够长，它们能存活哪怕20年的都不多，而写作本身的坡道可是几乎可以横跨人的一生。所以，我们需要每隔一段时间，将这些输出的内容整理与保存起来，或者同步在自己的个人网站上，以沉淀知识，方便随时转移阵地。甚至如果写出了一项较为完备的知识体系，可以整理出版成书籍，为人类知识库贡献一份力量。

最小成本护牙法

2024-04-03T03:40:26+00:00

由于我们的预期寿命的提高，牙齿这个器官未来需要扛过更长的岁月，而年老牙口不好实在是太影响幸福感了，于是我们只能从年轻的时候开始，直到入土之前时刻不停的爱护好牙齿。

相比金钱的有限，我们的时间更加得有限，这里我们将「成本最小」近似等同于时间成本最小，虽然该方法从结果上同样也是金钱成本最低的。

首先，最基本的就是要减少食物残渣在牙齿上的残留时间，牙齿寿命基本上是与它成反比的。要想最小化食物残渣残留时间，有两个办法，一是减少进食频率，二是进食后立即清洁牙齿。从成本最小角度看，减少进食频率是成本最低的，除了生活必要的用餐，餐间其他零食之类的少吃，避免吃完后不清洁而增加残留时长。如果真的很喜欢零食，那就只能在进食后立即清理牙齿下手了。

牙齿结构是复杂的，沟槽相接、崎岖不平，在如此长的岁月中我们很难完全规避刷不干净的情况，于是我们有个时间千万不能省，那就是学习正确刷牙以及刷牙的时间。首先需要花点时间学习正确的刷牙方式，其次日常的每次刷牙必须刷够3分钟以上，否则节省的时间实际上最后会因为牙齿问题而成倍亏回去。建议弄个旧mp3放在卫生间，里面全下载3分钟以上的歌，每次刷牙点首歌，既愉悦又刷够了必要时长。

如此，有个时间不能省，那就是进食后刷牙的必要时长。设单天进食频率是N次，必要的刷牙时长就是3N分钟。如果想节省时间，只能控制进食频率，不能减少单次刷牙时长。当然，如果在外面，可以用漱口临时代替刷牙。

即便我们正确刷牙，牙齿间隙依然可能刷不到，这时候我们还需要一个工具——冲牙器，感谢我们这个工业大国，这玩意已经非常便宜了。这个一天2-3次，每次使用不要超过2分钟，我一般1.5分钟每次，一般就是大餐后刷完牙之后，这个投入时间大致是每天4分钟。

即便我们学会了正确刷牙，并使用冲牙器，假如我们偶尔没有坚持，牙齿与牙龈间容易由食物残渣残留而生成牙结石，它会造成牙龈的不可逆萎缩，而且它也是很多牙齿疾病的前奏。基于我对人性的了解，很多人看到牙齿只有一点点牙结石是不会去医院花几十到百元块钱解决它的，感觉性价比低，而是会等到牙结石大量生成后才会去。

这个问题依然可以低成本解决，现在家用洗牙器已经既便宜又实用了，发现一点牙结石就可以分分钟解决。这比去医院在时间与金钱上都便宜，只需要稍加练习就会了。这是一道保险，前两步做到了，这一步就不会花太多时间了。

综上，花100元内买个冲牙器和家用洗牙器，每天认真花个3N+4分钟的护牙时间，是我认为的最小成本护牙法。如果在牙结石上花了额外的时间，那一定是在刷牙和冲牙上少用了时间，导致平均每天的时长大于了3N+4，依然不改变3N+4的最小成本的结论。这样做的结果，是那些难缠又费时的牙齿疾病基本与你无缘了。而反过来说，妄想不好好刷牙，节省这3N+4的每天必要的护牙时间的结果，则是在牙齿上花费的时间远大于每天3N+4分钟，更别提那额外的金钱上的成本。

我个人一天只吃两餐，而且几乎不吃零食，牙齿上花费的金钱成本就是花了不到100块钱买的冲牙器和洗牙器，以及不含智商税的平价牙膏和牙刷，时间成本就是每天3✖️2➕1.5✖️2🟰9分钟。

门户Apps

2024-04-03T03:40:26+00:00

在PC互联网时代的早期，门户网站十分重要，它在搜索引擎尚未成熟之前给互联网用户提供了获取信息的入口，是通往互联网的大门，故谓之“门户”。当然，它被后来居上的搜索引擎降维打击之后，就此没落。搜索引擎所形成的“万网归一”效果，使得信息获取效率指数级提升，当之无愧地成为了新的互联网超级入口。

但如今，移动互联网时代（尤其是我国的），各子网们忙着进行“圈地运动”（甚至连搜索引擎公司也参与），它们不断建城墙、挖壕沟，相互形成了很强的信息壁垒。它们共同争抢的有限资源，是「国民总注意力」，而且这种有限资源也随着出生人口锐减而变得日益稀缺。这种竞争势态下，搜索引擎所构成的所谓“互联网”其实是一张四分五裂的浅网，信息聚合程度大大变弱，更糟糕的是，现在还“信息爆炸”，导致我们很多时候是难以直接搜到想要的信息的。

于是我们不同程度地陷入了一种信息焦虑之中——一方面信息越来越多，另一方面信息又相互割裂、杂乱无章因而难以理顺。但是我们仔细想想，真的是“信息爆炸”吗，还是更确切地说，其实是「垃圾信息爆炸」？当然，新增的信息由于实效性强，对我们很重要，我们不能忽视它，但是，其整体的“信息密度”其实是很低的，远低于受物质条件限制（不重要的低密度信息不容易成书）、经时间的洗礼、同行评议等过滤器而浓缩而成的书籍、论文等。我们对于信息的获取，首先是应当以后者为主，并优化前者的获取方式，以形成对后者的有力补充。

而优化对新知识的获取的关键在于这几个字——变被动为主动。注册一个平台账号，平台一般会诱导性地强力推荐你关注一堆大V、话题等，这是被动；由于大脑底层架构原因，你在查找目标信息时，发现了无关乎目的的一个震惊体视频或一位美女/帅哥图片，于是你莫名其妙地点击了一下，之后由几千名工程师生成并维护的推荐算法就开始尝试接管你的选择权，陆续诱导你在一次次点击中不断强化该倾向性，这是被动；由于信息壁垒，你被迫把每家的App都下载下来，以尽量保留信息获取的完整性，结果遭受着更大范围的消息推送与广告轰击，这也是被动。

「主动」是要有自己的信息获取目的、自己的信息筛选标准以及自己掌握信息获取的渠道。在目的的指引下，我们得以形成信息筛选的标准，最终找到正确的信息源。例如，我要学习XX知识，然后深入学习后，知道YY老师是靠谱的学习对象，于是在ZZ平台找到了YY老师发布的信息。在这种情况下，其他目的、其他平台、或者ZZ平台的其他信息对该目的是无效的，我们要的只是YY老师的信息而已。这种情况还好，就只要注册ZZ平台并关注YY老师即可，当然这种情况还得浪费点自制力以抵制ZZ平台推荐的其他信息的诱惑、以及受些开屏广告嵌入广告等的对商品偏好的影响，问题不大。但当要获取的信息在多个平台，我们就被迫下载一堆塞满手机内存的很少优化App体积的国产软件了，这种情况下众Apps形成的诱惑或诱导的强度呈几何级数的增加，而自制力又是有限资源，最终我们往往会沉迷在「获取用户注意力竞赛」中胜出的那个App中许久才回过神来。

怎么办呢？我的解决方案是利用RSS订阅这个古典互联网时代的解决方案，作用是在不注册ZZ平台的情况下，自动获取YY老师的内容更新。过去很多内容提供者会给出做好的RSS订阅链接，但如今信息壁垒战都打得热火朝天，提供RSS的少之又少，需要我们自己想办法去突破壁垒「爬取」内容。我们虽然很难用一个“门户”就集齐想获取的所有信息，但个位数的门户还是可以接受的。以下是我的信息获取门户Apps，一共是四个，邮箱、Distill、Reeder和微信读书。

微信公众号的信息质量相对较高且难以爬取，只好借助它自己推出的门户——微信读书——来订阅了，在微信中我虽然关注了很多杂七杂八的公众号，但我会全部取消消息推送，然后在微信读书里只订阅自己真正需要的。这样微信的作用就仅限于聊天，我得以不与它复杂绑定了。

正宗的RSS订阅依靠的主要是用Reeder这个RSS阅读器配合RSSHub的生成RSS订阅链接，可以订阅国内绝大多数媒体的内容，例如微博、B站、知乎等，无需在多个平台“反复横跳”。

Distill这个探测网页内容变化的App是作为RSS订阅的有力补充，有些平台没有RSS就算了，甚至做了极其严格的反爬让RSSHub也生成不了链接（例如抖音、小红书），这个时候Distill就派上用场了。这个App具有普适性，可以应付各种复杂情形。例如，可以用它探测知识星球的更新，这样不仅不用下载该App，而且可以白嫖很多付费内容。

而邮件这个传统的异步通讯工具以及订阅方式当然也少不了，除了用邮箱订阅了很多重要的信息来源外，凡是能用邮箱注册的账号我尽量用的是邮箱注册，因而归集了很多重要的信息。

这四个移动互联网时代的门户App，基本把我需要关注的所有消息都归集起来了，我只需要每天把它们看完就行了。有了它们，我得以无需注册那些我只作为内容的消费者的平台。当然，这个过滤系统需要定期维护，剔除些变劣质或不符合目的的信息源并增加些新的信息源。

手机无法代替手表

2024-04-03T03:40:26+00:00

在时间管理方面，多年前我做错了一件事，那就是想当然地认为有了手机，就把手表给扔了，直到现在我才幡然醒悟，这是个很重要的细节。

过去十多年的学生生涯，我的时间感都是建立在手表之上的，简单来说就是在手表看时间的纯粹、方便的基础上，通过一天非常多次的核对时间，大脑对光阴流逝有了颗粒度更细的感知，使得对一天能做多少事有了更好的把握，一天下来时间安排更加有的放矢，过得明明白白。这几年没有手表的日子，总感觉时间不受掌控了，但却不知哪里不对，当然不能全怪没手表，但也是很重要的因素之一。

过去，假如一天做了N件事，我最起码会查看N+1次时间，这就是大脑该有的时间校对频率，对时间的感知力就是通过一次次的事件预期所用时间和实际所用时间而逐渐建立的。如果说时间也是一件工具，就像手术医生对各类手术器材的感知越精细就越能用好，对时间的感知力很可能也是用好它的关键。这一点是我近年在看完《奇特的一生》这本书后想到的。

多年来经常看表的结果，柳比歇夫肯定形成了一种特殊的时间感。

他记下工作起讫的时间，误差不超过五分钟。

他的时间好像是物质，不会无影无踪地消失不见，不会消亡；它变成了什么，总能查得出来。他由于做了统计，获得了时间。这是最实在的收获。

柳比歇夫通过他的时间统计法对自己进行了研究和试验：试验在写、读、听、工作、思索各方面，他到底能干多少？干多少？怎么干？他不让自己负担过重，力不胜任；他总是循着他能力的边缘前进，他对自己能力的掂量愈来愈精确。

小小的时间统计法变成了生活的方法。采用这种方法的结果，柳比歇夫的时间多了一倍。

依我看，时间统计法的灵魂并不在统计，而在于看表、记录产生的时间感知力，很多人践行柳比歇夫的时间统计法犯了一个很大的错误，那就是用手表APP点击开始计时，然后做完一项任务点击停止，以此「统计了时间」。这种傻瓜式操作非常地简单，但将关注点落在了统计，却忽略了最核心的要点——训练时间感知，时间感知的训练才是这种方法的灵魂，统计不过是副产品。

真正需要做的是怎样的呢？

做一件事前看下时间
做这件事
做完这件事后要「估计用了」多长时间
查看「实际用了」多长时间

手机APP这种方便性（手指点击即可，柳比歇夫是纸笔记录）与看似更优秀的精确性（精确到1分钟，柳比歇夫是5分钟），实际上反而沦为了单纯的时间统计了。纸笔记录无形中利用了沉没成本效应，手眼的能量投资绑架让大脑对其更加珍重，而点击即可却让这种投资接近于零。而5分钟这种颗粒度恰到好处，就像合适密度的齿轮能更好地带动转动，合适颗粒度使得我们去估计时间有了合适的脚手架。如果用APP记录，本来APP记录就倾向于不去估计时间，过细的颗粒度更让这种估计难以落脚，因为颗粒度下相同时间的不断重复才能逐渐形成对该时间的感知。

例如，这次17分钟，下次23分钟，下次24分钟，这种1分钟颗粒度的我们认知上会将它看成三种时间长度，但一天中很难有这种相同时间长度的碰撞。如果上5分钟的，17分钟会归为15分钟，23、24分钟都会归为25分钟，后者是相同时间，大脑会知道，“哦，原来这两段时间是一样的，而前面那段比后两段少了一个单位”，更高频率地让大脑被动地去估计时间，而且这种需要“四舍五入”的步骤正好也能带动我们去主动估计时间。

所以，这样看，手机相对于手表存在明显的劣势。

第一，手机并不是纯粹的计时工具，足量查看时间的需求很容易转化为了过量查看手机，分散我们的注意力。我过去几年扔掉手表改用手机查看时间后，是本能地少看手机规避了注意力的分散，却也直接导致查看时间上的不足，逐渐从一个时常拜访时间的时间的朋友变成了一个不怎么看它的陌路人。

第二，手机在时间查看上没手表方便。

第三，手机缺少了去掌控时间的仪式感。

基于这三点，看时间方面，手机是很差的选择，一块电子手表加纸笔统计，就能轻松跑赢「时间管理」市场的大盘，看似简单的选择实则却是最明智的。

孤独大脑专栏的老喻曾写道：

销售“拥有感”，是许多商品的本质。其价格取决于该“拥有错觉”的用户焦虑度与制造成本。故奢侈品总试图提供高难度的幻觉。而不可能真正拥有物的占有替代品最贵，如时光（这方面的商品有：表、化妆品、整容、包养年轻异性、私人飞机等）。

而名表销售的可以看作是对时间的拥有感，这只是一个幻觉，实际上对时间的感知越强、使用得越好，才越配得上时间。

第二次换跑步记录App

2024-04-03T03:40:26+00:00

用一幅图介绍下我之前用的记录跑步的App：

我对记录跑步App的核心需求只有一个——方便导出数据，数据自己掌握，而不是像这次NRC停运一样很多人的数据就直接没了。而且这次NRC做得非常不好的一点就是，停运也没给我邮件通知，导致我未在规定时间内申请数据导出，我的数据现在也就拿不到了。当然如果我平时就打开了自动导出，也就没这回事儿了，但因为很早前自动导出程序出了个bug我忘了修正，很早就停止了自动导出……

虽然2022年上半年我跑步较少，但本来还是跑了些的，现在这幅我用脚步“画”出的图也因此缺失大块了，里面没有半点色彩，不得不说是一个遗憾。

发现NRC用不了了后，我重新用悦跑圈顶替一会儿，但它有一个不好的地方是，没法简单地用api自动导出数据，因为用于登录的sid每次都不同。

于是我研究了市面上的跑步记录App，发现「小米运动健康」App 可以接入strava，每次跑完步该App会将数据自动同步到strava，然后我的页面自动连strava画图，这样就搞定了。

市场竞争中没有永远存在的企业，「小米运动健康」如果不运营了，我就考虑用其他能接入strava的App替代或者用strava本身即可。如果strava不运营了，就只有自己手动导出gpx数据或者买佳明手表了……总之我觉得够用就行，核心需求就是要能始终自己掌握自己的跑步数据，这次NRC停运事件就是一个警醒，这也证明了我之前选择的道路是正确的。

西湖随拍

2024-04-03T03:40:26+00:00

戒瘾的通用方法

2024-04-03T03:40:26+00:00

到底喜欢某种东西何种程度才算上瘾？密歇根大学专门研究食物成瘾的心理学家Ashley Cearhardt提出的条件十分合理——需要同时满足三个条件：

强迫性和习惯性（明知不好但仍然想继续）
耐受性和戒断反应（离开这个东西混身不自在）
对生活质量产生负面影响（使用这个东西时能获得短期快乐，但长期却会付出代价，甚至妨碍正常生活）

我本人研究上瘾这个问题好久了，看了不少书和文章，最后发现了一个正念方法基本上对所有的上瘾行为均有非常好的效果，对什么吸烟、喝酒、玩手机上瘾等都非常好。要实施这个方法就在于理解下面这几段话：

对某物上瘾之后，或情绪或欲望或本能的冲动会产生一种身体上强烈的难受感（对应要点2耐受性），这种感受会驱使你（对应要点1强迫性）做出相应的行动去缓解这种冲动。如果你做了，冲动会减少，难受感会降低，同时奖励你舒服愉悦的感受（对应要点3），但这种愉悦感会强化该行为的强迫性与耐受性，让你下次继续做这个动作。这就是我们被瘾所奴役的过程，这个过程会在一次次循环中不断强化该瘾，让其十分顺滑地成为我们身心的又一道枷锁。

如何跳出这个过程呢，你需要在那种冲动带来的难受感浮现时，把注意力放在那个难受的感受上，不要去逃避这个感受，而是正面观察它，去仔细看看这个感受究竟是怎样的，不带任何评价，不去尝试抵制、抗议，不被这种感受所影响，不去管难受到最后会怎样，也不去想办法减少这种难受让身体舒服，接受这种难受感，难受就是难受，就让它难受着，唯一要做的就是观察它。过不了一会，这种感受自己就消退了，因为感受的本质就是不可持续的，就像不再搅动湖面，涟漪很快就会消失，你观察它，它就渐渐软弱消散了；而当你正面与之打斗，或者屈服于它，按它的要求满足于它，你便永远是它的奴隶。观察它让其自行消散，是打败它做自己身心的主人的唯一方法，与其正面打斗、或者屈服它，只会让它越来越强大。

而经常被建议的所谓做其他事去绕过它、单纯的转移注意力等方法，本质上并没有面对它，而是在逃避它，这并不会使它真正消失，它很快就会卷土重来。这虽然看似并没有直接强化它，但由于欲望与冲动的积蓄效果，它很可能同样被强化了，同时由于相当于放虎归山，下次袭击变得更加不可控，你会更加被动，例如在你情绪不佳时，它的突然袭击很可能能够得逞。

观察它让其自行消散，是打败它做自己身心的主人的唯一方法，它会在一次次的化解中逐渐变弱、变得可控，而与其正面打斗、或者屈服它，只会让它越来越强大。

一文搞懂窗口函数

2024-04-03T03:40:26+00:00

MySQL从8.0开始支持窗口函数。所谓窗口函数，包括两个内容，一个是窗口，要明白窗口的概念，另一个是函数，特指应用在窗口上的函数。

概念

我们有时候不对整个源数据进行处理，而是要一部分一部分依次处理，就需要一个窗口限定一下，这里的窗口其实真正指的是划定范围，连续作用下（就像窗口的滑动）实现了数据的动态分区。

而应用在窗口的函数则实现对窗口限定的分区的各类计算。

所谓窗口函数，窗口实现数据选择，函数实现数据处理。

窗口函数的基本用法：

`1`	`函数名(字段名) over(子句)`

其中，函数参数部分填需要被加工的字段名称，over是关键字，用来指定函数执行的窗口范围，包含三个分析子句：

分组子句：partiton by <要分列的组>
排序子句：order by <要排序的列>
窗口子句：rows between <数据范围>

`1`	`函数名(字段名) over(partiton by <要分列的组> order by <要排序的列> rows between <数据范围>)`

窗口函数相当于在整个select语句执行中过程中给行打上标签，并依据分组、排序、开窗等方法在内部生成新的结果，然后用标签匹配回原结果，一起组装后产出。

数据选择

partition by它与普通函数的分组语句group by相比，它们其实作用没区别，都是分组，但处理结果有区别。group by分组后做的是整组聚合运算，各组里如果有多个行处理后最终只会有一行返回，而partition by它分组后做的是逐行按窗口计算，不管用什么函数处理，一行记录得到一行记录，返回的行还是那么多。

order by好理解，就是按字段进行排序，与普通函数的排序语句一样。

而最有意思的其实是窗口子句rows between。具体的窗口大小其实通过它来限定。

之前说了，窗口函数里对各分区中的数据的处理做的不是聚合运算，而是逐行按窗口计算，也就是基于每一行给定的窗口里的数据进行处理。这里rows between就限定了该行所对应的窗口范围。

rows between 2 preceding and current row #取当前行和前面行
rows between unbounded preceding and current row #包括本行和之前所有的行
rows between current row and unbounded following # 包括本行和之后所有的行
rows between 3 preceding and current row # 包括本行和前面三行
rows between 3 preceding and 1 following #从前面三行和下面一行,总共五行

当order by后面缺少窗口从句条件，窗口规范默认是rows between unbounded preceding and current row，也就是当前行以及之前的所有行。

当order by和窗口从句都缺失，窗口规范默认是rows between unbounded preceding and unbounded following，也就是全部的行。

【注：以上rows也可以写成range】

以上就是数据选择部分，其中分组子句实现数据的分组归类，排序子句对分区中的数据进行排序，二者均为数据提供了某种秩序，为最终的目的——窗口的选取——作了铺垫，如果数据杂乱无章，窗口的选取将难以进行。partition by提供的秩序是——分隔而互不干扰，即对于数据选取的目的来说，partition by后面接的字段如果值不同，其数据行就100%不会在后续处于同一窗口而发生相互关系。order by后面接的字段提供的秩序是有序性，后面窗口的选取需要这些字段排好序。有了partition by和order by提供的秩序，rows between就得以按照简单的规则进行数据选取了，甚至很多情况只用默认规则就达到了目的。

概念图如下：

数据处理

对选取的数据，我们用前面的函数进行处理。一般可以将它们分成两类。

专有函数（即窗口环境下专有的函数，主要有排序函数三巨头，偏移函数，切分函数ntile）
1. rank()：为跳跃排序，结果相同的两个数据并列，例如并列第一，则为1134
2. dense_rank()：为有重复的连续排序，结果相同的两个数据并列，例如并列第一，则为1123
3. row_number()：为不重复的连续排序，例如并列第一，照样为1234
4. ntile(n)：用于将分组数据平均切分成n块，如果切分的每组数量不均等，则第一组分得的数据更多
5. 偏移函数，用于取出同一字段的前N行数据或后N行数据，作为单独的列，分别是lead(str, n, default)和lag(str, n, default)，n表示前/后n行数据,默认值为1，default表示如果取值范围已经超过整个表的返回值，可以不填，不填默认返回N/A
6. 位置函数，用于取出第一行的first_value()函数和最后一行的last_value()函数，以及取出第n个的nth_value(str,n)函数
7. 分布函数，包括PERCENT_RANK()每行按照公式(rank-1) / (rows-1)进行计算。其中，rank为RANK()函数产生的序号，rows为当前窗口的记录总行数。CUME_DIST()则按rank/rows进行计算，即当前行的行号/总行数。
聚合类函数（即普通场景下与group by一起使用的那类函数，作用相同）
1. sum()
2. count()
3. avg()
4. max()
5. min()

掌握这些函数，具体还是需要在具体例子中完成。

实战

准备

建表

（考试成绩和生活消费记录）

create table exam_score(
    sname varchar(20),
    age int,
    subject varchar(20),
    score varchar(20)
)charset=utf8;

# ----------------------- #

create table cost_fee(
    sname varchar(20),
    buydate varchar(20),
    buycost int
)charset=utf8;

插值

insert into exam_score values
('张三' , 18, '语文' , 90),
('张三' , 18, '数学' , 80),
('张三' , 18, '英语' , 70),
('李四' , 21, '语文' , 88),
('李四' , 21, '数学' , 78),
('李四' , 21, '英语' , 71),
('王五' , 18, '语文' , 95),
('王五' , 18, '数学' , 83),
('王五' , 18, '英语' , 71),
('赵六' , 19, '语文' , 98),
('赵六' , 19, '数学' , 90),
('赵六' , 19, '英语' , 80);
# ----------------------- #
insert into cost_fee values
('张三','2019-01-01',10),
('张三','2019-03-03',23),
('张三','2019-02-05',46),
('李四','2019-02-02',15),
('李四','2019-01-07',50),
('李四','2019-03-04',29),
('王五','2019-03-08',62),
('王五','2019-02-09',68),
('王五','2019-01-11',75),
('赵六','2019-02-08',55),
('赵六','2019-03-10',12),
('赵六','2019-01-12',80);

检查

mysql> select * from exam_score;
+--------+------+---------+-------+
| sname  | age  | subject | score |
+--------+------+---------+-------+
| 张三   |   18 | 语文    | 90    |
| 张三   |   18 | 数学    | 80    |
| 张三   |   18 | 英语    | 70    |
| 李四   |   21 | 语文    | 88    |
| 李四   |   21 | 数学    | 78    |
| 李四   |   21 | 英语    | 71    |
| 王五   |   18 | 语文    | 95    |
| 王五   |   18 | 数学    | 83    |
| 王五   |   18 | 英语    | 71    |
| 赵六   |   19 | 语文    | 98    |
| 赵六   |   19 | 数学    | 90    |
| 赵六   |   19 | 英语    | 80    |
+--------+------+---------+-------+

mysql> select * from cost_fee;
+--------+------------+---------+
| sname  | buydate    | buycost |
+--------+------------+---------+
| 张三   | 2019-01-01 |      10 |
| 张三   | 2019-03-03 |      23 |
| 张三   | 2019-02-05 |      46 |
| 李四   | 2019-02-02 |      15 |
| 李四   | 2019-01-07 |      50 |
| 李四   | 2019-03-04 |      29 |
| 王五   | 2019-03-08 |      62 |
| 王五   | 2019-02-09 |      68 |
| 王五   | 2019-01-11 |      75 |
| 赵六   | 2019-02-08 |      55 |
| 赵六   | 2019-03-10 |      12 |
| 赵六   | 2019-01-12 |      80 |
+--------+------------+---------+

聚合函数

1.计算每位同学的得分与平均值的情况

分析：

这里的结果需要原来的得分，也需要平均值，结果还是需要有原来的行数，所以要用窗口函数
不同人的分需要隔离开，立即想到partition by的字段是人名
平均值不需要各分区的值排序，所以可以无order by
全区求平均，无需划定滑动小窗口，自始至终都是静态的大窗口——整个分区全部的行，也就是rows between需要用rows between unbounded preceding and unbounded following
但由于省略order by与rows between时，rows between默认就是unbounded preceding and unbounded following，同样满足条件，因此可简写

代码：

select sname
,subject
,score
,avg(score) over(partition by sname rows between unbounded preceding and unbounded following) as avg_score
from exam_score;

结果如下：

+--------+---------+-------+-------------------+
| sname  | subject | score | avg_score         |
+--------+---------+-------+-------------------+
| 张三   | 语文    | 90    |                80 |
| 张三   | 数学    | 80    |                80 |
| 张三   | 英语    | 70    |                80 |
| 李四   | 语文    | 88    |                79 |
| 李四   | 数学    | 78    |                79 |
| 李四   | 英语    | 71    |                79 |
| 王五   | 语文    | 95    |                83 |
| 王五   | 数学    | 83    |                83 |
| 王五   | 英语    | 71    |                83 |
| 赵六   | 语文    | 98    | 89.33333333333333 |
| 赵六   | 数学    | 90    | 89.33333333333333 |
| 赵六   | 英语    | 80    | 89.33333333333333 |
+--------+---------+-------+-------------------+

简写代码：

select sname
,subject
,score
,avg(score) over(partition by sname) as avg_score
from exam_score;

结果相同：

+--------+---------+-------+-------------------+
| sname  | subject | score | avg_score         |
+--------+---------+-------+-------------------+
| 张三   | 语文    | 90    |                80 |
| 张三   | 数学    | 80    |                80 |
| 张三   | 英语    | 70    |                80 |
| 李四   | 语文    | 88    |                79 |
| 李四   | 数学    | 78    |                79 |
| 李四   | 英语    | 71    |                79 |
| 王五   | 语文    | 95    |                83 |
| 王五   | 数学    | 83    |                83 |
| 王五   | 英语    | 71    |                83 |
| 赵六   | 语文    | 98    | 89.33333333333333 |
| 赵六   | 数学    | 90    | 89.33333333333333 |
| 赵六   | 英语    | 80    | 89.33333333333333 |
+--------+---------+-------+-------------------+

2.计算每位同学的消费情况和消费总额

分析：

既要消费情况又要消费总额，则窗口函数请求一战
【每位同学】，立马有partition by 同学名
消费总额，sum函数跃跃欲试，且是整个区的静态大窗口，无需rows between，且无关order by，简写方式与第一题同理

代码：

select sname
,buydate
,buycost
,sum(buycost) over(partition by sname) as sum_cost
from cost_fee;

结果：

+--------+------------+---------+----------+
| sname  | buydate    | buycost | sum_cost |
+--------+------------+---------+----------+
| 张三   | 2019-01-01 |      10 |       79 |
| 张三   | 2019-03-03 |      23 |       79 |
| 张三   | 2019-02-05 |      46 |       79 |
| 李四   | 2019-02-02 |      15 |       94 |
| 李四   | 2019-01-07 |      50 |       94 |
| 李四   | 2019-03-04 |      29 |       94 |
| 王五   | 2019-03-08 |      62 |      205 |
| 王五   | 2019-02-09 |      68 |      205 |
| 王五   | 2019-01-11 |      75 |      205 |
| 赵六   | 2019-02-08 |      55 |      147 |
| 赵六   | 2019-03-10 |      12 |      147 |
| 赵六   | 2019-01-12 |      80 |      147 |
+--------+------------+---------+----------+

3.计算每位同学的消费情况和累计消费总额

分析：

这里与第二题基本一样，但这里是累积消费总额，是随时间累积的，与时间的顺序有关，因此order by后要接时间字段
窗口在每行都需要有所变化，累积即本行之前行至本行的总额，因此rows between是unbounded preceding and current row，窗口随着【本行】的变化是滑动的
但由于有partition by和order by但无rows between则rows between的默认结果是unbounded preceding and current row，因此可省略rows between

代码：

select sname
,buydate
,buycost
,sum(buycost) over(partition by sname order by buydate rows between unbounded preceding and current row) as sum_cost
from cost_fee;

结果：

+--------+------------+---------+----------+
| sname  | buydate    | buycost | sum_cost |
+--------+------------+---------+----------+
| 张三   | 2019-01-01 |      10 |       10 |
| 张三   | 2019-02-05 |      46 |       56 |
| 张三   | 2019-03-03 |      23 |       79 |
| 李四   | 2019-01-07 |      50 |       50 |
| 李四   | 2019-02-02 |      15 |       65 |
| 李四   | 2019-03-04 |      29 |       94 |
| 王五   | 2019-01-11 |      75 |       75 |
| 王五   | 2019-02-09 |      68 |      143 |
| 王五   | 2019-03-08 |      62 |      205 |
| 赵六   | 2019-01-12 |      80 |       80 |
| 赵六   | 2019-02-08 |      55 |      135 |
| 赵六   | 2019-03-10 |      12 |      147 |
+--------+------------+---------+----------+

简化代码：

select sname
,buydate
,buycost
,sum(buycost) over(partition by sname order by buydate) as sum_cost
from cost_fee;

结果一样：

+--------+------------+---------+----------+
| sname  | buydate    | buycost | sum_cost |
+--------+------------+---------+----------+
| 张三   | 2019-01-01 |      10 |       10 |
| 张三   | 2019-02-05 |      46 |       56 |
| 张三   | 2019-03-03 |      23 |       79 |
| 李四   | 2019-01-07 |      50 |       50 |
| 李四   | 2019-02-02 |      15 |       65 |
| 李四   | 2019-03-04 |      29 |       94 |
| 王五   | 2019-01-11 |      75 |       75 |
| 王五   | 2019-02-09 |      68 |      143 |
| 王五   | 2019-03-08 |      62 |      205 |
| 赵六   | 2019-01-12 |      80 |       80 |
| 赵六   | 2019-02-08 |      55 |      135 |
| 赵六   | 2019-03-10 |      12 |      147 |
+--------+------------+---------+----------+

排序函数

1.计算每个科目的排名，相同的分数排名不同，顺序依次增加

分析：

每个科目的排名，要用窗口排序函数，且【每个科目】锁定partition by 科目
排名一定要用到order by，字段显然是分数
排名是基于本行及之前行进行的，因此rows between使用默认的unbounded preceding and current row
相同的分数排名不同，要用row_number()函数

select sname
,subject
,score
,row_number() over(partition by subject order by score) as rank1
from
exam_score;

结果如下：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 李四   | 数学    | 78    |     1 |
| 张三   | 数学    | 80    |     2 |
| 王五   | 数学    | 83    |     3 |
| 赵六   | 数学    | 90    |     4 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 英语    | 71    |     3 |
| 赵六   | 英语    | 80    |     4 |
| 李四   | 语文    | 88    |     1 |
| 张三   | 语文    | 90    |     2 |
| 王五   | 语文    | 95    |     3 |
| 赵六   | 语文    | 98    |     4 |
+--------+---------+-------+-------+

可以看到，英语成绩中李四与王五并列第二，但李四名字排名更前，因此排第二，王五含泪第三。

2.计算每个科目的排名，相同的分数排名相同，余下排名跳跃增加

分析：

与第一题同理，但函数换成rank()。

代码：

select sname
,subject
,score
,rank() over(partition by subject order by score) as rank1
from
exam_score;

结果：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 李四   | 数学    | 78    |     1 |
| 张三   | 数学    | 80    |     2 |
| 王五   | 数学    | 83    |     3 |
| 赵六   | 数学    | 90    |     4 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 英语    | 71    |     2 |
| 赵六   | 英语    | 80    |     4 |
| 李四   | 语文    | 88    |     1 |
| 张三   | 语文    | 90    |     2 |
| 王五   | 语文    | 95    |     3 |
| 赵六   | 语文    | 98    |     4 |
+--------+---------+-------+-------+

这回英语成绩李四与王五并列第二，但赵六还是第四。

3.计算每个科目的排名，相同的分数排名相同，余下排名顺序增加

分析：

与第一题同理，这回排序函数换成dense_rank()

代码：

select sname
,subject
,score
,dense_rank() over(partition by subject order by score) as rank1
from
exam_score;

结果：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 李四   | 数学    | 78    |     1 |
| 张三   | 数学    | 80    |     2 |
| 王五   | 数学    | 83    |     3 |
| 赵六   | 数学    | 90    |     4 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 英语    | 71    |     2 |
| 赵六   | 英语    | 80    |     3 |
| 李四   | 语文    | 88    |     1 |
| 张三   | 语文    | 90    |     2 |
| 王五   | 语文    | 95    |     3 |
| 赵六   | 语文    | 98    |     4 |
+--------+---------+-------+-------+

这回结果英语成绩李四与王五还是并列第二，但赵六为第三。

切分函数

这个函数一般是用来划分数据桶用的。

1.将exam_score表分成四份

代码：

select sname
,subject
,score
,ntile(4) over() rank1
from
exam_score;

结果：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 张三   | 语文    | 90    |     1 |
| 张三   | 数学    | 80    |     1 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 语文    | 88    |     2 |
| 李四   | 数学    | 78    |     2 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 语文    | 95    |     3 |
| 王五   | 数学    | 83    |     3 |
| 王五   | 英语    | 71    |     3 |
| 赵六   | 语文    | 98    |     4 |
| 赵六   | 数学    | 90    |     4 |
| 赵六   | 英语    | 80    |     4 |
+--------+---------+-------+-------+

由于没分组，因此对整个表进行切分，有12份，每份3个。

2.将exam_score表分成五份

代码：

select sname
,subject
,score
,ntile(5) over() rank1
from
exam_score;

结果：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 张三   | 语文    | 90    |     1 |
| 张三   | 数学    | 80    |     1 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 语文    | 88    |     2 |
| 李四   | 数学    | 78    |     2 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 语文    | 95    |     3 |
| 王五   | 数学    | 83    |     3 |
| 王五   | 英语    | 71    |     4 |
| 赵六   | 语文    | 98    |     4 |
| 赵六   | 数学    | 90    |     5 |
| 赵六   | 英语    | 80    |     5 |
+--------+---------+-------+-------+

这里它要保证前面的份量更大，因此第一二份有3个，第三四五份有2个。

3.对exam_score表，对score排序后，按照subject分组切成4份

分析：

这里有4个人，分组并排序后切分成4份的结果就相当于row_number()了

select sname
,subject
,score
,ntile(4) over(partition by subject order by score) rank1
from
exam_score;

结果：

+--------+---------+-------+-------+
| sname  | subject | score | rank1 |
+--------+---------+-------+-------+
| 李四   | 数学    | 78    |     1 |
| 张三   | 数学    | 80    |     2 |
| 王五   | 数学    | 83    |     3 |
| 赵六   | 数学    | 90    |     4 |
| 张三   | 英语    | 70    |     1 |
| 李四   | 英语    | 71    |     2 |
| 王五   | 英语    | 71    |     3 |
| 赵六   | 英语    | 80    |     4 |
| 李四   | 语文    | 88    |     1 |
| 张三   | 语文    | 90    |     2 |
| 王五   | 语文    | 95    |     3 |
| 赵六   | 语文    | 98    |     4 |
+--------+---------+-------+-------+

位置函数

1.截止到当前日期，每位同学的“最后一次购买时间”、“首次购买时间”和“第二次购买金额”

注意【截止到当前日期】，注意窗口是前面的行至当前行。

代码：

select sname
,buydate
,buycost
,last_value(buydate) over(partition by sname order by buydate ) as last_buydate
,first_value(buydate) over(partition by sname order by buydate) as first_buydate
,nth_value(buycost,2) over(partition by sname order by buydate) as 2nd_buycost
from cost_fee;

结果：

+--------+------------+---------+--------------+---------------+-------------+
| sname  | buydate    | buycost | last_buydate | first_buydate | 2nd_buycost |
+--------+------------+---------+--------------+---------------+-------------+
| 张三   | 2019-01-01 |      10 | 2019-01-01   | 2019-01-01    |        NULL |
| 张三   | 2019-02-05 |      46 | 2019-02-05   | 2019-01-01    |          46 |
| 张三   | 2019-03-03 |      23 | 2019-03-03   | 2019-01-01    |          46 |
| 李四   | 2019-01-07 |      50 | 2019-01-07   | 2019-01-07    |        NULL |
| 李四   | 2019-02-02 |      15 | 2019-02-02   | 2019-01-07    |          15 |
| 李四   | 2019-03-04 |      29 | 2019-03-04   | 2019-01-07    |          15 |
| 王五   | 2019-01-11 |      75 | 2019-01-11   | 2019-01-11    |        NULL |
| 王五   | 2019-02-09 |      68 | 2019-02-09   | 2019-01-11    |          68 |
| 王五   | 2019-03-08 |      62 | 2019-03-08   | 2019-01-11    |          68 |
| 赵六   | 2019-01-12 |      80 | 2019-01-12   | 2019-01-12    |        NULL |
| 赵六   | 2019-02-08 |      55 | 2019-02-08   | 2019-01-12    |          55 |
| 赵六   | 2019-03-10 |      12 | 2019-03-10   | 2019-01-12    |          55 |
+--------+------------+---------+--------------+---------------+-------------+

注意，这里体现了first_value/last_value依前述这里有partition by和order by，窗口按默认应该是rows between unbounded preceding and current row，同样nth_value与前述一致，当计算分区第一行时并不知道第二个值，因此填NULL，计算到第二行时知道第二个值，返回，第三行也一样。

2.每位同学的“最后一次购买时间”、“首次购买时间”和“第二次购买金额”

这里窗口就是整个分区了

代码：

select sname
,buydate
,buycost
,last_value(buydate) over(partition by sname order by buydate rows between unbounded preceding and unbounded following) as last_buydate
,first_value(buydate) over(partition by sname order by buydate rows between unbounded preceding and unbounded following) as first_buydate
,nth_value(buycost,2) over(partition by sname order by buydate rows between unbounded preceding and unbounded following) as 2nd_buycost
from cost_fee;

结果：

+--------+------------+---------+--------------+---------------+-------------+
| sname  | buydate    | buycost | last_buydate | first_buydate | 2nd_buycost |
+--------+------------+---------+--------------+---------------+-------------+
| 张三   | 2019-01-01 |      10 | 2019-03-03   | 2019-01-01    |          46 |
| 张三   | 2019-02-05 |      46 | 2019-03-03   | 2019-01-01    |          46 |
| 张三   | 2019-03-03 |      23 | 2019-03-03   | 2019-01-01    |          46 |
| 李四   | 2019-01-07 |      50 | 2019-03-04   | 2019-01-07    |          15 |
| 李四   | 2019-02-02 |      15 | 2019-03-04   | 2019-01-07    |          15 |
| 李四   | 2019-03-04 |      29 | 2019-03-04   | 2019-01-07    |          15 |
| 王五   | 2019-01-11 |      75 | 2019-03-08   | 2019-01-11    |          68 |
| 王五   | 2019-02-09 |      68 | 2019-03-08   | 2019-01-11    |          68 |
| 王五   | 2019-03-08 |      62 | 2019-03-08   | 2019-01-11    |          68 |
| 赵六   | 2019-01-12 |      80 | 2019-03-10   | 2019-01-12    |          55 |
| 赵六   | 2019-02-08 |      55 | 2019-03-10   | 2019-01-12    |          55 |
| 赵六   | 2019-03-10 |      12 | 2019-03-10   | 2019-01-12    |          55 |
+--------+------------+---------+--------------+---------------+-------------+

由于窗口是整个分区，在第一行就知道了第二次购买金额以及整个分区的最后一次购买时间。

偏移函数

1.展示各位同学的“上次购买时间”和“下次购买时间”。对于第一天，显示 “first buy”；对于最后一天，显示 “last buy”

这里上次购买就相当于把排好序的日期向下偏移一行，首行空缺则填默认值first buy。下次购买则相当于把排好序的日期向上偏移一行，尾行空缺则填默认值last buy。

代码：

select sname
,buydate
,lag(buydate,1,'first buy') over(partition by sname order by buydate) as prior_buy
,lead(buydate,1,'last buy') over(partition by sname order by buydate) as next_buy
from cost_fee;

结果：

+--------+------------+------------+------------+
| sname  | buydate    | prior_buy  | next_buy   |
+--------+------------+------------+------------+
| 张三   | 2019-01-01 | first buy  | 2019-02-05 |
| 张三   | 2019-02-05 | 2019-01-01 | 2019-03-03 |
| 张三   | 2019-03-03 | 2019-02-05 | last buy   |
| 李四   | 2019-01-07 | first buy  | 2019-02-02 |
| 李四   | 2019-02-02 | 2019-01-07 | 2019-03-04 |
| 李四   | 2019-03-04 | 2019-02-02 | last buy   |
| 王五   | 2019-01-11 | first buy  | 2019-02-09 |
| 王五   | 2019-02-09 | 2019-01-11 | 2019-03-08 |
| 王五   | 2019-03-08 | 2019-02-09 | last buy   |
| 赵六   | 2019-01-12 | first buy  | 2019-02-08 |
| 赵六   | 2019-02-08 | 2019-01-12 | 2019-03-10 |
| 赵六   | 2019-03-10 | 2019-02-08 | last buy   |
+--------+------------+------------+------------+

分布函数

举例说明一下分布函数的用法

好的。

代码：

select sname
,buydate
,buycost
,percent_rank() over(partition by sname order by buydate) as percentrank
,cume_dist() over(partition by sname order by buydate) as cumedist
from cost_fee;

结果：

+--------+------------+---------+-------------+--------------------+
| sname  | buydate    | buycost | percentrank | cumedist           |
+--------+------------+---------+-------------+--------------------+
| 张三   | 2019-01-01 |      10 |           0 | 0.3333333333333333 |
| 张三   | 2019-02-05 |      46 |         0.5 | 0.6666666666666666 |
| 张三   | 2019-03-03 |      23 |           1 |                  1 |
| 李四   | 2019-01-07 |      50 |           0 | 0.3333333333333333 |
| 李四   | 2019-02-02 |      15 |         0.5 | 0.6666666666666666 |
| 李四   | 2019-03-04 |      29 |           1 |                  1 |
| 王五   | 2019-01-11 |      75 |           0 | 0.3333333333333333 |
| 王五   | 2019-02-09 |      68 |         0.5 | 0.6666666666666666 |
| 王五   | 2019-03-08 |      62 |           1 |                  1 |
| 赵六   | 2019-01-12 |      80 |           0 | 0.3333333333333333 |
| 赵六   | 2019-02-08 |      55 |         0.5 | 0.6666666666666666 |
| 赵六   | 2019-03-10 |      12 |           1 |                  1 |
+--------+------------+---------+-------------+--------------------+

这里，每个分区的行数是3，我们看下法外狂徒张三的消费情况，这里percent_rank第一行是(rank-1)/(rows-1)，rows已经固定了是3，那么第一行就是(1-1)/(3-1)=0了，第二行就是(2-1)/(3-1)=0.5了，第三行就是(3-1)/(3-1)就是1了。

而just-dist第一行是1/3，第二行是2/3，第三行是3/3=1。

只是计算方式不一样而已。

《Tableau实战》项目文档

2024-04-03T03:40:26+00:00

数据下载

有些朋友下载的Tableau不自带示例数据，现提供下载：

sample superstore.xls文件下载：
https://www.aliyundrive.com/s/JewobAutZ5F

提取码：86jd

问题汇总

地图出不来｜ region字段的地理角色换成state怎么都变不成美国

各位地图出不来的朋友估计是因为国家没选美国，在菜单栏【地图-编辑位置-国家/地区】那里哦

软件一定要买吗？

可以用免费的tableau public做

颜色提取的工具是什么呢？

snipaste。可以直接在原工作表中选择更多颜色-添加到自定义颜色，就可以在我们的工作表中设置这个颜色了

拖动xxx无法复制

Tableau里拖动复制需要按住ctrl（windows用户）或command（mac用户）键的同时拖动才行哦

P10年份不太一样

@绿毛水怪____：第六节写了半天代码，结果发现数据源和up主的不一样，时间是从2015-2018。重新下载了up主文档中的数据源替换以后就解决问题了。

win系统没有显示包内容，要怎么保存呢

@热心网友：在安装目录下能找到一样的内容

请问P16讲中manufacturer字段是怎么创建哒，数据源里没有诶，作者也没有细讲分组和聚合的步骤

这个是根据产品名称进行分组得到的，

根据的是原作者的分组方式，选择该组的所有产品再点击「分组」，

取好分组名称，

依此类推，将所有类别分好组即可。

《MySQL实战》项目文档

2024-04-03T03:40:26+00:00

资料下载

数据集与kettle阿里云下载（是伪装成mp4格式的，因为阿里云不让分享压缩包，安装解码器后就可以分离出原文件了）：

https://www.aliyundrive.com/s/isM3tAFx5nk 提取码：l2e0

解码器下载：
1
https://pan.baidu.com/s/18prgug55xWsutQTV0B1q_A
提取码: 3v0p

注意事项

【留存情况】中11:35处，提醒了“这里漏了，上面那个表的temp_behavior也要改成原表user_behavior”
【商品按热度分类】中04:37处，order by后面的“品类商品浏览量”不能直接填上一行的别名，应该要填具体的共识，具体详情更正在了【数据可视化结果】中0:30处

数据集介绍

阿里云天池数据集: User Behavior Data from Taobao for Recommendation

字段	说明
User ID	整数类型，序列化后的用户ID
Item ID	整数类型，序列化后的商品ID
Category ID	整数类型，序列化后的商品所属类目ID
Behavior type	字符串，枚举类型，包括('pv', 'buy', 'cart', 'fav')
Timestamp	行为发生的时间戳

Behavior type	说明
pv	商品详情页pv，等价于点击
buy	商品购买
cart	将商品加入购物车
fav	收藏商品

kettle的安装

安装jdk8

Java开发工具包jdk

百度搜索 windows｜mac 安装jdk8

https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html

注意mac用户无论是intel还是苹果自家芯片都下载intel版的jdk8

一定是1.8版本的

安装kettle

百度搜索 windows｜mac 安装kettle

下载kettle

https://sourceforge.net/projects/pentaho/files/

下载mysql驱动mysql-connector-java

各版本下载地址：Maven Repository: mysql » mysql-connector-java (mvnrepository.com)

运行kettle

将mysql驱动(.jar文件)放在bin目录下
进入data-integration目录下命令行运行 spoon.sh

Mac M1报错，需要设置强制用intel模式运行 spoon.sh:

`1`	`arch -x86_64 ./spoon.sh`

Mac用户之包装成App

How to create simple Mac apps from shell scripts · Mathias Bynens

appify.sh文件：

#!/bin/bash

if [ "$1" = "-h" -o "$1" = "--help" -o -z "$1" ]; then cat <<EOF
appify v3.0.1 for Mac OS X - http://mths.be/appify
Creates the simplest possible Mac app from a shell script.
Appify takes a shell script as its first argument:
    `basename "$0"` my-script.sh
Note that you cannot rename appified apps. If you want to give your app
a custom name, use the second argument:
    `basename "$0"` my-script.sh "My App"
Copyright (c) Thomas Aylott <http://subtlegradient.com/>
Modified by Mathias Bynens <http://mathiasbynens.be/>
EOF
exit; fi

APPNAME=${2:-$(basename "$1" ".sh")}
DIR="$APPNAME.app/Contents/MacOS"

if [ -a "$APPNAME.app" ]; then
	echo "$PWD/$APPNAME.app already exists :("
	exit 1
fi

mkdir -p "$DIR"
cp "$1" "$DIR/$APPNAME"
chmod +x "$DIR/$APPNAME"

echo "$PWD/$APPNAME.app"

kettle.sh文件：

1
2
3

#!/bin/bash
cd ~/MySQL实战/data-integration
arch -x86_64 ./spoon.sh

然后

`1`	`appify kettle.sh "kettle"`

就形成了 kettle.app

可以用alfred查找快速打开（聚焦搜索🔍查找不到）

快速导入一亿条数据

数据库准备

create database taobao;
use taobao;

create table user_behavior (user_id int(9), item_id int(9), category_id int(9), behavior_type varchar(5), timestamp int(14) );

kettle配置

连接池100 最大空闲空间100 默认提交取消

参数配置

字段	值
useServerPrepStmts	false
useCompression	true
rewriteBatchedStatements	true

线程10-20个左右

数据预处理

use taobao;
desc user_behavior;
select * from user_behavior limit 5;

-- 改变字段名
alter table user_behavior change timestamp timestamps int(14);
desc user_behavior;

-- 检查空值 
select * from user_behavior where user_id is null;
select * from user_behavior where item_id is null;
select * from user_behavior where category_id is null;
select * from user_behavior where behavior_type is null;
select * from user_behavior where timestamps is null;

-- 检查重复值 
select user_id,item_id,timestamps from user_behavior
group by user_id,item_id,timestamps
having count(*)>1;

-- 去重 
alter table user_behavior add id int first;
select * from user_behavior limit 5;
alter table user_behavior modify id int primary key auto_increment;

delete user_behavior from
user_behavior,
(
select user_id,item_id,timestamps,min(id) id from user_behavior
group by user_id,item_id,timestamps
having count(*)>1
) t2
where user_behavior.user_id=t2.user_id
and user_behavior.item_id=t2.item_id
and user_behavior.timestamps=t2.timestamps
and user_behavior.id>t2.id;

-- 新增日期：date time hour
-- 更改buffer值
show VARIABLES like '%_buffer%';
set GLOBAL innodb_buffer_pool_size=1070000000;
-- datetime
alter table user_behavior add datetimes TIMESTAMP(0);
update user_behavior set datetimes=FROM_UNIXTIME(timestamps);
select * from user_behavior limit 5;
-- date
alter table user_behavior add dates char(10);
alter table user_behavior add times char(8);
alter table user_behavior add hours char(2);
-- update user_behavior set dates=substring(datetimes,1,10),times=substring(datetimes,12,8),hours=substring(datetimes,12,2);
update user_behavior set dates=substring(datetimes,1,10);
update user_behavior set times=substring(datetimes,12,8);
update user_behavior set hours=substring(datetimes,12,2);
select * from user_behavior limit 5;

-- 去异常 
select max(datetimes),min(datetimes) from user_behavior;
delete from user_behavior
where datetimes < '2017-11-25 00:00:00'
or datetimes > '2017-12-03 23:59:59';

-- 数据概览 
desc user_behavior;
select * from user_behavior limit 5;
SELECT count(1) from user_behavior; -- 100095496条记录

获客情况

-- 创建临时表 
create table temp_behavior like user_behavior;

-- 截取 
insert into temp_behavior
select * from user_behavior limit 100000;

select * from temp_behavior;

-- pv 
select dates
,count(*) 'pv'
from temp_behavior
where behavior_type='pv'
GROUP BY dates;
-- uv 
select dates
,count(distinct user_id) 'pv'
from temp_behavior
where behavior_type='pv'
GROUP BY dates;

-- 一条语句 
select dates
,count(*) 'pv'
,count(distinct user_id) 'uv'
,round(count(*)/count(distinct user_id),1) 'pv/uv'
from temp_behavior
where behavior_type='pv'
GROUP BY dates;

-- 处理真实数据 
create table pv_uv_puv (
dates char(10),
pv int(9),
uv int(9),
puv decimal(10,1)
);

insert into pv_uv_puv
select dates
,count(*) 'pv'
,count(distinct user_id) 'uv'
,round(count(*)/count(distinct user_id),1) 'pv/uv'
from user_behavior
where behavior_type='pv'
GROUP BY dates;

select * from pv_uv_puv

delete from pv_uv_puv where dates is null;

留存情况

select * from user_behavior where dates is null;
delete from user_behavior where dates is null;


select user_id,dates 
from temp_behavior
group by user_id,dates;

-- 自关联 
select * from 
(select user_id,dates 
from temp_behavior
group by user_id,dates
) a
,(select user_id,dates 
from temp_behavior
group by user_id,dates
) b
where a.user_id=b.user_id;

-- 筛选 
select * from 
(select user_id,dates 
from temp_behavior
group by user_id,dates
) a
,(select user_id,dates 
from temp_behavior
group by user_id,dates
) b
where a.user_id=b.user_id and a.dates<b.dates;

-- 留存数 
select a.dates
,count(if(datediff(b.dates,a.dates)=0,b.user_id,null)) retention_0
,count(if(datediff(b.dates,a.dates)=1,b.user_id,null)) retention_1
,count(if(datediff(b.dates,a.dates)=3,b.user_id,null)) retention_3 from

(select user_id,dates 
from temp_behavior
group by user_id,dates
) a
,(select user_id,dates 
from temp_behavior
group by user_id,dates
) b
where a.user_id=b.user_id and a.dates<=b.dates
group by a.dates

-- 留存率 
select a.dates
,count(if(datediff(b.dates,a.dates)=1,b.user_id,null))/count(if(datediff(b.dates,a.dates)=0,b.user_id,null)) retention_1
from
(select user_id,dates 
from temp_behavior
group by user_id,dates
) a
,(select user_id,dates 
from temp_behavior
group by user_id,dates
) b
where a.user_id=b.user_id and a.dates<=b.dates
group by a.dates

-- 保存结果 
create table retention_rate (
dates char(10),
retention_1 float 
);

insert into retention_rate 
select a.dates
,count(if(datediff(b.dates,a.dates)=1,b.user_id,null))/count(if(datediff(b.dates,a.dates)=0,b.user_id,null)) retention_1
from
(select user_id,dates 
-- from temp_behavior
-- 纠错，这里漏改为原表了
from user_behavior
group by user_id,dates
) a
,(select user_id,dates 
from user_behavior
group by user_id,dates
) b
where a.user_id=b.user_id and a.dates<=b.dates
group by a.dates

select * from retention_rate

-- 跳失率 
-- 跳失用户  -- 88
select count(*) 
from 
(
select user_id from user_behavior
group by user_id
having count(behavior_type)=1
) a


select sum(pv) from pv_uv_puv; -- 89660670

-- 88/89660670

时间序列分析

-- 统计日期-小时的行为
select dates,hours
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'

from temp_behavior
group by dates,hours
order by dates,hours

-- 存储 
create table date_hour_behavior(
dates char(10),
hours char(2),
pv int,
cart int,
fav int,
buy int);

-- 结果插入 
insert into date_hour_behavior
select dates,hours
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'

from user_behavior
group by dates,hours
order by dates,hours

select * from date_hour_behavior;

用户转化率分析

-- 统计各类行为用户数 
select behavior_type
,count(DISTINCT user_id) user_num
from temp_behavior
group by behavior_type
order by behavior_type desc;

-- 存储 
create table behavior_user_num(
behavior_type varchar(5),
user_num int);

insert into behavior_user_num
select behavior_type
,count(DISTINCT user_id) user_num
from user_behavior
group by behavior_type
order by behavior_type desc;

select * from behavior_user_num

select 672404/984105 -- 这段时间购买过商品的用户的比例

-- 统计各类行为的数量 
select behavior_type
,count(*) user_num
from temp_behavior
group by behavior_type
order by behavior_type desc;

-- 存储 
create table behavior_num(
behavior_type varchar(5),
behavior_count_num int);

insert into behavior_num
select behavior_type
,count(*) behavior_count_num
from user_behavior
group by behavior_type
order by behavior_type desc;

select * from behavior_num

select 2015807/89660670 -- 购买率 

select (2888255+5530446)/89660670 -- 收藏加购率

行为路径分析

select '难度增加'
drop view user_behavior_view
drop view user_behavior_standard
drop view user_behavior_path
drop view path_count 

create view user_behavior_view as
select user_id,item_id
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'
from temp_behavior
group by user_id,item_id

-- 用户行为标准化  
create view user_behavior_standard as
select user_id
,item_id
,(case when pv>0 then 1 else 0 end) 浏览了
,(case when fav>0 then 1 else 0 end) 收藏了
,(case when cart>0 then 1 else 0 end) 加购了
,(case when buy>0 then 1 else 0 end) 购买了
from user_behavior_view

-- 路径类型 

create view user_behavior_path as
select *,
concat(浏览了,收藏了,加购了,购买了) 购买路径类型
from user_behavior_standard as a
where a.购买了>0


-- 统计各类购买行为数量 
create view path_count as
select 购买路径类型
,count(*) 数量
from user_behavior_path
group by 购买路径类型
order by 数量 desc

-- 人话表
create table renhua(
path_type char(4),
description varchar(40));

insert into renhua 
values('0001','直接购买了'),
('1001','浏览后购买了'),
('0011','加购后购买了'),
('1011','浏览加购后购买了'),
('0101','收藏后购买了'),
('1101','浏览收藏后购买了'),
('0111','收藏加购后购买了'),
('1111','浏览收藏加购后购买了')

select * from renhua

select * from path_count p 
join renhua r 
on p.购买路径类型=r.path_type 
order by 数量 desc

-- 存储 
create table path_result(
path_type char(4),
description varchar(40),
num int);


create view user_behavior_view as
select user_id,item_id
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'
from user_behavior
group by user_id,item_id

-- 用户行为标准化  
create view user_behavior_standard as
select user_id
,item_id
,(case when pv>0 then 1 else 0 end) 浏览了
,(case when fav>0 then 1 else 0 end) 收藏了
,(case when cart>0 then 1 else 0 end) 加购了
,(case when buy>0 then 1 else 0 end) 购买了
from user_behavior_view

-- 路径类型 

create view user_behavior_path as
select *,
concat(浏览了,收藏了,加购了,购买了) 购买路径类型
from user_behavior_standard as a
where a.购买了>0


-- 统计各类购买行为数量 
create view path_count as
select 购买路径类型
,count(*) 数量
from user_behavior_path
group by 购买路径类型
order by 数量 desc


insert into path_result
select path_type,description,数量 from
path_count p 
join renhua r 
on p.购买路径类型=r.path_type 
order by 数量 desc

select * from path_result

select sum(buy)
from user_behavior_view
where buy>0 and fav=0 and cart=0

 -- 1528016
 
 select 2015807-1528016 -- 487791
 
 select 487791/(2888255+5530446)

RFM模型

-- 最近购买时间 
select user_id
,max(dates) '最近购买时间'
from temp_behavior
where behavior_type='buy'
group by user_id
order by 2 desc;

-- 购买次数 
select user_id
,count(user_id) '购买次数'
from temp_behavior
where behavior_type='buy'
group by user_id
order by 2 desc;

-- 统一 
select user_id
,count(user_id) '购买次数'
,max(dates) '最近购买时间'
from user_behavior
where behavior_type='buy'
group by user_id
order by 2 desc,3 desc;

-- 存储
drop table if exists rfm_model;
create table rfm_model(
user_id int,
frequency int,
recent char(10)
);

insert into rfm_model
select user_id
,count(user_id) '购买次数'
,max(dates) '最近购买时间'
from user_behavior
where behavior_type='buy'
group by user_id
order by 2 desc,3 desc;

-- 根据购买次数对用户进行分层 
alter table rfm_model add column fscore int;

update rfm_model
set fscore = case
when frequency between 100 and 262 then 5
when frequency between 50 and 99 then 4
when frequency between 20 and 49 then 3
when frequency between 5 and 20 then 2
else 1
end

-- 根据最近购买时间对用户进行分层 
alter table rfm_model add column rscore int;

update rfm_model
set rscore = case
when recent = '2017-12-03' then 5
when recent in ('2017-12-01','2017-12-02') then 4
when recent in ('2017-11-29','2017-11-30') then 3
when recent in ('2017-11-27','2017-11-28') then 2
else 1
end

select * from rfm_model

-- 分层
set @f_avg=null;
set @r_avg=null;
select avg(fscore) into @f_avg from rfm_model;
select avg(rscore) into @r_avg from rfm_model;

select *
,(case
when fscore>@f_avg and rscore>@r_avg then '价值用户'
when fscore>@f_avg and rscore<@r_avg then '保持用户'
when fscore<@f_avg and rscore>@r_avg then '发展用户'
when fscore<@f_avg and rscore<@r_avg then '挽留用户'
end) class
from rfm_model

-- 插入
alter table rfm_model add column class varchar(40);
update rfm_model
set class = case
when fscore>@f_avg and rscore>@r_avg then '价值用户'
when fscore>@f_avg and rscore<@r_avg then '保持用户'
when fscore<@f_avg and rscore>@r_avg then '发展用户'
when fscore<@f_avg and rscore<@r_avg then '挽留用户'
end


-- 统计各分区用户数
select class,count(user_id) from rfm_model
group by class

商品按热度分类

-- 统计商品的热门品类、热门商品、热门品类热门商品
select category_id
,count(if(behavior_type='pv',behavior_type,null)) '品类浏览量'
from temp_behavior
GROUP BY category_id
order by 2 desc
limit 10

select item_id
,count(if(behavior_type='pv',behavior_type,null)) '商品浏览量'
from temp_behavior
GROUP BY item_id
order by 2 desc
limit 10

select category_id,item_id,
品类商品浏览量 from
(
select category_id,item_id
,count(if(behavior_type='pv',behavior_type,null)) '品类商品浏览量'
-- ,rank()over(partition by category_id order by '品类商品浏览量' desc) r
-- 纠错，'品类商品浏览量'这里不能指代count(if(behavior_type='pv',behavior_type,null))因为还没返回
,rank()over(partition by category_id order by count(if(behavior_type='pv',behavior_type,null)) desc) r
from temp_behavior
GROUP BY category_id,item_id
order by 3 desc
) a
where a.r = 1
order by a.品类商品浏览量 desc
limit 10

-- 存储 

create table popular_categories(
category_id int,
pv int);
create table popular_items(
item_id int,
pv int);
create table popular_cateitems(
category_id int,
item_id int,
pv int);


insert into popular_categories
select category_id
,count(if(behavior_type='pv',behavior_type,null)) '品类浏览量'
from user_behavior
GROUP BY category_id
order by 2 desc
limit 10;


insert into popular_items
select item_id
,count(if(behavior_type='pv',behavior_type,null)) '商品浏览量'
from user_behavior
GROUP BY item_id
order by 2 desc
limit 10;

insert into popular_cateitems
select category_id,item_id,
品类商品浏览量 from
(
select category_id,item_id
,count(if(behavior_type='pv',behavior_type,null)) '品类商品浏览量'
,rank()over(partition by category_id order by '品类商品浏览量' desc) r
from user_behavior
GROUP BY category_id,item_id
order by 3 desc
) a
where a.r = 1
order by a.品类商品浏览量 desc
limit 10


select * from popular_categories;
select * from popular_items;
select * from popular_cateitems;

商品转化率分析

-- 特定商品转化率
select item_id
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'
,count(distinct if(behavior_type='buy',user_id,null))/count(distinct user_id) 商品转化率
from temp_behavior
group by item_id
order by 商品转化率 desc


-- 保存 
create table item_detail(
item_id int,
pv int,
fav int,
cart int,
buy int,
user_buy_rate float);

insert into item_detail
select item_id
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'
,count(distinct if(behavior_type='buy',user_id,null))/count(distinct user_id) 商品转化率
from user_behavior
group by item_id
order by 商品转化率 desc;

select * from item_detail;

-- 品类转化率 

create table category_detail(
category_id int,
pv int,
fav int,
cart int,
buy int,
user_buy_rate float);

insert into category_detail
select category_id
,count(if(behavior_type='pv',behavior_type,null)) 'pv'
,count(if(behavior_type='fav',behavior_type,null)) 'fav'
,count(if(behavior_type='cart',behavior_type,null)) 'cart'
,count(if(behavior_type='buy',behavior_type,null)) 'buy'
,count(distinct if(behavior_type='buy',user_id,null))/count(distinct user_id) 品类转化率
from user_behavior
group by category_id
order by 品类转化率 desc;

select * from category_detail;

没有努力，生活就会失去秩序

2024-04-03T03:40:26+00:00

薛定谔在《生命是什么》里说过一句话：

人活着就是在对抗熵增定律，生命以负熵为生。

那什么是熵增定律呢？

其定义是：

在一个孤立系统里，如果没有外力做功，其总混乱度（即熵）会不断增大。

简单理解，「熵」就是一种对混乱程度的刻画，定义的意思是说如果没有外界干扰的情况下，任何一个东西的混乱程度都是逐渐增加的。

底层原理可以这样理解，物质是由原子、分子、离子等微粒组成，而它们都有热运动，即都在不停地做无规则的运动。想象一下，我们在沙滩建沙雕，沙雕作为有序形式只是沙粒排列的少有状态，而沙子的绝大多数其他排列方式都是散乱的。当我们建好沙雕，不久后会发现沙雕不见了，回到了最大可能的状态——一盘散沙。因为风、海浪让沙粒的随机运动不太会将无序的沙子变成沙雕，却可以很容易地将沙雕变成一盘散沙。

要想建立与维持沙雕，需要我们的努力，这也就是标题说的「没有努力，生活就会失去秩序」。企业如果不精心管理，就会被淘汰；房间如果不定期收拾，就会变乱；吃早餐如果不留心，就会打翻牛奶；人如果不吃饭，就会饿死……这是一个令人沮丧的定律。

但好消息是，我们可以抵抗熵增，而这正是生命的意义。史蒂芬·平克说过一句话——「生命、思想和人类奋斗的最终目的是：利用能量和信息来对抗熵增，开辟有益秩序的庇护所。」

下面从熵的角度思考我们的生活。

日常生活面临的情况可以分成身体的熵增和精神的增熵。

而身体的熵减是通过帮助身体正确行使其功能而达成的。例如运动、健康的饮食与作息等。早上起来，刷牙洗脸时通过去除牙齿上的菌膜与脸上的尘垢，有利于身体功能的正常行使，降低的是身体的熵。当然代价是提高环境的熵，例如干净的水变脏了。几乎所有健康的生活方式都是对应着减少身体的熵，如体育锻炼等。吃饭吃的其实是富有秩序的有机物的负熵，以抵消身体的熵增，最后将有机物变成了熵值大得多的无机物，排出体外。

对于古代人，获取能量以抵御身体的熵增（饿死）是几乎所有的工作。但对于现代人，精神的熵增是目前面临的更重大的考验。

人的行为受欲望驱使，欲望没满足前是痛苦的，而如果满足了又会感觉无聊，然后又催生新的更多的欲望，这是自然选择带给我们的困境。在如今信息化社会，整个社会系统是极其复杂而且日趋复杂，我们生活在其中，只会加剧这种看似有序实则无序的状态。

人如果不做什么，就会感觉无聊，人如果要做什么，就需要有欲望，而人如果欲望太多，又会感觉痛苦。无聊恰恰是精神熵值大的状态。哪怕是已经财务自由的人，也不得不找点事做，特别是有目标感的事做，否则精神熵的增加会让他受不了。但欲望太多而导致痛苦恰恰也是精神熵值大的状态。

也就是说，无聊与痛苦都是精神熵大的状态。而与之对应，人在两种状态下精神熵最低，一是无欲望却能不无聊，也就是佛教追求的那种境界——内心平静又充实。二是专注于基于单一欲望的目标的行动上，特别是如果处于忘却欲望的状态——心流时，可以极大地降低精神熵。对于大多数人，我们要追求的是——管理自己的欲望及其衍生的目标，简化它，然后全身心投入为实现自己的目标的行动中，这个状态是精神熵最低的。这样看，其实有事做的人更容易幸福与满足，它体现了生命以负熵为食的本质。

综上，佛家的六根清净以及俗人的专注做事精神熵最低。可以把它看成是牛顿第一定律——在无外力的情况下，任何物体都会保持静止或匀速直线运动状态。佛家追求的是静止状态，我们俗人追求的是匀速直线运动。

冥想实际上是抑制了只要不结构化思考大脑就会进入的默认模式网络的无序带来的熵增，它靠给大脑一个清晰的目标——专注呼吸来降低精神熵。相比而言，行动时大脑的熵其实大多是降低了的，特别是目标极其明确的行动，可以说，目标明确的行动就相当于在冥想，其最高境界是达到心流状态，此时就是身体的冥想巅峰状态。行动比不行动更有利于降低熵值，因为行动更容易指向一个清晰的目标，而由于大脑的不可控性，无事可做时指向一个清晰的目标是非常难的，这也是为什么冥想有效的原因之一，它以行动的模式（专注呼吸）防止大脑在无事可做时变得无序。

写作也是指向清晰的目标，有利于整理大脑思绪，降低精神的熵。

下面思考的是——手机增加还是降低了人的精神熵？

从宏观上看，整体上似乎是提高了人的精神熵的，为什么？因为它们养活了一个极其庞大的母体——手机生产商及其供应链以及周边产业（以下简称手机商）。从这个角度看，手机商是有生命的，它们也要靠负熵为食，其熵源就是广大手机使用者的精神熵，手机商靠吸食手机使用者的精神熵为生。当然，这个论断非常不严谨，因为这并不是个孤立系统。

从生命质量的角度看，多半人在拥有手机和丢掉手机无疑后者能提供更高的生命质量，但对于另一部分人来说，把手机当成工具而非娱乐设备的人来说，手机的恰当使用却是有利于降低他们的精神熵的。例如笔记与提醒系统降低大脑负担、互联网的加持下办公的效率大大增加、能将繁琐的日常生活简化等。

睡眠是人的一天中无论是精神熵还是身体熵都大大降低的行为。它靠对大脑记忆进行整理与身体修复来完成。

我们的生命的意义甚至存在本身就是要尽可能得减少熵，放纵、浪费时间、放任熵增的行为都愧于生命体存在的本质，过多则会被熵增逐渐杀死、淘汰。

微博账号分析

2024-04-03T03:40:26+00:00

以下对微博上一位大V进行内容爬取与分析。

数据获取

首先安装Python的微博爬虫包：

`1`	`pip install weibo_spider`

然后在一个目录中初次执行：

`1`	`python -m weibo_spider`

会在当前目录下生成config.json配置文件。新建user_id_list.txt文件，按照README.md填写config.json和user_id_list.txt相应参数。

进行相关配置后（用MySQL数据库承接爬取的数据），再次运行

`1`	`python -m weibo_spider`

开始爬虫。

数据概览

该爬虫脚本会在MySQL数据库中新建一个叫做weibo的数据库，并建立两张表，user表和weibo表，分别存放用户信息和内容信息。

mysql> use weibo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+-----------------+
| Tables_in_weibo |
+-----------------+
| user            |
| weibo           |
+-----------------+
2 rows in set (0.00 sec)

user表字段如下：

mysql> desc user;
+-----------------+--------------+------+-----+---------+-------+
| Field           | Type         | Null | Key | Default | Extra |
+-----------------+--------------+------+-----+---------+-------+
| id              | varchar(20)  | NO   | PRI | NULL    |       |
| nickname        | varchar(30)  | YES  |     | NULL    |       |
| gender          | varchar(10)  | YES  |     | NULL    |       |
| location        | varchar(200) | YES  |     | NULL    |       |
| birthday        | varchar(40)  | YES  |     | NULL    |       |
| description     | varchar(400) | YES  |     | NULL    |       |
| verified_reason | varchar(140) | YES  |     | NULL    |       |
| talent          | varchar(200) | YES  |     | NULL    |       |
| education       | varchar(200) | YES  |     | NULL    |       |
| work            | varchar(200) | YES  |     | NULL    |       |
| weibo_num       | int          | YES  |     | NULL    |       |
| following       | int          | YES  |     | NULL    |       |
| followers       | int          | YES  |     | NULL    |       |
+-----------------+--------------+------+-----+---------+-------+
13 rows in set (0.01 sec)

weibo表内容如下：

mysql> desc weibo;
+-------------------+---------------+------+-----+---------+-------+
| Field             | Type          | Null | Key | Default | Extra |
+-------------------+---------------+------+-----+---------+-------+
| id                | varchar(10)   | NO   | PRI | NULL    |       |
| user_id           | varchar(12)   | YES  |     | NULL    |       |
| content           | varchar(5000) | YES  |     | NULL    |       |
| article_url       | varchar(200)  | YES  |     | NULL    |       |
| original_pictures | varchar(3000) | YES  |     | NULL    |       |
| retweet_pictures  | varchar(3000) | YES  |     | NULL    |       |
| original          | tinyint(1)    | NO   |     | 1       |       |
| video_url         | varchar(300)  | YES  |     | NULL    |       |
| publish_place     | varchar(100)  | YES  |     | NULL    |       |
| publish_time      | datetime      | NO   |     | NULL    |       |
| publish_tool      | varchar(30)   | YES  |     | NULL    |       |
| up_num            | int           | NO   |     | NULL    |       |
| retweet_num       | int           | NO   |     | NULL    |       |
| comment_num       | int           | NO   |     | NULL    |       |
+-------------------+---------------+------+-----+---------+-------+
14 rows in set (0.00 sec)

我们来看下该博主的出生日、性别和粉丝数：

mysql> select birthday,gender,followers from user;
+------------+--------+-----------+
| birthday   | gender | followers |
+------------+--------+-----------+
| 1986-10-01 | 女     |     41000 |
+------------+--------+-----------+
1 row in set (0.00 sec)

内容表weibo里，id是内容id，user_id对应user表的id。

发布的微博总数：

mysql> select count(*) from weibo;
+----------+
| count(*) |
+----------+
|      941 |
+----------+
1 row in set (0.00 sec)

最早发布的微博日期：

mysql> select min(publish_time) from weibo;
+---------------------+
| min(publish_time)   |
+---------------------+
| 2021-11-12 11:47:00 |
+---------------------+
1 row in set (0.00 sec)

最近发布的微博日期：

mysql> select max(publish_time) from weibo;
+---------------------+
| max(publish_time)   |
+---------------------+
| 2022-02-16 09:53:00 |
+---------------------+
1 row in set (0.00 sec)

也就是说，该账号注册于2021年11月12日，这里爬取到的是2021年11月12日到2022年2月16日的微博。

数据分析

用Tableau连接MySQL。首先，分析发微博数量随日期的变化。由于点赞、评价、转发都是对应单个微博的数据，而一天中可能发布里多条微博，因此需要创建计算字段，获得聚合点赞、评价和转发的度量值。

结果如上，可以得出两个猜测：

该用户在上线日平均发微博数量为12条，为非常活跃的用户。
该用户2021年12月5日左右被禁言了，12月21日取消禁言，大致禁言2周。
该用户为期两周后回来的第一天发微博次数只比平均值高一点，但点赞、评论和转发数量均非常高，可见其粉丝非常想念他。
该用户2022年2月5日至2月16日，均被限制转发了。

翻开该用户微博证实，其确实在12月5日或6日左右被禁言了，确实是在12月21日左右被解封了，而且其解封后的第一条微博下有大量粉丝留言，这点可以从数据上印证：

mysql> select publish_time,up_num,comment_num,retweet_num from weibo order by comment_num desc limit 1;
+---------------------+--------+-------------+-------------+
| publish_time        | up_num | comment_num | retweet_num |
+---------------------+--------+-------------+-------------+
| 2021-12-21 01:35:00 |   2127 |        1144 |          15 |
+---------------------+--------+-------------+-------------+
1 row in set (0.00 sec)

确实该火热的微博是解封当天的，好一出失而复得。

确实该博主也说了自己的微博已经被限制转发了。

该用户是何许人也？为何在短短3个月就获得4万多粉丝，而且与粉丝的互动极好，极具威望？其单日获赞平均数量达到了3831个，评论数达到了1209个，转发数达到了128个，即便是在日均12条微博下也是非常活跃的。

这位博主是外国人吗？

从发微博时段看应该不是：

非常标准的作息，猜测这位博主大概平均1点睡觉，7点半起床。

是上班族吗？

不太是，因为每天都发布大量微博，且均集中在一天中的工作时间。

再看看工作日分布：

周日和周一发得最少，周二和周四发得最多，而且相差不大。

从发布方式上看，使用的手机是iPhone13 pro，weibo.com发布可以看作是从电脑端发出的，其余的可以看出是手机发出的。

这些都不如内容重要。

其微博文本原数据如下：

可见，这位博主仅在发微博这一方面单日产出了大量的文字，也可以推测出该博主很有话说，且不属于摄影等之类的博主。

要想最快看出这位博主是做什么的，可以通过词云图来看。

用Python连接数据库，进行数据预处理：

import pandas as pd
from sqlalchemy import create_engine

# 初始化数据库连接
# 按实际情况依次填写MySQL的用户名、密码、IP地址、端口、数据库名
engine = create_engine("mysql+pymysql://{}:{}@{}:{}/{}")

# MySQL导入DataFrame
# 填写自己所需的SQL语句，可以是复杂的查询语句
sql_query = 'select content from weibo;'
# 使用pandas的read_sql_query函数执行SQL语句，并存入DataFrame
df_read = pd.read_sql_query(sql_query, engine)

# 初步去除无意义的符号：ASCII空白字符
clean_list = "".join(list(df_read['content'])).split('\xa0')
f = "".join(clean_list)

# 中文词频统计
from wordcloud import WordCloud
from collections import Counter
import jieba

dele = {'。','！','？','的','“','”','（','）',' ','》','《','，', '...', '原图', '全文', '微博', '转发', '组图', '视频'}
words = jieba.lcut(f)
articleDict = {}
articleSet = set(words)-dele

for w in articleSet:
    if len(w)>1:
        articleDict[w] = words.count(w)

articlelist = sorted(articleDict.items(),key = lambda x:x[1], reverse = True)
top500 = pd.DataFrame(articlelist[0:500],columns=['词语','词频'])
top500.to_csv('词频统计.csv',index=False)
top500

将该数据导入Tableau，先用该数据制作气泡图

第一步是将词语拖动到文本：

然后将词频拖给大小，

将形状改为文本，并将词语拖动到颜色，用离散的颜色区分即可。

可见，该博主主要关注的是性别方面（男人、女人、女性、女权、孩子、离婚），以及国家政策层面（中国、社会、就是、没有），这500个词涵盖的维度很多，属于知识面很广的博主了。

力量训练+有氧运动

2024-04-03T03:40:26+00:00

如果你是年轻人，而且时间精力有限，只能从以上四种锻炼方式选两种，你会选哪两个？

我的选择是「力量训练+有氧运动」。

首先，为了尽量全面发展，应该选择有氧+无氧的组合。

其次，力量训练和徒手训练都属于无氧训练，但力量训练相比徒手训练，在训练强度上能更好地实现负荷渐进，强度足够大，效率高，而徒手训练在训练强度上很容易达到天花板；有氧运动与瑜伽都属于有氧训练，但瑜伽相比普遍的有氧运动强度太低，主攻柔韧性，对心肺能力的提升非常有限。

最后，在雷达图上，「力量训练+有氧运动」恰好是两个强度大训练效果好但“偏科”的锻炼方式的组合，能实现非常大的「效果面积」。

什么？这样柔韧度的提升非常有限？

放弃柔韧度，就能获得单位时间最大的力量、围度、心肺、耐力的提升。放弃能产生力量。如果一天有2小时的锻炼时间，若无其他必要，应该全用在「力量训练+有氧运动」上。

实际上，在科学性上这方面最具权威的指南之一的《美国居民身体活动指南》，对18-64岁的人给出的运动建议如下：

All adults should avoid inactivity. Some physical activity is better than none, and adults who participate in any amount of physical activity gain some health benefits.

For substantial health benefits, adults should do at least 150 minutes (2 hours and 30 minutes) a week of moderate-intensity, or 75 minutes (1 hour and 15 minutes) a week of vigorous-intensity aerobic physical activity, or an equivalent combination of moderate- and vigorous-intensity aerobic activity. Aerobic activity should be performed in episodes of at least 10 minutes, and preferably, it should be spread throughout the week.

For additional and more extensive health benefits, adults should increase their aerobic physical activity to 300 minutes (5 hours) a week of moderate-intensity, or 150 minutes a week of vigorous-intensity aerobic physical activity, or an equivalent combination of moderate- and vigorous-intensity activity. Additional health benefits are gained by engaging in physical activity beyond this amount.

Adults should also include muscle-strengthening activities that involve all major muscle groups on 2 or more days a week.²³

推荐的正好也是中等或高强度的有氧运动和力量训练的组合，看来「力量训练+有氧运动」的意义很大，受此启发，我用 Echarts 做了一个日历热力图，将力量训练和有氧运动的记录同时可视化出来，给自己些仪式感。「力量训练+有氧运动」，如此美妙的组合，人生值得拥有。

之前还用APP记录了跑步三年（2018.08.26-2021.08.27），正好1000km。

源于：【卓叔】你还在迷信徒手训练吗？【增重答疑03】_哔哩哔哩_bilibili ↩︎
http://health.gov/dietaryguidelines/2015/guidelines/ ↩︎
也可参考中国营养学会翻译的《美国居民膳食指南（2015-2020）》附录1，由于禁止复制该书内容，故直接给出英文原文。 ↩︎

为什么会有「她喜欢我」的错觉？

2024-04-03T03:40:26+00:00

被称为人生三大错觉之一的「她喜欢我」给无数的男同胞带来了很多苦恼，看了一本叫《进化心理学》的书后，我才明白其中的道理。

这个心理机制，其实是在进化机制下被刻印在男性基因里的。有证据表明男性在一个女性对一个男性微笑时，男性观察者往往比女性观察者更倾向于认为该女性对那个男性有兴趣。因为对男性来说，在这种心理机制下，高估女性的性意图能够带来更多的繁衍机会，哪怕错误也损失有限，但正确则收益很大，自然选择下该心理机制成为人类男性的标配。

这个角度的更专业全面的解释就要用到统计学了：

错误管理理论(error management theory)从进化心理学出发对性误解现象进行了解释，该理论认为个体所做推断的价值取决于其是否有利于生存和繁衍。在长期进化的过程中，个体会保存有利于自身繁衍的认知，而逐渐削弱代价过高或收益过低的认知。个体在不确定情境下做出判断时，一般会出现两种错误(Haselton & Buss, 2000)，第一类错误是假阳性错误(false positive)，即将友好知觉为性兴趣；第二类错误是假阴性错误(false negative)，即将性兴趣知觉为友好(Kohl& &Robertson, 2014)，在进化心理学中这两种错误对男女两性而言所带来的收益及所要付出的代价不同。对于男性而言,其想要尽可能地传递自身基因增大繁殖机会，只需争取更多的性伴侣即可，因此男性会通过高估女性的性意图来获益。而对于女性而言,其繁衍后代需要经过怀孕期与哺乳期，在此期间不能有其他伴侣，大量的时间与资源要耗费在照顾后代上，因此女性会通过低估男性的性意图来避免付出代价。¹

也就是说，男性对推断性意图的阈值更低，只要女性稍微友好一点，不经意间透露出某种关心之类，男性都会视为“她喜欢我”。

因此，作为男性，通过学习知道了自己脑子里天然存在这种心理机制下，就可以利用该知识减少错误推断性意图带来的“她喜欢我”的错觉了。一女性好像在盯着你看，别自恋，她很可能是觉得你很奇怪，心理想的可能是“这人怕不是脑子有问题吧”、“他好像一条狗”等等，这时候别胡思乱想，直接怼一句“你瞅啥？”了事；一女性让你晚上送她回家，别自作多情，她很可能只是单纯怕黑而已，与喜不喜欢你无关；一女性加你微信后发了很多自拍在朋友圈，别想太多，她很可能只是日常在有意无意地利用互联网放大颜值对配偶选择范围的加成而已。总之，千万不要胡思乱想，该咋地咋地。但要注意，这是为了减少错误推断，别用力过猛而全盘否定，否则注孤生（此为免责声明）。

以上说明的是男性会高估女性的性意图，会倾向于误解女性喜欢自己。然而，实际上女性是怎样评估他的呢？Christian Rudder在其书《Dataclysm》中，分析了美国最大的线上约会相亲网站之一 Okcupid 上男性和女性对异性的吸引力评分。

数据显示男性对女性对吸引力评分大致呈正态分布，分布比较均匀，认为吸引力最低和最高的都大致有6%左右。

但女性对男性的吸引力评分就非常不均匀了，而且可以看出明显二八分布——80%的男性都被评为低吸引力，能被女性认为是优质的高吸引力的男性比例非常低。

作者指出，互联网时代没有太影响男性对女性的期望，男性对女性的吸引力评价依然整体偏高且均匀，而女性对男性的吸引力评价则整体偏低。

所以综合二者看，现实非常冰冷：大多数男性都在意淫，认为女性喜欢自己，但实际上他对于女性而言根本没有多少吸引力。

https://doi.org/10.1016/j.paid.2015.12.027 ↩︎
Dataclysm who we are (when we think no one’s looking) by Christian Rudder, P17. ↩︎

口腔溃疡的解法

2024-04-03T03:40:26+00:00

口腔溃疡这个疾病虽然非常常见，但我们对它的认识仍然十分有限，只是概括了一大堆可能的致病因素，如柑桔类水果、口腔物理创伤、急速减肥、食物过敏、免疫反应、缺乏相关维生素等¹。治疗上也没有特效药，一般是等待它七至十四天自行痊愈。

如果是我们外面的皮肤因为某些原因破了，它会通过流血并凝固堵住伤口，防止病菌乘机攻入，从而为人体修复伤口创造良好条件。但口腔粘膜有点特殊，它是一个湿润的环境而且本身细菌众多，一旦形成溃烂点，恶性的修复环境让人体难以很快修复，一般会继续恶化一段时间，使得看似简单的小免疫战却一直拖了一两周才结束，而且还反反复复。常驻皮肤的免疫军一直都很鄙视口腔粘膜的免疫军，认为它们办事拖拉，实际上它们已经很努力了、有自己的苦衷。

由于我们对该疾病的认识非常有限，目前根本没发明出通过了双盲临床对照试验的特效药，这个复杂问题的解决，完全只能依靠人体的自愈能力（大多疾病都是如此），而我们能做的关键在于为溃烂处创造良好的修复环境。

所以我依据这个思路，在淘宝上找到一款“药品”，正好满足了我的需求：

涂后会在伤口上形成一层油性保护膜，保证唾液、水等不破坏伤口。

贴上后还是很牢固的！吃东西、喝水都不会掉下来！

我试了下，果然溃疡愈合速度快了好多，以前要七至十天才能愈合的溃疡用它辅助只要四五天，而且还减轻了疼痛。

缺点是有点贵，其溢价的地方在于用保健品的思路来卖产品：

主要成分是紫根精华，可以促进创口愈合。另外一个主要的成分是甘草次酸。

实际上，根本就没有实验证明了它们对加速溃疡愈合有效果，有99.9%的概率是完全靠人体自身的修复能力完成的（而且完全足够）。如果不怕麻烦，完全可以自己用例如凡士林之类的无毒油性密封类原料做成像它那样的贴纸堵住溃疡处防止与唾液接触就行。

22.08.11更新：

与医生朋友交流后得知，有个叫做「蜂胶口腔溃疡贴」的东西也能起到同样的作用，价格还很便宜。如果想要好得更快，可以注射地塞米松。

口腔溃疡 - 维基百科，自由的百科全书 (wikipedia.org) ↩︎

Numpy中axis参数的理解

2024-04-03T03:40:26+00:00

要点：

Numpy 中 axis=i 中的 i 代表的轴不固定，不同维度编排不同，可以把它看成是种由外向内的编排方式
Numpy 中 axis=i 中的 i 表示数组索引的第 i+1 层
axis=i 即沿着 i 轴方向进行相应操作
axis=i 即对索引的第 i+1 层元素进行相应操作

道生一，一生二，二生三，三生万物。

——《道德经》

先从一维开始。

In [1]: import numpy as np

In [2]: d1 = np.array([1,2,3])

In [3]: d1
Out[3]: array([1, 2, 3])

因为只有一个维度，该数组的排列方向就是 axis=0 的方向。

在一维的基础上，增加一个维度，变成一个二维数组。

In [4]: d2 = np.array([[1,2,3],[4,5,6]])

In [5]: d2
Out[5]: 
array([[1, 2, 3],
       [4, 5, 6]])

对于二维数组，Numpy 把新增加的这个维度编在前面即 axis=0，而把原来的低维度编在后面即 axis=1。对初学者而言，困惑就在这里，我们在小学学习一维坐标系时，它的名称为「x轴」；学习到二维坐标系时，原来的x轴还叫 x，只是增加了一个「y轴」；之后三维是「z轴」。而 Numpy 这是要重新编号的，这也就是要点1：

1.Numpy 中 axis=i 中的 i 代表的轴不固定，不同维度编排不同，可以把它看成是种由外向内的编排方式

在二维的基础上，增加一个维度，变成一个三维数组。

In [6]: d3 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])

In [7]: d3
Out[7]: 
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

根据要点1，新来的轴优先，设为 axis=0，于是原来的 axis=0 变成了 axis=1 了，axis=1 的变成了 axis=2。类比我们学习的空间坐标系，第三维相当于与「xy平面」垂直的「z轴」，我们在其方向上堆砌二维数据。（参考资料3的第三维的数据堆砌反了，导致后面的数据排列有问题）

对于三维以上的数组同理。总之，axis 的编号是由外向内的。

为什么 axis 这样编排？可能它本身就是从数组索引层级命名的。

对于任意维度 m 的数组A，其 m 维度里的第一个数组是 A[0]，第二个是A[1]等等，它们都是最高维度「m维」内的数组，即数组索引的第一个值对应的正是最高维度的轴的元素（也就是上面说的相对低维轴的新加的轴）；A[0]里的第一个数组是A[0][0]，第二个是A[0][1]等等，即数组索引的第二个值对应的是次高维度的轴的元素，依此类推。于是我们有了要点2：

2.Numpy 中 axis=i 中的 i 表示数组索引的第 i+1 层

例如上面的例子中，三维数组d3的第一层索引对应的就是 axis=0，d3[1]取的就是其第二个元素，是个二维数组。

In [7]: d3
Out[7]: 
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [8]: d3[0]
Out[8]: 
array([[ 7,  8,  9],
       [10, 11, 12]])

于是，我们可以指定不同的轴对数据进行操作，在空间几何角度也就是要点3：

3.axis=i 即沿着 i 轴方向进行相应操作

对于二维数组，设 axis=0 就是沿着竖直方向进行相应操作，axis=1 是沿着水平方向进行操作。

In [9]: d2
Out[9]: 
array([[1, 2, 3],
       [4, 5, 6]])

In [10]: d2.sum(axis=0)
Out[10]: array([5, 7, 9])

对于三维数组，设 axis=0 就是沿着垂直方向进行相应操作。

In [11]: d3
Out[11]: 
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [12]: d3.sum(axis=0)
Out[12]: 
array([[ 8, 10, 12],
       [14, 16, 18]])

设 axis=1 就是沿着竖直方向进行相应操作。

In [13]: d3
Out[13]: 
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [14]: d3.sum(axis=1)
Out[14]: 
array([[ 5,  7,  9],
       [17, 19, 21]])

注意距离原点更近的数据层排在前（[ 5, 7, 9]），越上面的排在越后（[17, 19, 21]），组合为[[ 5, 7, 9],[17, 19, 21]]，与计算结果一致。

axis=2 同理。

指定不同的轴对数据进行操作，在解析几何角度也就是要点4：

4.axis=i 即对索引的第 i+1 层元素进行相应操作

对于三维数组，axis=0 就是对第一层索引元素进行对应操作，例如sum函数就是将第一层的所有元素的值对应相加。

axis=1 就是对第二层索引元素进行对应操作。

axis=2 就是对第三层索引元素进行对应操作。

参考资料：

Sqlzoo练习笔记

2024-04-03T03:40:26+00:00

前置课程

未明学院的《SQL零基础教程》

sqlzoo官网

https://sqlzoo.net/

文字样式匹配查询

https://sqlzoo.net/wiki/SELECT_names

15.For Monaco-Ville the name is Monaco and the extension is -Ville.

Show the name and the extension where the capital is an extension of name of the country.

方法一：REPLACE函数。

SELECT w.name, REPLACE(w.capital, w.name, '')
FROM world AS w
WHERE w.capital LIKE concat('%', w.name, '%')
AND w.capital != w.name

1
2
3

SELECT name,REPLACE(capital,name,'') AS extension
FROM world
WHERE capital Like CONCAT(name, '_%')

方法二：截取字符串

SELECT w.name, RIGHT(w.capital, length(w.capital)-length(w.name))
FROM world AS w
WHERE w.capital LIKE concat('%', w.name, '%')
AND w.capital != w.name

Nobel表查询

https://sqlzoo.net/wiki/SELECT_from_Nobel_Tutorial

14.The expression subject IN ('Chemistry','Physics') can be used as a value - it will be 0 or 1.

Show the 1984 winners and subject ordered by subject and winner name; but list Chemistry and Physics last.

SELECT winner, subject
FROM nobel
WHERE yr = 1984
ORDER BY subject IN ('Chemistry','Physics'), subject, winner

subject IN ('Chemistry','Physics')是一个逻辑判断，输出0和1，也可以作为排序的依据，这样物理和化学的就输出1排在最后了。

winner	subject	subject IN ('Chemistry','Physics')
Richard Stone	Economics	0
Jaroslav Seifert	Literature	0
César Milstein	Medicine	0
Georges J.F. Köhler	Medicine	0
Niels K. Jerne	Medicine	0
Desmond Tutu	Peace	0
Bruce Merrifield	Chemistry	1
Carlo Rubbia	Physics	1
Simon van der Meer	Physics	1

子查询原理

https://sqlzoo.net/wiki/Using_nested_SELECT

4.Show each country that has a population greater than the population of ALL countries in Europe.

Note that we mean greater than every single country in Europe; not the combined population of Europe.
1
2
3
4
SELECT name FROM world
WHERE population > ALL
(SELECT population FROM world
  WHERE continent='Europe')

子查询练习

https://sqlzoo.net/wiki/SELECT_within_SELECT_Tutorial

5.Germany (population 80 million) has the largest population of the countries in Europe. Austria (population 8.5 million) has 11% of the population of Germany.

Show the name and the population of each country in Europe. Show the population as a percentage of the population of Germany.
1
SELECT name, concat(ROUND((population/(SELECT population FROM world WHERE name='Germany'))*100,0), '%') FROM world WHERE continent = 'Europe'
7.Find the largest country (by area) in each continent, show the continent, the name and the area.
1
2
3
4
5
SELECT continent, name, area FROM world x
WHERE area >= ALL
 (SELECT area FROM world y
     WHERE y.continent=x.continent
       AND area>0)
8.List each continent and the name of the country that comes first alphabetically.

方法一：
1
2
3
4
5
SELECT continent, name FROM world x
WHERE name IN
 (SELECT TOP 1 y.name FROM world y
     WHERE y.continent=x.continent
       ORDER BY y.name)
注意：The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified. 所以上述方法需要加TOP才行。

也可以用MIN就不需要ORDER BY了。

方法二：
1
2
3
4
SELECT continent, name FROM world x
WHERE name <= ALL
 (SELECT MIN(y.name) FROM world y
     WHERE y.continent=x.continent)
9.Find the continents where all countries have a population <= 25000000. Then find the names of the countries associated with these continents. Show name, continent and population.
1
2
3
4
SELECT name, continent, population FROM world x
WHERE 25000000 > ALL (
 (SELECT y.population FROM world y
     WHERE y.continent=x.continent))
10.Some countries have populations more than three times that of any of their neighbours (in the same continent). Give the countries and continents.
1
2
3
4
SELECT name, continent FROM world x
WHERE population > ALL (
 (SELECT y.population*3 FROM world y
     WHERE y.continent=x.continent AND x.name!=y.name))

表连接练习1

https://sqlzoo.net/wiki/The_JOIN_operation

11.For every match involving 'POL', show the matchid, date and the number of goals scored.
1
2
3
SELECT matchid, mdate, COUNT(matchid)
FROM game JOIN goal ON (matchid = id)
WHERE (team1 = 'POL' OR team2 = 'POL') GROUP BY matchid, mdated
13.List every match with the goals scored by each team as shown. This will use "CASE WHEN" which has not been explained in any previous exercises.

mdate team1 score1 team2 score2

1 July 2012 ESP 4 ITA 0

10 June 2012 ESP 1 ITA 1

10 June 2012 IRL 1 CRO 3

...

Notice in the query given every goal is listed. If it was a team1 goal then a 1 appears in score1, otherwise there is a 0. You could SUM this column to get a count of the goals scored by team1. Sort your result by mdate, matchid, team1 and team2.
1
2
3
4
SELECT mdate,
team1,SUM(CASE WHEN teamid=team1 THEN 1 ELSE 0 END) score1,
team2,SUM(CASE WHEN teamid=team2 THEN 1 ELSE 0 END) score2
FROM game JOIN goal ON matchid = id GROUP BY mdate, team1, team2 ORDER BY mdate
我的和答案的差别在于0:0的答案保留，而我的则去除了。所以怎样保留0:0的答案呢？

原来正确答案为：
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
SELECT mdate,
       team1,
       SUM(CASE WHEN teamid=team1 THEN 1 ELSE 0 END) score1,
       team2,
       SUM(CASE WHEN teamid=team2 THEN 1 ELSE 0 END) score2
FROM game 
LEFT JOIN goal ON matchid = id
GROUP BY mdate,matchid,team1,team2
ORDER BY mdate,matchid,team1,team2;		-- LEFT JOIN是为了防止缺少比赛中双方都没进球的情况
-- 原文链接：https://blog.csdn.net/weixin_45739141/article/details/104079549

表连接练习2

https://sqlzoo.net/wiki/More_JOIN_operations

7.Obtain the cast list for the film 'Alien'

SELECT actor.name FROM casting JOIN actor
ON (casting.actorid=actor.id)
WHERE movieid IN
(SELECT id FROM movie WHERE title = 'Alien'
AND actorid=actor.id

8.List the films in which 'Harrison Ford' has appeared

SELECT title FROM movie JOIN casting
ON (movie.id=casting.movieid)
WHERE casting.actorid =
(SELECT actor.id FROM actor
WHERE actor.name LIKE '%Harrison Ford%')

10.List the films together with the leading star for all 1962 films.

SELECT title,
(SELECT actor.name FROM actor
 WHERE actor.id=casting.actorid)
FROM movie JOIN casting
ON (movie.id=casting.movieid)
WHERE casting.ord = 1
AND movie.yr=1962

11Which were the busiest years for 'Rock Hudson', show the year and the number of movies he made each year for any year in which he made more than 2 movies.

SELECT yr,COUNT(title) FROM
  movie JOIN casting ON movie.id=movieid
        JOIN actor   ON actorid=actor.id
WHERE name='Rock Hudson'
GROUP BY yr
HAVING COUNT(title) > 1

12.List the film title and the leading actor for all of the films 'Julie Andrews' played in.

SELECT title, name FROM casting
JOIN movie ON (casting.movieid=movie.id)
JOIN actor ON (casting.actorid=actor.id)
WHERE movieid IN
(SELECT movieid FROM actor
JOIN casting ON (actor.id=casting.actorid)
WHERE name = 'Julie Andrews')
AND ord = 1

自连接练习

https://sqlzoo.net/wiki/Self_join

5.Execute the self join shown and observe that b.stop gives all the places you can get to from Craiglockhart, without changing routes. Change the query so that it shows the services from Craiglockhart to London Road.
1
2
3
4
5
SELECT a.company, a.num, a.stop, b.stop
FROM route a JOIN route b ON
  (a.company=b.company AND a.num=b.num)
WHERE a.stop=53
AND b.stop=(SELECT id FROM stops WHERE name='London Road')
6.The query shown is similar to the previous one, however by joining two copies of the stops table we can refer to stops by name rather than by number. Change the query so that the services between 'Craiglockhart' and 'London Road' are shown.
1
2
3
4
5
6
7
SELECT a.company, a.num, stopa.name, stopb.name
FROM route a JOIN route b ON
  (a.company=b.company AND a.num=b.num)
  JOIN stops stopa ON (a.stop=stopa.id)
  JOIN stops stopb ON (b.stop=stopb.id)
WHERE stopa.name='Craiglockhart'
AND stopb.name='London Road'
10.Find the routes involving two buses that can go from Craiglockhart to Lochend.
Show the bus no. and company for the first bus, the name of the stop for the transfer,
and the bus no. and company for the second bus.

Hint

Self-join twice to find buses that visit Craiglockhart and Lochend, then join those on matching stops.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
SELECT S1.num, S1.company, S1.name, S2.num, S2.company
FROM
(SELECT stopb.name, a.company, a.num FROM route a JOIN route b
ON (a.company=b.company AND a.num=b.num)
JOIN stops stopa ON (a.stop=stopa.id)
JOIN stops stopb ON (b.stop=stopb.id)
WHERE stopa.name='Craiglockhart') AS S1
JOIN
(SELECT stopa.name, a.company, a.num FROM route a JOIN route b
ON (a.company=b.company AND a.num=b.num)
JOIN stops stopa ON (a.stop=stopa.id)
JOIN stops stopb ON (b.stop=stopb.id)
WHERE stopb.name='Lochend') AS S2
ON (S1.name=S2.name)

常用函数

https://sqlzoo.net/wiki/Functions_Reference

🤣

CAST allows you to convert from one type to another.

Often a CAST is implicit - for example if you concatenate a string with a number the number will be automatically changed to a string. However sometimes you need to make the CAST explicit.
1
CAST(expr TO type) 
这个很有用：
1
SELECT CAST(population/1000000 AS DECIMAL(8,1))
🤣

COALESCE takes any number of arguments and returns the first value that is not null.
1
2
3
4
COALESCE(x,y,z) = x if x is not NULL
COALESCE(x,y,z) = y if x is NULL and y is not NULL
COALESCE(x,y,z) = z if x and y are NULL but z is not NULL
COALESCE(x,y,z) = NULL if x and y and z are all NULL
🤣

a DIV b returns the integer value of a divided by b.
1
8 DIV 3 -> 2
整除原来是这个。

🤣

EXTRACT allows you to retrieve components of a date.

You can extract also YEAR, MONTH, DAY, HOUR, MINUTE, SECOND.
1
2
3
EXTRACT(YEAR FROM d)    EXTRACT(MONTH FROM d)
EXTRACT(DAY FROM d)     EXTRACT(HOUR FROM d)
EXTRACT(MINUTE FROM d)  EXTRACT(SECOND FROM d)
🤣

IFNULL takes two arguments and returns the first value that is not null.
1
2
IFNULL(x,y) = x if x is not NULL
IFNULL(x,y) = y if x is NULL
这个和COALESCE(coalesce 合并、结合)功能是一样的。

🤣

INSTR(s1, s2) returns the character position of the substring s2 within the larger string s1. The first character is in position 1. If s2 does not occur in s1 it returns 0.
1
INSTR('Hello world', 'll') -> 3 
🤣

NULLIF returns NULL if the two arguments are equal; otherwise NULLIF returns the first argument.
1
2
NULLIF(x,y) = NULL if x=y
NULLIF(x,y) = x if x != y     
🤣

d + i returns the date i days after the date d.
1
DATE '2006-05-20' + 7  -> DATE '2006-05-27'  
这个应该没问题。

🤣

d + INTERVAL i DAY returns the date i days after the date d.

You can also add YEAR, MONTH, DAY, HOUR, MINUTE, SECOND

You can also add a negative value.
DATE '2006-05-20' + INTERVAL 5 DAY   -> DATE '2006-05-25' 
DATE '2006-05-20' + INTERVAL 5 MONTH -> DATE '2006-10-20' 
DATE '2006-05-20' + INTERVAL 5 YEAR  -> DATE '2011-05-20' 
🤣

POSITION(s1 IN s2) returns the character position of the substring s1 within the larger string s2. The first character is in position 1. If s1 does not occur in s2 it returns 0.
1
POSITION('ll' IN 'Hello world') -> 3
这个和INSTR功能一样，只是后比前大。

🤣

REPLACE(f, s1, s2) returns the string f with all occurances of s1 replaced with s2.
1
REPLACE('vessel','e','a') -> 'vassal'
🤣

SUBSTRING allows you to extract part of a string.

它有两种写法：
1
SUBSTRING('Hello world' FROM 2 FOR 3) -> 'ell'
1
SUBSTRING('Hello world', 2, 3) -> 'ell'

窗口函数

Window functions - SQLZOO

5.You can use SELECT within SELECT to pick out only the winners in Edinburgh.

Show the parties that won for each Edinburgh constituency in 2017.

这题非常简单，要求的是每个地区的第一名，直接用partiton by把各地域的投票数排序后再选第一名即可。
1
2
3
4
5
6
7
SELECT constituency, party FROM
(SELECT constituency, party, votes,
RANK() OVER (PARTITION BY constituency ORDER BY votes DESC) as posn
FROM ge WHERE constituency
BETWEEN 'S14000021' AND 'S14000026'
AND yr  = 2017) AS m
WHERE posn = 1
6.You can use COUNT and GROUP BY to see how each party did in Scotland. Scottish constituencies start with 'S'

Show how many seats for each party in Scotland in 2017.
1
2
3
4
SELECT party, COUNT(*)
FROM ge
WHERE constituency LIKE 'S%' AND yr=2017
GROUP BY party
这答案不对吗？Scottish的constituency应该比以S打头的范围小吧？

懂了，获得seat需要在当地第一。（就是在前一题的基础上把各党派获奖情况算一算）
1
2
3
4
5
6
7
8
SELECT party,COUNT(*) FROM (
SELECT constituency,party, votes,
RANK() OVER (PARTITION BY constituency ORDER BY votes DESC) as posn
FROM ge
WHERE constituency LIKE 'S%'
AND yr  = 2017) rk
WHERE rk.posn=1
GROUP BY rk.party

Window LAG - SQLZOO

3.The number of confirmed case is cumulative - but we can use LAG to recover the number of new cases reported for each day.

Show the number of new cases for each day, for Italy, for March.

(SET @@sql_mode='ANSI';这题该网站要加上这句才能跑)
1
2
3
4
5
6
7
8
SELECT name, DAY(whn),
confirmed-LAG(confirmed, 1)
OVER (PARTITION BY name ORDER BY whn)
FROM covid
WHERE name = 'Italy'
AND MONTH(whn) = 3
AND YEAR(whn) = '2020'
ORDER BY whn;
这样一样：
1
2
3
4
5
6
7
8
9
SELECT name, DAY(whn),
CASE WHEN DAY(whn)=1 THEN null
ELSE confirmed-LAG(confirmed, 1)
OVER (PARTITION BY name ORDER BY whn) END
FROM covid
WHERE name = 'Italy'
AND MONTH(whn) = 3
AND YEAR(whn) = '2020'
ORDER BY whn;
4.The data gathered are necessarily estimates and are inaccurate. However by taking a longer time span we can mitigate some of the effects.

You can filter the data to view only Monday's figures WHERE WEEKDAY(whn) = 0.

Show the number of new cases in Italy for each week - show Monday only.
1
2
3
4
5
6
7
SELECT name
,DATE_FORMAT(whn,'%Y-%m-%d')
,confirmed-LAG(confirmed, 1) OVER (partition by name ORDER BY whn) AS lag
FROM covid
WHERE name = 'Italy'
AND WEEKDAY(whn) = 0 AND YEAR(whn) = 2020
ORDER BY whn;
5.You can JOIN a table using DATE arithmetic. This will give different results if data is missing.

Show the number of new cases in Italy for each week - show Monday only.

In the sample query we JOIN this week tw with last week lw using the DATE_ADD function.
1
2
3
4
5
6
7
8
SELECT tw.name, DATE_FORMAT(tw.whn,'%Y-%m-%d'), 
tw.confirmed-lw.confirmed
FROM covid tw LEFT JOIN covid lw ON 
DATE_ADD(lw.whn, INTERVAL 1 WEEK) = tw.whn
AND tw.name=lw.name
WHERE tw.name = 'Italy'
AND WEEKDAY(tw.whn)=0
ORDER BY tw.whn
这题是上一题的另一种解法，通过变换日期然后JOIN就直接获得了同在一行的这周和上周的确诊，直接相减即获得新增确诊。

7.The query shown includes a JOIN t the world table so we can access the total population of each country and calculate infection rates (in cases per 100,000).

Show the infect rate ranking for each country. Only include countries with a population of at least 10 million.
1
2
3
4
5
6
SELECT 
world.name,ROUND(100000*confirmed/population,0) infection,
rank()over(order by infection desc)
FROM covid JOIN world ON covid.name=world.name
WHERE whn = '2020-04-20' AND population > 10000000
ORDER BY population DESC
这题答案有问题。

8.For each country that has had at last 1000 new cases in a single day, show the date of the peak number of new cases.

先求出每日新增，然后给每日新增排序。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
SET @@sql_mode='ANSI';
SELECT name
,DATE_FORMAT(whn,'%Y-%m-%d')
,peakNewCases FROM
    (SELECT *
            ,RANK() OVER(PARTITION BY name ORDER BY peakNewCases DESC) AS rank
     FROM
             (SELECT name, whn,
                     confirmed-LAG(confirmed, 1)
                     OVER (PARTITION BY name ORDER BY whn)
                     AS peakNewCases
                     FROM covid) AS c WHERE peakNewCases > 1000)
             AS cc
     WHERE rank=1
     order by whn

牛客网sql实战题解析

2024-04-03T03:40:26+00:00

牛客网sql实战题

全部实战题见：SQL数据库实战题_面试必刷+解析_牛客题霸_牛客网)

本文只收录有点难度的题目。

SQL2

查找入职员工时间排名倒数第三的员工所有信息

有一个员工employees表简况如下:

请你查找employees里入职员工时间排名倒数第三的员工所有信息

-- 方法一：这种不规范，
-- 只适用于倒数第三只有一位员工或虽有多位但只需要选其中一位员工的情况
select *
from employees
order by hire_date desc
limit 2,1 -- limit的offset从0开始数

-- 方法二：如果倒数第三有多位员工或为了适应性更广
select *
from employees
where hire_date = (
                      select distinct hire_date
                      from employees
                      order by hire_date desc
                      limit 2,1
                  )
-- 加了distinct会去重分组，多个相同入职日期会分为一组
-- 注意distinct会先于limit执行

-- 方法三：用窗口函数
select emp_no
,birth_date
,first_name
,last_name
,gender
,hire_date
from
(
    select *
    ,dense_rank()over(order by hire_date desc) r
    from employees
) a
where r = 3

本题虽然简单，但题目模糊，不知道排名倒数第三指的如何排序。鉴于牛客网将其归类为一道简单题，因此暂且认为方法一就行。但本题的解法已包括各种要求。

1.如果倒数第三只有一位员工或虽有多位但只需要选其中一位员工的情况，选择方法一

2.如果是在有多位员工时均要选出，排序符合dense_rank，可以用方法二

3.如果是情况一，可用窗口函数的row_number，如果是情况二，可用窗口函数的dense_rank。鉴于本题的情况，不可能属于rank的排序，因为如果是1224，那么题目就问错了

SQL4

查找所有已经分配部门的员工的last_name和first_name以及dept_no

有一个员工表，employees简况如下:

有一个部门表，dept_emp简况如下:

请你查找所有已经分配部门的员工的last_name和first_name以及dept_no，未分配的部门的员工不显示

-- 这题用内连接即可，
-- employees的员工如果连不上部门表的员工（里面的员工id都分配了部门id），
-- 那自然是没有被分配部门，
-- 使用左连接然后筛选是多此一举
select last_name
,first_name
,dept_no
from employees e
join dept_emp d
on e.emp_no = d.emp_no

SQL10

获取所有非manager的员工emp_no

有一个员工表，employees简况如下:

有一个部门领导表dept_manager简况如下:

请你找出所有非部门领导的员工emp_no，输出格式如下:

emp_no

10001

-- 方法一：排除法
select emp_no
from employees
where emp_no not in (
                        select emp_no from dept_manager
                    )

-- 方法二：表连接再选取法
select e.emp_no
from employees e
left join dept_manager d
on e.emp_no = d.emp_no
where dept_no is null

SQL12

获取每个部门中当前员工薪水最高的相关信息

有一个员工表dept_emp简况如下:

有一个薪水表salaries简况如下:

获取每个部门中当前员工薪水最高的相关信息，给出dept_no, emp_no以及其对应的salary，按照部门编号升序排列

# 方法一：先取员工当前薪资表，再获取部门最高薪资表。
# 然后用薪资作为筛选条件对应以获取正确的员工编号。
SELECT t2.dept_no, t1.emp_no, t2.max_salary
FROM
(
    SELECT e.emp_no , e.dept_no , s.salary 
    FROM dept_emp e
    JOIN salaries s
    ON e.emp_no=s.emp_no
) t1
JOIN
(
    SELECT e.dept_no , MAX(salary) max_salary
    FROM dept_emp e
    JOIN salaries s
    ON e.emp_no=s.emp_no
    GROUP BY e.dept_no
) t2
ON t1.dept_no=t2.dept_no
WHERE t1.salary=t2.max_salary
ORDER BY t2.dept_no

# 方法二：窗口函数
select dept_no
,emp_no
,salary maxSalary
from
    (
        select d.dept_no
        ,d.emp_no
        ,salary
        ,dense_rank()over(partition by d.dept_no order by salary desc) r
        from dept_emp d
        join salaries s
        on d.emp_no = s.emp_no
    ) a
where r = 1
order by dept_no

SQL17

获取当前薪水第二多的员工的emp_no以及其对应的薪水salary

有一个员工employees表简况如下:

有一个薪水表salaries简况如下:

请你获取薪水第二多的员工的emp_no以及其对应的薪水salary

-- 与SQL2一样，这类问题统称为获取倒数或顺数第n的xx，
-- 第一种方法是用order by与limit，第二种是窗口函数
-- 方法一：严谨版（通过distinct来去重排行）
select emp_no
,salary
from salaries
where salary = (
                    select distinct salary from salaries
                    order by salary desc
                    limit 1,1
                )

-- 方法二：使用窗口函数
select emp_no
,salary
from
(
    select *
    ,dense_rank()over(order by salary desc) r
    from salaries
) a
where r = 2

SQL18

获取当前薪水第二多的员工的emp_no以及其对应的薪水salary

有一个员工employees表简况如下:

有一个薪水表salaries简况如下:

请你查找薪水排名第二多的员工编号emp_no、薪水salary、last_name以及first_name，不能使用order by完成

-- 此题与SQL17一样，只是要求不能使用order by完成，
-- 但第n多/少相当于n个select的max/min的嵌套，
-- 增加一个新方法：自连接排序法
-- 方法一：剥离
select e.emp_no
,s.salary
,last_name
,first_name
from employees e
join salaries s
on e.emp_no = s.emp_no
and s.salary =
(
    select max(salary) -- 第二多
    from salaries
    where salary !=
    (
        select max(salary) -- 第一多
        from salaries
    )
)

-- 方法二：自连接
select e.emp_no
,s.salary
,last_name
,first_name
from employees e
join salaries s
on e.emp_no=s.emp_no 
and s.salary = 
(
     select s1.salary
     from salaries s1
     join salaries s2 -- 自连接
     -- 与比它大或等于的值连接，这样它有几个不同值即大于等于多少个值，即排行第几
     on s1.salary<=s2.salary
     group by s1.salary
     having count(distinct s2.salary) = 2
 )
 
 
-- v2.0这样直接与自连接结果表join更简洁
select e.emp_no
,a.salary
,last_name
,first_name
from employees e
join 
(
     select s1.emp_no,s1.salary
     from salaries s1
     join salaries s2 -- 自连接
     -- 与比它大或等于的值连接，这样它有几个不同值即大于等于多少个值，即排行第几
     on s1.salary<=s2.salary
     group by s1.emp_no,s1.salary
     having count(distinct s2.salary) = 2
 ) a
 on e.emp_no=a.emp_no

综合SQL17和SQL18，“获取倒数或顺数第n的xx”类题通常有四种解法：

order by与limit去重排序
多重子查询筛选
自连接
窗口函数的dense_rank

SQL21

查找在职员工自入职以来的薪水涨幅情况

有一个员工employees表简况如下:

有一个薪水表salaries简况如下:

请你查找在职员工自入职以来的薪水涨幅情况，给出在职员工编号emp_no以及其对应的薪水涨幅growth，并按照growth进行升序

这题有点模糊，直接假设hire_date会对应from_date应该更好理解。

-- "查找<在职>员工<自入职以来>的薪水涨幅情况"，
-- 说明终点工资一定是to_date为9999-01-01的salary
-- 中间工资起伏不要紧，只需要求相对于入职时(hire_date)的涨幅就行了
select e.emp_no
,(s2.salary-s1.salary) as growth
from employees e
join salaries s1
on e.emp_no = s1.emp_no
and s1.from_date = e.hire_date
join salaries s2
on e.emp_no = s2.emp_no
and s2.to_date = '9999-01-01'
order by growth

SQL23

对所有员工的薪水按照salary降序进行1-N的排名

有一个薪水表salaries简况如下:

对所有员工的薪水按照salary降序进行1-N的排名，要求相同salary并列且按照emp_no升序排列

-- 方法一：自连接（自表连接，左表一列会连接右表所有列，同SQL18）
select s1.emp_no
,s1.salary
,count(distinct s2.salary) t_rank -- 被筛s2有几个，代表第几大
from salaries s1,salaries s2
where s1.salary <= s2.salary -- 晒出比s1大的s2的salary列
group by 1
order by s1.salary desc,emp_no

-- 方法二：窗口函数
select emp_no
,salary
,dense_rank()over(order by salary desc) t_rank -- 注意要用dense_rank
from salaries
order by t_rank,emp_no

这题其实与SQL17、SQL18差不多，后者要求筛选第xx的行，其实解题方法中就包括本题的要求——对其进行排序。这也体现了窗口函数的简便。

SQL24

获取所有非manager员工当前的薪水情况

有一个员工employees表简况如下:

有一个，部门员工关系表dept_emp简况如下:

有一个部门领导表dept_manager简况如下:

有一个薪水表salaries简况如下:

获取所有非manager员工薪水情况，给出dept_no、emp_no以及salary

-- 方法一：排除非manager的员工即可
select d.dept_no
,e.emp_no
,s.salary
from employees e
join dept_emp d
on e.emp_no = d.emp_no
join salaries s
on e.emp_no = s.emp_no
where e.emp_no not in (
    select emp_no from dept_manager
)

-- 方法二（不需要employees，因为dept_manager除去manager就是其他员工了）
select d.dept_no
,d.emp_no
,s.salary
from dept_emp d
join salaries s
on d.emp_no = s.emp_no
where d.emp_no not in (
    select emp_no from dept_manager
)

所以这题可以看出，当表多了之后，理清表的逻辑关系才是关键，例如给出5张表，实际解决问题可能只需要2张表连起来。

SQL25

获取员工其当前的薪水比其manager当前薪水还高的相关信息

有一个，部门员工关系表dept_emp简况如下:

有一个部门领导表dept_manager简况如下:

有一个薪水表salaries简况如下:

获取员工其当前的薪水比其manager当前薪水还高的相关信息，

第一列给出员工的emp_no，
第二列给出其manager的manager_no，
第三列给出该员工当前的薪水emp_salary,
第四列给该员工对应的manager当前的薪水manager_salary

select d.emp_no
,m.emp_no manager_no
,s1.salary emp_salary
,s2.salary manager_salary
from dept_emp d
join dept_manager m
on d.dept_no = m.dept_no
and d.emp_no != m.emp_no -- 排除d.emp_no=m.emp_no的对应的正是普通员工与其经理
join salaries s1 -- 于是这里对应的是普通员工的薪水
on d.emp_no = s1.emp_no
join salaries s2
on m.emp_no = s2.emp_no -- 于是这里对应经理的薪水
where s1.salary > s2.salary -- 普通员工比经理薪水高的情况

这题dept_emp表和dept_manager表都有emp_no和dept_no字段，不能选错连接字段，此处需要找出的是员工对应的领导，所以应该用员工表的部门id与领导表的部分id配对，这样就得到了员工与其所在部门的领导的对应关系了。由于领导本身也在员工表里，则相同emp_no的就是领导了。

SQL28

查找描述信息中包含robot的电影对应的分类名称以及电影数目，而且还需要该分类对应电影数量>=5部（注意，此题已被牛客网删除，可能是因为此题比较鸡肋的缘故）

film表

字段说明

film_id 电影id

title 电影名称

description 电影描述信息
1
2
3
4
5
6
7
8
9
CREATE TABLE IF NOT EXISTS film (

film_id smallint(5)  NOT NULL DEFAULT '0',

title varchar(255) NOT NULL,

description text,

PRIMARY KEY (film_id));
category表

字段说明

category_id 电影分类id

name 电影分类名称

last_update 电影分类最后更新时间
1
2
3
4
5
6
7
8
9
CREATE TABLE category  (

category_id  tinyint(3)  NOT NULL,

name  varchar(25) NOT NULL,

last_update timestamp,

PRIMARY KEY ( category_id ));
film_category表

字段说明

film_id 电影id

category_id 电影分类id

last_update 电影id和分类id对应关系的最后更新时间
1
2
3
4
5
6
7
CREATE TABLE film_category  (

film_id  smallint(5)  NOT NULL,

category_id  tinyint(3)  NOT NULL,

last_update timestamp);
查找描述信息(film.description)中包含robot的电影对应的分类名称(category.name)以及电影数目(count(film.film_id))，而且还需要该分类包含电影总数量(count(film_category.category_id))>=5部

select name
,count(fc.film_id) num
from film_category fc
join category c
on fc.category_id =c.category_id
join film f
on fc.film_id = f.film_id
where description like '%robot%'
and fc.category_id in -- 该分类包含电影总数量>=5部
(
    select category_id
    from film_category
    group by 1
    having count(film_id) >= 5
)
group by 1

这题特别需要注意的就是该分类包含电影总数量>=5，不是包含robot的电影>=5，因此这题必须分步骤，不能一气呵成。

SQL35

批量插入数据，不使用replace操作

题目已经先执行了如下语句:
1
2
3
4
5
6
7
8
9
drop table if exists actor;
create table actor
( 
    actor_id smallint(5) NOT NULL PRIMARY KEY,
    first_name varchar(45) NOT NULL,
    last_name varchar(45) NOT NULL,
    last_update DATETIME NOT NULL
);
insert into actor values ('3', 'WD', 'GUINESS', '2006-02-15 12:34:33');
对于表actor插入如下数据,如果数据已经存在，请忽略(不支持使用replace操作)

actor_id first_name last_name last_update

'3' 'ED' 'CHASE' '2006-02-15 12:34:33'

1
2

-- 如果存在，则忽略 insert ignore（mysql写法）
INSERT IGNORE INTO actor VALUES('3','ED','CHASE','2006-02-15 12:34:33');

本题我做了两遍，第二遍隐约记得有个ignore，然后先把ignore放insert前失败了，第二次放insert后成功了。

SQL46

在audit表上创建外键约束，其emp_no对应employees_test表的主键id

在audit表上创建外键约束，其emp_no对应employees_test表的主键id。

(以下2个表已经创建了)

CREATE TABLE employees_test(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);

CREATE TABLE audit(
EMP_no INT NOT NULL,
create_date datetime NOT NULL
);

-- 这是属于SQL高级特征-对字段进行约束的内容了，对外键进行约束的语法为：
-- ALTER TABLE <表名>
-- ADD CONSTRAINT FOREIGN KEY (<作为外键的列名>)
-- REFERENCES <关联的表>(<关联的列>)
ALTER TABLE audit
ADD CONSTRAINT FOREIGN KEY (emp_no)
REFERENCES employees_test(id)

这题我做第二遍时，依然不记得怎么写，只记得有constraint和references，最后试错了几次居然通过，代码如下：

1
2

alter table audit add constraint fk_audit_employees
foreign key audit(emp_no) references employees_test(id);

第一个表名可省略。

对外键进行约束的语法为：

ALTER TABLE <表名>
ADD CONSTRAINT <约束名> FOREIGN KEY (<作为外键的列名>)
REFERENCES <关联的表>(<关联的列>)

其实CONSTRAINT <约束名> 可以省略。

如果是在刚创建的时候时候语法就是在新的一行上写上这句。例如：

create table audit(
    emp_no int not null,
    create_date datetime not null,
    foreign key(emp_no) references employees_test(id)
);

SQL50

将employees表中的所有员工的last_name和first_name通过引号连接起来

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

将employees表中的所有员工的last_name和first_name通过(')连接起来。

-- 注意 ' 要转义，有两种转义方法

-- 方法一
select concat(last_name,'\'',first_name) from employees;

-- 方法二
select concat(last_name,'''',first_name) from employees;

-- 或者请出双引号
select concat(last_name,"'", first_name)  from employees;

SQL51

查找字符串 10,A,B 中逗号,出现的次数cnt

现有strings表如下：

id指序列号；

string列中存放的是字符串，且字符串中仅包含数字、字母和逗号类型的字符。

id string

1 10,A,B,C,D

2 A,B,C,D,E,F

3 A,11,B,C,D,E,G

请你统计每个字符串中逗号出现的次数cnt。

以上例子的输出结果如下：

id cnt

1 4

2 5

3 6

-- 方法一：把逗号去除后计算长度减少了多少
select id,length(string)-length(replace(string,',','')) from strings;
-- replace(字符串，“需要替换的子串”，“用于替换子串的字符串”）

-- 方法二：把数字字母去除后计算长度
SELECT
    id,
    length(
        regexp_replace(STRING, '[A-Z0-9]', '')
    )
FROM
    strings;

这题做第二遍依然不会。

SQL52

获取Employees中的first_name

现有employees表如下：

emp_no birth_date first_name last_name gender hire_date

10001 1953-09-02 Georgi Facello M 1986-06-26

10002 1964-06-02 Bezalel Simmel F 1985-11-21

10003 1959-12-03 Parto Bamford M 1986-08-28

10004 1954-05-01 Christian Koblick M 1986-12-01

10005 1955-01-21 Kyoichi Maliniak M 1989-09-12

10006 1953-04-20 Anneke Preusig F 1989-06-02

10007 1957-05-23 Tzvetan Zielinski F 1989-02-10

10008 1958-02-19 Saniya Kalloufi M 1994-09-15

10009 1952-04-19 Sumant Peac F 1985-02-18

10010 1963-06-01 Duangkaew Piveteau F 1989-08-24

10011 1953-11-07 Mary Sluis F 1990-01-22

请你将employees中的first_name按照first_name最后两个字母升序进行输出。

-- SUBSTR( )与SUBSTRING( )意思相等，第一个字符的位置为都1
-- 方法一
select first_name
from employees
order by right(first_name,2)

-- 方法二
select first_name
from employees
order by substring(first_name,-2) -- 为负数，返回从倒数第2个位置到字符串结尾的子字符串
-- 注意，如果第三个参数省略，则直接截取到末尾

-- 方法三
select first_name
from employees
order by substring(first_name,length(first_name)-1)

SQL53

按照dept_no进行汇总

按照dept_no进行汇总，属于同一个部门的emp_no按照逗号进行连接，结果给出dept_no以及连接出的结果employees。

表格结构如下：
1
2
3
4
5
6
CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));

-- 利用group_concat函数
select dept_no
,group_concat(emp_no) employees
from dept_emp
group by dept_no

-- 或者这样。合并的字段分隔符默认为逗号，可通过参数separator指定
select dept_no
,group_concat(emp_no separator ',') employees
from dept_emp
group by dept_no

第二次做时忘了group_concat的分隔符默认是逗号，而且忘记参数这里seperator不要加逗号。

group_concat(X,Y)

group_concat()函数返回X的非null值的连接后的字符串。如果给出了参数Y，将会在每个X之间用Y作为分隔符。如果省略了Y，“，”将作为默认的分隔符。每个元素连接的顺序是随机的。（注意，MySQL 的格式不一样）

SQL57

使用含有关键字exists查找未分配具体部门的员工的所有信息

使用含有关键字exists查找未分配具体部门的员工的所有信息。

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));
CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));

-- exists意思是存在，逐条比对返回满足条件的
select * from employees e
where not exists (
    select d.dept_no from dept_emp d
    where d.emp_no = e.emp_no);

-- 如果填的是exists，且后面匹配成功了，就是有部门的员工，加个not就是没有部门的员工

-- 换句话说，本题意为在 employees 中挑选出令
-- select d.dept_no from dept_emp d where d.emp_no = e.emp_no不成立的记录

exists强调是否返回结果集，不要求知道返回什么。只要返回了字段，就是真。

【第二次做，磕磕碰碰才做出来】

SQL60

统计salary的累计和running_total

按照salary的累计和running_total，其中running_total为前N个当前( to_date = '9999-01-01')员工的salary累计和，其他以此类推。具体结果如下Demo展示。
1
2
3
4
5
CREATE TABLE `salaries` ( `emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));
输出格式:

emp_no salary running_total

10001 88958 88958

10002 72527 161485

10003 43311 204796

-- 方法一：子查询法
select s1.emp_no
,s1.salary
,
(
    select sum(s2.salary) from salaries s2
    where s2.emp_no <= s1.emp_no -- 把小于等于的都加起来就是了
    and s2.to_date = '9999-01-01'
) running_total
from salaries s1
where s1.to_date = '9999-01-01'
order by s1.emp_no

-- 方法二：自连接法
select s1.emp_no
,s1.salary
,sum(s2.salary) running_total
from salaries s1
join salaries s2
on s1.emp_no >= s2.emp_no
where s1.to_date = '9999-01-01'
and s2.to_date = '9999-01-01'
group by s1.emp_no
order by s1.emp_no

-- 方法三：窗口函数
select emp_no
,salary
,sum(salary)over(order by emp_no) running_total
from salaries
where to_date = '9999-01-01'

此题是SQL23的变种，即按照emp_no排序后进行累加，对于自连接法只需要将连接后对应小于它的emp_no的salary相加，对于窗口函数，只需要将排序函数变成求和函数即可。

第二次做窗口函数直接秒杀。

SQL61

对于employees表中，给出奇数行的first_name

对于employees表中，输出first_name排名(按first_name升序排序)为奇数的first_name
1
2
3
4
5
6
7
8
9
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,

PRIMARY KEY (`emp_no`));
如，输入为：
1
2
3
4
INSERT INTO employees VALUES(10001,'1953-09-02','Georgi','Facello','M','1986-06-26');
INSERT INTO employees VALUES(10002,'1964-06-02','Bezalel','Simmel','F','1985-11-21');
INSERT INTO employees VALUES(10005,'1955-01-21','Kyoichi','Maliniak','M','1989-09-12');
INSERT INTO employees VALUES(10006,'1953-04-20','Anneke','Preusig','F','1989-06-02');
输出格式:

first_name

Georgi

Anneke

因为Georgi按first_name排名为3，Anneke按first_name排名为1，所以会输出这2个，且输出时不需排序。

请你在不打乱原序列顺序的情况下，输出：按first_name排升序后，取奇数行的first_name。

-- 方法一：自连接法类似
select e1.first_name
from employees e1
where (
          select count(*) -- 得到的结果是e1.first_name该行值的实际排名
          from employees e2
          where e1.first_name >= e2.first_name
      )%2 = 1

-- 方法二：窗口函数法
-- （不行，可能会打乱原顺序，除非原表是按emp_no升序排列的）
# select first_name
# from
# (
#     select emp_no
#     ,first_name
#     ,row_number()over(order by first_name) r
#     from employees
# ) a
# where r%2 = 1
# order by emp_no

-- 修正版窗口函数
SELECT
    e.first_name
FROM employees e JOIN
(
    SELECT 
        first_name
        , ROW_NUMBER() OVER(ORDER BY first_name ASC) AS  r_num
    FROM employees
) AS t 
ON e.first_name = t.first_name
WHERE t.r_num % 2 = 1;
-- 这里用原表连接窗口函数结果，就不打乱顺序了

此题也是SQL23的变种，只不过排序后筛选的是奇数行。至此，SQL16、SQL17、SQL23、SQL60、SQL61实际可以概况为一类题：(分组)排序再选择问题。

SQL65

异常的邮件概率

现在有一个需求，让你统计正常用户发送给正常用户邮件失败的概率:
有一个邮件(email)表，id为主键， type是枚举类型，枚举成员为(completed，no_completed)，completed代表邮件发送是成功的，no_completed代表邮件是发送失败的。简况如下:

第1行表示为id为2的用户在2020-01-11成功发送了一封邮件给了id为3的用户;
...
第3行表示为id为1的用户在2020-01-11没有成功发送一封邮件给了id为4的用户;
...
第6行表示为id为4的用户在2020-01-12成功发送了一封邮件给了id为1的用户;

下面是一个用户(user)表，id为主键，is_blacklist为0代表为正常用户，is_blacklist为1代表为黑名单用户，简况如下:

第1行表示id为1的是正常用户;
第2行表示id为2的不是正常用户，是黑名单用户，如果发送大量邮件或者出现各种情况就会容易发送邮件失败的用户
。。。
第4行表示id为4的是正常用户

现在让你写一个sql查询，每一个日期里面，正常用户发送给正常用户邮件失败的概率是多少，结果保留到小数点后面3位(3位之后的四舍五入)，并且按照日期升序排序，上面例子查询结果如下:

结果表示:

2020-01-11失败的概率为0.500，因为email的第1条数据，发送的用户id为2是黑名单用户，所以不计入统计，正常用户发正常用户总共2次，但是失败了1次，所以概率是0.500;

2020-01-12没有失败的情况，所以概率为0.000.

这题要注意send_id与receive_id都要判断是否为黑名单，因为求的是正常用户发送给正常用户邮件失败的概率是多少。

-- 利用group by与case when的组合拳
select date
,round(sum(case type when 'no_completed' then 1 else 0 end) / count(*),3) p
from email e
join user u1
on e.send_id = u1.id
and u1.is_blacklist = 0
join user u2
on e.receive_id = u2.id
and u2.is_blacklist = 0
group by date
order by date

SQL67-71

牛客每天有很多人登录，有一个登录(login)记录表，简况如下:

第1行表示user_id为2的用户在2020-10-12使用了客户端id为1的设备登录了牛客网，因为是第1次登录，所以是新用户
。。。
第4行表示user_id为2的用户在2020-10-13使用了客户端id为2的设备登录了牛客网，因为是第2次登录，所以是老用户
。。
最后1行表示user_id为4的用户在2020-10-15使用了客户端id为1的设备登录了牛客网，因为是第2次登录，所以是老用户

有一个刷题（passing_number)表，简况如下:

第1行表示user_id为2的用户在2020-10-12通过了4个题目。
。。。
第3行表示user_id为1的用户在2020-10-13提交了代码但是没有通过任何题目。
第4行表示user_id为4的用户在2020-10-13通过了2个题目

还有一个用户(user)表，简况如下:

还有一个客户端(client)表，简况如下:

问题：

SQL67 牛客每个人最近的登录日期(二)

请你写出一个sql语句查询每个用户最近一天登录的日子，用户的名字，以及用户用的设备的名字，并且查询结果按照user的name升序排序

SQL68 牛客每个人最近的登录日期(三)

请你写出一个sql语句查询新登录用户次日成功的留存率，即第1天登陆之后，第2天再次登陆的概率,保存小数点后面3位(3位之后的四舍五入)

SQL69 牛客每个人最近的登录日期(四)

请你写出一个sql语句查询每个日期登录新用户个数，并且查询结果按照日期升序排序

SQL70 牛客每个人最近的登录日期(五)

请你写出一个sql语句查询每个日期新用户的次日留存率，结果保留小数点后面3位数(3位之后的四舍五入)，并且查询结果按照日期升序排序

SQL71 牛客每个人最近的登录日期(六)

请你写出一个sql语句查询刷题信息，包括: 用户的名字，以及截止到某天，累计总共通过了多少题，并且查询结果先按照日期升序排序，再按照姓名升序排序，有登录却没有刷题的那一天的数据不需要输出

解析：

SQL67

-- 方法一：先查出最近登录对应的用户信息，然后把额外信息连过去
select u.name u_n
,c.name c_n
,l.date date
from login l
join
(
select user_id
,max(date) d
from login
group by 1
) a -- 用户最近登录表
on l.user_id = a.user_id
and l.date = a.d
join client c
on l.client_id = c.id
join user u
on l.user_id = u.id
order by u_n

-- 方法一.一：这种是方法一的改良，实际上，
-- 同一用户的客户端client.name相同，所以对user.name分组后没有影响结果，
-- 即便是非聚合字段也没事（group by默认取非聚合字段的第一条，这只有一条）
-- 由于在标准语法中select子句中不能出现group by子句中未出现的列名，
-- 这个在标准语法要求中通不过
select u.name u_n
,c.name c_n
,max(date)
from user u
join login l
on u.id = l.user_id
join client c
on l.client_id = c.id
group by u.name
order by u.name

-- 方法二：联结查询
select u.name,c.name,l1.date
from login l1,user u,client c
where l1.date=(select max(l2.date) from login l2 where l1.user_id=l2.user_id)
and l1.user_id=u.id
and l1.client_id=c.id
order by u.name

-- 方法三：窗口函数，全表联结，然后用窗口函数选个排第一的
select u_n
,c_n
,date
from
(
select b.name u_n
,c.name c_n
,date
,rank()over(partition by b.name order by date desc) r
from login a
join user b
on a.user_id = b.id
join client c
on a.client_id = c.id
) a
where r = 1

SQL68

分析：

这题求的概率p=新登录且次数登录的用户数/全部用户数，关键是求登录日期最小的登录日期比次小的小一天就是次日登录过的用户数。

-- 方法一：表连接
select round(count(*)/(select count(distinct user_id) from login),3) p
from login l
join
(
select user_id
,min(date) first_date -- 最小的登录日期
from login
group by user_id
) f
on l.user_id = f.user_id
where date = DATE_ADD(f.first_date,INTERVAL 1 DAY) -- 筛出比最小的大一天的记录

-- 方法二：表连接（稍微修改）
select round(count(l.id)/count(f.user_id),3) p
from login l
right join -- 各唯一用户id及最小登录日期表作为主表
(
select user_id
,min(date) first_date
from login
group by user_id
) f
on l.user_id = f.user_id
and l.date = DATE_ADD(f.first_date,INTERVAL 1 DAY)
-- 用right join将各唯一用户id及最小登录日期表作为主表，
-- round部分就不用进行更多子查询了，l.id数量即满足条件用户，f.user_id即全部用户

-- 方法三：子查询
select round(count(*)/(select count(distinct user_id) from login),3) p
from login l
where (user_id,date) in (
                            select user_id
                            ,DATE_ADD(min(date),INTERVAL 1 DAY)
                            from login
                            group by user_id
                        )

第二次做反而不会了，这样做的，还没验证对不对：

select 
round(count(if(datediff(a_date,b_date)=1,c.user_id,null))/count(*),3) p
from
(
select a.user_id
,a.date a_date
,b.date b_date
,row_number()over(partition by a.user_id order by a.date,b.date) r
from
(
select user_id
,date
from login
group by user_id,date
) a
join a as b
on a.user_id=b.user_id
and a.date<b.date
) c
where c.r=1

SQL69

-- 方法一：先获得各唯一用户id及最小登录日期表，
-- 与原表匹配，各最小登录日期有几个，该日期就有几个用户登录了，
-- 为了得到登录用户数为0的日期，用left join保留所有date
select date
,count(first_date) new
from login l
left join
(
    select
    user_id
    ,min(date) first_date
    from login
    group by user_id
) a
on l.user_id = a.user_id
and l.date = a.first_date
group by date

-- 方法二：窗口函数，排序后数下各日期有几个number one就可以
select date
,sum(case when r = 1 then 1 else 0 end)
from
(
    select *
    ,rank()over(partition by user_id order by date) r
    from login
) a
group by date
order by date

-- 方法三：联结查询机灵法
-- 对各date，满足case when中条件计数板就加1，外层用group by汇总计数板
select date,sum(t) from
(
    select date
    ,case when (user_id,date) in 
    (select user_id,min(date) from login group by user_id)
    then 1
    else 0
    end as t
    from login
) a
group by date
order by date

SQL70

-- 方法一
SELECT a.date, ROUND(COUNT(b.user_id) * 1.0/COUNT(a.user_id), 3) AS p
FROM (
    SELECT user_id, MIN(date) AS date
    FROM login
    GROUP BY user_id) a
LEFT JOIN login b
ON a.user_id = b.user_id
AND b.date = date(a.date, '+1 day')
GROUP BY a.date
UNION
SELECT date, 0.000 AS p
FROM login
WHERE date NOT IN (
    SELECT MIN(date)
    FROM login
    GROUP BY user_id)
ORDER BY date;

-- 方法二（尚未验证）
sele
,c.user_id
round(count(if(datediff(a_date,b_date)=1,c.user_id,null))/count(*),3) p
from
(
select a.user_id
,a.date a_date
,b.date b_date
,row_number()over(partition by a.user_id order by a.date,b.date) r
from
(
select user_id
,date
from login
group by user_id,date
) a
join a as b
on a.user_id=b.user_id
and a.date<b.date
) c
where c.r=1
group by c.user_id

SQL71

select u.name u_n
,l.date
,sum(p.number)over(partition by u.name order by l.date)
from login l
join passing_number p
on l.user_id = p.user_id
and l.date = p.date
join user u
on l.user_id = u.id
order by 2,1

SQL75-76

牛客每次考试完，都会有一个成绩表(grade)，如下:

第1行表示用户id为1的用户选择了C++岗位并且考了11001分

。。。

第8行表示用户id为8的用户选择了B语言岗位并且考了9999分

问题：

SQL75 考试分数(四)

请你写一个sql语句查询各个岗位分数升序排列之后的中位数位置的范围，并且按job升序排序，结果如下:

SQL76 考试分数(五)

请你写一个sql语句查询各个岗位分数的中位数位置上的所有grade信息，并且按id升序排序，结果如下:

解析：

SQL75

--  方法一
select job
,round(case when s%2=0 then s/2 else (s+1)/2 end,0) start
,round(case when s%2=0 then s/2+1 else (s+1)/2 end,0) end
from
(
    select job
    ,count(*) s
    from grade
    group by job
) a
order by job

-- 方法二（简化）
-- 偶数的round(s/2)与奇数的round(s/2)对算开头是一样的 round(4/2)=2 round(5/2)=3
-- 偶数的round((s+1)/2与奇数的round(s+1)/2对算结尾是一样的 round(4+1/2)=3 round(5+1)/2=3
select job
,round(round(s/2)) start
,round(round(s+1)/2) end
from
(
    select job
    ,count(*) s
    from grade
    group by job
) a
order by job

SQL76

-- 方法一：我的普通思路
select id
,job
,score
,t_rank
from
(
    select g.id
    ,g.job
    ,g.score
    ,rank()over(partition by g.job order by g.score desc) t_rank
    ,start
    ,end
    from grade g
    join
    (
        select job
        ,round(case when s%2=0 then s/2 else (s+1)/2 end,0) start
        ,round(case when s%2=0 then s/2+1 else (s+1)/2 end,0) end
        from
        (
            select job
            ,count(*) s
            from grade
            group by job
        ) a
    ) b
    on g.job = b.job
) c
where t_rank in (start,end)
order by id

-- 方法二：大佬妙解
select id
,job
,score
,s_rank
from
(select *
        ,(row_number()over(partition by job order by score desc))as s_rank
        ,(count(score)over(partition by job))as num
        from grade) t1
where abs(t1.s_rank - (t1.num+1)/2) < 1 -- 无论奇偶，中位数的位置距离（个数+1）/2 小于1
order by id

SQL79-81

有很多同学在牛客购买课程来学习，购买会产生订单存到数据库里。

有一个订单信息表(order_info)，简况如下:

第1行表示user_id为557336的用户在2025-10-10的时候使用了client_id为1的客户端下了C++课程的订单，但是状态为没有购买成功。

第2行表示user_id为230173543的用户在2025-10-12的时候使用了client_id为2的客户端下了Python课程的订单，状态为购买成功。

问题：

SQL79 牛客的课程订单分析(三)

请你写出一个sql语句查询在2025-10-15以后，同一个用户下单2个以及2个以上状态为购买成功的C++课程或Java课程或Python课程的订单信息，并且按照order_info的id升序排序

SQL80 牛客的课程订单分析(四)

请你写出一个sql语句查询在2025-10-15以后，如果有一个用户下单2个以及2个以上状态为购买成功的C++课程或Java课程或Python课程，那么输出这个用户的user_id，以及满足前面条件的第一次购买成功的C++课程或Java课程或Python课程的日期first_buy_date，以及购买成功的C++课程或Java课程或Python课程的次数cnt，并且输出结果按照user_id升序排序，以上例子查询结果如下:

SQL81 牛客的课程订单分析(五)

请你写出一个sql语句查询在2025-10-15以后，如果有一个用户下单2个以及2个以上状态为购买成功的C++课程或Java课程或Python课程，那么输出这个用户的user_id，以及满足前面条件的第一次购买成功的C++课程或Java课程或Python课程的日期first_buy_date，以及满足前面条件的第二次购买成功的C++课程或Java课程或Python课程的日期second_buy_date，以及购买成功的C++课程或Java课程或Python课程的次数cnt，并且输出结果按照user_id升序排序，以上例子查询结果如下:

解析：

SQL79

-- 方法一：普通法
select * from
order_info
where user_id in
(
    select user_id
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name in ('C++','Java','Python')
    group by user_id
    having count(status) >= 2
)
and status = 'completed'
and product_name in ('C++','Java','Python')
and date > '2025-10-15'
order by id

-- 方法二：窗口函数
select id
,user_id
,product_name
,status
,client_id
,date
from 
(
    select *
    ,count(*)over(partition by user_id) cnt
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name in ('C++','Java','Python')
) a
where cnt >= 2
order by id

SQL82-83

有很多同学在牛客购买课程来学习，购买会产生订单存到数据库里。

有一个订单信息表(order_info)，简况如下:

第1行表示user_id为557336的用户在2025-10-10的时候使用了client_id为1的客户端下了C++课程的非拼团(is_group_buy为No)订单，但是状态为没有购买成功。

第2行表示user_id为230173543的用户在2025-10-12的时候使用了client_id为2的客户端下了Python课程的非拼团(is_group_buy为No)订单，状态为购买成功。

。。。

最后1行表示user_id为557336的用户在2025-10-25的时候使用了下了C++课程的拼团(is_group_buy为Yes)订单，拼团不统计客户端，所以client_id所以为0，状态为购买成功。

有一个客户端表(client)，简况如下:

问题：

SQL82 牛客的课程订单分析(六)

请你写出一个sql语句查询在2025-10-15以后，同一个用户下单2个以及2个以上状态为购买成功的C++课程或Java课程或Python课程的订单id，是否拼团以及客户端名字信息，最后一列如果是非拼团订单，则显示对应客户端名字，如果是拼团订单，则显示NULL，并且按照order_info的id升序排序，以上例子查询结果如下:

SQL83 牛客的课程订单分析(七)

请你写出一个sql语句查询在2025-10-15以后，同一个用户下单2个以及2个以上状态为购买成功的C++课程或Java课程或Python课程的来源信息，第一列是显示的是客户端名字，如果是拼团订单则显示GroupBuy，第二列显示这个客户端(或者是拼团订单)有多少订单，最后结果按照第一列(source)升序排序，以上例子查询结果如下:

解析：

SQL82

-- 方法一：初始笨拙法
select o.id
,is_group_buy
,case when is_group_buy = 'Yes' then 'None'
      when is_group_buy='No' then name end client_name 
from order_info o
left join client c -- 这题要left join
on o.client_id = c.id
where date > '2025-10-15'
and status = 'completed'
and product_name IN ('C++','Java','Python')
and user_id IN
(
    select user_id
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name IN ('C++','Java','Python')
    group by user_id
    having count(status) >= 2
)
order by o.id

-- 方法二：由于使用左连接不需要用case when
select o.id
,is_group_buy
,name client_name 
from order_info o
left join client c -- 这题要left join
on o.client_id = c.id
where date > '2025-10-15'
and status = 'completed'
and product_name IN ('C++','Java','Python')
and user_id IN
(
    select user_id
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name IN ('C++','Java','Python')
    group by user_id
    having count(status) >= 2
)
order by o.id

-- 方法三：用窗口函数进一步简化
select a.id
,is_group_buy
,name client_name 
from
(
    select *
    ,count(*)over(partition by user_id) cnt
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name IN ('C++','Java','Python')
) a
left join client c -- 这题要left join
on a.client_id = c.id
where cnt >= 2
order by a.id

SQL83

-- 方法一：初始笨拙法
select COALESCE(source,'GroupBuy')
,count(*) cnt
from
(
    select o.id
    ,name source
    from order_info o
    left join client c
    on o.client_id = c.id
    where date > '2025-10-15'
    and status = 'completed'
    and product_name in ('C++','Java','Python')
    and user_id IN
    (
        select user_id
        from order_info
        where date > '2025-10-15'
        and status = 'completed'
        and product_name in ('C++','Java','Python')
        group by 1
        having count(status) >= 2
    )
) a
group by 1
order by 1

-- 方法二：窗口函数简化版
select COALESCE(name,'GroupBuy')
,count(*) cnt
from
(
    select *
    ,count(*)over(partition by user_id) num
    from order_info
    where date > '2025-10-15'
    and status = 'completed'
    and product_name in ('C++','Java','Python')
) a
left join client c
on a.client_id = c.id
where num >= 2
group by 1
order by 1

SQL86

实习广场投递简历分析(三)

在牛客实习广场有很多公司开放职位给同学们投递，同学投递完就会把简历信息存到数据库里。

现在有简历信息表(resume_info)，部分信息简况如下:

第1行表示，在2025年1月2号，C++岗位收到了53封简历

。。。

最后1行表示，在2027年2月6号，C++岗位收到了231封简历

请你写出SQL语句查询在2025年投递简历的每个岗位，每一个月内收到简历的数目，和对应的2026年的同一个月同岗位，收到简历的数目，最后的结果先按first_year_mon月份降序，再按job降序排序显示，以上例子查询结果如下:

-- 思路都是筛选2025年各岗位每月做临时表a，2026年各岗位每月做临时表b，再进行连接
-- 我的看似复杂，其实结构也是这个
select a.job
,first_year_mon
,first_year_cnt
,second_year_mon
,second_year_cnt
from
(
select job
,substring(date,1,7) first_year_mon
,substring(date,6,2) first_mon
,sum(num) first_year_cnt
from resume_info r1
where substring(date,1,4) = '2025'
group by 1,2,3
) a
join
(
select job
,substring(date,1,7) second_year_mon
,substring(date,6,2) second_mon
,sum(num) second_year_cnt
from resume_info r2
where substring(date,1,4) = '2026'
group by 1,2,3
) b
on a.job = b.job
and a.first_mon = b.second_mon
order by first_year_mon desc,a.job desc

SQL88

SQL88 最差是第几名(二)

TM小哥和FH小妹在牛客大学若干年后成立了牛客SQL班，班的每个人的综合成绩用A,B,C,D,E表示，90分以上都是A，80~90分都是B，60~70分为C，50~60为D，E为50分以下

因为每个名次最多1个人，比如有2个A，那么必定有1个A是第1名，有1个A是第2名(综合成绩同分也会按照某一门的成绩分先后)。

每次SQL考试完之后，老师会将班级成绩表展示给同学看。

现在有班级成绩表(class_grade)如下:

第1行表示成绩为A的学生有2个

.......

最后1行表示成绩为D的学生有2个

老师想知道学生们综合成绩的中位数是什么档位，请你写SQL帮忙查询一下，如果只有1个中位数，输出1个，如果有2个中位数，按grade升序输出，以上例子查询结果如下:

解析:

总体学生成绩排序如下:A, A, B, B, B, B, C, C, C, C, D, D，总共12个数，取中间的2个，取6，7为:B,C

-- 初始版
select grade
from
(
    select grade
    ,number
    ,sum(number)over(order by grade) posn1
    ,sum(number)over(order by grade desc) posn2
    from class_grade
) a
where posn1 >= round(case when (select sum(number) from class_grade)%2=0 then (select sum(number) from class_grade)/2 else ((select sum(number) from class_grade)+1)/2 end,0)
and posn2 >= round(case when (select sum(number) from class_grade)%2=0 then (select sum(number) from class_grade)/2 else ((select sum(number) from class_grade)+1)/2 end,0)
order by grade

-- 简化版
select grade
from
(
    select grade
    ,number
    ,(select sum(number) from class_grade) total
    ,sum(number)over(order by grade) posn1
    ,sum(number)over(order by grade desc) posn2
    from class_grade
) a
where posn1 >= total/2 and posn2 >= total/2
order by grade

SQL90

SQL90 获得积分最多的人(二)

牛客每天有很多用户刷题，发帖，点赞，点踩等等，这些都会记录相应的积分。

有一个用户表(user)，简况如下：

还有一个积分表(grade_info)，简况如下:

第1行表示，user_id为1的用户积分增加了3分。

第2行表示，user_id为2的用户积分增加了3分。

第3行表示，user_id为1的用户积分又增加了1分。

.......

最后1行表示，user_id为3的用户积分增加了1分。

请你写一个SQL查找积分增加最高的用户的id(可能有多个)，名字，以及他的总积分是多少，查询结果按照id升序排序，以上例子查询结果如下:

解释:

user_id为1和3的2个人，积分都为4，都要输出

select id
,name
,grade_num
from
(
    select *
    ,dense_rank()over(order by grade_num desc) r
    from
    (
    select u.id
    ,name
    ,sum(grade_num) grade_num
    from grade_info g
    join user u
    on g.user_id = u.id
    group by 1,2
    ) a
) b
where r = 1

SQL91

SQL91 获得积分最多的人(三)

牛客每天有很多用户刷题，发帖，点赞，点踩等等，这些都会记录相应的积分。

有一个用户表(user)，简况如下：

还有一个积分表(grade_info)，简况如下:

第1行表示，user_id为1的用户积分增加了3分。

第2行表示，user_id为2的用户积分增加了3分。

第3行表示，user_id为1的用户积分减少了1分。

.......

最后1行表示，user_id为3的用户积分减少了1分。

请你写一个SQL查找积分最高的用户的id，名字，以及他的总积分是多少(可能有多个)，查询结果按照id升序排序，以上例子查询结果如下:

解释:

user_id为1和3的先加了3分，但是后面又减了1分，他们2个是2分，

其他3个都是3分，所以输出其他三个的数据

-- 方法一
select id
,name
,grade_sum
from
(
    select *
    ,rank()over(order by grade_sum desc) r
    from
    (
        select u.id
        ,u.name
        ,sum(true_grade) grade_sum
        from user u
        join
        (
        select *
        ,case when type='add' then grade_num else -1*grade_num end true_grade
        from grade_info
        ) a
        on u.id = a.user_id
        group by 1,2
    ) b
) c
where r = 1
order by 1

-- 方法二：简化版
select id
,name
,grade_sum
from
(
    select *
    ,rank()over(order by grade_sum desc) r
    from
    (
        select u.id
        ,u.name
        ,sum(case when type='add' then grade_num else -1*grade_num end) grade_sum
        from user u
        join grade_info g
        on u.id = g.user_id
        group by 1,2
    ) b
) c
where r = 1
order by 1

十道题搞定SQL

2024-04-03T03:40:26+00:00

题目取自戴师兄的视频：https://www.bilibili.com/video/BV1zX4y1u7ZH

数据：

shop.csv

cpc.csv

orders.csv

第一关

2020年第一季度下单人数前3名的门店，业绩表现如何（GMV、下单人数、曝光人数、进店人数）

解答：

先按字面意思进行筛选。

select 门店id
,门店名称
,sum(GMV) 累计GMV
,sum(下单人数) 累计下单人数
,sum(曝光人数) 累计曝光人数
,sum(进店人数) 累计进店人数
from shop
where 日期 between '2020-01-01' and '2020-03-31'
group by 门店id,门店名称
order by 累计下单人数 desc
limit 3;

输出：

+------------+--------------+-----------+--------------------+--------------------+--------------------+
| 门店id     | 门店名称     | 累计GMV   | 累计下单人数       | 累计曝光人数       | 累计进店人数       |
+------------+--------------+-----------+--------------------+--------------------+--------------------+
| 2001104355 | 宝山店       |    116071 |               1639 |             143877 |              11659 |
| 2000507076 | 五角场店     |     80408 |               1282 |              87435 |               5935 |
| 8184590    | 五角场店     |     54560 |                875 |              58639 |               4173 |
+------------+--------------+-----------+--------------------+--------------------+--------------------+

这里有个很有意思的问题，就是门店名称虽然基本是唯一的，但是它们的id却会有多个，原因是因为门店会依据平台补贴政策灵活地进行业店重开，所以，最终答案是要按门店名称进行分组，否则得到的不是真实总业绩。后面的同理。

select 品牌名称
,门店名称
,sum(GMV) 累计GMV
,sum(下单人数) 累计下单人数
,sum(曝光人数) 累计曝光人数
,sum(进店人数) 累计进店人数
from shop
where 日期 between '2020-01-01' and '2020-03-31'
group by 品牌名称,门店名称
order by 累计下单人数 desc
limit 3;

输出：

+-----------------------------------+--------------+-----------+--------------------+--------------------+--------------------+
| 品牌名称                          | 门店名称     | 累计GMV   | 累计下单人数       | 累计曝光人数       | 累计进店人数       |
+-----------------------------------+--------------+-----------+--------------------+--------------------+--------------------+
| 蛙小辣火锅杯（总账号）            | 五角场店     |    134968 |               2157 |             146074 |              10108 |
| 蛙小辣火锅杯（总账号）            | 宝山店       |    137384 |               1979 |             180783 |              14535 |
| 蛙小辣火锅杯（总账号）            | 怒江路店     |     40900 |                689 |              46964 |               3446 |
+-----------------------------------+--------------+-----------+--------------------+--------------------+--------------------+

第二关

2020年第一季度每个月，每个门店的累计GMV

解答：

select 品牌名称
,门店名称
,substr(日期,1,7) 月份
,sum(GMV) 累计GMV
from shop
where 日期 between '2020-01-01' and '2020-03-31'
group by 1,2,3
order by 1,2,3;

输出：

+-----------------------------------+-------------------------------------+---------+-----------+
| 品牌名称                          | 门店名称                            | 月份    | 累计GMV   |
+-----------------------------------+-------------------------------------+---------+-----------+
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-03 |         0 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-01 |     92062 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-02 |         0 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-03 |     42906 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01 |     37157 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-02 |     39550 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-03 |     60677 |
| 蛙小辣火锅杯（总账号）            | 怒江路店                            | 2020-01 |     12185 |
| 蛙小辣火锅杯（总账号）            | 怒江路店                            | 2020-02 |      6319 |
| 蛙小辣火锅杯（总账号）            | 怒江路店                            | 2020-03 |     22396 |
| 蛙小辣火锅杯（总账号）            | 龙阳广场店                          | 2020-01 |     36558 |
+-----------------------------------+-------------------------------------+---------+-----------+

第三关

2020年第一季度曝光人数大于10w的门店，每个月的GMV

这道题只需在前一题的基础上，筛选出满足“2020年第一季度曝光人数大于10w”就行了（由于外层是按照月份累计的，所以才需要用两层select）

解答：

select 品牌名称
,门店名称
,substr(日期,1,7) 月份
,sum(GMV) 累计GMV
from shop
where 日期 between '2020-01-01' and '2020-03-31'
and 门店名称 in (
    select 门店名称
		from shop where 日期 between '2020-01-01' and '2020-03-31'
		group by 门店名称
		having sum(曝光人数)>10000
)
group by 1,2,3
order by 1,2,3;

输出：

+-----------------------------------+-----------------+---------+-----------+
| 品牌名称                          | 门店名称        | 月份    | 累计GMV   |
+-----------------------------------+-----------------+---------+-----------+
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-01 |     92062 |
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-02 |         0 |
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-03 |     42906 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-01 |     37157 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-02 |     39550 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-03 |     60677 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-01 |     12185 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-02 |      6319 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-03 |     22396 |
| 蛙小辣火锅杯（总账号）            | 龙阳广场店      | 2020-01 |     36558 |
+-----------------------------------+-----------------+---------+-----------+

第四关

2020年第一季度cpc总费用小于1000的门店（门店ID不同视为不同门店），每个月的GMV

解答：

和第三题几乎一样

select 品牌名称
,门店名称
,substr(日期,1,7) 月份
,sum(GMV) 累计GMV
from shop
where 日期 between '2020-01-01' and '2020-03-31'
and 门店id in (
    select 门店id
		from cpc c
		where 日期 between '2020-01-01' and '2020-03-31'
		group by 门店id
		having sum(cpc总费用)<1000
)
group by 1,2,3
order by 1,2,3;

输出：

+-----------------------------------+-----------------+---------+-----------+
| 品牌名称                          | 门店名称        | 月份    | 累计GMV   |
+-----------------------------------+-----------------+---------+-----------+
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-01 |     92062 |
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-02 |         0 |
| 蛙小辣火锅杯（总账号）            | 五角场店        | 2020-03 |     42906 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-01 |         0 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-02 |      1152 |
| 蛙小辣火锅杯（总账号）            | 宝山店          | 2020-03 |     20161 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-01 |     12185 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-02 |      6319 |
| 蛙小辣火锅杯（总账号）            | 怒江路店        | 2020-03 |     22396 |
| 蛙小辣火锅杯（总账号）            | 龙阳广场店      | 2020-01 |     36558 |
+-----------------------------------+-----------------+---------+-----------+

第五关

查询2020年饿了么平台上每个门店GMV最高那天的日期和GMV

select 平台
,门店名称
,日期
,GMV
from
(
select 平台
,门店名称
,日期
,GMV
,dense_rank() over(partition by 平台,门店名称 order by GMV desc) r
from shop
where 日期 between '2020-01-01' and '2020-12-31'
and 平台='eleme'
) a
where a.r=1
order by 日期;

输出：

+--------+-------------------------------------+------------+-------+
| 平台   | 门店名称                            | 日期       | GMV   |
+--------+-------------------------------------+------------+-------+
| eleme  | 宝山店                              | 2020-01-03 |  4093 |
| eleme  | 龙阳广场店                          | 2020-01-05 |  3451 |
| eleme  | 五角场店                            | 2020-01-22 |  3778 |
| eleme  | 拌客干拌麻辣烫(武宁路店)            | 2020-06-04 | 11013 |
+--------+-------------------------------------+------------+-------+

第六关

所有门店20年7月的累计GMV、累计CPC、累计商家实收、累计用户实付

如果细心观察会发现，这题不能直接将这三张表连起来，因为orders表与另外两张表的层级不一样，orders更细致，同一天有多条记录，所以需要先聚合一下，再join。

select 品牌名称
,门店名称
,sum(GMV) 累计GMV
,sum(cpc总费用) 累计cpc总费用
,sum(商家实收) 累计商家实收
,sum(用户实付) 累计用户实付
from shop s left join cpc c
on s.日期=c.日期
and s.门店ID=c.门店iD
left join (
select 门店ID,下单日期, sum(用户实付) 用户实付
from orders group by 1,2
) o
on s.日期=o.下单日期
and s.门店ID=o.门店ID
where s.日期 between '2020-07-01' and '2020-07-31'
group by 1,2;

输出：

+-----------------------------------+-------------------------------------+-----------+--------------------+--------------------+--------------------+
| 品牌名称                          | 门店名称                            | 累计GMV   | 累计cpc总费用      | 累计商家实收       | 累计用户实付       |
+-----------------------------------+-------------------------------------+-----------+--------------------+--------------------+--------------------+
| 蛙小辣火锅杯（总账号）            | 宝山店                              |     60875 |               2190 |              22037 |               NULL |
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            |    215690 |              11424 |              70115 |           13685.13 |
+-----------------------------------+-------------------------------------+-----------+--------------------+--------------------+--------------------+

第七关

拌客在饿了么上20年第二季度每个月的GMV，以及每个月GMV在20年第二季度累计GMV的占比

解答：

这个很好做，不过如果用窗口函数更简洁

select 品牌名称
,substring(日期,1,7) 月份
,sum(GMV) 当月GMV
,concat(round((sum(GMV)/sum(sum(GMV))over())*100,0),'%')  占比
from shop s
where s.日期 between '2020-04-01' and '2020-06-30'
and 品牌名称 like '%拌客%'
and 平台='eleme'
group by 1,2

注意sum(GMV)即group by的结果，然后给窗口函数接着处理。这里sum()over()如果没有partition by和order by，默认为全区的固定窗口。

输出：

+--------------------------+---------+-----------+--------+
| 品牌名称                 | 月份    | 当月GMV   | 占比   |
+--------------------------+---------+-----------+--------+
| 拌客（武宁路店）         | 2020-05 |    126967 | 39%    |
| 拌客（武宁路店）         | 2020-06 |    196896 | 61%    |
+--------------------------+---------+-----------+--------+

第八关

2020年拌客和蛙小辣两个品牌在饿了么和美团两个平台上各自GMV最高的三天以及这三天的GMV

解答：

这题得用窗口函数。

select 品牌名称
,平台
,日期
from (
select *
,row_number() over(partition by 品牌名称,平台 order by GMV desc) r
from shop
where (品牌名称 like '%拌客%' or 品牌名称 like '%蛙小辣%')
and 平台 in ('eleme','meituan')
and substring(日期,1,4)='2020'
) a
where a.r<=3
order by 1,2,3;

输出：

+-----------------------------------+---------+------------+
| 品牌名称                          | 平台    | 日期       |
+-----------------------------------+---------+------------+
| 拌客（武宁路店）                  | eleme   | 2020-06-02 |
| 拌客（武宁路店）                  | eleme   | 2020-06-03 |
| 拌客（武宁路店）                  | eleme   | 2020-06-04 |
| 拌客（武宁路店）                  | meituan | 2020-07-15 |
| 拌客（武宁路店）                  | meituan | 2020-07-16 |
| 拌客（武宁路店）                  | meituan | 2020-07-17 |
| 蛙小辣火锅杯（总账号）            | eleme   | 2020-01-03 |
| 蛙小辣火锅杯（总账号）            | eleme   | 2020-01-04 |
| 蛙小辣火锅杯（总账号）            | eleme   | 2020-01-22 |
| 蛙小辣火锅杯（总账号）            | meituan | 2020-01-02 |
| 蛙小辣火锅杯（总账号）            | meituan | 2020-01-06 |
| 蛙小辣火锅杯（总账号）            | meituan | 2020-05-03 |
+-----------------------------------+---------+------------+

第九关

2020年拌客和蛙小辣两个品牌各自门店在饿了么GMV排名前5%（GMV为0不计入排名）的日期、GMV、以及具体排名和排名百分比（取一位小数）

解答：

两个窗口函数。

select 品牌名称
,门店名称
,日期
,GMV
,concat(round(p*100,1),'%') 排名百分比
,r 排名
from (
select *
,cume_dist() over(partition by 品牌名称,门店名称 order by GMV desc) p
,row_number() over(partition by 品牌名称,门店名称 order by GMV desc) r
from shop
where (品牌名称 like '%拌客%' or 品牌名称 like '%蛙小辣%')
and 平台 = 'eleme'
and substring(日期,1,4)='2020'
and GMV != 0
) a
where a.p<=0.05;

输出：

+-----------------------------------+-------------------------------------+------------+-------+-----------------+--------+
| 品牌名称                          | 门店名称                            | 日期       | GMV   | 排名百分比      | 排名   |
+-----------------------------------+-------------------------------------+------------+-------+-----------------+--------+
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-06-04 | 11013 | 0.9%            |      1 |
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-06-02 |  9615 | 1.7%            |      2 |
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-06-03 |  9424 | 2.6%            |      3 |
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-05-26 |  9231 | 3.4%            |      4 |
| 拌客（武宁路店）                  | 拌客干拌麻辣烫(武宁路店)            | 2020-05-30 |  8992 | 4.3%            |      5 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-01-22 |  3778 | 1.1%            |      1 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-01-10 |  3609 | 2.1%            |      2 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-01-03 |  3455 | 3.2%            |      3 |
| 蛙小辣火锅杯（总账号）            | 五角场店                            | 2020-01-21 |  3402 | 4.3%            |      4 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-03 |  4093 | 0.4%            |      1 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-04 |  4058 | 0.8%            |      2 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-07 |  3735 | 1.2%            |      3 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-05 |  3577 | 1.6%            |      4 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-01 |  3546 | 2%              |      5 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-10 |  3333 | 2.4%            |      6 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-08 |  3300 | 2.9%            |      7 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-02 |  2878 | 3.3%            |      8 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-01-09 |  2757 | 3.7%            |      9 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-03-12 |  2594 | 4.1%            |     10 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-04-26 |  2434 | 4.5%            |     11 |
| 蛙小辣火锅杯（总账号）            | 宝山店                              | 2020-02-26 |  2324 | 4.9%            |     12 |
| 蛙小辣火锅杯（总账号）            | 龙阳广场店                          | 2020-01-05 |  3451 | 4.5%            |      1 |
+-----------------------------------+-------------------------------------+------------+-------+-----------------+--------+

第十关

2020年拌客在双平台每日GMV及前一日GMV，及GMV周同比增长量与百分比

这题显然要用窗口函数的lag函数。

select *
,当日GMV - 上周GMV GMV周同比增长量
,concat(round(((当日GMV - 上周GMV)/上周GMV)*100,0),'%') GMV周同比
from
(
select 品牌名称
,平台
,日期
,GMV 当日GMV
,lag(GMV,1,0) over(partition by 品牌名称,平台 order by 日期) 前日GMV
,lag(GMV,7,0) over(partition by 品牌名称,平台 order by 日期) 上周GMV
from shop
where 品牌名称 like '%拌客%'
and 平台 in ('eleme','meituan')
and substring(日期,1,4)='2020'
and GMV != 0
) a

输出：

-- 略

戴师兄总结：

1、尽可能使用分步解题法，顺着题目一步步写

2、写SQL代码时应该尽量脱离数据库，在脑海里完成代码的组合和调试

3、遇到特别复杂的逻辑，一次查询无法解决，可以直接上子查询，然后再慢慢优化

4、遇到暂时想不清楚的地方，可以先搁置，最后基于其他步骤已成型的代码进行推导

5、实在不行就画图，或者用excel表格先处理出来，再一步步用SQL实现

6、完成代码后一定要尽量优化自己的代码，这样逻辑才能越来越好

7、不断反复练习，最终能在读题时就在脑海里理清代码逻辑

我的无限游戏

2024-04-03T03:40:26+00:00

世上至少有两种游戏。一种可称为有限游戏，另一种称为无限游戏。有限游戏以取胜为目的，而无限游戏以延续游戏为目的。

……

世上有且只有一种无限游戏。

——摘自《有限与无限的游戏》

如今运行在互联网上的网络游戏平均寿命也就一到两年，无论玩家在网络游戏的虚拟载体中注入多少时间精力，由于网络游戏的商业性质，其最终都难免面临游戏停运、关服的终点，无数玩家用大量时间精力构建的意义系统随之也被摧毁或削弱。而越是热爱的玩家，游戏停运、关服之后越会难免感到失去陪伴的无所适从。

网络游戏注定只适用于短期刺激多巴胺，难以稳定地构建起人生的意义。因为它本质是种有限游戏，而无限游戏（以延续游戏为目的）无法在有限游戏中进行，于是妄想在其上构建起跨越人生的意义系统的人最终反而更容易感受到意义缺失感。而「缺失感」正是人类幸福的大敌。

正如韦伯所言，“人是悬挂在自己编织的意义之网上的动物”，人趋向的栖息之地是意义之网，而且是自己选择的意义之网。但很少人能够察觉，很多看似是自己的选择，实际上不过来自更高维度的操控。在自我选择与被操控的角度讲，绝大多数网络游戏带来的所谓意义之网的栖息行为实际上是属于「操控用户以为该行为是自我选择的」。如果说有哪个行业将人类进化而来的动机系统 bug 利用得淋漓尽致，毫无疑问第一是游戏行业，情色行业都只敢称第二。

其中电子游戏如此成功，让人类整体正在向游戏世界加速大迁徙。然而，即便越来越多人类逐游戏而居，我也仍不为所动，因为我想要的意义之网不是那种由他人编织的网，我不想栖息在他人设计的特别是想操控我的网，我只会栖息在自己编织的意义之网之上。我将坚守大本营，只主要玩一场游戏——人生游戏——这个大型角色养成游戏。这里才是我能尽量自己控制的、尽量能自己构建意义系统的地方。我会在这场游戏中玩好、玩出意义来，而不是在游戏的游戏中浪费太多精力。

当然，在我看来，游戏的游戏并非都是浪费精力，关键是要看它是否符合自己的意志，例如，我允许自己玩自己做的游戏（做测试、激发自豪感），例如聚会与朋友玩几把游戏（回忆过往、拉近友情）。但市场上绝大多数网络游戏，本质为的就是想方设法让用户上瘾（留存率、病毒性）以及尽可能赚钱（转化率、客户终身价值），当然我并不认为这本身有什么不对，天地不仁以万物为刍狗。对我来说，这是他人意志主导的游戏，在他人的地盘上，即使自己的意志再强，最终也会非常容易被他人的意志主导，所以我选择远离这些游戏。

但是，远离不代表不学习其强大之处。虽然我不再玩这些游戏了，但我想，是不是可以利用游戏的机制，让人更好地实现自控？例如我发现 habitica 这款游戏可以将玩家的生活习惯、每日任务等映射到游戏中，从而大大提高日常生活的仪式感与趣味性。

正如《有限与无限的游戏》中的最后一句话所言，“世上有且只有一种无限游戏”，那无疑就是人生，美团王兴是这样诠释的：

“有限游戏在边界内玩，无限游戏却是在和边界，也就是和「规则」玩，探索改变边界本身。实际上只有一个无限游戏，那就是你的人生，死亡是不可逾越的边界。与之相比，其他的边界并不是那么重要了。”

无限游戏中的游戏想要也成为无限游戏，需要与「元无限游戏」——人生——形成映射关系，可以离散映射，也可以连续映射，但必须是长期映射也就是要长期相互联系，长期的边界可以是死亡。

例如 habitica 可以被玩家设计成一款无限游戏，一款与其人生对应的无限游戏。如果该游戏停运了（如果有足够多把它视为无限游戏的玩家可能性就不大），由于其代码开源，玩家也可以搭服务器继续玩。玩这款游戏完全是玩家自己的意志在主导，虽然没有利用人类大脑 bug 的网络游戏的上瘾机制强，但给人的掌控感体验也是不错的，多巴胺分泌是微量而绵长的，其好玩程度取决于玩家如何运用。正如人生，其意义是自我赋予的。

除了狭义的游戏，生活中，只要是能与人生长期挂钩的东西都可以成为无限游戏，例如某项技能、某段关系等，但前提是要转换视角。例如从结果上看某人的确使用了某项技能一生，但过程中，用的是有限游戏视角，他并没有想过用一生的时间“玩”好它，只是碰巧使用了一生，那这不算是他的无限游戏。无限游戏的视角，核心是开头那句——无限游戏以延续游戏为目的。例如学英语，如果只是为了通过考试，那它无疑是场有限游戏，而与人生绑定——“学它并不是为了在某某处取胜，而是我就是一生要阅读/交流的人，我需要用它，并需要持续用它”，这样想就是无限游戏思维。

有什么东西可以持续一生，而且延续它本身就是目的吗？我还没有太多头绪。阅读算是吧，而为此英语算是吧，因为我要看英文书。哦，对了，我脖子上顶着的可能是全宇宙最复杂精密的仪器之一（笑什么，你不也有），我想持续调试与构建它，看看有什么有意思的结果。

如何科学地休息？

2024-04-03T03:40:26+00:00

我认为人生更像是一场一个人的长跑。

说是一个人是因为哪怕某些路途中有亲人朋友伴侣的陪伴，但他们最多能给予鼓励与帮助，人生绝大多数事情都是要独自面对的，路最终都是每个人自己选择出来的。另外，人生漫漫，困难重重，不是简单的百米冲刺，而是一个长期的折腾过程，更像长跑。长跑意味着起点跑得快没用，得合理分配精力。

人体是一个“反脆弱”系统。但“反脆弱”是有限度的。能恢复过来，就是反脆弱，会变得更强大；恢复不过来，反而会变得脆弱。因此，休息和恢复与学习和训练具有同等重要地位。用一个公式表达，就是成长 = 训练/压力 + 休息。训练/压力太大而休息太少，人就会被击垮；训练/压力不够而休息太多，人就会因为刺激不够或缺乏动力而停滞不前。合理分配压力和休息，才能高效、持续地成长。

这对于身体与大脑都是适用的。对于身体，进行有针对性的、高强度的训练，然后休息，身体就会超量恢复，能接受更大的刺激。下次再重复这个过程，但略微提高强度，就持续不断地开启超量恢复，循环向上地提升身体机能；对于大脑，要合理安排学习内容与难度，确保每次学习或者工作都是在稍微高出自己当前能力的水平上，这样不仅能对大脑给予适当强度的训练刺激，而且不容易厌倦或焦虑。

下面讲讲如何科学地休息，主要针对的是大脑。

1.睡眠

首先，最重要的就是睡眠了。它的作用不仅仅是消除疲劳，更重要的是让身体和大脑“成长”。睡眠要规律，以每晚7-9个小时为宜，具体长短因人而异，以不用闹钟、自然醒为最好。为了保证良好睡眠，晚上最好不要从事剧烈的脑力劳动。睡前不要使用手机、电脑或者iPad等电子产品。不要指望用打盹代替睡眠，打盹的作用仅限于恢复能量和注意力，且时间不要超过30分钟。

2.定时短休息

一天中不要等已经感觉疲倦了才休息，而是要计划好定时的短休息，在一天的工作之中随时进行。有的研究说最佳间隔时间是每工作52分钟休息17分钟，也有的研究说是 50 + 7，51 + 9 等等，大体来说，差不多是工作不到一小时，就休息十来分钟。不过我认为，如果你每天工作时间很长，就需要更均匀更充分的休息，直接采用番茄工作法的“每工作25分钟休息5分钟”也就是 25 + 5 或许会更好。

注意，休息的这几分钟时间就不要再想工作的事儿了。要离开工作去做一些不消耗认知力的事儿。《科学休息法》提到的最关键的研究结果就是凡是看电影、看书、玩手机这种消耗精力的活动都不叫休息，它们只会让你更累。

其次，动起来比不动好，户外比室内好，活动肢体可以增加给大脑的供血量，而回到大自然中会对大脑产生明显的休息效果。例如可以散步五分钟，就算不正式散步，每隔一个小时站起来走几步的休息效果也很好。例如可以找个有树的地方接触大自然，而如果在室内可以通过窗户眺望一下远方的景色，甚至看大自然图片，也能对大脑产生明显的效果。

另外，找人随便聊聊天比独自一个人休息的效果好。可以把这个短休息用于社交，例如跟朋友聚会，聊聊天。

最后，可以在下午最困的时候小睡一会儿。小睡的关键是一定不能超过25分钟。一般的睡眠是有惯性的，睡着了不愿意醒，整个昏昏沉沉的时间很长 —— 但是20分钟之内的小睡就没有惯性。这方面的研究结果可以用下面这张图表示 ——

3.减少选项

人生任何阶段，确保只有一个最大的欲望来提供前进的动力，减少各种不必要的欲望，太多欲望会使注意力分散。

无谓的纠结和生活中的各种诱惑，会极大消耗人的精力。要减少生活中的各种需要选择的场合，提前避开诱惑，这样能避免在选择和诱惑上耗能。

4.冥想

学会冥想。它不仅能起到休息的作用，还能锻炼我们监控注意力的能力，另外有研究发现长期冥想可以抑制大脑的默认模式网络，让我们从大脑喋喋不休的底噪中解脱出来；有的研究发现冥想可以改变大脑结构——增加大脑主要负责工作记忆和执行决策的额叶皮层的大脑灰质。

找个不受打扰的时间，舒服地坐在一个安静的地方；深呼吸，体会肚子随着呼吸起起伏伏。意识始终只想呼吸，但不用刻意回避脑子里冒出来的想法，承认它，然后把它放走。从每天1分钟开始，逐渐增加时间。

5.休假

好的休假就像充电，可以让人在后面很长一段时间有充沛精力。

身体训练上，即便每周都安排了好几天间隙供身体恢复，长时间训练也还是可能积累劳损，一般每2-3个月就需要安排一个恢复周，给身体放个假，期间不训练或者强度降低一半，以供身体进行深度的恢复。

大脑也是一样，即便每天都安排了密集的短休息，连续一周的密集工作也容易让大脑积累疲劳，这时候就需要给自己放半天到一天的假了，让大脑获得比较深的恢复。有条件可以每年都集中安排长达数星期的休假。休假的时候，要完全抛开工作。除了散步、回归自然、跟朋友聚会，还可以听音乐、洗澡，但是打游戏、半夜刷手机这些消耗注意力的活动，统统不行。

参考资料：

https://m.igetget.com/share/course/article/article_id/84948
万维钢关于高手如何休息的清单
《洞见：从科学到哲学，打开人类的认知真相》

我的学习观

2024-04-03T03:40:26+00:00

学习与自我

虽然「人有无自由意志的问题」学界还在争论，但我倾向于相信人类具有「自由意志」，人类前额叶皮质演化成占整个大脑皮质面积的将近1/3，而猴子只占1/10，猫只占1/30，我乐观猜测这足以保证自由意志的存在（虽然非常地弱）。在假设人有「自由意志」的前提下，我把人类的自由意志简单分为两层，首先是「隐性自由意志」，这是几乎所有人类都具备的，它是使人类与其他动物不同的主要原因；更高的那层是「显性自由意志」，即若一个拥有「隐性自由意志」的人去“怀疑自由意志是否存在”、“意识自己的意识”、“思考自己的思考”等等，即他开始去显性地思考「自由意志」了，则他的「隐性自由意志」就被激活为「显性自由意志」，他进一步就可以更加灵活地运用「自由意志」来改变「自我」了。

在我看来，「学习」就是「自我超越」的过程。我们每个人都有各自独特的出身、性格、知识水平、价值观等，但这个「自我」的形态几乎是由过去内部决定性因素「基因」与外部决定性因素「环境」的交错作用所决定的。除非拥有「自由意志」，并在「自由意志」的主导下进行「学习」，以改造「自我」，才能尽可能摆脱「宿命」的束缚，实现「自我超越」。

改造自我主要改变的是自己的大脑神经元，此外也包括身体的其他部分，通过有意识地学习，我们改变着神经元的连接与分布，可以让我们学会一门外语、学会数学计算、学会弹钢琴等等；甚至可以通过刻意地练习，改变我们对外界的情绪反应模式，以改变自己的所谓脾气、性格等；也完全可以学习模仿好的思维习惯，以改善我们的思考效率；对肌肉细胞进行相应刺激，我们可以改变身体相应部位的形态……每次「学习」，都能让我们得以重新定义「自我」，「学习」让「自我」从静态变成了动态，即学习前后，我们不是同一个人。

学习要诀

自己尝试也看别人尝试了非常多的学习方法，我发现学习方法本身的有用程度主要取决于其合乎大脑学习记忆特征的程度，而学习方法是否能取得预期效果则主要取决于使用者是否具备直面困难的能力，而这需要相应的自由意志的支撑，它决定着如注意力管理能力、自制力等影响因素。没有强大的自由意志，没有良好的自制力等，不可能做到直面困难，也不可能能够按照高效的学习方法一步步做下去。

无法直面困难而避重就轻的人终归是低效的，二八定律总是存在，80%的进步靠啃下20%的困难部分铸就，那80%的简单部分只能提供20%的进步。也就是说高效学习的本质就是困难的，因为要求花更多的时间用于刻意地攻克难点，其大多伴随着枯燥感，除非进入心流状态；低效学习才可能是愉悦的，因为只做自己喜欢的简单的而回避困难的。我们不能专门只做简单愉悦的部分，而回避困难的部分，而是应该快速完成简单愉悦的部分，然后把节约出来的时间用于困难的部分。

一个好的学习方法被某人使用发现没有多少效果，主要原因也是使用者跳过执行费力的步骤（即便有些学习方法中的步骤可以简化学习或使学习更有乐趣，但步骤本身也是需要刻意执行的），而只做自己感觉轻松的步骤，但实际上困难的那几步才是关键，能决定80%的学习效果。

我们要想高效学习，光知道高效学习方法是远远不够的，还需要有自由意志的支撑，使得能直面学习内容中的困难部分，使得能直面学习方法中的费力步骤，这才是最关键的。

学习方法

一、辅助

1.良好的睡眠

良好的睡眠是学习的最重要的保障，睡眠不好学习免谈。当天晚上的睡眠好，第二天精力充沛有利于新的学习，又由于睡觉是大脑整理记忆的时候，它很大程度决定了当天学习的吸收情况。

2.高效的休息

注意，凡是看电视、看书、玩手机这种消耗精力的活动都不叫休息，它们只会让我们更累。

休息也应该讲究效率，一天随时进行的定时“短”休息胜过长时间学习后的大段休息，且休息的这几分钟时间：1.动起来比不动好。2.户外比户内好。3.不要再想学习的事。4.与朋友随便聊聊天比独自一个人休息的效果好。

午睡能快速恢复精力，性价比很高，但关键是不能超过25分钟，否则会有睡眠惯性，使得头脑昏昏沉沉的时间很长。

3.简单的生活

不应该先有诱惑而后去抗拒，凡是主动或被动想考验自己抵抗诱惑能力的人，大多数都以失败告终，主动远离诱惑才不至于陷入被动。无谓的纠结和生活中的各种诱惑，会极大地消耗人的精力。保持简单生活，减少选项，远离诱惑，能避免在选择和诱惑上耗能。

4.冥想

找个不受打扰的时间，舒服地坐在一个安静的地方，深呼吸，意识始终停留在呼吸上，若意识到自己走神了，承认它，然后把它放走，继续回到呼吸上。

它不仅能起到休息的作用，还能锻炼我们监控注意力的能力。

5.运动

运动提供着身体健康的整体性保障，为了达到基本的健康获益，成人每周至少需要150分钟的中等强度身体活动或75分钟高强度的有氧运动，以及两天或两天以上的肌肉力量训练。为了达到进一步的健康获益，成人应将每周中等强度有氧运动的时间增加至300分钟或将高强度的有氧运动的时间增加至150分钟。¹

6.饮食

饮食同样提供着身体健康的整体性保障，与学习效率息息相关。

目前最靠谱的饮食指南之一是美国的膳食指南²，核心内容有：

谷类食物是基础，且应保证至少一半以上是全谷物，也就是常说的粗粮。
蔬菜摄入应当多样化，比如绿色（青菜）、红色（西红柿）、橙色（南瓜）等不同颜色蔬菜，豆类（大豆、豌豆）、淀粉类（土豆、红薯）等都需要吃一点。
水果也是必须的，建议直接食用完整水果，而不要总是用榨汁机。
蛋白质类食物摄入也应该多样化，包括鱼肉、瘦肉、禽肉、蛋、豆类、坚果、种子以及其他豆类产品。
乳制品。一天要喝大约708ml脱脂或低脂的牛奶或奶制品。

如果用一个餐盘表示的话，一个好的饮食结构应该是水果和蔬菜占餐盘的一半，谷类和蛋白质类占一半，其中蔬菜略多于水果，谷类略多于蛋白质类，并最好保证每餐都有一杯约240ml的牛奶。

二、技巧

1.先做困难事项

把意志力最强和越不受干扰的宝贵时间优先用于完成最困难的事项，例如早上，不仅趁热打铁不费劲，而且在搞定主要一件件主要任务后使该天剩余时段压力更小。

2.调动学习情绪

集中注意力，并尽量通过如赋予意义、增加难度、设定挑战等，调动学习的积极情绪。累了就休息，心情不好就出去玩，不要强迫自己学习，而要擅于引导大脑调整为好的学习状态。在学习过程中，我们需要调动的情绪是像惊喜、好奇、有趣、“我里个去！”以及解决了一道谜题那种成就感等，既有利于大脑记忆，也有助于保持注意力。

3.可视化

图片比单纯的文字更容易记住，这让学习更有效率（在回忆与转换研究中发现其能达到89%的改善作用），也让事情变得更容易理解。将文字放在与其相关联的图片旁（而不是放在底部或者第二页），学习者将有后者的两倍的几率解决与之相关的问题。

4.实践中学习

学习知识时尽量找到能使用它们的场景，边学边用，利用每一个反馈不断调整自己。在学习效率金字塔中，该法吸收效率位于最顶端。要通过实践让我们被带动、专注、感觉好奇、被激励地去解决问题、形成结论以及产生新知识。

5.设定与拆解目标

学习前应该设定学习目标，且应该将大目标拆解成一个个小任务并逐个击破，这充分顺应了大脑的注意力机制。由于20%的内容决定了80%的学习效果，应识别重点任务，对最重要的学习内容进行反复学习。

6.间隔重复

对于一定的学习内容，少数多次地学完比一次性学完的效果要好很多，且并非复习地越多越好，对于有逻辑关联的内容，也就是绝大多数学习内容，最佳复习间隔为：

第一次学过之后，一两天之内复习一次，然后过一个星期再复习，过一个月再复习。之后，复习间隔可拉得更长。

7.三分阅读七分回想

用大概30%的时间阅读，并用70%的时间去使用头口化、个人化风格背诵与复述，即刻自我检测，因为不断地费力地提取记忆的动作能极大地加深记忆，而重复地阅读过多次是低效的。

三、输出

1.集中注意力

找个安静的、无诱惑的场所，关闭手机，深呼吸，将注意力全部集中在当下，开始逐件完成学习任务。

2.番茄工作法

间隔学习+休息，大致学习25分钟休息5分钟，休息时走动一下，放空大脑。

3.回顾式学习

阅读、看视频或听音频等无论哪种媒介，学习一段后暂停，回顾前面所学，尽可能在头脑中或画图或借助已有图片进行可视化，尽全力进行总结。学习完一大段，还要自己拿试卷、提问题等进行自我测验。

4.追踪式学习

对大的学习任务进行拆分，并用表格记录各段学习日期与计划间隔复习的日期；对错题进行追踪，间隔重做，不遗漏任何不懂的重点问题。

5.输出式学习

尽量找到能使用所学知识的场景，在学习过程中不断输出，构建学习的反馈系统。最好能有构建自己相应作品的大计划，在学习中逐渐实现它。

6.费曼学习法

选择一个概念。选一个你想弄明白的概念，写在空白的笔记本或者纸的最上面。

解释这个概念。把解释这个概念的东西写成一句话，就像你在告诉一个完全不知道这个领域的菜鸟一样。这一步可以让你在阐释这个概念的过程中，可以让你明白你有没有搞懂这个概念，并在这个过程中加深对这个概念的理解。

解释不了时。当你发现你没办法解释的时候，回到书上面去，或者找同学、找老师、找已经懂的人，把书上的概念再重新研究一遍，直到你能在纸上流畅地把这个概念解释出来。

简化语言、学会类比。如果出现一个很学术的或抽象的词语的时候，试着要么平实化词语，要么学会用别的东西来类比它。

参见《美国居民身体活动指南》。 ↩︎
https://en.wikipedia.org/wiki/List_of_nutrition_guides#United_States. ↩︎

完美主义者自救指南

2024-04-03T03:40:26+00:00

虽然也有人以「完美主义」为豪，但「完美主义」最常与「脆弱的」这个形容词一起出现；谷歌搜索「完美主义」，显示的是「用户还搜索了：延宕，强迫症，焦虑，躁郁症，恐惧，注意缺陷障碍」。可见「完美主义」通常并不是什么好词。

实际上，有研究者对「完美主义」作了大致区分：

适应性完美主义（即正常的完美主义）是设置高成就标准、努力追求成功的倾向，反映个体对高个人标准和成就的主动追求，可以容忍在达成标准中的失败，不会对自尊造成无法恢复的损伤。既能带给人们追求目标的动力，同时给他们带来乐趣。

而非适应性完美主义（即神经质的完美主义），同样是追求高标准目标，但他们失败时会感觉到极大的痛苦，导致他们往往是在追求避免犯错，而不是在追求原目标。¹

简言之：

完美主义：追求高标准目标的倾向

适应性完美主义：追求完美，但可以容忍不完美

非适应性完美主义：追求完美，但不能容忍不完美

现实生活中，我们谈论的「完美主义」大多指的是「非适应性完美主义」，饱受困扰的也是「非适应性完美主义者」，故以下的「完美主义」指的是「非适应性完美主义」，而文章内容实际为「非适应性完美主义者自救指南」。

我过去是完美主义者，现在还是，它已经开始阻碍我的进步了。我识别了这个问题，并打算修复它。所以写这篇文章不仅为帮助他人，更是在自我疗愈。

我深知解决思维和态度上的问题，..改变认知..才是根本。层层剖析，摆事实，讲道理，颠覆底层价值观，重构认知，进而得以改变行为习惯。

完美主义，意味着追求目标的完美，同时不能容忍过程和结果的不完美。于是，治疗分两步走。第一步，不追求目标的完美；第二步，容忍过程和结果的不完美。

1.不追求目标的完美

首先，一个人所拥有的各项资源几乎都是有限的，最刚性的约束是时间。在死亡面前，人人生而平等，对于任何一个人，无论贫富出身，无一例外唯一可以百分百确定的是——他将死去。Time is the currency of life. 对于任何一个人，他此时的预期时间余额都是0到43830天²之间的一个数，例如，对目前的我来说大概还有21000天，等待我的终归是死亡。

作为人类，我们一生中需要花去约20年才能发育为成熟个体，之后，还需要工作折合约10年以获取赖以生存的资源……

此外，还有金钱、基因、精力、文化、信息、科技发展水平、随机性等各种其他约束……

我们各阶段需要做什么事、有多少资源去做等等基本都是被约束着的，我们没有太多时间精力实现脑中闪过的所有愿望，我们的人生总会有缺憾，总有想做的事情由于各种条件受限或有其他事情要做而不得不做。更糟糕的是，很多事情即便我们致力去做，也不一定能做到。不完美才是人生的常态。

对此，我们唯一可以做的，是直面人生的不完美。

徐志摩有首诗：

《偶然》

我是天空里的一片云，

偶尔投影在你的波心——

你不必讶异，

更无须欢喜——

在转瞬间消灭了踪影。

你我相逢在黑夜的海上，

你有你的，我有我的，方向；

你记得也好，

最好你忘掉，

在这交会时互放的光亮！

「你记得也好，最好你忘掉」，与不顾一切、害怕失去相比，直面现实、接受现实更显得成熟与勇敢。

对此，我们不需要也不应该设置完美的、面面俱到的目标，而是应该学会放弃。正如林语堂所言，「除了把事情做好的崇高艺术，还有把事情搁下不做的崇高艺术。人生的智慧在于剔除没有必要的事物。」

成大事者所走的路必然是困难重重，不可能可以不费任何代价达到目标，必然需要放弃些什么、必然会产生残缺。

关于巴菲特有这样一则故事：

Mike Flint 做了巴菲特的私人飞行员十年之久，还曾为美国四任总统开过飞机，但他仍在事业上有着更多追求。有一次，他和巴菲特在探讨他的职业生涯目标时，巴菲特让他去做这么一件事：

首先，巴菲特让 Flint 写下他职业生涯最重要的 25 个目标来。于是，Flint 花了一些时间，把这些目标写了下来。

然后，巴菲特让他审视一下这个清单，然后圈出他认为最重要的 5 个。Flint 也照做了。

Flint 现在有了两个清单。一个是他认为自己职业生涯最重要的 5 个目标，另一个是另外 20 个他也觉得比较重要的事。

巴菲特问 Flint：你现在知道该怎么做了么？Flint 答：知道了。我现在会马上开始着手于实现这 5 个目标。至于另外 20 个，并没有那么紧急，所以可以放在闲暇的时间去做，然后慢慢把它们实现。

巴菲特听完后说到：不 Mike，你搞错了。那些你并没有圈出来的目标，不是你应该在闲暇时间慢慢完成的事，而是你应该尽全力避免去做的事——你应该像躲避瘟疫一样躲避它们，不去花任何的时间和注意力在它们上面。³

这正揭示了巴菲特的成功之道。巴菲特曾说成功人士和真正的成功人士之间的区别是后者几乎对所有事情都说不。例如，巴菲特建立了一套非常严格的筛选机制，真正有价值的项目他才投资，而对其他大量的投资机会说不，才使他得以集中精力与资金获得超额回报。

放弃让人能集中时间和注意力在真正重要的事情，产生聚焦的效果，正是放弃使人具有力量，正是残缺让人生成为艺术，而追求完美、没有残缺，注定毫无力量。

未来春藤家长学院CEO老喻则以算法的形式对此进行了概括。

用一句话概括这套「半径算法」，即扩大认知半径，明确能力半径，减小行动半径。

第一，认知半径要尽可能地宽，否则会视野狭窄。
第二，能力半径要尽可能地明确，能力圈大或小不重要，重要的是你知道自己的能力圈有多大，然后待在里面。
第三，行动半径要尽可能地小，找到长期去做的那件事，集中资源把它做到最好。

抑制住目标完美化的冲动，让行动半径保持尽可能小，这也是要懂得放弃。

凡选择皆有代价。你想得到什么，那你愿意放弃什么？

2.容忍过程和结果的不完美

除了倾向于追求目标的完美外，完美主义者的另一困扰是不能容忍过程的不完美，这其中的关键是要改变对待失败的心态。

我们的生活处处充满不确定，你无法百分百确信明天天气真如天气预报所说，无法百分百确定今天下班后老板会不会批评你，甚至无法百分百确定下一秒某人还活着。小概率事件并不罕见，特别是事情越复杂、步骤越多，受到随机性的影响会越大。完美主义者的问题在于思维过于直线化，把达到目标的过程理解成了一个个简单的步骤，并对每一步确信无疑，而无视随机的力量。实际上，我们能控制的事情不多，总有我们考虑不周的地方，总有一些事情的发展轨迹偏离我们的预期，甚至连我们自己都不是完全可控的，我们每个人其实大部分时间都是“自动驾驶的”，认为很多事情是我们自主作出的不过是大脑的一个高明的把戏。⁴重要的不是直线到达目标（这在随机性的世界里也几乎不可能），而是即便遭遇失败，也仍然向着目标前进。

正如伏尔泰所说，完美是优秀的敌人。完美主义者在追求目标的过程中，为了过程的完美而很容易陷入避免犯错的陷阱中，且遇到一个小错误就彻底毁掉了心中的完美设想，接着又选择不接受现实。这种脆弱性让完美主义者反而难以达到优秀。

对此，我们应该拥抱随机性，承认哪怕是简单的目标也有其不可控性，承认达成目标的过程永远都不是直线的，把失败当作反馈，发现了问题就改进，不断接近目标。

除了要能够容忍过程的不完美，最好还应该能够容忍最终结果的不完美，我知道这对完美主义者来说非常难以接受，但考虑以下事实：假设摆在你面前有两个选项。选 A，成功率是60%；选 B，成功率只有40%。科学的决策当然是坚决选 A。那如果你选了 A 之后发现结果却是 B 正确，你能说当初不该选 A 吗？当然不能。我们不能事后诸葛亮，认为如果结果不好，当初肯定决策有问题。而是应该尊重随机性，要关注的是决策过程的合理性，而不能唯结果论事。

此外，我们也要考虑要求过高的可能性。如前所述，完美主义者倾向于追求目标的完美，喜欢面面俱到，可能使得各目标分配到的时间精力非常有限，却要达成完美。这个时候，受限于条件，实际上可能能完成目标的大部分就已经非常不错了，这时我们得接受结果的不完美。

完美主义者不缺乏认真的态度，只需一点直面现实的勇气，就能让我们成为优秀的人。愿你我都能够勇敢地迈出这一步。

Hamachek, D. E. (1978). psychodynamics of normal and neurotic perfectionism. Psychology, 15, 27-33. ↩︎
科学家根据端粒以及细胞的分裂周期，推测人类的理论极限寿命大约是120岁。 ↩︎
摘自 https://zhuanlan.zhihu.com/p/22812913 。 ↩︎
详见《注意力：专注的科学与训练》。 ↩︎

简单生活

2024-04-03T03:40:26+00:00

面对越来越复杂的生活，近几年兴起了一波「极简主义」浪潮，倡导「极简生活」。这可能确实是此情此景下生活方式与心态上的一大进步，但是似乎留下了一个 bug，其问题在于这个「极」字。

百度百科对极简主义的定义（2020-10-04版）如下：

极简主义是生活及艺术的一种风格，本意在于极力追求简约，并且拒绝违反这一形态的任何事物。

我认为「极简」同「极乱」一样，都是复杂度天平上的极端。极简主义对如今过度浮躁的社会风气具有矫正作用，如网络时代下的事事凑热闹、对各种资料的收集癖以及对感情的贪婪等。但极简主义存在矫枉过正的嫌疑，因为极简也容易导向另一个极端——完美主义——固执地一定要清空所有的杂物、所有的烦恼、所有的欲望，与一切都断舍离。

我们的确存在过度复杂化的倾向，但面对人的差异性，每个人所需要的简化程度是不同的，极简主义并不适合每个人，反而只适合少部分人。我们需要的并不是「极简的生活」，而是「简单的生活」，「简单」二字是自带「相对性」性质的，因为每个人认为的简单都不一样，想着「我要简单的生活」，做起来时会以自身过去的复杂程度做比较，进行简化。这样能避免「极简主义」口号下「过度简化」的倾向。

简单生活¹，确实能让人过得更幸福。

如无必要，勿增实体。我们生活中其实不需要那么多物品。如果对比古人与现代人拥有的物品，估计现代人的生活物品比古代皇帝还要繁杂。请你带着客观的态度思考一下你的个人物品：

有哪些对于目前的生活丝毫没有用的？

有哪些是跟风买的？

有哪些是在商家的宣传下「植入了购买意念」买的？

有哪些是一时冲动下单的？

...

你真的需要它们吗？如果其实少了某些物品也丝毫没有影响，那么，是什么原因导致你还保留它们呢？

花了钱，舍不得仍？

充满珍贵的回忆，舍不得仍？

怕以后还需要？

...

这些原因中哪些不合理，又有哪些真的合理？这样思考之后，希望你能有所发现。

对「购物」这件事我们应该要非常地谨慎，它是一种做起来爽但其结果很容易不爽的事情。首先，购物意味着耗费一定的「时间+金钱」，而且二者相加大致守恒，即如果货比三家领券寻实惠，则金钱花费更少而时间花费更多，反之亦然。其次，购入过多物品也会导致生活变繁杂，因为每一件物品都在我们的记忆里占有一席之地，多一件物品就多损耗一份注意力。而买入大量非必需品实际上是在用有限的金钱喂养无限的欲望，对于非必需品，最省钱的不是一年一度的打三折，而是「不购买」。最后，物品的处理又会成为问题，真金白银买的，但要处理时却发现左右为难，卖出时的廉价、对物品的感情、日益拥挤的房间等考量因素交织在一起，再次耗费心理能量。

而抑制住一时爽的冲动，只买必需品，随后获得的才是真正的幸福。只买必需品不仅意味着满足了合理的需求，而且意味着金钱花得少，有更多的财富剩余投入到其他重要的事情。只买必需品也避免了很多购入物品、打理物品和处理物品时耗费的心理能量。只买必需品充分发挥了金钱的价值，让人感觉心理踏实，甚至让人觉得自己花钱花成了艺术。

当然，也要区分你所认为的“必需品”是否真的“必需”，不然“必需品”也会堆砌出繁杂。目前，我发现物品购买严重过度的领域有两个，分别是美容品和保健品。大量只是人群「相信有效」但从未被证实的物质被排列组合地生产出各种护肤品和保健品，经过广告宣传，被推销出去。而一些刚被初步证实「可能有效」还需进一步研究其安全和有效性的物质，也被商家蜂拥抢先应用于新产品，进行新一轮的推销。结果，很多女人化妆台前充斥着各类高价的虚假宣传的护肤品，很多老人自己购买和被送了大堆无用甚至有害的保健品，很多孩子「被服用」各类号称可以让人变聪明的无用或影响微乎其微的保健品。

但其实，已成共识的科学有效的皮肤管理方式反而是简单的，只需要一瓶洗面奶、一瓶保湿乳和一瓶防晒霜即可。而科学有效的健康管理方式同样是简单的，即便做起来难，但别无更好的选择。

皮肤保养 = 清洁 + 保湿 + 防晒

健康管理 = 避免慢性自杀 + 合理的饮食 + 适当的锻炼 + 良好的心态

如果说各商品抢占的是「国民总收入」，那各手机APP抢占的则是「国民总注意力」。对下载手机APP这件事也应该要非常地谨慎，最好先明确它的用途，适用范围，可能带来的问题等。手机里各APP互为竞品，都在想方设法地抢夺你宝贵的注意力，加上国内软件的流氓气息，如各类弹窗广告推送，管理一大堆APP同样非常耗费注意力。注册的各类中心化平台账户越多，活动越活跃，也就意味着你的信息被越多商家掌握以及掌握得越透彻，你将越来越难远离广告的炮轰。我们最好定期将不用的APP卸载、不用的账户注销，以及找找什么APP能顶替多个APP，这样就可以进一步减少APP的数量。此外，任何珍惜自己注意力的人都应该选择良心手机以及善用手机的应用权限管理，恰当地阻止各种无用的推送。

正如「简化生活」的目的是「生活」，「简化」只是手段，不应该把它当成了目的导致落脚点成了「极力追求生活『简约』」。消费、使用手机等行为的「目的」也是为了让生活变得更美好，但它们本身也只是「手段」，不应该成为「目的」的阻碍，不应该因为「手段」而忘记最终的「目的」。

这里「简单」是动词，即「使...简单」。 ↩︎

谈现代化写作

2024-04-03T03:40:26+00:00

写作的步骤

从实践角度看，我认为写作包括记录想法、扩充完善想法、修改完善想法和发表文章这四个步骤，且实现方式可以是一个类似演化的过程。

1. 记录想法

想法的数量和质量依赖读书与人生阅历的积累，尽管有数量和质量的不同，每个人起码都是能够产生各种想法的，即几乎每个人都具备写作这个能力，但实际上能写出原创性文章的人却很少，我认为主要是第一步——记录想法这一环节出了问题。

这一论调与普遍教导的“读书多了，想法也就多了，自然就会写了”不太一样，读书当然有助于写作，但我认为在实际操作中，「记录想法」更直接导致着「写作」这一行为能不能形成。我们日常生活中会产生各种想法，但很多想法都是一闪而过然后没有记录，就被遗忘了，其中不乏好的想法。唐代诗人李贺就是一有想法就记录，随后整理成诗。好的想法一生不多，不记录真的就可惜了。

2. 扩充完善想法

有了想法并记录了，「记录」这个动作就延长了想法在大脑中的驻留时间，使得该想法更可能不断吸附其他想法，加上回头翻看记录导致的想法重现，这一效应就更是加强了，使得第二步——「扩充完善想法」更加轻松，甚至可以用”水到渠成“来形容。这样看，连普通的想法也具有记录的价值，因为它具有「驻留与吸附」的作用。我们不用管某单个想法最终能否形成一篇文章，用这个类似演化的方式写作，想法们会形成网络效应¹，无数想法的累积一定会涌现出哪怕是一篇好文章的。而且这个效应的力量在于，随着你的想法越来越多，新加入的想法一加入然后与其他想法相互碰撞并演化成一篇文章的速度将越来越快，即写作能力越来越强。

3. 修改完善想法

随着想法的扩充，这个想法被完善得初具文章的雏形，但仍是想法的集合，相比一篇最终产物——「好文章」还是差很多。文章的好坏有相对客观的评判标准，大多数文章最起码要求通俗易懂和逻辑自洽。也有相对主观的文风，如有的追求简洁干练，有的追求句子华丽、留有想象余地等。不管如何，该想法与最终的目的形式还存在差距，需要进行下一步——「修改完善想法」。

以追求通俗易懂和逻辑自洽为例，这时，需要简化语言和完善逻辑，如去除赘词，改正素材、语法、字词、逻辑上的错误。这一步其实也是一个演化过程，而且是文章与能力一同演化，多经历这个过程，组织想法与编辑文章的能力会不断提高，逻辑思维也会不断增强。现实中有意思的是，很多「帮人批改作文」的行为可能没能帮到被批改的人，因为他们可能压根没看批改的结果，也可能领会不到批改的逻辑，但却一定会帮到批改者，他实实在在地训练了自己的写作能力。

需要注意的是，第三步「修改完善想法」的过程中可能会有相关的新想法不断汇集而来，即进行着第二步「扩充完善想法」。二者本质都是在「完善想法」，实践中往往会穿插进行，相互加强。

4. 发表文章

最后，完善得差不多了，就可以考虑将最终产物「文章」发表出来。有人会立马反问——为什么要发表出来？

首先，我们一般谈「写作」，默认应该就是要发表出来吧？不发表出来的话好像不能叫「写作」吧？百度百科上对写作的定义，虽然杂乱，但具有共识的关键字有表达、传播、交流等，明显意味着「写作」是一个开放系统。

从实用性讲，关起门来“写作”那只能是自娱自乐，它没有压力，没有变得越来越好的动机。写的东西要拿到市场上去检验，接受批评与指正才有不断进化²的动力。想法就相当于DNA，文章是宿主或称为载体，是想法的表达形式。这样看，「写作」的过程就是想法内部的汇集、突变、自组织与自强化，表达形成更强³的宿主——文章，在市场中竞争并最终跟着存活下来的过程。某一文章作为静态的表达形式，它最终会被淹没在历史中，但好的想法或称之为「思想」，会蔓延开来，得永存。

现代化写作

写作作为一种经典的创造性脑力活动，已经伴随着人类很久了，历史上每一次重大的知识升级与技术革新，都改变着人类写作的方式与能力。我们作为一个现代人，拥有着远超过去任何时期的知识储备与科技水平，如臻于完善的现代科学体系与互联网架构，理应具备更先进的写作方式和写作工具、更强大的写作能力。但是，现代知识与科技对写作的冲击正如「科学的普及」那样遥遥无期，我至今未看到多少迹象，写作目前还普遍处于「前互联网时期」。结合「写作的步骤」，以下便是我认为写作在现代互联网时代的因应之道。

1. 需求

在前互联网时代，「记录想法」的最佳方式应该是随身准备一本本子，一有想法就记录，但在现在的互联网时代，这种方式不够方便与先进，会被外星人取笑的。用本子收集想法意味着要一直携带一本本子和一支笔，本子不能太大，笔不能太长，而且在记录想法时又需要找个适合书写的地方。这一方式我曾经试过，结果很快就坚持不下来，因为携带本子与笔以及书写都很麻烦，写出来的字丑得不忍直视。此外，这种方式使得第二步「扩充完善想法」也不好实施，各想法不好组织，因为书写是有顺序的，但想法大多无序且有不同的类别。随着想法的累积与完善，不仅本子越来越多，而且想法的组织与检索也是越发困难。

而在互联网时代，我们虽然不会随身携带一本本子，但必须随身携带一个手机，随便拿个便签app即可实现想法的随时记录，这才像是互联网时代下的行为。书写带来的感官刺激当然有助于记忆，但我们这一步的核心目的是「收集」想法，而非记忆想法，况且这时想法还处于「弱组织状态」，记忆效率也不高。

单纯用便签进行想法的收集是够用的，但进行想法的组织与修改就不太方便了，它既不能记录处理想法的过程，也不能做到时间回溯。例如当我的想法是v1.0版本时，我觉得不够好，修改了，变成v1.1，之后又觉得v1.0好像更好，或者单纯想一起参考这两个版本写下一个版本，但这时v1.0已经不可见了。「版本控制」需求日益强烈，于是市场上又有了带版本控制的写作app。但仍然有些不足，这样想法的演化就有点封闭了，如果一个想法在整个孕育的过程都能接受市场的检验与纠偏，那它会演化得更好、更强、更接近真理，其未来的表达形式——文章将更易存活。因此，我们需要一个更开放的系统。此外，这个系统最好能把写作四步骤全部囊括进来。

2. 雏形

目前，我认为最具现代化写作雏形的是用 Github 写作。它是现代人类最大规模的合作写作平台，其2019年年报显示已经有超过4000万用户，只不过写作形式主要是「代码」。

用 Github 写作，任何时间与地点，一有想法就可以拿手机开个 Github Issues 以「记录」想法。随后，我们在任何时间地点一有其他相关想法可以进一步「扩充」想法，并对想法们进行「修改与完善」。带有的版本控制能记录整个演化过程，注册了 Github 账号的人可以直接评论这些想法，也可帮助扩充与修改想法，其作出的贡献也被记录着。最后，当想法演化为一篇文章后，可以直接将其发表在 Github Pages 上，任何会使用互联网的人都能看到它。

这种形式下，写作的整个过程都是公开的、可追溯的、可参与的，不仅仅想法的终极演化产物「文章」可以进行思想的交流，其演化的任何中间形态都可以进行。加上知识储备上我们有维基百科和互联网档案馆，检索上我们有谷歌，引用资料上可以很方便地用超链接等，这难道不够惊艳吗？将这些现代知识与科技成果结合起来，应该足以构成对传统写作的冲击。

3. 实践

其实日常生活中每个人都有些想法，但很多可惜都丢进微博、朋友圈里了，这样虽然也进入了互联网，但缺乏系统推动下的进化，它们将一直处于弱小而单一的状态，被大规模遗忘。只有在系统下，想法才能像种子一样萌发并成长。我认为以上所述的写作方式便是一个好的现代化写作系统。

它还解决了一个「动笔难」的问题。一般人误以为写文章都是呼之欲出，这其实是误解，绝大多数文章是想法的积累与修改的结果，是成品，而传统写作下其雏形、各代次成品读者是见不到的。数学定理也是成品，高斯就特喜欢抹去思考与论证过程，他说：“当一幢建筑物完成时，应该把脚手架拆除干净。” 画家作画一般是一个由粗到细的过程，先构建框架然后逐渐细化，最后将辅助线等擦除。成品不能完全反映过程，看似简单的数学定理和画作其实过程是较为复杂的，而看似困难的写作拆开却较为简单。传统教育要求我们写文章呼之欲出，动笔当然难，而用 Github 则把写作战线拉得很长，随时可以动笔，随时可以停笔，将写作拆分成了一个个小的步骤，不仅能真正让写作生活化，而且大大降低了写作的难度。

万事开头难，开头后易。开启一个 Github Issues 后，它将在你的脑中占据了一个位置，发散思维会在你洗澡、刷牙、通勤等场合源源不断地涌来。而且你可以用标签组织 Issues，各 Issues 也能相互引用。当想法「扩充完善」到能够成为一篇文章的时候，进入了第三步「修改完善想法」，将 Issues 的内容进行初步整理，如前所述包括简化语言，完善逻辑，改正错误等，然后将这个文章雏形发布在 Github Pages 上。例如，可以将文章雏形发布在副站上，然后继续进行修改与完善，同时，Github Issues 可继续吸收新想法。「扩充完善」过程读者可以提供帮助，「修改完善」同样可以与读者一起完成，例如任何一篇文章需要补充、有错别字，读者可以点击文章末尾设置好的「编辑」按钮进行修改后提交 Pull requests，或者点击「反馈」按钮在 Issues 里提供建议，读者的贡献历史也会被保留下来。在副站的文章雏形经过一定时间的修改完善后，进入第四步「发表文章」，例如将文章选择性地发布在主站或其他网站上。

与传统写作相比，这种写作过程具有可追溯性——任何一版的内容及其变化都将保留下来，互动性——他人也能参与进来，以及动态性——文章最终发表后仍然可以继续演绎。其最终成果也具有更强的可达性——任何知道这个网址的人都可用浏览器进行访问。

这才是现代化的写作！Github 作为最大的代码托管平台，为什么不能作为最大的写作平台呢？「写代码」也可以看成是写作的一种，而以上谈的「写作」特指的是「写文章」，也是写作的一种。

让写作之风劲吹，愿科学早日普及。

具备网络效应的东西一般都值得关注。 ↩︎
进化这个词带有一种往更好的方向演化的倾向性。 ↩︎
这里的「强」指的是在外部环境即思想市场「更适合生存」。 ↩︎

mdate	team1	score1	team2	score2
1 July 2012	ESP	4	ITA	0
10 June 2012	ESP	1	ITA	1
10 June 2012	IRL	1	CRO	3
...

字段	说明
film_id	电影id
title	电影名称
description	电影描述信息

字段	说明
category_id	电影分类id
name	电影分类名称
last_update	电影分类最后更新时间

emp_no	birth_date	first_name	last_name	gender	hire_date
10001	1953-09-02	Georgi	Facello	M	1986-06-26
10002	1964-06-02	Bezalel	Simmel	F	1985-11-21
10003	1959-12-03	Parto	Bamford	M	1986-08-28
10004	1954-05-01	Christian	Koblick	M	1986-12-01
10005	1955-01-21	Kyoichi	Maliniak	M	1989-09-12
10006	1953-04-20	Anneke	Preusig	F	1989-06-02
10007	1957-05-23	Tzvetan	Zielinski	F	1989-02-10
10008	1958-02-19	Saniya	Kalloufi	M	1994-09-15
10009	1952-04-19	Sumant	Peac	F	1985-02-18
10010	1963-06-01	Duangkaew	Piveteau	F	1989-08-24
10011	1953-11-07	Mary	Sluis	F	1990-01-22