Binary relations define relations between two objects.

Well, we say "relation, relation" everytime, but what is the relation actually?

There are 5 types of binary relations:

Relational Images

The idea of the image of a set under a function extends directly to relations.

Formal definition: Given a relation R between two sets A (the domain) and B (the codomain), and a subset S⊆A. The image of S under R is the set

R(S) = {b∈B ∣ ∃a∈S such that (a,b)∈R}

Example: A = {1, 2, 3}, B = {a, b, c} and subset S = {1, 3}. Relation between A and B is R = {(1, a), (2, b), (1, c), (3, a)}. So the image of S under relation R becomes:

R(S) = {a, c}

Which means, the elements of the subset S is related to only these elements in a set B.

❓ Why we need this in Computer Science?

This concept is fundamental and very crucial in Computer Science due to its broad applicability to various fields like databases, graph theory and algorithms. Let's consider each:

1. Database management

In relational databases, the relationships between different tables (relations) are essential. For example, consider a database with tables for Users and Orders. The relationship can be represented by a relation R where each user is linked to their orders. If S is a set of users, R(S) would yield all orders related to these users.

Users = {Alice, Bob, Charlie}
Orders = {Order1, Order2, Order3, Order4}
R = {(Alice, Order1), (Bob, Order2), (Charlie, Order3), (Alice, Order4)}
S={Alice}
R(S)={Order1,Order4} - Image of S under relation R.

This is exactly the thing which finding all orders made by Alice.

2. Graph Theory

The image of a set under a relation in graph terms describes adjacency. Let's say we have a graph with some nodes and edges (relations). We can find all nodes which are directly reachable from some node (in this case A) using images:

Nodes = {A, B, C, D}
Edges (relation) = {(A, B), (A, C), (B, D), (C, B)}
S={A}
R(S)={B,C} - Nodes directly reachable from node A.

3. Algorithms

Many algorithms involve mapping elements from one set to another to identify properties or solve problems. For instance, in sorting algorithms, the relation might define how elements compare to each other, and understanding the image of a set under this relation can help optimize sorting.

array = {3, 1, 4, 1, 5, 9, 2}
Relation R based on '<'
S = {4}
R(S) = {5, 9} - elements greater than 4

Here, we have a relation "greater than" and we filtered the array for greater that 4.

Inverse Relation

Consider the relation R = {(1, a), (2, b), (3, a)} from set A = {1, 2, 3} to set B = {a, b}. The inverse relation becomes

R^(-1) = {(a, 1), (a, 3), (b, 2)}

Inverse Image

To understand this concept clearly, I'll give an example in relational databases.

Consider a database with two tables, Employees and Departments. Each employee is assigned to one department, establishing a relation R from Employees to Departments. The inverse relation R^{-1} can be used to find all employees in a specific department. If you know the department ID, you can easily retrieve all employees linked to that department, effectively using R^{-1}.

R = {(Sam, Development), (Tom, HR), (Martin, Development)}
R^(-1) = querying for the "Department" retrieves "Sam" and "Martin".

Finite Cardinality

We can then redefine the binary relations in finite sets:

1. If A surjective B, then |A| >= |B|
2. If A injective B, then |A| <= |B|
3. If A bijective B, then |A| = |B|

❓ How many subsets of a finite set?

✅ There are 2^n subsets in a n-element set.

https://docs.python.org/3/library/functions.html

👉abs(x) - absolute value of a number. Everyone knows it, right :)

👉all(iterable) - returns True if all elements of the iterable object (list, tuple, dictionary) are True, otherwise returns False. Equivalent to:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

👉any() - returns True if any item in an iterable object are true, otherwise it returns False. Equivalent to:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

👉ascii(object) - returns a readable version of an object. Replaces none-ascii characters with escape character.

x = ascii("Hi Såm!")
print(x)

# Output: Hi S\e5m!

👉bin(x) - Return the binary version of the number.

binary_number = bin(20)
print(binary_number)

# 0b10100

👉bool(object) - returns the boolean value of a specified object. The function returns False if:

• The object is empty, like [], {}, ()
• The object is False
• The object is 0
• The object is None

Otherwise, it returns True. Keep in mind that, using negative number also returns True:

print(bool(-4))

# True

👉callable(object) - returns True if the specified object is callable, otherwise it returns False.

def func():
    return 5

print(callable(func))

# True

When it returns False? Variables are not callable, for example.

👉chr(x) - converts an integer to its unicode character and returns it.

print(chr(97))
# a

👉classmethod() - converts the method into class method. In newer versions of Python, it is used as decorator, like @classmethod.

class Student:
  marks = 0

  def compute_marks(self, obtained_marks):
    marks = obtained_marks
    print('Obtained Marks:', marks)

# convert compute_marks() to class method
Student.print_marks = classmethod(Student.compute_marks)

👉complex(real, imaginary) - returns a complex number object by taking real and imaginary parts as floats.

print(complex(2.3, 5.4))
# (2.3 + 5.4j)

In addition, we can convert strings to complex numbers, but in this case we should omit the second parameter:

print(complex("2+3j"))
# (2+3j)

👉delattr(object, name) - removes an attribute of an Object (if the object allows it).

class Coordinate:
  x = 10
  y = -5
  z = 0

point1 = Coordinate()
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)

delattr(Coordinate, 'z')

# Raises Error
print('z = ',point1.z)

👉dict(**kwarg) - does not return any value. Instead, it creates a new dictionary according to keyword arguments given to it. Let's consider various ways of doing so:

numbers = dict(x=5, y=0)
print('numbers =', numbers)

# numbers = {'y':0, 'x':5}

numbers = dict([('x', 5), ('y', -5)])
print('numbers =',numbers)

# numbers = {'y':-5, 'x':5}

Also, we can create an empty dictionary:

print(dict())

# {}

👉dir(object) - returns the list of valid attributes of the passed object.

👉divmod(num1, num2) - takes two numbers as arguments and returns their quotient and remainder in a tuple.

result = divmod(8, 3)
print('Quotient and Remainder = ',result)

# Output: Quotient and Remainder =  (2, 2)

👉enumerate(iterable, start=0) - adds a counter to an iterable and returns it as an enumerate object (iterator with index and the value).

langs = ['Uzbek', 'English', 'Turkish']
enum_langs = enumerate(langs)
print(list(enum_length))

# [(0, 'Uzbek'), (1, 'English'), (2, 'Turkish')]

Keep in mind that, when printing always convert the result to list, since the function returns enumerate object.

👉staticmethod() - converts the given method of an object to static method.

class Calculator:
  def add_numbers(num1, num2):
    return num1 + num2

Calculator.add_numbers = staticmethod(Calculator.add_numbers)
sum = Calculator.add_numbers(5, 7)
print('Sum:', sum)

# Output: Sum: 12

👉filter(function, iterable) - selects elements from an iterable based on the result of a given function.

def check_even(number):
    if number % 2 == 0:
          return True  
    return False

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers_iterator = filter(check_even, numbers)
even_numbers = list(even_numbers_iterator)
print(even_numbers)

# Output: [2, 4, 6, 8, 10]

👉float() - returns a floating point number from a number or a string.

👉format(value, format_spec) - returns a formatted value based on the specified formatter. It can be 'b' - binary, 'd' - decimal or some other. You can find on doc.

val = 0xf3
bval = format(val, 'b')
dval = format(val, 'd')
print(bval, dval)

# 11110011 243

👉frozenset(iterable) - frozen set is just an immutable version of a Python set object. While elements of a set can be modified at any time, elements of the frozen set remain the same after creation.

Due to this, frozen sets can be used as keys in Dictionary or as elements of another set. But like sets, it is not ordered (the elements can be set at any index).

mylist = ['apple', 'banana', 'cherry']
x = frozenset(mylist)
print(x)

# frozenset({'apple', 'cherry', 'banana'})

👉getattr(object, name) - returns the value of the named attribute of an object. If not found, it returns the default value provided to the function.

class Student:
  marks = 88
  name = 'Sheeran'

person = Student()
name = getattr(person, 'name')
print(name)
marks = getattr(person, 'marks')
print(marks)

# Sheeran
# 88

👉globals() - returns a dictionary with all the global variables and symbols for the current program.

👉hasattr() - returns true if an object has the given named attribute and false if it does not.

class Person:
    age = 23
    name = "Adam"

person = Person()
print("Person's age:", hasattr(person, "age"))
print("Person's salary:", hasattr(person, "salary"))

# Person's age: True
# Person's salary: False

👉help() - use it when you need some help.

👉hex(int) - converts an integer to the corresponding hexadecimal number in string form and returns it.

num = 45
print(hex(num))

# 0x2d

👉hash(object) - returns the hash value of an object if it has one.

text = 'Python Programming'
hash_value = hash(text)
print(hash_value)

# Output: -966697084172663693

👉input('prompt') - takes input from the user and returns it.

👉id() - returns the “identity” of an object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.

In other words, this is the address of the object in memory.

print("id of 5 =", id(5))

# 140472391630016

👉isinstance(object, classinfo) - checks if the object (first argument) is an instance or subclass of classinfo class (second argument).

numbers = [1, 2, 3, 4, 2, 5]
result = isinstance(numbers, list)
print(result)

# Output: True

👉int(x) - converts a number or a string to its equivalent integer.

👉issubclass(class, classinfo) - checks whether the given class is subclass of classinfo.

class Polygon:
  def __init__(polygonType):
    print('Polygon is a ', polygonType)

class Triangle(Polygon):
  def __init__(self):

    Polygon.__init__('triangle')
    
print(issubclass(Triangle, Polygon))
print(issubclass(Triangle, list))
print(issubclass(Triangle, (list, Polygon)))
print(issubclass(Polygon, (list, Polygon)))

# True
# False
# True
# True

Take into account that every class is considered subclass of itself.

👉list(iterable) - returns a list in Python.

text = 'Python'
print(list(text))
print(type(text_list))

# ['P', 'y', 't', 'h', 'o', 'n']
# <class 'list'> 

👉locals() - returns a dictionary with all the local variables and symbols for the current program.

👉len(iterable) - returns the number of items (length) in an object.

👉max(iterable) - returns the largest item in an iterable.

👉min(iterable) - returns the smallest item in an iterable.

👉map(function, iterables) - executes a given function to each element of an iterable (such as lists, tuples, ...)

numbers = [1,2,3,4]

def square(number):
  return number * number

squared_numbers = map(square, numbers)

result = list(squared_numbers)
print(result)

# Output: [1,4,9,16]

Keep in mind that, after applying this function, you have to convert the result into list or some other alternative type, since by default it returns map object.

👉object() - returns a featureless object.

👉oct(int) - returns an octal string from the given integer number.

# decimal to octal
print('oct(10) is:', oct(10))

# 0o12

👉ord() - returns an integer representing the Unicode character.

character = 'P'
unicode_char = ord(character)
print(unicode_char)

# Output: 80

f = open("path_to_file", mode = 'r', encoding='utf-8')

👉pow() - computes the power of a number.

print(pow(3, 4))
# Output:  81

👉print() - Used to write "Hello World!" on the screen :))

👉range() - generates a sequence of numbers. By default, the sequence starts at 0, increments by 1, and stops before the specified number.

nums = range(4)
for i in nums:
    print(i, end=" ")
    
# 0 1 2 3

👉reversed() - computes the reverse of a given sequence object and returns it in the form of a list.

seq = 'Python'ng
print(list(reversed(seg)))

# Output: ['n', 'o', 'h', 't', 'y', 'P']

👉round(number) - rounds a number to the nearest integer.

👉set() - creates a set from an iterable object.

print(set([1,2,3]))

# {1,2,3}

👉setattr() - sets the value of the attribute of an object.

class Student:
  marks = 88
  name = 'Sheeran'

person = Student()
setattr(person, 'name', 'Adam')
setattr(person, 'marks', 78)

print(person.name)
print(person.marks)

# Adam
# 78

text = 'Python Programing'

sliced_text = slice(6)
print(text[sliced_text])

# Output: Python

👉sorted(iterable) - sorts the elements of the given iterable in ascending order and returns it.

👉str(object) - returns the string representation of a given object.

👉sum(iterable) - adds the items of an iterable and returns the sum.

👉tuple(iterable) - creates a tuple from a given iterable object.

👉type() - either returns the type of the object or returns a new type object based on the arguments passed.

👉zip(*iterables) - takes iterables (can be zero or more), aggregates them in a tuple, and returns it.

languages = ['Java', 'Python', 'JavaScript']
versions = [14, 3, 6]

result = zip(languages, versions)
print(list(result))

# Output: [('Java', 14), ('Python', 3), ('JavaScript', 6)]

That's all.

So, today we considered 66 out of 68 built-in functions in Python. I admit that some of them are highlighted and even without description, but that's not reasonless. Some methods need more thorough research and usage cases to grasp the whole meaning and hence I just highlighted them. Next time, I try to cover them as well on separate articles.

🏁 Enough for today, thanks for your attention!

https://docs.djangoproject.com/en/5.0/howto/legacy-databases/

Well, usually we work with databases using DBMS tools, like Navicat. Which means, there is rare writing models one-by-one in Django ORM. In such cases, we use inspectdb command of Django to make our life easier. I hope you got the point about this command at least by reading the documentation above. Now, I'll turn into a problem and start creating a new table, say user:

Let's assume that you have already connected your database to Django project:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': '<your_db_name>',
        'USER': '<your_db_user>',
        'PASSWORD': '<your_db_password>',
        'HOST': '<your_db_host>',
        'PORT': '5432'
    }
}

and there is at least one app on that project. I created a test app psql_app and now run python manage.py inspectdb > psql_app/models.py. Nothing happens on Command prompt, but when you open your models.py you can see generated tables:

Well, that's normal. But stop! ID field is popped up somehow! When we work with ORM after generating the table, undoubtedly encounter problems related to this ID field, and that is the issue you are facing with too.

Before turning into a solution, let's create another table courses :

We should point out that in this case we set the ID field type to serial . To learn more about serial:

https://www.tutorialsteacher.com/postgresql/serial-type

When we save the table, the type becomes int4 automatically, but:

As we can see, postgresql auto generates a sequence for us. Now, again we run inspectdb and see the result:

ID field is not present! So we solved the problem. It is very essential to pay attention on types of fields while creating a database tables using both DBMS tools and ORMs. Thanks for your attention.