If you’re subscribed to the RSS feed here, please visit the new site and add my latest RSS feed to keep getting updates.

Thank you!
Michael

We have been growing for over 5 years since we launched. Today we passed a major milestone in the podcast and I’d like to write this post just to share my excitement and to take a moment to appreciate the journey.

Today, Talk Python To Me has had over 20,000,000 downloads. That’s an average of just under 70,000 listeners per episode.

You can see how we fit in the podcast world by checking out the iTunes rankings (broader than just Apple as many players use this data). If you check Chartable (at the time of this writing), we are #37 of all technology podcasts. I kind of hate this category as it’s way too broad. But if you factor out general tech and gaming of the 36 above us, you’ll see we are the #2 developer podcast in the world. Only Wes Bos’s JavaScript show is ahead.

https://chartable.com/charts/itunes/us-technology-podcasts

Thank you everyone who has subscribed to the show via their podcast players. If you’re not yet a listener, just search for Talk Python in your favorite podcast app and get weekly episodes for free.

20 million. That’s amazing folks. Let me measure that with a few different metrics. 20,000,000, 1-hour long, 35 MB mp3 downloads is

• Like spending 8-years worth of time with listeners every week for 5 years or 23 centuries together.
• Giving 20 PyCon keynotes every week or 5,800 keynotes in total.
• 684,000 GB of traffic sent out of our modest Ubuntu box.
• A opportunity to make Talk Python my full time job and focus 100% on building it for you all.

So to everyone who has listened to one or more episodes. Thank you for helping us achieive this fantastic milestone.

Cheers,
Michael

Just to give you an idea, it talks about using for-in loops rather than faking a numerical for loop as many folks coming from C/C++ might do.

By popular request, I’ve decided to create a PDF distilling down these ideas into single concept images. Get it here for free:

Download at https://github.com/mikeckennedy/write-pythonic-code-demos/tree/master/tips-pdf

Feel free to share these with your coworkers and on social. And if they resonate with you, I cover lots of more complex, in-depth ones in the course that don’t fit into a single concept page.

Cheers,
Michael

There are many getting started presentations for Python, this webcast is specifically geared towards helping C# and .NET developers quickly get up to speed with Python. It covers a wide spectrum of the developer landscape from the language, databases and ORMs, web frameworks, data science and computational notebooks, and more.

Join me, Michael Kennedy, from Talk Python, the podcast and training company, to explore Python for the .NET developer. Oh, BTW, I did professional .NET for over 10 years so I knows where you’re coming from.

This event is free and open to everyone.

As we near the end of the year, I’d like to take a moment and highlight the top 5 episodes, measured by number of total downloads (nearly 100,000 each).

In reverse order, here they are! Thank you to everyone who has listened in and subscribed to the show.

#5: Learning (and teaching) Python in a vacuum

Guest
Rusti Gregory

Summary
How do you learn programming when you’re working in a vacuum? Sure there are resources on the internet, but sometimes just bouncing ideas of others in person makes a huge difference. Join me along with Rusti Gregory as we discuss how he is learning and teaching Python in a small town in Vermont.

#4: Modern Python Standard Library Cookbook

Guest
Alessandro Molina

Summary

[Sorry for the audio quality on this one, if you can handle it, the content is great]

A recent twitter poll went around the web and it asked, what percentage of the Python standard library do you think you know? Someone copied me on it, maybe expecting some really high percentage answer. In reality, what I did answer and my rough estimate is that it’s probably around 50%.

This episode with Alessandro Molina definitely helped confirm that experience for me. He just published a book entitled “Modern Python Standard Library Cookbook” and it’s full of these great little corners of the standard library that you might not have bumped into but you’ll be super glad to hear about on this episode!

#3: Automate all the things with Python at Zapier

Guest
Bryan Helmig

Summary
Do your applications call a lot of APIs? Maybe you have a bunch of microservices driving your app. You probably don’t have the crazy combinatorial explosion that Zapier does for connecting APIs! They have millions of users automating things with 1,000s of APIs. It’s pretty crazy. And they are doing it all with Python. Join me and Bryan Helmig, the CTO and co-founder of Zapier as we discuss how they pull this off with Python.

#2: Beginners and Experts in Software Development

Guests
* Karly Sindy – @karlysindy
* Joy Dantong Ma – @JoyDantongMa
* Tsitsi Flora Munikwa – @tsitsi_flora
* Ned Batchelder – @nedbat

Summary
What’s it like to be a beginner in software development? How about learning Python for the first time? This episode is a special panel episode and is the first of a two-part series we are doing on the podcast called Beginners and Experts.

On this first episode, we have a conversation between beginners and experts and how we can close the gap to help beginners get up to speed as quickly as possible. Our panelists are Karly Sindy, Joy Dantong Ma, Tsitsi Flora Munikwa, and Ned Batchelder.

#1: Escaping Excel Hell with Python and Pandas

Guest
Chris Moffitt

Summary
Do you know or maybe work with people who abuse Excel? Is it their hammer to pound all the computational problems that get in their way? Well, join me to chat about this opportunity to bring Python deeper into their lives. You’ll meet Chris Moffitt who runs Practical Business Python. He works with lots of folks who could make better use of Python to solve their business problems and he has a ton of material on his website. It’s time to escape Excel hell with Python and Pandas.

Conclusion

I think it’s fitting that the most downloaded episode is how to escape from Excel and start leveraging the power of Python’s data science stack. Just one more testament to Python being a full-spectrum language and welcoming beginners while not being too simple for true experts.

If you had a favorite, let us know in the comment section. Which one was it and why?

Thanks to everyone who made this year possible (guests, listeners, and students)!

Cheers,
@mkennedy

A quick note about time

There is a countdown to going live and a time listed on the page. This will be displayed in your timezone! Just register and click the date/time on the top of the page to add it to your calendar of choice and you’ll be good-to-go.

Help spread the word

Know someone at your company who should attend this? Please forward this blog post or just shared the link with them:

https://talkpython.fm/python-decision-webcast

I’m looking forward to seeing you in January.

Hope to see you there!
Michael

Episode 73 – Talking Python with Michael Kennedy

from the Local Maximum, episode 73

The Keys To Push Beyond Abundance with Michael Kennedy

on Profitable Python with Ben McNeill

In this episode we talk with Michael Kennedy, the host of Python Bytes and Talk Python to Me. He is the founder of Talk Python training and is a Python Software Foundation fellow. Michael has been working in the developer field for more than 20 years and has spoke at numerous conferences.

Today’s conversation weaves through creating impact with python, entrepreneurial wisdom, strategies for course and content creation, and methodologies to accelerate self learning.

Building data-driven web apps with Flask and SQLAlchemy

This is our most recent course over at Talk Python Training. It’s just under 10 hours of video content along with some demo code to follow along.

Here’s the elevator pitch

One of the areas Python really shines is in building clean and powerful web applications. Once you know the language basics, this course will teach you everything you need to build data-driven, modern web applications in Python with the Flask web framework.

A real-world demo app

Lots of web courses have cheesy or unrealistic web apps they build (if even that!). So with this one, I wanted to build the kernel of any SaaS product for public facing web app. So we will be building pypi.org from scratch using Flask and SQLAlchemy. Then we go further to write unit tests, deploy it to a Linux server and even build out a MongoDB version as well.

What’s this course about and how is it different?

Full stack web development is exactly what you need to build true data-driven web applications in Python. Yet these courses can be confusing and overwhelming due to the many technologies involved (Python, SQL, CSS, etc).

We have taken great care to build a course that is just real enough to give you what you need without anything extra. We build a replica of a popular web application, Python’s own packaging index over at pypi.org.

While building our replica PyPI, you will learn:

• Learn about the different major Python web frameworks
• Create a Flask-based website from scratch using the CLI and PyCharm
• Work with dynamic HTML templates
• Map URLs to view methods using routing
• Make advanced use of routing to build a full custom CMS in 8 minutes
• Take advantage of bootstrap to build well designed sites
• Map data to and from Python using classes with SQLAlchemy
• Learn how Alembic can help our database evolve as our models change
• Accept user input with HTML forms
• Add client and server-side validation
• Overcome the special challenges of testing web apps (databases, frameworks, etc)
• Deploy our web application to a fresh Linux machine (virtual, cloud-based)
• Leverage our design patterns to convert our app to another data model (MongoDB edition)

Get the early-bird discount

We are offering the course for 20% off for just the first week it’s out. So be sure to check it out now if you’re interested. The price goes back to normal July 10th.

So when Brian asked me to go meta with him and be his guest to help him and all his guests get more out of his show, I was happy to be part of it.

He just released our episode. Check it out over at https://testandcode.com/56

You might initially think this episode is only for peopole who are potential podcast guests or hosts. But it really has lots of advice and lessons for all sorts of opportunities where you are getting out and doing more in a public sphere (public speaking, etc.).

Hope you enjoy it and thank you to Brian for having me. Subscribe to his show on Apple iTunes or Overcast. If you just want to listen in right away, go ahead and play it here:

Cheers,
@mkennedy

I’m super excited to share a project I’ve been working on over the past couple of months. We just released a new course over at Talk Python Training.

Building data-driven web apps with Pyramid and SQLAlchemy

Visit the course page for all the details and to take the course or just keep reading.

This course will teach you everything you need to build data-driven, modern web applications in Python. Full stack web development is exactly what you need to build true data-driven web applications in Python. Yet these courses can be confusing and overwhelming due to the many technologies involved (Python, SQL, CSS, etc).

We have taken great care to build a course that is just real enough to give you what you need without anything extra. We build a replica of a popular web application, Python’s own packaging index over at pypi.org.

While building our replica PyPI, you will learn:

• Learn about the different major Python web frameworks
• Create a Pyramid-based website from scratch using the CLI and PyCharm
• Work with dynamic HTML templates
• Map URLs to view methods using routing
• Make advanced use of routing to build a full custom CMS in 5 minutes
• Take advantage of bootstrap to build well designed sites
• Map data to and from Python using classes with SQLAlchemy
• Learn how Alembic can help our database evolve as our models change
• Accept user input with HTML forms
• Add client and server-side validation
• Overcome the special challenges of testing web apps (databases, frameworks, etc)
• Deploy our web application to a fresh Linux machine (virtual, cloud-based)
• Leverage our design patterns to convert our app to another data model (MongoDB edition)

Sound interesting? Check out the course intro video or jump on over to the course page.

Cheers,
@mkennedy

Eve: Building RESTful APIs with MongoDB and Flask

If you are thinking of building RESTful HTTP APIs with MongoDB, you owe it to yourself to check out the course. Jump over the to the course page and watch the introductory video.

Here’s a little more info on the course, which was written by Nicola Iarocci, the creator and maintainer of Eve.

Course Summary

Eve is an open source Python REST API framework designed for human beings. It allows you to effortlessly build and deploy highly customizable, fully featured RESTful web services.

What’s this course about and how is it different?

This course will teach you to effortlessly build RESTful services based on Flask and MongoDB.

We dive deep into every aspect of the Eve REST framework. After a quick introduction to MongoDB and Flask, we’ll dig into Eve, build our schemas and endpoints and start serving HTTP clients right away, and that’s just the beginning.

In this course, you will:

• Create a new Eve web service application
• Define data schemas for the service and MongoDB
• Issue queries from the client straight into the service
• Validate inbound data (including custom rules)
• Add and configure paging for large data sets
• Project responses for just the data you need
• Switch between JSON and XML per client request
• Secure your service with authentication
• Add event hooks such as pre-insert actions
• Limit the rate of your clients to avoid abuse
• Deploy your service
• And lots more

Who is this course for?

It’s for anyone who has wants to leverage Eve to build RESTful APIs. We do assume you know basic Python concepts but advanced features and knowledge of MongoDB, Flask, and REST is not required.

Sound interesting? Sign up or read me over at the course page!

Happy 2018! There are many things to celebrate as we roll into this new year. One is a bunch of new Python courses are either available or coming soon at Talk Python Training.

I’ve been thinking about how to best make these available to everyone.

I want you to have access to everything, all the Python courses – almost 100 hours and growing fast. I want keep the own it forever model (way better than subscriptions for you). And so the Everything Bundle is born.

If you’re thinking about learning Python, there really isn’t a better single resource out there. We have many of the best courses available and many amazing courses from new authors coming soon. These include

• Python Jumpstart by Building 10 Apps
• Mastering PyCharm
• Pythonic code
• Python 3: An Illustrated Tour
• Introduction to Ansible
• Eve: Building RESTful APIs with MongoDB and Flask
• And many more we’re not ready to announce just yet

Check out the bundle and find the Python course to jumpstart your next adventure!

Thanks!
@mkennedy

Here’s a short form (only 3 questions). I’d appreciate your thoughts.

https://docs.google.com/forms/d/e/1FAIpQLSdygLS0G91t5E8LCGtZvdfzeqdePr2jFqoiR30HZjmGbaJjNQ/viewform

Thanks!
@mkennedy

Sound interesting? Just visit freemongodbcourse.com and sign up today. No strings attached!

What is covered?

There are four major topics covered.

• Why NoSQL and MongoDB
• Modeling data in document databases
• Introducing MongoEngine
• Building the data layer with MongoEngine

Why use MongoDB?

• Simplicity: Requires less work to evolve as your app grows.
• Most wanted: MongoDB is the most wanted database by a factor of 2.
• Powering the web: A $2 billion dollar ecommerce store and many more…
• Scalable: Built-in sharding and replication using the same API.

Take the course

What are you waiting for? Jump over to visit freemongodbcourse.com and get started!

Yelp Reviews: Authorship Attribution with Python and scikit-learn

When people write text, they do so in their own specific style. Often, it’s possible to identify someone using only their unique style of writing. In this post, we’ll see how easy it is to identify people using their writing style through machine learning. Specifically, we’ll look at reviewers who have left multiple reviews on Yelp. We’ll teach a machine learning system to differentiate between different writing styles, and then see how well it can predict the correct author of a review, looking only at the review text.

Overview

In this post, we will:

• Load over 4 million reviews from the 2017 Yelp Dataset Challenge
• Find users who have left at least 500 reviews
• Train a support vector machine classifier to identify the writing style of each author
• See how well the classifier can identify reviews it hasn’t seen during training

We’ll use Python and Jupyter Notebook to develop our system, relying on scikit-learn for the machine learning components. Jupyter allows us to easily run sections of code as we progress. We can easily view the output of each ‘cell’ of code, and make changes if necessary, without needing to rerun the entire script.

Prerequisites

To follow along with this post, you should have used Python before. It’ll help if you know some basics of machine learning, but we’ll explain everything we do in detail, so you should be able to keep up even if you’re just getting started. You’ll need a working Python environment with Jupyter notebook and scikit-learn installed. You can install both by running:

pip3 install jupyter sklearn

You’ll also need to download the Yelp dataset from https://www.yelp.com/dataset_challenge. The data is a 1.7 GB tarball, which decompresses to over 4 GB of JSON files, so you’ll need some free disk space. Once you’ve downloaded the data and decompressed it, start up a Jupyter notebook in the same directory that you saved the dataset to, and create a new Python 3 notebook. You will then be able to run all the code while reading the explanatory text, making any changes to the code that you want.

Reading in the review data

First, we’ll load the Yelp reviews from disk into a Python list. We put %%time at the beginning of the cell to tell Jupyter to indicate how long the code took to run. On my machine, parsing the 4 million reviews took about a minute and a half.

# python
%%time
import json

reviews = []
with open("yelp_academic_dataset_review.json") as f:
for line in f:
reviews.append(json.loads(line))

# CPU times: user 52.2 s, sys: 28.7 s, total: 1min 20s
Wall time: 1min 34s

We’ll take a look at the first review so we know how the data is structured. For this post, we’ll only be using the user_id and text fields (the user IDs have been anonymized, but if two reviews have the same user_id, it means that they were written by the same user).

# python

print(reviews[0])
{'business_id': '2aFiy99vNLklCx3T_tGS9A',
'cool': 0,
'date': '2011-10-10',
'funny': 0,
'review_id': 'NxL8SIC5yqOdnlXCg18IBg',
'stars': 5,
'text': 'If you enjoy service by someone who is
as competent as he is personable, I would recommend Corey Kaplan highly. The time he has spent here has been very productive and working with him educational and enjoyable. I hope not to need him again (though this is highly unlikely) but knowing he is there if I do is very nice. By the way, "I'm not from El Centro, CA. but Scottsdale, AZ.",
'type': 'review',
'useful': 0,
'user_id': 'KpkOkG6RIf4Ra25Lhhxf1A'}

Getting the top reviewers

We’re only interested in the users who have left multiple reviews for our analysis. Because most users have left only one or two reviews (see http://www.developintelligence.com/blog/2017/02/analyzing-4-million-yelp-reviews-python-aws-ec2-instance/ for a more detailed breakdown), we’ll be excluding a large portion of the reviews. We can find the reviewers who have left the most reviews efficiently by using a Python Counter. We’ll take the 80 top reviewers, who have all left at least 500 reviews in this dataset.

# python

from collections import Counter

prolific_reviewers = Counter([
review['user_id']
for review in reviews]
).most_common(80)

Let’s take a look at the top 5 reviewers.

# python
prolific_reviewers[:5]
[
('CxDOIDnH8gp9KXzpBHJYXw', 3327),
('bLbSNkLggFnqwNNzzq-Ijw', 1795),
('PKEzKWv_FktMm2mGPjwd0Q', 1509),
('QJI9OSEn6ujRCtrX06vs1w', 1316),
('DK57YibC5ShBmqQl97CKog', 1266)
]

One person has left over 3000 reviews on yelp! The drop-off is quite steep, but the 80th person in the list has still left over 500 reviews.

Now we want to create a balanced dataset — i.e., we want the same number of reviews of each reviewer. We’ll go through all our reviews again and keep only those reviews written by the 80 authors we identified above, and only 500 reviews from each author. Below, keep_ids is a dictionary which we’ll use to keep count of how many reviews we have from each author.

# python
keep_ids = {pr[0] : 0 for pr in prolific_reviewers}

keep_reviews = []
for review in reviews:
uid = review['user_id']
if uid in keep_ids and keep_ids[uid] < 500:
keep_reviews.append(review)
keep_ids[uid] += 1

Preparing the training data

Now we’ll split the reviews we kept into two lists: one for the texts of the reviews, and another for the author ids. The two lists are implicitly associated by index (i.e., the first text in our texts array was written by the first author in our authors array). In machine learning, we refer to these as “instances” and “labels”. Instances are the things we use to learn from, and the labels are the things we are trying to learn.

# python
texts = [review['text'] for review in keep_reviews]
authors = [review['user_id'] for review in keep_reviews]

Next, we need to import some things from the scikit-learn library. Specifically, we need a vectorizer (something that transforms our texts into a numerical representation that’s easier to work with) and a classifier (the thing that learns how to discriminate based on labeled examples). We’ll be using TfidfVectorizer, which transforms our text into vectors with tf-idf weighting and a LinearSVM, which is a Support Vector Machine with a linear kernel — a kernel that is often used for text classification tasks. We’ll also import a helper function called train_test_split. We’ll use this to split our data into a training set and a test set. The classifier will learn patterns from the training set, and then we’ll make sure that it actually works by seeing if it can correctly predict the authors in the held-out test set.

# python

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.model_selection import train_test_split

Now we can transform our texts into vectors by setting up a vectorizer and giving it the list of our texts.

# python

vectorizer = TfidfVectorizer()
vectors = vectorizer.fit_transform(texts)
print(vectors.shape)

(40000, 68619)

Our vectors variable contains a sparse matrix with shape 40000 (which is 500 texts times by 80 authors — the number of texts we kept) by 68619 which is the number of features. Our features are single words (unigrams) and each text is represented by an indication of how often that word appears in that text (which is nearly always 0 as we have 68619 unique words in the dataset).

Often in machine learning, you’ll see the instances (texts in our case) referred to as Xs and the labels as ys. You can think about machine learning tasks as a function y = f(x). We have x (the review text) and we want to know y (the author’s ID). The SVM attempts to learn a function f that can map the texts to the labels. We’ll follow this convention, and break our texts into X_train (the texts we’ll show the SVM as learning examples) and X_test (the texts we won’t show to the SVM so we can see if it’s able to predict the correct authors for these texts based on the patterns it learned from the texts in X_train). We’ll similarly break our labels (the author ids) into two arrays as well: y_train and y_test. We can use the function provided by scikit-learn to handle taking a random sample of our texts and labels, while making sure that the indices still correspond, as follows.

# python

# We use a fixed random_state to ensure that the same random sampling is used every time the code is run.

X_train, X_test, y_train, y_test = train_test_split(vectors, authors, test_size=0.2, random_state=1337)

We now have 32000 texts (80% of our data) to train on and 8000 (20%) for testing:

# python

print(X_train.shape, X_test.shape)
(32000, 68619) (8000, 68619)

Training and testing a classifier

We first need to call fit on our classifier and pass in the learning texts and labels. Then we’ll call predict to get predictions on the test data, and look at some metrics to see how well it did.

# python

%%time
svm = LinearSVC()
svm.fit(X_train, y_train)

# CPU times: user 16.7 s, sys: 119 ms, total: 16.8 s
# Wall time: 16.8 s

We can now make predictions on the test set (note that the SVM has never seen the labels from the test set that are stored in y_test). The SVM will output whichever user_id it thinks is most likely to be the author of that review, for each review we pass in.

# python

predictions = svm.predict(X_test)
print(list(predictions[0:10]))

['cMEtAiW60I5wE_vLfTxoJQ', 'EiP1OFgs-XGcKZux0OKWIA', 'V-BbqKqO8anwplGRx9Q5aQ', 'FIk4lQQu1eTe2EpzQ4xhBA', 'J3ucveGKKJDvtuCNnb_x0g', 'FIk4lQQu1eTe2EpzQ4xhBA', '1kNsEAhGU8d8xugMuXJGFA', 'j6wLUT0ZXi-x0otelYIFpA', 'DK57YibC5ShBmqQl97CKog', 'sYQyXDjGaJj7wfaqz5u8KQ']

If the classifier did a good job, the predictions should be similar to the test labels (y_test). We can look at the first 10 manually to see how this works:

# python
print(y_test[:10])

['yT_QCcnq-QGipWWuzIpvtw', 'EiP1OFgs-XGcKZux0OKWIA', 'V-BbqKqO8anwplGRx9Q5aQ', 'FIk4lQQu1eTe2EpzQ4xhBA', 'J3ucveGKKJDvtuCNnb_x0g', 'FIk4lQQu1eTe2EpzQ4xhBA', '1kNsEAhGU8d8xugMuXJGFA', 'j6wLUT0ZXi-x0otelYIFpA', 'DK57YibC5ShBmqQl97CKog', 'sYQyXDjGaJj7wfaqz5u8KQ']

It got all but the first one correct! We can use some more helper functions from scikit-learn to get a summarized view on the results for all 8000 predictions. Accuracy is simply the number of predictions it got right divided by all the predictions:

# python

from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, predictions))
0.86475

We have 80 authors in our dataset, so if were were simply guessing the authors we’d expect to get an accuracy score of 0.0125. Instead, our SVM can correctly predict the author of the review more than 86% of the time.

Improving our system

Let’s see if we can tune some parameters and do even better.

The following vectorizer looks at words individually (unigrams) but also looks at pairs of words (bigrams). This makes our feature space much larger, so we’ll need a bit more processing time, both to create the vectors, and to train the SVM using the vectors. To alleviate this issue, we’ll tell the vectorizer to ignore all words and word pairs that don’t appear in at least five different reviews — there are a lot of very rarely used words, and we can’t learn anything from these anyway.

# python

vectorizer = TfidfVectorizer(ngram_range=(1,2), min_df=5)
vectors = vectorizer.fit_transform(texts)
print(vectors.shape)
(40000, 174396)

Now we have 174,396 features, about double the number we had before. We can create our train test split again, and run the fitting and prediction code as before.

# python

X_train, X_test, y_train, y_test = train_test_split(vectors, authors, test_size=0.2, random_state=1337)

# python

svm = LinearSVC()
svm.fit(X_train, y_train)
predictions = svm.predict(X_test)
print(accuracy_score(y_test, predictions))
0.90525

The new vectorization parameters are a bit better, and we can now identify the correct author correctly more than 90% of the time. Considering that some of the reviews are only a few sentences long, it is perhaps surprising that the writing styles are inactive enough.

Conclusion

In this post, you learnt how to use Python and scikit-learn for authorship identification. You can now prepare text data and train a simple classifier. You know a bit about the vectorization process, and the choices that have to be made regarding data preparation.

It might seem useless to predict labels that we already have, but we could use this same principle for many practical tasks. For example, it could help find people who have more than one Yelp account for the purposes of promoting their own establishment or leaving bad reviews for competitors. It is also useful in forensic linguistics when the true authorship of someone’s will or suicide note is often questioned, and it can be used to prove the authorship of disputed literary works, such as Shakespeare’s plays or books written under pseudonyms.

Consuming HTTP, RESTful, and SOAP Services in Python

Visit the course page to join

What’s this course about?

This course will show you how easy it is to consume a wide variety of web services using Python. You will be comfortable working with a variety of web and HTTP services. In addition to core package APIs, you will learn the ins-and-outs of HTTP RESTful services and their data types.

What’s this course about and how is it different?

The goal of this online video course is to show you how to integrate with a variety of HTTP-based web services.

As you know, it’s a services world out there. There are literally 1,000’s of amazing APIs you can integrate into your applications. Whether it’s Slack or Twilio to add communication, GitHub, Trello, or BitBucket for development and deployment, or even Stripe for payments, you can dramatically boost your application’s features and power by adding services.

In addition to learning the APIs to integrate HTTP, REST, XML, SOAP services and web scraping into your application, you will learn the theory and concepts behind.

You’ll even learn to work with a number of data formats including JSON, XML, HTML, SOAP.

Who is this course for?

It’s for people who have some programming / scripting experience and want to improve their Python knowledge. Maybe you

• Want to add services to your local apps or your web apps
• Are a developer adding integration with existing services
• Are a data scientists looking to harvest data from the internet
• Are a developer who needs to integrate with legacy SOAP services
• Would like to understand the concepts behind HTTP / REST services

If any of those descriptions fit you, then you’re my target student. I wrote this course for you.

What services will we use?

We will create a number of demo applications in Python throughout this course. These applications will integrate with a variety of services and work with a number of data formats including:

• GitHub (list public repos for a user)
  api.github.com
• Blog explorer (three versions: requests, py2, py3)
  consumer_services_api.talkpython.fm
• RSS Feed Reader
  talkpython.fm/rss
• MP3 / podcast downloader (binary file examples)
  talkpython.fm
• Course Playground Service
  HTTP / REST version: /api/blog
  HTTP / REST version (auth): /api/restricted/blog
  SOAP version: /soap?wsdl
• Scraping and analyzing 80 hours of transcripts on talkpython.fm
  E.g. https://talkpython.fm/episodes/transcript/67/property-based-testing-with-hypothesis

What data formats will we learn to process?

In addition to working with requests, urllib*, beautifulsoup4, you will learn how to work with a number of data and file formats in Python including.

• via the HTTP APIs
• via the file system

I recently did a live webcast in conjunction with dataschool.io called Write Pythonic Code for Better Data Science. You might be thinking, “Live webcast, well that’s a little late, isn’t it?” Well, no, because the recording is available now. :)

If you missed it and want to watch the approximately 1 hour presentation with a short introduction and extensive Q&A afterwards, just visit the crowdcast page to watch the replay:

If you want to see the code written during the webcast, it’s available on GitHub here:

github.com/mikeckennedy/write-pythonic-code-for-better-data-science-webcast

If you want to go deeper than a single webcast, I wrote a whole course on this topic called Write Pythonic Code Like a Seasoned Developer. Please check it out if it sounds interesting.

Here’s the quick background info on the webcast as well:

As an aspiring data scientist, you’ve probably heard that you need to learn how to use pandas, scikit-learn, and other Python libraries. But did you know that you can also improve your data science skills by getting better at the Python language itself?

During this 1-hour webcast, special guest Michael Kennedy will teach you how to write Pythonic code, which is code that takes advantage of the best features of the Python language. Not only will this help you to write more efficient and readable code, it will also enable you to pick up other Python libraries more quickly!

At the end of Michael’s lesson, there will be plenty of time to answer your Python questions. All levels of Python users are welcome!

Have a listen:

I hope you love the idea. You can subscribe via iTunes, Google Play, Overcast, and more (just search).

Cheers,
@mkennedy

Interested? Visit the course page for a full, dynamic outline, more info, and to pre-order for just $59 with lifetime access:

https://talkpython.fm/launch

Introductory video

[Video Series] Taking Your Python Skills to the Next Level With Pythonic Code

Check out the original post for the full story. Here are the five videos and related posts if you want to dive in and watch them.

#1 Stop Using Lists for Everything

#2 Hacking Python’s Memory With __slots__

#3 Merging Dictionaries

#4 Processing Large Data Sets With Yield and Generators

#5 Lambda Expressions

Hope you enjoy the lessons!

If you find them useful, consider taking my full Write Pythonic Code Like a Seasoned Developer course. It covers 52 Pythonic code tips (including the 5 above) in over 4 hours of content.

@mkennedy

Python for Entrepreneurs

If you have been dreaming of launching your own web based business, this course is custom made for you. Check out the kickstarter page and be sure to back the project before the end of the campaign.

Thanks,
@mkennedy

If you run a podcast yourself, you might want to read this carefully too.

Why did I do this?

Why would I not want more listeners of my podcast? Do I already have too many? No, please subscribe if you haven’t – see below ;).

I have always been a little suspicious of Stitcher’s business model. After a number of listeners requested I add Talk Python there, I figured I’d do it because, hey, I really do love you guys and gals.

But, agreeing to have your show listed on Stitcher is a bit of a deal with the devil. You agree to:

1. Crappy audio: They can take your RSS feed and episode MP3s, copy them to their server and re-encode them with a super crappy bit-rate. I spend a lot of money and effort producing and distributing HQ audio and don’t appreciate this.
2. They sell your work, they keep the money: Stitcher takes your creative work and slices it apart, and sell their audio ads in your track without paying you at all (or if you partner with them extremely low revenue). Nevermind I spend almost 15 hours a week creating and producing the show.
3. Sell it in other ways, keep the money: Similarly, they sell banner ads around your content in their player. They keep all of this money too.
4. Stitcher is bad for podcasting: If they are wildly successful, they will undermine independent podcasting in general. Successful podcasts like Talk Python To Me currently work directly with sponsors, negotiate a fair rate based on product / audience fit and reach. If we are all in stitcher with their ads replacing ours, and them sending a few % back to us, podcasting will look very different (and not in a good way).

But don’t take my word for it

It’s not just me being paranoid or greedy. Here’s what John Gruber from Daring Fireball has to say about the situation.

Midroll owning Stitcher is not good for the podcast ecosystem. Stitcher is popular, but my show is not on Stitcher because Stitcher re-hosts the audio, compresses it to hell, and unless you opt out, inserts their own ads. That’s not how podcasting is supposed to work. I firmly believe podcasting should be open, like the web.
John Gruber – https://daringfireball.net/linked/2016/06/06/midroll-stitcher

Here are a few commenters on articles / posts about the subject:

I’ve been using stitcher for years. I had no idea how they worked. I’ve found this blog as well as some others highlighting this issue. I’ve deleted stitcher and now I’ve found an app that I can paste the rss feed into that gives me the same ability to stream or download. May not be compressed, but I want the people who worked hard to deliver me free content to make the most of their own shows. Furthermore, for people taking others ad revenue, they don’t even put it into making a good app. Stitcher had been getting buggier by the version. So people on top take it all and don’t even pay good money to decent developers. Stitcher is a capitalism-based-parasite in my opinion.
Kennadian – Nerdist: The Stitcher Situation

And from an older article:

I have an iPhone and I use the default app. I downloaded Overcast and it is amazing but only does audio. Stitcher’s business practices are a little suspect amongst the industry.
@ericelawrence – Deezer buys podcast app Stitcher

Ben Thompson, from the amazing Exponent podcast wrote a great article called “The Future of Podcasting” and did an episode with his co-host James on it called “A podcast about podcasts“.

In the article Ben writes:

Stitcher is thought to be the 2nd most popular podcast player, although it has long been controversial in some circles for its default practice of hosting podcasts itself (instead of directing users to download them directly from a podcaster’s server) and inserting ads. That model, though, was likely attractive to Scripps/Midroll: controlling the files and the player means the possibility of making meaningful measurements of play data plus dynamic ad insertion at scale.
Ben Thompson

Finally, Marco Arment, who created Instapaper, hosts the Accidental Tech podcast, and created the Overcast player mentioned above wrote:

Podcasts are hot right now. Big Money is coming. Big Money isn’t going to sell nicely designed, hand-crafted, RSS-backed podcast players for $2.99 or ask you to pay what you want to support them, because that doesn’t make Big Money. They’re coming with shitty apps and fantastic business deals to dominate the market, lockdown this open medium into proprietary “technology”, and build empires of middlemen to control distribution and take a cut of everyone’s revenue… I don’t know if Overcast stands a chance of preventing the Facebookization of podcasting, but I know I’m increasing the odds if my app is free without restrictions. As long as I can make money some other way, I’m fine.
Marco Arment – Apple’s actual role in podcasting: be careful what you wish for

Why now?

There are two events coming together to make me take the entirely manual step to hunt Google intensely to discover the email address to personally write and request removal of my podcast from Stitcher (this is not at all offered to publishers willingly from Stitcher). Oh, and I can save you the work. Email them and request your show to be removed via partners@stitcher.com if that’s your choice. Lock-in via obscurity is a poor long term business model.

Event 1: In February 2016, I struck out on my own to start Talk Python Training and focus on the Talk Python To Me podcast. These are my two income sources. The online courses and podcast revenue (from sponsors, the podcast is free for listeners) are how I pay my mortgage, my twin daughters upcoming college tuition and housing fees, and everything else in life that costs money when you have a family.

You can read the whole story here. You can bet this means I care more about a sustainable business model for my show and for everyone’s shows than if this was just a hobby.

Event 2: Midroll (the largest podcast ad network) bought Stitcher for $4.5M USD. They intend to double down on the dubious business model I mentioned in the opening 4 points. You can read about this at the Wall Street Journal: E.W. Scripps Buys Podcast Company Stitcher

Where can you listen to Talk Python To Me now?

Talk Python To Me has been available in many places and will continue to be. I even offer an OGG-Theora version for pure open source players. Please pick your favorite podcast client (mine is Overcast on iOS but there are many on all platforms including native ones on iOS and Android).

1. Via iTunes directory
2. Via Google Play podcast directory
3. Direct RSS from talkpython.fm
4. Direct OGG-Theora RSS feed from talkpython.fm
5. Via SoundCloud page or even our RSS feed for SoundCloud
6. Our YouTube channel

There are probably more places to find Talk Python To Me. But I think the 6 options above offer multiple high-quality choices no matter your platform or preferences. Don’t want to download the episodes to your device but would rather stream them like Stitcher? Many apps like Overcast allow you to subscribe but only stream the episodes on a per show basis.

Thanks to my listeners

Thanks to everyone who subscribes to the show. If you used stitcher, this kinda sucks for you I know. But, in the long run, this will help me keep the show going by letting me dedicate my time to creating content rather than doing this podcast as a side hustle (which I did for awhile, it’s exhausting!).

If this message resonates with you, please share this post with your friends and on social media.

Image credit: Alex Gooi via Flickr

I’m thrilled to announce the second online Python course in my grand plan to create an amazing online resource for Python developers.

Write Pythonic Code Like a Seasoned Developer

You can buy the course for just $39, own it forever, and get started immediately.

Course Summary

This course will take you on a tour of over 50 of the more popular and useful code examples demonstrating Pythonic code. In the examples, you’ll first see non-Pythonic code and then the more natural Pythonic version.

One of the special concepts in Python is the idea of writing idiomatic code that is most aligned with the language features and ideals. In Python, we call this idiomatic code Pythonic. While this idea is easy to understand, it turns out to be fairly hard to make concrete.

Topics covered include the expansive use of dictionaries, hacking Python’s memory usage via slots, using generators, comprehensions, and generator expressions, creating subsets of collections via slices (all the way to the database) and many more. Several of these are Python 3 features so you’ll have even more reason to adopt Python 3 for your next project.

What is Pythonic code and why does it matter?

One of the special concepts in Python is the idea of writing idiomatic code that is most aligned with the language features and ideals. In Python, we call this idiomatic code Pythonic. When you write Pythonic code, you are leveraging over 25 years of experience of many thousands of developers. You are writing code that is expected and tune in the CPython runtime. Most importantly perhaps, you are writing code that is easily read and understood by your follow and senior Python developers.

If you are building an open source product, it will be easier for other contributors to join in if your code is Pythonic. If you are running a software team, it will be easier to onboard Python developers new to your company.

On the flip side, if you are somewhat new to Python, you may be broadcasting this loud and clear to everyone listening: your teammates, interviewers if you’re looking for a new job, audience members if you’re giving a public presentation. This is less than ideal.

Finally, many of the over 50 tips covered in this course that are considered “Pythonic” allow you to write more readable code, more maintainable code, and more efficient code. So in some sense, you can think of this course as an effective Python course in its own right.

Who is this course for?

The course is for beginner to intermediate Python developers looking to hone their Python programming skills and become true professionals in the Python space. It is not a “Learn Python from Scratch” course and assumes you are familiar with language constructs such as modules, functions, classes, and more.

If you are looking to learn Python from scratch, please consider my Python Jumpstart by Building 10 Apps course.

What topics will we cover?

This course covers over 50 concrete programming tips to write more Pythonic code. These tips are grouped into the following broad categories.

• Pythonic Foundational Concepts
• Dictionaries
• Generators and Collections
• Methods and Functions
• Modules and Packages
• Classes and Objects
• Loops
• Tuples
• Python for Humans

Ready to start learning?

Head over to training.talkpython.fm and get started today.

Have a question?

Post them in the comments below. I’d be happy to talk about it.

• Do you love Entity Framework and the hyper productivity of a great ORM?
• How about ASP.NET MVC as a web framework for artisains?
• True properties on classes?
• The list goes on and on.

In this live presentation from NDC Oslo 2016, I make the case that virtually everything that is appealing for .NET developers in C# and .NET has an analogous and wonderful equivalent in the Python space.

If it’s time to diversify beyond Windows and Microsoft, I encourage you to watch this recorded session and see why Python is a great choice as a second language for the .NET developer.

I had the honor to spend an hour with Cecil Phillip and Richie Rump on their laid back technical, but casual podcast Away From The Keyboard. I really enjoyed the conversation and I think you will too. Give them a listen.

Today I wanted to tell you about a few features I’ve added to the player and the platform that have been requested by many of you.

Feature 1: Remember my watched lectures

(click to enlarge)

You can see from the screenshot above that the player has automatically recorded which videos I’ve watched across all my devices (grey with checkboxes).

Feature 2: Quick access and subtitles on videos

(click to enlarge)

You can see I’ve added a significant amount of quick access, navigational, and transcript / subtitle features in the player.

Use the CC icon in the lower-right to enable subtitles (and the HD allows you to adjust the quality / size while you’re there). Note that on Chrome sometimes it forgets your settings to keep this selected. I believe this is a third-party cookie setting.

Top has, from left to right, access to the main course page, transcript popup, github repository, twitter, facebook, linkedin shares, and “mark as watched and go to next”.

The mark as watched is automatic, but this allows you to skip ahead and record the video was watched even if you don’t actually watch it.

Feature 3: Transcripts on github course repo

I decided to add the transcript text files to the course github repository. You can have access to them offline from here and even use the “search this repository” for full text search across lectures.

Note that I’m adding transcripts as they get finished, but only the first 6 chapters have transcripts at the time of this writing.

Listen to Episode 112 | Michael Kennedy – The Geek’s Geek

There are just 36 hours left in my online Python course Kickstarter.

Python Jumpstart by Building 10 Apps

I want to thank everyone who has either backed the project or shared it with someone who might be interested.

Here are a few updates and a final call to action.

#1. Team options. I have had several backer levels all focused on individuals. I added a couple of company / team focused ones for the final day. If you work with a team who needs to (or should!) learn Python, please recommend they buy my course. They can choose one of the team options or just buy the course as a group when it’s out in a few weeks.

• TEAM PACK: 10 STUDENTS for $250
• TEAM PACK: 20 STUDENTS for $450

#2. Talk Python Training. This kickstarter campaign is just the first step on my journey to build the best set of online Python training courses. I have launched Talk Python Training. You will be able to buy the course directly there as soon as it is finished as well as see what I’m planning next.

How can you help?

If you think this project is pretty cool, please consider:

1. Backing the project on Kickstarter.
2. Subscribe to my mailing list on Talk Python Training to hear about new courses
3. Recommend the course to a friend, colleague or even your company

Once again, thanks everyone. This project has been a great joy to work on and I couldn’t have done it without.

— Michael

When I started the Talk Python To Me podcast almost a year ago, I had modest expectations and more than a little uncertainty about how it would be received by the community. And honestly, everyday I’m blown away by how many people’s lives I touch and help educate in some part of Python that was less well known to them.

I get a huge amount of satisfaction spending time making Python more relevant through the conversations on the podcast. I’ve been thinking about how I do more of that.

I believe the natural counterpart of a podcast which exposes people to new ideas and inspires them to learn more about Python is a comprehensive set of online courses to help you go from inspired to empowered, from new developer to highly effective developer, from a specialized developer to a well-rounded one.

Today I’m announcing the first course and taking the first step on a journey to build this resource for you and the whole Python community.

Over the next two years, I plan to release 20 high-quality online courses that will be between 3 to 10 hours each (one course every 4-6 weeks). These no-fluff courses will strive to make you effective with some corner of the Python ecosystem including the python language, web applications, databases, GUIs, parallelism, and more.

The first course will be about the Python programming language and will take a fun and playful approach of teaching you language details such as classes, loops, variables, and more. It’s called Python Jumpstart by Building 10 Applications, it will be about 6 hours long, and will be a comprehensive introduction to the python language.

If this project resonates with you, then I need your help. As of today, I’m launching a kickstarter to make this first course, this first step on my journey, a reality.

Please, take a moment to visit the kickstarter to see what it’s all about. There are many reward levels but main one is the $29 student reward which gives you lifetime access to this first course at a significant discount.

If you believe in this project and want to help, please tweet about the kickstarter, share it with your coworkers, or even back it yourself.

I’m really excited to start down this path to build something amazing for the community and I can’t do it without you. So any support or word-of-mouth endorsements you can give me will be deeply appreciated.

Please let me know you think. Send me a message over email, contact@talkpython.fm or on twitter via @talkpython.

Here’s a short video telling you what the course is about and why I think you’ll love it.

Update: Listen to the podcast interview with the PyCharm guys.

Many developers, especially in open source ecosystems such as Python and Ruby, or Linux-based web environments in general, tend towards the minimalist with regard to editors. This includes editors such as Emacs and VIM but I’d also throw in more UI based text editors such as Sublime Text, Notepad++, etc.

In some ways this makes perfect sense. If you spend a decent amount of time SSH’ed into Linux boxes in your data center, well GUI apps such as IDEs make little sense. If you’re doing open source, maybe you are looking for something non-commercial and free. Again, totally reasonable.

But the truth is, as professional developers, we spend most of our time on GUI-based OSes. Our time and effectiveness are extremely valuable.

Specifically for Python devs, I think we should be using the best tools that help us create but also read, test, maintain, and evolve the software we build. To me, the best software for this holistic purpose, is PyCharm. But often the conversation goes, “What feature makes using a big, heavyweight IDE that costs $200 worth it? I’ll just use Emacs” or something along those lines.

There probably isn’t a single reason that works for many people. Rather it’s the sum of all the features as a whole. Moreover, these only become a benefit once you take the time to truly learn them and leverage them without the features getting in the way.

So in this post, here are 9 of my favorite features of PyCharm which taken, in total, build a pretty serious case for giving PyCharm a chance. If your current workflow involves more pure text editors such as Emacs or Sublime Text, take a moment to see PyCharm with an open mind.

Finally, if you’re skeptical of this opinion and you think to yourself, “Here’s just another guy dependent on GUIs to write code. How weak. I don’t need that.” I should say that I spent several years writing C++ with Emacs on SGI supercomputers to great effect. So I have spent some time on both sides of the fence. For me, the grass is greener on this side.

Ok. Here they are: 9 reasons to consider making PyCharm your primary editor to write Python code. I could easily make this 25 but let’s start here.

1. Code completion

PyCharm has great code completion, whether it’s for a built-in or an external package.

I know I said it’s the sum total of features that make PyCharm worth it. Personally, I think great intellisense / code completion may be a single feature which alone wins me over. I have to deal with minor RSI issues and the amount of code I type vs the amount of code created by the tooling with good code completion really does make a big difference in both speed and health.

Python 3.5’s Type Hinting

If code completion fails you, type hints (as in episode_id: int ) will turn it right back on. Notice the dropdown lists methods from the int class.

Code completion for SQL and databases

Look carefully at the image above. That is a basic string literal but PyCharm has determined that it is likely a SQL expression so turns on syntax highlighting and code completion for language keywords (WHERE, FROM, etc).

Moreover, I have attached my SQLite DB to the project. PyCharm is suggesting database schema specific options! O. M. G. is what I thought when I first saw that. Because of the FROM Episodes, it knows that the SELECT clause should be columns from that table.

Just wow. Think of the time and effort as well as avoidance of bugs this will help you with.

SQLAlchemy in the debugger

Set a breakpoint, pause in the debugger and you’ll see the SQL language representation of your SQLAlchemy ORM expression. Yeah, that’s amazing.

I think this is really just part of the string representation of SQLAlchemy ORM expression, but I don’t care because it’s so helpful!

Git visualization in the editor

Wondering what is changed since the last time you did a git commit? Well that would be the blue sections right there! Can even get a diff of that segment or roll it back from within the editor.

Here’s the same file after I checked in the changes:

Code coverage in the editor

Yes, you can run coverage.py outside of PyCharm. But please click that image above and look around. The code coverage details are everywhere – in the project tree, in the summary, in the editor and more.

Now zoom in. See the greenish and redish parts in the margin? Those are the covered and not covered segments right in the editor!

Package management

Yes, we can all use pip. But a nice visual representation of what’s installed, whether it’s current, and ability to search and add new packages is sweet.

Local history

I sure hope you’re using source control. But even if you are, local history is always keeping track of your changes in a way that complements things like Git. Need to roll something back even if it’s not part of a check in? Local history is always there.

Here’s a diff of a file where the changes between the two versions were not checked in.

Refactoring

Last, but not least, the ability to make changes consistently and safely across 100’s of files by understanding the syntax tree (rather than text replace) is a primary reason to use an IDE in general and PyCharm in particular.

Conclusion

There you have it. Taken in total, those are some seriously powerful features. Check out PyCharm. They have free community editions, and the pro version is free for open source, students, and training.

Feel free to share your thoughts in the comments.

Thanks,
@mkennedy

There are two groups of people who I’m looking to spend 10 minutes talking with:

1. Newly hired Python developers: Did you just get your first job as a Python developer (within the past year)? Would you spend 10 minutes on the show (audio) talking about how you learned Python and how software development as well as how you got your first gig?
2. Technical leaders responsible for hiring Python developers:  Are you responsible for interviewing or hiring Python developers at your company? Would you spend 10 minutes on the show (audio) talking about what you look for and give some recommendations on how aspiring / new developers can build the right skills and experience to land their first job?

What do you say? Can you be part of the show and help a lot of new developers find the right path?

Contact me via the show contact email here:

http://talkpython.fm/home/contact

If this doesn’t describe you, but you know a new developer or tech leader who does, please forward this to them. If you want to participate but are unsure whether your company “approves” of this type of exposure, you can participate anonymously.

This project is expected to run over the last part of November, first part of December 2015.

Thanks in advance!
@mkennedy

But I had some reservations. First and foremost, I manage a lot of servers and thinking of keeping another one running was not appealing to me. Second, the audio stream of Talk Python is literally the lifeblood of Talk Python To Me and I owe it to both my listeners and sponsors to keep that flowing.

Towards this end, I have built a client (on PyPI) and server (in Python 3 using Flask). The client has the property that if it ever detects a problem with the cache server it will automatically switch back to serving from the source location. In my example, if the cache server has issues it will fall back to serving files directly out of S3. This gave me enough confidence to not worry about depending on yet another layer / tier.

Moreover, the server is super easy to setup and is built to automatically sync with the files that it needs to server from the source. So for example in my case, imagine the web server were trying to serve 100_yay_show_one_hundred.mp3 and that file existed in a preconfigured location on Amazon S3. The very first request to the cache tier would trigger the cache server to get it from S3 and all subsequent requests on the main website would detect the presence of this file in the caching tier and use the cache server rather than the more expensive S3.

You’ll notice I speak often of price. But we could just as well swap it for speed or reliability. Imaging you have a slow source server, this same setup would allow you to offload almost all the network traffic and serve it out of the (presumably) much faster cache server. Additionally, I have much more control over my own server and can get better analytics rather than just sending them off to S3.

This setup serves a tremendous amount of data without any glitches. When a new podcast episode is released, the actual network traffic hits around 900 Mbit/sec for several minutes. Yet the CPU load and memory usage remains very low, the latency of the web app is low, and things keep on serving.

Introducing Cache Tier

I call my project cache-tier. It’s of course open source on GitHub at:

https://github.com/mikeckennedy/cache-tier

and you can get the client via pip:

  pip3 install cache-tier

It’s built for Python 3 but should be easily converted to Python 2 if there is interest.

You can read the steps to setup a bare Ubuntu server to run the server here:

https://github.com/mikeckennedy/cache-tier/blob/master/docs/setup/setup-cache-tier-server.txt

Create a new Ubuntu VM and follow along. You’ll be running in no time.

Using the client

The client code is on PyPI as cache-tier. To get started just pip install it:

  pip3 install cache-tier

Then you use it as follows.

Call verify_file(base_file_name) to check for a cached file as well as to trigger a sync if needed. If verify_file returns True it’s safe to send the user (via a 301 redirect) to the URL generated by build_download_url(base_file_name).

Configuring the server

One possible deployment is to use nginx + uWSGI + the web app. This document describes the steps to set this up on Ubuntu:

https://github.com/mikeckennedy/cache-tier/blob/master/docs/setup/setup-cache-tier-server.txt

You will need to set a few settings. Change these two settings before the server-side will work correctly:

File: ./etc/nginx/sites-available/cache_tier_webapp
Value: server_name downloads.YOURDOMAIN.com;

File: ./config_data/prod.json
File: ./config_data/dev.json
Value: download_base_url: “https://s3.amazonaws.com/USERNAME/BUCKET/FOLDER/”

(Note: Amazon S3 is just one option, any public HTTP file server would work)

Listen to the opening interview before the show comes out right here:

You might be thinking, but I don’t live in San Diego! Don’t worry, they have you covered! Every session over the next 6 months are being streamed live from the Crafting Bytes YouTube channel:

https://www.youtube.com/channel/UCM4g18nauWI2pAuaiC6bWgw

After the six months diving into Python, I’ll put out a before and after podcast episode that follows them through the whole journey. The first one is already in the past, but here’s the video! The next session is coming soon. Put it on your calendar: 4th Wednesday of every month at 5:45pm.

Video from first session:

Hope you join the party. Become a member of their group on meetup.com:
http://www.meetup.com/San-Diego-Technology-Immersion-Group-SDTIG/

@mkennedy

Talk Python To Me – Episode #16 Python at Netflix
http://www.talkpythontome.com/episodes/show/16/python-at-netflix

In case you missed them, there have been a ton of other amazing Python shows. Check them out:

• #15: Python at Spotify, PSF, and PyLadies
• #14: Moving from PHP to Python 3 with Patreon
• #13: Flask web framework and much, much more
• #12: Deep Dive into Modules and Packages
• #11: PyImageSearch and Computer Vision
• #10: Bringing Python to the Masses with Hosting and DevOps at PythonAnywhere
• #9: Docker for the Python Developer
• #8: Teaching Python at Grok Learning and Classrooms
• #7: Robot Operating System (ROS) and ROSPy
• #6: Requests, PyCon, and Python’s future
• #5: SQLAlchemy and data access in Python
• #4: Enterprise Python and Large-Scale Projects
• And more…

Thanks guys!

Listen in now, hope you enjoy the show!

In this show we speak with Jesse Davis from MongoDB. Jesse is the maintainer for a number of popular open-source projects including the Python MongoDB driver known as PyMongo and Mongo C (for C/C++ developers, yes you read right! C developers). Jesse discusses how interesting it is to write both Python and C code and how it reawakens part of the brain.

You’ll learn a little about MongoDB, how it compares to RDBMSes as well as other NoSQL data stores.

Join Michael and Jesse for these great topics and much more!

Visit the website to learn more:

Talk Python To Me – http://www.talkpythontome.com/

Subscribe to the Podcast via the iTunes feed, become a friend of the show and follow us on twitter as well!

Python Cheat Sheet.pdf

If you find this useful please mention it on Twitter or forward it to a friend.

Want deeper Python training? Check out my over two hours of Python videos on my YouTube channel and consider my DevelopMentor Python courses for classroom training. I’m also the host of the Talk Python To Me Podcast. Be sure to subscribe and listen to some great conversations.

** I’m honored to be one of only 35 MongoDB Masters for 2015! **

Initialization in Modern C++ vs Apple’s Swift

A little while ago I wrote a short post comparing some of the basic features of Modern C++ and Apple’s Swift. It was far from comprehensive, basically only touching on the constructs mentioned in Michael Kennedy’s post Comparison of Python and Apple’s Swift Programming Language Syntax. However the post did generate enough interest that I decided to continue the comparison by looking at one of the differences I find interesting between the two languages, initialization. Initialization is very important in any language and both C++ and Swift have built in constructs and checks to help make sure that objects get completely initialized before they are used.

Initialization syntax

Let us start with the syntax of the two languages.

Objects are initialized in C++ through constructors. A constructor has no return value and the same name as the class.

// C++
 class Person {
 public:
 Person() {} // Constructor
 };

In Swift objects are initialized through initializers. An initializer has no return value and its name is init.

// Swift
 public class Person {
 public init() {} // Initializer
 }

Invoking a constructor or an initializer is similar.
Note: I am only pointing out the syntax here, how the objects are being allocated is different.

// C++
 Person p;
 // or
 auto p = Person();

// Swift
 var p = Person()

Constructors and initializers can be used to set initial values for fields.

// C++
 class Person {
 int _age;
 public:
 Person() : _age(25) { }
 };

// Swift
 public class Person {
 var _age : Int
 public init() { _age = 25 }
 }

Fields can also be inline initialized.

// C++
 class Person {
 int _age = 25;
 public:
 Person() { }
 };

// Swift
 public class Person {
 var _age : Int = 25
 public init() { }
 }

Constructors and initializers can take parameters. Note: I am only showing that parameters can be passed, and not discussing implicit vs explicit parameters in Swift.

// C++
 class Person {
 int _age;
 public:
 Person(int age) : _age(age) { }
 };
// invoke
auto p = Person(25);

// Swift
 public class Person {
 var _age : Int
 public init(age : Int) { _age = age }
 }
// invoke
var p = Person(age: 25)

Constructors can invoke other constructors in the same class.

// C++
 class Person {
 int _age;
 public:
 Person() : Person(25) { } // invoke the below constructor
 Person(int age) : _age(age) { }
 };

Initializers can invoke other initializers in the same class.

// Swift
 public class Person {
 var _age : Int
 public convenience init() {
 self.init(age: 25) // invoke the below initializer
 }
 public init(age : Int) { _age = age }
 }

Constructors and initializers can invoke their base class’s initializers or constructors.

// C++
 class Person {
 int _age;
 public:
 Person(int age) : _age(age) { }
 };

class Student : public Person {
 int _id;
 public:
 Student(int age, int id) :
 Person(age), // invoke base constructor
 _id(id)
 {}
 };

// Swift
 public class Person {
 var _age : Int
 public convenience init() {
 self.init(age: 25) // invoke the below initializer
 }
 public init(age : Int) { _age = age }
 }

public class Student : Person {
 var _id : Int
 public init(age: Int, id: Int) {
 _id = id
 super.init(age) // invoke base constructor
 }
 }

Order of initialization

Now that we have seen the basics of the initialization syntax of C++ and Swift, let us get to the interesting part, order of initialization.

In C++ the order of construction is determined by the class declaration.

Objects are initialized from the top down in the inheritance heiarchy. Base classes first left to right then data members top to bottom. Given the following code:

// C++
 // Given the following classes
 class Person {
 int _age;
 public:
 Person(int age) : _age(age) {
 // constructor code
 }
 };

class Student : public Person {
 int _id;
 public:
 Student(int age, int id) :
 Person(age), // invoke base constructor
 _id(id)
 {
 // constructor code
 }
 };

When an instance of a Student is created.

auto s = Student(25, 1001);

The constructor for Person will be executed first. It will initialize _age and execute any code in the constructor body. Then _id will be initialized and finally the the code in the Student constructor will be executed.

This is straight forward single-phase construction that works well in C++.

In Swift initialization is done in two-phases.

Two-phase initialization takes a different approach. Instead of completely initializing the base class protion of the object, i.e. initializing the data as well as executing the initialization code, before initializing the sub class protion, it separates the initialization of the data from the initialization code.

The first phase, initializes the data starting with the sub class fields and working its way up to the base class fields. The compilier will enforce this so that you cannot call super.init before all sub class fields have an initialized value and you will not be able to invoke any methods on the sub class until super.init finishes. The second phase then executes code that can now safely access any fields because they are guarenteed to be initialized.

// Swift
 // Given the following classes
 public class Person {
 var _age: Int
 public init(age: Int) {
 _age = age
 // initialization code
 }
 }

public class Student : Person {
 var _id: Int
 public init(age: Int, id: Int)
 {
 _id = id
 super.init(age)
 // initialization code
 }
 }

When an instance of a Student is created.

var s = Student(25, 1001);

First the field _id would be initialized, then super.init would be called, then _age would be initialized. This would complete the first-phase and the second-phase would then execute any initialization code.

Swift uses two-phase initialization to prevent code from accessing the memory of an object before it has been initialized which might happen if you were to call a method (which is dynamically bound by default) from a base class initializer.

// Swift
 public class Person {
 var _age: Int
 public init(age: Int) {
 _age = age
 print() // dynamically bound
 }
 public func print() { println("age: \(_age)") }
 }

public class Student : Person {
 var _id: Int
 public init(age: Int, id: Int) {
 _id = id
 super.init(age) // invoke base initializer
 }
 override public func print() {
 super.print()
 println("id: \(_id)")
 }
 }

Because _id is initialized before super.init is invoked the following code:

var s = Student(age: 25, id: 1001)

Prints out:

age: 25
 id: 1001

In C++ dynamic binding is not fully set up until construction is complete so the above example in C++ would result in the print function on Person being called instead of the print function on Student.

// C++
 class Person {
 int _age;
 public:
 Person(int age) : _age(age) { print(); }
 virtual void print() const {
 std::cout << "age: " << _age << std::endl;
 }
 };

class Student : public Person {
 int _id;
 public:
 Student(int age, int id) :
 Person(age), // invoke base constructor
 _id(id)
 {}
 void print() const override {
 Person::print();
 std::cout << "id: " << _id << std::endl;
 }
 };

In C++ _id is not initialized before Person’s constructor is invoked but the v-table used for dynamic binding is also not fully set up so Person::print gets called and the following code:

auto s = Student(25, 1001);

Prints out:

age: 25

Note: In Java _id would not be initialized and print would be dynamically bound allowing the access of uninitialized memory.

Two-phase initialization can be implemented in C++ and there are many discussions on the pros and cons of its use. This post is not concerned with addressing those. The intention of this post is to simply point out the difference between C++’s build in initialization mechanism and Swift’s.

I’m really happy to announce the latest course I’ve co-authored at DevelopMentor:

The Swift Programming Language
https://www.develop.com/training-course/the-swift-programming-language

This course is specifically build to help teams of existing Objective-C developers quickly but thoroughly get up to speed with Swift. Here are details on the course, read more at DevelopMentor.

Yesterday I stumbled across an excellent article by Mahmoud Hashemi from the PayPal engineering team entitled 10 Myths of Enterprise Python.

No. Seriously. It’s really good. Make sure you save it to your reading list.

10 Myths of Enterprise Python
https://www.paypal-engineering.com/2014/12/10/10-myths-of-enterprise-python/

I have been teaching a lot of Python at DevelopMentor and most people who are learning Python are coming to it from one of two places. Either they are experienced with another language but not Python or they know Python but only just enough to keep some basic scripts running.

While teaching the in’s and out’s of Python is a key goal, another thing we try to convey is that Python is a serious, full stack, professional, and comprehensive platform. For most projects, I’d gladly put Python up against C# / .NET, Java, and C++.

Mahmoud’s post conveys the same basic idea. The beautiful thing about his post is that he backs this up with solid usage and large enterprise data.

Here are a few key myths dispelled in the post:

False Myths about Python

• Python is not compiled
• Python is not secure
• Python is a scripting language
• Python is weakly-typed
• Python is slow
• Python does not scale
• Python is not for big projects

The large scale use of Python is particularly impressive. For example, Mahmoud writes:

Scale (as in performance)

Scale has many definitions, but by any definition, YouTube is a web site at scale. More than 1 billion unique visitors per month, over 100 hours of uploaded video per minute, and going on 20 percent of peak Internet bandwidth, all with Python as a core technology. Dropbox, Disqus, Eventbrite, Reddit, Twilio, Instagram, Yelp, EVE Online, Second Life, and, yes, eBay and PayPal all have Python scaling stories that prove scale is more than just possible: it’s a pattern.

Scale (as in size)

Myth #7 discussed running Python projects at scale, but what about developing Python projects at scale? As mentioned in Myth #9, most Python projects tend not to be people-hungry. while Instagram reached hundreds of millions of hits a day at the time of their billion dollar acquisition, the whole company was still only a group of a dozen or so people. Dropbox in 2011 only had 70 engineers, and other teams were similarly lean. So, can Python scale to large teams?

Bank of America actually has over 5,000 Python developers, with over 10 million lines of Python in one project alone. JP Morgan underwent a similar transformation. YouTube also has engineers in the thousands and lines of code in the millions. Big products and big teams use Python every day, and while it has excellent modularity and packaging characteristics, beyond a certain point much of the general development scaling advice stays the same. Tooling, strong conventions, and code review are what make big projects a manageable reality.

Hopefully this has given you a new perspective on Python. Once again, you really should check out the original article:

10 Myths of Enterprise Python

Also, if you’re coming at this from a .NET perspective, be sure to watch my video comparison of the two ecosystems.

Video: https://michaelckennedy.wordpress.com/2013/12/18/watch-python-for-the-c-and-net-developer/
(doesn’t work on Firefox, sorry)

Slides: http://www.slideshare.net/mkennedy66996693/python-for-the-c-developer

What a week! Time to announce the second course this week I’ve written for DevelopMentor along with my co-author Bradley Needham.

Essential Swift iOS and OS X Programming Course

If you’re ready to start building iOS and OS X applications with Apple’s latest language, check out our course.

Here’s some more background on this course.

https://www.develop.com/training-course/essential-swift-ios-and-os-x-programming

When Apple announced the Swift programming language to cheering crowds at WWDC 2014, we knew it would be important. Swift is destined to replace the aging Objective-C language which was introduced over 32 years ago. Swift is built upon three core principles: safe, modern, and powerful. It fulfills these principles by borrowing the best features from modern languages such as Python, C#, modern C++, and others. While Swift adopts modern high-level language features it also improves upon Objective-C’s native performance and is actually faster than its predecessor.

This course is a deep, practical, and hands-on exploration of the Swift language and surrounding ecosystem. You will learn why Swift was introduced. You will see how Swift is a safe, modern, and powerful language. You will learn how to build iOS (iPhone and iPad) applications as well as native OS X applications using Xcode. All of these lessons will be reinforced with hands-on exercises and many example applications built live during class.

There are cross-platform options for building iOS and OS X applications. However, if you are ready to go all in on the Apple ecosystem you need to learn Swift today. This comprehensive course is a great place to start.

Course Outline

Day 1

• Introduction to Swift for iOS and OS X
• Language Basics
• Types and collections
• Functions and closures

Day 2

• Optionals, Optional Chaining, and Generics
• Classes and Structures
• Protocols and Extensions
• Memory management

Day 3

• Day of iOS

Day 4

• Day of OS X

Read more on develop.com …

I’m very exited to announce the latest course I’ve written for DevelopMentor:

MongoDB for Python Developers

If you’re looking for MongoDB training for you or your team, please consider DevelopMentor. We also have my MongoDB for .NET developers course if you live in the .NET camp.

Here’s some more background on this course.

MongoDB for Python Developers

This course is a deep exploration of building applications in MongoDB (the most popular NoSQL document-database). There are many benefits to choosing a NoSQL database over traditional RDMBSs such as SQL Server or Oracle. This course starts out by looking at why you should choose a NoSQL database in the first place. We will explore the native query language and capabilities of MongoDB. Then we will start working with MongoDB from our Python applications and look at several topics that explore the advanced aspects of the MongoDB Python API including MongoDB from Python, PyMongo, ODMs such as MongoEngine, and more. We will see how to leverage the immense scalability of MongoDB using the aggregation framework, replica sets, and sharding. You will discover how to store and manage files of virtually unlimited size in MongoDB using GridFS. We will discuss how to properly design your entities and documents (both natively and in Python) to take full advantage of what MongoDB has to offer. Finally, we will round out the course with a few topics that you will need to be successful with MongoDB including Server administration for developers and Security and permissions.

Note that some of the topics cover in this course are technology agnostic (for example the native query lesson is equality applicable to Python developers as well as .NET or Java developers) and some are specifically optimized for Python developers (for example MongoEngine and ODMs).

Why should you choose DevelopMentor’s MongoDB course? At DevelopMentor we have experience building and running large scale MongoDB deployments including our online learning platform LearningLine and develop.com itself. The course authors work closely with the MongoDB team and are in the MongoDB Masters program. We have been teaching MongoDB in our Python courses and our Guerrilla .NET course for several years. In short, we know what we’re doing with MongoDB and Python and we’d love to share it with you.

Course outline

Day 1

• Why NoSQL and why MongoDB?
• The shell and ‘native’ commands
• MongoDB from Python

Day 2

• Real world MongoDB with MongoEngine
• Entity Design
• Indexing and profiling

Day 3

• GridFS – A file system within MongoDB
• Aggregation framework
• Server administration for developers

Day 4

• Replication
• Sharding
• Security and permissions

Read more on develop.com …

Here’s Bradley and C++ vs. Swift. Thanks Bradley!

When Michael wrote his Python vs Swift article, I found it interesting how similar each of these languages (Python, C#, and Swift) are and thought it might be worth having a similar article comparing Modern C++ and Swift.

Code Comments

Swift has the same comments as C++ with a twist:

// C++ single line comment
// Swift single line comment

/* C++ Multiline
comment but cannot nest */

/* Swift Multiline
comment but /*can*/ nest */

Constants and Variables

Swift is strictly typed but also makes use of type inference. C++ is also strictly typed and makes use of type inference.

var age = 25 // An inferred initialized Int variable in Swift
var salary : Float // An explicit uninitialized Float in Swift

auto age = 25; // An inferred initialized int variable in C++
double salary; // An explicit uninitialized float in C++

let pi = 3.1415 // Constant in Swift

const auto pi = 3.1415; // Constant in C++

Strings

Swift treats double-quoted literals as the String type. C++ treats double-quoted literals as a zero-terminated const char[] but does have a standard string type that can be used.

var msg = "A String in Swift"
var s = msg.utf16Count // s is 17

auto msg = "A zero-terminated const char[] in C++";
auto s = msg.length(); // error no such member

auto msg1 = std::string("A string in C++");
auto s = msg.length(); // s is 15

Both Swift and C++ support unicode. Swift provides the String type and C++ std::u16string.

Arrays

Swift supports dynamically-growable arrays. C++ has std::vector which offers similar functionality.

Declaring

// Swift
var nums = [1,2,3,5,7,11]
var strings = ["hello", "how are you", "goodbye"]

// C++
auto nums = std::vector {1,2,3,5,7,11};
auto strings = std::vector {"hello", "how are you", "goodbye"};

Using

Here is a comparison of using arrays in the two languages.

// Iteration in Swift
var nums = [1,2,3,5,7,11]
for n in nums {
println(n)
}

// Iteration in C++
auto nums = std::vector<int>{1,2,3,5,7,11}<wbr />;
for (auto n : nums) {
std::cout << n << "n";
}

// Updating values
nums[2] = 10 // Swift
nums[2] = 10 // C++

// Check for elements
// Swift
if !nums.isEmpty {
println("nums is not empty")
}

// C++
if (!nums.empty()) {
std::cout << "nums is not emptyn";
}

// Adding items
nums.append(7) // Swift
nums.push_back(7) // C++

Dictionaries

Swift has build in support for dictionaries. C++ has std::map and std::unordered_map.

// Swift
var cust = ["name": "Brad", "state": "CA"] // initialize

var the_name = cust["name"] // access value
cust["name"] = "Bradley" // change value
cust["hobby"] = "Swimming" // add key/value
cust.removeValueForKey("hobby") // remove key/value

// C++
auto cust =
std::map<std::string, std::string> {{"name", "Brad"}, {"state", "CA"}};

auto the_name = cust["name"]; // access value
cust["name"] = "Bradley"; // change value
cust["hobby"] = "Swimming"; // add key/value
cust.erase(cust.find("hobby")); // remove key/value

Both languages also allow for checking for the existence of a key

// Swift
if let theHobby = cust["hobby"] {
println("Your hobby is (theHobby)")
}

// C++
try {
auto theHobby = cust.at("hobby");
std::cout << "Your hobby is " << theHobby << “\n";
} catch (...) {
}

// C++
auto it = cust.find("hobby");
if (it != cust.end()) {
std::cout << "Your hobby is " << it->second << “\n";
}

Conditional statements

Swift allows the removal of parenthesis, C++ requires them.

// Swift
var n = 42
if n < 40 {
println("n is less than 40")
} else {
println("n is 40 or above")
}

if (n == 42) { // works with or without parenthesis
println("the answer")
}

// C++
if (n < 40) { // must have parenthesis
println("n is less than 40")
} else {
println("n is 40 or above")
}

if (n == 42) {
println("the answer")
}

// conditional and logic operators are the same
// &&, ||, <=, >=, !, ==, etc.

Switch statements

Default behavior differs between languages. At the end of a case statement, Swift has an automatic break while C++ falls through to next case.

// Swift
switch (i)
{
case 1:
// do work
case 2:
// do work
default:
// do work
}

// C++
switch (i)
{
case 1:
// do work
break; // must explicity break out of switch
case 2:
// do work
break; // must explicity break out of switch
default:
// do work
break; // must explicity break out of switch
}

fallthrough keyword is used to fall through a case in Swift. In C++, removal of the break causes a fall through

// Swift
switch i
{
case 1:
// do work
case 2:
// do work
fallthrough // must explicity fall through
default:
// do work
}

// C++
switch (i)
{
case 1:
// do work
break; // must explicitly break out of switch
case 2:
// do work
// no break will fall through
default:
// do work
break; // must explicitly break out of switch
}

Swift allows for switching on Strings, C++ does not

// Swift only
switch str
{
case "hello":
// do work
case "goodbye":
// do work
default:
// do work
}

Swift allows for range cases. C++ uses the default fall through to accomplish similar functionality

// Swift
switch i
{
case 1...3:
// do work
default:
// do work
}

// C++
switch (i)
{
case 1:
case 2:
case 3:
// do work
break;
default:
//do work
break;
}

Functions

Both languages have rich support for functions, including lambdas, function objects, and tuples.

// Swift
func getUser(id : Int) -> (String, String) {
var username = "username"
var email = "email"
return (username, email)
}

var (n, e) = getUser(1) // n = username, e = email

// C++11
auto getUser(int id) -> std::tuple<std::string, std::string> {
auto username = "username";
auto email = "email";
return std::make_tuple(username, email);
}

// C++14
auto getUser(int id) {
auto username = "username";
auto email = "email";
return std::make_tuple(username, email);
}

std::string n, e;
std::tie(n, e) = getUser(1);

Conclusion

Most modern 3rd-generation languages have many similarities, it just takes getting use to the small differences in order to be able to code between them. Once you get past the language issues, you can spend your time on the platform API which is the thing that really lets you get your work done.

Show 951:  Python on .NET with Michael Kennedy

Back in February, I had the honor of being the guest on the .NET Rocks podcast with Carl Franklin and Richard Campbell. We talked about the similarities between Python and C# and the Python and .NET ecosystems. It was a great show and I think you’ll find it interesting if you are a .NET or Python developer.

Listen to the whole show at the .NET Rocks page or you can stream the MP3 directly from the .NET Rocks website.

On OS X and Linux, we can use a special kind of comment at the top of our script called a shebang.

#!/usr/bin/env python3
# normal python code here...

This tells the OS which Python runtime to select and allows the script to be executed directly. For example, imagine that file was named program.py. Without the shebang, if we type simply ./program.py we likely will get an error. We have to specify which version of Python by running python3 ./program.py. This has several problems. It’s not obvious to users they have to do this to run the script. Moreover, if that program is for Python 2 and we guess to use Python 3 too bad for us! The shebang solves both of these for us… on OS X and Linux.

Shebangs on Windows

If you try this little trick on Windows, you are likely to be disappointed even if you have Python installed. One possibility is to get this lovely experience.

Another possibility is you’ll see a dialog to choose how to run *.py files.

If you pick Python.exe you may get the right outcome. But now all Python scripts are  tied to a single Python version (Python 2 or Python 3). What we need is to fix this with something like the shebangs of Linux.

Consider this simple program that states the version of Python executing it.

import sys

ver = sys.version_info[0]
print("Hello from Python {}".format(ver))

Notice that if we directly execute it by specifying the Python version to run, it works great.

Nice. But we still have the problem of the user deciding which version of Python to try (not good). Since Python 3.3, they have introduced a program named Python Launcher for Windows. This lovely little program allows us to use shebangs to let the script select its version.

#!/usr/bin/env python2
import sys

ver = sys.version_info[0]
print("Hello from Python {}".format(ver))

Now if we have the Python 2 shebang or Python 3 shebang, we get the perfect behavior. This is as long as we directly specify the Python launcher (c:\windows\py.exe)

Note we can even keep the /usr/bin/env for compatibility with Linux & OS X. But directly executing the script still fails.

Luckily, we can teach Windows to use the Python Launcher rather than locking to a particular installed version of Python. In an admin command prompt, run these two commands.

Success

Now, try to directly execute your script. Notice that simply changing the shebang controls the version selected by the operating system.

Props to my DevelopMentor colleague Pinku Surana for the tips about putting all of these together.

Learning Python?

If you or your team need to get up to speed on Python, consider my series of Python classes at DevelopMentor.

https://www.develop.com/training-courses/python

This post will explore the syntax of Python 3 vs Swift. I was inspired by Chris Pietschmann’s post Basic Comparison of C# and Apple Swift Programming Language Syntax for C# and Swift. So here is the Python version.

Before you review the syntax comparisons, you may want to download the code in Python, Swift or both:

Downloads

• Python: PythonVsSwift.py.zip
• Swift: SwiftComparedToPython.playground.zip

Code Comments

Both languages have comments:

# Python has single line comments 
 
// Swift has single line comments
/* Swift also has multi-line
   comments in C style
*/

Declaring Constants and Variables

Swift has rich support for type inference and constants. Python is dynamic and does not natively support constants.

name = "A string variable in Python"
age = 42 # An integer variable in Python
 
var name = "A string variable in Swift"
var age : Int // An explicit integer variable in Swift
age = 42
 
let pi = 3.14 // Constant in Swift

Integer Bounds

# Python does not have upper bounds for integer numbers (Python 3)
large_nun = 10000000000000000000000000000000000000000000000000000
 
// Swift
var a = Int32.min
var b = Int32.max

Type Inference

Swift is a strongly-typed language which makes heavy use of type-inference although you can declare explicit types. Python is a dynamic language so while there is a type system it is not evident in the syntax.

# Python
name = "Michael" # string variable, but can change
name = 42        # would run
n = 42           # currently an int
d = 42.0         # currently a float
 
// Swift
var name = "Michael" // string
name = 42            // Error
var n = 42           // int
var d = 42.0         // double

String Comparison

Python and Swift both have Unicode strings. Python generally has richer string support than Swift (especially around string formatting).

# python
a = "some text"
b = "some text"
if a == b:
    print("The strings are equal")
 
# swift
var a = "some text"
var b = "some text"
if a == b {
    println("The strings are equal")
}

Both languages have many functions on strings

# python
if a.startswith("some"): 
     print("Starts with some")

if a.endswith("some"):
     print("Ends with some")
 
// swift
if a.hasPrefix("some") {
     println("Starts with some")
 }
 
if a.hasSuffix("some") {
     println("Ends with some")
 }

String Upper or Lower Case

# python
s = "some text"
u = s.upper()
l = s.lower()
 
// swift
var s = "some text"
var u = s.uppercaseString
var l = s.lowercaseString

Declaring Arrays

Neither language has strict array types in the sense of C-based arrays. The arrays in Swift and Python are closer to lists. Python’s lists are not typed (hence can be heterogeneous).

# python
nums = [1,1,3,5,8,13,21]

// swift
var nums = [1,1,3,5,8,13,21]          // int array
var strings = ["one", "two", "three"] // string array

Working with Arrays

# Iteration in python
nums = [1,1,3,5,8,13,21]
for n in nums:
    print(n)
 
# Iteration in Swift:
var nums = [1,1,3,5,8,13,21]
for n in nums {
    println(n)
}
 
# Element access
n = nums[2]      # python, n = 3
var n = nums[2]  # swift,  n = 3
 
# Updating values
nums[2] = 10 # python
nums[2] = 10 # swift
 
# Check for elements
# python
if nums:
    print("Nums is not empty")

// swift
if !nums.isEmpty {
    println("Nums is not empty")
} 
 
# Adding items:
nums.append(7) # python
nums.append(7) # swift
 
# Slicing
nums = [1,1,3,5,8,13,21]
middle     = nums[2:4]       # python, middle = [3, 5]
var middle = nums[2..<4]     // swift, middle = [3,5]

Dictionaries

Dictionaries play important roles in both languages and are fundamental types.

# python
d = dict(name="Michael", state="OR")
d = { "name": "Michael", "state": "OR" }
the_name = d["name"]
 
// swift
var empty_dict = Dictionary<String, String>()
var d = ["name": "Michael", "state": "OR"]
var the_name = d["name"]

Adding items is the same in both languages. Removing entries is arguably clearer in Swift.

# add an item
d["hobby"] = "Biking" # python
d["hobby"] = "Biking" // swift
 
# remove an item
del d["hobby"]                # python
d.removeValueForKey("hobby")  // swift

Checking for the existence of a key can also be done in both languages.

# python
if "hobby" in d:
    print("Your hobby is " + d["hobby"])
 
// swift
if let theHobby = d["hobby"] {
     println("Your hobby is \(theHobby)")
}

Conditional Statements

Conditional statements are quite similar.

# python
n = 40
m = 2

if n > 40:
    print("n bigger than 40") 
elif m == 2 and n % 2 == 0:
    print("m is 2")
else:
    print("else")
 
# swift
var n = 40
var m = 2

if n > 40 {
    println("n bigger than 40") 
}
else if m == 2 && n % 2 == 0 {
    print("m is 2")
}
else {
    print("else")
}

Switch statements

Swift has them, Python does not.

Functions

Functions are very rich in both languages. They have closures, multiple return values, lambdas, and more. Here is a simple version. Note that this example also leverages tuples and tuple unpacking in both languages.

# python
def get_user(id):
    name = "username"
    email = "email"
    return name,email
 
n, e = get_user(1)
 
// swift
func getUser(id : Int) -> (String, String) {
     var username = "username"
     var email = "email"
     return (username, email)
}
 
var (n, e) = getUser(1) // n = username, e = email

Conclusion

As you can see, the similarities to Python are striking. I expect with some experience transitioning between the languages will be easy. The major differences actually lie underneath at the standard library vs cocoa base classes. As with most languages, this is where the real mastery of the platform happens.

Please vote for this request on UserVoice:

Ship Python 3 and Python 2 with Windows 10
https://windows.uservoice.com/forums/265757-windows-feature-suggestions/suggestions/6693586-ship-python-3-and-python-2-with-windows-10

Ubuntu and OS X include the Python runtimes by default. Please Include the 64-bit version of Python 3 and Python 2 with Windows.

I believe many developers choose OS X and Linux over Windows because these OSes are more open source and CLI friendly. You have done a lot of fix the CLI experience in Windows 10. Please make Python development better on Windows by including it out of the box.

Need more inspiration? Watch this video about the future of Python (hint: it involves Windows)