作者：顾斯比
 
 链接：https://www.zhihu.com/question/20717354/answer/15968282
 
 来源：知乎
 
 著作权归作者所有，转载请联系作者获得授权。
 
 
 
 
 计算机主机网关的作用是什么？ 
 
 假设你的名字叫小不点，你住在一个大院子里，你的邻居有很多小伙伴，在门口传达室还有个看大门的李大爷，李大爷就是你的网关。当你想跟院子里的某个小伙伴玩，只要你在院子里大喊一声他的名字，他听到了就会回应你，并且跑出来跟你玩。 
 
 但是你不被允许走出大门，你想与外界发生的一切联系，都必须由门口的李大爷（网关）用电话帮助你联系。假如你想找你的同学小明聊天，小明家住在很远的另外一个院子里，他家的院子里也有一个看门的王大爷（小明的网关）。但是你不知道小明家的电话号码，不过你的班主任老师有一份你们班全体同学的名单和电话号码对照表，你的老师就是你的DNS服务器。于是你在家里拨通了门口李大爷的电话，有了下面的对话： 
 
 小不点：李大爷，我想找班主任查一下小明的电话号码行吗？ 
 
 李大爷：好，你等着。（接着李大爷给你的班主任挂了一个电话，问清楚 
 
 了小明的电话）问到了，他家的号码是211.99.99.99 
 
 小不点：太好了！李大爷，我想找小明，你再帮我联系一下小明吧。 
 
 李大爷：没问题。（接着李大爷向电话局发出了请求接通小明家电话的请 
 
 求，最后一关当然是被转接到了小明家那个院子的王大爷那里，然后王大 
 
 爷把电话给转到小明家） 
 
 就这样你和小明取得了联系。 
 
 
 至于DHCP服务器嘛，可以这样比喻： 
 
 你家院子里的居民越来越多了，传达室李大爷那里的电话交换机已经不能满足这么多居民的需求了，所以只好采用了一种新技术叫做DHCP，居民们开机的时候随机得到一个电话号码，每一次得到的号码都可能会不同。 
 
 
 你家门口的李大爷：就是你的网关 
 你的班主任：就是你的DNS服务器 
 
 传达室的电话交换机：就是你的DHCP服务器 
 
 同上，李大爷和王大爷之间的对话就叫做路由。 
 
 另：如果还有个小朋友叫做小暗，他住的院子看门的是孙大爷，因为小暗的院子刚盖好，孙大爷刚来不久，他没有李大爷和王大爷办公室的电话（李大爷和王大爷当然也没有他的电话），这时会有两种情况： 
 
 1、居委会的赵大妈告诉了孙大爷关于李、王两位大爷的电话（同时赵大妈也告诉了李、王关于孙的电话），这就叫静态设定路由 
 
 2、赵大妈病了，孙大爷自己到处打电话，见人就说：“我是小暗他们院子管电话的”，结果被李、王二位听到了，就记在了他们的通讯录上，然后李、王就给孙大爷回了个电话说：“我是小明（小不点）他们院子管电话的”，这就叫动态设定路由 
 
 然后有一天小不点要找小暗，结果自然是小不点给李大爷打电话说：“大爷，我找小暗”（这里省略了李大爷去查小暗电话的过程，假设他知道小暗的电话），李大爷一找通讯录：“哦，小暗的院子的电话是孙大爷管着的，要找小暗自然先要通知孙大爷，我可以通知王大爷让他去找孙大爷，也可以自己直接找孙，那当然是自己直接找孙方便了”，于是李大爷给孙大爷打了电话，然后孙大爷又把电话转到了小暗家。 
 
 
 这里李大爷的通讯录叫做路由表。 
 
 李大爷选择是自己直接找孙大爷还是让王大爷帮忙转接叫做路由选择。 
 
 李大爷之所以选择直接找孙大爷是有依据的，因为他直接找孙大爷就能一步到位，如果要王大爷转接就需要两步才能完成，这里的“步”叫做“跳数”，李大爷的选择遵循的是最少步骤（跳数）原则（如果他不遵守这个原则，小不点可能就会多等些时间才能找到小暗，最终结果可能导致李大爷因工作不力被炒鱿鱼，这叫做“延时太长，选路原则不合理，换了一个路由器”） 
 
 当然，事情总是变化的，小不点和小明吵架了，这些天小不点老是给小暗打电话，小明心里想：“操，他是不是在说我坏话啊？”于是小明决定偷听小不点和小暗的通话，但是他又不能出院子，怎么办呢？小明做了这样一个决定： 
 
 首先他告诉自己院里管电话的王大爷说：“你给李大爷打个电话说小暗搬到咱们院子了，以后凡是打给他的电话我来接”，王大爷没反映过来（毕竟年纪大了啊！）就给李大爷打了电话，说：“现在我来管理小暗的电话了，孙已经不管了”，结果李大爷就把他的通讯录改了，这叫做路由欺骗。 
 
 以后小不点再找小暗，李大爷就转给王大爷了（其实应该转给孙大爷的），王大爷收到了这个电话就转给了小明（因为他之前已经和小明说好了），小明收到这个电话就假装小暗和小不点通信。因为小明作贼心虚，害怕明天小不点和小暗见面后当面问他，于是通信断了之后，又自己以小不点的名义给小暗通了个电话复述了一遍刚才的话，有这就叫数据窃听 
 
 再后来，小不点还是不断的和小暗联系，而零落了小明，小明心里嘀咕啊：“我不能总是这样以小暗的身份和小不点通话啊，外一有一天露馅了怎么办！”于是他想了一个更阴险的招数：“干脆我也不偷听你们的电话了，你小不点不是不给我打电话吗！那我让你也给小暗打不了，哼哼！”，他怎么做的呢？我们来看： 
 
 他联系了一批狐朋狗友，和他们串通好，每天固定一个时间大家一起给小暗院子传达室打电话，内容什么都有，只要传达室的孙爷爷接电话，就会听到“打雷啦，下雨收衣服啊！”、“人是人他妈生的，妖是妖他妈生的”、“你妈贵姓”等等，听的脑袋都大了，不听又不行，电话不停的响啊！终于有一天，孙爷爷忍不住了，大喊一声：“我受不了拉！！！！”，于是上吊自杀了！ 
 
 
 这就是最简单的DDOS攻击，孙爷爷心理承受能力弱的现象叫做“数据报处理模块有BUG”，孙爷爷的自杀叫做“路由器瘫痪”。如果是我，就会微笑着和他们拉家常，例如告诉他们“我早就听了天气预报，衣服10分钟前已经收好了”或者“那你妈是人还是妖”或者“和你奶奶一个姓”等等，我这种健全的心理叫做“健壮的数据报处理，能够抵御任何攻击” 
 
 孙爷爷瘫了之后，小不点终于不再给小暗打电话了，因为无论他怎么打对方都是忙音，这种现象叫做“
 拒绝服务”，所以小明的做法还有一个名字叫做“
 拒绝服务攻击”。 
 
 小明终于安静了几天，... 
 
 几天后，小明的院子来了一个美丽的女孩，名字叫做小丽，小明很喜欢她（小小年纪玩什么早恋！）可是小丽有个很帅的男朋友，小明干瞪眼没办法。当然这里还是要遵循上面的原则：小丽是不能出院子的。那个男的想泡小丽自然只能打电话，于是小明又蠢蠢欲动了： 
 
 还记得王爷爷是院子的电话总管吗？他之所以能管理电话是因为他有一个通讯录，因为同一个院子可能有2个孩子都叫小明，靠名字无法区分，所以通讯录上每一行只有两项： 
 
 门牌电话 
 
 一号门 1234567 （这个是小明的） 
 
 二号门 7654321 （这个是小丽的） 
 
 ...... 
 
 王爷爷记性不好，但这总不会错了吧（同一个院子不会有2个“二号门”吧）？每次打电话人家都要说出要找的电话号码，然后通过通讯录去院子里面敲门，比如人家说我找“1234567”，于是王爷爷一比较，哦，是一号门的，他就去敲一号门“听电话”，如果是找“7654321”，那他就找二号门“听电话”。 
 
 这里的电话号码就是传说中的“IP地址” 
 
 这里的门牌号就是传说中的
 网卡的’MAC‘地址（每一块网卡的MAC地址都是不一样的，这是网卡的制造商写死在网卡的芯片中的） 
 
 小明心里想“奶奶的，老子泡不到你也别想泡”，于是他打起了王爷爷通讯录的主意，经过细心的观察，周密的准备，他终于发现王爷爷有尿频的毛病（毕竟是老人啊...），终于在一个月黑风高的白天，王爷爷去上厕所了，小明偷偷的摸进传达室，小心翼翼的改了王爷爷的通讯录...... 
 
 过了几天，小丽的男朋友又给小丽打来了电话，对方报的电话是“7654321”，王爷爷一看通讯录，靠： 
 
 门牌电话 
 
 一号门 1234567 （这个是小明的） 
 
 一号门 7654321 （注意：这个原来是小丽的，但是被小明改了） 
 
 ...... 
 
 王爷爷不知道改了啊，于是就去找一号门的小明了，小明心里这个美啊，他以小丽父亲的口吻严厉的教训了那个男的和小丽之间不正当的男女关系，结果那个男的恭恭敬敬的挂了电话。当然小丽并不知道整个事情的发生... 
 
 这里小明的行为叫做“
 ARP欺骗”（因为在实际的网络上是通过发送ARP数据包来实现的，所以叫做“ARP欺骗”），王爷爷的通讯录叫做“ARP表” 
 
 这里要注意：王爷爷现在有两个通讯录了，一个是记录每个院子传达室电话的本本，叫做“路由表”，一个是现在说的记录院子里面详细信息的本本，叫做“ARP表”。 
 
 有句命言是“人们总是在追求完美的，尽管永远也做不到”（请记住这句话，因为这是一个大名人--也就是我，说的） 
 
 
 王爷爷的制度中有一条是这么写的“每个月要重新检查一下门牌号和电话的对应本（也就是ARP表）”，这个动作叫做“刷新ARP表”，每个月的时间限制叫做“刷新ARP表的周期”。这样小明为了让那个男的永远不能找到小丽，之后每个月都要偷偷改一次那个通讯录，不过这样也是不得不做的事啊！ 
 
 补充一点，小明是很聪明的，如果通讯录（ARP表）被改成了这样： 
 
 门牌（MAC）电话（IP） 
 
 一号门 1234567 （这个是小明的） 
 
 二号门 1234567 （注意：这个被小明改了，但是他一时头晕改错了） 
 
 ...... 
 
 就会是计算机就会弹出一个对话框提示“出现重复的IP地址”，最终会导致王爷爷不知所措，于是通知一号门和二号门，你们的电话重复了。这样小丽就知道有人在破坏她的好事，这个现象叫做“骗局被揭穿了” 
 
 小不点知道了小明偷听他和小暗的电话，于是就和小暗约定好了密码。小不点在家里把要说的加密了之后告诉小暗。土豆－〉星期三，地瓜－〉请客，笨蛋－〉小不点家。于是小不点告诉小暗：土豆笨蛋地瓜。小明听了？？？不懂。。。。郁闷了。。。这是加密。 
 
 除此之外，小丽也知道了小明改他家的电话号码了。于是王爷爷就登门一个一个把电话和门牌号记下来。并且藏起来不允许外人修改，只能自己有钥匙（密码）。
 这是ip地址和MAC地址绑定。当有人改了电话号码的时候，就得找王爷爷改。麻烦是麻烦了，但是安全了。不过小明偷偷的把王爷爷的钥匙偷配了一把（盗窃密码成功），于是他还可以修改。这样么，就这样了。

今天再跟大家聊聊如何将工作总结PPT设计的更加有视觉效果。
 
什么意思呢?
 
其实就是换一种思路，让整套PPT的设计感变得更加强烈、突出。
 
现在很多人自己做PPT时，或者是下载的PPT模板都有些显然并不符合我们的审美需求，对吧。
 
所以需要“操刀”将其“削骨”一番。
 　　
 
要把PPT制作的更形象、生动，在于熟练、运用自如，熟能生巧，在于图文并茂，要有音频、视频、图片、图形的处理、编辑的高水平。这些并非一日之功，熟悉多种软件的使用，结合PPT的操作，多看教程的样板、示例，学习很重要，用好也很不容易。相比于自己做PPT，选择网上成熟的PPT模板，islide可提供大量精美的PPT模板可以选择，这样更加可以节省大量的时间，但需根据自身应用场景或者需求做修改。
 
怎么才能把PPT制作的更形象
 
1、选择好主题
 
对于PPT来说，选好主题很关键，因为主题是整个PPT的中心思想，PPT中的所有内容都是围绕这一主题进行展开的。如果PPT主题不明确，构思就无从着手。
 
2、讲个好故事
 
每个PPT都是一个故事，要想使制作的PPT生动，能快速深入人心，那么，离不开一个好故事。
 
3、写个好文案
 
文案是将策划人员的策划思路形成文字，而PPT则是将制作人的想法、思路等以文字等内容表现出来，对于PPT来说，PPT中的文字内容就是文案的体现，一个好的PPT，其中的文字内容都是经过精心雕琢的，并不是随意复制和添加的，所以说，写个好文案对于PPT来说非常重要。
 
4、做个好设计
 
优秀的PPT是需要设计的，这里所说的PPT设计是指以视觉为主，听觉为辅，对PPT中的对象进行美化、设计，PPT的设计过程就是PPT的制作过程，当PPT制作完成了，设计也就完成了。
 　　
 
PPT制作中要注意哪些技巧?
 
绝招一：文字是用来瞟的，不是读的
 
“PPT很简单，就是把Word里的文字复制、粘贴呗。”这其实是对PPT的一种无知与亵渎。如果直接把文字复制粘贴就能达到演示的效果，PPT根本就没有存在的必要了。
 
PPT的本质在于可视化，就是要把原来看不见、摸不着、晦涩难懂的抽象文字转化为由图表、图片、动画及声音所构成的生动场景，以求通俗易懂、栩栩如生。
 
文字总是高度抽象的，人们需要默读、需要转换成自己的语言、需要上下联想、需要寻找其中的逻辑关系;但人们看电影就轻松许多，只需要跟着故事的发展顺理成章地享受其情节、体味其寓意就行了。PPT就是要把这些文字变得像电影一样生动。
 
所以，提出了两个观点：
 
1、文字是用来瞟的，凡是瞟一眼看不清的地方，就要放大，放大还看不清的，删!
 
2、文字是PPT的天敌。能减则减，能少则少，能转图片转图片，能转图表转图表。
 　　
 
绝招二：20分钟是快乐的极限
 
传统上，我们总是认为，讲得越多，时间越长，越体现出演示者的重视。这是计划经济时代的标准。现在，无论我们的领导、客户还是普通的受众，时间都极为宝贵，没有人愿意阅读动辄数百页的研究报告，也没有人去听你的长篇大论。
 
浓缩的才是精品!演示的核心内容是什么?观点!
 
在此基础上把观众容易困惑的地方、你认为重要的地方作一些说明。永远不要担心你的演示过短，如果花费20分钟就能够把一天才能了解的内容讲清楚，你实际上为观众节省了7小时40分，在时间就是金钱的年代，观众当然求之不得。
 
简短的另一个好处是意犹未尽。如果你的演示足够精彩，会给观众留下更多的期待和回味，甚至会有人要求把你的PPT拷回去好好研究几遍呢。
 
绝招三：清晰比什么都重要
 
PPT有一个致命的弱点——观众容易迷失思路。
 
为什么?
 
一、PPT毕竟不是电影，其逻辑结构是抽象的，难以把握;
 
二、PPT是一页页翻下去的，一次只能看一页内容，前面看过的只能依靠记忆。
 　　
 
解决的办法有两个：
 
一、事先给每位观众发一份演说纲要;
 
二、给你的PPT建立清晰的导航系统
 
导航系统主要包括：
 
从片头动画、封面、前言、目录，到切换页、正文页、结尾页等一套完整的PPT架构;
 
每页都有标题栏(除了标明整个PPT的标题，更重要的是标明本章节的标题、本页的主题);
 
页码，如果方便的话也尽可能加上。
 
设计非一日之功，但我们可以找到捷径。要善于选择专业素材、做好排版布局、多看精美案例，才可以逐步提升自身的PPT制作实力。

装饰器
 
装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多初次接触这个知识的人来讲，这个功能有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，这个都不会，别跟人家说你会Python, 看了下面的文章，保证你学会装饰器。
 
1、先明白这段代码
 
#### 第一波 ####
def foo():
    print('foo')

foo  # 表示是函数
foo()  # 表示执行foo函数

#### 第二波 ####
def foo():
    print('foo')

foo = lambda x: x + 1

foo()  # 执行lambda表达式，而不再是原来的foo函数，因为foo这个名字被重新指向了另外一个匿名函数
 
函数名仅仅是个变量，只不过指向了定义的函数而已，所以才能通过 函数名()调用，如果 函数名=xxx被修改了，那么当在执行 函数名()时，调用的就不知之前的那个函数了
 
2、需求来了
 
初创公司有N个业务部门，基础平台部门负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：
 
############### 基础平台提供的功能如下 ###############

def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

def f4():
    print('f4')

############### 业务部门A 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()

############### 业务部门B 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()
 
目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。
 
老大把工作交给 Low B，他是这么做的：
 
 
 
跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证。诶，这样一来基础平台就不需要做任何修改了。太棒了，有充足的时间泡妹子...
 
 
当天Low B 被开除了…
 
老大把工作交给 Low BB，他是这么做的：
 
############### 基础平台提供的功能如下 ############### 

def f1():
    # 验证1
    # 验证2
    # 验证3
    print('f1')

def f2():
    # 验证1
    # 验证2
    # 验证3
    print('f2')

def f3():
    # 验证1
    # 验证2
    # 验证3
    print('f3')

def f4():
    # 验证1
    # 验证2
    # 验证3
    print('f4')

############### 业务部门不变 ############### 
### 业务部门A 调用基础平台提供的功能### 

f1()
f2()
f3()
f4()

### 业务部门B 调用基础平台提供的功能 ### 

f1()
f2()
f3()
f4()
 
过了一周 Low BB 被开除了…
 
老大把工作交给 Low BBB，他是这么做的：
 
 
 
只对基础平台的代码进行重构，其他业务部门无需做任何修改
 
 
############### 基础平台提供的功能如下 ############### 

def check_login():
    # 验证1
    # 验证2
    # 验证3
    pass


def f1():

    check_login()

    print('f1')

def f2():

    check_login()

    print('f2')

def f3():

    check_login()

    print('f3')

def f4():

    check_login()

    print('f4')
 
老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：
 
老大说：
 
写代码要遵循开放封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：
 
封闭：已实现的功能代码块
开放：对扩展开发
如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：
 
def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        func()
    return inner

@w1
def f1():
    print('f1')
@w1
def f2():
    print('f2')
@w1
def f3():
    print('f3')
@w1
def f4():
    print('f4')
 
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。
 
Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？
 
老大正要生气，突然Low BBB的手机掉到地上，恰巧屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，决定和Low BBB交个好朋友。
 
详细的开始讲解了：
 
单独以f1为例：
 
def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        func()
    return inner

@w1
def f1():
    print('f1')
 
python解释器就会从上到下解释代码，步骤如下：
 
def w1(func): ==>将w1函数加载到内存
@w1
没错， 从表面上看解释器仅仅会解释这两句代码，因为函数在 没有被调用之前其内部代码不会被执行。
 
从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章， @函数名 是python的一种语法糖。
 
上例@w1内部会执行一下操作：
 
执行w1函数
 
 
 
执行w1函数 ，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1) 所以，内部就会去执行：
 
 
def inner(): 
    #验证 1
    #验证 2
    #验证 3
    f1()    # func是参数，此时 func 等于 f1 
return inner# 返回的 inner，inner代表的是函数，非执行函数 ,其实就是将原来的 f1 函数塞进另外一个函数中
 
 
w1的返回值
 
 
 
将执行完的w1函数返回值 赋值 给@w1下面的函数的函数名f1 即将w1的返回值再重新赋值给 f1，即：
 
 
新f1 = def inner(): 
            #验证 1
            #验证 2
            #验证 3
            原来f1()
        return inner
 
 
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。
 
 
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着
 
Low BBB 你明白了吗？要是没明白的话，我晚上去你家帮你解决吧！！！
 
3. 再议装饰器
 

# 定义函数：完成包裹数据
def makeBold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

# 定义函数：完成包裹数据
def makeItalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makeBold
def test1():
    return "hello world-1"

@makeItalic
def test2():
    return "hello world-2"

@makeBold
@makeItalic
def test3():
    return "hello world-3"

print(test1())
print(test2())
print(test3())
 
运行结果:
 
<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>
 
4. 装饰器(decorator)功能
 
引入日志
函数执行时间统计
执行函数前预备处理
执行函数后清理功能
权限校验等场景
缓存
5. 装饰器示例
 
例1:无参数的函数
 

from time import ctime, sleep

def timefun(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        func()
    return wrapped_func

@timefun
def foo():
    print("I am foo")

foo()
sleep(2)
foo()
 
上面代码理解装饰器执行行为可理解成
 
foo = timefun(foo)
# foo先作为参数赋值给func后,foo接收指向timefun返回的wrapped_func
foo()
# 调用foo(),即等价调用wrapped_func()
# 内部函数wrapped_func被引用，所以外部函数的func变量(自由变量)并没有释放
# func里保存的是原foo函数对象
 
例2:被装饰的函数有参数
 
from time import ctime, sleep

def timefun(func):
    def wrapped_func(a, b):
        print("%s called at %s" % (func.__name__, ctime()))
        print(a, b)
        func(a, b)
    return wrapped_func

@timefun
def foo(a, b):
    print(a+b)

foo(3,5)
sleep(2)
foo(2,4)
 
例3:被装饰的函数有不定长参数
 
from time import ctime, sleep

def timefun(func):
    def wrapped_func(*args, **kwargs):
        print("%s called at %s"%(func.__name__, ctime()))
        func(*args, **kwargs)
    return wrapped_func

@timefun
def foo(a, b, c):
    print(a+b+c)

foo(3,5,7)
sleep(2)
foo(2,4,9)
 
例4:装饰器中的return
 
from time import ctime, sleep

def timefun(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        func()
    return wrapped_func

@timefun
def foo():
    print("I am foo")

@timefun
def getInfo():
    return '----hahah---'

foo()
sleep(2)
foo()


print(getInfo())
 
执行结果:
 
foo called at Fri Nov  4 21:55:35 2016
I am foo
foo called at Fri Nov  4 21:55:37 2016
I am foo
getInfo called at Fri Nov  4 21:55:37 2016
None
 
如果修改装饰器为return func()，则运行结果：
 
foo called at Fri Nov  4 21:55:57 2016
I am foo
foo called at Fri Nov  4 21:55:59 2016
I am foo
getInfo called at Fri Nov  4 21:55:59 2016
----hahah---
 
总结：
 
一般情况下为了让装饰器更通用，可以有return
例5:装饰器带参数,在原有装饰器的基础上，设置外部变量
 
#decorator2.py

from time import ctime, sleep

def timefun_arg(pre="hello"):
    def timefun(func):
        def wrapped_func():
            print("%s called at %s %s" % (func.__name__, ctime(), pre))
            return func()
        return wrapped_func
    return timefun

# 下面的装饰过程
# 1. 调用timefun_arg("itcast")
# 2. 将步骤1得到的返回值，即time_fun返回， 然后time_fun(foo)
# 3. 将time_fun(foo)的结果返回，即wrapped_func
# 4. 让foo = wrapped_fun，即foo现在指向wrapped_func
@timefun_arg("itcast")
def foo():
    print("I am foo")

@timefun_arg("python")
def too():
    print("I am too")

foo()
sleep(2)
foo()

too()
sleep(2)
too()
 
可以理解为
 
foo()==timefun_arg("itcast")(foo)()
 
例6：类装饰器（扩展，非重点）
 
装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 __call__() 方法，那么这个对象就是callable的。
 
class Test():
    def __call__(self):
        print('call me!')

t = Test()
t()  # call me
 
类装饰器demo
 

class Test(object):
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s"%func.__name__)
        self.__func = func
    def __call__(self):
        print("---装饰器中的功能---")
        self.__func()
#说明：
#1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象
#   并且会把test这个函数名当做参数传递到__init__方法中
#   即在__init__方法中的属性__func指向了test指向的函数
#
#2. test指向了用Test创建出来的实例对象
#
#3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法
#
#4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用
#   所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体
@Test
def test():
    print("----test---")
test()
showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"
 
运行结果如下：
 
---初始化---
func name is test
---装饰器中的功能---
----test---

不要相信任何所谓程序员说的：“HTML是用来做网页的”。
 
这句话正确的描述是：“HTML是用于描述超文本的，网页是一个超文本资源节点”。
 
HTML和网页本无联系。
 
建立向女神寝室的信息通信
 
为了简化你对复杂的Internet的理解，我们暂时把复杂的Internet抽象成：你向女生宿舍发送信号。
 
为了能够在断网后继续联络女神，你买来了电池和开关，然后拉了普通电线线到女神的寝室。
 
你的女神把小灯泡接在了电线的两端。
 
那么，你只需要开闭开关，就可以控制女神屋里的灯泡了。
 
发送信号
 
关闭着小灯泡1秒钟，代表发送一个0。
 
打开了小灯泡1秒钟，代表发送一个1。
 
此时你可以向女神发送任意二进制内容了。
 
发送文本
 
你只希望发送一个“Good Night”。
 
所以你必须想办法对“Good Night”进行编码。
 
'G','o','o','d'的ASCII编码是：071，111，111，100
 
转换成二进制就是： 0100 0001 0110 1111 0110 1111 0110 0100
 
使用发送二进制信号的方法发过去，你的女神需要自己解码来阅读出“Good”。
 
发送富文本
 
有一天，你希望发送“I miss you”。
 
为了表达心意，你希望加粗“you”，并使用红色的字体发送“miss”。
 
而……这一根简陋的电线似乎很难理解“加粗”和“红色”……
 
不过这难不倒你的。
 
于是机智你发送了：I <red>miss</red> <b>you</b>
 
同样机智的女神理解了这件事情。
 
你发明了一种语言
 
你很喜欢这种编码格式。
 
这是一种标记语言，于是你称其为：TGML （To Girl Markup Language）
 
平时你使用TGML来和你的女神通信。
 
TGML可以非常好的解决富文本的传输问题。
 
表白
 
终于你决定表白了。
 
你绘制了很美丽的心形图片，还有两个按钮：接受、拒绝。
 
两个按钮分别会链接到 "接受.tgml"和"拒绝.tgml"
 
为了描述图片，你使用了<img src="pic">
 
为了描述按钮，你使用了<a href="接受.tgml">
 
现在你发送给女神的内容，已经不只是带格式的富文本，而是带链接的富文本。
 
如果把带链接的富文本叫超文本。那么……
 
于是在这个世界上，拥有了一种能够描述超文本的语言，叫做TGML
 
超文本
 
描述超文本的方式有很多，例如：HTML，TGML，还有markdown。
 
HTML的诞生是为了描述超文本。
 
超文本的用途也很多，例如：描述一个网页，或者描述一个Word文档。
 
HTML文件是超文本文件。但是超文本未必是HTML。
 
Microsoft Word
 
Microsoft Word是Office的一个组件。它同样代表一个超文本资源。
 
如果你解压一个docx文件并仔细翻一翻，你能找到你刚才写的作业，是以XML方式记载着。
 
当然，描述超文本还有markdown。所以你可以使用一些工具，比如pandoc，把markdown转换成word。
 
故事的结局
 
你的女神有一个名字，叫浏览器。
 
你的名字叫Web服务器。
 
你们中间的那根线，叫HTTP。
 
总结
 
HTML用于描述超文本。描述超文本的语言有很多种。
 
超文本的用途很多。做网页只是其中一种。
 
HTML最初设计时确实是为了做网页考虑的。但HTML不是做网页的唯一工具。
 
探索HTML是如何呈现、渲染还有它强大的功能时，你只是在探索你的浏览器的解码能力而已。
 
 
 
=====小字=====
 
 
 
*后注：html一般不是ASCII编码，而是utf-8
 
*HTTP除了要传输内容，还要传输状态码，头，地址等很多信息。上面的文字只是简化了这个模型。
 
*<Red>不是合法的html标签