blocks|key|112193|text|如果你从来没有做过任何CGI编程之前，我认为这将是值得做一个项目-也许只是一个示例播放网站只是为你自己-使用DIY方法。与使用框架相比，您将更多地了解所有不同部分是如何工作的。这将有助于您设计和调试，等等，您的所有未来的web应用程序，无论您编写它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|112194|就我个人而言，我现在使用姜戈。真正的好处是非常快速的应用程序部署。对象关系映射使事物移动得更快，模板库是joy所使用的。另外，管理界面为所有对象提供了基本的CRUD屏幕，因此您不需要编写任何“无聊”的东西。|offset|length|112195|使用基于ORM的解决方案的缺点是，如果您确实想手工处理一些SQL，比如出于性能原因，那么它要比其他方法困难得多，尽管仍然很有可能。|112196|entityMap|0|LINK|mutability|MUTABLE|url|http://www.djangoproject.com/^0|0|C|2|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

If you've never done any CGI programming before I think it would be worth doing one project - perhaps just a sample play site just for yourself - using the DIY approach. You'll learn a lot more about how all the various parts work than you would by using a framework. This will help in you design and debug and so on all your future web applications however you write them.

Personally I now use <a href="http://www.djangoproject.com/" rel="nofollow noreferrer">Django</a>. The real benefit is very fast application deployment. The object relational mapping gets things moving fast and the template library is a joy to use. Also the admin interface gives you basic CRUD screens for all your objects so you don't need to write any of the "boring" stuff.

The downside of using an ORM based solution is that if you do want to handcraft some SQL, say for performance reasons, it much harder than it would have been otherwise, although still very possible.

blocks|key|112252|text|如果您决定使用一个基于WSGI的框架(例如TurboGears)，我建议您阅读Ian的优秀文章另一个自己动手的框架。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|112253|在本文中，他从零开始构建了一个简单的web应用程序框架。|112254|另外，请看凯文·丹戈尔的视频使用WSGI创建web框架。Dangoor是TurboGears项目的创始人。|112255|entityMap|0|LINK|mutability|MUTABLE|url|http://www.turbogears.org/2.0|1|http://pythonpaste.org/webob/do-it-yourself.html|2|http://www.vimeo.com/3258566^0|L|A|0|1B|A|1|0|0|E|D|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]|$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

If you decide to go with a framework that is WSGI-based (for instance <a href="http://www.turbogears.org/2.0" rel="nofollow noreferrer">TurboGears</a>), I would recommend you go through the excellent article <a href="http://pythonpaste.org/webob/do-it-yourself.html" rel="nofollow noreferrer">Another Do-It-Yourself Framework</a> by Ian Bicking.

In the article, he builds a simple web application framework from scratch.

Also, check out the video <a href="http://www.vimeo.com/3258566" rel="nofollow noreferrer">Creating a web framework with WSGI</a> by Kevin Dangoor. Dangoor is the founder of the TurboGears project.

blocks|key|823036|text|CGI对于低流量的网站来说是很棒的，但是对于其他的网站，它也有一些性能问题。这是因为每次请求传入时，服务器都会在自己的进程中启动CGI应用程序。这有两个原因:+1)启动和停止进程需要时间；2)不能在内存中缓存任何东西。您可以使用FastCGI，但我认为，如果要使用这种方式，最好只编写一个直接的WSGI应用程序(+WSGI的工作方式与CGI并没有太大的不同)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|823037|除此之外，您的选择在很大程度上取决于您希望框架做多少。你可以跟着一个全唱的，所有的舞蹈框架，像姜戈或塔。或者您可以使用混合匹配方法(使用CherryPy作为HTTP，SQLAlchemy用于数据库内容，粘贴用于部署，等等)。我还应该指出，大多数框架也允许您为其他框架切换不同的组件，因此这两种方法不一定是相互排斥的。|823038|就我个人而言，我不喜欢对我有太多魔力的框架，更喜欢混合和匹配技术，但我被告知我也完全疯了。:)|823039|你有多少网络编程经验？如果你是初学者，我建议你和Django一起去。如果你更有经验的话，我建议你在找到合适的方法和技巧之前，先尝试一下不同的方法和技巧。|823040|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-0333/^0|43|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

CGI is great for low-traffic websites, but it has some performance problems for anything else. This is because every time a request comes in, the server starts the CGI application in its own process. This is bad for two reasons: 1) Starting and stopping a process can take time and 2) you can't cache anything in memory. You can go with FastCGI, but I would argue that you'd be better off just writing a straight <a href="http://www.python.org/dev/peps/pep-0333/" rel="noreferrer">WSGI</a> app if you're going to go that route (the way WSGI works really isn't a whole heck of a lot different from CGI).

Other than that, your choices are for the most part how much you want the framework to do. You can go with an all singing, all dancing framework like Django or Pylons. Or you can go with a mix-and-match approach (use something like CherryPy for the HTTP stuff, SQLAlchemy for the database stuff, paste for deployment, etc). I should also point out that most frameworks will also let you switch different components out for others, so these two approaches aren't necessarily mutually exclusive.

Personally, I dislike frameworks that do too much magic for me and prefer the mix-and-match technique, but I've been told that I'm also completely insane. :)

How much web programming experience do you have? If you're a beginner, I say go with Django. If you're more experienced, I say to play around with the different approaches and techniques until you find the right one.

blocks|key|1111625|text|最简单的web程序是CGI脚本，它基本上只是一个程序，其标准输出被重定向到提出请求的web浏览器。在这种方法中，每个页面都有自己的可执行文件，必须在每个请求上加载和解析该文件。这使得建立和运行一些东西变得非常简单，但是在性能和组织方面都很糟糕。因此，当我需要一个非常动态的页面，它不会发展成一个更大的系统时，我会使用一个CGI脚本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1111626|这之后的一个步骤是将Python代码嵌入到HTML代码中，比如使用PSP。我认为现在没有多少人使用它，因为现代的模板系统已经使它变得非常过时。我与PSP一起工作了一段时间，发现它与CGI脚本(每个页面都有自己的文件)有着基本相同的组织限制，并且尝试将空白无知的HTML与对空格敏感的Python混合在一起，还带来了一些与空白相关的烦恼。|1111627|下一步是非常简单的web框架，比如我也使用过的web.py。与CGI脚本一样，启动和运行一些东西非常简单，您不需要任何复杂的配置或自动生成的代码。您自己的代码将非常容易理解，因此您可以看到正在发生的事情。然而，它并不像其他web框架那样丰富；上次我使用它时，没有会话跟踪，所以我不得不使用自己的。它还有“太多的魔法行为”引用Guido+("upvars()，bah")。|1111628|最后，您有功能丰富的web框架，如Django。这些都需要一些工作才能让Hello程序简单地工作，但是每个主要的程序都有一个很棒的、写得很好的教程(特别是Django)来指导您完成它。我强烈建议在任何实际项目中使用这些web框架之一，因为它的方便性、特性和文档等等。|1111629|最终你得决定你喜欢什么。例如，框架都使用模板语言(特殊代码/标记)来生成HTML文件。其中一些模板，如Cheetah模板，允许您编写任意Python代码，以便您可以在模板中执行任何操作。其他模板，如Django模板，则限制性更强，迫使您将表示代码与程序逻辑分开。这都是你个人所喜欢的。|1111630|另一个例子是URL处理；一些框架，如Django，让您通过正则表达式在应用程序中定义URL。其他如CherryPy等则通过函数名自动将您的函数映射到urls。同样，这也是个人偏好。|1111631|我个人使用CherryPy作为web服务器(表单参数、会话处理、url映射等)和Django+(对象-关系映射和模板)的混合web框架。我的建议是从一个高层次的网络框架开始，通过它的教程，然后开始一个小的个人项目。我已经用我提到的所有技术做了这件事，这是非常有益的。最终，你会感觉到你喜欢什么，并在这个过程中成为一个更好的网络程序员(和一个更好的程序员)。|1111632|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

The simplest web program is a CGI script, which is basically just a program whose standard output is redirected to the web browser making the request. In this approach, every page has its own executable file, which must be loaded and parsed on every request. This makes it really simple to get something up and running, but scales badly both in terms of performance and organization. So when I need a very dynamic page very quickly that won't grow into a larger system, I use a CGI script.

One step up from this is embedding your Python code in your HTML code, such as with PSP. I don't think many people use this nowadays, since modern template systems have made this pretty obsolete. I worked with PSP for awhile and found that it had basically the same organizational limits as CGI scripts (every page has its own file) plus some whitespace-related annoyances from trying to mix whitespace-ignorant HTML with whitespace-sensitive Python.

The next step up is very simple web frameworks such as web.py, which I've also used. Like CGI scripts, it's very simple to get something up and running, and you don't need any complex configuration or automatically generated code. Your own code will be pretty simple to understand, so you can see what's happening. However, it's not as feature-rich as other web frameworks; last time I used it, there was no session tracking, so I had to roll my own. It also has "too much magic behavior" to quote Guido ("upvars(), bah").

Finally, you have feature-rich web frameworks such as Django. These will require a bit of work to get simple Hello World programs working, but every major one has a great, well-written tutorial (especially Django) to walk you through it. I highly recommend using one of these web frameworks for any real project because of the convenience and features and documentation, etc.

Ultimately you'll have to decide what you prefer. For example, frameworks all use template languages (special code/tags) to generate HTML files. Some of them such as Cheetah templates let you write arbitrary Python code so that you can do anything in a template. Others such as Django templates are more restrictive and force you to separate your presentation code from your program logic. It's all about what you personally prefer.

Another example is URL handling; some frameworks such as Django have you define the URLs in your application through regular expressions. Others such as CherryPy automatically map your functions to urls by your function names. Again, this is a personal preference.

I personally use a mix of web frameworks by using CherryPy for my web server stuff (form parameters, session handling, url mapping, etc) and Django for my object-relational mapping and templates. My recommendation is to start with a high level web framework, work your way through its tutorial, then start on a small personal project. I've done this with all of the technologies I've mentioned and it's been really beneficial. Eventually you'll get a feel for what you prefer and become a better web programmer (and a better programmer in general) in the process.

blocks|key|1111680|text|好的，rails实际上很不错，但是里面有一点魔法(从Ruby世界我更喜欢merb而不是rails)。我个人用的是塔架，我很高兴。我想说(与django相比)，与django相比，幽门允许您更容易地交换ints内部部件。缺点是你必须自己写更多的东西(比如基本的CRUD)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1111681|使用框架的优点：|1111682|快速完成任务(我的意思是，一旦你了解了框架，你就可以快速地点亮)|ordered-list-item|1111683|每件事都符合标准(在滚动自己的标准时，这可能不是那么容易实现)|1111684|无需阅读大量文章和文档，就可以更容易地获得一些有用的东西(很多教程)。|1111685|缺点：|1111686|你学得少|1111687|更难更换零件(在塔架上没那么大问题，用django就更难了)|1111688|更难调整一些低级的东西(如上面提到的SQL)|1111689|这样你就可以设计出它们的优点:-)既然你得到了所有的代码，就有可能对其进行调整，以适应即使是最复杂的情况(据推测，幽门现在已经在Google应用引擎上工作了.)。|1111690|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|13|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|14|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|15|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|V|$]]

OK, rails is actually pretty good, but there is just a little bit too much magic going on in there (from the Ruby world I would much prefer merb to rails). I personally use Pylons, and am pretty darn happy. I'd say (compared to django), that pylons allows you to interchange ints internal parts easier than django does. The downside is that you will have to write more stuff all by youself (like the basic CRUD). 

Pros of using a framework:

<ol>
<li>get stuff done quickly (and I mean lighning fast once you know the framework)</li>
<li>everything is compying to standards (which is probably not that easy to achieve when rolling your own)</li>
<li>easier to get something working (lots of tutorials) without reading gazillion articles and docs</li>
</ol>

Cons:

<ol>
<li>you learn less</li>
<li>harder to replace parts (not that much of an issue in pylons, more so with django)</li>
<li>harder to tweak some low-level stuff (like the above mentioned SQLs)</li>
</ol>

From that you can probably devise what they are good for :-) Since you get all the code it is possible to tweak it to fit even the most bizzare situations (pylons supposedly work on the Google app engine now...).

blocks|key|112403|text|如果你想变大，选择Django，你就准备好了。但是，如果您只想学习，使用已经提到的WebOb来滚动您自己的框架--这真的很有趣，我相信您会学到更多(另外，您还可以使用您喜欢的组件:模板系统、url调度器、数据库层、会话等等)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|112404|在过去的两年中，我使用Django创建了几个大型站点，我只能说，Django将在20%25的时间内满足您80%25的需求。剩下的20%25的工作将占用80%25的时间，无论您使用哪个框架。|112405|entityMap|0|LINK|mutability|MUTABLE|url|http://pythonpaste.org/webob/^0|15|5|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

If you want to go big, choose Django and you are set. But if you want just to learn, roll your own framework using already mentioned <a href="http://pythonpaste.org/webob/" rel="nofollow noreferrer">WebOb</a> - this can be really fun and I am sure you'll learn much more (plus you can use components you like: template system, url dispatcher, database layer, sessions, et caetera).

In last 2 years I built few large sites using Django and all I can say, Django will fill 80% of your needs in 20% of time. Remaining 20% of work will take 80% of the time, no matter which framework you'd use.

blocks|key|112482|text|作为一项学习练习，做一次艰难的事情总是值得的。一旦您了解了它的工作原理，就选择一个适合您的应用程序的框架，并使用它。一旦你了解了角速度，你就不需要重新发明轮子了。:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|112483|在进入框架之前，确保您对框架背后的编程语言有了相当强的理解也是值得的--尝试同时学习Django和Python+(或者Ruby和Rails，或者X和Y)会导致更多的混乱。先用语言编写一些代码，然后添加框架。|112484|我们学习发展，不是通过使用工具，而是通过解决问题。跑进几堵墙，爬过去，找到一些更高的墙！|112485|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's always worth doing something the hard way - once - as a learning exercise. Once you understand how it works, pick a framework that suits your application, and use that. You don't need to reinvent the wheel once you understand angular velocity. :-)

It's also worth making sure that you have a fairly robust understanding of the programming language behind the framework before you jump in -- trying to learn both Django and Python at the same time (or Ruby and Rails, or X and Y), can lead to even more confusion. Write some code in the language first, then add the framework.

We learn to develop, not by using tools, but by solving problems. Run into a few walls, climb over, and find some higher walls!

blocks|key|819132|text|如果您正在使用Python，则不应该从CGI开始，而是从WSGI开始(您可以使用wsgiref.handlers.CGIHandler作为CGI脚本运行您的WSGI脚本。其结果基本上与CGI一样低(在教育意义上可能有用，但也会有些烦人)，但不必编写完全过时的接口(并将应用程序绑定到单个进程模型)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|819133|如果您想要一个不那么烦人但类似于低级别的接口，那么使用WebOb就可以提供这个功能。您将实现所有的逻辑，并且会有一些您不了解的黑暗角落，但是您将不必花费时间来研究如何解析HTTP日期(它们很奇怪！)或者解析邮局的身体。我以这种方式编写应用程序(没有任何其他框架)，这是完全可行的。作为初学者，如果您对框架的功能感兴趣，我会建议您这样做，因为这是不可避免的，您将编写自己的迷你框架。OTOH，一个真正的框架可能会教给您应用程序设计和结构的良好实践。要成为一个真正优秀的web程序员，我相信你需要认真地尝试；你应该理解一个框架所做的一切，而不是害怕它的内部，但你也应该花时间在一个别人设计的深思熟虑的环境中(即一个现有的框架)，并了解这种结构如何帮助你。|819134|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/wsgiref.html#wsgiref.handlers.CGIHandler|1|http://pythonpaste.org/webob/^0|14|R|0|0|R|5|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

If you are using Python you should not start with CGI, instead start with WSGI (and you can use <a href="http://docs.python.org/library/wsgiref.html#wsgiref.handlers.CGIHandler" rel="nofollow noreferrer">wsgiref.handlers.CGIHandler</a> to run your WSGI script as a CGI script. The result is something that is basically as low-level as CGI (which might be useful in an educational sense, but will also be somewhat annoying), but without having to write to an entirely outdated interface (and binding your application to a single process model).

If you want a less annoying, but similarly low-level interface, using <a href="http://pythonpaste.org/webob/" rel="nofollow noreferrer">WebOb</a> would provide that. You would be implementing all the logic, and there will be few dark corners that you won't understand, but you won't have to spend time figuring out how to parse HTTP dates (they are weird!) or parse POST bodies. I write applications this way (without any other framework) and it is entirely workable. As a beginner, I'd advise this if you were interested in understanding what frameworks do, because it is inevitable you will be writing your own mini framework. OTOH, a real framework will probably teach you good practices of application design and structure. To be a really good web programmer, I believe you need to try both seriously; you should understand everything a framework does and not be afraid of its internals, but you should also spend time in a thoughtful environment someone else designed (i.e., an existing framework) and understand how that structure helps you.

blocks|key|823152|text|对于较小的项目，滚动自己是相当容易的。特别是因为您可以简单地导入像根石这样的模板引擎，并且非常快速和容易地实现。有时候用螺丝刀比去找电钻要快。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|823153|完整的框架提供了更多的功能，但在利用这种能力之前，必须先安装和安装。对于较大的项目，这是一个微不足道的关注，但对于较小的项目，这可能会占用您的大部分时间-特别是如果框架不熟悉。|823154|entityMap|0|LINK|mutability|MUTABLE|url|http://genshi.edgewall.org/^0|X|2|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

For smaller projects, rolling your own is fairly easy. Especially as you can simply import a templating engine like <a href="http://genshi.edgewall.org/" rel="nofollow noreferrer">Genshi</a> and get alot happening quite quickly and easily. Sometimes it's just quicker to use a screwdriver than to go looking for the power drill.

Full blown frameworks provide alot more power, but do have to be installed and setup first before you can leverage that power. For larger projects, this is a negligible concern, but for smaller projects this might wind up taking most of your time - especially if the framework is unfamiliar.

I'd like to do some server-side scripting using Python. But I'm kind of lost with the number of ways to do that.
It starts with the do-it-yourself CGI approach and it seems to end with some pretty robust frameworks that would basically do all the job themselves. And a huge lot of stuff in between, like <a href="http://webpy.org/" rel="nofollow noreferrer">web.py</a>, <a href="http://pyroxide.org/" rel="nofollow noreferrer">Pyroxide</a> and <a href="http://wiki.python.org/moin/Django" rel="nofollow noreferrer">Django</a>.
<ul>
<li>What are the pros and cons of the frameworks or approaches that you've worked on?</li>
<li>What trade-offs are there?</li>
<li>For what kind of projects they do well and for what they don't?</li>
</ul>
Edit: I haven't got much experience with web programing yet.
I would like to avoid the basic and tedious things like parsing the URL for parameters, etc. 
On the other hand, while the video of <a href="http://www.rubyonrails.org/screencasts" rel="nofollow noreferrer">blog created in 15 minutes</a> with <a href="http://www.rubyonrails.org/" rel="nofollow noreferrer">Ruby on Rails</a> left me impressed, I realized that there were hundreds of things hidden from me - which is cool if you need to write a working <code>webapp</code> in no time, but not that great for really understanding the magic - and that's what I seek now.

Pros and Cons of different approaches to web programming in Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想使用Python编写一些服务器端脚本。但我对这么多的方法感到迷茫。它从自己动手的CGI方法开始，最后似乎是一些非常健壮的框架，基本上可以自己完成所有的工作。中间还有很多东西，比如，和。您所研究的框架或方法的、利弊、和缺点是什么？有什么取舍？对于，什么样的项目做得好，哪些项目没有？编辑:我还没有多少网络编程的经验。我...

问Python中不同web编程方法的优缺点
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中不同web编程方法的优缺点EN