Cloud Service Provider
for Developers and Teams

The first question newcomers often ask about the walrus operator in Python is: why such a strange name? The answer lies in its appearance. Look at the Python walrus operator: :=. Doesn't it resemble a walrus lounging on a beach, with the symbols representing its "eyes" and "tusks"? That's how it earned the name. How the Walrus Operator Works Introduced in Python 3.8, the walrus operator allows you to assign a value to a variable while returning that value in a single expression. Here's a simple example: print(apples = 7) This would result in an error because print expects an expression, not an assignment. But with the walrus operator: print(apples := 7) The output will be 7. This one-liner assigns the value 7 to apples and returns it simultaneously, making the code compact and clear. Practical Examples Let’s look at a few examples of how to use the walrus operator in Python. Consider a program where users input phrases. The program stops if the user presses Enter. In earlier versions of Python, you'd write it like this: expression = input('Enter something or just press Enter: ') while expression != '': print('Great!') expression = input('Enter something or just press Enter: ') print('Bored? Okay, goodbye.') This works, but we can simplify it using the walrus operator, reducing the code from five lines to three: while (expression := input('Enter something or just press Enter: ')) != '': print('Great!') print('Bored? Okay, goodbye.') Here, the walrus operator allows us to assign the user input to expression directly inside the while loop, eliminating redundancy. Key Features of the Walrus Operator: The walrus operator only assigns values within other expressions, such as loops or conditions. It helps reduce code length while maintaining clarity, making your scripts more efficient and easier to read. Now let's look at another example of the walrus operator within a conditional expression, demonstrating its versatility in Python's modern syntax. Using the Walrus Operator with Conditional Constructs Let’s write a phrase, assign it to a variable, and then find a word in this phrase using a condition: phrase = 'But all sorts of things and weather must be taken in together to make up a year and a sphere...' word = phrase.find('things') if word != -1: print(phrase[word:]) The expression [word:] allows us to get the following output: things and weather must be taken in together to make up a year and a sphere... Now let's shorten the code using the walrus operator. Instead of: word = phrase.find('things') if word != -1: print(phrase[word:]) we can write: if (word := phrase.find('things')) != -1: print(phrase[word:]) In this case, we saved a little in volume but also reduced the number of lines. Note that, despite the reduced time for writing the code, the walrus operator doesn’t always simplify reading it. However, in many cases, it’s just a matter of habit, so with practice, you'll learn to read code with "walruses" easily. Using the Walrus Operator with Numeric Expressions Lastly, let’s look at an example from another area where using the walrus operator helps optimize program performance: numerical operations. We will write a simple program to perform exponentiation: def pow(number, power): print('Calling pow') result = 1 while power: result *= number power -= 1 return result Now, let’s enter the following in the interpreter: >>> [pow(number, 2) for number in range(3) if pow(number, 2) % 2 == 0] We get the following output: Calling pow Calling pow Calling pow Calling pow Calling pow [0, 4, 16] Now, let's rewrite the input in the interpreter using the walrus operator: >>> [p for number in range(3) if (p := pow(number, 2)) % 2 == 0] Output: Calling pow Calling pow Calling pow [0, 4, 16] As we can see, the code hasn’t shrunk significantly, but the number of function calls has nearly been halved, meaning the program will run faster! Conclusion In conclusion, the walrus operator (:=) introduced in Python 3.8 streamlines code by allowing assignment and value retrieval in a single expression. This operator enhances readability and efficiency, particularly in loops and conditional statements. Through practical examples, we’ve seen how it reduces line counts and minimizes redundant function calls, leading to faster execution. With practice, developers can master the walrus operator, making their code cleaner and more concise.

As the name suggests, Python 3 string functions are designed to perform various operations on strings. There are several dozen string functions in the Python programming language. In this article, we will cover the most commonly used ones and several special functions that may be less popular but are still useful. They can be helpful not only for formatting but also for data validation. List of Basic String Functions for Text Formatting First, let’s discuss string formatting functions, and to make the learning process more enjoyable, we will use texts generated by a neural network in our examples. capitalize() — Converts the first character of the string to uppercase, while all other characters will be in lowercase: >>> phrase = 'the shortage of programmers increases the significance of DevOps. After the presentation, developers start offering their services one after another, competing with each other for DevOps.' >>> phrase.capitalize() 'The shortage of programmers increases the significance of devops. after the presentation, developers start offering their services one after another, competing with each other for devops.' casefold() — Returns all elements of the string in lowercase: >>> phrase = 'Cloud providers offer scalable computing resources and services over the internet, enabling businesses to innovate quickly. They support various applications, from storage to machine learning, while ensuring reliability and security.' >>> phrase.casefold() 'cloud providers offer scalable computing resources and services over the internet, enabling businesses to innovate quickly. they support various applications, from storage to machine learning, while ensuring reliability and security.' center() — This method allows you to center-align strings: >>> text = 'Python is great for writing AI' >>> newtext = text.center(40, '*') >>> print(newtext) *****Python is great for writing AI***** A small explanation: The center() function has two arguments: the first (length of the string for centering) is mandatory, while the second (filler) is optional. In the operation above, we used both. Our string consists of 30 characters, so the remaining 10 were filled with asterisks. If the second attribute were omitted, spaces would fill the gaps instead. upper() and lower() — convert all characters to uppercase and lowercase, respectively: >>> text = 'Projects using Internet of Things technology are becoming increasingly popular in Europe.' >>> text.lower() 'projects using internet of things technology are becoming increasingly popular in europe.' >>> text.upper() 'PROJECTS USING INTERNET OF THINGS TECHNOLOGY ARE BECOMING INCREASINGLY POPULAR IN EUROPE.' replace() — is used to replace a part of the string with another element: >>> text.replace('Europe', 'USA') 'Projects using Internet of Things technology are becoming increasingly popular in the USA.' The replace() function also has an optional count attribute that specifies the maximum number of replacements if the element to be replaced occurs multiple times in the text. It is specified in the third position: >>> text = 'hooray hooray hooray' >>> text.replace('hooray', 'hip', 2) 'hip hip hooray' strip() — removes identical characters from the edges of a string: >>> text = 'ole ole ole' >>> text.strip('ole') 'ole' If there are no symmetrical values, it will remove what is found on the left or right. If the specified characters are absent, the output will remain unchanged: >>> text.strip('ol') 'e ole ole' >>> text.strip('le') 'ole ole o' >>> text.strip('ura') 'ole ole ole' title() — creates titles, capitalizing each word: >>> texttitle = 'The 5G revolution: transforming connectivity. How next-gen networks are shaping our digital future' >>> texttitle.title() 'The 5G Revolution: Transforming Connectivity. How Next-Gen Networks Are Shaping Our Digital Future' expandtabs() — changes tabs in the text, which helps with formatting: >>> clublist = 'Milan\tReal\tBayern\tArsenal' >>> print(clublist) Milan Real Bayern Arsenal >>> clublist.expandtabs(1) 'Milan Real Bayern Arsenal' >>> clublist.expandtabs(5) 'Milan Real Bayern Arsenal' String Functions for Value Checking Sometimes, it is necessary to count a certain number of elements in a sequence or check if a specific value appears in the text. The following string functions solve these and other tasks. count() — counts substrings (individual elements) that occur in a string. Let's refer again to our neural network example: >>> text = "Cloud technologies significantly accelerate work with neural networks and AI. These technologies are especially important for employees of large corporations operating in any field — from piloting spacecraft to training programmers." >>> element = "o" >>> number = text.count(element) >>> print("The letter 'o' appears in the text", number, "time(s).") The letter 'o' appears in the text 19 time(s). As a substring, you can specify a sequence of characters (we'll use text from the example above): >>> element = "ob" >>> number = text.count(element) >>> print("The combination 'ob' appears in the text", number, "time(s).") The combination 'in' appears in the text 5 time(s). Additionally, the count() function has two optional numerical attributes that specify the search boundaries for the specified element: >>> element = "o" >>> number = text.count(element, 20, 80) >>> print("The letter 'o' appears in the specified text fragment", number, "time(s).") The letter 'o' appears in the specified text fragment 6 time(s). The letter 'o' appears in the specified text fragment 6 time(s). find() — searches for the specified value in the string and returns the smallest index. Again, we will use the example above: >>> print(text.find(element)) 7 This output means that the first found letter o is located at position 7 in the string (actually at position 8, because counting in Python starts from zero). Note that the interpreter ignored the capital letter O, which is located at position zero. Now let's combine the two functions we've learned in one code: >>> text = "Cloud technologies significantly accelerate work with neural networks and AI. These technologies are especially important for employees of large corporations operating in any field — from piloting spacecraft to training programmers." >>> element = "o" >>> number = text.count(element, 20, 80) >>> print("The letter 'o' appears in the specified text fragment", number, "time(s), and the first time in the whole text at", (text.find(element)), "position.") The letter 'o' appears in the specified text fragment 3 time(s), and the first time in the whole text at 7 position. index() — works similarly to find(), but will raise an error if the specified value is absent: Traceback (most recent call last): File "C:\Python\text.py", line 4, in <module> print(text.index(element)) ValueError: substring not found Here's what the interpreter would return when using the find() function in this case: -1 This negative position indicates that the value was not found. enumerate() — a very useful function that not only iterates through the elements of a list or tuple, returning their values, but also returns the ordinal number of each element: team_scores = [78, 74, 56, 53, 49, 47, 44] for number, score in enumerate(team_scores, 1): print(str(number) + '-th team scored ' + str(score) + ' points.') To output the values with their ordinal numbers, we introduced a few variables: number for ordinal numbers, score for the values of the list, and str indicates a string. And here’s the output: 1-th team scored 78 points. 2-th team scored 74 points. 3-th team scored 56 points. 4-th team scored 53 points. 5-th team scored 49 points. 6-th team scored 47 points. 7-th team scored 44 points. Note that the second attribute of the enumerate() function is the number 1, otherwise Python would start counting from zero. len() — counts the length of an object, i.e., the number of elements that make up a particular sequence: >>> len(team_scores) 7 This way, we counted the number of elements in the list from the example above. Now let's ask the neural network to write a string again and count the number of characters in it: >>> network = 'It is said that artificial intelligence excludes the human factor. But do not forget that the human factor is still present in the media and government structures.' >>> len(network) 162 Special String Functions in Python join() — allows you to convert lists into strings: >>> cities = ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio'] >>> cities_str = ', '.join(cities) >>> print('Cities in one line:', cities_str) Cities in one line: New York, Los Angeles, Chicago, Houston, Phoenix, Philadelphia, San Antonio print() — provides a printed representation of any object in Python: >>> cities = ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio'] >>> print(cities) ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio'] type() — returns the type of the object: >>> type(cities) <class 'list'> We found out that the object from the previous example is a list. This is useful for beginners, as they may initially confuse lists with tuples, which have different functionalities and are handled differently by the interpreter. map() — is a fairly efficient replacement for a for loop, allowing you to iterate over the elements of an iterable object, applying a built-in function to each of them. For example, let's convert a list of string values into integers using the int function: >>> numbers_list = ['4', '7', '11', '12', '17'] >>> list(map(int, numbers_list)) [4, 7, 11, 12, 17] As we can see, we used the list() function, "wrapping" the map() function in it—this was necessary to avoid the following output: >>> numbers_list = ['4', '7', '11', '12', '17'] >>> map(int, numbers_list) <map object at 0x0000000002E272B0> This is not an error; it simply produces the ID of the object, and the program will continue to run. However, the list() method is useful in such cases to get the desired list output. Of course, we haven't covered all string functions in Python. Still, this set will already help you perform a large number of operations with strings and carry out various transformations (programmatic and mathematical).

In this article, we’ll show how to set up an Ubuntu 20.04 server and install and configure the components required for deploying Python applications. We’ll configure the WSGI server Gunicorn to interact with our application. Gunicorn will serve as an interface that converts client requests via the HTTP protocol into Python function calls executed by the application. Then, we will configure Nginx as a reverse proxy server for Gunicorn, which will forward requests to the Gunicorn server. Additionally, we will cover securing HTTP connections with an SSL certificate or using other features like load balancing, caching, etc. These details can be helpful when working with cloud services like those provided by Hostman. Creating a Python Virtual Environment To begin, we need to update all packages: sudo apt update Ubuntu provides the latest version of the Python interpreter by default. Let’s check the installed version using the following command: python3 --version Example output: Python 3.10.12 We’ll set up a virtual environment to ensure that our project has its own dependencies, separate from other projects. First, install the virtualenv package, which allows you to create virtual environments: sudo apt-get install python3-venv python3-dev Next, create a folder for your project and navigate into it: mkdir myappcd myapp Now, create a virtual environment: python3 -m venv venv And create a folder for your project: mkdir app Your project directory should now contain two items: app and venv. You can verify this using the standard Linux command to list directory contents: ls Expected output: myapp venv You need to activate the virtual environment so that all subsequent components are installed locally for the project: source venv/bin/activate Installing and Configuring Gunicorn Gunicorn (Green Unicorn) is a Python WSGI HTTP server for UNIX. It is compatible with various web frameworks, fast, easy to implement, and uses minimal server resources. To install Gunicorn, run the following command: pip install gunicorn WSGI and Python WSGI (Web Server Gateway Interface) is the standard interface between a Python application running on the server side and the web server itself, such as Nginx. A WSGI server interacts with the application, allowing you to run code when handling requests. Typically, the application is provided as an object named application in a Python module, which is made available to the server. In the standard wsgi.py file, there is usually a callable application. For example, let’s create such a file using the nano text editor: nano wsgi.py Add the following simple code to the file: from aiohttp import web async def index(request): return web.Response(text="Welcome home!") app = web.Application() app.router.add_get('/', index) In the code above, we import aiohttp, a library that provides an asynchronous HTTP client built on top of asyncio. HTTP requests are a classic example of where asynchronous handling is ideal, as they involve waiting for server responses, during which other code can execute efficiently. This library allows sequential requests to be made without waiting for the first response before sending a new one. It’s common to run aiohttp servers behind Nginx. Running the Gunicorn Server You can launch the server using the following command template: gunicorn [OPTIONS] [WSGI_APP] Here, [WSGI_APP] consists of $(MODULE_NAME):$(VARIABLE_NAME) and [OPTIONS] is a set of parameters for configuring Gunicorn. A simple command would look like this: gunicorn wsgi:app To restart Gunicorn, you can use: sudo systemctl restart gunicorn Systemd Integration systemd is a system and service manager that allows for strict control over processes, resources, and permissions. We’ll create a socket that systemd will listen to, automatically starting Gunicorn in response to traffic. Configuring the Gunicorn Service and Socket First, create the service configuration file: sudo nano /etc/systemd/system/gunicorn.service Add the following content to the file: [Unit] Description=gunicorn daemon Requires=gunicorn.socket After=network.target [Service] Type=notify User=someuser Group=someuser RuntimeDirectory=gunicorn WorkingDirectory=/home/someuser/myapp ExecStart=/path/to/venv/bin/gunicorn wsgi:app ExecReload=/bin/kill -s HUP $MAINPID KillMode=mixed TimeoutStopSec=5 PrivateTmp=true [Install] WantedBy=multi-user.target Make sure to replace /path/to/venv/bin/gunicorn with the actual path to the Gunicorn executable within your virtual environment. It will likely look something like this: /home/someuser/myapp/venv/bin/gunicorn. Next, create the socket configuration file: sudo nano /etc/systemd/system/gunicorn.socket Add the following content: [Unit] Description=gunicorn socket [Socket] ListenStream=/run/gunicorn.sock SocketUser=www-data [Install] WantedBy=sockets.target Enable and start the socket with: systemctl enable --now gunicorn.socket Configuring Gunicorn Let's review some useful parameters for Gunicorn in Python 3. You can find all possible parameters in the official documentation. Sockets -b BIND, --bind=BIND — Specifies the server socket. You can use formats like: $(HOST), $(HOST):$(PORT). Example: gunicorn --bind=127.0.0.1:8080 wsgi:app This command will run your application locally on port 8080. Worker Processes -w WORKERS, --workers=WORKERS — Sets the number of worker processes. Typically, this number should be between 2 to 4 per server core. Example: gunicorn --workers=2 wsgi:app Process Type -k WORKERCLASS, --worker-class=WORKERCLASS — Specifies the type of worker process to run. By default, Gunicorn uses the sync worker type, which is a simple synchronous worker that handles one request at a time. Other worker types may require additional dependencies. Asynchronous worker processes are available using Greenlets (via Eventlet or Gevent). Greenlets are a cooperative multitasking implementation for Python. The corresponding parameters are eventlet and gevent. We will use an asynchronous worker type compatible with aiohttp: gunicorn wsgi:app --bind localhost:8080 --worker-class aiohttp.GunicornWebWorker Access Logging You can enable access logging using the --access-logfile flag. Example: gunicorn wsgi:app --access-logfile access.log Error Logging To specify an error log file, use the following command: gunicorn wsgi:app --error-logfile error.log You can also set the verbosity level of the error log output using the --log-level flag. Available log levels in Gunicorn are: debug info warning error critical By default, the info level is set, which omits debug-level information. Installing and Configuring Nginx First, install Nginx with the command: sudo apt install nginx Let’s check if the Nginx service can connect to the socket created earlier: sudo -u www-data curl --unix-socket /run/gunicorn.sock http If successful, Gunicorn will automatically start, and you'll see the HTML code from the server in the terminal. Nginx configuration involves adding config files for virtual hosts. Each proxy configuration should be stored in the /etc/nginx/sites-available directory. To enable each proxy server, create a symbolic link to it in /etc/nginx/sites-enabled. When Nginx starts, it automatically loads all proxy servers in this directory. Create a new configuration file: sudo nano /etc/nginx/sites-available/myconfig.conf Then create a symbolic link with the command: sudo ln -s /etc/nginx/sites-available/myconfig.conf /etc/nginx/sites-enabled Nginx must be restarted after any changes to the configuration file to apply the new settings. First, check the syntax of the configuration file: nginx -t Then reload Nginx: nginx -s reload Conclusion Gunicorn is a robust and versatile WSGI server for deploying Python applications, offering flexibility with various worker types and integration options like Nginx for load balancing and reverse proxying. Its ease of installation and configuration, combined with detailed logging and scaling options, make it an excellent choice for production environments. By utilizing Gunicorn with frameworks like aiohttp and integrating it with Nginx, you can efficiently serve Python applications with improved performance and resource management.

Anaconda is a popular platform for data processing and machine learning. It supports Python and R programming languages and is used for large-scale data processing, predictive analytics, and scientific computing. You can install it on a local machine or scalable cloud servers from Hostman. The Python distribution comes with 250 open-source data packages, and you can install over 7,500 additional packages from Anaconda repositories. It also includes the Conda package manager and the graphical user interface, Anaconda Navigator. In this guide, you'll learn how to install the Anaconda distribution on the latest versions of Ubuntu. Downloading the Anaconda Distribution There are three options to download the Anaconda script: Download via a browser. Download using wget. Download using curl. To download the distribution via a browser, go to the official Anaconda website in the Distribution section. Enter your email, and you’ll receive a download link. Download the 64-bit (x86) Installer for Linux. To download the distribution using the wget utility, use the following command: wget https://repo.anaconda.com/archive/Anaconda3-2024.06-1-Linux-x86_64.sh --output anaconda.sh When downloading, it’s important to specify the correct version. This command requests version 2024.06, which is the latest at the time of writing. If you need another version, specify its number (e.g., 2022.05). You can find the version number and changes on the Release Notes page in the documentation. Pay attention to the syntax. In the end, we specify --output anaconda.sh, which is an optional argument that renames the file Anaconda3-2024.06-Linux-x86_64.sh to anaconda.sh for convenience, so you don’t have to type a long, complex filename during installation. To verify the integrity of the data, compare the cryptographic hash using the checksum (optional step). To see the SHA-256 checksum, run: sha256sum anaconda.sh The terminal will display a line of numbers and letters. Compare this checksum with the one provided on the Anaconda website for the corresponding version. If the hash doesn’t match, the file may not have been downloaded completely. Download it again and recheck the checksum. Installing Anaconda To work with Anaconda, you can use the graphical interface Navigator. For it to work correctly on Ubuntu, you need to install additional packages: sudo apt install libgl1-mesa-glx libegl1-mesa libxrandr2 libxss1 libxcursor1 libxcomposite1 libasound2 libxi6 libxtst6 If you don’t plan to use the graphical interface, these packages are not necessary. Now that you have the distribution file, it's time to deploy the package manager with all components. Regardless of how you downloaded the distribution, deployment is done with a single command: bash anaconda.sh The installation runs in dialog mode. First, you’ll be prompted to press Enter to continue. Then, press Enter to read the license agreement. If you agree to the terms, type 'yes' and press Enter again. The next step is choosing the installation location. You can accept the default directory by pressing Enter. If you want to specify a different folder, enter the full path. Installing Anaconda takes a few minutes. After completion, you'll be prompted to initialize Anaconda. Type 'yes' and press Enter. The installation wizard will automatically make the necessary changes to all required directories. Activating the Installation Activation refers to adding a new PATH variable. This allows the system to recognize commands given to Anaconda and its components. To activate, run the following command: source ~/.bashrc After activation, the environment variables will be updated. Visually, this change is reflected by the appearance of the word base before the username. To confirm the installation was successful, run: conda list The screen will display a list of all the installed Anaconda components. Setting Up a Virtual Environment By default, Anaconda uses the base environment for work. Working in a single environment can be inconvenient if you have multiple projects with different packages and versions. Anaconda Python virtual environments solve this issue. For each environment, you can specify the Python version, as well as the composition and versions of all packages. For example, if you have a project on a Hostman server that uses Python 3.9, you can create a dedicated virtual environment for it with the following command: conda create -n new_env python=3.9 The syntax is quite simple: create: the command to create a virtual environment; -n: the argument followed by the name of the new environment, in this case, new_env; python=3.9: specifies the version of Python to be used inside the virtual environment. After running the command, information about the packages to be installed will be displayed. If you agree with the list, type 'yes' and press Enter. To switch to the environment, you need to activate it: conda activate new_env To exit the environment, deactivate it: conda deactivate Inside the environment, you can install the packages needed for your project. There are two ways to do this: Activate the environment and install packages within it. Specify the environment's name when installing a package. For example: conda install --name new_env numpy This command can be run from the base environment, but the numpy library will be installed inside new_env. You can create as many virtual environments as needed for your Anaconda projects. To display a full list of environments, use the command: conda info --envs The current environment will be marked with an asterisk (*). Updating Anaconda Updating Anaconda is a simple task. Open the terminal and run the following command: conda update --all If updates are available for Anaconda in Python 3, they will be displayed in a list. To confirm the installation of updates, type 'y' and press Enter. You can also update package manager components individually. For example, if you know there’s a new version of the conda command-line utility, update it with the command: conda update conda To update the entire distribution without checking the list of updates, use this command: conda update anaconda Remember to check for updates periodically to ensure you're using the latest versions of tools. Complete Removal of Anaconda There are two ways to uninstall the Anaconda package manager. Let’s review both. Method 1: Manual Removal Remove the installation directory and all other files created during installation with the following command: rm -rf ~/anaconda3 ~/.condarc ~/.conda ~/.continuum Method 2: Using anaconda-clean This method is a bit more automated. You can use the anaconda-clean module to ensure all components are completely removed from the system. It helps remove configuration files. After that, you just need to delete the anaconda3 directory. First, install the module: install anaconda-clean To confirm the removal, enter 'y' in the prompt and press Enter. Run the module after installation with the following command: anaconda-clean The uninstaller will ask for confirmation before deleting each component. To avoid having to enter 'y' repeatedly, add the flag for automatic confirmation: anaconda-clean --yes After the cleanup, a backup folder will appear in the user's home directory. Inside, you’ll find a backup of the last saved state, in case you change your mind and want to restore Anaconda on Ubuntu. Once the cleaning module has finished, you can finally delete the package manager directory: rm -rf ~/anaconda3 To completely remove all traces of Anaconda from the system, also delete the PATH entry from the .bashrc file. This entry is added by default during installation. Open the .bashrc file in any text editor. In this example, we'll use nano: nano ~/.bashrc Look for the lines where conda is initialized. If Anaconda was installed recently, these lines will be near the end of the file. To speed up the search, use the Ctrl+W key combination. The lines will look something like this: # >>> conda initialize >>> # !! Contents within this block are managed by 'conda init' !! __conda_setup="$('/home/linux/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)" if [ $? -eq 0 ]; then eval "$__conda_setup" else if [ -f "/home/linux/anaconda3/etc/profile.d/conda.sh" ]; then . "/home/linux/anaconda3/etc/profile.d/conda.sh" else export PATH="/home/linux/anaconda3/bin:$PATH" fi fi unset __conda_setup # <<< conda initialize <<< Delete or comment out these lines in the file. To save changes in nano, press Ctrl + X and confirm the overwrite. The removal of Anaconda is now complete. Conclusion In this tutorial, we covered the key steps from installing Anaconda to fully removing it. Now you can properly install the package manager in your system, keep it up to date, and, if needed, completely remove the software components from Ubuntu.

When we want to check if a user is registered on a website, we ask for their username and password. If the username exists in the database and the entered password matches the one in the database, we authorize the user. Otherwise, we continue to ask the user for their username and password. In the examples below, we will compare values of the same type with each other using the Python programming language. Here’s how to compare two strings in Python: print(10 == 5)   # Falseprint('abc' == 'abc')   # True Example with password verification: correct_password = 'qwerty' asked_password = input('Enter password: ') if (correct_password == asked_password): print('You are authorized') else: print('Incorrect password') Enter password: 123 Incorrect password Enter password: qwerty You are authorized Logical comparisons or their results are used in if-else constructions and while loops. Logical Expressions A logical expression, in the simplest sense, is a mathematical comparison. In Python, the question "What is greater: 3 or 5?" would be written as 3 > 5 and would sound like: “Three is greater than five. True? - No.” print(3 > 5)    # False Or another option: 4 != 0 (4 is not equal to 0. True?) print(4 != 0)   # True Here’s how comparison operators are expressed in Python: a == b - A equals B a > b - A is greater than B a >= b - A is greater than or equal to B a < b - A is less than B a <= b - A is less than or equal to B a != b - A is not equal to B a = 5 b = 10 print(a == b) # False print(a > b) # False print(a >= b) # False print(a < b) # True print(a <= b) # True print(a != b) # True The result of such comparisons can be stored in a variable, just like any other value: a = 5 b = 10 expr = a > b print(expr) # False You can compare multiple values in sequence: a = 4 expr = 0 < a < 10 print(expr) # True a = 15 expr = 0 < a < 10 print(expr) # False In the first case, we obtained True, while in the second case, Python returned False. String Comparison In addition to numbers, Python allows to compare strings, lists, and other data types. For example, here’s how to compare two strings in Python: s1 = 'python' s2 = 'python' s3 = 'Python' # Changing one letter to uppercase print(s1 == s2) # True print(s1 == s3) # False In the second case, the result is false because the comparison is case-sensitive. Strings can also be compared in terms of greater than or less than: print('abc' > 'abc') # False print('abc' > 'aaa') # True print('abc' > 'x') # False In the first case, the strings are equal. In the second case, a character-by-character comparison occurs. The first two characters are equal, so the next characters are compared. 'b' > 'a' is true because 'b' comes after 'a' in the alphabet. Thus, the entire expression is true. To make it easier to understand, you can think of the letters as their positions in the alphabet: 123 > 111. The character-by-character comparison does not depend on the length of the strings, so in the third case, the expression is false: 'a' > 'x'. print('a' > 'x')   # False This type of comparison is called lexicographic comparison. Comparison of Other Types of Values Comparing lists is similar to comparing strings. For example, when using the not equal condition in Python, each element of the list is compared in sequence with the other: print([1, 2, 3] > [1, 2, 3]) # False print([1, 2, 3] > [1, 1, 1]) # True print([1, 2, 3] > [25]) # False Values of different types can also be compared with each other: expr1 = '1' == 1 expr2 = '' == 0 print(expr1) # False print(expr2) # False The result is false because the data types are not the same (a string and an integer). Comparing greater than or less than between different types will raise an error: print('a' > 1) # TypeError: '>' not supported between instances of 'str' and 'int' print((1, 1, 1) < [1, 2, 3]) # TypeError: '<' not supported between instances of 'tuple' and 'list' Converting Values to Bool Type Values can be converted to False or True directly from the values themselves, without a comparison operation. For example, the string 'a' will evaluate to True, while 0 will evaluate to False. To do this, you can call the bool() function and pass it the value you want to convert: var1 = bool('a') var2 = bool(0) print(var1) # True print(var2) # False An empty string or list will evaluate to False: var1 = bool('') var2 = bool([]) print(var1) # False print(var2) # False The logic is simple: if the size of a list or string is zero, then the bool variable will be False. Similarly, 0 is also considered False. All other values, other than 0 or with a length greater than 0, will be True. Typically, boolean operations in Python are used when checking for the presence of information in a variable, for example, to determine whether the user has filled in the required fields in a registration form or left them empty. Here’s a simplified version of such a check: user_name = input('Enter your name: ') if user_name: print(f'Welcome, {user_name}!') else: print('This field is required') Enter your name: This field is required Enter your name: Mary Welcome, Mary! Logical Operators If we want to check multiple logical expressions or values for truth at the same time, we need to use logical operators in Python 3. For example, to check whether a user has entered their name and if their age is greater than 12: name = 'Mary' age = 10 expr = name and age > 12 print(expr) # False In this case, we used the logical operator and. It returns a true value only when both sides of it are true values. There are also or and not operators: or - Returns a true value when at least one side has a true value. not - Changes the value to the opposite. All of these operators work with the boolean equivalents of values, meaning they first convert them to the bool type before performing calculations. print(True and False) # False print(True or False) # True print(not True) # False print(not False) # True Logical operations can be combined in a single expression: expr = not True and False print(expr) # False Calculations happen in order. To change the order, parentheses can be used, just like in mathematics: expr = not (True and False) print(expr) # True The value changed to true because the expression inside the parentheses is calculated first (resulting in False), and then it is inverted. When using the and and or operators in Python, they do not necessarily return only True or False; they return the actual value where the calculations stopped. Let’s look at an example: name1 = 'Mary' age = 0 name2 = 'Anna' print(name1 and age and name2) # 0 print(name1 or age or name2) # Mary In the first case, the output is 0 because the calculations stopped at the variable age. Since all operators are and, if any value is false, the entire expression is false, meaning there's no point in calculating further. In the second case, the situation is reversed. All operators are or, so the calculations stop at the first true value, which is the value of the variable name1. Other Types of Logical Operators Other logical operations are used less frequently and in specific situations. For example, there are bitwise logical operations that are applied in data encryption. One of these is XOR (exclusive OR), which is represented by the symbol ^ in Python. Here’s an example of encrypting a number. Any binary data can replace the numbers. phrase = 2022 key = 101 # Encrypting using the key encrypt = phrase ^ key print(encrypt) # Decrypting the message using the key decrypt = encrypt ^ key print(decrypt) Output: 19232022 List of All Bitwise Operators in Python Operation Description a & b Bitwise AND for a and b a | b Bitwise OR for a and b a ^ b Bitwise XOR for a and b ~a Bitwise NOT for a a << b Bitwise left shift for a by b a >> b Bitwise right shift for a by b However, not all logical operations are present in Python. For example, there is no logical implication operation. Conclusion We have explored logical expressions and operators in Python 3. For more information on working with Python, check out the tutorials on Hostman.

Manipulating file system paths in Python 3 is handled by several libraries, one of which is pathlib. In this article, we'll show you how to use the pathlib module and solve practical tasks with it. File System Basics Before diving into the practical use of the pathlib library, we need to refresh some foundational concepts about the file system and its terminology. Let's consider a file example.exe located in C:\Program Files (Windows file system). This file has four main characteristics from the perspective of the file system: Path: This is the identifier of the file, determining its location in the file system based on a sequence of directory names. Paths can be divided into two types: Absolute path: A full path that starts from the root directory, e.g., C:\Program Files\example.exe. Relative path: A path relative to another directory, e.g., Program Files\example.exe. Directory (C:\Program Files): This is an object in the file system used to organize files hierarchically. It's often referred to as a directory or folder. The term "folder" perfectly describes this object’s practical use — for convenient storage and quick retrieval when needed. Extension (.exe): This indicates the file type. Extensions help users or programs determine the type of data stored in the file (video, text, music, etc.). Path Instances Let's import the pathlib module to manipulate file system paths: from pathlib import * The classes in this module can be divided into two types: Pure (or "abstract") and Concrete. The Pure classes are used for abstract computational work with paths, where no actual interaction with the OS file system occurs. The Concrete classes, on the other hand, allow for direct interaction with the file system (e.g., creating and deleting directories, reading files, etc.). If you're unsure which class to use, the Path class is likely the right choice. It automatically adapts to the OS and allows interaction with the file system without restrictions. In this article, we'll cover all classes but focus specifically on Path. Let's start small by creating a variable of type Path: >>> PathExample = Path('Hostman', 'Cloud', 'Pathlib')>>> PathExampleWindowsPath('Hostman/Cloud/Pathlib') As we can see, the module automatically adapts to the operating system — in this case, Windows 10. The constructor Path(args) creates a new Path instance, accepting directories, files, or other paths as arguments. The PathExample is a relative path. We need to add the root directory to make it an absolute path. Using the Path.home() and Path.cwd() methods, we can get the current user's home directory and the current working directory: >>> Path.home()WindowsPath('C:/Users/Blog')>>> Path.cwd()WindowsPath('C:/Users/Blog/AppData/Local/Programs/Python/Python310') Let's make PathExample an absolute path and explore other aspects of working with pathlib: >>> PathExample = Path.home() / PathExample>>> PathExampleWindowsPath('C:/Users/Blog/Hostman/Cloud/Pathlib') Using the / operator, we can concatenate paths to create new ones. Path Attributes The Python pathlib module provides various methods and properties to retrieve information about file paths. For illustration, let's create a new variable AttributeExample and append a file to the path: >>> AttributeExample = PathExample / 'file.txt'>>> AttributeExampleWindowsPath('C:/Users/Blog/Hostman/Cloud/Pathlib/file.txt') Disk To retrieve the drive letter or name, use the .drive property: >>> AttributeExample.drive'C:' Parent Directories You can get parent directories using two properties: .parent and .parents[n]. The .parent property returns the immediate parent directory: >>> AttributeExample.parentWindowsPath('C:/Users/Blog/Hostman/Cloud/Pathlib') To get higher-level parent directories, you can either call .parent multiple times: >>> AttributeExample.parent.parentWindowsPath('C:/Users/Blog/Hostman/Cloud') Or use .parents[n] to retrieve the nth ancestor: >>> AttributeExample.parents[3]WindowsPath('C:/Users/Blog') Name To get the file name, use the .name property: >>> AttributeExample.name'file.txt' Extension To get the file extension, use the .suffix property (or .suffixes for multiple extensions, such as .tar.gz): >>> AttributeExample.suffix'.txt'>>> Path('file.tar.gz').suffixes['.tar', '.gz'] Absolute or Relative Path To check if the path is absolute, use the .is_absolute() method: >>> AttributeExample.is_absolute()True Path Components To split the path into its individual components, use the .parts property: >>> AttributeExample.parts('C:\\', 'Users', 'Blog', 'Hostman', 'Cloud', 'Pathlib', 'file.txt') Paths Comparison You can compare paths using both comparison operators and various methods. Comparison Operators You can check if two paths are the same: >>> Path('hostman') == Path('HOSTMAN')True Note: On UNIX-based systems, case sensitivity matters, so the result would be False: >>> PurePosixPath('hostman') == PurePosixPath('HOSTMAN')False This is because Windows file systems are case-insensitive, unlike UNIX-based systems. Comparison Methods You can check if one path is part of another using .is_relative_to(): >>> CompareExample = AttributeExample >>> CompareExample.is_relative_to('C:') True >>> CompareExample.is_relative_to('D:/') False You can also use patterns for matching with the .match() method: >>> CompareExample.match('*.txt')True Creating and Deleting Folders and Files To create directories using the pathlib module, you can use the .mkdir(parents=True/False, exist_ok=True/False) method. This method takes two boolean parameters in addition to the path where the folder is to be created: parents: If True, it creates any necessary parent directories. If False, it raises an error if they don't exist. exist_ok: Determines whether an error should be raised if the directory already exists. Let's create a folder CreateExample, but first, check if such a directory already exists using the .is_dir() method: >>> CreateExample = CompareExample>>> CreateExample.is_dir()False Now, let's create the folder: >>> CreateExample.mkdir(parents=True, exist_ok=True)>>> CreateExample.is_dir()True If you check the result in Windows Explorer, you will see that a directory (not a file) was created. To create an empty file, use the .touch() method. But first, let's remove the file.txt directory using the .rmdir() method: >>> CreateExample.rmdir()>>> CreateExample.touch()>>> CreateExample.is_file()True To delete files, use the .unlink() method. Searching for Files Let's create a more complex directory structure based on the existing folder: >>> SearchingExample = CreateExample >>> Hosting = Path(SearchingExample.parents[2], 'hosting/host.txt') >>> Hosting.parent.mkdir(parents=True, exist_ok=True) >>> Hosting.touch() >>> Docker = Path(SearchingExample.parents[1], 'Docker/desk.txt') >>> Docker.parent.mkdir(parents=True, exist_ok=True) >>> Docker.touch() We now have the following structure (starting from C:\Users\Blog\Hostman): Cloud |— Pathlib | `— file.txt `— Docker `— desk.txt Hosting `— host.txt To search for files using pathlib, you can use a for loop along with the .glob() method: >>> for file_cloud in SearchingExample.parents[2].glob('*.txt'):    print(file_cloud) This code doesn't find anything because it doesn't search in subfolders. To search recursively in subdirectories, modify it as follows: >>> for file_cloud in SearchingExample.parents[2].glob('**/*.txt'): print(file_cloud) ... C:\Users\Blog\Hostman\Cloud\Docker\desk.txt C:\Users\Blog\Hostman\Cloud\Pathlib\file.txt C:\Users\Blog\Hostman\hosting\host.txt Reading and Writing to Files You can perform both reading and writing operations in text or binary mode. We'll focus on text mode. The pathlib module provides four methods: Reading: .read_text() and .read_bytes() Writing: .write_text() and .write_bytes() Let's write some important information to a file, for example, "Hostman offers really cool cloud servers!". This is definitely something worth saving: >>> WRExample = SearchingExample >>> WRExample.is_file() True >>> WRExample.write_text('Hostman offers really cool cloud servers!') 55 # Length of the message >>> WRExample.read_text() 'Hostman offers really cool cloud servers!' Conclusion In conclusion, the pathlib module is an essential tool for efficient file system management in Python. It allows developers to easily create, manipulate, and query file paths, regardless of the operating system. pathlib simplifies tasks such as file creation, deletion, and searching by supporting both absolute and relative paths and providing detailed metadata access. Its flexibility and ease of use make it a preferred choice for modern Python development, allowing for cleaner, more maintainable code. Embracing pathlib can significantly enhance productivity in any file-related project.

In this tutorial, we will write a simple web application in Python with a database for user authentication. We will use Windows 10 and work in PyCharm using pipenv. The website will be built with HTML and CSS. The installation of Flask, PyCharm, and pipenv is described in detail in this article. Throughout this article, we will use testing and educational examples that are not suitable for production implementation. For instance, to verify passwords in the database, you need to store password hashes and compare hashes, not plaintext passwords. Additionally, when working with databases, you should use an ORM rather than writing "raw" SQL (for more on ORM, see here). To get started, we will create a project directory called Hostman. Within this directory, we will place the templates and static directories, and within the static directory, we will create a css directory. The project structure will look like this: Hostman |— templates |— static | — css Database for Logins and Passwords Once you have installed Flask and the other tools, you can proceed to work. We will use the SQLite database management system (DBMS) to store user data. It is well-suited for small projects, and its main advantage is its standalone nature: it does not require a server to operate. Additionally, Python includes a built-in module, sqlite3, for working with SQLite. However, if you decide to work with a server-based DBMS, consider using cloud servers like Hostman. In the project directory, we create a file named db.py. In this file, we will import the sqlite3 module and create a database and a table for logins and passwords: import sqlite3 db_lp = sqlite3.connect('login_password.db') cursor_db = db_lp.cursor() sql_create = '''CREATE TABLE passwords( login TEXT PRIMARY KEY, password TEXT NOT NULL);''' cursor_db.execute(sql_create) db_lp.commit() cursor_db.close() db_lp.close() Let’s break down what this code does: We connect to the database using the connect() method. This method will look for the file login_password.db in the project directory. If it does not find it, it will create one automatically. We create the cursor_db object for interacting with the database. sql_create is the SQL query for creating the table that holds the logins and passwords. We execute sql_create using the execute() method. We save changes to the database with the commit() method. Finally, we close the cursor_db and db_lp objects to avoid any database issues. To create the database, run the command: python db.py Authentication Now let’s work on the authentication for our Flask application. Main Form First, we will create a form that will be used for authentication into an abstract service. In the templates directory, we create a file named authorization.html with the following content: <form method="POST"> <div class="container"> <label for="Login"><b>Login</b></label> <input type="text" placeholder="" name="Login" required> <label for="Password"><b>Password</b></label> <input type="password" placeholder="" name="Password" required> <button type="submit">Login</button> <div class="container"> <span class="reg"><a href="/registration">Registration</a></span> </div> </div> </form> <link rel="stylesheet" href="{{ url_for('static', filename='css/auth.css') }}"> Here, there are three important points: <form method="POST"> — we indicate that we will be using POST requests. <label for="Login"> and <label for="Password"> — we mark the Login and Password fields that we will process later using the get() method from the request module. <link rel="stylesheet" href="{{ url_for('static', filename='css/auth.css') }}"> — we inform HTML where the CSS file is stored. In the /static/css directory, we create a file named auth.css: form { font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ border: 1px solid black; /* Color, size, and type of border */ -webkit-border-radius: 20px; /* Round corners */ color: #777991; /* Label color */ width: 50%; /* Form width */ margin-right: auto; /* Form positioning */ margin-left: auto; /* Form positioning */ text-align: center; /* Center text */ } input[type=text], input[type=password] { text-align: center; /* Center text */ -webkit-border-radius: 4px; /* Round corners */ width: auto; /* Width */ padding: 15px 20px; /* Internal padding size */ margin: 10px 0; /* External margin size */ margin-right: auto; /* External right margin size */ margin-left: auto; /* External left margin size */ display: block; /* Display type */ border: 1px solid #050c26; /* Color, size, and type of border */ box-sizing: border-box; /* Size of object relative to parent */ font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ color: #777991; /* Text color in input */ } button { font: 16px Stem-medium, arial, sans-serif; /* Choose button font */ background-color: #454cee; /* Choose background color */ -webkit-border-radius: 8px; /* Round edges */ color: white; /* Choose text color */ padding: 16px 20px; /* Internal padding size */ margin: 8px 0; /* External margin size */ border: none; /* No border */ cursor: pointer; /* Change cursor on hover */ width: auto; /* Width */ } button:hover { opacity: 0.9; /* Change button brightness on hover */ } .container { padding: 20px; /* Internal padding size of the container */ } As a result, our form will look like this: Message for Successful Authentication If the user enters the correct username-password pair, we will display a corresponding message. In the templates directory, we create a file named successfulauth.html with the following content: <form method="POST"> <div class="container"> <label><b>You have successfully logged in</b></label> </div> </form> <link rel="stylesheet" href="{{ url_for('static', filename='css/successfulauth.css') }}"> In the /static/css directory, we create a file named successfulauth.css: form { font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ border: 1px solid black; /* Color, size, and type of border */ -webkit-border-radius: 20px; /* Round corners */ color: #777991; /* Label color */ width: 40%; /* Form width */ margin-right: auto; /* Form positioning */ margin-left: auto; /* Form positioning */ text-align: center; /* Center text */ } .container { padding: 30px; /* Internal padding size of the container */ } Message for Unsuccessful Authentication In the templates directory, we create a file named auth_bad.html with the following content: <form method="POST"> <div class="container"> <label><b>Incorrect username or password</b></label> </div> </form> <link rel="stylesheet" href="{{ url_for('static', filename='css/auth_bad.css') }}"> In the /static/css directory, we create a file named auth_bad.css: form { font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ border: 1px solid black; /* Color, size, and type of border */ -webkit-border-radius: 20px; /* Round corners */ color: #777991; /* Label color */ width: 40%; /* Form width */ margin-right: auto; /* Form positioning */ margin-left: auto; /* Form positioning */ text-align: center; /* Center text */ } .container { padding: 30px; /* Internal padding size of the container */ } Now, we will create a registration form. Registration With the registration form, users will be able to create their own accounts. In the templates directory, create a file named registration.html with the following content: <form method="POST"> <div class="container"> <label for="Login"><b>Username</b></label> <input type="text" placeholder="" name="Login" required> <label for="Password"><b>Password</b></label> <input type="password" placeholder="" name="Password" required> <button type="submit">Register</button> </div> </form> <link rel="stylesheet" href="{{ url_for('static', filename='css/regis.css') }}"> In the /static/css directory, create a file named regis.css: form { font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ border: 1px solid black; /* Color, size, and type of border */ -webkit-border-radius: 20px; /* Round corners */ color: #777991; /* Label color */ width: 50%; /* Form width */ margin-right: auto; /* Form positioning */ margin-left: auto; /* Form positioning */ text-align: center; /* Center text */ } input[type=text], input[type=password] { text-align: center; /* Center text */ -webkit-border-radius: 4px; /* Round corners */ width: auto; /* Width */ padding: 15px 20px; /* Internal padding size */ margin: 10px 0; /* External padding size */ margin-right: auto; /* External padding size on the right */ margin-left: auto; /* External padding size on the left */ display: block; /* Display type */ border: 1px solid #050c26; /* Color, size, and type of border */ box-sizing: border-box; /* Size of the object relative to the parent */ font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ color: #777991; /* Text color in input */ } button { font: 16px Stem-medium, arial, sans-serif; /* Choose button font */ background-color: #454cee; /* Choose background color */ -webkit-border-radius: 8px; /* Round corners */ color: white; /* Choose text color */ padding: 16px 20px; /* Internal padding size */ margin: 8px 0; /* External padding size */ border: none; /* No border */ cursor: pointer; /* Change cursor when hovering over the button */ width: auto; /* Width */ } button:hover { opacity: 0.9; /* Change button brightness when hovering */ } .container { padding: 20px; /* Internal padding size of the container */ } The registration form will look like this: Upon successful registration, the user will see a message like this: To create this message, in the templates directory, create a file named successfulregis.html with the following content: <form method="POST"> <div class="container"> <label><b>You have successfully registered</b></label> <div class="container"> <span class="reg"> <a href="/authorization">Return to login</a></span> </div> </div> </form> <link rel="stylesheet" href="{{ url_for('static', filename='css/successfulregis.css') }}"> In the /static/css directory, create a file named successfulregis.css: form { font: 14px Stem-Regular, arial, sans-serif; /* Choose font */ border: 1px solid black; /* Color, size, and type of border */ -webkit-border-radius: 20px; /* Round corners */ color: #777991; /* Label color */ width: 25%; /* Form width */ margin-right: auto; /* Form positioning */ margin-left: auto; /* Form positioning */ text-align: center; /* Center text */ } .container { padding: 20px; /* Internal padding size of the container */ } Authorization Decorator After creating all the forms and the database, we can start developing the Flask web application. To send an HTML document in response to a client request in Flask, the render_template() method must be used. This function from the Flask module is used to display templates from the templates folder. The project directory now has the following structure: Hostman |— db.py |— login_password.db |— templates | — authorization.html | — auth_bad.html | — successfulauth.html | — successfulregis.html | — registration.html |— static | — css | — auth_bad.css | — auth.css | — successfulauth.css | — regis.css | — successfulregis.css In the /Hostman project directory, create a file named main.py, where we will import the necessary modules from Flask and add the code for user authorization. For more details on authentication, we recommend reading here. from flask import Flask, request, render_template import sqlite3 @app.route('/authorization', methods=['GET', 'POST']) def form_authorization(): if request.method == 'POST': Login = request.form.get('Login') Password = request.form.get('Password') db_lp = sqlite3.connect('login_password.db') cursor_db = db_lp.cursor() cursor_db.execute(('''SELECT password FROM passwords WHERE login = '{}'; ''').format(Login)) pas = cursor_db.fetchall() cursor_db.close() try: if pas[0][0] != Password: return render_template('auth_bad.html') except: return render_template('auth_bad.html') db_lp.close() return render_template('successfulauth.html') return render_template('authorization.html') Here is the logic of how it works: The user navigates to /authorization — this is a GET request, and the decorator returns authorization.html. When the user enters their username and password and clicks the "Login" button, the server receives a POST request, which the decorator will handle. The decorator will retrieve the username and password entered by the user. Next, we connect to the database and execute an SQL query. Using cursor_db.execute() and cursor_db.fetchall(), we get the row with the password (which may be empty) corresponding to the entered username. We "extract" the password from the row, and: If the row is empty, it will raise an error (array index out of bounds), which we handle with a try-except block, notifying the user of invalid input. The decorator completes its work. If the password in the database does not match the received password, it simply returns a message about incorrect data and ends the operation. If the password is correct, we display a message about successful authorization and conclude the work of the Flask decorator. Registration Decorator Users can access the /registration page from the authorization form. Here is the code for the decorator, which we will add to the end of main.py: @app.route('/registration', methods=['GET', 'POST']) def form_registration(): if request.method == 'POST': Login = request.form.get('Login') Password = request.form.get('Password') db_lp = sqlite3.connect('login_password.db') cursor_db = db_lp.cursor() sql_insert = '''INSERT INTO passwords VALUES('{}','{}');'''.format(Login, Password) cursor_db.execute(sql_insert) db_lp.commit() cursor_db.close() db_lp.close() return render_template('successfulregis.html') return render_template('registration.html') Initially, the GET request for /registration is processed, returning registration.html. When the user enters their data and clicks the "Register" button, the server receives a POST request, which extracts the Login and Password. Next, we connect to the database. The sql_insert variable holds the SQL query for adding a new row with the user's data. We execute sql_insert and save the changes. Finally, we close the cursor_db and db_lp objects, returning a message indicating successful registration. Full Program Code from flask import Flask, request, render_template import sqlite3 app = Flask(__name__) @app.route('/authorization', methods=['GET', 'POST']) def form_authorization(): if request.method == 'POST': Login = request.form.get('Login') Password = request.form.get('Password') db_lp = sqlite3.connect('login_password.db') cursor_db = db_lp.cursor() cursor_db.execute(('''SELECT password FROM passwords WHERE login = '{}'; ''').format(Login)) pas = cursor_db.fetchall() cursor_db.close() try: if pas[0][0] != Password: return render_template('auth_bad.html') except: return render_template('auth_bad.html') db_lp.close() return render_template('successfulauth.html') return render_template('authorization.html') @app.route('/registration', methods=['GET', 'POST']) def form_registration(): if request.method == 'POST': Login = request.form.get('Login') Password = request.form.get('Password') db_lp = sqlite3.connect('login_password.db') cursor_db = db_lp.cursor() sql_insert = '''INSERT INTO passwords VALUES('{}','{}');'''.format(Login, Password) This completes the implementation of the user registration decorator and the overall application. Conclusion In this tutorial, we covered the essential steps to create a simple web application for user authentication and registration using Python framework Flask. We began by setting up the project structure and configuring SQLite for user data storage. We then developed HTML forms for authorization and registration, styling them with CSS. Through decorators, we implemented the logic to handle user input and interact with the database, ensuring secure processing of credentials. Finally, users receive feedback on successful or failed actions. This foundational knowledge equips you to build more complex Flask applications while enhancing user experience and security.

The entire web operates using the HTTP protocol. To open this page, you sent an HTTP request via your browser to the server hosting Hostman tutorials. The server analyzed your request and responded by returning this post so you could learn about the requests library in Python. The requests library allows you to send HTTP requests. With it, you can write requests in Python to solve a wide range of tasks. What You Need to Know to Work with requests Sending HTTP requests and using the responses isn’t rocket science. However, some basic knowledge is still required. At the very least, you need to know the primary methods you'll be sending to servers: GET — retrieve a resource. POST — create a resource. PUT — update a resource. DELETE — delete a resource. These are not all the methods. There are also HEAD, PATCH, and others. But for our practice, we’ll only need GET, the most common method. Users constantly request servers to give them something: pages, posts, images. Processing HTTP requests in Python with other methods works similarly. In response to requests, you’ll receive status codes. These range from 1xx to 5xx. Every internet user encounters them, though not everyone knows what they are. Error 404 is status code 404. It indicates a client-side error: the user is trying to access a page that doesn’t exist. The first digit of a status code indicates the type of response: 1xx — informational codes. 2xx — success. 3xx — redirection. 4xx — client-side error. 5xx — server-side error. These basic concepts are enough to make a few interesting requests and correctly interpret the responses. Now, let’s see how all this behind-the-scenes web magic is handled with the requests library. Installing the Library To work with the library, you need Python installed on your computer. You’ll also need the package manager pip to install requests. To install Python requests using pip: python -m pip install requests The library’s code is hosted on GitHub. You can clone it to your computer: git clone git://github.com/psf/requests.git For more details, check the library’s documentation. Usage Examples Now, for the most exciting part — practice.  Let's start with a simple request. We'll give the Python requests library a task to connect to a page containing information about Hostman cloud servers. Create a file called script.py. Inside it, write the following script: import requestsresult = requests.get('https://hostman.con/cloud-servers')print(result) The first line imports the requests library. Then, you define a variable result and use the GET method to get a response from the server, specifying the URI you're interested in. The last line prints the response in the terminal. To run this short program, open any terminal, navigate to the folder where the script.py file is located, and execute it with the command:  python script.py The response should return status code 200, meaning the requested page is available. You can continue working with it. As an example, let's try using a non-existent URI. You should get a 404 error code. Change the page address in your script. You can make up your own invalid link or just alter any working one: import requestsresult = requests.get('https://hostman.com/badlink')print(result) The response will return a 404 status code. From Python’s perspective, every response is an object. This object has its own methods and functions that help retrieve additional information or normalize data. Let's revert to the correct page address and try to get its content. To do this, simply add the text method to the print command. Here’s what the script should look like after editing: import requestsresult = requests.get('https://hostman.com/cloud-servers')print(result.text) Running the script will display the entire HTML code of the requested page in the terminal. You can see the markup, linked style sheets, scripts, and content. This is public information, which can also be viewed in a browser using the "View Page Source" option. Instead of the text method, you can use the url method, which will display the URL you requested. You can also use the status_code method to print the request's status code. This was just the beginning of working with requests in Python. Now, let’s look at some more interesting examples. Basic Authentication Authentication helps an application understand who you are and check if there’s any information about you in the database. Typically, you provide your credentials to the server by passing them through the Authorization header. One example of an API that requires user authentication is the GitHub Authenticated User API. This service provides information about the profile of an authenticated user. To make a request to the Authenticated User API, you must pass your GitHub username and password as a tuple, using the get() method: from getpass import getpassrequests.get('https://api.github.com/user', auth=('username', getpass())) If you passed valid credentials in the auth tuple, you’ll receive a success message in response: <Response [200]> If you try to make the same request without valid credentials, you’ll get a 401 Unauthorized status code: >>> requests.get('https://api.github.com/user')<Response [401]> When you pass the username and password in a tuple, the credentials are applied using the basic access authentication scheme. You can make the same request using HTTPBasicAuth: from requests.auth import HTTPBasicAuth from getpass import getpass requests.get( 'https://api.github.com/user', auth=HTTPBasicAuth('username', getpass()) ) <Response [200]> The requests library also provides other authentication methods, such as HTTPDigestAuth and HTTPProxyAuth. You can also implement your own method. However, keep in mind that poorly designed authentication mechanisms can introduce security vulnerabilities. Unless there's a strong need to create your own solution, using a proven authentication scheme like Basic or OAuth is better. SSL Verification Working with requests in Python also allows you to solve another important task — checking if a website has an SSL certificate. When handling sensitive data, security is crucial. You can protect it during transmission over HTTP by setting up an encrypted connection using an SSL certificate. To ensure the safety of a site, you need to verify the SSL certificate of the target server. The good news is that the requests library does this by default. However, in some cases, you might want to change this behavior. If you want to disable SSL certificate verification, set the verify parameter to False: requests.get('https://api.github.com', verify=False) This will return a warning: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised.<Response [200]> requests even warns you when making a request without SSL verification to help keep your data secure. Fetching the Weather Forecast Finally, let’s look at a small project example. We’ll create a utility that fetches the weather forecast and displays the result in the terminal. The data source will be OpenWeather, where you can create a free API key for access. Create a file called weather.py and write the following: import requests result = requests.get('https://api.openweathermap.org/data/2.5/weather?q=Warsaw,pl&appid=someidappkey0ff7889240be2&units=metric') weather = result.text print(weather) First, you import the requests library. Then, you make an API request to the weather service. After the q parameter, you specify the city and country; appid is the key that you need to create on OpenWeather. The units=metric parameter indicates that the metric system should be used, so the temperature will be displayed in Celsius. By default, the response comes in JSON format, but you can choose XML or HTML by adding the mode parameter to the request with the corresponding value. Here’s an example of a response in JSON format: { "coord": {"lon": 21.0118, "lat": 52.2298}, "weather": [ { "id": 800, "main": "Clear", "description": "clear sky", "icon": "01d" } ], "base": "stations", "main": { "temp": 15.35, "feels_like": 14.28, "temp_min": 14.78, "temp_max": 16.12, "pressure": 1021, "humidity": 63 }, "visibility": 10000, "wind": { "speed": 3.09, "deg": 90 }, "clouds": { "all": 0 }, "dt": 1697721600, "sys": { "type": 2, "id": 2038500, "country": "PL", "sunrise": 1697689772, "sunset": 1697726778 }, "timezone": 7200, "id": 756135, "name": "Warsaw", "cod": 200 } Even without additional data processing, it’s easy to see that at the time of checking, the temperature in Warsaw was slightly above 7 degrees Celsius, with light wind. For example, you can use this information to create a web interface for a more user-friendly display. Conclusion You’ve learned the basics of the requests library in Python. Now you can make requests using HTTP methods, perform user authentication, check data, and retrieve information from various sources.

This tutorial will help you create a simple game template in Python where you move a character to avoid obstacles. You'll use Pygame, a set of Python modules designed for video game development. Pygame builds on top of the powerful SDL library. The latest version of Pygame uses Pygame SDL2. Installing the Library Pygame includes several modules with functions for drawing graphics, playing sounds, handling mouse input, and more—all essential for building your first game with Python 3. You need to install the library in your development environment to get started. Installation is done using pip: python -m pip install -U pygame --user To verify the library is working, you can run a built-in example game: python -m pygame.examples.aliens This will launch a game where you shoot down alien UFOs. There are other installation methods for different operating systems, including compiling the library from source. Check the Pygame documentation for details. Game Loop The game loop is where all the game events happen, updates are made, and the game is displayed on the screen. Once the initial setup and variable initialization are complete, the game loop begins, and the program continues to run repeatedly until a QUIT event occurs. Here’s an example of a game loop that we'll use in our Pygame program: while True: # Code pygame.display.update() Changes in the game only take effect after pygame.display.update() is called. Since games involve continuous updates, this function is placed inside the game loop and is executed repeatedly. Exiting the Game Loop Every game loop must have a way to exit or trigger the end of the game—for example, when the user clicks a quit button. while True: pygame.display.update() for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() Here, pygame.quit() closes the Pygame window, and sys.exit() ends the Python script. Using only sys.exit() can sometimes cause the IDE to freeze, so it's important to call pygame.quit() first. Game Events An event occurs when the user performs a certain action, like clicking the mouse or pressing a key. Pygame tracks every event that happens. You can find out which events have occurred by calling the function pygame.event.get(). It returns a list of pygame.event.Event objects, which we'll call event objects for simplicity. One of the many attributes (or properties) that event objects have is type. The type attribute tells you what event the object represents. In the example above, we used event.type == QUIT. This checks if the game should be closed. As long as the user does not trigger a QUIT event, the game will keep running in an infinite loop. Game Window For the game, we need to create a fixed-size window where all the events will occur. The window's width and height in pixels are passed to the pygame.set_mode() function as a tuple: DISPLAYSURF = pygame.display.set_mode((300, 300)) A pixel is the smallest possible area on the screen. There is no such thing as half a pixel or a quarter of a pixel, so both the width and height must be integers. Frame Rate (FPS) If you don’t set a frame rate limit, the computer will run the game loop as many times as it can in a second. To control the frame rate, you can use the tick(fps) method, where fps is an integer representing the frame rate. The tick(fps) method belongs to the pygame.time.Clock class and must be used with an object of that class. FPS = pygame.time.Clock()FPS.tick(60) This will cap the game’s frame rate at 60 frames per second (FPS). The ideal FPS may vary depending on the game, but generally, you should aim for a value between 30 and 60. Keep in mind that if your game is complex or resource-heavy, the computer may struggle to run it at higher frame rates. Colors Pygame uses the RGB color system (Red, Green, Blue), where each color component can have a value between 0 and 255, providing 256 possible values for each color. These three colors combine to create all the colors you see on screens. To use colors in Pygame, you create Color objects using RGB values in the form of a tuple: BLACK = pygame.Color(0, 0, 0) WHITE = pygame.Color(255, 255, 255) GREY = pygame.Color(128, 128, 128) RED = pygame.Color(255, 0, 0) One thing to note about working with colors is that if you draw a shape and assign it a color (e.g., green), only the outline will be green by default. To fill the shape with color, you need to use the fill method, which makes the entire shape that color. Creating the Game Now it’s time for the fun part—developing your first Python game. Below is the complete code for the project that you’ll have by the end of this tutorial. # Import libraries import pygame, sys from pygame.locals import * import random # Initialize Pygame pygame.init() # Set frame rate FPS = 60 FramePerSec = pygame.time.Clock() # Define colors WHITE = (255, 255, 255) # Set game screen size SCREEN_WIDTH = 400 SCREEN_HEIGHT = 600 # Create and fill the display screen with white DISPLAYSURF = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) DISPLAYSURF.fill(WHITE) pygame.display.set_caption("Game") # Define the Player class class Player(pygame.sprite.Sprite): def __init__(self): super().__init__() self.image = pygame.image.load("Player.png") self.rect = self.image.get_rect() self.rect.center = (160, 520) def update(self): pressed_keys = pygame.key.get_pressed() if self.rect.left > 0: if pressed_keys[K_LEFT]: self.rect.move_ip(-5, 0) if self.rect.right < SCREEN_WIDTH: if pressed_keys[K_RIGHT]: self.rect.move_ip(5, 0) def draw(self, surface): surface.blit(self.image, self.rect) # Define the Enemy class class Enemy(pygame.sprite.Sprite): def __init__(self): super().__init__() self.image = pygame.image.load("Enemy.png") self.rect = self.image.get_rect() self.rect.center = (random.randint(40, SCREEN_WIDTH - 40), 0) def move(self): self.rect.move_ip(0, 10) if self.rect.bottom > 600: self.rect.top = 0 self.rect.center = (random.randint(30, 370), 0) def draw(self, surface): surface.blit(self.image, self.rect) # Create characters P1 = Player() E1 = Enemy() # Define the game loop while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() P1.update() E1.move() DISPLAYSURF.fill(WHITE) P1.draw(DISPLAYSURF) E1.draw(DISPLAYSURF) pygame.display.update() FramePerSec.tick(FPS) Now let's go over which Pygame Python commands are used here. Game Initialization Creating a game in Python with Pygame begins with importing the library. Open a file in any IDE or code editor and add these two lines: import pygamefrom pygame.locals import * The first line imports the Pygame module for Python 3. The second line imports all the variables from pygame.locals. You can skip the second import, but it significantly reduces the amount of code. For example, without the import, the event for exiting the game would need to be written as pygame.locals.QUIT. With the import, the syntax is much shorter — just write QUIT to add the event. To use random values, import the random library. Without it, the game would be too predictable: import random Another important line to add at the beginning of the file is: pygame.init() This is mandatory when using the Pygame library. It must be added before using any other functions from Pygame, or you'll run into initialization problems. Therefore, you add init() at the beginning to prevent errors. Defining Characters The project uses an object-oriented approach, which allows to create classes that serve as the foundation for different characters. For instance, you'll have one class for enemies (obstacles in the game), and as you progress through levels, they can evolve and gain additional abilities. Let's start by defining the player class: class Player(pygame.sprite.Sprite): def __init__(self): super().__init__() self.image = pygame.image.load("Player.png") self.rect = self.image.get_rect() self.rect.center = (160, 520) The image.load() function loads the player's image from a file. To define the sprite boundaries, you use the get_rect() function, which automatically creates a rectangle matching the image's size. This will be useful later when, for example, you implement collision logic between objects. The last line, self.rect.center, sets the player's initial position on the game screen. def update(self): pressed_keys = pygame.key.get_pressed() if self.rect.left > 0: if pressed_keys[K_LEFT]: self.rect.move_ip(-5, 0) if self.rect.right < SCREEN_WIDTH: if pressed_keys[K_RIGHT]: self.rect.move_ip(5, 0) The update method controls the player's movement. When it's called, it checks if the arrow keys are pressed. In this project, we're only interested in left and right movement, which allows the player to dodge obstacles. If the left arrow is pressed, the player moves left, and similarly for right movement. The move_ip() method takes two parameters. The first is the number of pixels to move the object horizontally, and the second is the number of pixels to move it vertically. The conditions if self.rect.left > 0 and if self.rect.right < SCREEN_WIDTH ensure that the player doesn't move beyond the screen's edges. def draw(self, surface):    surface.blit(self.image, self.rect) The blit() function draws objects on the screen. The first parameter is the object to be drawn (in this case, self.image), and the second is the sprite rectangle. The enemy class is similar, but it includes a random number generator: self.rect.center = (random.randint(40, SCREEN_WIDTH - 40), 0) This ensures that obstacles appear at random locations each time, making the game less predictable. Creating the Game Loop The most important part of the game is the game loop: while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() P1.update() E1.move() DISPLAYSURF.fill(WHITE) P1.draw(DISPLAYSURF) E1.draw(DISPLAYSURF) pygame.display.update() FramePerSec.tick(FPS) The loop runs indefinitely until the user exits the game. This is the simplest implementation. In practice, various events (e.g., losing all lives) could end the game. First, the update functions for both the Player and Enemy classes are called. Then the screen is refreshed with DISPLAY.fill(WHITE). Finally, the draw function is called to render the objects on the screen. The pygame.display.update() command updates the screen, displaying all the changes made during that cycle. The tick() function ensures that the frames per second do not exceed the previously set FPS value. Conclusion Your game is now ready. While it's not polished enough to order a VPS on Hostman and await a flood of players, it's your first Python game — and now you know how to improve it. For instance, you could add vertical movement or change the logic for spawning obstacles. There are many possibilities for improving the project. For example, you could make a 3D game by using Pygame's raycasting features. While Pygame can't create something like Cyberpunk 2077, you could certainly make your version of Wolfenstein 3D. There are numerous tutorials and guides on Pygame that can help you explore both the library and some universal game development concepts. If you later switch to a more advanced game engine, many of these concepts will still be relevant.

Knowing how to work with strings is essential in any programming language. Today, we will cover strings in Python: what they are, how to find an index in a string, and which methods exist for working with indexes. Strings Strings are sequences of character data that can be indexed like any other sequence type in Python. To define a string, you enclose a sequence of characters (letters, numbers, spaces, punctuation marks, etc.) in single, double, or triple quotes. The indexing of characters starts at zero, and each character in the string has its own index. The index of the last character is one less than the length of the string. string = 'We love Python!' If we check the type of the string variable, we will get: str. Indexes Numerical indexes can be both positive and negative. To access a character by its index, you simply specify the index in square brackets []. If you refer to a specific index, you can retrieve the character that corresponds to it: print('4th character: ', string[4]) Output: 4th character: o In our string, the character "o" has the index 4. If you try to access a character at an index that does not exist in the string, you will get an error: print('15th character: ', string[15]) Error: IndexError: string index out of range To find the maximum index in a string, you can subtract 1 from the length of the string, since indexing starts at 0: print('Maximum index in the string: ', len(string) - 1) Output: Maximum index in the string: 14 Indexes in Python can also be negative, which means indexing starts from the end of the string: print('-1st character in the string: ', string[-1]) Output: -1st character: ! The index -1 corresponds to the last character of the string. String Slicing In addition to retrieving a character at a specific index, you can also extract a range of characters from a string—a substring. This is done using the slicing operator, and the resulting portion of the string is called a slice. print('Characters from index 1 to 6: ', string[1:6]) Output: Characters from index 1 to 6:  e lov In this example, 1 is the start index, and 6 is the end index. The slice includes characters from index 1 to 5 (the end index is excluded). If you want to extract a substring starting from index 0, you can omit the start index: print('Characters from index 0 to 6: ', string[:6]) Output: Characters from index 0 to 6:  We lov Similarly, you can omit the end index if you want a slice that goes to the end of the string. Python also allows the use of negative indices when slicing. Negative indices start at -1 from the end of the string and decrease as you move further back: print('Characters from -7 to -1: ', string[-7:-1]) Output: Characters from -7 to -1:  Python If no start or end indices are provided, the entire string is returned: print('Full string: ', string[:]) Output: Full string:  We love Python! Python allows indices that are out of the string’s bounds, in which case the slice is taken up to the end: print('Characters from 6 to 100: ', string[6:100]) Output: Characters from 6 to 100:  e Python! You can also use a third parameter when slicing—a step. The step defines how many characters to skip after each character is retrieved. In the examples above, the default step of 1 was used. Here is an example with a step: print('Substring with a step of 3: ', string[0:10:3]) Output: Substring with a step of 3:  Wley This returns every third character from the first 10 characters: "We love Python!". You can even use a step without specifying the start or end, which will create a substring using every nth character from the entire string: print('Substring with a step of 3: ', string[::3]) Output: Substring with a step of 3:  Wleyo The step can also be negative, which allows slicing in reverse order. Methods Python has several methods for counting and retrieving indexes within a string. One of the methods we’ve already covered is len(string)—which returns the length of the string. In addition to getting the length, you can also count the occurrences of a character or substring using the count() method: print('Number of occurrences of "e":', string.count('e')) Output: Number of occurrences of "e": 2 Another method lets you find the index of a character or substring within the original string: print('Index of character "e":', string.find('e')) Output: Index of character "e": 1 The first occurrence of the character "e" is at index 1. If the element is not found, the method returns -1. When searching for a substring, the method returns the index of its first character: print('Index of substring "love":', string.find('love')) Output: Index of substring "love": 3 To search for a substring starting from a specific index range, you can specify the range: print('Index of character "e" between index 4 and 9:', string.find('e', 4, 9)) Output: Index of character "e": 6 To get the highest index of an element in the string, you can use the rfind() method, which works like find() but returns the last occurrence of the element: print('Last occurrence of "e":', string.rfind('e')) For finding a substring, you can use index() and rindex(), which work similarly to find() and rfind(), but raise an error if the substring is not found: ValueError: substring not found Conclusion In this tutorial, we covered the characteristics of string data types, indexing, and slicing in Python 3. These fundamental concepts are useful for a wide range of tasks in one of the most popular programming languages. You can find more information in the documentation and Hostman tutorials.