{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "[nltk_data] Downloading package stopwords to\n", "[nltk_data] C:\\Users\\YavuzSelim\\AppData\\Roaming\\nltk_data...\n", "[nltk_data] Package stopwords is already up-to-date!\n" ] }, { "data": { "text/plain": [ "True" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import nltk\n", "nltk.download('stopwords')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from bs4 import BeautifulSoup # For HTML parsing\n", "# import urllib2 # Website connections\n", "from urllib.request import urlopen\n", "import re # Regular expressions\n", "from time import sleep # To prevent overwhelming the server between connections\n", "from collections import Counter # Keep track of our term counts\n", "from nltk.corpus import stopwords # Filter out stopwords, such as 'the', 'or', 'and'\n", "import pandas as pd # For converting results to a dataframe and bar chart plots\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def text_cleaner(website):\n", " '''\n", " This function just cleans up the raw html so that I can look at it.\n", " Inputs: a URL to investigate\n", " Outputs: Cleaned text only\n", " '''\n", " try:\n", " site = urlopen(website).read() # Connect to the job posting\n", " except: \n", " print(\"Error while opening web site\")\n", " return # Need this in case the website isn't there anymore or some other weird connection problem \n", " \n", " soup_obj = BeautifulSoup(site) # Get the html from the site\n", " \n", " if len(soup_obj) == 0: # In case the default parser lxml doesn't work, try another one\n", " soup_obj = BeautifulSoup(site, 'html5lib')\n", " \n", " #print(soup_obj)\n", " for script in soup_obj([\"script\", \"style\"]):\n", " script.extract() # Remove these two elements from the BS4 object\n", " \n", " \n", "\n", " text = soup_obj.get_text() # Get the text from this\n", "\n", " \n", "\n", " lines = (line.strip() for line in text.splitlines()) # break into lines\n", "\n", " \n", " \n", " chunks = (phrase.strip() for line in lines for phrase in line.split(\" \")) # break multi-headlines into a line each\n", " \n", "\n", " text = ''.join(chunk for chunk in chunks if chunk).encode('utf-8') # Get rid of all blank lines and ends of line\n", " \n", " # Now clean out all of the unicode junk (this line works great!!!)\n", " \n", " try:\n", " text = text.decode('unicode_escape').encode('ascii', 'ignore') # Need this as some websites aren't formatted\n", " except: # in a way that this works, can occasionally throw\n", " return # an exception\n", " \n", " text = str(text)\n", " text = re.sub(\"[^a-zA-Z+3]\",\" \", text) # Now get rid of any terms that aren't words (include 3 for d3.js)\n", " # Also include + for C++\n", " text = re.sub(r\"([a-z])([A-Z])\", r\"\\1 \\2\", text) # Fix spacing issue from merged words\n", " \n", " text = text.lower().split() # Go to lower case and split them apart\n", " \n", " \n", " stop_words = set(stopwords.words(\"english\")) # Filter out any stop words\n", " text = [w for w in text if not w in stop_words]\n", " \n", " \n", " \n", " text = list(set(text)) # Last, just get the set of these. Ignore counts (we are just looking at whether a term existed\n", " # or not on the website)\n", " \n", " return text" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['data',\n", " 'hands',\n", " 'hour',\n", " 'physics',\n", " 'claims',\n", " 'senior',\n", " 'based',\n", " 'knowledge',\n", " 'help',\n", " 'tools',\n", " 'zeneca',\n", " 'also',\n", " 'organize',\n", " 'algorithm',\n", " 'working',\n", " 'varelated',\n", " 'consulting',\n", " 'group',\n", " 'create',\n", " 'companies']" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sample = text_cleaner('https://www.indeed.com/jobs?q=Data+Scientist&l=Washington%2C+DC')\n", "sample[:20] # Just show the first 20 words\n" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "def skills_info(city = None, state = None):\n", " '''\n", " This function will take a desired city/state and look for all new job postings\n", " on Indeed.com. It will crawl all of the job postings and keep track of how many\n", " use a preset list of typical data science skills. The final percentage for each skill\n", " is then displayed at the end of the collation. \n", " \n", " Inputs: The location's city and state. These are optional. If no city/state is input, \n", " the function will assume a national search (this can take a while!!!).\n", " Input the city/state as strings, such as skills_info('Chicago', 'IL').\n", " Use a two letter abbreviation for the state.\n", " \n", " Output: A bar chart showing the most commonly desired skills in the job market for \n", " a data scientist. \n", " '''\n", " #https://tr.indeed.com/jobs?q=data+scientist&l=Ankara\n", " final_job = 'data+scientist' # searching for data scientist exact fit(\"data scientist\" on Indeed search)\n", " \n", " # Make sure the city specified works properly if it has more than one word (such as San Francisco)\n", " if city is not None:\n", " final_city = city.split() \n", " final_city = '+'.join(word for word in final_city)\n", " '''\n", " final_site_list = ['http://www.indeed.com/jobs?q=', final_job, '&l=', final_city,\n", " '+', state] # Join all of our strings together so that indeed will search correctly\n", " '''\n", " final_site_list = ['https://tr.indeed.com/jobs?q=',final_job,'&l=', final_city]\n", " else:\n", " final_site_list = ['http://www.indeed.com/jobs?q=\"', final_job, '\"']\n", "\n", " final_site = ''.join(final_site_list) # Merge the html address together into one string\n", " print('Final_site:'+ final_site)\n", "\n", " base_url = 'http://www.indeed.com'\n", "\n", "\n", " try:\n", " html = urlopen(final_site).read() # Open up the front page of our search first\n", " except:\n", " print('That city/state combination did not have any jobs. Exiting . . .') # In case the city is invalid\n", " return\n", " soup = BeautifulSoup(html) # Get the html from the first page\n", " #print(soup)\n", "\n", "\n", " # Now find out how many jobs there were\n", "\n", " num_jobs_area = soup.find(id = 'searchCount').string.encode('utf-8') # Now extract the total number of jobs found\n", " print(str(num_jobs_area)) # The 'searchCount' object has this\n", " num_jobs_area = str(num_jobs_area)\n", " job_numbers = re.findall('\\d+', num_jobs_area) # Extract the total jobs found from the search result\n", " job_numbers = (job_numbers[1])\n", " total_num_jobs = (job_numbers)\n", " city_title = city\n", " if city is None:\n", " city_title = 'Nationwide'\n", " \n", " print ('There were '+str(total_num_jobs)+' jobs found,'+city_title) # Display how many jobs were found\n", "\n", " num_pages = int(total_num_jobs)/10 # This will be how we know the number of times we need to iterate over each new\n", " # search result page\n", " job_descriptions = [] # Store all our descriptions in this list\n", " print(\"Num pages: \"+str(num_pages+1))\n", " for i in range(0,int(num_pages+1)): # Loop through all of our search result pages\n", " print ('Getting page'+ str(i))\n", " start_num = str(i*10) # Assign the multiplier of 10 to view the pages we want\n", " current_page = ''.join([final_site, '&start=', start_num])\n", " # Now that we can view the correct 10 job returns, start collecting the text samples from each\n", " print('Current page'+ current_page)\n", " \n", " html_page = urlopen(current_page).read() # Get the page\n", " \n", " page_obj = BeautifulSoup(html_page) # Locate all of the job links\n", " job_link_area = page_obj.find(id = 'resultsCol') # The center column on the page where the job postings exist\n", " #print(job_link_area)\n", " \n", " job_URLS = [base_url + str(link.get('href')) for link in job_link_area.find_all('a')] # Get the URLS for the jobs\n", " \n", " job_URLS = list(filter(lambda x:'clk' in x, job_URLS)) # Now get just the job related URLS\n", " \n", " for j in range(0,len(job_URLS)):\n", " \n", " final_description = text_cleaner(job_URLS[j])\n", " #print(final_description)\n", " if final_description: # So that we only append when the website was accessed correctly\n", " job_descriptions.append(final_description)\n", " #sleep(1) # So that we don't be jerks. If you have a very fast internet connection you could hit the server a lot! \n", " \n", " print ('Done with collecting the job postings!') \n", " print ('There were'+str(len(job_descriptions))+ 'jobs successfully found.')\n", "\n", "\n", " doc_frequency = Counter() # This will create a full counter of our terms. \n", " [doc_frequency.update(item) for item in job_descriptions] # List comp\n", "\n", " # Now we can just look at our final dict list inside doc_frequency\n", "\n", " # Obtain our key terms and store them in a dict. These are the key data science skills we are looking for\n", "\n", " prog_lang_dict = Counter({'R':doc_frequency['r'], 'Python':doc_frequency['python'],\n", " 'Java':doc_frequency['java'], 'C++':doc_frequency['c++'],\n", " 'Ruby':doc_frequency['ruby'],\n", " 'Perl':doc_frequency['perl'], 'Matlab':doc_frequency['matlab'],\n", " 'JavaScript':doc_frequency['javascript'], 'Scala': doc_frequency['scala']})\n", " \n", " analysis_tool_dict = Counter({'Excel':doc_frequency['excel'], 'Tableau':doc_frequency['tableau'],\n", " 'D3.js':doc_frequency['d3.js'], 'SAS':doc_frequency['sas'],\n", " 'SPSS':doc_frequency['spss'], 'D3':doc_frequency['d3']}) \n", "\n", " hadoop_dict = Counter({'Hadoop':doc_frequency['hadoop'], 'MapReduce':doc_frequency['mapreduce'],\n", " 'Spark':doc_frequency['spark'], 'Pig':doc_frequency['pig'],\n", " 'Hive':doc_frequency['hive'], 'Shark':doc_frequency['shark'],\n", " 'Oozie':doc_frequency['oozie'], 'ZooKeeper':doc_frequency['zookeeper'],\n", " 'Flume':doc_frequency['flume'], 'Mahout':doc_frequency['mahout']})\n", " \n", " database_dict = Counter({'SQL':doc_frequency['sql'], 'NoSQL':doc_frequency['nosql'],\n", " 'HBase':doc_frequency['hbase'], 'Cassandra':doc_frequency['cassandra'],\n", " 'MongoDB':doc_frequency['mongodb']})\n", " \n", " \n", " overall_total_skills = prog_lang_dict + analysis_tool_dict + hadoop_dict + database_dict # Combine our Counter objects\n", "\n", " \n", "\n", " final_frame = pd.DataFrame(list(overall_total_skills.items()), columns = ['Term', 'NumPostings']) # Convert these terms to a \n", " # dataframe \n", "\n", " # Change the values to reflect a percentage of the postings \n", "\n", " final_frame.NumPostings = (final_frame.NumPostings)*100/len(job_descriptions) # Gives percentage of job postings \n", " # having that term \n", "\n", " # Sort the data for plotting purposes\n", "\n", " #final_frame.sort(columns = 'NumPostings', ascending = False, inplace = True)\n", " final_frame.sort_values(by=['NumPostings'], ascending = False, inplace = True)\n", " # Get it ready for a bar plot\n", " \n", " final_plot = final_frame.plot(x = 'Term', kind = 'bar', legend = None, \n", " title = 'Percentage of Data Scientist Job Ads with a Key Skill, ' + city_title)\n", " \n", " final_plot.set_ylabel('Percentage Appearing in Job Ads')\n", " fig = final_plot.get_figure() # Have to convert the pandas plot object to a matplotlib object\n", " \n", " \n", " return fig, final_frame # End of the function\n", " \n", " \n", " #'''\n", " '''\n", " if len(job_numbers) > 3: # Have a total number of jobs greater than 1000\n", " total_num_jobs = (int(job_numbers[2])*1000) + int(job_numbers[3])\n", " else:\n", " total_num_jobs = int(job_numbers[2]) \n", "'''" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final_site:https://tr.indeed.com/jobs?q=data+scientist&l=Istanbul\n", "b'\\n Sayfa 1 (toplam 15 i\\xc5\\x9f)'\n", "There were 15 jobs found,Istanbul\n", "Num pages: 2.5\n", "Getting page0\n", "Current pagehttps://tr.indeed.com/jobs?q=data+scientist&l=Istanbul&start=0\n", "Getting page1\n", "Current pagehttps://tr.indeed.com/jobs?q=data+scientist&l=Istanbul&start=10\n", "Done with collecting the job postings!\n", "There were15jobs successfully found.\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "seattle_info = skills_info(city = 'Istanbul')" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final_site:https://tr.indeed.com/jobs?q=data+scientist&l=Ankara\n", "b'\\n Sayfa 1 (toplam 1 i\\xc5\\x9f)'\n", "There were 1 jobs found,Ankara\n", "Num pages: 1.1\n", "Getting page0\n", "Current pagehttps://tr.indeed.com/jobs?q=data+scientist&l=Ankara&start=0\n", "Done with collecting the job postings!\n", "There were2jobs successfully found.\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "seattle_info = skills_info(city = 'Ankara')" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final_site:https://tr.indeed.com/jobs?q=data+scientist&l=İzmir\n", "That city/state combination did not have any jobs. Exiting . . .\n" ] } ], "source": [ "seattle_info = skills_info(city = 'İzmir')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 2 }