In this article, we’ll talk about the most efficient way to learn Python. Of course, this article will be really subjective, as it is only based on my personal experience.<\/p>\n
I’ve started learning Python from it’s 3.4 version. I’ve never actually worked with previous versions, although I coded a little bit just to satisfy my curiosity. Still, the difficulty of every subject here is based on my experience with Python 3.4, the results may vary if you work with other versions.<\/p>\n
Python is a high-level, object oriented, interpreted programming language. It was created by Guido van Rossum, and its source code is available under the GNU General Public License.<\/p>\n
It\u2019s a great language for the beginner-level programmers and supports the development of a wide range of applications from simple text processing to big web applications and even games.<\/p>\n
[ulp id=’R7QVpFMZmjosABLC’]<\/p>\n
This language has a lot of awesome features:<\/p>\n
Also, it supports functional programming, which is a huge plus for me at least, and it can be used as a scripting language or be compiled to build big applications too.<\/p>\n
It provides high-level dynamic data types and supports dynamic type checking. It also supports automatic garbage collection.<\/p>\n
First of all, we’ll talk a little bit about how to set up your development environment. I am currently working in a Linux Mint 17.2, which is basically an Ubuntu 14.04. On this platform, I just run If the set up is right, if you open a console and run This is the Python REPL (read\u2013eval\u2013print loop). This is an interactive language shell. You can write Python code there and execute it. Let’s see:<\/p>\n If you don’t know anything about programming, codecademy<\/a> has a great course about Python, which will show you the basics, both about the language and about programming.<\/p>\n Now, what I’d do first, If I am new to the language, but I know at least a little bit about programming, is to find a more extensive introduction to Python. I wrote what I think is an extensive, but concise example of Python here<\/a>. In that example you’ll find:<\/p>\n After you read that example you will be able to do some really awesome stuff, like:<\/p>\n fibonacci.py<\/em><\/span><\/p>\n There we defined a function that given an integer, it returns the number present in that position of the fibonacci sequence. We know the fibonacci sequence goes like (0, 1, 1, 2, 3, 5, 8, …) so if you ask for the number in the position 6 (having in mind that the first position is zero) it would return an 8.<\/p>\n The algorithm is so simple and yet so beautiful. We first defined a dictionary which we’ll use as cache (that’s why it’s called And, of course, you also have the knowledge to do that example with a non recursive solution, like this:<\/p>\n fibonacci.py<\/em><\/span><\/p>\n If you are already familiar with these subjects, and you are looking to deepen your knowledge about the language, you should skip to the next steps.<\/p>\n If not, you should read that example, and complement it with some research. Stack Overflow<\/a> is a question and answer site for professional and enthusiast programmers, here you can find some explanation about the concepts you are not familiar with. For example if you want to know what a variable is, in Stack Overflow’s search box you type what is a variable?<\/a> and one of the answers in the result will be this one<\/a>. If the responses are too technical or advanced, you can try other similar questions and maybe even read as many answers as you can until you actually understand what they mean.<\/p>\n At this point, I would also create a profile in GitHub<\/a> and read about git<\/a>, which is a version control system. You can use git to save your code (projects, exercises, etc.) and it will also provide a history of changes and some really useful stuff. Having a GitHub account will let you share your code with friends and colleagues and they may even be able to help you or guide you when you are blocked out or anything. A facebook post is not the best way to share code.<\/p>\n Of course, there are alternatives to GitHub, for private repositories, for example, GitLab<\/a> would be my first choice, althoug some people prefer Bitbucket<\/a> (I’ve never actually used it, but people say it’s awesome).<\/p>\n At this point you should have some strong basis of the language, so you should work on those functions to know how to work with them properly, as they are a really powerful tool and the core of Python. In essence, functions are procedures that return a value based on some given arguments. In Python, functions are first-class objects. This means that functions can be assigned to a variable, they can be defined inside another functions, they can be passed as parameters (higher-order functions), and they can return other functions (also, higher-order functions).<\/p>\n I’ve actually learnt a lot about Python at tutorials point<\/a>, and here<\/a> you can find a basic but great example about functions. Most tutorials at tutorials point are based on Python 2.7, but most of the knowledge you’ll get there can be applied to more recent versions of Python, and of course, tutorials about conversions can be found almost everywhere.<\/p>\n My Python Decorators Tutorial<\/a> will show you how powerful functions are in Python, and how you can extend their behavior without actually modifying them. Before it jumps into decorators, it will explain functions in a more detailed way. It will also explain how and why functions are first-class objects in Python, which is the main reason they are awesome.<\/p>\n Another useful example to practice with functions is this<\/a> example about the built-in function Now we have a strong knowledge about functions, we can solve more complex problem. For example, if we wanted to write a function that returns the lowest common multiple of n numbers, where n is not a fixed integer, we could do something like this:<\/p>\n lcm.py<\/em><\/span><\/p>\n Here we are using So, with this utility we can do things like:<\/p>\n Now we know functions, I would strongly recommend to deepen your knowledge of data structures, although in the example given at the beginning of this article they are pretty well explained. The most used data structures in Python are lists and dictionaries, read my Python Dictionary Example<\/a>, which explains in detail how to define a dictionary, the best way to read from it, how to write data to it and some useful built-in functions and keywords.<\/p>\n Also, an example<\/a> about a not so used data structure will come in handy, as it explains how At codility<\/a> you can find some really fun and awesome exercises to practice your functions, data structures, programming skills and algorithm knowledge. Keep in mind that some of the tasks are actually pretty hard, so you may take a while to solve them. If you actually have no idea of what to do there, you should practice more, maybe read about a couple subjects and then try again.<\/p>\n There are a lot of exercises in codility where we can train our skills with arrays and dictionaries, but I will talk about three here.<\/p>\n The first one is Odd Ocurrences in Array<\/a>. The problem says something like:<\/p>\n A non-empty zero-indexed array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired. Write a function that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.<\/em><\/p>\n I’m sure there are more than one ways to solve this problem, but the one solution I came up with was this one:<\/p>\n codiliti.py<\/em><\/span><\/p>\n Codility does not test our validation skills, so the last statement, the one that says In this solution I’m abusing of the The second problem, Tape Equilibrium<\/a>, says something like this:<\/p>\n A non-empty zero-indexed array A consisting of N integers is given. Array A represents numbers on a tape. Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], …, A[P \u2212 1] and A[P], A[P + 1], …, A[N \u2212 1]. The difference between the two parts is the value of: |(A[0] + A[1] + … + A[P \u2212 1]) \u2212 (A[P] + A[P + 1] + … + A[N \u2212 1])|. <\/em><\/p>\n In other words, it is the absolute difference between the sum of the first part and the sum of the second part. Write a function that, given a non-empty zero-indexed array A of N integers, returns the minimal difference that can be achieved.<\/em><\/p>\n Again, I’m sure there is more than one solution, but I came out with this one:<\/p>\n codiliti.py<\/em><\/span><\/p>\n I create my first and second parts of the tape. The first one is only the head of the array, the second one is the sum of the tail. Then I iterate over the array, until the element before the last one, and subtract from the second part and add to the first part. I have a variable called The third and last exercise I’ll talk about is Missing Integer<\/a>, and it says something like:<\/p>\n Write a function that, given a non-empty zero-indexed array A of N integers, returns the minimal positive integer (greater than 0) that does not occur in A.<\/em><\/p>\n I solved this problem using an algorithm that uses dictionaries like in the first exercise:<\/p>\n codiliti.py<\/em><\/span><\/p>\n As you see, I am using the dictionary as a buffer to store the values I’ve already found in the array, and by the way I register the maximum value present in the array in question. Then, I iterate over a range from 1 to the length of the array plus one, and return the first number in that range that is not a key in my dictionary. If none of those elements is absent in the dictionary, then I return the maximum value of the array plus one. Here I’m only using dictionaries because they are indexed.<\/p>\n At this point, you would actually be capable of writing a really interesting program, but if it gets too big, maybe classes would be a nice way to make your program more modular. Of course, you can always solve that problem with modules, but still, a deep knowledge of classes will come handy.<\/p>\n Read this<\/a> article about classes, it explains how easy it is to write a class in Python, how an instance of a class is an object but in Python a class is also an object, which let’s you do some real fun stuff. It will talk about inheritance, and best practices and standards that the community defined to tell users of you API that some members are not meant to be accessed from outside (private members).<\/p>\n Also, this<\/a> article about object oriented programming, is a more advanced tutorial about classes and objects in Python, if you read mine before, you could skip a couple sections and stop where you see something that doesn’t ring a bell.<\/p>\n At this<\/a> section, you can find some good exercises for beginners and even for advanced programmers. Some of them where actually written for Java, but you can solve them in Python, the result should finally work the same. Of course, to actually become good at anything, you should put it in practice for real. Maybe you should start a project at this point. An application that solves some kind of problem that you don’t want to do it manually.<\/p>\n I, for example, when I learnt scala, made an application that took care of my accounts. I input how much money I make, how much I spend, in what, and it does some calculations that I don’t want to do and tells me how much money I can save, how much I should be able to save, when will I run out of cash, and some other useful information.<\/p>\n With classes in hand, you can start doing some really interesting stuff. You can, by example, start working with threads. A really extensive example about threading and concurrency can be found here<\/a>. This threading tutorial will give you an overview of the deprecated You’ll see how to extend a thread, how to get thread’s information, what is and how can you create a daemon thread, how to join threads and some concurrency utilities, like events, locking, limiting concurrent access, and thread locals. Threads are processes which run in parallel to other threads. In a utopian scenario, if you split a big process in 2 threads, these threads will run in parallel so it would take half the time.<\/p>\n IBM also provides a really detailed example about threading with Python here<\/a>, it may bee a little too advanced, but if you got this far I’m sure you can get pass this article.<\/p>\n With this knowledge about functions, objects and threads in hand, there is a lot of things we can do now some more interesting things, like asynchronous programming. Let’s see:<\/p>\n asynch.py<\/em><\/span><\/p>\n You have 2 threads here, which are executing tasks in parallel, we can say they are asynchronous as they receive callbacks so we can run them, tell them what to do when they finish and continue with our execution on the main thread. When we run the script we’ll see:<\/p>\n As you see, the script is taking a little more than 3 seconds to run, which proves these tasks are being run in parallel as they are both sleeping for three seconds.<\/p>\n Once you get the hang of threads, you can learn the basics of sockets with this<\/a> tutorial, which will explain in detail sockets, it’s perks and best practices. Sockets are behind any kind of network communications done by your computer.<\/p>\n We all know that, when you type a url in your browser, it\u2019s connecting to a server somewhere in the world which receives a request, returns a response and then the connection is closed. All of this is made through sockets, always. It doesn\u2019t matter if your are communicating through HTTP, UDP or whatever, there is a socket behind every one of those protocols.<\/p>\n Once you read this article you should jump into network programming<\/a> and learn how to write a p2p messenger and a simple chat room.<\/p>\n Then, as you are getting into big applications, I would recommend reading this<\/a> article about logging, which is necessary, as After you’ve done all of this, you will find it very easy to integrate with a big web framework as Django, and you can use this<\/a> article as a cheat sheet. The article will walk you through the basics of this complete web framework, and with a little more research in Django’s docs<\/a> you will be able to build your first full, productive web application with Python. Django is an open source web framework which solves most common problems of a web application development.<\/p>\n It has some very useful features like an auto generated admin page and an ORM. It\u2019s a high-level framework, so we just need to focus on the actual core logic of our business and let Django take care of mappings, filters and such. It works by defining some standards that, if you follow them, will make the application\u2019s development so much easier and faster.<\/p>\n A good alternative, more lightweight but also minimal, to Django is Flask<\/a>, I found out that Flask is easy to setup, runs fine. Here<\/a> you can find a benchmark that compares some response times of a lot of Python frameworks in some interesting scenarios. You’ll find that Django and Flask behave almost the same, even Flask wins in a couple scenarios.<\/p>\n Now, if you’ve got this far, you are probably starting to think about writing a big project, like a product, that you may be able to sell or at least make popular. You might be thinking about looking for a job to use these new skills. You would recommend having Python’s docs<\/a> in speed dial, get the hang of Stack Overflow and prepare yourself to learn a lot. Every project, every new project you face, has something new to teach you.<\/p>\n If it’s big you may learn how important it is to make modular and testable code. If it gets really popular you will learn about concurrency and performance. If it’s open source you will learn about reading someone else’s code, and writing code that is readable by anyone (this one is REALLY<\/strong> important) (that’s my first bold text in this article, that’s how important readable code is).<\/p>\n A good activity to get really fluent with a language is to see some GitHub projects written in it and try to understand what they are doing and how are they doing it. Maybe, if it’s an open source project, you could contribute to it, an example of a contribution of mine is this pull request<\/a> I made for a web socket client which didn’t have support for Scala 2.11, so I implemented it as I was learning Scala myself, the issue is this one<\/a>. The process can be pretty long, it gets worse if you and the owner of the project are in different timezones, but once it gets done it is really awesome to see people use a tool you contributed to.<\/p>\n I think at this point I have no more guidance to give. Keep in mind that by doing you learn. The more you read, the more prepared you are to face new problems, so sit down, open google and start researching. The most stupid idea, the most stupid problem you can think of, I can guarantee that if you write a program that solves it, you will learn something new from it.<\/p>\n Spend time updating you knowledge, join a programming community, if you are from Argentina, for example, there is PyAr<\/a>, which is a pretty big, nerd, awesome community.<\/p>\n A programming community has a lot to give you, you will know whenever a new update is coming, a new big useful framework\/library gets released, a good convention is near and more. It will help you keep updated and interested, you will be able to socialize with awesome, really smart and experienced people, and even help newbies (it sounds like an insult, but I don’t see it that way) get to speed. You should never underestimate a community.<\/p>\n Python is, in my humble opinion, the perfect language for the beginners level of programmers. If I had to tell someone which language should he\/she use to learn programming from scratch, I would automatically say “Python!”. Also, it really is powerful, you can write web applications that will perform just as good as in any other language, you just have to keep in mind the existence of the GIL and try not to do long blocking operations inside it, which is not a difficult task once you get the hang of the language.<\/p>\n So, that’s it. Python is one of my favourite languages, it’s actually my second favourite. I have a lot of fun coding with it, I think it’s really versatile and powerful. I hope you have fun with it too. Thanks for reading!<\/p>\n","protected":false},"excerpt":{"rendered":" In this article, we’ll talk about the most efficient way to learn Python. Of course, this article will be really subjective, as it is only based on my personal experience. I’ve started learning Python from it’s 3.4 version. I’ve never actually worked with previous versions, although I coded a little bit just to satisfy my …<\/p>\n","protected":false},"author":109,"featured_media":1651,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[53],"tags":[],"class_list":["post-12054","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python"],"yoast_head":"\nsudo apt-get install python3<\/code> and, at the time this article was written, this will install Python 3.4.3. Other ways to install Python, and support for other platforms can be found at https:\/\/www.python.org\/<\/a>.<\/p>\npython3<\/code> you should see something like this:<\/p>\n$ python3\r\nPython 3.4.3 (default, Oct 14 2015, 20:28:29)\r\n[GCC 4.8.4] on linux\r\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\r\n>>>\r\n<\/pre>\n
$ python3\r\nPython 3.4.3 (default, Oct 14 2015, 20:28:29)\r\n[GCC 4.8.4] on linux\r\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\r\n>>> print(\"hello world!\")\r\nhello world!\r\n>>> for i in range(10):\r\n... print(i)\r\n...\r\n0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n>>>\r\n<\/pre>\n
<\/a>2. An Extensive Introduction<\/h2>\n
\n
_cache = {\r\n 0: 0,\r\n 1: 1\r\n}\r\n\r\ndef fibonacci(i):\r\n if i < 0:\r\n return None\r\n if i not in _cache:\r\n _cache[i] = fibonacci(i - 1) + fibonacci(i - 2)\r\n return _cache[i]\r\n<\/pre>\n_cache<\/code>), with a couple default values, and then a function that receives an argument i<\/code>, which first checks if i<\/code> is not a key in our cache, if it is it returns the content in our cache, if it isn’t, it does a recursive call to get the two numbers in the sequence before the one that is being asked for and adds them.<\/p>\ndef fibonacci2(i):\r\n second_last = 0\r\n last = 1\r\n for index in range(2, i + 1):\r\n aux = second_last + last\r\n second_last = last\r\n last = aux\r\n return last\r\n<\/pre>\n
<\/a>3. Some Functions<\/h2>\n
map<\/code>, which is a really useful built-in function to transform iterable objects. Strictly speaking, a map function, is a function that accepts a function and an array as arguments, and applies the given function to each element of the array, returning another array with the result of each transformation. So, in other words, a map applies a transformation to each element of an array and returns the results.<\/p>\nfrom functools import reduce\r\n\r\ndef greatest_common_divisor(a, b):\r\n if b == 0:\r\n return a\r\n return greatest_common_divisor(b, a % b)\r\n\r\ndef _lowest_common_multiple(a, b):\r\n return a * b \/\/ greatest_common_divisor(a, b)\r\n\r\ndef lowest_common_multiple(*args):\r\n return reduce(_lowest_common_multiple, args)\r\n<\/pre>\n
reduce<\/code> from functools<\/code> (if you are not familiar with this function wikipedia<\/a> has a good explanation about it) to combine de results of applying _lowest_common_multiple<\/code> to the arguments received. That _lowest_common_multiple<\/code> function, receives 2 arguments, and as you see it calls greatest_common_divisor<\/code> to divide a * b<\/code>, and greatest_common_divisor<\/code> is a recursive function which uses the Euclidean algorithm<\/a> to return the greatest common divisor.<\/p>\nlowest_common_multiple(6, 1, 6) # 6\r\nlowest_common_multiple(2, 4, 6) # 12\r\nlowest_common_multiple(10, 8) # 40\r\nlowest_common_multiple(5, 9, 3, 7) # 315\r\n<\/pre>\n
<\/a>4. Data Structures<\/h2>\n
arrays<\/code> in Python work just as lists do. It will show you something actually new, but that is very familiar to you at this point. Also, the practice is never enough.<\/p>\ndef solution(array):\r\n my_dict = {}\r\n for i in array:\r\n my_dict[i] = my_dict.get(i, 0) + 1\r\n for key, value in my_dict.items():\r\n if value % 2 > 0:\r\n return key\r\n return None\r\n<\/pre>\nreturn None<\/code> will never execute. As you may know at this point, dictionaries are indexed, so they are a good option when you want to check some data that you will infer from iterating over an array without adding time complexity to your solution. And that’s what I did, I iterate over the array, and increase a counter for every number I find in the array, at last I iterate over the dictionary and return the number that appeared an odd number of times.<\/p>\nget<\/code> and items<\/code> methods that dictionaries provide, and the fact that they are indexed.<\/p>\ndef solution(array):\r\n first_part = array[0]\r\n second_part = sum(array[1:])\r\n min_absolute_difference = abs(first_part - second_part)\r\n for i in range(1, len(array) - 1):\r\n first_part += array[i]\r\n second_part -= array[i]\r\n new_absolute_difference = abs(first_part - second_part)\r\n if new_absolute_difference < min_absolute_difference:\r\n min_absolute_difference = new_absolute_difference\r\n return min_absolute_difference\r\n<\/pre>\n
min_absolute_difference<\/code> which is updated every time I find a difference smaller than the actual value and after I iterate over the whole array, I return it. As you see, I’m exploiting the capabilities of slicing arrays and a couple built-in functions.<\/p>\ndef solution(array):\r\n my_dict = {}\r\n max = 0\r\n for i in array:\r\n my_dict[i] = True\r\n if i > max:\r\n max = i\r\n for i in range(1, len(array) + 1):\r\n if not my_dict.get(i):\r\n return i\r\n return max + 1\r\n<\/pre>\n<\/a>5. Object Oriented<\/h2>\n
_thread<\/code> module, which is no longer used after Python 2.4. Then it will walk you through the newer threading<\/code> module.<\/p>\nfrom threading import Thread\r\nfrom time import sleep\r\nfrom types import FunctionType\r\n\r\nimport datetime\r\n\r\n\r\ndef asynchronous_task(callback: FunctionType):\r\n sleep(3)\r\n callback()\r\n\r\nstart_time = datetime.datetime.now()\r\nt1 = Thread(target=asynchronous_task, args=[lambda: print(\"first task is done\")])\r\nt2 = Thread(target=asynchronous_task, args=[lambda: print(\"second task is done\")])\r\n\r\nt1.start()\r\nt2.start()\r\n\r\nt1.join()\r\nt2.join()\r\n\r\nend_time = datetime.datetime.now()\r\nprint(\"job done in {}\".format(end_time - start_time))\r\n<\/pre>\nsecond task is done\r\nfirst task is done\r\njob done in 0:00:03.003682\r\n<\/pre>\n
print<\/code> is not the best option to show information about your program. When you have an application that it is not you the one that uses it, most of the time you’ll need something that tells you what the application is doing, how, how long does it take it, if it fails and if it does why. The logging<\/code> module provides a pretty straight forward solution to this problem, and you will find that it is quite easy to make your application log.<\/p>\n<\/a>6. Getting Serious<\/h2>\n
<\/a>7. Conclusion<\/h2>\n