Fix possessive 'its' spelling in documentation and tests

Author: MarkRosemaker

concepts/class-inheritance/about.md

@@ -7,7 +7,7 @@ In situations where only a small amount of functionality needs to be customized
 
 `Inheritance` describes `is a kind of` relationship between two or more classes, abstracting common details into super (_base_ or _parent_) class and storing specific ones in the subclass (_derived class_ or _child class_).
 
-To create a child class, specify the parent class name inside the pair of parenthesis, followed by it's name.
+To create a child class, specify the parent class name inside the pair of parenthesis, followed by its name.
 Example
 ```python
 class Child(Parent):  

exercises/practice/tree-building/.meta/example.py

@@ -18,7 +18,7 @@ def validate_record(record):
         raise ValueError('Only root should have equal record and parent id.')
 
     if not record.equal_id() and record.parent_id >= record.record_id:
-        raise ValueError("Node parent_id should be smaller than it's record_id.")
+        raise ValueError("Node parent_id should be smaller than its record_id.")
 
 
 def BuildTree(records):

exercises/practice/tree-building/tree_building_test.py

@@ -111,7 +111,7 @@ def test_root_node_has_parent(self):
         with self.assertRaises(ValueError) as err:
             BuildTree(records)
         self.assertEqual(type(err.exception), ValueError)
-        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than it's record_id.")
+        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than its record_id.")
 
     def test_no_root_node(self):
         records = [
@@ -167,7 +167,7 @@ def test_cycle_indirectly(self):
         with self.assertRaises(ValueError) as err:
             BuildTree(records)
         self.assertEqual(type(err.exception), ValueError)
-        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than it's record_id.")
+        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than its record_id.")
 
     def test_higher_id_parent_of_lower_id(self):
         records = [
@@ -179,7 +179,7 @@ def test_higher_id_parent_of_lower_id(self):
         with self.assertRaises(ValueError) as err:
             BuildTree(records)
         self.assertEqual(type(err.exception), ValueError)
-        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than it's record_id.")
+        self.assertEqual(err.exception.args[0], "Node parent_id should be smaller than its record_id.")
 
     def assert_node_is_branch(self, node, node_id, children_count):
         self.assertEqual(node.node_id, node_id)

reference/concepts/builtin_types/list.md

@@ -8,7 +8,7 @@ A multi-dimensional list-with-a-list is used as a simple (but not very efficient
 
 TODO: ADD MORE DETAIL
 
-See the Python documentation entries for the [mutable][mutation] [`list` type][docs-list-type] and it's [constructor][list-as-function]. This is Python's most commonly used [sequential collection][docs-sequence-types], and as it allows _heterogeneous data_ it's quite different from the [fixed array][general-concept-array] and [singly-linked list][general-concept-list] types you may have encountered in other, less flexible, languages.
+See the Python documentation entries for the [mutable][mutation] [`list` type][docs-list-type] and its [constructor][list-as-function]. This is Python's most commonly used [sequential collection][docs-sequence-types], and as it allows _heterogeneous data_ it's quite different from the [fixed array][general-concept-array] and [singly-linked list][general-concept-list] types you may have encountered in other, less flexible, languages.
 
 [variable-length-quantity]: ../../exercise-concepts/variable-length-quantity.md
 [markdown]: ../../exercise-concepts/markdown.md

reference/concepts/class_inheritance.md

@@ -3,5 +3,5 @@
 TODO: ADD MORE
 
 - The default `__str___` method is inherited from `Object`, which every class in Python inherits from. (See: inheritance) [phone-number](../exercise-concepts/phone-number.md)
-- a "subclass" will inherit all methods, attributes from it's parent class, and can then override methods as needed. Overriding means the logic in the parent class is not used. The `super` builtin function (not shown here) exists to allow the programmer to defer logic up the inheritance chain to the parent class when needed. [phone-number](../exercise-concepts/phone-number.md)
+- a "subclass" will inherit all methods, attributes from its parent class, and can then override methods as needed. Overriding means the logic in the parent class is not used. The `super` builtin function (not shown here) exists to allow the programmer to defer logic up the inheritance chain to the parent class when needed. [phone-number](../exercise-concepts/phone-number.md)
 - the knowledge of inheritance can be useful in this exercises because all `Exceptions` types inherit from the base class [variable-length-quantity](../exercise-concepts/variable-length-quantity.md)

reference/exercise-concepts/phone-number.md

@@ -43,7 +43,7 @@ class PhoneNumber:
 - [Methods][methods]: classes can have instance _methods_ which are called from an instance of the class (as opposed to class methods, called from the Class itself). The first parameter of an instance method is always `self`, which is provided when calling from the instance (i.e. the programmer does not need to pass it as an argument explicitly). Static methods are methods called from the class itself, and are not connected to an instance of the class. They have access to class attributes (those defined on the class, not connected to the `self`), and do not require an instance of the class to exist. Classes can also define a `property` by using the `@property` decorator (not shown here); a `property` can be "lazily evaluated" to avoid unneeded computation
 - [Non-Public Methods][non-public-methods]: Methods or attributes (including those of an imported module) prefixed with an underscore, `_`, are conventionally treated as "non-public" methods. Python does not support data privacy in the way a language like Java does. Instead convention dictates that methods and attributes that are not prefixed with a single underscore can be expected to remain stable along with semver, i.e. a public method will be backwards compatible with minor version updates, and can change with major version updates. Generally, importing non-public functions or using non-public methods is discouraged, though Python will not explicitly stop the programmer from doing so.
 - [Implied Argument][implied-argument]: within the class definition, methods and properties can be accessed via the `self.` notation
-- [Inheritance][inheritance]: a "subclass" will inherit all methods, attributes from it's parent class, and can then override methods as needed. Overriding means the logic in the parent class is not used. The `super` builtin function (not shown here) exists to allow the programmer to defer logic up the inheritance chain to the parent class when needed.
+- [Inheritance][inheritance]: a "subclass" will inherit all methods, attributes from its parent class, and can then override methods as needed. Overriding means the logic in the parent class is not used. The `super` builtin function (not shown here) exists to allow the programmer to defer logic up the inheritance chain to the parent class when needed.
 - [Standard Library][standard-library]: the `re` module is an example of the Python stdlib (standard library), or included code libraries and tools that are frequently used in Python
 - [Import][import]: to use the module, the `import` syntax can be used
 - [Iterables][iterables]: characters in a string are _iterables_ and are subject to index and slice access as described below