精华内容
下载资源
问答
  • python和golang

    2012-07-05 15:18:30
    用了一段时间,因工作原因,停了一段时间,后面因为某个个人爱好的小原因,就尝试学一下python,并来解决一个小问题,发现python比想像中的容易入门,当然了,其资料齐全也是一个原因,相比golang那是齐全多了。...
    近来在学习这二种语言,我是先学的golang,用了一段时间,因工作原因,停了一段时间,后面因为某个个人爱好的小原因,就尝试学一下python,并来解决一个小问题,发现python比想像中的容易入门,当然了,其资料齐全也是一个原因,相比golang那是齐全多了。而且碰到啥问题,一搜一大把结果。。。相当给力

    学习python的过程中,因为我是先学golang,所以开始时“发现”好多语法与golang有点像,有点近亲的感觉,后面才想起来python比golang老得多。。。应该是golang语法借鉴了一些python的。。。

    在学完python写了一个小程序后,突然接到一个单子,需求是写一个蜘蛛程序,去其它网站抓取某个行业的信息,抓取回来要格式化,并通过一定规则后同步到正式数据中心,于是就用python去写了,发现蛮得心应手的,用python写这种需求真是应了那句老话:撞在枪口上了。。。

    现在程序快完了,平常有空开始继续看golang的资料,发现学完python后再看golang,真是又容易一些了。。。还是有一些东西很像的,意外的收获:)

    [u] [/u]
    展开全文
  • python和golang After a recent comparison of Python, Ruby, and Golang for a command-line application I decided to use the same pattern to compare building a simple web service. I have selected Flask ...

    python和golang

    python, ruby, and golang images

    After a recent comparison of Python, Ruby, and Golang for a command-line application I decided to use the same pattern to compare building a simple web service. I have selected Flask (Python), Sinatra (Ruby), and Martini (Golang) for this comparison. Yes, there are many other options for web application libraries in each language but I felt these three lend well to comparison.

    最近对命令行应用程序的Python,Ruby和Golang进行比较之后,我决定使用相同的模式来比较构建简单的Web服务。 为了进行比较,我选择了Flask (Python), Sinatra (Ruby)和Martini (Golang)。 是的,每种语言的Web应用程序库还有许多其他选择,但是我觉得这三个可以很好地进行比较。

    This is a guest blog post by Kyle Purdon, a software engineer from Boulder.

    这是一个客人博客文章由凯尔珀登 ,从博尔德一名软件工程师。

    图书馆概况 (Library Overviews)

    Here is a high-level comparison of the libraries by Stackshare.

    这是Stackshare对库的高层比较。

    烧瓶(Python) (Flask (Python))

    Flask is a micro-framework for Python based on Werkzeug, Jinja2 and good intentions.

    Flask是基于Werkzeug,Jinja2和良好意图的Python微型框架。

    For very simple applications, such as the one shown in this demo, Flask is a great choice. The basic Flask application is only 7 lines of code (LOC) in a single Python source file. The draw of Flask over other Python web libraries (such as Django or Pyramid) is that you can start small and build up to a more complex application as needed.

    对于非常简单的应用程序,例如本演示中显示的应用程序,Flask是一个不错的选择。 基本的Flask应用程序在一个Python源文件中只有7行代码(LOC)。 Flask与其他Python Web库(例如DjangoPyramid )相比,其优势在于您可以从小规模开始,并根据需要构建更复杂的应用程序。

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    

    锡纳特拉(Ruby) (Sinatra (Ruby))

    Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort.

    Sinatra是一种DSL,用于以最少的工作量在Ruby中快速创建Web应用程序。

    Just like Flask, Sinatra is great for simple applications. The basic Sinatra application is only 4 LOC in a single Ruby source file. Sinatra is used instead of libraries such as Ruby on Rails for the same reason as Flask – you can start small and expand the application as needed.

    就像Flask一样,Sinatra非常适合简单的应用程序。 基本的Sinatra应用程序在单个Ruby源文件中只有4个LOC。 出于与Flask相同的原因,使用Sinatra代替了诸如Ruby on Rails之类的库–您可以从小处着手,并根据需要扩展应用程序。

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    

    马提尼(Golang) (Martini (Golang))

    Martini is a powerful package for quickly writing modular web applications/services in Golang.

    Martini是一个功能强大的软件包,用于在Golang中快速编写模块化的Web应用程序/服务。

    Martini comes with a few more batteries included than both Sinatra and Flask but is still very lightweight to start with – only 9 LOC for the basic application. Martini has come under some criticism by the Golang community but still has one of the highest rated Github projects of any Golang web framework. The author of Martini responded directly to the criticism here. Some other frameworks include Revel, Gin, and even the built-in net/http library.

    马提尼酒比西纳特拉酒瓶和Flask酒瓶附带的电池要多一些,但一开始仍然非常轻巧-基本应用只有9 LOC。 Martini受到Golang社区的批评 ,但仍然是所有Golang Web框架中评分最高的Github项目之一。 马提尼酒的作者在这里直接回应了批评。 其他一些框架包括RevelGin甚至内置的net / http库。

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    

    With the basics out of the way, let’s build an app!

    借助基础知识,让我们构建一个应用程序!

    服务说明 (Service Description)

    The service created provides a very basic blog application. The following routes are constructed:

    创建的服务提供了一个非常基本的博客应用程序。 构建了以下路线:

    • GET /: Return the blog (using a template to render).
    • GET /json: Return the blog content in JSON format.
    • POST /new: Add a new post (title, summary, content) to the blog.
    • GET / :返回博客(使用模板进行渲染)。
    • GET /json :以JSON格式返回博客内容。
    • POST /new :向博客添加新帖子(标题,摘要,内容)。

    The external interface to the blog service is exactly the same for each language. For simplicity MongoDB will be used as the data store for this example as it is the simplest to set up and we don’t need to worry about schemas at all. In a normal “blog-like” application a relational database would likely be necessary.

    每种语言的博客服务外部接口完全相同。 为简单起见,MongoDB将用作此示例的数据存储,因为它是最简单的设置,我们完全不需要担心架构。 在正常的“类博客”应用程序中,可能需要关系数据库。

    添加帖子 (Add A Post)

    POST /new

    POST /new

    1
    1
    2
    2
    3
    3
    4
    4
    

    查看HTML (View The HTML)

    GET /

    GET /

    python, ruby, and golang images

    查看JSON (View The JSON)

    GET /json

    GET /json

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    

    应用结构 (Application Structure)

    Each application can be broken down into the following components:

    每个应用程序可以细分为以下组件:

    应用程式设定 (Application Setup)

    • Initialize an application
    • Run the application
    • 初始化应用程序
    • 运行应用程序

    请求 (Request)

    • Define routes on which a user can request data (GET)
    • Define routes on which a user can submit data (POST)
    • 定义用户可以请求数据(GET)的路由
    • 定义用户可以提交数据(POST)的路由

    响应 (Response)

    • Render JSON (GET /json)
    • Render a template (GET /)
    • 渲染JSON( GET /json
    • 渲染模板( GET /

    数据库 (Database)

    • Initialize a connection
    • Insert data
    • Retrieve data
    • 初始化连接
    • 插入资料
    • 检索数据

    应用部署 (Application Deployment)

    • Docker!
    • 码头工人!


    The rest of this article will compare each of these components for each library. The purpose is not to suggest that one of these libraries is better than the other – it is to provide a specific comparison between the three tools:

    本文的其余部分将比较每个库的每个组件。 目的并不是要建议这些库中的一个优于另一个,而是要提供这三个工具之间的特定比较:

    项目设置 (Project Setup)

    All of the projects are bootstrapped using docker and docker-compose. Before diving into how each application is bootstrapped under the hood we can just use docker to get each up and running in exactly the same way – docker-compose up

    使用dockerdocker-compose引导所有项目 在深入探讨如何在后台启动每个应用程序之前,我们可以使用docker以完全相同的方式启动和运行每个应用程序– docker-compose up

    Seriously, that’s it! Now for each application there is a Dockerfile and a docker-compose.yml file that specify what happens when you run the above command.

    说真的,就是这样! 现在,对于每个应用程序,都有一个DockerfileDockerfile docker-compose.yml文件,它们指定运行上述命令时发生的情况。

    Python(烧瓶)– Dockerfile (Python (flask) – Dockerfile)

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    This Dockerfile says that we are starting from a base image with Python 3.4 installed, adding our application to the /app directory and using pip to install our application requirements specified in requirements.txt.

    Dockerfile表示,我们从安装了Python 3.4的基础映像开始,将我们的应用程序添加到/app目录中,并使用pip来安装requirements.txt中指定的应用程序requirements.txt

    Ruby(sinatra) (Ruby (sinatra))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    This Dockerfile says that we are starting from a base image with Ruby 2.2 installed, adding our application to the /app directory and using bundler to install our application requirements specified in the Gemfile.

    这个Dockerfile表示,我们从安装了Ruby 2.2的基本映像开始,将我们的应用程序添加到/app目录,并使用bundler安装我们在Gemfile指定的应用程序需求。

    Golang(马提尼酒) (Golang (martini))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    

    This Dockerfile says that we are starting from a base image with Golang 1.3 installed, adding our application to the /go/src/github.com/kpurdon/go-blog directory and getting all of our necessary dependencies using the go get command.

    这个Dockerfile表示我们从安装Golang 1.3的基础映像开始,将我们的应用程序添加到/go/src/github.com/kpurdon/go-blog目录中,并使用go get命令获取所有必要的依赖项。

    初始化/运行应用程序 (Initialize/Run An Application)

    Python(烧瓶)– app.py (Python (Flask) – app.py)

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    
    1
    1
    

    Ruby(Sinatra)– app.rb (Ruby (Sinatra) – app.rb)

    1
    1
    2
    2
    
    1
    1
    

    Golang(马提尼酒)– app.go (Golang (Martini) – app.go)

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    13
    13
    14
    14
    
    1
    1
    

    定义路线(GET / POST) (Define A Route (GET/POST))

    Python(烧瓶) (Python (Flask))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    13
    13
    14
    14
    15
    15
    16
    16
    17
    17
    

    呈现JSON响应 (Render A JSON Response)

    Python(烧瓶) (Python (Flask))

    Flask provides a jsonify() method but since the service is using MongoDB the mongodb bson utility is used.

    Flask提供了jsonify()方法,但是由于该服务使用的是MongoDB,因此使用了mongodb bson实用程序。

    1
    1
    2
    2
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    2
    2
    3
    3
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    

    渲染HTML响应(模板化) (Render An HTML Response (Templating))

    Python(烧瓶) (Python (Flask))

    1
    1
    
    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    13
    13
    14
    14
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    
    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    13
    13
    14
    14
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    
    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    13
    13
    14
    14
    

    数据库连接 (Database Connection)

    All of the applications are using the mongodb driver specific to the language. The environment variable DB_PORT_27017_TCP_ADDR is the IP of a linked docker container (the database ip).

    所有应用程序都使用特定于该语言的mongodb驱动程序。 环境变量DB_PORT_27017_TCP_ADDR是链接的DB_PORT_27017_TCP_ADDR容器的IP(数据库ip)。

    Python(烧瓶) (Python (Flask))

    1
    1
    2
    2
    3
    3
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    2
    2
    3
    3
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    2
    2
    3
    3
    4
    4
    

    从POST插入数据 (Insert Data From a POST)

    Python(烧瓶) (Python (Flask))

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    

    检索数据 (Retrieve Data)

    Python(烧瓶) (Python (Flask))

    1
    1
    

    露比(Sinatra) (Ruby (Sinatra))

    1
    1
    

    Golang(马提尼酒) (Golang (Martini))

    1
    1
    2
    2
    

    应用程序部署(泊坞窗!) (Application Deployment (docker!))

    A great solution to deploying all of these applications is to use docker and docker-compose.

    部署所有这些应用程序的绝佳解决方案是使用dockerdocker-compose

    Python(烧瓶) (Python (Flask))

    Dockerfile

    Docker文件

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    docker-compose.yml

    docker-compose.yml

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    

    露比(Sinatra) (Ruby (Sinatra))

    Dockerfile

    Docker文件

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    docker-compose.yml

    docker-compose.yml

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    

    Golang(马提尼酒) (Golang (Martini))

    Dockerfile

    Docker文件

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    docker-compose.yml

    docker-compose.yml

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    8
    9
    9
    10
    10
    11
    11
    12
    12
    

    结论 (Conclusion)

    To conclude lets take a look at what I believe are a few categories where the presented libraries separate themselves from each other.

    最后,让我们看一下我认为所提供的库彼此分开的几个类别。

    简单 (Simplicity)

    While Flask is very lightweight and reads clearly, the Sinatra app is the simplest of the three at 23 LOC (compared to 46 for Flask and 42 for Martini). For these reasons Sinatra is the winner in this category. It should be noted however that Sinatra’s simplicity is due to more default “magic” – e.g., implicit work that happens behind the scenes. For new users this can often lead to confusion.

    虽然Flask非常轻巧,而且读起来很清晰,但Sinatra应用是这三个应用中最简单的,它的LOC为23(Flask为46,马丁尼为42)。 由于这些原因,Sinatra是该类别的赢家。 但是,应该注意的是Sinatra的简单性是由于更多默认的“魔术”所致–例如,幕后发生的隐性工作。 对于新用户,这通常会导致混乱。

    Here is a specific example of “magic” in Sinatra:

    这是Sinatra中“魔术”的一个具体示例:

    1
    1
    

    And the equivalent Flask code:

    和等效的Flask代码:

    1
    1
    2
    2
    3
    3
    4
    4
    5
    5
    6
    6
    

    For beginners to programming Flask and Sinatra are certainly simpler, but for an experienced programmer with time spent in other statically typed languages Martini does provide a fairly simplistic interface.

    对于初学者来说,Flask和Sinatra肯定更简单,但是对于有经验的程序员,他们花时间在其他静态类型的语言上,Martini确实提供了一个相当简单的界面。

    文献资料 (Documentation)

    The Flask documentation was the simplest to search and most approachable. While Sinatra and Martini are both well documented, the documentation itself was not as approachable. For this reason Flask is the winner in this category.

    Flask文档是最容易搜索且最易于访问的文档。 尽管Sinatra和Martini都有很好的文档,但是文档本身并不那么容易获得。 因此,Flask是该类别的赢家。

    社区 (Community)

    Flask is the winner hands down in this category. The Ruby community is more often than not dogmatic about Rails being the only good choice if you need anything more than a basic service (even though Padrino offers this on top of Sinatra). The Golang community is still nowhere near a consensus on one (or even a few) web frameworks, which is to be expected as the language itself is so young. Python however has embraced a number of approaches to web development including Django for out-of-the-box full-featured web applications and Flask, Bottle, CheryPy, and Tornado for a micro-framework approach.

    Flask是此类别中的获胜者。 如果您除了基本服务之外还需要其他任何东西(即使Padrino在Sinatra之上提供了此功能),Ruby社区通常会坚信Rails是唯一的好选择。 Golang社区在一个(或什至几个)Web框架上仍未达成共识,这是因为它本身还很年轻。 但是,Python接受了许多Web开发方法,其中包括Django用于开箱即用的全功能Web应用程序,以及Flask,Bottle,CheryPy和Tornado用于微框架方法。

    最终决定 (Final Determination)

    Note that the point of this article was not to promote a single tool, rather to provide an unbiased comparison of Flask, Sinatra, and Martini. With that said, I would select Flask (Python) or Sinatra (Ruby). If you are coming from a language like C or Java perhaps the statically-typed nature of Golang may appeal to you. If you are a beginner, Flask might be the best choice as it is very easy to get up and running and there is very little default “magic”. My recommendation is that you be flexible in your decisions when selecting a library for your project.

    请注意,本文的目的不是要推广单个工具,而是要对Flask,Sinatra和Martini进行公正的比较。 话虽如此,我会选择Flask(Python)或Sinatra(Ruby)。 如果您来自C或Java之类的语言,那么Golang的静态类型本质可能会吸引您。 如果您是初学者,则Flask可能是最好的选择,因为它很容易启动和运行,并且几乎没有默认的“魔术”。 我的建议是,在为项目选择库时,您可以灵活地做出决定。



    翻译自: https://www.pybloggers.com/2015/07/python-ruby-and-golang-a-web-service-application-comparison/

    python和golang

    展开全文
  • LeetCode:Python和Golang中LeetCode问题的解决方案
  • CTF_Bot_Discord 使用Python和Golang的CTF Bot
  • python和golang 精通一种编程语言需要花费很多时间,而学习一种新语言则不需要。 相信我,在编码方面没有人是完美的。 作为软件工程师,至少应该熟悉至少4–5种不同的语言,或者至少应该知道如何在短时间内学习一种...

    python和golang

    精通一种编程语言需要花费很多时间,而学习一种新语言则不需要。 相信我,在编码方面没有人是完美的。 作为软件工程师,至少应该熟悉至少4–5种不同的语言,或者至少应该知道如何在短时间内学习一种新的语言。

    好吧,为了让大家知道,我最近从python和javascript切换到了Golang。 因此,本文只是试图指导开发人员如何从一种语言平稳切换到另一种语言。

    注意:[这篇文章供那些有任何编程语言经验的人,并且希望以快速简便的方式(只需查看Go代码!)学习实用的Go编程概念。

    第1步:为什么存在该语言及其优势

    Golang是软件行业中非常强大且流行的编程语言。 Golang是可表达的,静态类型的,编译的语言,快速可靠,并且在许多方面都比JavaScript和Python好很多。 它正在慢慢获得发展势头,并成为许多开发人员开发软件,现代Web应用程序和应用程序后端的首选语言。

    它用于制作涉及并发的大规模,可靠的应用程序。 使用go的唯一缺点是,他们在互联网上用于学习或完成/完成任务以及开发软件的资源很少。

    第2步:设置,安装和运行“ Hello world”程序。

    为了学习一种新的语言,需要下载一种语言(二进制/ SDK)本身。 因此,只需点击以下链接即可下载golang。

    链接: https : //golang.org/dl/ 设置工作区并在文本编辑器中创建一个基本的go文件,复制并粘贴以下代码并运行该文件。

    通过以下方式直接运行文件: go run <filename.go>

    或通过以下方法编译为可执行文件: go build <filename.go>然后通过./ <executable_file>将其作为可执行文件运行

    package main
    import "fmt"
    func main () { fmt.Println( "Hello World !" ) }

    如果代码输出Hello World! 你已准备好出发 :)

    值得注意的几点:

    1. 我们需要执行的每个文件都必须在顶部有一个主包。
    2. 接下来是用于读取和写入的导入语句。
    3. 接下来是程序启动的主要功能。

    第3步:编程,语法和编码模式的基础。

    在编程方面,基本原理保持不变。 无论我们使用哪种语言,都将始终有数据类型,如果还有其他语句,循环,switch语句等……。 让我们看一下Golang的基础知识。

    在这里,我将讨论:

    • 资料类型
    • 控制声明
    • 函数(定义和声明)
    • 循环
    • 指针
    • 错误处理
    • 包(创建和导入)
    • 创建数据结构

    让我们一一看一下。

    资料类型

    像所有其他语言一样,Golang还支持许多类似的原始数据类型,例如int,float64,字符串,bool等……让我们看一下语法:

    语法1: <变量> <变量名称> <数据类型> = <值>

    语法2: <变量名称>:= <值>

    var x int 
    fmt.Println(x) // output 0 or 
    x := 5 
    fmt.Println(x) // output 5
    name := "Karan"
    fmt.Println(name) // output karan
    var array [] int { 1 , 2 , 3 , 4 , 5 , 6 }
    fmt.Println(array) // output [1,2,3,4,5]
    fmt.Println(array[ 2 ]) // output 3 
    append (array, 7 )
    fmt.Println(array) // output [1,2,3,4,5,7]

    控制语句,函数,导入包

    让我们借助示例来了解Golang中的控制流语句(如果还有,开关,循环),函数声明和函数调用的基础知识。

    函数的语法如下所示。

    func <函数名称>(param_name param_type)<return_type> {代码}

    获取软件包的语法 :go install <package>或go get <package>

    // 1st line is always the package 
    package main 
    // Importing basic packages in golang 
    import (
     "fmt"
    )
    func main () {
      add_of_number := sum( 5 , 10 )
      square_of_number := square( 5 )
      factorial_of_number := factorial( 5 )
      fmt.Println(add_of_number,square_of_number,factorial_of_number)
      print_n_numbers( 3 )
    }
    func sum (x int , y int ) int { return x + y }
    func square (x int ) int { return x*x }
    func factorial (x int ) int {
     if x < 1 { return 1 }
      return x*factorial(x -1 )
    }
    func print_n_numbers (x int ) {
      for i:= 1 ; i<x+ 1 ; i++ { fmt.Println(i) }
    }

    //输出//

    15 25 120

    1 2 3

    错误处理,指针和结构类型

    有趣的事实: Go没有异常,因此我们必须手动检查错误,并且函数可以返回多个值。 Golang结构用于将多种类型的数据组合为一种。 它也可以用于创建新的数据结构。 让我们来看一个例子。

    // 1st line is always the package 
    package main
    // Importing basic packages in golang 
    import (
      "fmt"
      "errors"
      "math"
    )
    // struct type 
    type person struct {
    name string
    age int
    height float64 }
    func main () {
    // Pointers .. 
    number := 10
    fmt.Println(&number) 
    fmt.Println(number)
    increment_number(&number)
    fmt.Println(number)
    // Error Handling .. 
    sqrt_result , err := sqrt( 16 )
    if err != nil { fmt.Println(err) } else { fmt.Println(sqrt_result) }
    // accessing struct in golang .. 
    p := person{name: "karan" ,age: 25 ,height: 5.10 }
    fmt.Println(p)
    fmt.Println(p.name)
    }
    func sqrt (x float64 ) ( float64 , error) {
    if x< 0 { return 0 , errors.New( "Negative number is not allowed !" ) }   else {  return math.Sqrt(x), nil } }
    func increment_number (x * int ) { *x++ }

    //输出//

    0Xc82000a2f0 10 11 4 {karan 25 5.1} karan

    就是这个帖子。 我希望你喜欢它。 直到那时,继续编码并继续学习。

    翻译自: https://hackernoon.com/from-javascript-and-python-to-golang-3-steps-to-learn-go-programming-pus32y0

    python和golang

    展开全文
  • 文章目录python和golang对比系列(二)--> 参数传递方式一、golang中的参数传递1.1 如何选择==T== 和 ==*T==1.2 发生副本创建的情形1.3 不同类型的副本创建二、python中的参数传递2.1 python的变量内存模型2.2 ...

    python和golang对比系列(二)–> 参数传递方式

    在编程语言深入讨论中,经常被大家提起也是争论最多的讨论之一就是按值(by value)还是按引用传递(by reference, by pointer)

    一、golang中的参数传递

    在golang中,严格意义上来说,只有一种传递方式,那就是按值传递,即在函数内部修改传入参数的值时函数外部传入值的拷贝,传入时发生了复制行为。无论是变量本身或者是将变量当做指针被传递,都是创建一个副本(值的副本或者是一个指向该变量的指针的副本),T类型的变量和*T类型的变量在当做函数或者方法的参数时会传递它的副本。
    如果要想实现和使用按引用传递,则需要将传入的参数设置为指针类型;可以看起来达到按引用传递的效果,实际还是按值传递的。

    传递方式 数据类型
    值传递 int、float、bool、string、数组、结构体
    引用传递 指针、切片、map、管道、接口

    1.1 如何选择T*T

    在定义函数和方法的时候,作为一位资深的Go开发人员,一定会对函数的参数和返回值定义成T和T深思熟虑,有些情况下可能还会有些苦恼。
    那么什么时候才应该把参数定义成类型T,什么情况下定义成类型
    T呢。

    一般的判断标准是看副本创建的成本和需求。

    1. 不想变量被修改。 如果你不想变量被函数和方法所修改,那么选择类型T。相反,如果想修改原始的变量,则选择*T
    2. 如果变量是一个大的struct或者数组,则副本的创建相对会影响性能,这个时候考虑使用*T,只创建新的指针,这个区别是巨大的
    3. (不针对函数参数,只针对本地变量)对于函数作用域内的参数,如果定义成T,Go编译器尽量将对象分配到栈上,而*T很可能会分配到对象上,这对垃圾回收会有影响

    1.2 发生副本创建的情形

    1. 对变量的赋值
    2. slice,map和数组在初始化和按索引设置时
    3. for-range循环
    4. 往channel中send对象时
    5. 函数参数和返回值
    6. 方法Receiver

    1.3 不同类型的副本创建

    1. bool,数值和指针
      对象很小,创建副本的开销可以忽略
    2. 数组
      对于大的数组的参数传递和赋值,一定要慎重
    3. map、slice 和 channel
      指向指针类型,指向一个底层的数据结构
    4. 字符串
      大部分情况下你不需要定义成*string。唯一的例外你需要 nil值的时候。"“和nil表示的意义是不一样的,”"表示字段存在,只不过字符串是空值,而nil表示字段不存在。
    5. 函数
      指针类型

    二、python中的参数传递

    python的函数调用到底是传值还是传引用?

    2.1 python的变量内存模型

    对于python而言,一切皆对象,python为每个对象分配内存空间,但是并非为每个变量分配内存空间,因为在python中,变量更像是一个标签,就像在现实生活中,一个人可以有多种身份标签,比如:XX的父亲,XX的儿子,XX的工程师,X地志愿者等等,但对应的实体都是同一个人,只占同一份资源。

    2.2 python的间接引用机制

    类型 对象
    可变类型 列表,字典
    不可变类型 int、float、字符串、元组

    2.3 python传参时可变类型和不可变类型的区别

    1. 在参数传递时,实参将标签复制给了形参,这个时候形参和实参都是指向同一个对象。
    2. 在函数内修改形参:
      2.1 对于不可变类型变量而言:因为不可变类型变量特性,修改变量需要新创建一个对象,形参的标签转而指向新对象,而实参没有变
      2.2 对于可变类型变量而言,因为可变类型变量特性,直接在原对象上修改,因为此时形参和实参都是指向同一个对象,所以,实参指向的对象自然就被修改了。

    这种机制存在于整个python环境中,而不仅仅是参数传递中。

    展开全文
  • 文章目录python和golang对比系列(一)--流程控制循环一、 条件循环二、for的键值遍历 python和golang对比系列(一)–流程控制循环 一、 条件循环 golang的条件循环表达式 // 循环表达式 for 初始语句; 条件...
  • 文章目录python和golang对比系列(三)--> 函数闭包一、golang中的闭包二、python中的闭包 python和golang对比系列(三)–> 函数闭包 闭包是引用了自由变量的函数。简单来说:闭包=函数+引用变量 闭包在某些...
  • 功能示例 用Node,Python和GoLang编写的Planetr.io分布式代码示例
  • python和golangThis is a guest blog post by Kyle Purdon​, a software engineer in Boulder, CO. Kyle is a Python first developer with experience in Ruby, Golang, and many more languages. This post was ...
  • 崇高–受Python和Golang启发,用于C ++ 11的协同程序,堆栈跟踪和智能I / O。 1.简介 Lofty是一个C ++ 11框架,具有: 多种平台兼容性:Linux和Windows,部分与macOS和FreeBSD兼容(请参阅§5 .兼容性); 建立在C...
  • python和golang的对比

    2020-03-14 12:35:01
    1.Python ①解释型语言  程序不需要在运行前编译,在运行程序的时候才翻译,专门的解释器负责在每个语句执行的时候解释程序代码。这样解释型语言每执行一次就要翻译一次,运行效率相对较低。 ②动态数据类型   ...
  • def bsearch(find, arr, low, high): while low <= high: mid = (low + high) >> 1 if arr[mid] == find: return mid, True elif arr[mid] > find...
  • 首先在~下新建目录.vim配置文件.vimrc,.vimrc内容如下: syntax on set nocompatible filetype off set rtp+=~/.vim/bundle/Vundle.vimset tags=~/tags call vundle#begin() Plugin 'gmarik/Vundle.vim'...
  • 递归顾名思义就是自己调用自己,当初自己学习python的时候写过一些小案例,觉得挺有意思,今天拿出来再写一遍! 注:本次的递归案例都是一些经典的案例 个人觉得递归只要找准三个要素,理清逻辑,就能写出一个完整...
  • 代码的出现 来自Python,GoJava的Code Advent网站的任务 测验

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,431
精华内容 572
关键字:

python和golang

python 订阅