The Coronavirus Bar Chart Race: Don’t Even Compete

I created a Coronavirus bar chart race using Matplotlib. There is no winning in this race.

I miss seeing people. I miss getting on the subway. I miss dinging the Citi Bike bell. Given that one of the #1 things on my mind is the Coronavirus, I went through this tutorial, “Bar Chart Race in Python with Matplotlib” and created my own race using this updated COVID-19 dataset.

In this blog post, I share my bar chart race, talk about my observations, and visualize the rapid growth of cases aboard the Diamond Princess cruise ship. You can follow along my code in Jupyter Notebook here.

The First Month

The data starts from January 22nd. China’s confirmed cases are staggering compared to the rest of the world. At this point, the countries with the most cases are well below one hundred. Only after the first month do we see several Asian countries increase. However, South Korea, Italy and Iran’s numbers increase even faster, surpassing those countries.

For the first month, the rest of the world seems quiet. Looking back, it’s sad to know that death and pain would be waiting to happen. I’m imagine life going on as normal for others with the idea that “this wouldn’t happen to me.” If only we knew! Have you seen the Washington Post social distancing visual? This could’ve been prevented (Hindsight 20/20, right?).

Out of Control

By the second month, the rest of the world picks up at scary rates. And we see the appearance of the United States.

The United States violently overtakes the rest of the countries and is in a similar position as China during the first month. This is the race you do not want to win. We can see that South Korea, one of the earliest countries with the most confirmed cases, “flattened its curve.” One friend of mine, upon recently returning to South Korea, was tested, and put under mandatory self-quarantine. She was required to download an app that tracked her location. If she went too far out of her home location, an assigned government officer would contact her. This enforcement is justifiable as the data shows that this virus will ravage any country that reacts too slowly.

The Infected Diamond Princess

This is a visualization of the Diamond Princess cruise ship’s daily growth of COVID-19 cases over time. It’s crazy to see the cases skyrocket. The boat, containing 3,711 passengers, reaches seven hundred cases in 2 weeks, or 18%. In other words, of a family of five, one will get the Coronavirus.

I think of the cruise ship’s thorough sanitary procedures like crew members spritzing disinfectant saying, “washy washy,” as well as trained medical staff on board. But a cruise ship is in the middle of the ocean with people in constant proximity of each other. Is the ship by its nature a place for disaster? What can cruise lines do to prevent this from happening again?

Hope for all

We’re still in this crisis and I hope to see the numbers stop increasing. I hope that the countries that just hit their 100th confirmed case this week are learning from what has happened and use our hindsight 20/20 to save themselves. It’s not too late.

Which NYC museums are near you? A Tableau and Webscraping project.

Over the last year I’ve enjoyed visiting art museums especially in NYC. It’s great to go with a couple of friends and get blown away by a huge range of creations. One day I’ll stand side by side with a massive steel sculpture and another I’ll squint my eyes at a tiny painting to scan over its intricate details. In NYC, there are many museums to visit, and I found an NYC public dataset that gives the coordinates and address information for each one. I will plot them out with Tableau.

I also got more data to add context to the NYC dataset by getting the museum’s category and description so that you’ll know a little bit more about the museum when you look at the map. I webscraped museums on Wikipedia and supplemented the public dataset with as much data as possible.

You can follow along with my code from my Jupyter Notebook here.

Below is a map of NYC Museums. Plentiful from midtown upwards. We’ll look closer into each area.

Interact with the map on Tableau here.

Lower East Museums

There is a handful across Lower East Side along the same latitude.I think I could take a weekend to visit that cluster. Some of the museums on the Lower East include: The Tenement Museum, The Italian American Museum, and the Children’s Museum of the Arts. I’ve highlighted details of the New Museum below.

FiDi Museums

Towards the end of the island, we have the Museum of Jewish Heritage and the Skyscraper Museum. We also have the American Indian museum and the 9/11 Museum. Off the island, we have Ellis Island Statue of Liberty as well as a sprinkle of Brooklyn museums. I haven’t visited any of the museums there but I heard the Brooklyn Museum is amazing. Will visit soon!

Midtown and Upper NYC Museums

We have many midtown to Upper East Side museums and within Central Park the beautiful, legendary MET as well as more modern art at the Whitney Museum. Even higher up we have regional and traditional focused art including the The Studio Museum and the Jazz Museum in Harlem.

The Data

After collecting more data to add to the public dataset, 52/132 or 39% of my museum data points have location details, a description and/or a category (some are still missing). The rest, 50/129 or 61% of my data contain only name location details. After I scraped the Wikipedia link of NYC museums and filled in missing data on Excel, I wasn’t able to get the last 79 without googling each address. On the interactive map, toggle “Null” on the interactive map to see the rest of the data points without descriptions.

What Museums Mean To Me

Visiting museums has helped me envision differently and wonder beyond what I can imagine. I’m glad that there are so many establishments and galleries across NYC that allow me to learn about other cultures and enjoy a different way to see the world. Thank you.

Explore the map here

You can see my Python code from jupyter notebook here

NYC biking can be dangerous because of aggressive driving and an overwhelming amount of cars. But as we’ll soon see, they’re not the only…

I’ve been riding Citi Bikes for a year now and it’s hands on the handles my favorite way to get around NYC. I think it’s so convenient and fun to zoom around the streets and enjoy the city’s amazing atmosphere. I’m thankful for the plethora of bike docks and safe bike lanes that allow me to have these experiences.

On the contrary, NYC biking can be dangerous because of aggressive driving and an overwhelming amount of cars. In this blog post, I look into an NYC public dataset of collisions involving bikes in Manhattan in January and February 2020. Furthermore I look closer into the details to see why these accidents occurred and what vehicles were involved. We’ll soon see that it may not be the drivers and cars that are the only problems.

You can read along my code in my jupyter notebook here.

The NYC Motor Vehicle Collision Dataset

The original data source is NYC public safety motor vehicle collision crashes. The data shows the exact location of accidents, why they occurred, what vehicles were involved, number of cyclists hurt, time and date of crash. I filtered January and February 2020 accidents in Manhattan and used python pandas to keep only the rows with bicyclists that were either injured or killed (In my data, there were no deaths, fortunately!) The dataframe contains 65 accidents. Here are screenshots of the first 5 rows in two parts. Let’s look at what the data is showing.

1. Vehicle_type_code_1 (first party involved in accident aka vehicle 1) refers to the specific vehicle involved.
2. Contributing_factor_vehicle_1 is the reason why vehicle 1 contributed to the accident. It contains reasons like turning improperly, driver inattention/distraction and backing unsafely.
3. Vehicle_type_code_2 and Contributing_factor_vehicle_2 mean the same thing as vehicle 1 but the second party involved.

Let’s analyze our data.

What’s Causing The Accidents?

The dataset is organized with vehicle 1 (a driver or biker) as the cause of the accident while occasionally vehicle 2 (the other driver or biker) is blamed as well e.g. both drivers were distracted.

56/65 or 86% of accidents had contributions from vehicle 1 drivers because of:

Driver Inattention/Distraction                           19
Unspecified                                              11
Passing or Lane Usage Improper                            6
Passenger Distraction                                     4
Pedestrian/Bicyclist/Other Pedestrian Error/Confusion     3
Failure to Yield Right-of-Way                             3
Turning Improperly                                        2
Following Too Closely                                     2
Backing Unsafely                                          2
Passing Too Closely                                       1
Traffic Control Disregarded                               1
Unsafe Lane Changing                                      1
Driver Inexperience                                       1

The top reason was driver inattention at 19/56 or 34% and reason “unspecified” in second place. We’ll talk a little about unspecified later. Other reasons include passing, lane usage improper and passenger distraction.

It’s interesting to read through the lists of reasons to be more aware of these possibilities so that I can be even safer when I’m biking. With 4/56 or 7% of accidents from distracted passengers, I can only imagine how this could’ve cause the accident. Playing music too loud? Talking too much to the driver? Passenger rage towards biker?

And It’s Not Just Drivers

Vehicle 1 consists not only of drivers but bikers too. 9/65 or 14% of vehicle 1 category were made up of bikers with accidents caused because of:

Driver Inattention/Distraction    6
Aggressive Driving/Road Rage      1
Passing Too Closely               1
Unspecified                       1

The top reason was biker inattention/distraction at 67%. The second and third reason are aggressive biking / rage and passing too closely. Lessons learned: Pay attention, keep a cool head, and get space!

As for “unspecified” reasons by the biker, the reason is also unspecified or missing a reason for vehicle 2, the second party. I assume that there could’ve been a multitude of reasons like unable to conclude what the exact cause. It would be interesting to know the circumstances to lead to two unknown reasons.

On the other hand, these are some of the reasons how the accidents were caused by both parties:

The majority of reasons is that both drivers were distracted or not paying attention. Other combinations are cars backing up unsafely while the bike was too close or some kind of error or miscalculation from either driver or biker that caused the accident. Some of the other accidents were caused by Pedestrian/Bicyclist/Other Pedestrian Error. I was wondering what this could possibly be but when I spoke about these accidents with a friend, she told me a personal story. There was a time she was crossing the street texting and did not notice an incoming bicyclist heading her way. The bicyclist tried to avoid her and crashed!

Who is Most Responsible For The Accidents?

Let’s look at what vehicles were involved in the overall accidents.

Taxi                                   20
Station Wagon/Sport Utility Vehicle    16
Bike                                   14
Sedan                                  13
Pick-up Truck                           2
Box Truck                               2
Van                                     1
Armored Truck                           1
Bus                                     1

About 30% of the accidents were caused by taxis, 24% caused by station wagon or SUVs, and 20% of accidents were caused by the bikers! Let’s look closer into how Taxis caused the most accidents.

Driver Inattention/Distraction                           6
Passing or Lane Usage Improper                           4
Unspecified                                              3
Following Too Closely                                    2
Passenger Distraction                                    2
Pedestrian/Bicyclist/Other Pedestrian Error/Confusion    2
Traffic Control Disregarded                              1

Again driver inattention and distraction as well as improperly lane passing. Speaking for myself, I should be careful not to assume vehicles can see me and remember to pass them with caution. New Yorkers taxi drivers are notorious for cutting into lanes without signaling and changing lanes too close to other vehicles. One bad move from the taxi driver or a biker could cause serious injuries!

Watch Out!

Finally I’m also interested in seeing if there were any bike to bike collisions. In 65 accidents, there was only one where one biker passed too closely. Only one biker was injured. Maybe one biker assumed to have enough space to pass by a slower biker but ultimately got too close and caused the crash. I’ll keep my space.

Next Steps

I love we can look at this data and use our imagination to see how the accident might have happened. 2 months of data already gives me a glimpse of NYC bike safety today. With more months in the analysis, we could start to see more trends. My analysis of these events is helpful to me to understand the ways that I could get into an accident. The reasons above are just a handful of causes but it has also helped me know what else to be aware of as I’m biking. In a future post, I will dive further into this dataset and plot out the crashes along with my Citi Bike trips to learn about my proximity to the accidents. Thanks for reading.

Come see my jupyter notebook to see how I coded my analysis in Python.

Exploring 2 Months of NYC Bike Accidents was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

I’ve been interested in the automation of our tasks. One of my most memorable inspirations was the scene in the “Green Hornet” where Jay Chou, playing tech-savvy Kato, makes an amazing cup of latte that you can practically taste and smell through the screen, using a beautiful, complicated-looking coffee machine (that he built!) by pushing a few buttons and pulling a few levers!

I also remember when I came out of college and worked a temporary job that primarily had me entering data, which I found very boring. I wish there was a program to do that work for me! (there are but we won’t cover that here).

I recently picked up a book called “Automate the Boring Stuff with Python,” by a very funny and smart guy named Al Sweigart. In his book, he talks about how you can do really cool things using Python like creating watermarks on a large number of photos at the same time and controlling your mouse and keyboard through a GUI. I will be talking about the latter topic in this post.

In this book, Sweigart covers controlling the mouse and keyboard with a module that he created called “PyAutoGui.” With this module, you can program your computer to do things like move your mouse to a specified spot, open programs for you at a chosen time, scroll up and down pages and many other applications. The first time I messed with PyAutoGui, I was mind-blown when my cursor instantaneously moved to a coordinate on my screen, all by itself! It almost felt like I was sharing my screen with someone that had full access to my computer. From there I was hooked- now I wanted to see what else I could do it. How about creating a script that likes all of someone’s Instagram posts?

First I wanted to understand how the computer screen coordinates work. On Sweigart’s PyAutoGui site, the docsclearly explains how to use it. On a 1440x900 screen, coordinates (0,0) would be the top left corner of your screen and (1439,899) would be the bottom right corner. One important note is that when you pull the curser down the screen, the coordinate increases. Here is a diagram of the screen and how to read the coordinates on a 1920x1080 screen taken from the site.

0,0       X increases -->
+---------------------------+
|                           | Y increases
|                           |     |
|   1920 x 1080 screen      |     |
|                           |     V
|                           |
|                           |
+---------------------------+ 1919, 1079

When I first started thinking about how I would do this, I tested its applications by manually inputting the coordinates of where to click and how many times it would click. I had a friend’s Instagram pulled up on my laptop.

pyautogui.moveTo(35,689)
pyautogui.click(clicks=4, interval=0.5)
pyautogui.press('right')
pyautogui.moveTo(135,621)
pyautogui.click(clicks=3, interval=0.5)
pyautogui.press('right')
pyautogui.moveTo(134,568)
pyautogui.click(clicks=3, interval=0.75)
pyautogui.press('right')

This code block essentially moved to the Instagram heart’s coordinates, clicked it, and then moved to the next page. Pyautogui.moveTo() tells the mouse to go to that coordinate. Pyautogui.click(), where there are adjustable parameters, clicks the specified number of times and waits 0.5 between each click. Pyautogui.press() presses the specified key. Very intuitive! Because this code was written manually, this method will too long especially when the location of the Instagram heart moved after every next photo. The next step shows you how Pyautogui locates each heart automatically using Pyautogui.locateOnScreen().

With this method, you need have a photo saved on your computer where you can access it by inserting it into its parameter. Essentially it searches for the exact picture down to the pixel. If even one pixel is off, it will return None and the code will break. First I screen-shotted the heart, then I entered the file name like so Pyautogui.locateOnScreen(heart.png). After the heart is located, I used another method called Pyautogui.center(‘heart.png’) that centered the cursor on the heart. Afterwards I created a loop that clicks the heart and presses the ‘right’ direction key to get to the next photo.

Next Steps

Now that it can like all of someone’s posts, I could potentially have it leave a comment at the end of the posts, leave the screen, go to your mutual friends, and find another person’s Instagram page to like. Although this was a simple project using only python, it’s interesting to note that people would pay for this type of bot service to automatically follow people, leave many many comments, and post pictures on its own.

I used to sell luxury watches in a retail environment. My job was to use my knowledge of customers and convince them to splurge. In retrospect, I was constantly filtering and sorting customer information then drawing conclusions on how to construct my next sales approach. Today, many companies use algorithms to do the same thing with recommendation systems. It’s fascinating that companies are able to ell you what you want before you knew it and without ever seeing your face. In this blog post I’m going to briefly talk about how companies YouTube and Ant Financial use their recommendation system to great effect and show you a simple movie recommendation system using numpy and pandas.

YouTube has been an exceptional resource for learning and watching anything under the sun but it’s also a place where you can spend too many hours on it if you’re not careful. There have been many nights where I went to watch a video and emerged an hour later in a daze wondering what just happened. Needless to say, YouTube has done a great job at keeping viewers longer and longer on their site. What recommendation systems have they implemented to keep us watching for longer? Google Brain, their parent company’s artificial intelligence division, turned to unsupervised learning. YouTube uses Google Brain’s machine learning algorithms to find relationships and patterns that software engineers would not have seen, providing more useful recommendations on its own and at an accelerated rate. The patterns they’ve picked up have made a significant improvement in viewership.

In the past, YouTube relied on algorithms that put videos with the most clicks in front of more viewers. However, with Google Brain’s unsupervised learning algorithms, they realized that the amount of time a user spent watching a video was a much better indicator of a higher quality video. Another way is recommending longer times on YouTube’s TV app and shorter times on its mobile app. This helped boost view duration as people on their mobile phone tend to be on the go while people on the TV app stayed in one place. In this same effect, the ad times were shorter on mobile and longer on the TV.

We should be careful not to look too closely at the most obvious things because I think we can get attached to one way of thinking and not see another pattern. It’s great that machine learning algorithms are able to detect these relationships and help us make impactful changes. Another company that is using recommendation systems is Ant Financial.

Ant Financial is the financial affiliate of Alibaba Group Holding. I found this company very interesting because while I was doing research on this company, I realized that when I was in China, I was using it every single day. They’re behind Alipay, a third-party mobile and online payment platform in China. People have stopped using cash because of its popularity. I never needed to bring a wallet out. All you do is put money on your e-wallet and scan the terminal’s QR code and you’re good to go. Convenience is king.

You can basically buy anything on Alipays’ platform. Shop owners, restaurant owners online stores, rice paddy grandmas, are all using the app. When over 500 million people are using the same platform, you have a huge amount of transactional data. What do they do with this data to create a very good recommendation system? Instead of the traditional recommendation system such as collaborative filtering, where the algorithm deduces that since love pineapples, you might like mangos because someone else who pineapples also likes mangos, or content-based filtering where it recommends you other tropical fruits, Ant Financial provides a two-way recommendation system that connects you to the businesses. Michael Jordan, professor at UC Berkeley and a prominent leader in machine learning, goes into more detail about this. Say you just come out of a movie and you’re looking for a restaurant to eat at nearby.

On your app, it would say here’s some restaurant nearby that you might like and some you’ve been to, and on the restaurant sides app, the restaurant owners might be holding a wedding so there might be 50 empty seats so they put down this down in their preferences. Since you’re nearby this particular restaurant, they can send you discounts and special offers to entice you to eat there tonight. One those 50 seats are filled, great! Now you’re happy you’re full and you saved some money AND the restaurant filled to capacity. And this creates a market because when that restaurant is full, other restaurants in the area see this and can also make special offers to fill their seating as well. It’s a win-win for you, the businesses and the economy. Jordan says that this is “democratizing financial services” and “it’s all about providing to the right people at the right time.”

Now this is a simple python recommendation system using numpy and pandas which will return similar movies based on rating correlation in order to find the similarity between movies. First showing that the higher number of ratings a movie gets is related to the average rating it receives as more people tend to watch these movies. Then using rating correlation, where users who voted the same for both movies would strengthen the correlation, to show similar movies. We will be using the MovieLens dataset which consists of 100,000 ratings of 9,000 movies by 600 users last updated 9/2018. This part is following the walkthrough of Usman Malik in this post.

First the author explored the MovieLens data. We open the ratings and movies .csv’s in the dataset with pandas. We name them ‘ratings_data’ and ‘movie_names’. We merge the two together.

movie_data = pd.merge(ratings_data, movie_names, on='movieId')

Then we take the mean of each of the ratings and average them.

movie_data.groupby('title')['rating'].mean().sort_values(ascending=False).head()

Because these movies can reach the top as the highest rated movies because they only have 1 review, we should also get the number of ratings per movie. The authors main point was that “really good movies get higher ratings because it is rated by a large number of users.”

movie_data.groupby('title')['rating'].count().sort_values(ascending=False).head()

The really well known movies are now at the top of the list. And it may be safe to say that these are also very good movies. Next, we’ll add the rating count and the rating tables together.

ratings_mean_count['rating_counts'] = pd.DataFrame(movie_data.groupby('title')['rating'].count())

Here above we have the rating and the number of ratings next to the title of the movies. To illustrate the amount of movies with or without ratings, we’ll plot it out on a histogram.

sns.set_style('dark')
%matplotlib inline

plt.figure(figsize=(8,6))
plt.rcParams['patch.force_edgecolor'] = True
plt.title('Movies and Ratings Counts')
plt.ylabel("Number of Movies")
plt.xlabel("Number of Ratings per Movie")
ratings_mean_count['rating_counts'].hist(bins=50)
#graphing number of movies that received x amount of ratings

This shows there are many movies that have 0 ratings and very few that have over 100 ratings (can’t even see it on the graph).

plt.figure(figsize=(8,6))
plt.rcParams['patch.force_edgecolor'] = True
plt.title('Movies and Average Rating')
plt.xlabel("Average Rating per Movie")
plt.ylabel("Number of Movies")
ratings_mean_count['rating'].hist(bins=50)

The graph shows that the higher the amount of ratings the average rating tends to be higher.

plt.figure(figsize=(8,6))
plt.rcParams['patch.force_edgecolor'] = True
sns.jointplot(x='rating', y='rating_counts', data=ratings_mean_count, alpha=0.4)
#movies with higher avg rating have more ratings

This puts the two graphs together to show that the more well known a movie is, the more people watch it, therefore has a higher rating. Now to find the similarities between the movies.

user_movie_rating = movie_data.pivot_table(index='userId', columns='title', values='rating')

This is a matrix with each movie and their ratings. Many of them have had no votes so there are NaN. We will choose Forrest Gump to be our base movie because it has the highest amount of ratings and then find other movies that are highly correlated with its rating. We will clean this data by removing the NaN in the next steps.

forrest_gump_ratings = user_movie_rating['Forrest Gump (1994)']

These are the user ratings for the movie Forrest Gump. Using the corrwith() method we can find the correlation of other movies that rated the same thing for Forrest Gump.

movies_like_forrest_gump = user_movie_rating.corrwith(forrest_gump_ratings)

corr_forrest_gump = pd.DataFrame(movies_like_forrest_gump, columns=['Correlation'])
corr_forrest_gump.dropna(inplace=True)
corr_forrest_gump.head()
corr_forrest_gump.sort_values('Correlation', ascending=False).head(10)

A lot of these movies are unheard of. Although the correlation is 1.0, a movie with one rating is not as a good of an indicator as one with more ratings. So, we filter out the movies with less than 50 review counts.

corr_forrest_gump[corr_forrest_gump ['rating_counts']>50].sort_values('Correlation', 
                                                                      ascending=False).head(10)

The final results shows other movies that are also very similar as they are big Hollywood movies, showing movies that they are pretty correlated, taking into account the rating count and average rating.

Sources:

https://www.forbes.com/sites/kristinwestcottgrant/2017/12/10/how-to-think-about-artificial-intelligence-in-the-music-industry/#2938bfc37d4a

Eigentaste: A Constant Time Collaborative Filtering Algorithm. Ken Goldberg, Theresa Roeder, Dhruv Gupta, and Chris Perkins. Information Retrieval, 4(2), 133–151. July 2001.

https://stackabuse.com/creating-a-simple-recommender-system-in-python-using-pandas/

https://www.forbes.com/sites/bernardmarr/2017/08/08/the-amazing-ways-how-google-uses-deep-learning-ai/#2aaa6e713204

https://www.theverge.com/2017/8/30/16222850/youtube-google-brain-algorithm-video-recommendation-personalized-feed

The 'terrifying' moment in 2012 when YouTube changed its entire philosophy

https://grouplens.org/datasets/movielens/latest/

“Code is the new concrete for 21st century cities and we need a digital infrastructure to share data and create safer and more sustainable streets.”

-Janette Sadik-Khan, former commissioner of the New York City Department of Transportation and an advisor on transportation and urban issues.

Ever since the advent of rideshare services, I’ve felt that it’s improved my life. I don’t have to feel awkward getting wave-rejected as an occupied taxi whizzes past me and I can avoid shady taxi drivers from taking me on the longest route possible. Ridesharing services have done me a great service and I think it’s fair to say that they’re doing very well for themselves too. But are companies doing any good for the world? Just last year, Uber, Ford and Lyft have partnered up with a company called SharedStreets to give city mayors across the world “unparalleled access to their road traffic data” in order to help cities rethink transportation.

Cities are trying to improve urban mobility but are unable to because their street maps are inadequate to deal with the super surge of cars taking up limited space. One very valuable space is the curb. People get dropped off there, bicyclists use it, cars park on it, and trucks unload there. It’s a crucial pain point not only for pedestrians and drivers who deal with constant delays from people blocking traffic but also for many businesses because freight and logistics companies are using the curb more and more and they have no way to collaborate well with the city. Many cities don’t have their infrastructures mapped out well and even more of a problem is that they don’t have enough data to make any actionable changes.

Ridesharing companies have a huge amount of data that cities could use to make traffic efficient and safer. For this cities-companies collaboration, Uber and Lyft provided a substantial amount of trip information including fare amount, vehicle speed data, pick up, and drop off data. However, even if these companies provided data to the cities, their street level data sets are still not compatible. Not only are city mapping systems different each other (the city of Detroit has cities within that all have their own way of managing their infrastructure), they’re also different from ridesharing companies.

SharedStreets makes it possible by creating an open-source, universal map language in a simple machine readable format that everyone — the city, companies and citizens — all have access to. And because SharedStreets is a third party, non-political, and non profit, Uber and Lyft do not need to fear risking proprietary secrets such as routing algorithms and SharedStreets removes thecompany name from the trips. Regarding our privacy, SharedStreets uses data in a way that is completely unrelated to the privacy of people. This allows all data to work in everyone’s favor without jeopardizing anyone’s interest.

Both cities and companies have been using a Geometric Information System(GIS) to map street level data. However, when data is merged together, the sets do not match. SharedStreets is able to link the two sets of data together by breaking down a street into short form IDs that can be referred back to in a database.

This is important because when it links up different maps’ data sets, the SharedStreets IDs provide a common reference. The grey lines represent different data sets of the same spot and the blue line represents the SharedStreet ID reference that allow a common ground.

The millions of GPS points are clustered together and allows analysis of traffic congestion, curb usage, how long cars stay in a spot, how often vehicles are picking up and dropping. With a common map and a huge amount of data, cities now have the resources to create a roadmap for urban mobility.

My thoughts

This has been one of the largest collaborations with private companies and the government in what seems very much like an active attempt from all sides to do good. I hope that these companies involved have set an example as a way of providing social good with data, especially for the ones that have been emerging as abusers of our trust and privacy.

Sources:

• The City of Detroit, SharedStreets, and NACTO to Pilot New Data Standard for Dockless Mobility - National Association of City Transportation Officials
• To Share the Streets With Uber and Lyft, Cities Have a Powerful New Map
• Uber Makes Peace With Cities by Spilling Its Secrets
• Ford, Uber & Lyft agree to share data through the SharedStreets platform
• State of the Map US 2018
• Getting started with SharedStreets

https://nacto.org/2018/02/22/nacto-and-otp-launch-sharedstreets/

Random, Rndmao, Nardom. Arbitrary spellings of the same word. First I’m going to talk a little bit about the random module in python and then some ways we can use it with few lines of code.

We will be using the function shuffle(x).

First we import our random module and import its shuffle module.

import random
from random import shuffle

Then we will take our password string, reshuffle the letters and then put them back together.

def password_scramble(string):
 string = list(string)
 shuffle(string)
 print(‘’.join(string))

password_scramble('learnlovecode')

Output: rdloeovcneeal

[Finished in 0.689s]

What was the wifi code again?

2. Letting Python decide what you eat tonight

We will use the random.choice( ) function. It randomly chooses an element from a list.

I multiplied each element in the list by a weighted number according to my preferences. Then I let the random module choose for me.

import random
types_of_rests = [‘Indian’] * 30 + [‘Italian’] * 30 + [‘Thai’] * 40
print(random.choice(types_of_rests))

Output: Indian

[Finished in 0.579s]

3. Choosing Mega Millions numbers (5 numbers between 1 & 70 and 1 Megaball between 1 & 25)

We will use the random.randint(x, y) function which generates numbers between ‘x’ and ‘y’, and the .choice( ) function from before.

We want to create a new list for our generated lottery numbers. We set ‘x’ = 0 because we will be using a ‘while’ loop to keep our returned list capped. Finally creating a lucky number variable between 1 and 70.

import random
lotterynumbers = []
megaball = range(1,26)
x = 0

The randint and choice generated numbers are all compiled into the lottery numbers list.

while x < 5:
    lotterynumbers.append(random.randint(1, 71))
    x += 1

lotterynumbers.append(random.choice(megaball))

Output: [47, 58, 16, 54, 62, 13]

[Finished in 1.392s]

//.

Sources:

https://docs.python.org/3/library/random.html

https://en.wikipedia.org/wiki/Mersenne_Twister

• Are there any ways to scramble strings in python?
• Python - Lottery Number Generator
• Python Weighted Random

• random - Generate pseudo-random numbers
• Barry Ritholtz Quotes
• Mega Millions
• Thinking Emoji

https://password-lock-win.en.softonic.com/