||Home||Switchboard||Unix Administration||Red Hat||TCP/IP Networks||Neoliberalism||Toxic Managers|
|(slightly skeptical) Educational society promoting "Back to basics" movement against IT overcomplexity and bastardization of classic Unix|
|News||Scripting Languages||Recommended Links||Python Braces Debate||Command-Line Syntax and Options||Python pretty printers|
|Beautifiers and Pretty Printers||Python Debugging||Python source code checking tools to help you find common bugs||pdb The Python Debugger||Programming environment||Python IDEs||Pycharm IDE|
|Python for Perl programmers||Quotes||Python history||Tips||Etc|
This tool comes with the standard python distribution (look for pindent in the Tools directory cpython/pindent.py at master GitHub):
This file contains a class and a main program that perform three related (though complimentary) formatting operations on Python programs.
- When called as "pindent -c", it takes a valid Python program as input and outputs a version augmented with block-closing comments.
- When called as "pindent -d", it assumes its input is a Python program with block-closing comments and outputs a commentless version.
- When called as "pindent -r" it assumes its input is a Python program with block-closing comments but with its indentation messed up, and outputs a properly indented version.
A "block-closing comment" is a comment of the form '# end
' where is the keyword that opened the block. If the opening keyword is 'def' or 'class', the function or class name may be repeated in the block-closing comment as well. Here is an example of a program fully augmented with block-closing comments:def foobar(a, b): if a == b: a = a+1 elif a < b: b = b-1 if b > a: a = a-1 # end if else: print 'oops!' # end if # end def foobar
Note that only the last part of an if...elif...else... block needs a block-closing comment; the same is true for other compound statements (e.g. try...except). Also note that "short-form" blocks like the second 'if' in the example must be closed as well; otherwise the 'else' in the example would be ambiguous (remember that indentation is not significant when interpreting block-closing comments).
The operations are idempotent (i.e. applied to their own output they yield an identical result). Running first "pindent -c" and then "pindent -r" on a valid Python program produces a program that is semantically identical to the input (though its indentation may be different). Running "pindent -e" on that output produces a program that only differs from the original in indentation.
- -s stepsize: set the indentation step size (default 8)
- -t tabsize : set the number of spaces a tab character is worth (default 8)
- -e : expand TABs into spaces
- file ... : input file(s) (default standard input)
The results always go to standard output
- - comments ending in a backslash will be mistaken for continued lines
- - continuations using backslash are always left unchanged
- - continuations inside parentheses are not extra indented by -r but must be indented for -c to work correctly (this breaks idempotency!)
- - continued lines inside triple-quoted strings are totally garbled
- - On input, a block may also be closed with an "end statement" -- this is a block-closing comment without the '#' sign.
- - check syntax based on transitions in 'next' table
- - better error reporting
- - better error recovery
- - check identifier after class/def The following wishes need a more complete tokenization of the source:
- - Don't get fooled by comments ending in backslash
- - reindent continuation lines indicated by backslash
- - handle continuation lines inside parentheses/braces/brackets
- - handle triple quoted strings spanning lines
- - realign comments
- - optionally do much more thorough reformatting, a la C indent
Feb 20, 2013 | stackoverflow.comI can't compile because of this part in my code:if command == 'HOWMANY': opcodegroupr = "A0" opcoder = "85" elif command == 'IDENTIFY': opcodegroupr = "A0" opcoder = "81"
I have this error:
Sorry: IndentationError: ('unindent does not match any outer indentation level', ('wsn.py', 1016, 30, "\t\telif command == 'IDENTIFY':\n"))
But I don't see any indentation error. What can be the problem?
Martijn Pieters ,Feb 20, 2013 at 11:54You are mixing tabs and spaces.
Find the exact location with:python -tt yourscript.py
and replace all tabs with spaces. You really want to configure your text editor to only insert spaces for tabs as well.
poke ,Feb 20, 2013 at 11:55Or the other way around (depends on your personal preference) poke Feb 20 '13 at 11:55
poke ,Feb 20, 2013 at 12:02@MartijnPieters If you use tabs, you have tabs, so you do not need to care about its visual presentation. You should never mix tabs and spaces, but apart from that, just choose one and stick to it . You are right, it's a never-ending debate; it totally depends on your personal preference -- hence my comment. poke Feb 20 '13 at 12:02
neil ,Feb 20, 2013 at 12:02I have never understood why you would want to use spaces instead of tabs - 1 tab is 1 level of indent and then the size of that is a display preference - but it seems the world disagrees with me. neil Feb 20 '13 at 12:02
Martijn Pieters ♦ ,Feb 20, 2013 at 12:13@poke: That's very nice, but in any decent-sized project you will not be the only developer. As soon as you have two people together, there is a large chance you'll disagree about tab size. And pretending that noone will ever make the mistake of mixing tabs and spaces is sticking your head in the sand, frankly. There is a reason that every major style guide for OSS (python or otherwise) states you need to use spaces only . :-) Martijn Pieters ♦ Feb 20 '13 at 12:13
geoffspear ,Feb 20, 2013 at 12:22There should be one, and preferably only one, obvious way to do it. Following the style of the python codebase itself is obvious. geoffspear Feb 20 '13 at 12:22
Nov 06, 2017 | www.secnetix.de
Python: Myths about Indentation
Note: Lines beginning with "
>>>" and "
..." indicate input to Python (these are the default prompts of the interactive interpreter). Everything else is output from Python.
There are quite some prejudices and myths about Python's indentation rules among people who don't really know Python. I'll try to address a few of these concerns on this page.
"Whitespace is significant in Python source code."
No, not in general. Only the indentation level of your statements is significant (i.e. the whitespace at the very left of your statements). Everywhere else, whitespace is not significant and can be used as you like, just like in any other language. You can also insert empty lines that contain nothing (or only arbitrary whitespace) anywhere.
Also, the exact amount of indentation doesn't matter at all, but only the relative indentation of nested blocks (relative to each other).
Furthermore, the indentation level is ignored when you use explicit or implicit continuation lines. For example, you can split a list across multiple lines, and the indentation is completely insignificant. So, if you want, you can do things like this:
foo = [
['some string', 'another string', 'short string']
bar = 'this is ' \
'one long string ' \
'that is split ' \
'across multiple lines'
this is one long string that is split across multiple lines
"Python forces me to use a certain indentation style."
Yes and no. First of all, you can write the inner block all on one line if you like, therefore not having to care about intendation at all. The following three versions of an "if" statement are all valid and do exactly the same thing (output omitted for brevity):
Of course, most of the time you will want to write the blocks in separate lines (like the first version above), but sometimes you have a bunch of similar "if" statements which can be conveniently written on one line each.
if 1 + 1 == 2:
x = 42
if 1 + 1 == 2:
print "foo"; print "bar"; x = 42
if 1 + 1 == 2: print "foo"; print "bar"; x = 42
If you decide to write the block on separate lines, then yes, Python forces you to obey its indentation rules, which simply means: The enclosed block (that's two "print" statements and one assignment in the above example) have to be indented more than the "if" statement itself. That's it. And frankly, would you really want to indent it in any other way? I don't think so.
So the conclusion is: Python forces you to use indentation that you would have used anyway, unless you wanted to obfuscate the structure of the program. In other words: Python does not allow to obfuscate the structure of a program by using bogus indentations. In my opinion, that's a very good thing.
Have you ever seen code like this in C or C++?
Either the indentation is wrong, or the program is buggy, because an "else" always applies to the nearest "if", unless you use braces. This is an essential problem in C and C++. Of course, you could resort to always use braces, no matter what, but that's tiresome and bloats the source code, and it doesn't prevent you from accidentally obfuscating the code by still having the wrong indentation. (And that's just a very simple example. In practice, C code can be much more complex.)
/* Warning: bogus C code! */
if (some condition)
if (another condition)
In Python, the above problems can never occur, because indentation levels and logical block structure are always consistent. The program always does what you expect when you look at the indentation.
Quoting the famous book writer Bruce Eckel:
Because blocks are denoted by indentation in Python, indentation is uniform in Python programs. And indentation is meaningful to us as readers. So because we have consistent code formatting, I can read somebody else's code and I'm not constantly tripping over, "Oh, I see. They're putting their curly braces here or there." I don't have to think about that.
"You cannot safely mix tabs and spaces in Python."
That's right, and you don't want that. To be exact, you cannot safely mix tabs and spaces in C either: While it doesn't make a difference to the compiler, it can make a big difference to humans looking at the code. If you move a piece of C source to an editor with different tabstops, it will all look wrong (and possibly behave differently than it looks at first sight). You can easily introduce well-hidden bugs in code that has been mangled that way. That's why mixing tabs and spaces in C isn't really "safe" either. Also see the "bogus C code" example above.
Therefore, it is generally a good idea not to mix tabs and spaces for indentation. If you use tabs only or spaces only, you're fine.
Furthermore, it can be a good idea to avoid tabs alltogether, because the semantics of tabs are not very well-defined in the computer world, and they can be displayed completely differently on different types of systems and editors. Also, tabs often get destroyed or wrongly converted during copy&paste operations, or when a piece of source code is inserted into a web page or other kind of markup code.
Most good editors support transparent translation of tabs, automatic indent and dedent. That is, when you press the tab key, the editor will insert enough spaces (not actual tab characters!) to get you to the next position which is a multiple of eight (or four, or whatever you prefer), and some other key (usually Backspace) will get you back to the previous indentation level.
In other words, it's behaving like you would expect a tab key to do, but still maintaining portability by using spaces in the file only. This is convenient and safe.
Having said that -- If you know what you're doing, you can of course use tabs and spaces to your liking, and then use tools like "expand" (on UNIX machines, for example) before giving the source to others. If you use tab characters, Python assumes that tab stops are eight positions apart.
"I just don't like it."
That's perfectly OK; you're free to dislike it (and you're probably not alone). Granted, the fact that indentation is used to indicate the block structure might be regarded as uncommon and requiring to get used to it, but it does have a lot of advantages, and you get used to it very quickly when you seriously start programming in Python.
Having said that, you can use keywords to indicate the end of a block (instead of indentation), such as "
endif". These are not really Python keywords, but there is a tool that comes with Python which converts code using "end" keywords to correct indentation and removes those keywords. It can be used as a pre-processor to the Python compiler. However, no real Python programmer uses it, of course.
[Update] It seems this tool has been removed from recent versions of Python. Probably because nobody really used it.
"How does the compiler parse the indentation?"
The parsing is well-defined and quite simple. Basically, changes to the indentation level are inserted as tokens into the token stream.
The lexical analyzer (tokenizer) uses a stack to store indentation levels. At the beginning, the stack contains just the value 0, which is the leftmost position. Whenever a nested block begins, the new indentation level is pushed on the stack, and an "INDENT" token is inserted into the token stream which is passed to the parser. There can never be more than one "INDENT" token in a row.
When a line is encountered with a smaller indentation level, values are popped from the stack until a value is on top which is equal to the new indentation level (if none is found, a syntax error occurs). For each value popped, a "DEDENT" token is generated. Obviously, there can be multiple "DEDENT" tokens in a row.
At the end of the source code, "DEDENT" tokens are generated for each indentation level left on the stack, until just the 0 is left.
Look at the following piece of sample code:
In the following table, you can see the tokens produced on the left, and the indentation stack on the right.
x = 42
Note that after the lexical analysis (before parsing starts), there is no whitespace left in the list of tokens (except possibly within string literals, of course). In other words, the indentation is handled by the lexer, not by the parser.
<if> <foo> <:> 
<INDENT> <if> <bar> <:> [0, 4]
<INDENT> <x> <=> <42> [0, 4, 8]
<DEDENT> <DEDENT> <else> <:> 
<INDENT> <print> <foo> [0, 2]
The parser then simply handles the "INDENT" and "DEDENT" tokens as block delimiters -- exactly like curly braces are handled by a C compiler.
The above example is intentionally simple. There are more things to it, such as continuation lines. They are well-defined, too, and you can read about them in the Python Language Reference if you're interested, which includes a complete formal grammar of the language.
Nov 21, 2019 | stackoverflow.com
ephemient ,Feb 28, 2010 at 0:35Use the
reindent.pyscript that you find in the
Tools/scripts/directory of your Python installation:
Change Python (.py) files to use 4-space indents and no hard tab characters. Also trim excess spaces and tabs from ends of lines, and remove empty lines at the end of files. Also ensure the last line ends with a newline.
Have a look at that script for detailed usage instructions.
Jul 3, 2014 | stackoverflow.com
tricasse ,Jul 3, 2014 at 19:15I was wondering if there exists a sort of Python beautifier like the gnu-indent command line tool for C code. Of course indentation is not the point in Python since it is programmer's responsibility but I wish to get my code written in a perfectly homogenous way, taking care particularly of having always identical blank space between operands or after and before separators and between blocks.
Mike A ,Mar 1, 2010 at 17:49I am the one who asks the question. In fact, the tool the closest to my needs seems to be PythonTidy (it's a Python program of course : Python is best served by himself ;) ).
tom ,Sep 29, 2014 at 18:26autopep8 attempts to automate making your code conform to pep8 coding standards
Eyal Levin ,Oct 31, 2017 at 9:31You can also try
A formatter for Python files
Vinko Vrsalovic ,Jun 23, 2009 at 12:57PyLint has some formatting checks.
xxx ,Jun 23, 2009 at 12:57Have you looked at pindent ?
YAPFShort for "Yet Another Python Formatter," YAPF reformats Python code so that it conforms to the style guide and looks good. It's a Google-owned project. Operating System: OS Independent
About: pycallgraph is a Python library that creates call graphs for Python programs.
Changes: The "pycg" command line tool was renamed to "pycallgraph" due to naming conflicts with other packages.
Google matched content
GitHub - juanantoniofm-pythoniter Little python formatter-beautifier online (web) implemented in appengine
GitHub - google-yapf A formatter for Python files
PythonTidy · PyPI
autopep8 · PyPI
GitHub - be5invis-codeface Typefaces for source code beautification nice fonts
Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers : Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism : The Iron Law of Oligarchy : Libertarian Philosophy
War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda : SE quotes : Language Design and Programming Quotes : Random IT-related quotes : Somerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce : Bernard Shaw : Mark Twain Quotes
Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 : Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law
Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds : Larry Wall : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS : Programming Languages History : PL/1 : Simula 67 : C : History of GCC development : Scripting Languages : Perl history : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history
The Peter Principle : Parkinson Law : 1984 : The Mythical Man-Month : How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Haters Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite
Most popular humor pages:
Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor
The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D
Copyright © 1996-2021 by Softpanorama Society. www.softpanorama.org was initially created as a service to the (now defunct) UN Sustainable Development Networking Programme (SDNP) without any remuneration. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.
FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available to advance understanding of computer science, IT technology, economic, scientific, and social issues. We believe this constitutes a 'fair use' of any such copyrighted material as provided by section 107 of the US Copyright Law according to which such material can be distributed without profit exclusively for research and educational purposes.
This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...
|You can use PayPal to to buy a cup of coffee for authors of this site|
Last modified: November, 26, 2019