{"id":399032,"date":"2024-06-29T14:25:49","date_gmt":"2024-06-29T14:25:49","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=399032"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=399032","title":{"rendered":"Writing The Matrix in Python<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n
<\/figure>\n

There are different ways to learn new things. Some like to study theory first, and then apply it in practice. Others prefer to learn solely from examples found at Stackoverflow. And someone just downloads helicopter control skills and martial arts techniques via dedicated channel directly into the brain.<\/p>\n

In any case, practical exercises are indispensable. After the accelerated download of knowledge, Neo still must spar with Morpheus to learn how to put the terabytes of downloaded skills into practice. Just the exercises are different. It is one thing\u2014to fly dashingly up to the ceiling and break through the walls of the oriental gym, and quite another\u2014to methodically polish your skills for hours.<\/p>\n

\"Training<\/p>\n
Training in the Matrix<\/em><\/figcaption><\/div>\n<\/figure>\n

Defining the goals<\/h2>\n

Programming textbooks usually do not indulge us with variety of examples. There are, of course, exceptions, but in most manuals, exercises are similar to each other and not particularly interesting: create another address book, draw a circle using turtle, develop a website for a store selling some kind of «necessary» advertising nonsense. Too far from the authentic imitation of «The Matrix». Although\u2026<\/p>\n

How about taking over the control and starting to invent exercises yourself?<\/p>\n

Would you like to write your own personal little «Matrix»? Of course, not the one with skyscrapers, stylish phones of the time, and the ubiquitous invincible Agent Smiths. We surely will need a couple of more months of learning for that. But any beginner programmer can write a model of the cult splash screensaver with the green streams of digits flowing down the screen. This is what we are going to do.<\/p>\n

It is possible to program such screensaver in almost any language. Let’s try to create it in the «great and mighty» Python.<\/p>\n

\"Original<\/p>\n
Original Matrix with green hieroglyphs<\/em><\/figcaption><\/div>\n<\/figure>\n

The technical requirements<\/h2>\n

First, we need to decide what we want to end up with. We should develop technical requirements\u2014it is always useful. Just think of «The Matrix» for a moment, and your memory will probably suggest a familiar image\u2014the dark console window in which streams of green numbers will flow. To make it even more interesting, let them move at different speeds. Each stream should have a beginning\u2014a bright green zero\u2014and an end. By the way, let the speeds of movement of the beginning and the end of the stream will also be different and determined randomly.<\/p>\n

It doesn’t sound so hard, does it? Now it’s time to just write the code. Let’s get started.<\/p>\n

\"Technical<\/p>\n
Technical task in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n

Preparing the tools<\/h2>\n

At first we will connect all the necessary modules, starting with the standard ones:<\/p>\n

import sys import random import time<\/code><\/pre>\n
To work with the Windows console, we need the bext<\/strong> and the colorama<\/strong> modules. How to install them using pip<\/strong>, you probably already know. You need to connect them. But let’s do it according to all the rules\u2014with a check:<\/p>\n
try:     import bext, colorama except ImportError:     print ('Bext and colorama modules are required to run the program')     sys.exit ()<\/code><\/pre>\n
Let’s prepare the console for work:<\/p>\n
bext.title ('Matrix') bext.clear () bext.hide () width, height = bext.size () width -= 1 height -= 1<\/code><\/pre>\n
Now it remains only to create constants with colors for the colorama<\/strong> module. We need green and dark green:<\/p>\n
lgreen = colorama.Fore.LIGHTGREEN_EX green = colorama.Fore.GREEN<\/code><\/pre>\n
Windows is a tricky and controversial thing. The base color of green in the console is dark green.<\/p>\n
\"Standard<\/p>\n
Standard tools in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n
Inventing the antimatter<\/h2>\n
Now let’s think about the most important question: how can we program the flowing drops of the «Matrix»? Each drop is an object. All drops are different, but they behave the same. Therefore, we need to create a class in which we will describe the main actions with the drop and all its attributes.<\/p>\n
To make the drops flow at different speeds, let’s set a random delay timeout for each of them\u2014in steps. Some drops will move at each step of updating our picture, some\u2014less often.<\/p>\n
What about the upper end of the stream? It must «dry», and at its own speed. Let’s not invent anything complicated. Let the upper end also be a drop, but black. Such a «drop» when moving will not add digits, but rather erase them. It turns out just some kind of anti-drop, anti-matter\u2014beautiful and stylish.<\/p>\n
Since the drop and the anti-drop behave the same, let’s program them in the same class.<\/p>\n
Creating the drops<\/h2>\n
So, we will perform all actions with drops and anti-drops in the class methods. Let’s call it Drop<\/strong> and write a method for creating a class object:<\/p>\n
def __init__ (self):     self.x = random.randint (0, width)     self.y = -1     self.drop_type = random.randint (0, 1)     self.timeout = random.randint (0, 3)     self.wait_count = random.randint (0, 3)<\/code><\/pre>\n
Everything is clear with the x<\/strong> and y<\/strong> attributes. The second one is ‘-1’ so that the drop is not shown on the screen ahead of time. The timeout and wait_count attributes are needed to provide different drop rates. The first sets the constant flow rate, the second sets the iteration counter.<\/p>\n
Moving the drops<\/h2>\n
Now let’s write a method for moving a drop, taking into account its speed.<\/p>\n
def move (self):     if drop.wait_count < drop.timeout:         drop.wait_count += 1         return False     else:         drop.wait_count = 0         drop.y += 1         return True<\/code><\/pre>\n
The method returns a boolean value\u2014the fact that the drop has moved. Or antidrops\u2014all the same.<\/p>\n
<\/figure>\n
Drawing the stream<\/h2>\n
Now we\u2019ve done with moving the drops. It’s time to draw!<\/p>\n
def draw (self):     if self.drop_type == 1:         symbol = str (random.randint (1, 9))         con_print (self.x, self.y, green, symbol)         self.zero_draw ()     else:         con_print (self.x, self.y, green, ' ')<\/code><\/pre>\n
Here we call two new methods not yet written: con_print<\/strong> and zero_draw<\/strong>. The first one will output the character of the desired color to the specified location in the console window. The second will draw an extra bright zero at the beginning of the trickle.<\/p>\n
Here is the second method:<\/p>\n
def zero_draw (self):     if (self.y < height):     con_print (self.x, self.y+1, lgreen, '0')<\/code><\/pre>\n
\"Rain<\/p>\n
Rain in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n
Organizing the reincarnation of the drops<\/h2>\n
We have already understood that what we are getting is not a simple «Matrix», but a philosophical one. Therefore, when the drops and anti-drops reach the bottom edge of the screen, let’s make them reborn. They will get a new life at the upper border. This will only cost us two lines:<\/p>\n
def renew (self):     self.__init__ ()<\/code><\/pre>\n
Now we have everything we need. The Drop<\/strong> class is ready.<\/p>\n
Outputting text to the console<\/h2>\n
Let’s break out of the boundaries of the Drop<\/strong> class and write two functions for displaying text in the console window.<\/p>\n
If we try to print something in the lower right corner of the console window, then another line will automatically be added to the bottom. Nothing can be done: in this place in our ideal «Matrix» there will be a «broken pixel»:<\/p>\n
def is_rb_corner (x, y):     return x==width and y==height<\/code><\/pre>\n
Now everything is ready to print the requested character in the right place.<\/p>\n
def con_print (x, y, color, symbol):     if not is_rb_corner (x, y):         bext.goto (x, y)         sys.stdout.write (color)         print (symbol, end='')<\/code><\/pre>\n
<\/figure>\n
Getting it all together<\/h2>\n
All components of our future «Matrix» are ready. Now it remains to put everything together and run.<\/p>\n
Let’s create an array of drops and antidrops (what type of object is born is a matter of chance).<\/p>\n
drops = [] for i in range (1, width*2\/\/3):     drop = Drop ()     drops.append (drop)<\/code><\/pre>\n
And finally, the most important loop:<\/p>\n
while True:     for drop in drops:         if drop.move ():             drop.draw ()             if drop.y >= height:                 drop.renew ()     key = bext.getKey (blocking = False)     if key == 'esc':         bext.clear ()         sys.exit ()     time.sleep (0.02)<\/code><\/pre>\n
<\/figure>\n
The entire program<\/h2>\n
import sys import random import time  try:     import bext, colorama except ImportError:     print ('Bext and colorama modules are required to run the program')     sys.exit ()  class Drop:     def __init__ (self):         self.x = random.randint (0, width)         self.y = -1         self.drop_type = random.randint (0, 1)         self.timeout = random.randint (0, 3)         self.wait_count = random.randint (0, 3)     def renew (self):         self.__init__ ()     def move (self):         if drop.wait_count < drop.timeout:             drop.wait_count += 1             return False         else:             drop.wait_count = 0             drop.y += 1             return True     def draw (self):         if self.drop_type == 1:             symbol = str (random.randint (1, 9))             con_print (self.x, self.y, green, symbol)             self.zero_draw ()         else:             con_print (self.x, self.y, green, ' ')     def zero_draw (self):         if (self.y < height):             con_print (self.x, self.y+1, lgreen, '0')  def is_rb_corner (x, y):     return x==width and y==height  def con_print (x, y, color, symbol):     if not is_rb_corner (x, y):         bext.goto (x, y)         sys.stdout.write (color)         print (symbol, end='')  bext.title ('Matrix') bext.clear () bext.hide () width, height = bext.size () width -= 1 height -= 1  green = colorama.Fore.GREEN lgreen = colorama.Fore.LIGHTGREEN_EX  drops = [] for i in range (1, width*2\/\/3):     drop = Drop ()     drops.append (drop)  while True:     for drop in drops:         if drop.move ():             drop.draw ()             if drop.y >= height:                 drop.renew ()     key = bext.getKey (blocking = False)     if key == 'esc':         bext.clear ()         sys.exit ()     time.sleep (0.02)<\/code><\/pre>\n
You can also experiment with this program. Try adding your own additional unique effects. 
I wonder what your «Matrix» will be like.<\/p>\n<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/720452\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
\n
\n
\n
\n
<\/figure>\n
There are different ways to learn new things. Some like to study theory first, and then apply it in practice. Others prefer to learn solely from examples found at Stackoverflow. And someone just downloads helicopter control skills and martial arts techniques via dedicated channel directly into the brain.<\/p>\n
In any case, practical exercises are indispensable. After the accelerated download of knowledge, Neo still must spar with Morpheus to learn how to put the terabytes of downloaded skills into practice. Just the exercises are different. It is one thing\u2014to fly dashingly up to the ceiling and break through the walls of the oriental gym, and quite another\u2014to methodically polish your skills for hours.<\/p>\n
\n
Training in the Matrix<\/em><\/figcaption><\/div>\n<\/figure>\n
Defining the goals<\/h2>\n
Programming textbooks usually do not indulge us with variety of examples. There are, of course, exceptions, but in most manuals, exercises are similar to each other and not particularly interesting: create another address book, draw a circle using turtle, develop a website for a store selling some kind of «necessary» advertising nonsense. Too far from the authentic imitation of «The Matrix». Although\u2026<\/p>\n
How about taking over the control and starting to invent exercises yourself?<\/p>\n
Would you like to write your own personal little «Matrix»? Of course, not the one with skyscrapers, stylish phones of the time, and the ubiquitous invincible Agent Smiths. We surely will need a couple of more months of learning for that. But any beginner programmer can write a model of the cult splash screensaver with the green streams of digits flowing down the screen. This is what we are going to do.<\/p>\n
It is possible to program such screensaver in almost any language. Let’s try to create it in the «great and mighty» Python.<\/p>\n
\n
Original Matrix with green hieroglyphs<\/em><\/figcaption><\/div>\n<\/figure>\n
The technical requirements<\/h2>\n
First, we need to decide what we want to end up with. We should develop technical requirements\u2014it is always useful. Just think of «The Matrix» for a moment, and your memory will probably suggest a familiar image\u2014the dark console window in which streams of green numbers will flow. To make it even more interesting, let them move at different speeds. Each stream should have a beginning\u2014a bright green zero\u2014and an end. By the way, let the speeds of movement of the beginning and the end of the stream will also be different and determined randomly.<\/p>\n
It doesn’t sound so hard, does it? Now it’s time to just write the code. Let’s get started.<\/p>\n
\n
Technical task in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n
Preparing the tools<\/h2>\n
At first we will connect all the necessary modules, starting with the standard ones:<\/p>\n
import sys import random import time<\/code><\/pre>\n
To work with the Windows console, we need the bext<\/strong> and the colorama<\/strong> modules. How to install them using pip<\/strong>, you probably already know. You need to connect them. But let’s do it according to all the rules\u2014with a check:<\/p>\n
try:     import bext, colorama except ImportError:     print ('Bext and colorama modules are required to run the program')     sys.exit ()<\/code><\/pre>\n
Let’s prepare the console for work:<\/p>\n
bext.title ('Matrix') bext.clear () bext.hide () width, height = bext.size () width -= 1 height -= 1<\/code><\/pre>\n
Now it remains only to create constants with colors for the colorama<\/strong> module. We need green and dark green:<\/p>\n
lgreen = colorama.Fore.LIGHTGREEN_EX green = colorama.Fore.GREEN<\/code><\/pre>\n
Windows is a tricky and controversial thing. The base color of green in the console is dark green.<\/p>\n
\n
Standard tools in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n
Inventing the antimatter<\/h2>\n
Now let’s think about the most important question: how can we program the flowing drops of the «Matrix»? Each drop is an object. All drops are different, but they behave the same. Therefore, we need to create a class in which we will describe the main actions with the drop and all its attributes.<\/p>\n
To make the drops flow at different speeds, let’s set a random delay timeout for each of them\u2014in steps. Some drops will move at each step of updating our picture, some\u2014less often.<\/p>\n
What about the upper end of the stream? It must «dry», and at its own speed. Let’s not invent anything complicated. Let the upper end also be a drop, but black. Such a «drop» when moving will not add digits, but rather erase them. It turns out just some kind of anti-drop, anti-matter\u2014beautiful and stylish.<\/p>\n
Since the drop and the anti-drop behave the same, let’s program them in the same class.<\/p>\n
Creating the drops<\/h2>\n
So, we will perform all actions with drops and anti-drops in the class methods. Let’s call it Drop<\/strong> and write a method for creating a class object:<\/p>\n
def __init__ (self):     self.x = random.randint (0, width)     self.y = -1     self.drop_type = random.randint (0, 1)     self.timeout = random.randint (0, 3)     self.wait_count = random.randint (0, 3)<\/code><\/pre>\n
Everything is clear with the x<\/strong> and y<\/strong> attributes. The second one is ‘-1’ so that the drop is not shown on the screen ahead of time. The timeout and wait_count attributes are needed to provide different drop rates. The first sets the constant flow rate, the second sets the iteration counter.<\/p>\n
Moving the drops<\/h2>\n
Now let’s write a method for moving a drop, taking into account its speed.<\/p>\n
def move (self):     if drop.wait_count < drop.timeout:         drop.wait_count += 1         return False     else:         drop.wait_count = 0         drop.y += 1         return True<\/code><\/pre>\n
The method returns a boolean value\u2014the fact that the drop has moved. Or antidrops\u2014all the same.<\/p>\n
<\/figure>\n
Drawing the stream<\/h2>\n
Now we\u2019ve done with moving the drops. It’s time to draw!<\/p>\n
def draw (self):     if self.drop_type == 1:         symbol = str (random.randint (1, 9))         con_print (self.x, self.y, green, symbol)         self.zero_draw ()     else:         con_print (self.x, self.y, green, ' ')<\/code><\/pre>\n
Here we call two new methods not yet written: con_print<\/strong> and zero_draw<\/strong>. The first one will output the character of the desired color to the specified location in the console window. The second will draw an extra bright zero at the beginning of the trickle.<\/p>\n
Here is the second method:<\/p>\n
def zero_draw (self):     if (self.y < height):     con_print (self.x, self.y+1, lgreen, '0')<\/code><\/pre>\n
\n
Rain in «The Matrix»<\/em><\/figcaption><\/div>\n<\/figure>\n
Organizing the reincarnation of the drops<\/h2>\n
We have already understood that what we are getting is not a simple «Matrix», but a philosophical one. Therefore, when the drops and anti-drops reach the bottom edge of the screen, let’s make them reborn. They will get a new life at the upper border. This will only cost us two lines:<\/p>\n
def renew (self):     self.__init__ ()<\/code><\/pre>\n
Now we have everything we need. The Drop<\/strong> class is ready.<\/p>\n
Outputting text to the console<\/h2>\n
Let’s break out of the boundaries of the Drop<\/strong> class and write two functions for displaying text in the console window.<\/p>\n
If we try to print something in the lower right corner of the console window, then another line will automatically be added to the bottom. Nothing can be done: in this place in our ideal «Matrix» there will be a «broken pixel»:<\/p>\n
def is_rb_corner (x, y):     return x==width and y==height<\/code><\/pre>\n
Now everything is ready to print the requested character in the right place.<\/p>\n
def con_print (x, y, color, symbol):     if not is_rb_corner (x, y):         bext.goto (x, y)         sys.stdout.write (color)         print (symbol, end='')<\/code><\/pre>\n
<\/figure>\n
Getting it all together<\/h2>\n
All components of our future «Matrix» are ready. Now it remains to put everything together and run.<\/p>\n
Let’s create an array of drops and antidrops (what type of object is born is a matter of chance).<\/p>\n
drops = [] for i in range (1, width*2\/\/3):     drop = Drop ()     drops.append (drop)<\/code><\/pre>\n
And finally, the most important loop:<\/p>\n
while True:     for drop in drops:         if drop.move ():             drop.draw ()             if drop.y >= height:                 drop.renew ()     key = bext.getKey (blocking = False)     if key == 'esc':         bext.clear ()         sys.exit ()     time.sleep (0.02)<\/code><\/pre>\n
<\/figure>\n
The entire program<\/h2>\n
import sys import random import time  try:     import bext, colorama except ImportError:     print ('Bext and colorama modules are required to run the program')     sys.exit ()  class Drop:     def __init__ (self):         self.x = random.randint (0, width)         self.y = -1         self.drop_type = random.randint (0, 1)         self.timeout = random.randint (0, 3)         self.wait_count = random.randint (0, 3)     def renew (self):         self.__init__ ()     def move (self):         if drop.wait_count < drop.timeout:             drop.wait_count += 1             return False         else:             drop.wait_count = 0             drop.y += 1             return True     def draw (self):         if self.drop_type == 1:             symbol = str (random.randint (1, 9))             con_print (self.x, self.y, green, symbol)             self.zero_draw ()         else:             con_print (self.x, self.y, green, ' ')     def zero_draw (self):         if (self.y < height):             con_print (self.x, self.y+1, lgreen, '0')  def is_rb_corner (x, y):     return x==width and y==height  def con_print (x, y, color, symbol):     if not is_rb_corner (x, y):         bext.goto (x, y)         sys.stdout.write (color)         print (symbol, end='')  bext.title ('Matrix') bext.clear () bext.hide () width, height = bext.size () width -= 1 height -= 1  green = colorama.Fore.GREEN lgreen = colorama.Fore.LIGHTGREEN_EX  drops = [] for i in range (1, width*2\/\/3):     drop = Drop ()     drops.append (drop)  while True:     for drop in drops:         if drop.move ():             drop.draw ()             if drop.y >= height:                 drop.renew ()     key = bext.getKey (blocking = False)     if key == 'esc':         bext.clear ()         sys.exit ()     time.sleep (0.02)<\/code><\/pre>\n
You can also experiment with this program. Try adding your own additional unique effects. 
I wonder what your «Matrix» will be like.<\/p>\n<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/720452\/<\/a>
<\/br><\/br><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-399032","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/399032","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=399032"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/399032\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=399032"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=399032"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=399032"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}