[c0mrade]

So.. Python seems to be getting some attention lately, and as I don't actually know anyone who uses it - i'd like to know, whats with python?

Specifically, I'm mainly a PHP developer so I'd love to here from someone who uses both.

My first impressions of the language were not exactly great.. I'd not a fan of the syntax, it reminds me of vb6.. I'm more of a c style fan.

Anyway, enough rambling. Convince me Python evangelists, why should I learn Python?

[k0b13r]

Hi ! I use both PHP and Python (hm, I'm still learning Python) ...
1) No one uses Python ? Here's the link
http://wiki.python.o...ionsUsingPython
Google, NASA ... need to say more ?
2) C style syntax ... I'm fan of this too, but Python syntax is much more friendly and complex Curly brackets - nooo xD
3) Why should you ? It's very useful, good designed language
And it's fun to use it

This post has been edited by k0b13r: 09 April 2008 - 04:40 AM

[MitkOK]

Python is absolutelly brilliant scripting language.

While talking about Google using it -> http://code.google.c...eappengine.html

Google AppEngine :

- no servers to maintain: You just upload your application, and it's ready to serve your users.
- free domain name on the appspot.com domain
- free account can use up to 500MB of persistent storage and enough CPU and bandwidth for about 5 million page views a month
- automatic scaling and load balancing
- APIs for authenticating users and sending email using Google Accounts
- a fully featured local development environment that simulates Google App Engine on your computer
- scalability and uptime guaranteed by Google!

Python + Django = Amazing web applications

This post has been edited by MitkOK: 09 April 2008 - 07:36 AM

[c0mrade]

Sorry when I said I dont know anyone who uses it, I was talking about me not personally knowing a python programmer.

What got me interested in it is the fact that so many organizations seem to love it - google adores it, so does ubuntu for us linux fans

What does it do well? What does it do not so well?

[Nykc]

Thats a good question c0mrade, I started teaching myself Python about two months ago then put in on hold. There are lots of resources out there for python however I could never find anything on how to implement it in your web apps.

Personally I love the language and it has great potential, but I don't want to write console apps with it, I have a need to use it and can't figure out how to implement on my server to function with my web pages.

[c0mrade]

Oh yeah I have been following AppEngine. Curious as to how it will turn out, it seems like it could just be a glorified shared hosting setup - but then again it is google so I'll be watching it closely.

Btw AppEngine will support other languages... Python is just the first. (maybe because the python creator works for google?)

I see it's object oriented which is nice. Thats something I really hate about php. But ahhh I HATE whitespace rules!! Lol i'm going to have to learn it anyway..

[baavgai]

c0mrade, on 9 Apr, 2008 - 10:47 AM, said:

But ahhh I HATE whitespace rules!! Lol i'm going to have to learn it anyway..

Hint, use tabs. It's easier to make all the little bits line up if it's only one character per indent. Plus you can set your visual insert as you like. It should be noted that some programmers insisted on spaces. When it comes to style, everyone is a critic.

Currently, for the most part, Python is not a class room language. Which is a pity, because it has a lot to recommed it as such. It's one of the languages bundled in the OLPC for the kids and the interpreter is amusing.

[c0mrade]

Yeah, my first impression of Python was that I was sitting in an "Introduction to programming" class.

I guess its not that bad of a thing..

I'm all for indenting in c, java, php, etc - but I hate the idea of protecting programmers from themselves. The language should always assume that the programmer knows what they are doing. If I want to put an if statement on one line, I should be allowed to!

For example.. getters and setters

public int getNum() {return this.num;}
public void setNum(int num) {this.num = num;}

Anyway.. I'm going on again

Why are companies like google backing python instead of others like php and ruby?

This post has been edited by c0mrade: 09 April 2008 - 10:11 AM

[girasquid]

Because they like it more? That's really what most of these language choices come down to - do you like Python, PHP, Perl, C#, VB.Net, Ruby, or <language here>'s syntax better?

If you do, use that one. If you don't, use some other one.

[c0mrade]

I wish it was like that - but I cant only use the language I like the look of..

Anyway, I do like some parts of Python. Everything is an object which is nice - something I miss in php.

I'm a freelance web developer, currently the market is dominated by PHP. If the market decides to swing over to Python I have no choice but to learn Python..

I'm sure there are plenty of rails developers out there who have been forced to use php

I'm learning python anyway, going through code it seems like an interesting language. And Django looks like quality stuff.

[girasquid]

I'm going to have to respectfully disagree with you on this one.

If you're doing freelance Web Development, what tools you use are your business. If you use ASP.Net/IIS, or you use the LAMP stack, or anything else, that's entirely up to you - because you can tell your customers what sort of platform they need to get for you to work with. In the case of people coming to you with pre-built systems they want you to work on that's not quite the case, but for new contracts you can do that. It doesn't really matter what "the market is dominated by", it only matters what you can produce using your tools. If you can produce amazing things in Python, the average client isn't going to look at you and go "oh, well, we kind of wanted a PHP guy...". They'll just hire you.

</rant>

This post has been edited by girasquid: 10 April 2008 - 07:32 AM

[c0mrade]

Well this is not really the place for that discussion.

I do a lot of outsourced work for companies, freelance isn't always for one client who knows nothing about web development but just wants a site.

[girasquid]

Quote

I do a lot of outsourced work for companies

Ah - in that case, most of my point is moot. Nevermind.

[not1975]

baavgai, on 9 Apr, 2008 - 09:27 AM, said:

c0mrade, on 9 Apr, 2008 - 10:47 AM, said:

But ahhh I HATE whitespace rules!! Lol i'm going to have to learn it anyway..

Hint, use tabs. It's easier to make all the little bits line up if it's only one character per indent. Plus you can set your visual insert as you like. It should be noted that some programmers insisted on spaces. When it comes to style, everyone is a critic.

Currently, for the most part, Python is not a class room language. Which is a pity, because it has a lot to recommed it as such. It's one of the languages bundled in the OLPC for the kids and the interpreter is amusing.

If you're using IDLE, you can use Ctrl+[ and Ctrl+] to indent/un-indent whole blocks of code pretty conveniently.

[dave_6_10]

c0mrade, on 9 Apr, 2008 - 07:47 AM, said:

But ahhh I HATE whitespace rules!! Lol i'm going to have to learn it anyway..

#! /usr/bin/env python

"""The Tab Nanny despises ambiguous indentation.  She knows no mercy.

tabnanny -- Detection of ambiguous indentation

For the time being this module is intended to be called as a script.
However it is possible to import it into an IDE and use the function
check() described below.

Warning: The API provided by this module is likely to change in future
releases; such changes may not be backward compatible.
"""

# Released to the public domain, by Tim Peters, 15 April 1998.

# XXX Note: this is now a standard library module.
# XXX The API needs to undergo changes however; the current code is too
# XXX script-like.  This will be addressed later.

__version__ = "6"

import os
import sys
import getopt
import tokenize
if not hasattr(tokenize, 'NL'):
	raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")

__all__ = ["check", "NannyNag", "process_tokens"]

verbose = 0
filename_only = 0

def errprint(*args):
	sep = ""
	for arg in args:
		sys.stderr.write(sep + str(arg))
		sep = " "
	sys.stderr.write("\n")

def main():
	global verbose, filename_only
	try:
		opts, args = getopt.getopt(sys.argv[1:], "qv")
	except getopt.error, msg:
		errprint(msg)
		return
	for o, a in opts:
		if o == '-q':
			filename_only = filename_only + 1
		if o == '-v':
			verbose = verbose + 1
	if not args:
		errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...")
		return
	for arg in args:
		check(arg)

class NannyNag(Exception):
	"""
	Raised by tokeneater() if detecting an ambiguous indent.
	Captured and handled in check().
	"""
	def __init__(self, lineno, msg, line):
		self.lineno, self.msg, self.line = lineno, msg, line
	def get_lineno(self):
		return self.lineno
	def get_msg(self):
		return self.msg
	def get_line(self):
		return self.line

def check(file):
	"""check(file_or_dir)

	If file_or_dir is a directory and not a symbolic link, then recursively
	descend the directory tree named by file_or_dir, checking all .py files
	along the way. If file_or_dir is an ordinary Python source file, it is
	checked for whitespace related problems. The diagnostic messages are
	written to standard output using the print statement.
	"""

	if os.path.isdir(file) and not os.path.islink(file):
		if verbose:
			print "%r: listing directory" % (file,)
		names = os.listdir(file)
		for name in names:
			fullname = os.path.join(file, name)
			if (os.path.isdir(fullname) and
				not os.path.islink(fullname) or
				os.path.normcase(name[-3:]) == ".py"):
				check(fullname)
		return

	try:
		f = open(file)
	except IOError, msg:
		errprint("%r: I/O Error: %s" % (file, msg))
		return

	if verbose > 1:
		print "checking %r ..." % file

	try:
		process_tokens(tokenize.generate_tokens(f.readline))

	except tokenize.TokenError, msg:
		errprint("%r: Token Error: %s" % (file, msg))
		return

	except Indentationerror, msg:
		errprint("%r: Indentation Error: %s" % (file, msg))
		return

	except NannyNag, nag:
		badline = nag.get_lineno()
		line = nag.get_line()
		if verbose:
			print "%r: *** Line %d: trouble in tab city! ***" % (file, badline)
			print "offending line: %r" % (line,)
			print nag.get_msg()
		else:
			if ' ' in file: file = '"' + file + '"'
			if filename_only: print file
			else: print file, badline, repr(line)
		return

	if verbose:
		print "%r: Clean bill of health." % (file,)

class Whitespace:
	# the characters used for space and tab
	S, T = ' \t'

	# members:
	#   raw
	#	   the original string
	#   n
	#	   the number of leading whitespace characters in raw
	#   nt
	#	   the number of tabs in raw[:n]
	#   norm
	#	   the normal form as a pair (count, trailing), where:
	#	   count
	#		   a tuple such that raw[:n] contains count[i]
	#		   instances of S * i + T
	#	   trailing
	#		   the number of trailing spaces in raw[:n]
	#	   It's A Theorem that m.indent_level(t) ==
	#	   n.indent_level(t) for all t >= 1 iff m.norm == n.norm.
	#   is_simple
	#	   true iff raw[:n] is of the form (T*)(S*)

	def __init__(self, ws):
		self.raw  = ws
		S, T = Whitespace.S, Whitespace.T
		count = []
		b = n = nt = 0
		for ch in self.raw:
			if ch == S:
				n = n + 1
				b = b + 1
			elif ch == T:
				n = n + 1
				nt = nt + 1
				if b >= len(count):
					count = count + [0] * (b - len(count) + 1)
				count[b] = count[b] + 1
				b = 0
			else:
				break
		self.n	= n
		self.nt   = nt
		self.norm = tuple(count), b
		self.is_simple = len(count) <= 1

	# return length of longest contiguous run of spaces (whether or not
	# preceding a tab)
	def longest_run_of_spaces(self):
		count, trailing = self.norm
		return max(len(count)-1, trailing)

	def indent_level(self, tabsize):
		# count, il = self.norm
		# for i in range(len(count)):
		#	if count[i]:
		#		il = il + (i/tabsize + 1)*tabsize * count[i]
		# return il

		# quicker:
		# il = trailing + sum (i/ts + 1)*ts*count[i] =
		# trailing + ts * sum (i/ts + 1)*count[i] =
		# trailing + ts * sum i/ts*count[i] + count[i] =
		# trailing + ts * [(sum i/ts*count[i]) + (sum count[i])] =
		# trailing + ts * [(sum i/ts*count[i]) + num_tabs]
		# and note that i/ts*count[i] is 0 when i < ts

		count, trailing = self.norm
		il = 0
		for i in range(tabsize, len(count)):
			il = il + i/tabsize * count[i]
		return trailing + tabsize * (il + self.nt)

	# return true iff self.indent_level(t) == other.indent_level(t)
	# for all t >= 1
	def equal(self, other):
		return self.norm == other.norm

	# return a list of tuples (ts, i1, i2) such that
	# i1 == self.indent_level(ts) != other.indent_level(ts) == i2.
	# Intended to be used after not self.equal(other) is known, in which
	# case it will return at least one witnessing tab size.
	def not_equal_witness(self, other):
		n = max(self.longest_run_of_spaces(),
				other.longest_run_of_spaces()) + 1
		a = []
		for ts in range(1, n+1):
			if self.indent_level(ts) != other.indent_level(ts):
				a.append( (ts,
						   self.indent_level(ts),
						   other.indent_level(ts)) )
		return a

	# Return True iff self.indent_level(t) < other.indent_level(t)
	# for all t >= 1.
	# The algorithm is due to Vincent Broman.
	# Easy to prove it's correct.
	# XXXpost that.
	# Trivial to prove n is sharp (consider T vs ST).
	# Unknown whether there's a faster general way.  I suspected so at
	# first, but no longer.
	# For the special (but common!) case where M and N are both of the
	# form (T*)(S*), M.less(N) iff M.len() < N.len() and
	# M.num_tabs() <= N.num_tabs(). Proof is easy but kinda long-winded.
	# XXXwrite that up.
	# Note that M is of the form (T*)(S*) iff len(M.norm[0]) <= 1.
	def less(self, other):
		if self.n >= other.n:
			return False
		if self.is_simple and other.is_simple:
			return self.nt <= other.nt
		n = max(self.longest_run_of_spaces(),
				other.longest_run_of_spaces()) + 1
		# the self.n >= other.n test already did it for ts=1
		for ts in range(2, n+1):
			if self.indent_level(ts) >= other.indent_level(ts):
				return False
		return True

	# return a list of tuples (ts, i1, i2) such that
	# i1 == self.indent_level(ts) >= other.indent_level(ts) == i2.
	# Intended to be used after not self.less(other) is known, in which
	# case it will return at least one witnessing tab size.
	def not_less_witness(self, other):
		n = max(self.longest_run_of_spaces(),
				other.longest_run_of_spaces()) + 1
		a = []
		for ts in range(1, n+1):
			if self.indent_level(ts) >= other.indent_level(ts):
				a.append( (ts,
						   self.indent_level(ts),
						   other.indent_level(ts)) )
		return a

def format_witnesses(w):
	firsts = map(lambda tup: str(tup[0]), w)
	prefix = "at tab size"
	if len(w) > 1:
		prefix = prefix + "s"
	return prefix + " " + ', '.join(firsts)

def process_tokens(tokens):
	INDENT = tokenize.INDENT
	DEDENT = tokenize.DEDENT
	NEWLINE = tokenize.NEWLINE
	JUNK = tokenize.COMMENT, tokenize.NL
	indents = [Whitespace("")]
	check_equal = 0

	for (type, token, start, end, line) in tokens:
		if type == NEWLINE:
			# a program statement, or ENDMARKER, will eventually follow,
			# after some (possibly empty) run of tokens of the form
			#	 (NL | COMMENT)* (INDENT | DEDENT+)?
			# If an INDENT appears, setting check_equal is wrong, and will
			# be undone when we see the INDENT.
			check_equal = 1

		elif type == INDENT:
			check_equal = 0
			thisguy = Whitespace(token)
			if not indents[-1].less(thisguy):
				witness = indents[-1].not_less_witness(thisguy)
				msg = "indent not greater e.g. " + format_witnesses(witness)
				raise NannyNag(start[0], msg, line)
			indents.append(thisguy)

		elif type == DEDENT:
			# there's nothing we need to check here!  what's important is
			# that when the run of DEDENTs ends, the indentation of the
			# program statement (or ENDMARKER) that triggered the run is
			# equal to what's left at the top of the indents stack

			# Ouch!  This assert triggers if the last line of the source
			# is indented *and* lacks a newline -- then DEDENTs pop out
			# of thin air.
			# assert check_equal  # else no earlier NEWLINE, or an earlier INDENT
			check_equal = 1

			del indents[-1]

		elif check_equal and type not in JUNK:
			# this is the first "real token" following a NEWLINE, so it
			# must be the first token of the next program statement, or an
			# ENDMARKER; the "line" argument exposes the leading whitespace
			# for this statement; in the case of ENDMARKER, line is an empty
			# string, so will properly match the empty string with which the
			# "indents" stack was seeded
			check_equal = 0
			thisguy = Whitespace(line)
			if not indents[-1].equal(thisguy):
				witness = indents[-1].not_equal_witness(thisguy)
				msg = "indent not equal e.g. " + format_witnesses(witness)
				raise NannyNag(start[0], msg, line)


if __name__ == '__main__':
	main()

this may be helpful to you