IPFS(四) 源码解读之-p2p

package p2p

10年积累的成都做网站、成都网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有石嘴山免费网站建设让你可以放心的选择与我们合作。

import (

"context"

"errors"

"time"

net "gx/ipfs/QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh/go-libp2p-net"

manet "gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"

ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"

pro "gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"

pstore "gx/ipfs/QmZR2XWVVBCtbgBWnQhWk2xcQfaR3W8faQPriAiaaj7rsr/go-libp2p-peerstore"

p2phost "gx/ipfs/Qmb8T6YBBsjYsVGfrihQLfCJveczZnneSBqBKkYEBWDjge/go-libp2p-host"

peer "gx/ipfs/QmdVrMn1LhB4ybb8hMVaMLXnA8XRSewMnK6YqXKXoTcRvN/go-libp2p-peer"

)

//P2P结构保存当前正在运行的流/监听器的信息

// P2P structure holds information on currently running streams/listeners

type P2P struct {

//监听器

Listeners ListenerRegistry

//数据流

Streams StreamRegistry

//节点ID

identity peer.ID

//节点地址

peerHost p2phost.Host

//一个线程安全的对等节点存储

peerstore pstore.Peerstore

}

//创建一个新的p2p结构

// NewP2P creates new P2P struct

//这个新的p2p结构不包含p2p结构中的监听器和数据流

func NewP2P(identity peer.ID, peerHost p2phost.Host, peerstore pstore.Peerstore) *P2P {

return P2P{

identity: identity,

peerHost: peerHost,

peerstore: peerstore,

}

}

//新建一个数据流 工具方法 构建一个有节点id，内容和协议的流

func (p2p P2P) newStreamTo(ctx2 context.Context, p peer.ID, protocol string) (net.Stream, error) {

//30s 后会自动timeout

ctx, cancel := context.WithTimeout(ctx2, time.Second 30) //TODO: configurable?

defer cancel()

err := p2p.peerHost.Connect(ctx, pstore.PeerInfo{ID: p})

if err != nil {

return nil, err

}

return p2p.peerHost.NewStream(ctx2, p, pro.ID(protocol))

}

//对话为远程监听器创建新的P2P流

//创建一个新的p2p流实现对对话的监听

// Dial creates new P2P stream to a remote listener

//Multiaddr是一种跨协议、跨平台的表示格式的互联网地址。它强调明确性和自我描述。

//对内接收

func (p2p P2P) Dial(ctx context.Context, addr ma.Multiaddr, peer peer.ID, proto string, bindAddr ma.Multiaddr) ( ListenerInfo, error) {

//获取一些节点信息 network, host, nil

lnet, _, err := manet.DialArgs(bindAddr)

if err != nil {

return nil, err

}

//监听信息

listenerInfo := ListenerInfo{

//节点身份

Identity: p2p.identity,

////应用程序协议标识符。

Protocol: proto,

}

//调用newStreamTo 通过ctx（内容） peer（节点id） proto（协议标识符） 参数获取一个新的数据流

remote, err := p2p.newStreamTo(ctx, peer, proto)

if err != nil {

return nil, err

}

//network协议标识

switch lnet {

//network为"tcp", "tcp4", "tcp6"

case "tcp", "tcp4", "tcp6":

//从监听器获取新的信息 nla.Listener, nil

listener, err := manet.Listen(bindAddr)

if err != nil {

if err2 := remote.Reset(); err2 != nil {

return nil, err2

}

return nil, err

}

//将获取的新信息保存到listenerInfo

listenerInfo.Address = listener.Multiaddr()

listenerInfo.Closer = listener

listenerInfo.Running = true

//开启接受

go p2p.doAccept(listenerInfo, remote, listener)

default:

return nil, errors.New("unsupported protocol: " + lnet)

}

return listenerInfo, nil

}

//

func (p2p *P2P) doAccept(listenerInfo *ListenerInfo, remote net.Stream, listener manet.Listener) {

//关闭侦听器并删除流处理程序

defer listener.Close()

//Returns a Multiaddr friendly Conn

//一个有好的 Multiaddr 连接

local, err := listener.Accept()

if err != nil {

return

}

stream := StreamInfo{

//连接协议

Protocol: listenerInfo.Protocol,

//定位节点

LocalPeer: listenerInfo.Identity,

//定位节点地址

LocalAddr: listenerInfo.Address,

//远程节点

RemotePeer: remote.Conn().RemotePeer(),

//远程节点地址

RemoteAddr: remote.Conn().RemoteMultiaddr(),

//定位

Local: local,

//远程

Remote: remote,

//注册码

Registry: p2p.Streams,

}

//注册连接信息

p2p.Streams.Register(stream)

//开启节点广播

stream.startStreaming()

}

//侦听器将流处理程序包装到侦听器中

// Listener wraps stream handler into a listener

type Listener interface {

Accept() (net.Stream, error)

Close() error

}

//P2PListener保存关于侦听器的信息

// P2PListener holds information on a listener

type P2PListener struct {

peerHost p2phost.Host

conCh chan net.Stream

proto pro.ID

ctx context.Context

cancel func()

}

//等待侦听器的连接

// Accept waits for a connection from the listener

func (il *P2PListener) Accept() (net.Stream, error) {

select {

case c := -il.conCh:

return c, nil

case -il.ctx.Done():

return nil, il.ctx.Err()

}

}

//关闭侦听器并删除流处理程序

// Close closes the listener and removes stream handler

func (il *P2PListener) Close() error {

il.cancel()

il.peerHost.RemoveStreamHandler(il.proto)

return nil

}

// Listen创建新的P2PListener

// Listen creates new P2PListener

func (p2p P2P) registerStreamHandler(ctx2 context.Context, protocol string) ( P2PListener, error) {

ctx, cancel := context.WithCancel(ctx2)

list := P2PListener{

peerHost: p2p.peerHost,

proto: pro.ID(protocol),

conCh: make(chan net.Stream),

ctx: ctx,

cancel: cancel,

}

p2p.peerHost.SetStreamHandler(list.proto, func(s net.Stream) {

select {

case list.conCh - s:

case -ctx.Done():

s.Reset()

}

})

return list, nil

}

// NewListener创建新的p2p侦听器

// NewListener creates new p2p listener

//对外广播

func (p2p P2P) NewListener(ctx context.Context, proto string, addr ma.Multiaddr) ( ListenerInfo, error) {

//调用registerStreamHandler 构造一个新的listener

listener, err := p2p.registerStreamHandler(ctx, proto)

if err != nil {

return nil, err

}

//构造新的listenerInfo

listenerInfo := ListenerInfo{

Identity: p2p.identity,

Protocol: proto,

Address: addr,

Closer: listener,

Running: true,

Registry: p2p.Listeners,

}

go p2p.acceptStreams(listenerInfo, listener)

//注册连接信息

p2p.Listeners.Register(listenerInfo)

return listenerInfo, nil

}

//接受流

func (p2p *P2P) acceptStreams(listenerInfo *ListenerInfo, listener Listener) {

for listenerInfo.Running {

//一个有好的 远程 连接

remote, err := listener.Accept()

if err != nil {

listener.Close()

break

}

}

//取消注册表中的p2p侦听器

p2p.Listeners.Deregister(listenerInfo.Protocol)

}

// CheckProtoExists检查是否注册了协议处理程序

// mux处理程序

// CheckProtoExists checks whether a protocol handler is registered to

// mux handler

func (p2p *P2P) CheckProtoExists(proto string) bool {

protos := p2p.peerHost.Mux().Protocols()

for _, p := range protos {

if p != proto {

continue

}

return true

}

return false

}

python如何入门？

1.找浅显易懂，例程比较好的教程，从头到尾看下去。不要看很多本，专注于一本。把里面的例程都手打一遍，搞懂为什么。

2.去找实际项目练手。最好是要有真实的项目做。可以找几个同学一起做个网站之类。注意，真实项目不一定非要是商业项目。

3.最好能找到一个已经会python的人。问他一点学习规划的建议，然后在遇到卡壳的地方找他指点。这样会事半功倍。

4.另外，除了学习编程语言，也兼顾补一点计算机基础，和英语。

5.不但要学写代码，还要学会看代码，更要会调试代码。读懂你自己程序的报错信息。再去找些github上的程序，读懂别人的代码。

6.学会查文档，用好搜索引擎和开发者社区。

想学Python的童鞋可以加企鹅裙前三位是227，中间是435，后三位是450分享软件视频资料

学Python和学其他的语言其实是相同的，我给新同事讲课的时候就说学编程和练武功其实是很相似，入门大致这样几步:

找本靠谱的书,

找个靠谱的师傅，

找一个地方开始练习。

学语言也是的：选一本通俗易懂的书，找一个好的视频资料，然后自己装一个IDE工具开始边学变写。下面我具体来讲讲:

1.找一本靠谱的书，难度一定要是入门级别，千万不能太复杂，不要一下子陷进去，会打乱节奏，学东西要循序渐进，不能一口吃个胖子.打个比方，学过java的同学都听过大名鼎鼎的thinking in java,这边书很厚很全，若一上来就学，肯定会吃力，时间长了就会失去兴趣，因此对初学者来说，一定要找一个通熟易懂的，简单的书。入门的书非常关键。

入门的书很多，但是我个人强烈推荐"A Byte of Python",这本书我读了2遍，作者写的思路非常清晰，对每一个知识点讲解的很到位，不多不少，刚刚好，对初学者来说，力道刚刚好。而且是全英文，对提高自己的英语水平，很有帮助.

网上有人会推荐"笨办法学Python",我个人觉得这本书没有"A Byte of Python"好 .一般有一些编程基本，我建议直接看"A Byte of Python".这本书的销量已经破百万了，而且在豆瓣上点评有8.8,可谓是入门级的神书.电子版大家可以在CSDN 搜一下就有，都是高清的.

2.多编写程序，这似乎是废话，但是确实是一句实话。学编程一定要亲身去编写，没有什么捷径.一开始哪怕你把书里面的例子一字不落敲一遍，也好过你只是去看书，而不动手。

而且学python 最好是坚持编，每天抽小半个小时，学一些知识点,不断的坚持.大概快的话几个星期基本就能入门了。

以上就是我对python 入门的感悟，希望对初学者能有一点帮助，能帮到一些人少走一点弯路.也就不枉我大半夜在这里码字了~~

最后说一下，我坚持原创，若我写的对大家有帮助，麻烦大家支持一下，也是对我的一点鼓励和动力。

当然，如果你是0基础，周围也没有大神带领，自己也学不进去，我劝你还是放弃吧，或者就找个培训机构花点钱学习

谢谢

golang p2p网

继续进入下一个初始化

n.netService, err = nebnet.NewNebService(n)

if err != nil {

logging.CLog().WithFields(logrus.Fields{

"err": err,

}).Fatal("Failed to setup net service.")

}

netservice有两个成员

type NebServicestruct {

node      *Node

dispatcher *Dispatcher

}

跳出stup()函数

先进入start()函数看一看

if err := n.netService.Start(); err != nil {

logging.CLog().WithFields(logrus.Fields{

"err": err,

}).Fatal("Failed to start net service.")

}

进入netservice.start()

func (ns *NebService) Start() error {

logging.CLog().Info("Starting NebService...")

// start dispatcher.

ns.dispatcher.Start()

// start node.

if err := ns.node.Start(); err != nil {

ns.dispatcher.Stop()

logging.CLog().WithFields(logrus.Fields{

"err": err,

}).Error("Failed to start NebService.")

return err

}

logging.CLog().Info("Started NebService.")

return nil

}

可以看到第一个start()的函数是dispatcher.start()

进入dispatch.start()

func (dp *Dispatcher) Start() {

logging.CLog().Info("Starting NebService Dispatcher...")

go dp.loop()

}

然后就出现一个新的线程、goruntime

go dp.loop()

进入该线程，看它干了些什么

timerChan := time.NewTicker(time.Second).C

for {

select {

case -timerChan:

metricsDispatcherCached.Update(int64(len(dp.receivedMessageCh)))

case -dp.quitCh:

logging.CLog().Info("Stoped NebService Dispatcher.")

return

case msg := -dp.receivedMessageCh:

msgType := msg.MessageType()

v, _ := dp.subscribersMap.Load(msgType)

if v == nil {

continue

  }

m, _ := v.(*sync.Map)

m.Range(func(key, valueinterface{}) bool {

select {

case key.(*Subscriber).msgChan - msg:

default:

logging.VLog().WithFields(logrus.Fields{

"msgType": msgType,

}).Warn("timeout to dispatch message.")

}

return true

  })

}

}

一个有点长的循环

metricsDispatcherCached.Update(int64(len(dp.receivedMessageCh)))一秒钟刷新一次缓冲区

case msg := -dp.receivedMessageCh:

msgType := msg.MessageType()如果能取出dp.receivedMessageCh

msgType := msg.MessageType()首先判断取出的信息类型

v, _ := dp.subscribersMap.Load(msgType)

if v == nil {

continue

}

根据类型取出相应的map

如果取不出，那么使用continue结束这个case

m, _ := v.(*sync.Map)

断言

m.Range(func(key, valueinterface{}) bool {

select {

case key.(*Subscriber).msgChan - msg:

default:

logging.VLog().WithFields(logrus.Fields{

"msgType": msgType,

}).Warn("timeout to dispa+tch message.")

}

return true

})

将msg推入其他管道里面去。其他goruntime会循环等待该

区块链技术想要快速入门，一般涉及哪些编程语言？

任何一门计算机语言，都能在特定某个领域的应用中，实现区块链技术；

具体使用哪一门语言，完全看我们相应领域行业企业项目的技术要求，以及更关键的：跟已有信息系统的有效对接联通。

区块链具有自下而上生成记录，生成两方或多方合同类记录，加入第三方确认机制，分布存储，……等特点；

从而让它相比集中式的存储运算而言，变得更为可信。

常见的总统投票，就非常适合以区块链技术重新架构；采用区块链技术的投票系统，能够避免哪一家技术公司、某一个关键技术人员，操纵选票统计结果的可能。

像我们的法院证据，也特别适合采用区块链技术重新架构开发。

其实像当前我们各类互联网时代的“版权系统”，它们中一些就是采用区块链技术架构而来，只不过，目前我们的新闻出版局、专利局（或者更广义地被称作“专家评委”），都尚未接入这些由互联网公司创新而来的版权平台。

我们耳熟能详 的“法大大”（虽然名字不甚好听、甚至乍一听来有些让人“摸不着头脑”），它也其实正准备采用最新的区块链技术重新架构；采用区块链技术的合同平台，因为变得更加可信，也才能更便于互联网时代人们签订各类商务合同。

还有像我们的“征信系统”，也非常适合以区块链技术加以改造。能够让它更有说服力，而不致于出现一家单位、乃至随意某个关键技术人员，能随意往其中添加“征信污点数据”的情况。

还有像我们的P2P贷款，如果能够以区块链技术重新架构的话，也能够变得更加可信，而不致于出现违约、卷款跑路这样的失信情况。

python哪家的培训比较好？价钱是多少？

相信在IT领域发展的同学对Java很熟悉。Java编程语言排行中一直处于领先地位，这可以直接体现Java的重要。因此很多同学准备参加Python培训机构系统学习。那么，Python培训机构哪家比较好？下面我们介绍一下。

随着Java的普及，越来越多的人了解Java，企业也会对求职者提出更高的要求，他们想招聘一些能马上开始工作的人，所以往往会招聘一些有项目开发经验的人。这就是为什么那么多计算机专业的大学生找不到工作，所以越来越多的大学生会选择在毕业前后参加一些专业的Python培训课程，以增加他们的实践经验。只有增强自己的力量，才能立于不败之地。

Python培训机构哪家比较好？判断Python培训机构好与坏主要看以下几个方面

1.看教学课程内容

学习Java技术，最主要是与时俱进，掌握的技术点能够满足时下企业的用人需求。而想要了解一家培训机构所提供的课程是否新颖，也可以去机构的官网上看看，了解自己想学习的学科的课程大纲。看看学习路线图是如何安排的，有没有从零到一的系统搭建，是不是有强化实训、实操的比重，有尽量多的项目实战。因为企业对Java从业者的技术能力和动手实战能力要求较高。

2.看师资力量

因为Java开发技术知识的专业性很强，如果盲目去学很容易走进误区。相反，有讲师带领，站在巨人的肩膀上，往往事半功倍。毕竟现在这个时代只要多跟别人交流才能获得更多更有价值的信息，初学者千万不能闭门造车。

3.看口碑

行业内口碑比较好，学生对培训机构比较认可，这种机构把精力放在了学生身上的机构，才是做教育的应有态度。

4.看就业情况

以学生就业为目标的培训机构现在才是最主要的。要知道就业也是教学成果的体现，没有好的教学保证是做不到好的就业的。

5.上门免费试听

试听是为了更好的去感受培训机构的课程内容、讲课风格、班级氛围等，同时也能通过和班上在读同学进行交流，更进一步去了解这家培训机构各个方面是否符合自己的需要。

如何系统地自学 Python

是否非常想学好 Python，一方面被琐事纠缠，一直没能动手，另一方面，担心学习成本太高，心里默默敲着退堂鼓？

幸运的是，Python 是一门初学者友好的编程语言，想要完全掌握它，你不必花上太多的时间和精力。

Python 的设计哲学之一就是简单易学，体现在两个方面：

语法简洁明了：相对 Ruby 和 Perl，它的语法特性不多不少，大多数都很简单直接，不玩儿玄学。

切入点很多：Python 可以让你可以做很多事情，科学计算和数据分析、爬虫、Web 网站、游戏、命令行实用工具等等等等，总有一个是你感兴趣并且愿意投入时间的。

废话不多说，学会一门语言的捷径只有一个： Getting Started

¶ 起步阶段

任何一种编程语言都包含两个部分：硬知识和软知识，起步阶段的主要任务是掌握硬知识。

硬知识

“硬知识”指的是编程语言的语法、算法和数据结构、编程范式等，例如：变量和类型、循环语句、分支、函数、类。这部分知识也是具有普适性的，看上去是掌握了一种语法，实际是建立了一种思维。例如：让一个 Java 程序员去学习 Python，他可以很快的将 Java 中的学到的面向对象的知识 map 到 Python 中来，因此能够快速掌握 Python 中面向对象的特性。

如果你是刚开始学习编程的新手，一本可靠的语法书是非常重要的。它看上去可能非常枯燥乏味，但对于建立稳固的编程思维是必不可少。

下面列出了一些适合初学者入门的教学材料：

廖雪峰的 Python 教程    Python 中文教程的翘楚，专为刚刚步入程序世界的小白打造。  

笨方法学 Python    这本书在讲解 Python 的语法成分时，还附带大量可实践的例子，非常适合快速起步。  

The Hitchhiker’s Guide to Python!    这本指南着重于 Python 的最佳实践，不管你是 Python 专家还是新手，都能获得极大的帮助。  

Python 的哲学：

用一种方法，最好是只有一种方法来做一件事。

学习也是一样，虽然推荐了多种学习资料，但实际学习的时候，最好只选择其中的一个，坚持看完。

必要的时候，可能需要阅读讲解数据结构和算法的书，这些知识对于理解和使用 Python 中的对象模型有着很大的帮助。

软知识

“软知识”则是特定语言环境下的语法技巧、类库的使用、IDE的选择等等。这一部分，即使完全不了解不会使用，也不会妨碍你去编程，只不过写出的程序，看上去显得“傻”了些。

对这些知识的学习，取决于你尝试解决的问题的领域和深度。对初学者而言，起步阶段极易走火，或者在选择 Python 版本时徘徊不决，一会儿看 2.7 一会儿又转到 3.0，或者徜徉在类库的大海中无法自拔，Scrapy，Numpy，Django 什么都要试试，或者参与编辑器圣战、大括号缩进探究、操作系统辩论赛等无意义活动，或者整天跪舔语法糖，老想着怎么一行代码把所有的事情做完，或者去构想圣洁的性能安全通用性健壮性全部满分的解决方案。

很多“大牛”都会告诫初学者，用这个用那个，少走弯路，这样反而把初学者推向了真正的弯路。

还不如告诉初学者，学习本来就是个需要你去走弯路出 Bug，只能脚踏实地，没有奇迹只有狗屎的过程。

选择一个方向先走下去，哪怕脏丑差，走不动了再看看有没有更好的解决途径。

自己走了弯路，你才知道这么做的好处，才能理解为什么人们可以手写状态机去匹配却偏要发明正则表达式，为什么面向过程可以解决却偏要面向对象，为什么我可以操纵每一根指针却偏要自动管理内存，为什么我可以嵌套回调却偏要用 Promise...

更重要的是，你会明白，高层次的解决方法都是对低层次的封装，并不是任何情况下都是最有效最合适的。

技术涌进就像波浪一样，那些陈旧的封存已久的技术，消退了迟早还会涌回的。就像现在移动端应用、手游和 HTML5 的火热，某些方面不正在重演过去 PC 的那些历史么？

因此，不要担心自己走错路误了终身，坚持并保持进步才是正道。

起步阶段的核心任务是掌握硬知识，软知识做适当了解，有了稳固的根，粗壮的枝干，才能长出浓密的叶子，结出甜美的果实。

¶ 发展阶段

完成了基础知识的学习，必定会感到一阵空虚，怀疑这些语法知识是不是真的有用。

没错，你的怀疑是非常正确的。要让 Python 发挥出它的价值，当然不能停留在语法层面。

发展阶段的核心任务，就是“跳出 Python，拥抱世界”。

在你面前会有多个分支：科学计算和数据分析、爬虫、Web 网站、游戏、命令行实用工具等等等等，这些都不是仅仅知道 Python 语法就能解决的问题。

拿爬虫举例，如果你对计算机网络，HTTP 协议，HTML，文本编码，JSON 一无所知，你能做好这部分的工作么？而你在起步阶段的基础知识也同样重要，如果你连循环递归怎么写都还要查文档，连 BFS 都不知道怎么实现，这就像工匠做石凳每次起锤都要思考锤子怎么使用一样，非常低效。

在这个阶段，不可避免要接触大量类库，阅读大量书籍的。

类库方面

「Awesome Python 项目」：vinta/awesome-python · GitHub

这里列出了你在尝试解决各种实际问题时，Python 社区已有的工具型类库，如下图所示：

请点击输入图片描述

vinta/awesome-python

你可以按照实际需求，寻找你需要的类库。

至于相关类库如何使用，必须掌握的技能便是阅读文档。由于开源社区大多数文档都是英文写成的，所以，英语不好的同学，需要恶补下。

书籍方面

这里我只列出一些我觉得比较有一些帮助的书籍，详细的请看豆瓣的书评：

科学和数据分析：

❖「集体智慧编程」：集体智慧编程 (豆瓣)

❖「数学之美」：数学之美 (豆瓣)

❖「统计学习方法」：统计学习方法 (豆瓣)

❖「Pattern Recognition And Machine Learning」：Pattern Recognition And Machine Learning (豆瓣)

❖「数据科学实战」：数据科学实战 (豆瓣)

❖「数据检索导论」：信息检索导论 (豆瓣)

爬虫：

❖「HTTP 权威指南」：HTTP权威指南 (豆瓣)

Web 网站：

❖「HTML CSS 设计与构建网站」：HTML CSS设计与构建网站 (豆瓣)

...

列到这里已经不需要继续了。

聪明的你一定会发现上面的大部分书籍，并不是讲 Python 的书，而更多的是专业知识。

事实上，这里所谓“跳出 Python，拥抱世界”，其实是发现 Python 和专业知识相结合，能够解决很多实际问题。这个阶段能走到什么程度，更多的取决于自己的专业知识。

¶ 深入阶段

这个阶段的你，对 Python 几乎了如指掌，那么你一定知道 Python 是用 C 语言实现的。

可是 Python 对象的“动态特征”是怎么用相对底层，连自动内存管理都没有的C语言实现的呢？这时候就不能停留在表面了，勇敢的拆开 Python 的黑盒子，深入到语言的内部，去看它的历史，读它的源码，才能真正理解它的设计思路。

这里推荐一本书：

「Python 源码剖析」：Python源码剖析 (豆瓣)

这本书把 Python 源码中最核心的部分，给出了详细的阐释，不过阅读此书需要对 C 语言内存模型和指针有着很好的理解。

另外，Python 本身是一门杂糅多种范式的动态语言，也就是说，相对于 C 的过程式、 Haskell 等的函数式、Java 基于类的面向对象而言，它都不够纯粹。换而言之，编程语言的“道学”，在 Python 中只能有限的体悟。学习某种编程范式时，从那些面向这种范式更加纯粹的语言出发，才能有更深刻的理解，也能了解到 Python 语言的根源。

这里推荐一门公开课

「编程范式」：斯坦福大学公开课：编程范式

讲师高屋建瓴，从各种编程范式的代表语言出发，给出了每种编程范式最核心的思想。

值得一提的是，这门课程对C语言有非常深入的讲解，例如C语言的范型和内存管理。这些知识，对阅读 Python 源码也有大有帮助。

Python 的许多最佳实践都隐藏在那些众所周知的框架和类库中，例如 Django、Tornado 等等。在它们的源代码中淘金，也是个不错的选择。

¶  最后的话

每个人学编程的道路都是不一样的，其实大都殊途同归，没有迷路的人只有不能坚持的人！

希望想学 Python 想学编程的同学，不要犹豫了，看完这篇文章，

Just Getting Started  ！！！

分享名称：go语言p2p项目练手,p2p golang
标题路径：http://myzitong.com/article/dsgdehc.html