Emoji Print
It is easy to add an emoji to a message in code. However, using the emoji library or other libraries often requires you to install code on your machine. Before using a library, that is not part of Python distribution, you must install with pip
# terminal command to install library
$ pip install emoji
Collecting emoji
Downloading emoji-2.5.1.tar.gz (356 kB)
...
Successfully installed emoji-2.5.1
#!pip install emoji
from emoji import emojize
print(emojize(":panda: Python is awesome! :snake:"))
🐼 Python is awesome! 🐍
Extracting Data
Web sites become a lot more interesting when you are working with data, not trying to create it. Here is some code using a library called newspaper, this extracts a couple of writeups from the CNN Entertainment site.
- Learn more on newspaper3k
- Learn about library for wikipedia
#!pip install newspaper3k
from newspaper import Article
from IPython.display import display, Markdown
urls = ["https://theconversation.com/virtual-reality-has-negative-side-effects-new-research-shows-that-can-be-a-problem-in-the-workplace-210532"]
for url in urls:
article = Article(url)
article.download()
article.parse()
# Jupyter Notebook Display
# print(article.title)
display(Markdown(article.title)) # Jupyter display only
display(Markdown(article.text)) # Jupyter display only
print("\n")
Virtual reality has negative side effects – new research shows that can be a problem in the workplace
The Research Brief is a short take about interesting academic work.
The big idea
Some employers are excited about swapping out computer monitors for virtual reality headsets, but the side effects of using VR are not completely understood. In a recent study, my colleagues and I propose 90 factors that could influence VR side effects in the workplace. In another study, we suggest guidelines to reduce these negative symptoms.
Our analysis considers over 350 studies to identify a range of VR side effects. Some negative symptoms of VR use – like headaches, tiredness, eyestrain and neck and shoulder pain –are familiar to those workers who sit at a computer all day.
But the nature of VR introduces new avenues for discomfort, such as disorientation, dizziness, nausea and increased muscle fatigue. Users can be overwhelmed with too much information, and sudden or intense sources of stress – like unexpected noises when talking in front of a virtual audience – can diminish attention and memory.
There are many factors that can affect the frequency and severity of these side effects. Some of these characteristics relate to the virtual environment content – for example, how complicated the scene is or the way VR reproduces user movements. Others have more to do with the user, such as age or how long they’re immersed in the VR simulation.
Although more research is needed to identify the exact relationship between side effects and their contributing factors, our study suggests several guidelines to mitigate side effects. Each individual’s risk level is unique, but there are basic things anyone can do, like taking regular breaks, not using VR for more than 30 minutes at a time, and stopping use immediately when any symptoms start.
Why it matters
Studies have found that 80% of VR users report mild to severe short-term side effects. Symptoms can make it harder to efficiently do basic tasks like reading and writing emails.
Nonetheless, several tech giants, like Meta and Microsoft, are promoting VR technology as the future of the workplace. But to safeguard workers, employers need a better understanding of the negative side effects of VR.
What’s next
Some government organizations, both in the U.S. and abroad, have already begun to identify safety concerns and propose guidelines for mitigating the side effects of VR. While in line with our study’s findings, these safety guidelines are often very broad, and some have yet to be finalized.
More research is needed to improve the quality of evidence. One way to gather more data is to use physiological sensors and machine learning models to detect VR side effects and better link each factor to a given effect.
Although researchers can identify influential factors, we don’t yet fully understand which ones are linked to specific side effects – or how strong those connections are. Researchers believe that some characteristics are connected to several VR side effects, but there’s some redundancy when looking at the list of symptoms.
At best, following suggested guidelines could reduce the risks of using VR. With the current level of evidence, it’s difficult to assess how high these risks are. Most assessments about VR side effects are short term. Long-term studies are just starting to be launched or published. Additional research is crucial to ensuring that VR helps workers rather than harming them.
#!pip install wikipedia
import wikipedia
from IPython.display import display, Markdown # add for Jupyter
terms = ["gorilla"]
for term in terms:
# Search for a page
result = wikipedia.search(term)
# Get the summary of the first result
summary = wikipedia.summary(result[0])
print(term)
# print(summary) # console display
display(Markdown(summary)) # Jupyter display
gorilla
Gorillas are herbivorous, predominantly ground-dwelling great apes that inhabit the tropical forests of equatorial Africa. The genus Gorilla is divided into two species: the eastern gorilla and the western gorilla, and either four or five subspecies. The DNA of gorillas is highly similar to that of humans, from 95 to 99% depending on what is included, and they are the next closest living relatives to humans after chimpanzees and bonobos. Gorillas are the largest living primates, reaching heights between 1.25 and 1.8 metres, weights between 100 and 270 kg, and arm spans up to 2.6 metres, depending on species and sex. They tend to live in troops, with the leader being called a silverback. The Eastern gorilla is distinguished from the Western by darker fur colour and some other minor morphological differences. Gorillas tend to live 35–40 years in the wild. Gorillas’ natural habitats cover tropical or subtropical forest in Sub-Saharan Africa. Although their range covers a small percentage of Sub-Saharan Africa, gorillas cover a wide range of elevations. The mountain gorilla inhabits the Albertine Rift montane cloud forests of the Virunga Volcanoes, ranging in altitude from 2,200 to 4,300 metres (7,200 to 14,100 ft). Lowland gorillas live in dense forests and lowland swamps and marshes as low as sea level, with western lowland gorillas living in Central West African countries and eastern lowland gorillas living in the Democratic Republic of the Congo near its border with Rwanda. There are thought to be around 316,000 western gorillas in the wild, and 5,000 eastern gorillas. Both species are classified as Critically Endangered by the IUCN; all subspecies are classified as Critically Endangered with the exception of the mountain gorilla, which is classified as Endangered. There are many threats to their survival, such as poaching, habitat destruction, and disease, which threaten the survival of the species. However, conservation efforts have been successful in some areas where they live.
Inspecting a Function
The inspect module can give you the output of what’s inside many Python functions/objects. This can help you explore code behind what you are using.
- Inspect documentation.
import inspect
from newspaper import Article
# inspect newspaper Article function
print(inspect.getsource(Article))
class Article(object):
"""Article objects abstract an online news article page
"""
def __init__(self, url, title='', source_url='', config=None, **kwargs):
"""The **kwargs argument may be filled with config values, which
is added into the config object
"""
if isinstance(title, Configuration) or \
isinstance(source_url, Configuration):
raise ArticleException(
'Configuration object being passed incorrectly as title or '
'source_url! Please verify `Article`s __init__() fn.')
self.config = config or Configuration()
self.config = extend_config(self.config, kwargs)
self.extractor = ContentExtractor(self.config)
if source_url == '':
scheme = urls.get_scheme(url)
if scheme is None:
scheme = 'http'
source_url = scheme + '://' + urls.get_domain(url)
if source_url is None or source_url == '':
raise ArticleException('input url bad format')
# URL to the main page of the news source which owns this article
self.source_url = source_url
self.url = urls.prepare_url(url, self.source_url)
self.title = title
# URL of the "best image" to represent this article
self.top_img = self.top_image = ''
# stores image provided by metadata
self.meta_img = ''
# All image urls in this article
self.imgs = self.images = []
# All videos in this article: youtube, vimeo, etc
self.movies = []
# Body text from this article
self.text = ''
# `keywords` are extracted via nlp() from the body text
self.keywords = []
# `meta_keywords` are extracted via parse() from <meta> tags
self.meta_keywords = []
# `tags` are also extracted via parse() from <meta> tags
self.tags = set()
# List of authors who have published the article, via parse()
self.authors = []
self.publish_date = ''
# Summary generated from the article's body txt
self.summary = ''
# This article's unchanged and raw HTML
self.html = ''
# The HTML of this article's main node (most important part)
self.article_html = ''
# Keep state for downloads and parsing
self.is_parsed = False
self.download_state = ArticleDownloadState.NOT_STARTED
self.download_exception_msg = None
# Meta description field in the HTML source
self.meta_description = ""
# Meta language field in HTML source
self.meta_lang = ""
# Meta favicon field in HTML source
self.meta_favicon = ""
# Meta tags contain a lot of structured data, e.g. OpenGraph
self.meta_data = {}
# The canonical link of this article if found in the meta data
self.canonical_link = ""
# Holds the top element of the DOM that we determine is a candidate
# for the main body of the article
self.top_node = None
# A deepcopied clone of the above object before heavy parsing
# operations, useful for users to query data in the
# "most important part of the page"
self.clean_top_node = None
# lxml DOM object generated from HTML
self.doc = None
# A deepcopied clone of the above object before undergoing heavy
# cleaning operations, serves as an API if users need to query the DOM
self.clean_doc = None
# A property dict for users to store custom data.
self.additional_data = {}
def build(self):
"""Build a lone article from a URL independent of the source (newspaper).
Don't normally call this method b/c it's good to multithread articles
on a source (newspaper) level.
"""
self.download()
self.parse()
self.nlp()
def download(self, input_html=None, title=None, recursion_counter=0):
"""Downloads the link's HTML content, don't use if you are batch async
downloading articles
recursion_counter (currently 1) stops refreshes that are potentially
infinite
"""
if input_html is None:
try:
html = network.get_html_2XX_only(self.url, self.config)
except requests.exceptions.RequestException as e:
self.download_state = ArticleDownloadState.FAILED_RESPONSE
self.download_exception_msg = str(e)
log.debug('Download failed on URL %s because of %s' %
(self.url, self.download_exception_msg))
return
else:
html = input_html
if self.config.follow_meta_refresh:
meta_refresh_url = extract_meta_refresh(html)
if meta_refresh_url and recursion_counter < 1:
return self.download(
input_html=network.get_html(meta_refresh_url),
recursion_counter=recursion_counter + 1)
self.set_html(html)
self.set_title(title)
def parse(self):
self.throw_if_not_downloaded_verbose()
self.doc = self.config.get_parser().fromstring(self.html)
self.clean_doc = copy.deepcopy(self.doc)
if self.doc is None:
# `parse` call failed, return nothing
return
# TODO: Fix this, sync in our fix_url() method
parse_candidate = self.get_parse_candidate()
self.link_hash = parse_candidate.link_hash # MD5
document_cleaner = DocumentCleaner(self.config)
output_formatter = OutputFormatter(self.config)
title = self.extractor.get_title(self.clean_doc)
self.set_title(title)
authors = self.extractor.get_authors(self.clean_doc)
self.set_authors(authors)
meta_lang = self.extractor.get_meta_lang(self.clean_doc)
self.set_meta_language(meta_lang)
if self.config.use_meta_language:
self.extractor.update_language(self.meta_lang)
output_formatter.update_language(self.meta_lang)
meta_favicon = self.extractor.get_favicon(self.clean_doc)
self.set_meta_favicon(meta_favicon)
meta_description = \
self.extractor.get_meta_description(self.clean_doc)
self.set_meta_description(meta_description)
canonical_link = self.extractor.get_canonical_link(
self.url, self.clean_doc)
self.set_canonical_link(canonical_link)
tags = self.extractor.extract_tags(self.clean_doc)
self.set_tags(tags)
meta_keywords = self.extractor.get_meta_keywords(
self.clean_doc)
self.set_meta_keywords(meta_keywords)
meta_data = self.extractor.get_meta_data(self.clean_doc)
self.set_meta_data(meta_data)
self.publish_date = self.extractor.get_publishing_date(
self.url,
self.clean_doc)
# Before any computations on the body, clean DOM object
self.doc = document_cleaner.clean(self.doc)
self.top_node = self.extractor.calculate_best_node(self.doc)
if self.top_node is not None:
video_extractor = VideoExtractor(self.config, self.top_node)
self.set_movies(video_extractor.get_videos())
self.top_node = self.extractor.post_cleanup(self.top_node)
self.clean_top_node = copy.deepcopy(self.top_node)
text, article_html = output_formatter.get_formatted(
self.top_node)
self.set_article_html(article_html)
self.set_text(text)
self.fetch_images()
self.is_parsed = True
self.release_resources()
def fetch_images(self):
if self.clean_doc is not None:
meta_img_url = self.extractor.get_meta_img_url(
self.url, self.clean_doc)
self.set_meta_img(meta_img_url)
imgs = self.extractor.get_img_urls(self.url, self.clean_doc)
if self.meta_img:
imgs.add(self.meta_img)
self.set_imgs(imgs)
if self.clean_top_node is not None and not self.has_top_image():
first_img = self.extractor.get_first_img_url(
self.url, self.clean_top_node)
if self.config.fetch_images:
self.set_top_img(first_img)
else:
self.set_top_img_no_check(first_img)
if not self.has_top_image() and self.config.fetch_images:
self.set_reddit_top_img()
def has_top_image(self):
return self.top_img is not None and self.top_img != ''
def is_valid_url(self):
"""Performs a check on the url of this link to determine if article
is a real news article or not
"""
return urls.valid_url(self.url)
def is_valid_body(self):
"""If the article's body text is long enough to meet
standard article requirements, keep the article
"""
if not self.is_parsed:
raise ArticleException('must parse article before checking \
if it\'s body is valid!')
meta_type = self.extractor.get_meta_type(self.clean_doc)
wordcount = self.text.split(' ')
sentcount = self.text.split('.')
if (meta_type == 'article' and len(wordcount) >
(self.config.MIN_WORD_COUNT)):
log.debug('%s verified for article and wc' % self.url)
return True
if not self.is_media_news() and not self.text:
log.debug('%s caught for no media no text' % self.url)
return False
if self.title is None or len(self.title.split(' ')) < 2:
log.debug('%s caught for bad title' % self.url)
return False
if len(wordcount) < self.config.MIN_WORD_COUNT:
log.debug('%s caught for word cnt' % self.url)
return False
if len(sentcount) < self.config.MIN_SENT_COUNT:
log.debug('%s caught for sent cnt' % self.url)
return False
if self.html is None or self.html == '':
log.debug('%s caught for no html' % self.url)
return False
log.debug('%s verified for default true' % self.url)
return True
def is_media_news(self):
"""If the article is related heavily to media:
gallery, video, big pictures, etc
"""
safe_urls = ['/video', '/slide', '/gallery', '/powerpoint',
'/fashion', '/glamour', '/cloth']
for s in safe_urls:
if s in self.url:
return True
return False
def nlp(self):
"""Keyword extraction wrapper
"""
self.throw_if_not_downloaded_verbose()
self.throw_if_not_parsed_verbose()
nlp.load_stopwords(self.config.get_language())
text_keyws = list(nlp.keywords(self.text).keys())
title_keyws = list(nlp.keywords(self.title).keys())
keyws = list(set(title_keyws + text_keyws))
self.set_keywords(keyws)
max_sents = self.config.MAX_SUMMARY_SENT
summary_sents = nlp.summarize(title=self.title, text=self.text, max_sents=max_sents)
summary = '\n'.join(summary_sents)
self.set_summary(summary)
def get_parse_candidate(self):
"""A parse candidate is a wrapper object holding a link hash of this
article and a final_url of the article
"""
if self.html:
return RawHelper.get_parsing_candidate(self.url, self.html)
return URLHelper.get_parsing_candidate(self.url)
def build_resource_path(self):
"""Must be called after computing HTML/final URL
"""
res_path = self.get_resource_path()
if not os.path.exists(res_path):
os.mkdir(res_path)
def get_resource_path(self):
"""Every article object has a special directory to store data in from
initialization to garbage collection
"""
res_dir_fn = 'article_resources'
resource_directory = os.path.join(settings.TOP_DIRECTORY, res_dir_fn)
if not os.path.exists(resource_directory):
os.mkdir(resource_directory)
dir_path = os.path.join(resource_directory, '%s_' % self.link_hash)
return dir_path
def release_resources(self):
# TODO: implement in entirety
path = self.get_resource_path()
for fname in glob.glob(path):
try:
os.remove(fname)
except OSError:
pass
# os.remove(path)
def set_reddit_top_img(self):
"""Wrapper for setting images. Queries known image attributes
first, then uses Reddit's image algorithm as a fallback.
"""
try:
s = images.Scraper(self)
self.set_top_img(s.largest_image_url())
except TypeError as e:
if "Can't convert 'NoneType' object to str implicitly" in e.args[0]:
log.debug('No pictures found. Top image not set, %s' % e)
elif 'timed out' in e.args[0]:
log.debug('Download of picture timed out. Top image not set, %s' % e)
else:
log.critical('TypeError other than None type error. '
'Cannot set top image using the Reddit '
'algorithm. Possible error with PIL., %s' % e)
except Exception as e:
log.critical('Other error with setting top image using the '
'Reddit algorithm. Possible error with PIL, %s' % e)
def set_title(self, input_title):
if input_title:
self.title = input_title[:self.config.MAX_TITLE]
def set_text(self, text):
text = text[:self.config.MAX_TEXT]
if text:
self.text = text
def set_html(self, html):
"""Encode HTML before setting it
"""
if html:
if isinstance(html, bytes):
html = self.config.get_parser().get_unicode_html(html)
self.html = html
self.download_state = ArticleDownloadState.SUCCESS
def set_article_html(self, article_html):
"""Sets the HTML of just the article's `top_node`
"""
if article_html:
self.article_html = article_html
def set_meta_img(self, src_url):
self.meta_img = src_url
self.set_top_img_no_check(src_url)
def set_top_img(self, src_url):
if src_url is not None:
s = images.Scraper(self)
if s.satisfies_requirements(src_url):
self.set_top_img_no_check(src_url)
def set_top_img_no_check(self, src_url):
"""Provide 2 APIs for images. One at "top_img", "imgs"
and one at "top_image", "images"
"""
self.top_img = src_url
self.top_image = src_url
def set_imgs(self, imgs):
"""The motive for this method is the same as above, provide APIs
for both `article.imgs` and `article.images`
"""
self.images = imgs
self.imgs = imgs
def set_keywords(self, keywords):
"""Keys are stored in list format
"""
if not isinstance(keywords, list):
raise Exception("Keyword input must be list!")
if keywords:
self.keywords = keywords[:self.config.MAX_KEYWORDS]
def set_authors(self, authors):
"""Authors are in ["firstName lastName", "firstName lastName"] format
"""
if not isinstance(authors, list):
raise Exception("authors input must be list!")
if authors:
self.authors = authors[:self.config.MAX_AUTHORS]
def set_summary(self, summary):
"""Summary here refers to a paragraph of text from the
title text and body text
"""
self.summary = summary[:self.config.MAX_SUMMARY]
def set_meta_language(self, meta_lang):
"""Save langauges in their ISO 2-character form
"""
if meta_lang and len(meta_lang) >= 2 and \
meta_lang in get_available_languages():
self.meta_lang = meta_lang[:2]
def set_meta_keywords(self, meta_keywords):
"""Store the keys in list form
"""
self.meta_keywords = [k.strip() for k in meta_keywords.split(',')]
def set_meta_favicon(self, meta_favicon):
self.meta_favicon = meta_favicon
def set_meta_description(self, meta_description):
self.meta_description = meta_description
def set_meta_data(self, meta_data):
self.meta_data = meta_data
def set_canonical_link(self, canonical_link):
self.canonical_link = canonical_link
def set_tags(self, tags):
self.tags = tags
def set_movies(self, movie_objects):
"""Trim video objects into just urls
"""
movie_urls = [o.src for o in movie_objects if o and o.src]
self.movies = movie_urls
def throw_if_not_downloaded_verbose(self):
"""Parse ArticleDownloadState -> log readable status
-> maybe throw ArticleException
"""
if self.download_state == ArticleDownloadState.NOT_STARTED:
raise ArticleException('You must `download()` an article first!')
elif self.download_state == ArticleDownloadState.FAILED_RESPONSE:
raise ArticleException('Article `download()` failed with %s on URL %s' %
(self.download_exception_msg, self.url))
def throw_if_not_parsed_verbose(self):
"""Parse `is_parsed` status -> log readable status
-> maybe throw ArticleException
"""
if not self.is_parsed:
raise ArticleException('You must `parse()` an article first!')
Python Data Types
Dynamic typing means that the type of the variable is determined only during runtime. Strong typing means that variables do have a type and that the type matters when performing operations. In the illustration below there are two functions
- mean… shows types required prior to calling average function
- average, average2… calculates the average of a list of numbers
Python has types. In the language you can use type hints, but most coders do not use them. In other languages like Java and ‘C’ you must specify types.
from typing import Union
# Define types for mean function, trying to analyze input possibilities
Number = Union[int, float] # Number can be either int or float type
Numbers = list[Number] # Numbers is a list of Number types
Scores = Union[Number, Numbers] # Scores can be single or multiple
def mean(scores: Scores, method: int = 1) -> float:
"""
Calculate the mean of a list of scores.
Average and Average2 are hidden functions performing mean algorithm
If a single score is provided in scores, it is returned as the mean.
If a list of scores is provided, the average is calculated and returned.
"""
def average(scores):
"""Calculate the average of a list of scores using a Python for loop with rounding."""
sum = 0
len = 0
for score in scores:
sum += score
len += 1
return sum / len
def average2(scores):
"""Calculate the average of a list of scores using the built-in sum() function with rounding."""
return sum(scores) / len(scores)
# test to see if scores is a list of numbers
if isinstance(scores, list):
if method == 1:
# long method
result = average(scores)
else:
# built in method
result = average2(scores)
return round(result + 0.005, 2)
return scores # case where scores is a single valu
# define a list of numbers
tests = [90.5, 100, 85.4, 88]
print("Print test data")
print(tests)
print()
print("Average score, long method")
print(mean(tests))
print("Average score, short method")
print(mean(tests, 2))
Print test data
[90.5, 100, 85.4, 88]
Average score, long method
90.98
Average score, short method
90.98
Hacks
Here is a summary of some of the things learned above.
- Formatting messages with emoji
- Exploring data with newspaper and wikipedia libraries
- Finding code on how the library we used was made
- Learning about data types while writing an algorithm for mean
Part of Project Based learning is the idea of combining concepts to form something more interesting. Make a plan, form some ideas, brainstorm ideas with pair. Produce something that is interesting and challenging. Samples…
- Could I get input from user to look up wikipedia information? Python input, Article on Input
- What could I learn in Python about Stats to get Machine Learning Read? Stats Calculations
- Could I add emoji to an extracted article? String Find, String Methods
print("Welcome to Wikipedia!")
search_history = []
condition = True
while condition:
search_input = input("Enter a search or type 'quit' to exit: ")
if search_input != "quit":
result = wikipedia.search(search_input)
# Get the summary of the first result
summary = wikipedia.summary(result[0])
print(search_input)
search_history.append(search_input)
# print(summary) # console display
display(Markdown(summary)) # Jupyter display
else:
condition = False
print(f"Here is your search history: {search_history}")
choice = input("Would you like to clear your search history? [y/n]")
if choice == "y":
search_history.clear()
print("Search history cleared!")
print(search_history)
elif choice == "n":
print("Ok, no problem.")
else:
print("Invalid choice entered.")
print("Thank you for visiting Wikipedia! Come back soon!")
Welcome to Wikipedia!
chimpanzee
The chimpanzee (; Pan troglodytes), also known as simply the chimp, is a species of great ape native to the forest and savannah of tropical Africa. It has four confirmed subspecies and a fifth proposed one. When its close relative the bonobo was more commonly known as the pygmy chimpanzee, this species was often called the common chimpanzee or the robust chimpanzee. The chimpanzee and the bonobo are the only species in the genus Pan. Evidence from fossils and DNA sequencing shows that Pan is a sister taxon to the human lineage and is humans’ closest living relative. The chimpanzee is covered in coarse black hair, but has a bare face, fingers, toes, palms of the hands, and soles of the feet. It is larger and more robust than the bonobo, weighing 40–70 kg (88–154 lb) for males and 27–50 kg (60–110 lb) for females and standing 150 cm (4 ft 11 in). The chimpanzee lives in groups that range in size from 15 to 150 members, although individuals travel and forage in much smaller groups during the day. The species lives in a strict male-dominated hierarchy, where disputes are generally settled without the need for violence. Nearly all chimpanzee populations have been recorded using tools, modifying sticks, rocks, grass and leaves and using them for hunting and acquiring honey, termites, ants, nuts and water. The species has also been found creating sharpened sticks to spear small mammals. Its gestation period is eight months. The infant is weaned at about three years old but usually maintains a close relationship with its mother for several years more. The chimpanzee is listed on the IUCN Red List as an endangered species. Between 170,000 and 300,000 individuals are estimated across its range. The biggest threats to the chimpanzee are habitat loss, poaching, and disease. Chimpanzees appear in Western popular culture as stereotyped clown-figures and have featured in entertainments such as chimpanzees’ tea parties, circus acts and stage shows. Although many chimpanzees have been kept as pets, their strength, aggressiveness, and unpredictability makes them dangerous in this role. Some hundreds have been kept in laboratories for research, especially in the United States. Many attempts have been made to teach languages such as American Sign Language to chimpanzees, with limited success.
gorilla
Gorillas are herbivorous, predominantly ground-dwelling great apes that inhabit the tropical forests of equatorial Africa. The genus Gorilla is divided into two species: the eastern gorilla and the western gorilla, and either four or five subspecies. The DNA of gorillas is highly similar to that of humans, from 95 to 99% depending on what is included, and they are the next closest living relatives to humans after chimpanzees and bonobos. Gorillas are the largest living primates, reaching heights between 1.25 and 1.8 metres, weights between 100 and 270 kg, and arm spans up to 2.6 metres, depending on species and sex. They tend to live in troops, with the leader being called a silverback. The Eastern gorilla is distinguished from the Western by darker fur colour and some other minor morphological differences. Gorillas tend to live 35–40 years in the wild. Gorillas’ natural habitats cover tropical or subtropical forest in Sub-Saharan Africa. Although their range covers a small percentage of Sub-Saharan Africa, gorillas cover a wide range of elevations. The mountain gorilla inhabits the Albertine Rift montane cloud forests of the Virunga Volcanoes, ranging in altitude from 2,200 to 4,300 metres (7,200 to 14,100 ft). Lowland gorillas live in dense forests and lowland swamps and marshes as low as sea level, with western lowland gorillas living in Central West African countries and eastern lowland gorillas living in the Democratic Republic of the Congo near its border with Rwanda. There are thought to be around 316,000 western gorillas in the wild, and 5,000 eastern gorillas. Both species are classified as Critically Endangered by the IUCN; all subspecies are classified as Critically Endangered with the exception of the mountain gorilla, which is classified as Endangered. There are many threats to their survival, such as poaching, habitat destruction, and disease, which threaten the survival of the species. However, conservation efforts have been successful in some areas where they live.
Here is your search history: ['chimpanzee', 'gorilla']
Search history cleared!
[]
Thank you for visiting Wikipedia! Come back soon!