Python classes

An object is an instance of a class.

A class is like a cookie-cutter.
An object is the cookies cut from the cookie-cutter.

Here is a minimal Python class. The __name__ attribute of the class is the name of that class.

Here is the Python code [#1]

class myClass():
	pass
print("(begin main)")
name1 = myClass.__name__
print("Class: \"{0:s}\"".format(name1))
print("(end main)")

In Python, a docstring is a string literal that is the first element of a module, function, class or method definition.

That string literal becomes the __doc__ attribute of that module, function, class or method.

Here is a better minimal class that uses a docstring. A common convention is to use triple double quotes to delimit the docstring.

Here is the Python code [#2]

class myClass():
	"""myClass does some useful functionality"""
print("(begin main)")
name1 = myClass.__name__
docs1 = myClass.__doc__
print("Class: \"{0:s}\"".format(name1))
print("Docstring: \"{0:s}\"".format(docs1))
print("(end main)")

Here is the output of the Python code.

(begin main)
Class: "myClass"
Docstring: "myClass does some useful functionality"
(end main)

The Python str function returns a string representation of the supplied actual parameter.

Here is an example of the str function with a minimal class.

Here is the Python code [#3]

class myClass():
	pass
print("(begin main)")
object1 = myClass()
str1 = str(object1)
print("\"{0:s}\" (object)".format(str1))
print("(end main)")

Here is the output of the Python code.

(begin main)
"<__main__.myClass object at 0x0000000002444E20>" (object)
(end main)

This is not very meaningful.

Here is the Python code [#4]

class myClass():
	def __str__(self):
		str1 = "(custom string for instance)"
		return str1
print("(begin main)")
object1 = myClass()
str1 = str(object1)
print("\"{0:s}\" (instance)".format(str1))
print("(end main)")

Here is the output of the Python code.

(begin main)
"(custom string for instance)" (instance)
(end main)

This can be more meaningful.

Many aspects of a Python class are accessible from the class dictionary or other methods. Here is the Python code [#5]

class myClass():
	"""myClass purpose text"""
	var1 = 123
	def __init__(self):
		self.var1 = 456
	def method1(self):
		"""purpose 1"""
		print("method1 action")
	def method2(self):
		"""purpose 2"""
		print("method2 action")
	def method3(self):
		"""purpose 3"""
		print("method3 action")
object1 = myClass()
object1.method1()
object1.method2()
object1.method3()
print("myClass.var1={0:d} (class variable)".format(myClass.var1))
print("object1.var1={0:d} (object variable)".format(object1.var1))
print("")
name1 = myClass.__name__
doc1 = myClass.__doc__
if doc1 == None:
	doc1 = ""
print("Members of class {0:s} :: {1:s}".format(name1,doc1))
for item1 in myClass.__dict__.items():
	name1 = item1[0]
	value1 = item1[1]
	if not name1.startswith("__"):
		doc1 = value1.__doc__
		if doc1 == None:
			doc1 = ""
		type1 = type(value1).__name__
		if type1 == "int":
			doc1 = ""
			int1 = myClass.__dict__[name1]
			print("\t{0:s} {1:s} = {2:d}".format(type1,name1,int1))
		else:
			print("\t{0:s} {1:s} :: {2:s}".format(type1,name1,doc1))

Here is the output of the Python code.

method1 action
method2 action
method3 action
myClass.var1=123 (class variable)
object1.var1=456 (object variable)
Members of class myClass :: myClass purpose text
	int var1 = 123
	function method1 :: purpose 1
	function method2 :: purpose 2
	function method3 :: purpose 3

Code reflection is the ability of code in a language to accesses parts of it's own code.

The above shows how Python makes it easy to do code reflection.

Notice the use of self in a class. The passed variable self allows the object instance to access the object variables. The name does not need to be self but that is the convention.

The Python str function is used to get the informal output intended for display to the user.

The Python repr function is used to get the formal output intended for use in debugging and development.

A object of a class acts as a cloned module.

This is especially obvious in Python when one looks at the module and class structure. The module code is put inside a class definition, a constructor mechanism is added, and a name usually called self is added to allow that instance to access object members.