From dec1983284cb9bb0d674d7699cbd2f7dae094217 Mon Sep 17 00:00:00 2001 From: lakshaysharma14 <32371154+lakshaysharma14@users.noreply.github.com> Date: Wed, 25 Oct 2017 20:33:27 +0530 Subject: [PATCH 1/3] Difference between Python And Java i have added a file that is showing difference between the two languages python and java --- Difference between Python And Java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Difference between Python And Java diff --git a/Difference between Python And Java b/Difference between Python And Java new file mode 100644 index 0000000..65217bf --- /dev/null +++ b/Difference between Python And Java @@ -0,0 +1,15 @@ +A programmer can be significantly more productive in Python than in Java. + +How much more productive? The most widely accepted estimate is 5-10 times. On the basis of my own personal experience with the two languages, I agree with this estimate. + +Managers who are considering adding Python to their organization’s list of approved development tools, however, cannot afford to accept such reports uncritically. They need evidence, and some understanding of why programmers are making such claims. This page is for those managers. + +On this page, I present a list of side-by-side comparisons of features of Java and Python. If you look at these comparisons, you can see why Python can be written much more quickly, and maintained much more easily, than Java. The list is not long — it is meant to be representative, not exhaustive. + +This page looks only at programmer productivity, and does not attempt to compare Java and Python on any other basis. There is, however, one related topic that is virtually impossible to avoid. Python is a dynamically-typed language, and this feature is an important reason why programmers can be more productive with Python; they don’t have to deal with the overhead of Java’s static typing. So the debates about Java/Python productivity inevitably turn into debates about the comparative advantages and drawbacks of static typing versus dynamic typing — or strong typing versus weak typing — in programming languages. I will not discuss that issue here, other than to note that in the last five years a number of influential voices in the programming community have been expressing serious doubts about the supposed advantages of static typing. + +For those who wish to pursue the matter, Strong versus Weak Typing: A Conversation with Guido van Rossum, Part V is a good place to start. See also Bruce Eckel’s weblog discussion Strong Typing vs. Strong Testing and Robert C. Martin’s weblog discussion Are Dynamic Languages Going to Replace Static Languages?. For background, see one of the papers that started it all in 1998 — Scripting: Higher Level Programming for the 21st Century by John Ousterhout. + +Several of these discussions contain valuable comparisons of Java and Python. For other language comparisons, see the Python language comparisons page at www.python.org, and the PythonComparedToJava page at Python for Java Programmers. + +Finally, it is important to note that asserting that a programmer can be more productive in Python than in Java, is not the same as asserting that one ought always to use Python and never to use Java. Programming languages are tools, and different tools are appropriate for different jobs. It is a poor workman whose toolbox contains only a hammer (no matter how big it is!), and it is a poor programmer (or software development organization) whose development toolkit contains only one programming language. Our toolboxes should contain both Python and Java, so that in any given situation we have the option of choosing the best tool for the job. So our claim is not that Python is the only programming language that you’ll ever need — only that the number of jobs for which Python is the best tool is much larger than is generally recognized. From a608d748796177929638fb9aaf316171256891c5 Mon Sep 17 00:00:00 2001 From: lakshaysharma14 <32371154+lakshaysharma14@users.noreply.github.com> Date: Wed, 25 Oct 2017 20:38:30 +0530 Subject: [PATCH 2/3] BASIC SYNTAX ADDITION OF TWO NUMBERS --- BASIC SYNTAX | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 BASIC SYNTAX diff --git a/BASIC SYNTAX b/BASIC SYNTAX new file mode 100644 index 0000000..851f7d4 --- /dev/null +++ b/BASIC SYNTAX @@ -0,0 +1,8 @@ +num1 = 1.5 +num2 = 6.3 + +# Add two numbers +sum = float(num1) + float(num2) + +# Display the sum +print('The sum of {0} and {1} is {2}'.format(num1, num2, sum)) From 131180619e2088e36f079685d52998a2585cf157 Mon Sep 17 00:00:00 2001 From: lakshaysharma14 <32371154+lakshaysharma14@users.noreply.github.com> Date: Fri, 27 Oct 2017 19:27:09 +0530 Subject: [PATCH 3/3] Difference between Python 2 and Python 3 --- Difference between Python 2 and Python 3 | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Difference between Python 2 and Python 3 diff --git a/Difference between Python 2 and Python 3 b/Difference between Python 2 and Python 3 new file mode 100644 index 0000000..bd44753 --- /dev/null +++ b/Difference between Python 2 and Python 3 @@ -0,0 +1,11 @@ +Short version: Python 2.x is legacy, Python 3.x is the present and future of the language + +Python 3.0 was released in 2008. The final 2.x version 2.7 release came out in mid-2010, with a statement of extended support for this end-of-life release. The 2.x branch will see no new major releases after that. 3.x is under active development and has already seen over five years of stable releases, including version 3.3 in 2012, 3.4 in 2014, 3.5 in 2015, and 3.6 in 2016. This means that all recent standard library improvements, for example, are only available by default in Python 3.x. + +Guido van Rossum (the original creator of the Python language) decided to clean up Python 2.x properly, with less regard for backwards compatibility than is the case for new releases in the 2.x range. The most drastic improvement is the better Unicode support (with all text strings being Unicode by default) as well as saner bytes/Unicode separation. + +Besides, several aspects of the core language (such as print and exec being statements, integers using floor division) have been adjusted to be easier for newcomers to learn and to be more consistent with the rest of the language, and old cruft has been removed (for example, all classes are now new-style, "range()" returns a memory efficient iterable, not a list as in 2.x). + +The What's New in Python 3.0 document provides a good overview of the major language changes and likely sources of incompatibility with existing Python 2.x code. Nick Coghlan (one of the CPython core developers) has also created a relatively extensive FAQ regarding the transition. + +However, the broader Python ecosystem has amassed a significant amount of quality software over the years. The downside of breaking backwards compatibility in 3.x is that some of that software (especially in-house software in companies) still doesn't work on 3.x yet.