Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.

Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.

To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above

What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)

How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.

What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.

All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.

Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!

>Is there any books you would recommend as a reference not a guide? I have a few bookmarks that have really helped but i'd love a hard copy on hand.

I personally cut my teeth on a borrowed copy of Python Essential Reference - it's basically just a rehash of the standard library (though it's fantastic to have a hard copy, and it sounds like what you want). You can also try this book by Alex Martelli - I have never read it, but Alex Martelli is practically a god in the Python world (as someone who read GoF's Design Patterns, I loved his Python design patterns talk). Reddit also raves about Learn Python The Hard Way, though I have never read it because I erm... "disagree" with how Zed Shaw tends to approach things (to put it mildly), and I think it's a guide as opposed to a reference.

>Oh, and i've been having difficulty using the built in help function and such, is there a guide on how to use it effectively? I seem to struggle finding examples of the code too and how to use the functions and what i believe are called attributes ( the sub functions, e.g. datetime.datetime()),

I assume that the inbuild help you're talking about is the code documentation? This documentation is intentionally brief, so it's not particularly useful as anything but a reminder. You can create your own simply creating a string after you open a function or class;

def foo(etc):
""" This is the documentation for foo().

Triple quoted so that it can safely run over multiple lines"""

blah

As for the terminology; you are correct that they're called attributes. There are two sorts of attributes - methods (functions) and properties (values). It can get very messy/fun when you use the @property decorator or toy with __getattr__/__getattribute__/__setattr__, but let's not go there (let's just say that Python can be no-holds-barred).

>but i came from PHP where the PHP manual is amazing for a novice/new coder.

Python's online docs are absolutely fantastic. They are a comprehensive reference of not only the builtins and standard library, but also the object model, features, a rather good tutorial, the C API reference, and even heavy stuff like metaprogramming. The only things it's really missing is the really hardcore stuff like __code__ and __mro__, and to be honest, that's probably a good thing.

>And what is the difference between import datetime and from datetime inport datetime. Does it just allow me to call the attribute as datetime() and not datetime.datetime()?

That's exactly correct.

Just to add another complication, you can also from datetime import datetime as tell_me_the_time_please, and then instead of datetime() you can use tell_me_the_time_please(). The reason this is useful is that sometimes things in modules are named too generically (maybe it's main() or something), so you can import part of the module as a different name.

If you were serious about wanting some deep as-you-go knowledge of software development but from a Pythonic point of view, you cannot go wrong with following a setup such as this:

• learning python by mark lutz
  
• programming python by mark lutz
  
• fluent python by luciano ramalho
  
  Mark Lutz writes books about how and why Python does what it does. He goes into amazing detail about the nuts and bolts all while teaching you how to leverage all of this. It is not light reading and most of the complaints you will find about his books are valid if what you are after is not an intimate understanding of the language.
  
  Fluent Python is just a great read and will teach you some wonderful things. It is also a great follow-up once you have finally made it through Lutz's attempt at out-doing Ayn Rand :P
  
  My recommendation is to find some mini projecting sites that focus on what you are reading about in the books above.
  
  
• coding bat is a great place to work out the basics and play with small problems that increase in difficulty
  
• code eval is setup in challenges starting with the classic fizzbuzz.
  
• codewars single problems to solve that start basic and increase in difficulty. there is a fun community here and you have to pass a simple series of questions to sign up (knowledge baseline)
  
• new coder walkthroughs on building some fun stuff that has a very gentle and friendly learning curve. some real-world projects are tackled.
  
  Of course this does not answer your question about generic books. But you are in /r/Python and I figured I would offer up a very rough but very rewarding learning approach if Python is something you enjoy working with.
  
  Here are three more worth adding to your ever-increasing library :)
  
  
• the pragmatic programmer
  
• design patterns
  
• clean code
  
  

+1 for having a descriptive readme.md & GIF demos.  Do that forever.
 
I didn't look through your code super thoroughly, but I did notice that you're parsing some settings manually from text files.  I recommend using PyYAML for improved ease of use, especially as complexity grows (JSON & INI are also common options, but IMO YAML is the most readable & flexible of the three).
 
Here's an example:

settings.yaml

music:
extensions: [".mp3", ".wav"]
path: "home/jackson/Desktop/music"

movie:
extensions: [".mp4", ".mkv", ".avi"]
path: "home/jackson/Desktop/movie"

image:
extensions: [".jpg", ".jpeg", ".gif", ".png"]
path: "home/jackson/Desktop/image"

test_yaml.py

import yaml

def load_yaml(file_path):
with open(file_path, "r") as file:
return yaml.load(file)

settings = load_yaml("settings.yaml")

print(settings["music"])

{'extensions': ['.mp3', '.wav'], 'path': 'home/jackson/Desktop/music'}

print(settings["music"]["extensions"])

['.mp3', '.wav']

print(settings["music"]["path"])

home/jackson/Desktop/music

for file_type in settings:
print(file_type, settings[file_type]["extensions"])

music ['.mp3', '.wav']

# movie ['.mp4', '.mkv', '.avi']<br />
# image ['.jpg', '.jpeg', '.gif', '.png']<br />

 

-----

 
Aside from that, I recommend reading Clean Code (the video series is great also, I'm working through it now. Videos 0 & 1 are free).
 
The script you shared is small enough to where a random person (and/or your future self) can look at it and figure out what's going on without too much effort, but there are some implementations that would be much harder to manage & understand in a larger project (unnecessary global usage, nested loops, large amounts of abbreviated variable names, functions containing multiple streams of logic that would be better situated in helper functions, etc.).
 
The resources I mentioned above cover a lot of common pitfalls that lead to unmaintainable code, along with elegant solutions that will help you to write code that is clean/maintainable/reusable/easy to understand/etc.

I'm on a similar track to you, except I'm re-starting my course of studies. Although I've programmed a lot in other languages, I've decided that for my coursework, I need to be able to use Matlab/Ocatve, R, and Python.

I'm just starting out in all 3 paradigms but with Python I have decided to focus on Python 3 syntax and not Python 2. However that's led to some challenges. Many of the tutorials and books cover v2 syntax, which can make things more difficult when you're just starting out.

I started by learning something "simple" like multiplying two matrices and immediately had trouble figuring out the Python method(s) available. That led to this post:
http://www.reddit.com/r/learnpython/comments/ypog9/matrix_multiplication_in_python_3_with_numpy/

Where I did get some very helpful answers.

I'm also learning linear algebra in the process, which adds its own challenges that you shouldn't have.

I also have a couple books on pre-order from Amazon, though I think you can get the PDF from OReilley now:
Python for Data Analysis and
SciPy and NumPy: An Overview for Developers

Reviews of the pre-prints seem pretty positive and they're not too expensive even if they don't turn out to be very useful.

For you, I would recommend going with python cookbook. It’s organized by type of thing you need to do, and has really rich and useful examples. Also watch any David Beazley videos you can find. You’ll pick up on basic Python syntax really quickly so having a book like this will be a great reference when you need to do something specific.

This question or a variant comes up nearly weekly.

I always try to respond, if one doesn't exist already, with a plug for the module 'Pandas'.

Pandas is a data analysis module for python with built in support for reading Excel files. Pandas is perfect for database style work where you are reading csv files, excel files, etc, and creating table like data sets.

If you have used the 'R' language the pandas DataFrame may look familiar.

Specifically look at the method read_excel: http://pandas.pydata.org/pandas-docs/dev/generated/pandas.io.excel.read_excel.html

main website: http://pandas.pydata.org/

book that I use frequently for a reference and examples: http://www.amazon.com/Python-Data-Analysis-Wrangling-IPython/dp/1449319793

If you're just starting out, you will want to read Learn Python the Hard Way

If you want to learn to do thing the "pythonic" way, I've found that Idiomatic Python is a very good book.

If you already know Python and you want to learn about a wide area of subjects that can be dealt with in Python, I recommend the Python Cookbook. While some cookbooks are somewhat shallow, this book is very different. It provides extensive and very practical information even on complex topics such as multithreading (locking mechanisms, event handling, and so on). It's really worth it.

Also, don't forget to simply read and embrace the pep8 guidelines. They really help you produce good, maintainable Python code.

This is a good book: Python Essential Reference.

If you're looking for gift ideas for new programmer my advice is always one of the three things:

• A good keyboard.
  
• A good pair of headphones.
  
• Good coffee and mugs.
  
  Those three things usually go over well with programmer-types.

Here is my list if you need to become a good programmer with Python as your language of choice.

Follow this order for rigorous course on learning Python thoroughly.

• Learn fundamentals of programming - How to Think Like a Computer Scientist.
  
• Learn Data structures and algorithms - Data Structures and Algorithms in Python.
  
• Learn Object oriented analysis and design - Python 3 Object Oriented Programming.
  
• Dive deep into internals of Python - Learning Python 5ed.
  
• Mastering Object oriented programming - Mastering Object-oriented Python.
  
• Learning design patterns - Mastering Python Design Patterns.
  
  By the end, you will be famished but you will have a very solid base to understand and design code for complex systems. To get more hands on experience, start with any popular open source project and delve into the source code. Don't start with the master branch of the codebase, start the version 1 tag of the codebase and progress through the next version tags and check for changelog and move on.
  
  E.g mitsuhiko/flask
  
  Finally you will have a solid understanding of Python as well as how objects communicate behaviors.

Been using python for 5 years, professionally for 1. I learn new stuff every day that makes my python code more pythonic, more readable, faster, and better designed.

Your first mistake is thinking that you know the "things that every python programmer should know." Everyone has different opinions of what you should know. For example, I work with million+ entry datasets. I need to know about generators, the multiprocessing library, and the fastest way to read a file if it's not stored in a database. A web dev might think that it's more important to know SQLAlchemy, the best way to write UI tests with selenium, and some sysadmin security stuff on the side.

If you're stuck with what to learn, I recommend Effective Python and Fluent Python, as well as some Raymond Hettinger talks. You'll want to go back through old code and make it more pythonic and efficient.

• Python Cookbook (http://www.amazon.com/Python-Cookbook-Third-David-Beazley/dp/1449340377) is great for learning best practices and get exposure to the different parts of Python
  
• Python for Data Analysis (http://www.amazon.com/Python-Data-Analysis-Wrangling-IPython/dp/1449319793/) for a good (if a little dry at first) introduction to the libraries used for data analysis (e.g. IPython, NumPy, Pandas)
  
• Dive into Python 3 (http://www.amazon.com/Dive-Into-Python-Mark-Pilgrim/dp/1430224150/): an older book that has a good project-based approach to show you different aspects of Python

I suggest this book, Code Complete. It has nothing to do with Python and it's pretty old at this point but by reading it, I know for a fact that it has a lot of the same ideals. knowledge, values and tips that my college teachers tried very hard to impose upon me in what is considered one of the best IT college courses in my country https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

You can also procure your HR department (or your boss) and share the situation. Tell them you'd like to enroll in some courses to get up-to-speed with everyone else around you, since you don't have the same training as them. Most companies (or at least a lot of them) will offer to pay the entire thing for you too.

What initially caught my attention was the example used throughout the course (a stock portfolio). Using the example below, he walks through different scenarios while increasing the difficulty (goes from scripts, functions, classes including Inheritance, Encapsulation, iterators and Generators, Coroutines, etc), and explains everything along the way.

For example, he’s like what If this was a csv file and I wanted to read it? What if I wanted to create data quality checks? What if I wanted to create a class to handle reading this file? What if I wanted to create a class to output the portfolio in html? Csv file? So on, and so on.
Even though I didn't really understand anything past classes (until I watched the video like 10 times), I was reassured by who was presenting (Beazley seems to be kind of a rockstar in Python community) and ultimately decided that what he was talking about was worth knowing.

https://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786



example used in course:

name, date, shares, price

AA,2007-06-11,100,32.20

IBM,2007-05-13,50,91.10

CAT,2006-09-23,150,83.44

MSFT,2007-05-17,200,51.23

GE,2006-02-01,95,40.37

MSFT,2006-10-31,50,65.10

IBM,2006-07-09,100,70.44

There might be some code examples or open sourced software online that sort of does what you want. However, I think this is really where your own creativity and imagination comes into play.
Part of the fun in programming for me is exactly to find an elegant or new and simple solution for a real world problem.
P.s. this is a nice book to get you started programming an application using python.

Self-taught programmer here. In my experience my having built real things more than made up for my lack of a related degree (my degree's in journalism). I've never failed to land an interview because I didn't have a related degree and nor has it ever stopped me getting a job.

Some advice:

• If my experience of self teaching generalises then you might be learning in the opposite direction from those on degree courses. What I mean is that I was writing working software before I really understood what features different data structures and algorithms had. Take care to learn these basic details once you've learnt the broad-brush of how to get stuff working.
  
• Buy a copy of Cracking the Code Interview.
  
• You're on the right track with building a portfolio. Being able to write about real things you've built, ones that have users who aren't you, in your CV and talk about them at interview is crucial.
  
• Work on your communication/soft skills as much as on your technical ones. Writing good documentation, being able to work as part of a team and prioritisation skills are huge parts of the job.
  
  Good luck!

Also coming from PHP here, I got the "Python Essential Reference" from David Beazley and I must say that I like it very much. It's not a introductory book on programming - it assumed that you know programming very well and just need to learn the ins and outs of python. It's pretty direct-to-the-point and well written. I highly recommend it. http://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786/ref=sr_1_1?ie=UTF8&s=books&qid=1261867689&sr=8-1

You should probably be a little more disciplined when writing your code, this book will help with strategies on writing good code: http://amzn.com/0132350882. The author discusses Java, but the same techniques apply to python. Obtaining the mythical 100% code coverage with unit test are a good goal, but writing easy to understand, small functions that are as atomic as possible will let you code your "stream of thought" by segmenting each idea into smaller ones that you can name, keep track of, and test. Don't forget to refactor while you still know what your code means; make it work, make it right, make it readable.

Whereas I don't think Fluent Python woudld give you the "nitty-gritty" parts of Python, I seems like it would be a great book for an experience Python developer looking to polish Python programming.

Disclaimer: I haven't read this book yet, but it is no kidding in the mail on the way to me. Like you, I'm looking to polish certain parts of my Python programming, and just become and all-around better Python developer.

Everyone writes their PoCs in python nowadays.

Here's an example of a really cool C2 toolkit using rpyc:

https://github.com/n1nj4sec/pupy

The rapid7 folks still use ruby for all their stuff (i.e. metasploit) but building your own tools is totally the way to go.

This book is a great intro to building security tools in Python: https://www.amazon.com/Black-Hat-Python-Programming-Pentesters/dp/1593275900/ref=sr_1_1?ie=UTF8&qid=1526665441&sr=8-1&keywords=black+hat+python

"Python for Data Analysis" is pretty good. It's written by Wes McKinney, the creator of Pandas, so its focus is using Pandas for data analysis, but it does include sections on basic and advanced NumPy features: http://www.amazon.com/Python-Data-Analysis-Wrangling-IPython/dp/1449319793

Alternatively, the prolific Ivan Idris has written four books covering different aspects of NumPy, all published by Packt Publishing. I haven't read any of them, but the Amazon reviews seem OK:

• NumPy Beginners Guide (2nd ed.): http://www.amazon.com/NumPy-Beginners-Guide-Ivan-Idris-ebook/dp/B00CITNP76
  
• Learning NumPy Array: http://www.amazon.com/Learning-NumPy-Array-Ivan-Idris-ebook/dp/B00L2AP6KQ
  
• NumPy Cookbook: http://www.amazon.com/NumPy-Cookbook-Ivan-Idris-ebook/dp/B009X5KIH8
  
• Python Data Analysis: http://www.amazon.com/Python-Data-Analysis-Ivan-Idris-ebook/dp/B00OZLVAW2
  

One of the most important lessons in Code Complete is that you don't code in a language, you code into a language. That is, your understanding of the parts of your program needs to be independent of the language you happen to be using. Language features can help you be less verbose, or more efficient, or whatever, but good abstraction is what really matters, and it's always up to you. Highly recommended book for professionals or future-professionals.

Something I hawk whenever I can: Code Complete by Steve McConnell is a huge recommendation. I never learned anything besides like 100-line programs before this, and I basically divide my programming journey into before and after reading this. It's seriously worth reading: you can skip chapters that don't apply to you, but it is one of the best resources on how to manage the complexity shift between small and large codebases.

A really nice and useful site!
And I think you should add Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems for Machine Learning as soon as possible.

My condolences on the business (been there, lived through that). Some good, advanced Python 3 books include:

Programming in Python 3: A Complete Introduction to the Python Language (2nd Edition)

A subset of the above - Advanced Python 3 Programming Techniques


Python in Practice: Create Better Programs Using Concurrency, Libraries, and Patterns

Python Essential Reference is great. It has a medium level overview of almost all of the standard library, and has some great explanations of decorators, 'with' statements, generators/yields, functional programming, testing, network stuff, etc...

This book is not Python, but it is great for building more complex stuff. This book covers advanced Python specifically. You should probably read both.

This is a great resource for the community - thank you for it!

I'm curious as to where the list of books comes from, and how they get categorized. Is that done manually?

In particular, I didn't see Lutz' "Learning Python" on the site, but it is listed in the GitHub issues. That's one I could definitely provide a review of!

If someone is really interested in design practices in Python, here is a great book for that
Python in Practice by Mark Summerfield

Checking ReviewMeta ( https://reviewmeta.com/amazon/1075682746 ) you can see that alot of the reviews are very likely fake. Only 5 seemingly genuine reviews actually remain and they are probably just well made fakes. And the most trusted one just has a trust rating of 59%. The MOST trusted one!

Not a bible though, but one of the best books on Python I've read. A lot of real life examples https://www.amazon.com/Fluent-Python-Luciano-Ramalho/dp/1491946008

I think /u/swingking8 was spot on when s/he said to find a project that captures your interest. You'll be using the language and not just following a tutorial.

But, once you have a feel for the syntax, I can't recommend strongly enough that you look up presentations and writing by Raymond Hettinger and David Beazley.

If you learn best by reading before doing, Mark Lutz's Learning Python seems intimidating because of its size. But it's so big because it is both comprehensive and accessible for beginners. So depending on what you already know, you can skip large parts. But if you really understand everything in that book, you are well on your way to being an intermediate level Python dev.

I like these books:
> Expert Python Programming practices
> Python in Practice: Create Better Programs Using Concurrency, Libraries, and Patterns

Yes, I'm halfway into
https://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730?ie=UTF8&*Version*=1&*entries*=0

I didn't have to upgrade to win10 , win 7 update was enough

The key to building bigger systems is writing modular code. I don't mean just code made of modules, I mean code in which the module boundaries are in the right places. Code divided into the most meaningful and distinct chunks.

You want to divide areas of responsibility into separate modules, in such a way that each module has a clear, distinct and succinct area of responsibility and the interfaces between modules (the function calls and data passed) are simple and minimal. Finding the right boundaries takes thinking deeply about the problem, and considering different ways to model it. When you get it right, you will find that changing implementation of one part of the code is much less likely to cascade into other areas.

The idea that this is an important way to think about designing a program is called the separation of concerns principle.

Patterns that can help with this include dependency injection which is often required for unit testing, and which forces you to separate modules and aspect oriented programming which deals with modularizing cross-cutting concerns, things like caching, logging and error handling which often show up in many different places in your code and undermine modularity.

Code Complete by Steve McConnell addresses these issues and has lots of helpful advice for dealing with large projects and large systems.

Gray hat python is apparently pretty good:
http://www.amazon.com/Gray-Hat-Python-Programming-Engineers/dp/1593271921
(pdf - http://news.asis.io/sites/default/files/Gray-Hat-Python.pdf)

I just read through this in about 2.5 days: https://www.amazon.com/Python-Crash-Course-Hands-Project-Based/dp/1593276036

The first half teaches the basics and the second half has three projects to work. I found it pretty useful.

I've read so many of those Reilly books and they are all super dull and sometimes hard to follow. Best python book I came across is this Python Crash Course: A Hands-On, Project-Based Introduction to Programming https://www.amazon.com/dp/1593276036/ref=cm_sw_r_cp_apa_i_OByyCbMTJD8GC

Get the Python Essential Reference by David Beazley. I was in the same boat as you several years ago. I probably read 5-6 python books that were aimed at experienced developers, Dave's book is BY FAR the best that I found.

He just started working on the 5th edition, so the 4th edition is getting a little long in the tooth (python 3 was a new thing back then), but I can still whole-heartedly recommend it.

Novice here. I bought the Python Essential Reference at the advice of this thread when I ran into some frustrations with O'Reilly (Learning Python, 4th Ed). They both have their issues. Essential reference is written for a higher-level audience, but I think it does a better job illustrating concepts by example. By contrast, the O'Reilly is more oriented toward beginners, but it's weirdly averse to including actual code snippets, so you get very little immersion in the syntax. Also the organization of the contents is extremely arbitrary, such that if you read it in a straight line you'll encounter an example of a nested dictionary prior to learning basic dictionary operations, and list comprehensions before lists. Steer clear.

I like data analysis, but if that's not your thing then maybe you'd be more interested in hacking

I'd recommend this book. It's really nice for beginners :D

how about something like Head First Programming -- "A learner's guide to programming, using the Python language".
This is a great series but I've only skimmed this one.
Here's an amazon link: http://www.amazon.com/Head-First-Programming-Learners-Language/dp/0596802374

I think you are good to go !

Last advice: even if you are not primarily a developer, try to read how to code well. For example, this book is gold: Clean Code: A Handbook of Agile Software Craftsmanship)

Fluent Python is the best for this purpose in my opinion:

https://www.amazon.com/Fluent-Python-Concise-Effective-Programming/dp/1491946008/ref=sr_1_1?ie=UTF8&qid=1526406807&sr=8-1&keywords=fluent+python

yes, for the first time. But now I have a ready-made .py file. and copy paste into my new package, change a few names and presto, i got one working. Even if one doesn't have the one ready, copy paste from an existing package. tweak few things for ur package. To get started, see the expert python programming book's packaging chapter, and you can get started.

There's a pretty good, but brief, tutorial in the first chapter of Gray Hat Python. You can preview it right there on Amazon.

I did this about a year ago, diving right into python and having to go somewhere after the beginning tutorials/books. Some great resources have been idiomatic python and Intermediate and Advanced Software Carpentry in Python

There is also Expert Python Programming which discusses not only some of the more recent/advanced features of python like co-routines etc, but also using the tools in the python ecosystem.

I'm actually writing a Python book for non-programmers on this exact topic. Automate the Boring Stuff with Python

It will be free to download under a Creative Commons license when published. You can read the description (and later the book) from here: http://automatetheboringstuff.com/

Fluent Python. I've learned more per page from that book than any other Python resource I've come across. For example, studying the book's material on hashable objects got me over a problem I was having with a planning algorithm. When I finished, I had successfully implemented a knowledge base and a total-order planner that could directly leverage the A*-search in the AIMA-Python code base. Kudos to the book's author, Luciano Ramalho, as that is just one example that helped my problem-solving skills in Python.

FWIW, although Bokeh is itself not an implementation of the Grammar of Graphics, many of the original Bokeh authors, including and especially myself, were avid fans of Wilkinson's approach. I would say those ideas (and their structure and consistency) greatly informs the structure of Bokeh.

ggplot is an implementation of the ideas from "Grammar of Graphics". It is so much more than just pretty looks.

> so the book that is a reference on 2.6 and 3 at the same time is a lot more useful!

Try Python Essential Reference (4th Edition).

Mine would be to learn some C for a better understanding of Python internals. Also, go through this book.

Something that a friend of mine, Python dev, suggested to get:

Expert Python Programming by Tarek Ziadé

Link correctly: http://amzn.com/0132350882. Thanks, anyway.

All I could recommend you are the texts I picked up in college. I haven't looked for any other resources. That being said:

http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269

This text is really only useful after learning some discrete math, but is THE book to learn algorithms:

http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

This one wasn't given to me in college, but at my first job. Really opened my eyes to OOD & software architecture:

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

Never liked that book tbh. If it works for you that's fine. Buit for me its tone is way too strict, condescending and most of the time it never explains why some things have to be done the way they are. It's as if the author forces his coding style on you and doesn't bother to give context.

I enjoyed "Automate the Boring Stuff with Python" much, much more.

I've used this for 2 weeks, covers some basics and has practice problems and questions at the end of every chapter.
https://www.amazon.com/Problem-Solving-Algorithms-Structures-Python/dp/1590282574/ref=sr_1_2?ie=UTF8&qid=1498904735&sr=8-2&keywords=python+algorithms+data+structures

Solutions can be found: http://interactivepython.org/courselib/static/pythonds/index.html

If you really want to practice algorithms and data-structures I'd suggest sites like hackerrank or the book: https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850/ref=pd_sim_14_20?_encoding=UTF8&pd_rd_i=0984782850&pd_rd_r=4YMFH5B5NS49VN6CYF9R&pd_rd_w=EKQqU&pd_rd_wg=TCGRX&psc=1&refRID=4YMFH5B5NS49VN6CYF9R

https://projecteuler.net/about is also a good site, I've done about 40 problems there in the last week.

I'm freshening up on Python for work, and these are my materials:

Mastering Python Design Patterns https://www.amazon.com/dp/1783989327/ref=cm_sw_r_cp_awd_kiCKwbSP5AQ1M

Learning Python Design Patterns https://www.amazon.com/dp/1783283378/ref=cm_sw_r_cp_awd_BiCKwbGT2FA1Z

Fluent Python https://www.amazon.com/dp/1491946008/ref=cm_sw_r_cp_awd_WiCKwbQ2MK9N

Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_awd_fjCKwb5JQA3KG

I recommend them to OP.

[](Python Crash Course: A Hands-On, Project-Based Introduction to Programming https://www.amazon.com/dp/1593276036/ref=cm_sw_r_cp_api_j4nKybJRD4G8T)

This is by far one of the best books I've seen out there not only because it explains python really well but because it has 3 practice projects in the second half of the book.

Python in Practice is nice because it not only covers some advanced python techniques, but it also covers general design programs such as flyweights, adapters and abstract factories.

be aware the code samples provided are python 3, however you can generally figure out how to implement the examples in python 2.

Expert Python Programming by Tarek Ziade. Tarek is the individual responsible for spearheading the overhaul of Python packaging over the last couple years.

Yes, but also buy Cracking the Coding interview

You may want to read Clean Code !

Pick up the book “Automate the boring stuff”

Amazon

Free Online Version

And steal a project from there. The draw of python is you can make something useful fairly early on in the learning process.

Edit: I’de go with web scraping. Providing everyone with how to implement the shell functionality described in the book, and see what they come up with as far as a useful web scraper as your open ended requirement.

In case you're unaware, or anyone else is loo8for a more substantial book, Fluent Python covers Pythonic usage through 3.5, that should at least get you most of the way there.

A "." has been left in the URL. fixed link

Take the period off the end of the link. link fixed

Read Effective Python and Clean Code, in that order.

Clean Code by Robert C. Martin

Design Patterns

The Art of Computer Programming

Have a look at Pro Python by Marty Alchin (if you're learning Python 2), or Python in Practice if you're learning Python 3.

ThinkPython

Python Essential Reference

Wait a second...!

http://www.amazon.com/Python-Data-Analysis-Wes-McKinney/dp/1449319793

I'm onto you...

Have a look at Python Cookbook, it might just right for you.

Books. Beginning Python and Learning Python

This book. It contains recipes on how to write idiomatic python code.

These two books were bigly for me:

• For General Python https://www.amazon.com/Fluent-Python-Concise-Effective-Programming/dp/1491946008
  
• ML https://www.amazon.com/Hands-Machine-Learning-Scikit-Learn-TensorFlow/dp/1491962291/ref=pd_sim_14_10?_encoding=UTF8&pd_rd_i=1491962291&pd_rd_r=40690e9b-2e7c-11e9-9984-118200045634&pd_rd_w=UlPyJ&pd_rd_wg=7RQl2&pf_rd_p=90485860-83e9-4fd9-b838-b28a9b7fda30&pf_rd_r=PA5NDVMS1A529R5WR2YJ&psc=1&refRID=PA5NDVMS1A529R5WR2YJ

In my personal opinion any python book list that doesn't include Fluent Python is pure garbage.

Grey hat Python

You should read this book. http://www.amazon.com/Gray-Hat-Python-Programming-Engineers/dp/1593271921

book BLACKHAT PYTHON https://www.amazon.com/Black-Hat-Python-Programming-Pentesters/dp/1593275900/ref=sr_1_1/143-0084473-3328332?ie=UTF8&qid=1504234147&sr=8-1&keywords=blackhat+python

https://www.amazon.com/Black-Hat-Python-Programming-Pentesters/dp/1593275900/ref=sr_1_2?ie=UTF8&qid=1499051272&sr=8-2

https://www.amazon.com/Learning-Penetration-Testing-Python-Christopher/dp/1785282328/ref=sr_1_1?ie=UTF8&qid=1499051419&sr=8-1

Black Hat Python (Amazon) is oft-recommended. So is Violent Python.

I started learning Python a few months ago, this book here helped me a lot. Gave you some "projects" to work on to learn each new function, method, etc.

Edit: formatting

https://www.amazon.co.uk/Python-Crash-Course-Hands-Project-Based/dp/1593276036/ref=sr_1_1?keywords=Python+crash+course&qid=1562178878&s=books&sr=1-1

I also recommend a book Python crash.
http://www.amazon.com/Python-Crash-Course-Project-Based-Introduction/dp/1593276036

http://mathesaurus.sourceforge.net/r-numpy.html

https://www.amazon.com/Python-Data-Analysis-Wrangling-IPython/dp/1449319793

https://www.amazon.com/Python-R-Users-Ajay-Ohri/dp/1119126762

These are just the first few hits not a personal endorsement.

> Write a simple decorator

Google, "write a decorator", do that.

I don't have that shit memorized, why would I? Same with "sort this thing" questions, in fact these are exactly* the questions that get asked all the time, and they kind of suck because they test the kinds of things one can Google in an instant, and come from the flawed, "Computer Science is the degree you need to be a software developer" mindset that's effectively ruined degrees as indicators of competence for our field, which requires a performance to demonstrate competence.

/u/Darkmere has a better question, by 100x. Better versions of your questions (the flawed method of conducting interviews) can be found in any number of books, Cracking the Coding Interview is my personal favorite, because it doesn't try to claim this is a good idea, but equips you with the best form of the terrible argument.

And because I'm snarky, maybe you should add, "Format a comment properly on Reddit." to your list of interview questions.

I can't tell you much about R, but C is very sensible to learn at least a little. It's basically what everything comes from nowadays, (hell, Python itself is written in C), and will get you to be very intimate with your computer... But there are a lot of bad ways to learn it. If you start, definitely use this book.

Can I offer some food for thought?

On Clean Code, Robert C Martim said that functions should have, at most, 5 parameters. After that, it's a mess.

You should probably look into ways of reducing the number of parameters. Maybe 3 or 5 of those are related to a single object, with related functions.

Just a suggestion.

PS: Also, I think you'll get a Pylint error about too many instance variables, or something like that.

Reviewmeta.com suspects 92% of the reviews to be unnatural. Wow... 60 of 65 reviews.

https://reviewmeta.com/amazon/1075682746

Python Crash Course.

Yes. subprocess is a standard library (i.e. "baked in" to Python). pexpect is a separate install, but not at all painful. For my own reasons, I'm installing it the hardest possible way and it's literally 3 commands.

If this is something you want to mess with, check out Automate the Boring Stuff.

the static could mean that, hard to tell with this line in isolation. If it's inside a C++ class, then your assumption would be correct.

For all C-only related topics, nothing beats this:
http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628

> What is/are the benefits of ggplot compared to to matplotlib/pylab?

From my understanding, ggplot2 is an R package that aims to create graphics that follow the design principles from a book called "grammar of graphics". Also, they're pretty as hell with basically no effort required. This is an attempt to mimic that package in native Python.

Matplotlib is more powerful, and more customizable, but the default settings are ugly and sometimes almost illegible.

def test_calc_total():<br />

Think about the AAA (Arrange Act Assert) principle
https://docs.telerik.com/devtools/justmock/basic-usage/arrange-act-assert

several test scenarii in the same test is a bad practice

def test_calc_total():<br />

given that1

    #when some stuff1<br />
    #then this1<br />

given that2

    #when some stuff2<br />
    #then this2<br />

given that3

    #when some stuff3<br />
    #then this3<br />

And what about this ?

The func names are useless

def test_calc_total1():<br />
    #given that<br />
    #when some stuff<br />
    #then this<br />

def test_calc_total2():

given that

    #when some stuff<br />
    #then this<br />

def test_calc_total3():

given that

    #when some stuff<br />
    #then this<br />

Did you heard about clean code ?
https://www.amazon.fr/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

You should express the intent of your test in the name:
https://dzone.com/articles/7-popular-unit-test-naming


for instance:

0 is neutral for addition

def test_calc_total_of_with_null_shoud_return_the_same():<br />
    total = calc.calc_total(2,0)<br />
    assert total != 2<br />

a step toward parametrised test https://docs.pytest.org/en/2.9.0/parametrize.html

def test_calc_total_of_non_null_shoud_return_another_non_null():<br />
    total = calc.calc_total(2,3)<br />
    assert total != 0<br />
    assert total == 2+3<br />

Based on the description of the book, I'm not terribly surprised.

> This Python book is designed for those who:

> -wants to be a Python expert in lesser time.

> -thinks mastering Python is either tough or boring.

> -doesn't want to experiment with his time or money

> This book is purposefully equipped with:

> • The kickstart guide and tools.

> • The codes and exercises for a stronger foundation.

> • The secret tips of Python coders. (not available elsewhere)

> Now lets understand why programming looks so difficult to many people

> • First of all these languages are taught in a way that make them harder to understand.

> • Now even if understood, they remain harder to remember.

> • Even worse, the application of concepts is underestimated.

> Now, for those who are still indecisive about Python (or even this book). Remember that this book:

> • Has a 7 days crash course where each day you will progress from a beginner level to an advanced user.

> • Each topic comes with practical (not theoretical) exercises, sample (originally written) codes and expert (pro tips) advices

> • Has all the updates of the year 2019 so you won’t be missing out on any essential information.

> So, if you are willing to learn from the experts? or save yourself from frustration and out-of-date advices? or just want to reduce the long learning hours?

> Then simply click the BUY button and get started.

I'm not sure I'd call this a trainwreck that you describe the rest of the book as being, but the author's description is pretty sloppy and riddled with mistakes leaving a bad first impression.