Properties.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"Cdbj7h6WHD2T"},"source":["# Properties\n","\n","Sometimes, it can be convenient to use a property. This is an attribute of a class which can be accessed or assigned to as though it is a member variable, but actually invokes a piece of code of the class before retrieving or storing the value.\n","\n","Let's look at a simple example based on the Square class from the previous notebook:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"yJS2wvVyOzV7"},"outputs":[],"source":["class Square:\n","  def __init__(self, side_length):\n","    self.side_length = side_length\n","\n","  @property\n","  def area(self):\n","    area = self.side_length ** 2\n","    return area\n","\n","my_square = Square(3)\n","print(my_square.area)"]},{"cell_type":"markdown","metadata":{"id":"m-S-V9iyPcWv"},"source":["The \"area\" property is defined in the same way as an instance method, with the exception that the it uses the ```@property``` decorator. This decorator means it can be accessed in the same way as an instance variable with the same name. However, when the ```area``` property of ```my_square``` is accessed, the code inside the ```area``` property is executed.\n","\n","This is one example of how a property can be used - to calculate a value which is a function of the saved data within the instance of the class. However, at the moment, we can't set the value of area in the same way as we could with an instance variable:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1o3PMWukYgd6"},"outputs":[],"source":["my_square.area = 16"]},{"cell_type":"markdown","metadata":{"id":"zqMKWDs-YkRP"},"source":["We can't set the value of this attribute. This actually makes a lot of sense in this context - if we were able to save a value of the area of the square to ```my_square```, it would create an inconsistency within the class if, for instance, the area was saved as 16 and the side length was saved as 3."]},{"cell_type":"markdown","metadata":{"id":"UFQe1XhvG3ad"},"source":["## Setters\n","\n","There are times when, whilst setting an attribute, we want to execute some code first. One such example is when we want to provide a way to set a value within an instance of a class, but we want to check the supplied value fulfills some criterion.\n","\n","Let's consider our square again. Let's say that, now, we wan to be able to change the side length other than in the constructor, but we can to check to make sure it's not negative, as a negative side length doesn't make sense. We can do that using the decorator ```[attribute_name].setter``` on an instance method named ```[attribute_name]```. This method should take two arguments, ```self``` as normal, and another argument which will receive the value being set. A setter with a particular name must follow a property for that same name found in the class definition.\n","\n","For our square class, let's use the variable name ```side_length```. We also need to add a property with this name ```side_length```."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LDn333bhdGxb"},"outputs":[],"source":["class Square:\n","  def __init__(self, side_length):\n","    # The constructor will now access the property setter \"side_length\"\n","    self.side_length = side_length\n","\n","  @property\n","  def side_length(self):\n","    return self._side_length\n","\n","  @side_length.setter\n","  def side_length(self, value):\n","    if value < 0:\n","      raise ValueError(\"A square must have a side length of zero or greater\")\n","    self._side_length = value\n","\n","  @property\n","  def area(self):\n","    area = self.side_length ** 2\n","    return area\n","\n","my_square = Square(2)\n","print(my_square.area)\n","# The side_length property setter will be called\n","# A value of 3 will be given to \"value\" when this function is called\n","my_square.side_length = 3\n","print(my_square.side_length)\n","print(my_square.area)\n","my_square.side_length = -1"]},{"cell_type":"markdown","metadata":{"id":"OSQfWQVwpAZa"},"source":["Now, we are able to change the value of the side length using the ```side_length``` setter and, when we do, it checks the value provided is zero or greater and raises an exception if it's not. If its value is acceptable, it sets the value of the ```_side_length``` instance variable.\n","\n","Note that, when we made these changes, we had to change the name of the instance variable used to store the side length to ```_side_length```. The reason for this is that, if it remained being named ```side_length```, when the side length setter tried to assign a value to ```self.side_length```, it would call the ```self.side_length``` setter and this process would repeat and never exit.\n","\n","The reason we chose to modify the name of the instance variable by adding an underscore is that it follows a Python convention whereby the name of the instance variable accessed by a property/setter is the name of the property/setter preceded by an underscore. This keeps the association clear to a future developer, but avoids naming conflicts.\n","\n","This convention also warns a future developer that they should probably not interact directly with a instance variable with an underscore at the start and, instead should interact with the properties. In this example, always using the setter for ```side_length``` will ensure that ```_side_length``` never has a negative value.\n","\n","### Other Languages\n","\n","In most other object-oriented languages, there is the idea of \"private\" variables and, in many object-oriented languages, member variables will be private by default. Private instance or class variables are completely inaccessible from outside the methods of the class. This means methods, properties and setters become the only way they can be accessed or modified. This is important for the idea of encapsulation, which we'll talk about later.\n","\n","Python does not have the concept of a \"private\" variable. In the example above, we're still able to access ```my_square._side_length``` from outside the class and it's only convention which serves as a hint that that was not what was intended."]},{"cell_type":"markdown","metadata":{"id":"7hjNiCjQ4tZo"},"source":["## Exercise\n","\n","In the code cell below, complete the class named \"Temperature\" which is designed to hold a value to represent a temperature and to convert it into different units when it is asked for. The class should have a single instance variable which stores the temperature in units of Celsius.\n","\n","The class should also have two properties, named \"celsius\" and \"fahrenheit\", which returns the stored temperature in the appropriate unit.\n","\n","You do not need to use a constructor. Instead, the class should have two setters named \"celsius\" and \"fahrenheit\". Each of these expects a single value which represents the temperature to be stored in the respective unit. Each of these setters should set the value of the same variable which represents the temperature value in units of Celsius.\n","\n","Absolute zero is -273.15 celsius. Cause the class to raise a ValueError if a temperature lower than this is provided to either setter.\n","\n","Once you've created your class, run the code cell which will set and retrieve a temperature using different units. Ensure your code returns the correct values in each case. The final time the temperature is set should raise a ValueError.\n","\n","To convert a temperature in Celsius to a temperature in Fahrenheit, use the equation:\n","\n","$T(F) = 1.8T(C) + 32$\n","\n","To convert a temperature in Celsius to a temperature in Fahrenheit, use the equation:\n","\n","$T(C) = \\frac{T(F) - 32}{1.8}$"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Xrr7G3IRB1tm"},"outputs":[],"source":["# Complete the definition of this class\n","class Temperature:\n","\n","\n","# Run the tests of the new class\n","temperature1 = Temperature()\n","\n","# Set the temperature using the celsius setter\n","temperature1.celsius = 0\n","# This should have a value of 0C\n","print(temperature1.celsius, \"C\")\n","# This should have a value of 32F\n","print(temperature1.fahrenheit, \"F\")\n","\n","# Set the temperature using the fahrenheit setter\n","temperature1.fahrenheit = 0\n","# This should have a value of -17.78C\n","print(temperature1.celsius, \"C\")\n","# This should have a value of 0F\n","print(temperature1.fahrenheit, \"F\")\n","\n","# Setting the temperature too low should result in an exception\n","temperature1.fahrenheit = -1000"]},{"cell_type":"code","execution_count":null,"metadata":{"cellView":"form","id":"NPkJMq0bW8Rk"},"outputs":[],"source":["#@title\n","class Temperature:\n","  # Return the temperature in Celsius\n","  # Because the temperature is stored in Celsius no conversion is required\n","  @property\n","  def celsius(self):\n","    return self._celsius\n","\n","  # Return the temperature in Fahrenheit\n","  # Convert the stored value from Celsius to Fahrenheit before returning\n","  # Then set it using the Celsius setter\n","  # This means the check in the Celsius setter is performed even when setting the temperature in Fahrenheit\n","  @property\n","  def fahrenheit(self):\n","    return 1.8 * self._celsius + 32\n","\n","  # Allows the temperature to be set when supplied in Celsius\n","  # Because the temperature is stored in Celsius no conversion is required\n","  @celsius.setter\n","  def celsius(self, value):\n","    # If the temperature is too low, raise a ValueError\n","    if value < -273.15:\n","      raise ValueError(\"The specified temperature was below absolute zero\")\n","    self._celsius = value\n","\n","  # Allows the temperature to be set when supplied in Fahrenheit\n","  # Convert the provided value from Fahrenheit to Celsius\n","  # Then set it using the Celsius setter\n","  # This means the check in the Celsius setter is performed even when setting the temperature in Fahrenheit\n","  @fahrenheit.setter\n","  def fahrenheit(self, value):\n","    self.celsius = (value - 32) / 1.8\n","\n","# Run the tests of the new class\n","temperature1 = Temperature()\n","\n","#Set the temperature using the celsius setter\n","temperature1.celsius = 0\n","#This should have a value of 0C\n","print(temperature1.celsius, \"C\")\n","#This should have a value of 32F\n","print(temperature1.fahrenheit, \"F\")\n","\n","#Set the temperature using the fahrenheit setter\n","temperature1.fahrenheit = 0\n","#This should have a value of -17.78C\n","print(temperature1.celsius, \"C\")\n","#This should have a value of 0F\n","print(temperature1.fahrenheit, \"F\")\n","\n","#Setting the temperature too low should result in an exception\n","temperature1.fahrenheit = -1000"]}],"metadata":{"colab":{"collapsed_sections":[],"name":"Properties.ipynb","provenance":[]},"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.11.8"}},"nbformat":4,"nbformat_minor":0}