整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
题一：1+2+3+4+5+…+10000=？
第一种解法：
1+2=3,3+3=6，6+4=10,10+5=15…
这是要算到猴年马月的节奏呀 果断弃之
第二种解法：
聪明的高斯，这样玩：
（1+10000）×10000÷2=50005000 （1+10000）\times10000\div2=50005000（1+10000）×10000÷2=50005000
在这一问题的解答上，高斯的方法真香！
?问题二：冬天里，你和小红玩猜数字，小红随便想一个1～100的数字。你的目标是以最少的次数猜到这个数字。你每次猜测后，小红会说小了、大了或对了。在10次内猜对了，小红就答应今晚用你暖床。是不是听着很刺激
第一种解法：
你从1开始依次往上猜，猜测过程会是这样,小红皱着眉不断说小了
?
?
?
这是简单查找，更准确的说法是傻找 。每次猜测都只能排除一个数字。如果小红想的数字是99，你得猜99次才能猜到！，注定今晚你和小红无缘了
第二种解法：
你从50开始，小红笑着说小了，你接着说75…
?
?你每次猜测的是中间的数字，从而每次都将余下的数字排除一半。接下来，你猜63（50和75中间的数字）…这就是二分查找，每次猜测排除的数字个数如下:
?不管小红心里想的是哪个数字，你在7次之内都能猜到，因为每次猜测都将排除很多数字！恭喜你，小红今晚是你的人了。
解析：对于包含n 个元素的有序列表，用二分查找最多需要log2n log_2 nlog2n步1，而简单查找最多需要n 步。
二分查找的python实现
def binary_search(list1, item):
low=0 # low和high用于跟踪要在其中查找的列表部分
high=len(list1) - 1
while low <=high:
mid=(low + high) // 2
guess=list1[mid]
if guess==item: # 猜对了
return mid # 返回位置
elif guess > item: # 猜大了
high=mid - 1
else: # 猜小了
low=mid + 1
return None # 没有找到
my_list=[i for i in range(1,100)] # 列表推导式生成0-100个数
print(binary_search(my_list, 3)) # 别忘了索引从0开始
回到前面的二分查找。使用它可节省多少时间呢？简单查找逐个地检查数字，如果列表包含100个数字，最多需要猜100次。如果列表包含40亿个数字，最多需要猜40亿次。换言之，最多需要猜测的次数与列表长度相同，这被称为线性时间（linear time）。
二分查找则不同。如果列表包含100个元素，最多要猜7次；如果列表包含40亿个数字，最多需猜32次。厉害吧？二分查找的运行时间为对数时间 （或log loglog时间）。
算法
在计算机领域，我们同样会遇到各种高效和拙劣的算法。衡量算法好坏的重要标准有两个。通常指最糟的情形下的：
时间复杂度（采用大O表示法）
空间复杂度（采用大O表示法）
理解：小明和小刚都是初入IT的新人，一天老板给他们布置了同一个需求让他们用代码实现出来，小明的代码运行一次要花100ms，占用内存5MB。小刚的代码运行一次要花100s，占用内存500MB。于是……小刚第二天就从公司消失了
?你经常会遇到的5种大O运行时间：
O (logn log nlogn)，也叫对数时间，这样的算法包括二分查找
O (n)，也叫线性时间，这样的算法包括简单查找
O (n?logn n * log nn?logn)，这样的算法包括快速排序——一种速度较快的排序算法。
O (n2 n ^2n2)，这样的算法包括选择排序——一种速度较慢的排序算法。
O (n! n !n!)，这样的算法包括旅行商问题的解决方案——一种非常慢的算法.
假设你要绘制一个包含16格的网格，且有5种不同的算法可供选择：
?时间复杂度的概念明白了，那空间复杂度呢：
问题三：给出下图所示的n个整数，其中有两个整数是重复的，要求找出这两个重复的整数。
?
第一种解法：
你采用双重循环，遍历整个数列，每遍历到一个新的整数就开始回顾之前遍历过的所有整数，看看这些整数里有没有与之数值相同的，第1步，遍历整数3，前面没有数字，所以无须回顾比较。第2步，遍历整数1，回顾前面的数字3，没有发现重复数字。后续步骤类似，一直遍历到最后的整数2，发现和前面的整数2重复。
?这个算法的时间复杂度是O(n2) O(n^2)O(n2)
第二种解法：
当你遍历整个数列时，每遍历一个整数，就把该整数存储起来，就像放到字典中
一样。当遍历下一个整数时，不必再慢慢向前回溯比较，而直接去“字典”中查找，看看有没有对应的整数即可。“字典”左侧的Key代表整数的值，“字典”右侧的Value代表该整数出现的次数（也可以只记录Key）。当遍历到最后一个整数2时，从“字典”中可以轻松找到2曾经出现过，问题也就迎刃而解了。
?读写“字典”本身的时间复杂度是O(1) O(1)O(1)，所以整个算法的时间复杂度是O(n) O(n)O(n)
第二种解法采用的这个所谓的“字典”，是一种特殊的数据结构，叫作散列表。这个数据结构需要开辟一定的内存空间来存储有用的数据信息。
计算机的内存空间是有限的，在时间复杂度相同的情况下，算法占用的内存空间自然是越小越好。如何描述一个算法占用的内存空间的大小呢？这就用到了算法的另一个重要指标——空间复杂度（space complexity）。
常量空间，当算法的存储空间大小固定，和输入规模没有直接的关系时，空间复杂度记作O(1) O(1)O(1)
线性空间，当算法分配的空间是一个线性的集合（如数组），并且集合大小和输入规模n成正比时，空间复杂度记作O(n) O(n)O(n)
二维空间，当算法分配的空间是一个二维数组集合，并且集合的长度和宽度都与输入规模n成正比时，空间复杂度记作O(n2) O(n^2)O(n2)
递归空间，递归是一个比较特殊的场景。虽然递归代码中并没有显式地声明变量或集合，但是计算机在执行程序时，会专门分配一块内存，用来存储“方法调用栈”。执行递归操作所需要的内存空间和递归的深度成正比。纯粹的递归操作的空间复杂度也是线性的，如果递归的深度是n，那么空间复杂度就是O(n) O(n)O(n)。
时间与空间的取舍:
人们之所以花大力气去评估算法的时间复杂度和空间复杂度，其根本原因是计算机的运算速度和空间资源是有限的。虽然目前计算机的CPU处理速度不断飙升，内存和硬盘空间也越来越大，但是面对庞大而复杂的数据和业务，我们仍然要精打细算，选择最有效的利用方式。
在寻找重复整数的问题三中，双重循环的时间复杂度是O(n2) O(n^2)O(n2)，空间复杂度是O(1) O(1)O(1)，这属于牺牲时间来换取空间的情况。相反，字典法的空间复杂度是O(n) O(n)O(n)，时间复杂度是O(n) O(n)O(n)，这属于牺牲空间来换取时间的情况。在绝大多数时候，时间复杂度更为重要一些，我们宁可多分配一些内存空间，也要提升程序的执行速度。
数据结构
算法的概念理解清楚了，下面就是数据结构。如果把算法比喻成美丽灵动的舞者，那么数据结构就是舞者脚下广阔而坚实的舞台。数据结构，对应的英文单词是data structure，是数据的组织、管理和存储格式，其使用目的是为了高效地访问和修改数据。
常见的数据结构：
线性结构，线性结构是最简单的数据结构，包括数组、链表，以及由它们衍生出来的栈、队列、哈希表。
树是相对复杂的数据结构，其中比较有代表性的是二叉树，由它又衍生出了二叉堆之类的数据结构。
?图是更为复杂的数据结构，因为在图中会呈现出多对多的关联关系。
山东掌趣网络科技有限公司
021年1月3日，比特币的价格又创下历史新高，超过33000美元了。
但是，凡事皆有始末。天下，没有不散的宴席。比特币的“盛宴”会在何时结束呢？
如果，人类还有未来，我们的后代，是否会在2140年，也就是全部2100万比特币发行完毕后，再次进入比特币的“原始社会”，跟中本聪一样，是用家用电脑、笔记本电脑来挖矿的。唯一不同的是，中本聪挖矿的奖励是50个比特币，而他们得到的奖励是“0”，加上不确定的交易费。噢，那时应该不能叫挖矿，只能叫记账了。
也许，这一切，无需等到2140年，因为每隔四年一次的区块奖励减半，对于比特币来说都是一次“严重的”冒险。挺不过去，也就完了。
虽然，这一切，还都是假设。因为，这个问题的出现，还有时日，可能是几年、几十年，也可能是100年之后，但是对这个问题的思考和回答，将会有助于我们看清比特币的未来。
不过，当下却是另一种光景。谈这个问题似乎有点不合时宜，有点煞风景，简直就是杞人忧天。因为，比特币的“减半涨价”效应， 还在继续发挥作用，正有不少公司准备大展拳脚。
2020年12月21日，纳斯达克上市公司RIOT宣布，他们将花费3500万美元采购15000台蚂蚁矿机，用于比特币挖矿。 原因也很简单，因为，比特币的价格正在持续攀升。不要嫌我唠叨，记住，现在不宜入场。具体的，你可以看一下这个《小心！别上当！比特币从来没有牛市！》。
2020年12月21日RIOT宣布购买15000台蚂蚁矿机
RIOT公司新购买的矿机，预计从2021年5月开始部署，到10月部署完成。此后，RIOT的挖矿算力，将达到3.8Eh/s，占总算力140Eh/s的2.17%。如果，你对算力这些基本的概念还不清楚，需要抓紧时间补课了。请先看一下《即使美国也“杀不死”比特币？ 》。
不要以为，3.8Eh/s只是枯燥的数字，它的背后就是钱。简单算笔账，你就知道了。比特币的区块是每10分钟出一个，每个奖励6.25比特币，按照现在2.3万美元一个计算，每天产生的区块奖励是：
2070万美元=24 X 60 ÷ 10 X 6.25 X 2.3万美元。
在这里，我们还没有算比特币的交易费。RIOT公司可以获得2.17%的份额，也就是44.919万美元。你可能会有疑问了，这么确定？是的，很确定，算力的占比就是收入的占比，因为挖矿是当前地球上最公平的比赛之一，这是由算法保证的。他们投资的3500万美元，只需要78天就收回了。当然还只是估算，里面还有其他各种费用需要计算和扣除。
看到上面简单的测算，你是不是也蠢蠢欲动了，你是不是也想去挖矿了。
且慢，矿机没有了。你现在知道中国什么公司最厉害吗？比特大陆，就是生产蚂蚁矿机的比特大陆，RIOT想买的他们的S19 pro矿机 。已经早就卖断货了，现在定，最早要到2021年8月1日才能交货。怎么样？你是不是也觉得矿机比茅台强多了，也高级多了。
蚂蚁矿机S19 Pro2021年8月1日才能交货
Tips：S19 Pro赢利能力 下图来自一个专门帮你测算矿机赢利能力的网站 ，按照截图时的比特币价格27000多美元，电费按照每度0.12美元计算，平均每个月可以赢利247美元。
比特币挖矿算力赢利能力测算
如果你以为，RIOT投资完了、安装完了，钱就滚滚而来了？错。他们将不得不面对新一轮的算力军备竞赛。因为，挖矿产生的收入是摆在那里的，所有人都知道。RIOT并不比别人高明，他们想到加大矿机投入，别人自然也会。你之所以不知道，是有的人只做不说，RIOT不同，是上市公司，需要以此提升股价，还没有做就先说了。果不其然，消息公布后的第二天，RIOT的股价，就从11.04涨到了14.65美元，涨幅高达32%。
RIOT购买大量矿机消息发布后股票狂涨32%
但是，RIOT公司的这笔投资，是绝对不可能在78天内收回，具体何时能收回，要看到时的全网算力占比，是不是还能保持在2.17%。电力当然也是一笔不小的开支。不过，至少目前为止，在下图的矿池算力的前17名里面 ，我们没有看到RIOT的身影。2021年10月份，RIOT就会出现在下面这张图里吗？不一定。
2020年12月23日矿池算力份额
Tips：全网算力如何计算？ Blockchain.com 网站提供了一个计算公式： H=2^{32}\times D\div T ， 其中，D代表的是当前挖矿的难度。每挖出2016个区块，也就是大概2周的时间，难度会调整一次；T代表的是挖出的两个块之间的平均时间。一般统计的周期是24小时，下面这张图来自 fork.lol ，平均12小时的，我一般看这个。
比特币平均12小时全网算力
算力，是连接现实世界与比特币世界的一个真实存在。它的增加与减少，也与我们这2个世界密切相关。与4年一次的区块奖励减半不一样，有些变化会随时发生，它们对算力的影响，也可能是致命的。自然灾害，就是其中之一。
2020年8月18日，四川洪灾导致中国矿主算力损失20%
2020年8月18日Poolin发布的推特截图
上图是一个叫Poolin的人，发布的推特截图。视频的内容是，位于四川境内的“矿场”被泥石流摧毁，他正在组织工人抢救矿机的视频。因为四川洪灾，2020年8月18日，当天比特币全网算力出现了大幅下降，有报道认为中国矿主的算力损失有20% 。
2020年8月18日四川泥石流导致算力下降
下图，是比特币的算力增长的历史变化图。2018年8月27日的算力增长率达到了858%，为近期最高，当前的增长率是38%。 显然，比特币的算力增长正在减缓。
比特币算力增长变化
但是，“同袍兄弟”BCH的算力，已经开始负增长了。历史上，BCH曾经多次出现负增长。2020年10月份以来，BCH又再次出现了负增长，达到了-34%。
BCH算力开始出现负增长
BCH的现在，可能就是比特币的未来。之所以这样说，是因为它们采用的挖矿方式和算法都一样，最大的不同是价格。还有，那些BCH消失的算力，只是转移了，很可能是去挖比特币了。因为，现在比特币更有利可图。2020年12月28日，比特币的价格是26504.67美元，BCH是323.02美元，比特币的价格是BCH的82倍。下面这张图，也是来自fork.lol，3个小时之内的比特币与BCH之间的算力对比图。很显然，当前比特币占有绝对的优势，拥有的算力超过了98%。
比特币与BCH全网算力对比图
算力的增加或减少，其背后实际上是“赤裸裸”的利益，矿工们不是中本聪，讲情怀是要饿死人的。利益，才是算力的保障。
没有了利益，也就没有了算力。
比特币，拥有全球顶级算力。即使全球最快的前100名超级计算机加起来的算力，也只不过是它的十万分之一。
然而，天下，没有免费的午餐。比特币付出的代价，是铸币税，全部的铸币税。矿工们，获得了100%的铸币税。除此之外，没有人可以享受比特币的铸币税，美国政府也不行。
Tips：铸币税 不要被“铸币税”这个名字误导，铸币税不是税，而是一种收入。之所以叫“铸币税”，可能是因为：这种收入，只要干，就会有，很稳定，就像税收一样稳定。 铸币税的英文是Seigniorage，来自法语。 它是指货币发行过程中的面值和成本之间的差额。简单说，100美元，如果发行成本是2元，98元就是铸币税，这个收入归美联储，最终也就是属于美国政府。
比特币的铸币税，就是比特币的挖矿成本与挖矿收入之间的差额。其全部收入，都归挖矿的矿工所有，与政府获得铸币税不同的是，矿工需要负责记账，当然记账也不是免费的，还有交易费。
如果，比特币的铸币税，也能像主权国家发行货币那样，一直有，也不会有问题，也会有越来越多的矿工来挖矿。但是，中本聪，不可能创造一个自己反对的、只是虚拟化了的旧的金融体系。所以，他一开始就规定了发行货币的总量是2100万个。这也就间接的规定了，铸币税的总额。
你需要知道的是，2100万个比特币的发行，是通过每一个区块奖励实现的。开始的时候，担心没有人愿意挖矿，中本聪就把奖励定得很高，成功挖出一个区块可以奖励50个比特币，然后逐步的减半。关于挖矿，如果你还不了解，需要去看一下《比特币，真的值得信任吗？》。
比特币核心的程序里规定，每挖出21万个区块，比特币的奖励就减半，已经减半3次了。从50到25，再到12.5，现在的奖励是6.25个比特币，以后会越来越少。下面这张图，告诉你只剩下11%多一点的比特币还没有挖出来。在这个网站上，你可以实时看到，比特币还剩多少。
截止到2020年12月29日已经挖出的比特币是88.495%
下面这张图，是比特币的发行图， 如果你是我们专栏的老读者，应该不会陌生，在《比特币10年增长560万倍，凭什么？》已经出现过。通过这张图，你可以了解到，2024年，第四次区块奖励减半开始前，93.75%的比特币就已经挖出来了，余下的比特币只有7%不到了。
比特币发行表
现在，每天会挖出900个比特币左右。这个，你自己也是可以算出来的，每10分钟一个区块，每个区块奖励6.25个，每天有24小时。
每天挖出的比特币=6.25 X 24 X 60 / 10=900
你再看一下上面那个表，2064年的时候，一年挖出的比特币只有640个多一点，还不如现在一天的量。我担心，比特币撑不到那一天。
如果，现有的挖矿规则不改，矿工们的退出那是一定的。现在BCH出现的算力负增长，也同样不可避免地，会出现在比特币身上。最危险的时间段，就是刚刚减半后。如果比特币的价格不能涨到以前2倍以上，很多的矿工将不得不离开，因为有的一开机就会亏损。
算力下降之后，可怕的事情将会接踵而至。
51%攻击，就是有人汇集了超过全网51%的算力，去做坏事。这件事情，以前，之所以没有发生，是因为，以前挖矿还有利可图。当然，因为有利可图，所以比特币的全网算力是最强大的，要想进行51%的攻击很难。
但是，当比特币的算力，不再是全球第一的时候，比特币网络，也就不像现在这样强壮了。再加上，挖矿已经入不敷出的时候，攻击，也就成为了一种可能的选项。海盗，不都是这么来的吗？而且，他们干的可能要比海盗文明很多，只是将自己用过的比特币再拿出来用一下而已。这就是“双花”。
举个例子，2064年，我刚刚花了50个比特币买了所有我想买的，交易也被记录进比特币区块链了。比如说，记录我的这笔交易的区块高度是654321。那时，我缺钱花，但是有算力。但是，挖矿已经养不活自己了。为了养家糊口，我就找了10个哥们儿，说咱们干一票，把那笔50个比特币再花一次，得手后均分。
于是，我们把654320区块，也就是记录我那笔50个比特币交易的前面的那个区块作为上一个区块。大家一起加油干——挖矿，最终产生了有一个新的654321区块，并最终使得新的654321所在的链成为了最长的链。在这个链上，我的50个比特币还是我的。于是，我给参与51%攻击的每个哥们5个比特币。就这样，一次双花就完成了。
Tips：一次成功的“双花” 现实世界，比特币曾经出现过一次成功的双花案例，时间是2013年3月12日。不过，不是51%攻击攻击造成的，而是比特币核心（bitcoin core）软件错误升级到0.8版本，需要紧急降级处理造成的。下图是事后，当事人macbook-air在比特币论坛（bitcoin.org）上的留言截图。 感兴趣的，可以去围观一下。
2013年bitcoin core软件升级错误导致的一次成功的双花
这个世界，远比你我想象的险恶，像macbook-air这样的好人可遇而不可求。51%的算力攻击一直没有停过，只是还没有发生在比特币身上。
2020年1月，Savva Shanaev, Arina Shuraeva, Mikhail Vasenin 和 Maksim Kuznetsov四人联名在《另类投资杂志》（Journal of Alternative Investments）发表论文——《加密货币的价值和51％攻击》（Cryptocurrency Value and 51% Attacks: Evidence from Event Studies），专门就51%攻击进行了实证研究。
《加密货币的价值和51％攻击》论文网页截图
他们，一共研究了15起已经确认并且成功的51%算力攻击，发现：每一次51%算力攻击都会造成平均12.6%的价格下跌，而且在攻击前都存在内幕交易和拉高出货（pump-and-dump）的阴谋。
被攻击的加密货币有：Bitcoin Gold、Bitcoin Private、CoiledCoin、Electroneum、Feathercoin、Karbo、Krypton、Litecoin Cash、MonaCoin、Pigeoncoin、 Shift、Terracoin、Verge和ZenCash (最近改名为Horizen)。这些加密货币，有的你可能都没有听说过，我也没有听说过。例如CoiledCoin，它已经不存在了。
论文还确认，没有发现对比特币进行的51%攻击。不过，另一种攻击倒是被发现了：比特币矿池之间的DDos攻击。攻击的对象不是比特币区块链，而是竞争对手的矿池。目的也很简单，就是想在挖矿的竞争中赢得优势，让自己的矿池获得更多机会，赢得更多比特币。就像不道德的马拉松选手为了获得金牌，给对手使绊子一样。对此，有人从博弈论的角度进行了专门的研究 ，改天我们再谈。
也许，比特币也有会被51%算力攻击的那一天。也许是2064年，也许会更早。
如果，真有这么一天的话。那时，比特币已经离开了舞台中央，沦落为另一个不知名的加密货币了。再假如，比特币，还真的走到了2140年，那时的比特币又会怎么样呢？
如果，比特币真的活到了2140年。那时，挖矿不再有比特币奖励，不得不依靠交易费，当然，也只有交易费可以依靠了。其后果，将会很严重：区块奖励偷窃将不可避免。
Our key insight is that with only transaction fees, the variance of the block reward is very high due to the exponentially distributed block arrival time, and it becomes attractive to fork a "wealthy" block to "steal" the rewards therein.
上面的结论来自2016年的一篇学术论文——《没有区块奖励的比特币不稳定》（On the Instability of Bitcoin Without the Block Reward）。四位研究者，是经过理论分析，并用比特币的采矿模拟器验证后，得出上述结论的。 该论文的引用次数已经达到了238次，有相当高的说服力。
论文《没有区块奖励的比特币不稳定》网页截图
那么，比特币的未来，在哪里呢？
创新，才能让比特币走得更远。方式有两种，一是“改革”，二是“开放”。这两个词，上了年纪的中国人都耳熟能详，借用一下，以表达我对80年代的敬意。
改革，就是要根据“区块奖励少，挖矿吸引力下降”的实际情况，改变其底层的挖矿记账规则——工作量证明（PoW）机制，采取新的记账权确立方式。
中本聪真的聪明，他通过奖励递减的方式，启动了比特币的挖矿。不过，每4年减半，很难说是最优的策略。但是，我们也不能委曲求全。中本聪，能够启动比特币，而且一直能走到现在，已经很不容易了。余下的，我们应该自己去想办法解决。
开放，继续采用挖矿的思路，但是让矿池的收入来源能够得到扩展。让矿工在区块奖励、交易费之外，还能有新的收入来源。这一点比较难，但也可能是最终的解决方案。好在是，现实生活中，这样的成功案例有很多，移动互联网就是这样一路走过来的。
手机，以前是只能打电话的。后来可以发短信了，再后来可以上网了，可以视频聊天了。手机运营商，作为网络的维护者，好比矿池，当初是只能按照时间收取电话费的，后来可以按照条数收取短信费，现在可以按照流量收取上网费了。区块奖励和交易费，就好比是手机通话费。下图是从1983年到现在的标志性手机， 我用过其中的8款，你用过其中的哪几款？
手机的进化
什么是矿工们的“短信费”、“流量费”呢？
现在，还没有清晰的答案。只有不断的创新，才有可能找到答案。个人觉得，也可能是因为当下比特币挖矿奖励的价值太大了，遏制了人们的创新动力。好比，移动通讯初期，手机话费已经足够让运营商活得很好了，所以不思进取。
不过，再看看电信运营商的发展轨迹，你就会发现。创新，都是被逼出来的。在手机电话费就能带来足够的利润的时候，没有人愿意去主动创新的。所以，淘宝、微信，不可能是运营商的产品。当然，基于比特币区块链的，像“淘宝”“微信”这样的超级应用还没有出现，这是另外一番天地，有空再细说。
是创新，让我们有了比特币，同样也只有创新才会让比特币走得更远。
不管是改革，还是开放，都需要时间。幸亏，这个世界有“林迪效应”。
林迪效应，是说：“如果一个东西已经存在了很长时间，它不会像一个人那样，余下的时间越来越少，相反，它还会继续存在很长时间。”
This, simply, as a rule, tells you why things that have been around for a long time are not "aging" like persons, but "aging" in reverse.
纳西姆·尼可拉斯·塔勒布（Nassim Nicholas Taleb）
林迪效应，是2012年，塔勒布在《反脆弱》的书中提出的概念 。他说，如果一本书已经存在40年了，那么这本书还可以再活40年，而且，接下来再活10年，又会让它再活50年。
这个效应，是可以被我们的生活所检验的。例如：你喝水的杯子，与你的手机相比，已经存在很长时间了，而且我们相信，杯子还会继续存在更长的时间，至少比手机的时间要长很多。
如果，林迪效应是真的话，那么，比特币至少还可以再活11年。在这一点上，我选择相信塔勒布。
问题是，由于区块奖励减半的存在，每隔4年，我们所面对的都是一个新的比特币，也就是说“杯子”已经不再是原来的杯子了。看看下面这张比特币的发行表 ，你就知道了，挖矿的吸引力正在逐步下降。
Tips：比特币发行时间表 这张表，很重要，在本文中已经第二次出现了，我建议你把这个表打印出来，张贴在醒目的位置，时刻提醒自己，每隔4年，比特币都会有一次蜕变，结果如何，存在很大的不确定性。
比特币发行
我大胆预测一下，至少在2032年，区块奖励第6次减半后，比特币挖矿，还不会遇到大问题。虽然，那时的比特币奖励已经很少，只有0.78125个比特币了，但是，比特币价格的上涨还是可期的。如果，“减半涨价”效应继续发挥作用 ，比特币对于矿工们还是有吸引力的。
问题是，只有时间还是不够的，还需要人。
改革也好，开放也好，都是会有一个总设计师的。但是，去中心化的比特币，是没有总设计师的。否则，也不会中途出现分裂，有现在的BCH了。当然，从进化的角度来看，出现BCH也未必是坏事。
不管怎么说，比特币都是一个神奇的存在。原本是一篇论文，一个实验，居然就走到了现在。
我们应该清楚，中本聪，只是想好了开头，如何走下去还需要不断探索。
在后面的内容中，你将会了解到，比特币社区有一群智商极高的人，他们不但有自由主义的理想，还有强大的能力。
他们，应该可以让比特币“盛宴”不再只是盛宴，而是不断创新、不断进化的“生态”。
（待续，这是专题“比特币还能走多远”的第十一篇）
本文首发于“BTC深入浅出”（ID：xinshd30）微信公众号，每周一篇原创，更新你对比特币的认知。
ython 和放大镜的二进制代码
简介
Python 是一种高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 由 Guido van Rossum 于 1989 年底在荷兰国家数学和计算机科学研究所发明，第一个公开发行版发行于 1991 年。
特点
基础语法
运行 Python
交互式解释器
在命令行窗口执行python后，进入 Python 的交互式解释器。exit() 或 Ctrl + D 组合键退出交互式解释器。
命令行脚本
在命令行窗口执行python script-file.py，以执行 Python 脚本文件。
指定解释器
如果在 Python 脚本文件首行输入#!/usr/bin/env python，那么可以在命令行窗口中执行/path/to/script-file.py以执行该脚本文件。
注：该方法不支持 Windows 环境。
编码
默认情况下，3.x 源码文件都是 UTF-8 编码，字符串都是 Unicode 字符。也可以手动指定文件编码：
# -*- coding: utf-8 -*-
或者
# encoding: utf-8
注意: 该行标注必须位于文件第一行
标识符
注：从 3.x 开始，非 ASCII 标识符也是允许的，但不建议。
保留字
保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
注释
单行注释采用#，多行注释采用'''或"""。
# 这是单行注释
'''
这是多行注释
这是多行注释
'''
"""
这也是多行注释
这也是多行注释
"""
行与缩进
Python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}。 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。缩进不一致，会导致运行错误。
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠来实现多行语句。
total=item_one +
item_two +
item_three
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠。
空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。
等待用户输入
input函数可以实现等待并接收命令行中的用户输入。
content=input("请输入点东西并按 Enter 键")
print(content)
同一行写多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号;分割。
import sys; x='hello world'; sys.stdout.write(x + '')
多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号:结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上end=""或别的非换行符字符串：
print('123') # 默认换行
print('123', end="") # 不换行
import 与 from…import
在 Python 用 import 或者 from...import 来导入相应的模块。
将整个模块导入，格式为：import module_name
从某个模块中导入某个函数,格式为：from module_name import func1
从某个模块中导入多个函数,格式为：from module_name import func1, func2, func3
将某个模块中的全部函数导入，格式为：from module_name import *
运算符
算术运算符
运算符描述+加-减*乘/除%取模**幂//取整除
比较运算符
运算符描述==等于!=不等于>大于<小于>=大于等于<=小于等于
赋值运算符
运算符描述=简单的赋值运算符+=加法赋值运算符-=减法赋值运算符*=乘法赋值运算符/=除法赋值运算符%=取模赋值运算符**=幂赋值运算符//=取整除赋值运算符
位运算符
逻辑运算符
成员运算符
身份运算符
运算符优先级
具有相同优先级的运算符将从左至右的方式依次进行。用小括号()可以改变运算顺序。
变量
变量在使用前必须先”定义”（即赋予变量一个值），否则会报错：
>>> name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined
数据类型
布尔(bool)
只有 True 和 False 两个值，表示真或假。
数字(number)
整型(int)
整数值，可正数亦可复数，无小数。 3.x 整型是没有限制大小的，可以当作 Long 类型使用，所以 3.x 没有 2.x 的 Long 类型。
浮点型(float)
浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2=2.5 x 10^2=250）
复数(complex)
复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示，复数的实部 a 和虚部 b 都是浮点型。
数字运算
数学函数
注：以下函数的使用，需先导入 math 包。
随机数函数
注：以下函数的使用，需先导入 random 包。
三角函数
注：以下函数的使用，需先导入 math 包。
数学常量
字符串(string)
转义字符
字符串运算符
字符串格式化
在 Python 中，字符串格式化不是 sprintf 函数，而是用 % 符号。例如：
print("我叫%s， 今年 %d 岁！" % ('小明', 10))
// 输出:
我叫小明， 今年 10 岁！
格式化符号:
辅助指令:
Python 2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
多行字符串
实例：
string='''
print(math.fabs(-10))
print(random.choice(li))
'''
print(string)
输出：
print( math.fabs(-10))
print(
random.choice(li))
Unicode
在 2.x 中，普通字符串是以 8 位 ASCII 码进行存储的，而 Unicode 字符串则存储为 16 位 Unicode 字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在 3.x 中，所有的字符串都是 Unicode 字符串。
字符串函数
字节(bytes)
在 3.x 中，字符串和二进制数据完全区分开。文本总是 Unicode，由 str 类型表示，二进制数据则由 bytes 类型表示。Python 3 不会以任意隐式的方式混用 str 和 bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。
bytes 转 str：
b'abc'.decode()
str(b'abc')
str(b'abc', encoding='utf-8')
str 转 bytes：
'中国'.encode()
bytes('中国', encoding='utf-8')
列表(list)
创建列表
hello=(1, 2, 3)
li=[1, "2", [3, 'a'], (1, 3), hello]
访问元素
li=[1, "2", [3, 'a'], (1, 3)]
print(li[3]) # (1, 3)
print(li[-2]) # [3, 'a']
切片访问
格式: list_name[begin:end:step] begin 表示起始位置(默认为0)，end 表示结束位置(默认为最后一个元素)，step 表示步长(默认为1)
hello=(1, 2, 3)
li=[1, "2", [3, 'a'], (1, 3), hello]
print(li) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:2]) # ['2']
print(li[:2]) # [1, '2']
print(li[:]) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[2:]) # [[3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:-1:2]) # ['2', (1, 3)]
访问内嵌 list 的元素：
li=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ['a', 'b', 'c']]
print(li[1:-1:2][1:3]) # (3, 5)
print(li[-1][1:3]) # ['b', 'c']
print(li[-1][1]) # b
修改列表
通过使用方括号，可以非常灵活的对列表的元素进行修改、替换、删除等操作。
li=[0, 1, 2, 3, 4, 5]
li[len(li) - 2]=22 # 修改 [0, 1, 2, 3, 22, 5]
li[3]=33 # 修改 [0, 1, 2, 33, 4, 5]
li[1:-1]=[9, 9] # 替换 [0, 9, 9, 5]
li[1:-1]=[] # 删除 [0, 5]
删除元素
可以用 del 语句来删除列表的指定范围的元素。
li=[0, 1, 2, 3, 4, 5]
del li[3] # [0, 1, 2, 4, 5]
del li[2:-1] # [0, 1, 5]
列表操作符
[1, 2, 3] + [3, 4, 5] # [1, 2, 3, 3, 4, 5]
[1, 2, 3] * 2 # [1, 2, 3, 1, 2, 3]
3 in [1, 2, 3] # True
for x in [1, 2, 3]: print(x) # 1 2 3
列表函数
li=[0, 1, 5]
max(li) # 5
len(li) # 3
注: 对列表使用 max/min 函数，2.x 中对元素值类型无要求，3.x 则要求元素值类型必须一致。
列表方法
列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
将列表中每个数值乘三，获得一个新的列表：
vec=[2, 4, 6]
[(x, x**2) for x in vec]
# [(2, 4), (4, 16), (6, 36)]
对序列里每一个元素逐个调用某方法：
freshfruit=[' banana', ' loganberry ', 'passion fruit ']
[weapon.strip() for weapon in freshfruit]
# ['banana', 'loganberry', 'passion fruit']
用 if 子句作为过滤器：
vec=[2, 4, 6]
[3*x for x in vec if x > 3]
# [12, 18]
vec1=[2, 4, 6]
vec2=[4, 3, -9]
[x*y for x in vec1 for y in vec2]
# [8, 6, -18, 16, 12, -36, 24, 18, -54]
[vec1[i]*vec2[i] for i in range(len(vec1))]
# [8, 12, -54]
列表嵌套解析：
matrix=[
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
new_matrix=[[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(new_matrix)
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
元组(tuple)
访问元组
访问元组的方式与列表是一致的。 元组的元素可以直接赋值给多个变量，但变量数必须与元素数量一致。
a, b, c=(1, 2, 3)
print(a, b, c)
组合元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1=(12, 34.56);
tup2=('abc', 'xyz')
tup3=tup1 + tup2;
print (tup3)
# (12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组
元组函数
元组推导式
t=1, 2, 3
print(t)
# (1, 2, 3)
u=t, (3, 4, 5)
print(u)
# ((1, 2, 3), (3, 4, 5))
字典(dict)
格式如下:
d={key1 : value1, key2 : value2 }
访问字典
dis={'a': 1, 'b': [1, 2, 3]}
print(dis['b'][2])
修改字典
dis={'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}
dis[9]['name']=999
print(dis)
# {'a': 1, 9: {'name': 999}, 'b': [1, 2, 3]}
删除字典
用 del 语句删除字典或字典的元素。
dis={'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}
del dis[9]['name']
print(dis)
del dis # 删除字典
# {'a': 1, 9: {}, 'b': [1, 2, 3]}
字典函数
字典方法
dic1={'a': 'a'}
dic2={9: 9, 'a': 'b'}
dic1.update(dic2)
print(dic1)
# {'a': 'b', 9: 9}
字典推导式
构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
此外，字典推导可以用来创建任意键和值的表达式词典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
集合(set)
集合是一个无序不重复元素的序列
创建集合
{1, 2, 1, 3} # {} {1, 2, 3}
set('12345') # 字符串 {'3', '5', '4', '2', '1'}
set([1, 'a', 23.4]) # 列表 {1, 'a', 23.4}
set((1, 'a', 23.4)) # 元组 {1, 'a', 23.4}
set({1:1, 'b': 9}) # 字典 {1, 'b'}
添加元素
将元素 val 添加到集合 set 中，如果元素已存在，则不进行任何操作：
set.add(val)
也可以用 update 方法批量添加元素，参数可以是列表，元组，字典等：
set.update(list1, list2,...)
移除元素
如果存在元素 val 则移除，不存在就报错：
set.remove(val)
如果存在元素 val 则移除，不存在也不会报错：
set.discard(val)
随机移除一个元素：
set.pop()
元素个数
与其他序列一样，可以用 len(set) 获取集合的元素个数。
清空集合
set.clear()
set=set()
判断元素是否存在
val in set
其他方法
集合计算
a=set('abracadabra')
b=set('alacazam')
print(a) # a 中唯一的字母
# {'a', 'r', 'b', 'c', 'd'}
print(a - b) # 在 a 中的字母，但不在 b 中
# {'r', 'd', 'b'}
print(a | b) # 在 a 或 b 中的字母
# {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
print(a & b) # 在 a 和 b 中都有的字母
# {'a', 'c'}
print(a ^ b) # 在 a 或 b 中的字母，但不同时在 a 和 b 中
# {'r', 'd', 'b', 'm', 'z', 'l'}
集合推导式
a={x for x in 'abracadabra' if x not in 'abc'}
print(a)
# {'d', 'r'}
流程控制
if 控制
if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。 3、在 Python 中没有 switch - case 语句。
三元运算符：
<表达式1> if <条件> else <表达式2>
编写条件语句时，应该尽量避免使用嵌套语句。嵌套语句不便于阅读，而且可能会忽略一些可能性。
for 遍历
for <循环变量> in <循环对象>：
<语句1>
else:
<语句2>
else 语句中的语句2只有循环正常退出（遍历完所有遍历对象中的值）时执行。
在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
knights={'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
print(k, v)
在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
for i, v in enumerate(['tic', 'tac', 'toe']):
print(i, v)
同时遍历两个或更多的序列，可以使用 zip() 组合：
questions=['name', 'quest', 'favorite color']
answers=['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
for i in reversed(range(1, 10, 2)):
print(i)
要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
basket=['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
print(f)
while 循环
while<条件>：
<语句1>
else：
<语句2>
break、continue、pass
break 语句用在 while 和 for 循环中，break 语句用来终止循环语句，即循环条件没有 False 条件或者序列还没被完全递归完，也会停止执行循环语句。 continue 语句用在 while 和 for 循环中，continue 语句用来告诉 Python 跳过当前循环的剩余语句，然后继续进行下一轮循环。 continue 语句跳出本次循环，而 break 跳出整个循环。
pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
迭代器
迭代器可以被 for 循环进行遍历：
li=[1, 2, 3]
it=iter(li)
for val in it:
print(val)
迭代器也可以用 next() 函数访问下一个元素值：
import sys
li=[1,2,3,4]
it=iter(li)
while True:
try:
print (next(it))
except StopIteration:
sys.exit()
生成器
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter=0, 1, 0
while True:
if (counter > n):
return
yield a
a, b=b, a + b
counter +=1
f=fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print(next(f))
except StopIteration:
sys.exit()
函数
自定义函数
函数（Functions）是指可重复使用的程序片段。它们允许你为某个代码块赋予名字，允许你通过这一特殊的名字在你的程序任何地方来运行代码块，并可重复任何次数。这就是所谓的调用（Calling）函数。
def 函数名（参数列表）:
函数体
参数传递
在 Python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="Runoob"
以上代码中，[1,2,3] 是 List 类型，”Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
可更改与不可更改对象
在 Python 中，字符串，数字和元组是不可更改的对象，而列表、字典等则是可以修改的对象。
Python 函数的参数传递：
Python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def print_info(name, age):
"打印任何传入的字符串"
print("名字: ", name)
print("年龄: ", age)
return
print_info(age=50, name="john")
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。
def print_info(name, age=35):
print ("名字: ", name)
print ("年龄: ", age)
return
print_info(age=50, name="john")
print("------------------------")
print_info(name="john")
不定长参数
def print_info(arg1, *vartuple):
print("输出: ")
print(arg1)
for var in vartuple:
print (var)
return
print_info(10)
print_info(70, 60, 50)
def print_info(arg1, **vardict):
print("输出: ")
print(arg1)
print(vardict)
print_info(1, a=2, b=3)
匿名函数
Python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。 lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。 lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
# 语法格式
lambda [arg1 [,arg2,.....argn]]:expression
变量作用域
以 L –> E –> G –> B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字。
num=1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num=123
print(num)
fun1()
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字。
def outer():
num=10
def inner():
nonlocal num # nonlocal关键字声明
num=100
print(num)
inner()
print(num)
outer()
模块
编写模块有很多种方法，其中最简单的一种便是创建一个包含函数与变量、以 .py 为后缀的文件。
另一种方法是使用撰写 Python 解释器本身的本地语言来编写模块。举例来说，你可以使用 C 语言来撰写 Python 模块，并且在编译后，你可以通过标准 Python 解释器在你的 Python 代码中使用它们。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 Python 标准库的方法。
当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块，需要把命令放在脚本的顶端。
一个模块只会被导入一次，这样可以防止导入模块被一遍又一遍地执行。
搜索路径被存储在 sys 模块中的 path 变量。当前目录指的是程序启动的目录。
导入模块
导入模块：
import module1[, module2[,... moduleN]]
从模块中导入一个指定的部分到当前命名空间中：
from modname import name1[, name2[, ... nameN]]
把一个模块的所有内容全都导入到当前的命名空间：
from modname import *
__name__ 属性
每个模块都有一个 __name__ 属性，当其值是 '__main__' 时，表明该模块自身在运行，否则是被引入。
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 __name__ 属性来使该程序块仅在该模块自身运行时执行。
if __name__=='__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
dir 函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。
在 Python 中万物皆对象，int、str、float、list、tuple等内置数据类型其实也是类，也可以用 dir(int) 查看 int 包含的所有方法。也可以使用 help(int) 查看 int 类的帮助信息。
包
包是一种管理 Python 模块命名空间的形式，采用”点模块名称”。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
最简单的情况，放一个空的 __init__.py 文件就可以了。当然这个文件中也可以包含一些初始化代码或者为 __all__ 变量赋值。
第三方模块
easy_install 的用法：
easy_install 包名
easy_install "包名==包的版本号"
easy_install -U "包名 >=包的版本号"
pip 的用法：
pip install 包名pip install 包名==包的版本号
pip install —upgrade 包名 >=包的版本号
pip uninstall 包名
pip list
面向对象
类与对象是面向对象编程的两个主要方面。一个类（Class）能够创建一种新的类型（Type），其中对象（Object）就是类的实例（Instance）。可以这样来类比：你可以拥有类型 int 的变量，也就是说存储整数的变量是 int 类的实例（对象）。
Python 中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。
self
self 表示的是当前实例，代表当前对象的地址。类由 self.__class__ 表示。
self 不是关键字，其他名称也可以替代，但 self 是个通用的标准名称。
类
类由 class 关键字来创建。 类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
对象方法
方法由 def 关键字定义，与函数不同的是，方法必须包含参数 self, 且为第一个参数，self 代表的是本类的实例。
类方法
装饰器 @classmethod 可以将方法标识为类方法。类方法的第一个参数必须为 cls，而不再是 self。
静态方法
装饰器 @staticmethod 可以将方法标识为静态方法。静态方法的第一个参数不再指定，也就不需要 self 或 cls。
__init__ 方法
__init__ 方法即构造方法，会在类的对象被实例化时先运行，可以将初始化的操作放置到该方法中。
如果重写了 __init__，实例化子类就不会调用父类已经定义的 __init__。
变量
类变量（Class Variable）是共享的（Shared）——它们可以被属于该类的所有实例访问。该类变量只拥有一个副本，当任何一个对象对类变量作出改变时，发生的变动将在其它所有实例中都会得到体现。
对象变量（Object variable）由类的每一个独立的对象或实例所拥有。在这种情况下，每个对象都拥有属于它自己的字段的副本，也就是说，它们不会被共享，也不会以任何方式与其它不同实例中的相同名称的字段产生关联。
在 Python 中，变量名类似 __xxx__ 的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是 private 变量，所以，不能用 __name__、__score__ 这样的变量名。
访问控制
我们还认为约定，一个下划线开头的属性或方法为受保护的。比如，_protected_attr、_protected_method。
继承
类可以继承，并且支持继承多个父类。在定义类时，类名后的括号中指定要继承的父类，多个父类之间用逗号分隔。
子类的实例可以完全访问所继承所有父类的非私有属性和方法。
若是父类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。
方法重写
子类的方法可以重写父类的方法。重写的方法参数不强制要求保持一致，不过合理的设计都应该保持一致。
super() 函数可以调用父类的一个方法，以多继承问题。
类的专有方法：
类的专有方法也支持重载。
实例
class Person:
"""人员信息"""
# 姓名(共有属性)
name=''
# 年龄(共有属性)
age=0
def __init__(self, name='', age=0):
self.name=name
self.age=age
# 重载专有方法: __str__
def __str__(self):
return "这里重载了 __str__ 专有方法, " + str({'name': self.name, 'age': self.age})
def set_age(self, age):
self.age=age
class Account:
"""账户信息"""
# 账户余额(私有属性)
__balance=0
# 所有账户总额
__total_balance=0
# 获取账户余额
# self 必须是方法的第一个参数
def balance(self):
return self.__balance
# 增加账户余额
def balance_add(self, cost):
# self 访问的是本实例
self.__balance +=cost
# self.__class__ 可以访问类
self.__class__.__total_balance +=cost
# 类方法(用 @classmethod 标识，第一个参数为 cls)
@classmethod
def total_balance(cls):
return cls.__total_balance
# 静态方法(用 @staticmethod 标识，不需要类参数或实例参数)
@staticmethod
def exchange(a, b):
return b, a
class Teacher(Person, Account):
"""教师"""
# 班级名称
_class_name=''
def __init__(self, name):
# 第一种重载父类__init__()构造方法
# super(子类，self).__init__(参数1，参数2，....)
super(Teacher, self).__init__(name)
def get_info(self):
# 以字典的形式返回个人信息
return {
'name': self.name, # 此处访问的是父类Person的属性值
'age': self.age,
'class_name': self._class_name,
'balance': self.balance(), # 此处调用的是子类重载过的方法
}
# 方法重载
def balance(self):
# Account.__balance 为私有属性，子类无法访问，所以父类提供方法进行访问
return Account.balance(self) * 1.1
class Student(Person, Account):
"""学生"""
_teacher_name=''
def __init__(self, name, age=18):
# 第二种重载父类__init__()构造方法
# 父类名称.__init__(self,参数1，参数2，...)
Person.__init__(self, name, age)
def get_info(self):
# 以字典的形式返回个人信息
return {
'name': self.name, # 此处访问的是父类Person的属性值
'age': self.age,
'teacher_name': self._teacher_name,
'balance': self.balance(),
}
# 教师 John
john=Teacher('John')
john.balance_add(20)
john.set_age(36) # 子类的实例可以直接调用父类的方法
print("John's info:", john.get_info())
# 学生 Mary
mary=Student('Mary', 18)
mary.balance_add(18)
print("Mary's info:", mary.get_info())
# 学生 Fake
fake=Student('Fake')
fake.balance_add(30)
print("Fake's info", fake.get_info())
# 三种不同的方式调用静态方法
print("john.exchange('a', 'b'):", john.exchange('a', 'b'))
print('Teacher.exchange(1, 2)', Teacher.exchange(1, 2))
print('Account.exchange(10, 20):', Account.exchange(10, 20))
# 类方法、类属性
print('Account.total_balance():', Account.total_balance())
print('Teacher.total_balance():', Teacher.total_balance())
print('Student.total_balance():', Student.total_balance())
# 重载专有方法
print(fake)
输出：
John's info: {'name': 'John', 'age': 36, 'class_name': '', 'balance': 22.0}Mary's info: {'name': 'Mary', 'age': 18, 'teacher_name': '', 'balance': 18}Fake's info {'name': 'Fake', 'age': 18, 'teacher_name': '', 'balance': 30}john.exchange('a', 'b'): ('b', 'a')Teacher.exchange(1, 2) (2, 1)Account.exchange(10, 20): (20, 10)Account.total_balance(): 0Teacher.total_balance(): 20Student.total_balance(): 48这里重载了 __str__ 专有方法, {'name': 'Fake', 'age': 18}
错误和异常
语法错误
SyntaxError 类表示语法错误，当解释器发现代码无法通过语法检查时会触发的错误。语法错误是无法用 try...except...捕获的。
>>> print:
File "<stdin>", line 1
print:
^
SyntaxError: invalid syntax
异常
即便程序的语法是正确的，在运行它的时候，也有可能发生错误。运行时发生的错误被称为异常。 错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。
>>> 1 + '0'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
异常处理
Python 提供了 try ... except ... 的语法结构来捕获和处理异常。
try 语句执行流程大致如下：
抛出异常
使用 raise 语句抛出一个指定的异常。
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
自定义异常
可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类。
大多数的异常的名字都以”Error”结尾，就跟标准的异常命名一样。
实例
import sys
class Error(Exception):
"""Base class for exceptions in this module."""
pass
# 自定义异常
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression=expression
self.message=message
try:
print('code start running...')
raise InputError('input()', 'input error')
# ValueError
int('a')
# TypeError
s=1 + 'a'
dit={'name': 'john'}
# KeyError
print(dit['1'])
except InputError as ex:
print("InputError:", ex.message)
except TypeError as ex:
print('TypeError:', ex.args)
pass
except (KeyError, IndexError) as ex:
"""支持同时处理多个异常, 用括号放到元组里"""
print(sys.exc_info())
except:
"""捕获其他未指定的异常"""
print("Unexpected error:", sys.exc_info()[0])
# raise 用于抛出异常
raise RuntimeError('RuntimeError')
else:
"""当无任何异常时, 会执行 else 子句"""
print('"else" 子句...')
finally:
"""无论有无异常, 均会执行 finally"""
print('finally, ending')
文件操作
打开文件
open() 函数用于打开/创建一个文件，并返回一个 file 对象：
open(filename, mode)
文件打开模式：
文件对象方法
实例
filename='data.log'
# 打开文件(a+ 追加读写模式)
# 用 with 关键字的方式打开文件，会自动关闭文件资源
with open(filename, 'w+', encoding='utf-8') as file:
print('文件名称: {}'.format(file.name))
print('文件编码: {}'.format(file.encoding))
print('文件打开模式: {}'.format(file.mode))
print('文件是否可读: {}'.format(file.readable()))
print('文件是否可写: {}'.format(file.writable()))
print('此时文件指针位置为: {}'.format(file.tell()))
# 写入内容
num=file.write("第一行内容")
print('写入文件 {} 个字符'.format(num))
# 文件指针在文件尾部，故无内容
print(file.readline(), file.tell())
# 改变文件指针到文件头部
file.seek(0)
# 改变文件指针后，读取到第一行内容
print(file.readline(), file.tell())
# 但文件指针的改变，却不会影响到写入的位置
file.write('第二次写入的内容')
# 文件指针又回到了文件尾
print(file.readline(), file.tell())
# file.read() 从当前文件指针位置读取指定长度的字符
file.seek(0)
print(file.read(9))
# 按行分割文件，返回字符串列表
file.seek(0)
print(file.readlines())
# 迭代文件对象，一行一个元素
file.seek(0)
for line in file:
print(line, end='')
# 关闭文件资源
if not file.closed:
file.close()
输出：
文件名称: data.log
文件编码: utf-8
文件打开模式: w+
文件是否可读: True
文件是否可写: True
此时文件指针位置为: 0
写入文件 6 个字符
16
第一行内容
16
41
第一行内容
第二次
['第一行内容', '第二次写入的内容']
第一行内容
第二次写入的内容
序列化
在 Python 中 pickle 模块实现对数据的序列化和反序列化。pickle 支持任何数据类型，包括内置数据类型、函数、类、对象等。
方法
dump
将数据对象序列化后写入文件
pickle.dump(obj, file, protocol=None, fix_imports=True)
必填参数 obj 表示将要封装的对象。 必填参数 file 表示 obj 要写入的文件对象，file 必须以二进制可写模式打开，即wb。 可选参数 protocol 表示告知 pickle 使用的协议，支持的协议有 0,1,2,3，默认的协议是添加在 Python 3 中的协议3。
load
从文件中读取内容并反序列化
pickle.load(file, fix_imports=True, encoding='ASCII', errors='strict')
必填参数 file 必须以二进制可读模式打开，即rb，其他都为可选参数。
dumps
以字节对象形式返回封装的对象，不需要写入文件中
pickle.dumps(obj, protocol=None, fix_imports=True)
loads
从字节对象中读取被封装的对象，并返回
pickle.loads(bytes_object, fix_imports=True, encoding='ASCII', errors='strict')
实例
import pickle
data=[1, 2, 3]
# 序列化数据并以字节对象返回
dumps_obj=pickle.dumps(data)
print('pickle.dumps():', dumps_obj)
# 从字节对象中反序列化数据
loads_data=pickle.loads(dumps_obj)
print('pickle.loads():', loads_data)
filename='data.log'
# 序列化数据到文件中
with open(filename, 'wb') as file:
pickle.dump(data, file)
# 从文件中加载并反序列化
with open(filename, 'rb') as file:
load_data=pickle.load(file)
print('pickle.load():', load_data)
输出：
pickle.dumps(): b'?]q(KKKe.'
pickle.loads(): [1, 2, 3]
pickle.load(): [1, 2, 3]
命名规范
Python 之父 Guido 推荐的规范
一份来自谷歌的 Python 风格规范：
http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/
还需要更多资料可以私信小编（资料）获取
*请认真填写需求信息，我们会在24小时内与您取得联系。
