Below are two codes which first one is compiling and result is infinity loop, but with another one I get a compiler error as "Not a statement". As Math.random() returns double between 0.0 and 1.0 it is very strange for me why both of them do not gives same result.
1st
for(;;Math.random()){
System.out.println("Infinity Loop");
}
2nd
double i = 0.12654;
for(;;i){
System.out.println("Compile error");
}
The for loop requires three statements separated by semi-colons (or, as you illustrate, you can have no statement).
Java supports three types of statements:
Expression statements - those that create objects, call methods or change variables (e.g. Math.random())
Declaration statements - e.g. double i = 0.12654
Control flow statements - i.e. if, else, while, etc
i in the second incarnation isn't any of the above, which is why it fails compilation.
This question already has answers here:
Why Java identifies unreachable code only in case of while loop? [duplicate]
(3 answers)
Closed 3 years ago.
Code below fails to compile since x=3 is unreachable
while (false) { x=3; }
But why for( int i = 0; i< 0; i++) {x = 3;} compiles fine? In this code x=3 is also unreachable.
See JLS 14.21, Unreachable Statements.
The contained statement [in a while loop] is reachable iff the while statement is reachable and the condition expression is not a constant expression whose value is false.
false is a constant expression whose value is false, so x=3; is unreachable.
The contained statement [in a basic for loop] is reachable iff the for statement is reachable and the condition expression is not a constant expression whose value is false.
i<0 isn't a constant expression, so the contained statement is considered reachable, even if it is not actually reachable.
The while statement can be proven unreachable in compilation time, whereas the for statement needs to be checked in running time to find it unreachable.
If you try this
int i = 0;
while(i>1) { i = 4; }
The code will compile just fine.
In Java, consider the following piece of code:
Vector v = new Vector();
for(int i = 1; i <= 10; i++)
{
v.addElement(Integer.toString(i));
}
System.out.println(v.elementAt(9).toString());
Are Java statements like v.elementAt(9).toString() containing multiple '.' operators perfectly fine enough at all or do they cause any given type of conflict during some given period of time after all?
So far, I have only always kept them as safe enough in parenthesis, by making use of putting away off parenthesis around individual statements, so as not to create with any given type of conflict at all, after all.
(v.elementAt(9)).toString().
So far, I have never created with any given type of ambiguous statements like that during all of my own more than over a decade of programming and coding experience.
v.elementAt(9).toString().
Are Java statements like v.elementAt(i).toString() containing multiple '.' perfectly fine enough at all or do they cause any given type of conflict during some given period of time after all?
They are perfectly fine, with some caveats. If v.elementAt(i) is null, then calling v.elementAt(i).toString() will throw a NullPointerException. If you select i as some value that is either negative or larger than the Vector, I suspect an ArrayIndexOutOfBoundsException will be thrown as well. You can think of this syntax as the composition of functions (left-to-right), which is opposite how it is in mathematics.
In your specific example, this syntax is logically equivalent:
(v.elementAt(i)).toString()
Java does not support this construct:
if ((int ext_pos = fname.lastIndexOf('.')) >= 0)
fname = fname.substring(0,ext_pos);
(I get syntax errors when compiling).
However, some other languages support things like that, e.g., in Perl I can write
if (defined (my $foo = $bar{$baz})) { ... do stuff with $bar ... }
# $bar does not exist here
Obviously, this is more of syntactic sugar than anything else, since one can re-write it in Java as
{
int ext_pos = fname.lastIndexOf('.');
if (ext_pos >= 0)
fname = fname.substring(0,ext_pos);
}
at the cost of 3 extra lines of code.
How is this construct called?
(Bonus questions: Which languages support it? Why don't Java & C++ support it?)
You have to move the declaration outside of the if-statement condition. Declarations are statements and can't be used as expressions
int ext_pos;
if ((ext_pos = fname.lastIndexOf('.')) >= 0)
fname = fname.substring(0,ext_pos);
In some languages as you point out (Perl), you can do this. This is because assignment in those languages can also be considered an expression and as such nested in other expressions.
(I'm not sure what this construct is called)
Java allows assignments inside expressions, but not variable declarations (thanks for the correction biziclop!). C++ has traditionally had the same restriction, but I found another stackoverflow post describing how declarations are allowed in conditions in the C++03 standard. The syntax is limited, but this is allowed (tested on GCC 4.2.1):
int x = 1;
if (int y = x)
cout << "y = " << y << endl;
Note that as biziclop pointed out, this has the nice property of restricting the scope of y to that within the conditional. If you try to use y outside the conditional you'll get an error:
int x = 1;
if (int y = x)
cout << "y = " << y << endl;
cout << y; // error: ‘y’ was not declared in this scope
I don't think there's actually a name for this—it's just allowing declarations in expressions. I don't think it's common enough to have its own specialized term.
As for language support. JavaScript sort of supports this in that it allows assignments in expressions, and that if you reference an undeclared variable in JavaScript it just assumes it's global.
if (x = 1) alert(x) // x is global, assigned 1
alert(x) // since x is global it's still in scope and has value 1
Basically, any language in which a declaration is an expression will allow you to do this. In most functional programming languages (e.g. Haskell, ML, Lisp), basically everything is an expression, so you can declare new variable bindings inside the condition (but they wouldn't be available in the body of the conditional). Here's an example in Clojure:
(println ; print the result of the conditional
(if (let [x 1] ; declare local binding x = 1
(== x 2)) ; check if x == 2
"is two" ; true branch result
"isn't two")) ; false branch result
Although Java doesn't like it when you to instantiate a variable inside the if statement, it will let you set one.
int ext_pos;
if ((ext_pos = fname.lastIndexOf('.')) >= 0) {
fname = fname.substring(0, ext_pos);
}
compiles correctly. I know that this is very similar to your solution, but I just wanted to point it out.
Similarly, Matthew Crumely answered a question about setting a variable inside the if conditional statement using another method here. In short, he notes that this can cause some code confusion for others that look at your code.. It can easily look like a noob mistake of using the wrong "=" or "==" even if it really is intended.
My real guess as to why they did this was to keep the code easily readable.
This is block notation. See Java specification section 14.2. Per The specification:
A block is executed by executing each of the local variable declaration statements and other statements in order from first to last (left to right). If all of these block statements complete normally, then the block completes normally. If any of these block statements complete abruptly for any reason, then the block completes abruptly for the same reason.
Section 14.3 shows an example with this syntax in it, you can also find this syntax throughout the specification.
I've been writing Java for the last couple of years , and now I've started to write in python (in addition).
The problem is that when I look at my Python code it looks like someone tried to hammer Java code into a python format , and it comes out crappy because - well , python ain't Java.
Any tips on how to escape this pattern of "Writing Java in Python"?
Thanks!
You might consider immersing yourself in the Python paradigms. The best way is to first know what they are then explore the best practices by reading some literature and reviewing some code samples. I recommend Learning Python by Mark Lutz; great for beginners and advanced users.
You'll do yourself a great injustice if you program with Python and fail to leverage all of the built-in, developer-friendly, Pythonic syntax.
As my French teacher used to say, "French isn't just English with different words."
If you are new to Python and coming from Java (or C#, or other similar statically typed OO language), these classic articles from PJ Eby and Ryan Tomayko are necessary reading:
Python Is Not Java (PJE)
Java is not Python, either (PJE)
Python Interfaces are not Java Interfaces (PJE)
The Static Method Thing (Tomayko)
Getters/Setters/Fuxors (Tomayko)
You could start by reading The Zen of Python. It'll give you some insight into how Python code is supposed to be written, provided you understand the language enough to understand what it's talking about. :-)
Some of the major ways in which Python differs from C/Java-like languages are:
List comprehensions.
Support for functional programming.
The use of certain Pythonic constructs instead of similar C-like constructs although both seem to work (list comprehensions can be argued to be a part of this, but there are others).
There are others, but these are the main ones that bugged me when I first started Python (and I had come from years of Java like you).
Before using any of these, it is helpful to understand why you should go for pythonic code rather than the usual C/Java way in Python, although both give you the same output.
For starters, Python provides some powerful features not available in C/Java that makes your code much clearer and simpler (although this is subjective, and might not look any better to someone coming from Java at first). The first two points fall into this category.
For example, support for functions as first class objects and closures makes it easy to do things that would need all kinds of weird acrobatics with inner classes in Java.
But a major reason is that Python is an interpreted language, and certain constructs are much faster than the equivalent C/Java-like code. For example, list comprehensions are usually a lot faster than an equivalent for-loop that iterates over the indices of a list and accesses each item by index. This is a very objective benefit, and IMHO a lot of the "Python in way too slow" way of thinking comes from using Java-style code shoe-horned into Python.
One of the best ways to learn about pythonic code is to read other people's code. I actually learnt a lot by looking at Python code posted in answers to SO questions. These often come with explanations and it is usually obvious why it is better than non-pythonic code (speed, clarity, etc.).
Edit:
Of course, there are other ways of getting other people's code. You can also download and look through the code of any good open source Python project. Books are also a good resource, I would recommend O'Reilly Python Cookbook. It has lots of useful code examples and very detailed explanations.
1) Python supports many (but not all) aspects of
object-oriented programming; but it is
possible to write a Python program without
making any use of OO concepts.
1) Java supports only object-oriented
programming.
2) Python is designed to be used interpretively.
A Python statement may be entered at the
interpreter prompt
(>>>)
, and will be executed
immediately. (Implementations make some
use of automatic compilation into bytecodes
(.pyc files).
2) Programs written in Java must be explicitly
compiled into bytecodes (.class files),
though an IDE may do this automatically in a
way that is transparent to the user. Java does
not support direct execution of statements -
though there are tools like Dr. Java that
support this.
3) Python is dynamically typed:
• A variable is introduced by assigning a
value to it. Example:
someVariable = 42
• A variable that has been assigned a value of
a given type may later be assigned a value
of a different type. Example:
someVariable = 42
someVariable = 'Hello, world'
3) Java is
statically typed
:
• A variable must be explicitly declared to be
of some type before assigning a value to it,
though declaration and assignment may be
done at the same time. Examples:
int someVariable;
int someVariable = 42;
• A variable that has been declared to be of a
particular type may not be assigned a value
of a different type.
4) Python supports the following built-in data
types:
Plain integers (normally 32-bit integers in
the range -2147483648 through
2147483647).
• Long integers (size limited only by memory
size of the machine running on)
• Booleans (False and True).
• Real numbers.
• Complex numbers.
In addition, Python supports a number of
types that represent a collection of values -
including strings, lists, and dictionaries.
4) Java has two kinds of data types: primitive
types and reference types. Java supports the
following primitive data types:
• byte - 8-bit integers
• short - 16-bit integers
• int - 32-bit integers
• long - 64-bit integers (Java also supports a
class java.math.BigInteger to represent
integers whose size is limited only by
memory)
• float - 32-bit real numbers.
• double - 32-bit real numbers.
• boolean - (false and true).
• char - a single character.
In addition, Java supports arrays of any type
as the reference types, and the API includes
the class String and a large number of classes
used for collections of values.
5)
Python is line-oriented:
statements end at the
end of a line unless the line break is explicitly
escaped with . There is no way to put more
than one statement on a single line.
Examples:
this is a statement
this is another statement
this is a long statement that extends over more \
than one line
5)
Statements in Java always end with a
semicolon (;)
. It is possible for a statement to
run over more than one line, or to have
multiple statements on a single line.
Examples:
this is a statement;
this is another statement;
this is a long statement that extends over more
than one line;
a statement; another; another;
6)
Python comments begin with #
and extend to
the end of the line. Example:
This is a comment
A new statement starts here
6) Java has two kinds of comments. A comment
beginning with // extend to the end of the
line (like Python comments). Comments can
also begin with /* and end with */. These
can extend over multiple lines or be
embedded within a single line. Examples:
// This is a comment
A new statement starts here
/* This is also a comment */
/* And this is also a comment, which is
long enough to require several lines
to say it. */
Statement starts /* comment */ then continues
7) Python strings can be enclosed in either single
or double quotes (' or ""). A character is
represented by a string of length 1. Examples:
'This is a string'
"This is also a string" # Equivalent
'c' # A string
"c" # An equivalent string
Python uses the following operators for
constructing compound boolean expressions:
and, or and not. Example:
not(x > 0 and y > 0) or z > 0
7) Java strings must be enclosed in double
quotes (""). A character is a different type of
object and is enclosed in single quotes (').
Examples:
"This is a String"
'c' // A character, but not a String
Java uses the following operators for
constructing compound boolean expressions:
&&, ||, ! and ^ (meaning exclusive or)
Example:
! (x > 0 && y > 0) || z > 0 ^ w > 0
8) In Python, the comparison operators
(>, <, >=, <=, == and !=) can be applied to numbers
,
strings, and other types of objects), and
compare values in some appropriate way (e.g.
numeric order, lexical order) where possible.
8) In Java, most of the comparison operators
( >, <, >=, and <=) can be applied only to
primitive types. Two (== and !=) can be
applied to any object, but when applied to
reference types they test for same (different)
object rather than same (different) value.
9) There is no universally-accepted Python
convention for naming classes, variables,
functions etc.
9) By convention, most names in Java use mixed
case. Class names begin with an uppercase
letter; variable and function names begin with
a lowercase letter. Class constants are named
using all uppercase letters with underscores.
Examples:
AClassName
aVariableName
aFunctionName()
A_CLASS_CONSTANT
10) Python definite looping statements have the
form for variable in expression: Example:
for p in pixels:
something
10) Java has two kinds of definite looping
statements. One has the form
for (variable in collection) Example:
for (p in pixels)
something;
11) Python uses the built-in function range() with
for to loop over a range of integers.
Examples:
for i in range(1, 10)
something
(i takes on values 1, 2, 3, 4, 5, 6, 7, 8, 9)
for i in range(1, 10, 2)
something
(i takes on values 1, 3, 5, 7, 9)
11) Java uses a different form of the for to loop
over a range of integers. Examples:
for (int i = 1; i < 10; i ++)
something;
(i takes on values 1, 2, 3, 4, 5, 6, 7, 8, 9)
for (int i = 1; i < 10; i += 2)
something;
(i takes on values 1, 3, 5, 7, 9)
12) Python conditional statements have the form
if condition: and an optional else part has the
form else:. The form elif condition: is
allowed as an alternative to an else:
immediately followed by an if. Examples:
if x < 0:
something
if x < 0:
something
else:
something different
if x < 0:
something
elif x > 0:
something different
else:
yet another thing
12) Java conditional statements have the form
if (condition) and an optional else part has
the form else (no colon) There is no elif
form - else if is used directly. Examples:
if (x < 0)
something;
if (x < 0)
something;
else
something different;
if (x < 0)
something;
else if (x > 0)
something different;
else
yet another thing;
13) The scope of a Python conditional or looping
statement is denoted by indentation. (If
multiple lines are to be included, care must be
used to be sure every line is indented
identically). Examples:
if x < 0:
do something
do another thing regardless of the value of x
if x < 0:
do something
do something else
do yet a third thing
do another thing regardless of the value of x
13) The scope of a Java conditional or looping
statement is normally just the next statement.
Indentation is ignored by the compiler
(though stylistically it is still highly desirable
for the benefit of a human reader). If
multiple lines are to be included, the scope
must be delimited by curly braces ({ , }).
(Optionally, these can be used even if the
scope is a single line.) Examples:
if (x < 0)
do something;
do another thing regardless of the value of x;
if (x < 0)
do something; // Bad style-don't do this!
do another thing regardless of the value of x;
if (x < 0)
{
do something;
do something else;
do yet a third thing;
}
do another thing regardless of the value of x;
if (x < 0)
{
do something;
}
do another thing regardless of the value of x;
If you want to see some fairly idiomatic Python that does non-trivial stuff, there's Dive Into Python, although Dive Into Python 3 is newer and might be a better source of style tips. If you're looking more for some points to review, there's Code Like a Pythonista.
You could post your code at Refactor my code to see if someone can show you a more Pythonic way to do it.
Definitely not a panacea but I think you should try some code golf in Python. Obviously nobody should write "golfed" code IRL, but finding the most terse way to express something really forces you to exploit the built in functionality of the language.
Someone provided me with this list of how "Python is not Java" when I started Python after Java, and it was very helpful.
Also, check out this similar SO question that I posted a short time ago when in a similar position.
Try to find algorithms that you understand well and see how they are implemented in python standard libraries.
Persist. :)
Learn a few other languages. It will help you make the difference between algorithms (the structure of processing, unchanged between languages) and the local syntaxic features of the language. Then you can "write Foo in Bar" for any combination of languages "Foo" and "Bar".
Eat Python, Sleep Python and Drink Python. That is the only way........
This is useful if you want to understand how to code to python in a more pythonic or correct way: http://www.python.org/dev/peps/pep-0008/