Profitable App Profiles for App Store and Google Play

This project explores what types of free apps are likely to attract more users on Google Play and the App Store.

Data used

Android data set containing data about approximately 10,000 Android apps from Google Play, collected in August 2018.
iOS data set containing data about approximately 7,000 iOS apps from the App Store, collected in July 2017.

from csv import reader def get_dataset(file_path, with_header=True): opened_file = open(file_path) read_file = reader(opened_file) dataset = list(read_file) if with_header: return dataset[0], dataset[1:] return dataset[1:]

android_header, android_data = get_dataset("googleplaystore.csv") ios_header, ios_data = get_dataset("AppleStore.csv")

def explore_data(dataset, start, end, rows_and_columns=False): dataset_slice = dataset[start:end] for row in dataset_slice: print(row) if rows_and_columns: print("\n") print("Number of rows:", len(dataset)) print("Number of columns:", len(dataset[0]))

Data Overview

Android header and data

print(android_header, "\n") explore_data(android_data, 0, 3, True)

We can see that the Google Play data set has 10,841 apps and 13 columns.
The columns that may be useful for analysis are App, Category, Rating, Reviews, Installs, Type, Price and Genres

iOS header and data

print(ios_header, "\n") explore_data(ios_data, 0, 3, True)

We can see that the iOS data set has 7,197 apps and 17 columns.
The columns that may be useful are track_name, currency, price, rating_count_tot, rating_count_ver, user_rating and prime_genre.

print(android_data[10472])

Data Cleaning

Deleting incorrect data

print(android_header, "\n") print(android_data[0]) # correct format print(android_data[10472]) # incorrect format

del android_data[10472]

Removing Duplicate Entries

def find_duplicate_apps(dataset, index_of_name_column): duplicate_apps = [] unique_apps = [] for app in dataset: name = app[index_of_name_column] if name in unique_apps: duplicate_apps.append(name) else: unique_apps.append(name) return duplicate_apps, unique_apps

ios_duplicate_apps, ios_unique_apps = find_duplicate_apps(ios_data, 2) android_duplicate_apps, android_unique_apps = find_duplicate_apps(android_data, 0) print("Number of duplicate iOS apps:", len(ios_duplicate_apps)) print("Number of duplicate android iOS apps:", len(android_duplicate_apps))

print(ios_header) for app in ios_data: name = app[2] if name == ios_duplicate_apps[0]: print(app) print("\n") print(android_header) for app in android_data: name = app[0] if name == android_duplicate_apps[0]: print(app)

Duplicate apps mainly differ on the number of reviews (rating_count_tot for iOS and reviews for Android), suggesting that those with the highest review number were the most recent ones. Thus, we'll keep only the duplicate app with the highest rating.

def filter_duplicates_by_review(dataset, name_column_index, reviews_column_index): reviews_max = {} for app in dataset: name = app[name_column_index] num_reviews = float(app[reviews_column_index]) if name in reviews_max and reviews_max[name] < num_reviews: reviews_max[name] = num_reviews elif name not in reviews_max: reviews_max[name] = num_reviews unique_data = [] already_added = [] for app in dataset: name = app[name_column_index] num_reviews = float(app[reviews_column_index]) if num_reviews == reviews_max[name] and name not in already_added: unique_data.append(app) already_added.append(name) return unique_data

android_data_uniques = filter_duplicates_by_review(android_data, 0, 3) print("Original Android Length:", len(android_data)) print("Expected Android Length:", len(android_data) - len(android_duplicate_apps)) print("Uniques Android length:", len(android_data_uniques)) print("\n") ios_data_uniques = filter_duplicates_by_review(ios_data, 2, 6) print("Original iOS length:", len(ios_data)) print("Expected iOS length:", len(ios_data) - len(ios_duplicate_apps)) print("Uniques iOS length:", len(ios_data_uniques))

Removing Non-English Apps

We use the Unicode number of the characters in the app name to make sure they are less than 127 characters. This should filter out any apps with characters that imply they're not directed at an English-speaking audience.

def is_app_directed_at_english_speakers(app_name): num_non_english_characters = 0 for char in app_name: if ord(char) > 127: num_non_english_characters += 1 if num_non_english_characters > 2: return False return True def filter_non_english_apps(dataset, name_index): filtered_dataset = [] for app in dataset: name = app[name_index] if (is_app_directed_at_english_speakers(name)): filtered_dataset.append(app) return filtered_dataset

ios_data_english = filter_non_english_apps(ios_data_uniques, 2) android_data_english = filter_non_english_apps(android_data_uniques, 0) print("Android unique apps:", len(android_data_uniques)) print("Android unique, English apps:", len(android_data_english)) print("iOS unique apps:", len(ios_data_uniques)) print("iOS unique, English apps:", len(ios_data_english))

Isolate Free Apps

As a reminder, this project is analyzing apps that are free to download and install. We'll investigate later what this means for in-app revenue.

def isolate_free_apps(dataset, price_column): free_apps = [] for app in dataset: price = float(app[price_column].replace("$", "")) if price == 0: free_apps.append(app) return free_apps

android_data_free = isolate_free_apps(android_data_english, 7) ios_data_free = isolate_free_apps(ios_data_english, 5) print("Android free apps:", len(android_data_free)) print("Android English apps:", len(android_data_english)) print("iOS free apps:", len(ios_data_free)) print("iOS English apps:", len(ios_data_english))

Data Analysis

Here, we'll be investigating the most common and popular apps by genre.
The end goal is to find an app profile that works well for both Google Play and the iOS App Store.

# functions we'll need for later def freq_table(dataset, index): frequency_table = {} for app in dataset: freq_column = app[index] if freq_column in frequency_table: frequency_table[freq_column] += 1 else: frequency_table[freq_column] = 1 freq_table_as_percentage = {} for key in frequency_table: freq_table_as_percentage[key] = round((frequency_table[key] / len(dataset)) * 100, 2) return freq_table_as_percentage def display_table(dataset, index, limit=10): table = freq_table(dataset, index) table_display = [] for key in table: key_val_as_tuple = (table[key], key) table_display.append(key_val_as_tuple) table_sorted = sorted(table_display, reverse=True) for entry in table_sorted[:limit]: print(entry[1], ":", str(entry[0]) + "%") def display_popularity_by_genre(dataset, genre_index, popularity_index, formatter_cb=None): table = freq_table(dataset, genre_index) popularity_display = [] for genre in table: sum_of_popularity = 0 num_apps_in_genre = 0 for app in dataset: genre_app = app[genre_index] if genre == genre_app: if formatter_cb is not None: metric = formatter_cb(app[popularity_index]) else: metric = float(app[popularity_index]) sum_of_popularity += metric num_apps_in_genre += 1 popularity_display.append((round(sum_of_popularity / num_apps_in_genre), genre, num_apps_in_genre)) for entry in sorted(popularity_display, reverse=True): print(entry[1], ":", entry[0], "|", entry[2], "apps")

Most Common Apps by Genre

iOS Genres by Percentage

ios_genre_freq_table = display_table(ios_data_free, 12)

On the App Store, we can see that Games are the most common free, english-speaking apps by a wide margin at 58.32%. While the entertainment category is second at 7.84%, Games can technically be considered a subset of Entertainment. Thus, the general impression is that the majority of apps are designed for entertainment purposes as opposed to practical/educational purposes.

Android Genres by Percentage

display_table(android_data_free, 9)

Android Categories by Percentage

display_table(android_data_free, 1)

On Google Play, we can see that Tools- and Entertainment-related apps rank highly when considering the different Android genres and categories. This suggests a very different app profile from that we saw on the App Store.

Most Common Apps Analysis

We can't recommend an app profile for the App Store or the Google Play Store based on this information alone. The fact there's a large number of entertainment apps doesn't indicate that those apps also have the largest number of users. It does, however, reveal the most frequented genres.

Most Popular Apps by Genre

One way to find out what genres are the most popular is to calculate the average number of installs for each app genre. For the Google Play data set, this information exists in the Installs column. We don't have this information for the app store, so we'll use total number of user ratings as a proxy from the rating_count_tot column.

iOS: Average number of ratings by genre

display_popularity_by_genre(ios_data_free, 12, 6)

Navigation apps, while fewer, are rated the most highly. With fewer apps in a genre, it's reasonable to expect that those apps would be of higher ratings, but that people would be less likely to switch from the apps that they currently use.

It's also interesting to observe that while entertainment apps were the most frequent, practical apps are more highly rated.

Android: Average number of installs by genre

While the number of installs should provide is with a clearer picture of genre popularity, the install numbers themselves are not precise

display_table(android_data_free, 5)

Because we don't need precise data here, we'll assume that an app with 100,000+ installs has 100,000 installs and so on.

def format_installs(installs): installs = installs.replace("+", "") installs = installs.replace(",", "") return float(installs)

display_popularity_by_genre(android_data_free, 9, 5, format_installs)

Android: Average number of installs by category

display_popularity_by_genre(android_data_free, 1, 5, format_installs)

In Android's case, we can see that the Productivity category and the Communication genre has the most average installs. Entertainment apps as can be seen with the Arcade genre and the Game category are are not for behind.

Recommendation

App Store

For the App Store, the app profile I would thus recommend is one that is both frequent (meaning there is an opportunity for users to swtich) and highly rated. This leads me to recommend Social Networking or Music apps as a potential genre to develop an in.

Google Play

For Googe Play, the app profile I would recommend are communication apps which have a focus on productivity and ease-of-use. There are also enough apps in these categories such that users might switch if a better app was produced.

Cross Platform

From this analysis, it's reasonably clear that social apps would be well suited for both platforms.