Основы языка программирования python за 10 минут

Краткое введение в ООП

Объектно-ориентированное программирование (ООП) – технология разработки сложного программного обеспечения, в которой программа строится в виде совокупности объектов и их взаимосвязей.

Объединение данных и действий, производимых над этими данными, в единое целое, которое называется объектом – является одним из основных принципов ООП.

Основными понятиями являются понятие класса и объекта.

Класс является типом данных, определяемым пользователем и представляет собой структуру в виде данных и методов для работы с данными.

Формально Класс — это шаблон, по которому будет сделан объект.

Объект является экземпляром класса. Объект  и экземпляр - это одно и то же.

Вот пример. Форма для изготовления печенья – это класс, а само печенье это объект или экземпляр класса, т.е. это конкретное изделие. Печенье имеет размеры, цвет, состав – это атрибуты класса. Также в классе описываются методы, которые предназначены для чтения или изменения данных объекта.

В Python характеристики  объекта, называются атрибутами, а действия, которые мы можем проделывать с объектами, — методами. Методами в Python  называют функции, которые определяются внутри класса.

Объект = атрибуты + методы 

How to Set Environment Variable in Python

We can set the environment variable value using the syntax: os.environ = env_var_value

import os

env_var = input('Please enter environment variable name:\n')

env_var_value = input('Please enter environment variable value:\n')

os.environ = env_var_value

print(f'{env_var}={os.environ} environment variable has been set.')

Output:

Please enter environment variable name:
datatype
Please enter environment variable value:
CSV
datatype=CSV environment variable has been set.

If the environment variable already exists, it will be overwritten by the new value. The environment variable will be set only for the current session of the Python interpreter. If you want to change to be permanent, then you will have to edit the user profile file in the Python program.

Создание словаря

Пустой словарь можно создать при помощи функции или
пустой пары фигурных скобок (вот почему фигурные скобки
нельзя использовать для создания пустого множества). Для создания словаря
с некоторым набором начальных значений можно использовать следующие конструкции:

Capitals = {'Russia': 'Moscow', 'Ukraine': 'Kiev', 'USA': 'Washington'}
Capitals = dict(Russia = 'Moscow', Ukraine = 'Kiev', USA = 'Washington')
Capitals = dict()
Capitals = dict(zip(, ))
print(Capitals)

Первые два способа можно использовать только для создания небольших словарей, перечисляя все их элементы.
Кроме того, во втором способе ключи передаются как именованные параметры функции , поэтому
в этом случае ключи могут быть только строками, причем являющимися корректными идентификаторами.
В третьем и четвертом случае можно создавать большие словари, если в качестве аргументов
передавать уже готовые списки, которые могут быть получены не обязательно перечислением всех элементов,
а любым другим способом построены по ходу исполнения программы. В третьем способе
функции нужно передать список, каждый элемент которого является кортежем
из двух элементов: ключа и значения. В четвертом способе используется функция ,
которой передаются два списка одинаковой длины: список ключей и список значений.

Method 3: Explicitly print to the file

We can directly specify the file to be printed in the call to , by mentioning the file keyword argument.

For example, the below snippet prints to the file .

print('Hi', file=open('output.txt', 'a'))
print('Hello from AskPython', file=open('output.txt', 'a'))
print('exit', file=open('output.txt', 'a'))

The file now has the three lines appended to it, and we have successfully printed to !

Using a context manager

However, this method isn’t the best way to resolve this situation, due to the repeated calls to on the same file. This wastes time, and we can do better!

The better way would be to explicitly use a context manager statement, which takes care of automatically closing the file and using the file object directly.

with open("output.txt", "a") as f:
    print('Hi', file=f)
    print('Hello from AskPython', file=f)
    print('exit', file=f)

This gives the same result as before, appending the three lines to , but is now much faster, since we don’t open the same file again and again.

Операции над словарями Python

Если словарь, содержащий полный набор данных, большой, то разумнее использовать список lowscores, который мы только что скомпилировали, чтобы создать совершенно новый словарь (Python список в словарь). Преимущество этого приема заключается в том, что для дальнейшего анализа не нужно хранить в памяти большой словарь. Можно просто перейти к соответствующему подмножеству исходных данных.

Во-первых, мы используем ключи, хранящиеся в lowscores, для создания нового словаря. Чтобы сделать это, есть два способа: первый — извлекаем только соответствующие элементы из исходного словаря с помощью метода .get(), оставляя исходный словарь без изменений. Второй — использовать метод .pop(), который удаляет извлеченные записи из исходного словаря.

Код для подмножества может выглядеть следующим образом: subset = dict(). Такое написание может показаться незнакомым, потому что цикл задан одной строкой кода. Этот стиль называется «генерацией словаря». На самом деле это цикл for, который перебирает элементы lowscores, извлекает значения из отзывов и использует их для заполнения нового словаря.

Вы можете сравнить традиционный стиль с использованием цикла и генерацию словаря и убедиться, что они действительно дают идентичный результат:

# Метод с использованием цикла for для создания подмножества словаря
forloop = {}
for k in lowscores:
  forloop = reviews
# Добавляем специальный метод извлечения релевантных элементов из словаря `reviews`
dictcomp = {k : reviews.___(k) for k in lowscores}
# Удостоверимся, что эти объекты аналогичны
print(forloop == ________)

Предположим, что теперь вы хотите изменить словарь Python 3, чтобы оценки выступали в качестве ключей словаря, а не идентификаторов. Можно использовать для этого цикл for, указав как ключи, так и значения, и создав новый вложенный словарь. Нужно будет извлечь «score» из исходного вложенного словаря, чтобы использовать его в качестве нового ключа.

Чтобы упростить код, мы создаем в отдельной строке новый вложенный словарь как новый объект newvalues. После чего заполняем scoredict идентификаторами в качестве ключей и объектами из словаря newvalues в качестве значений:

from collections import defaultdict
scoredict = defaultdict(list)
for key, value in reviews.items():
  newvalues = {'id' : key, "title" : value, "review" : value}
  # Используем 'score' из значений (!) из исходного словаря в качестве ключей для только что созданного  словаря
  scoredict].append(newvalues)

# Выводим ключи словаря, чтобы удостовериться, что это на самом деле оценки из отзывов
print(scoredict.keys())

Print a dictionary line by line using List Comprehension

In a single line using list comprehension & dict.items(), we can print the contents of a dictionary line by line i.e.

# A dictionary of student names and their score
student_score = {   'Ritika': 5,
                    'Sam': 7, 
                    'John': 10, 
                    'Aadi': 8}

# Iterate over the key-value pairs of a dictionary 
# using list comprehension and print them

Output:

Ritika : 5
Sam : 7
John : 10
Aadi : 8

Learn more about Python Dictionaries

  • What is a Dictionary in Python ? Why do we need it?
  • 6 Different ways to create Dictionaries in Python
  • How to iterating over dictionaries in python.
  • Check if a key exists in dictionary
  • How to get all the keys in Dictionary as a list ?
  • How to Iterate over dictionary with index ?
  • How to remove a key from Dictionary?
  • How to find keys by value in Dictionary
  • How to filter a dictionary by conditions?
  • How to get all the Values in a Dictionary ?

Printing nested dictionaries line by line in python

Suppose we have a nested dictionary that contains student names as key, and for values, it includes another dictionary of the subject and their scores in the corresponding subjects i.e.

# Nested dictionary containing student names and their scores in separate subjects
student_score = {   'Mathew': { 'Math': 28,
                                'Science': 18,
                                'Econimics': 15},
                    'Ritika': { 'Math': 19,
                                'Science': 20,
                                'Econimics': 19},
                    'John': {   'Math': 11,
                                'Science': 22,
                                'Econimics': 17}
                }

If print this dictionary by passing it to the print() function,

print(student_score)

Then the output will be like,

{'Mathew': {'Math': 28, 'Science': 18, 'Econimics': 15}, 'Ritika': {'Math': 19, 'Science': 20, 'Econimics': 19}, 'John': {'Math': 11, 'Science': 22, 'Econimics': 17}}  

It printed all the contents in a single line. Therefore, it is tough to understand the contents. Now to print the contents of a nested dictionary line by line, we need to do double iteration i.e.

# Nested dictionary containing student names and their scores in separate subjects
student_score = {   'Mathew': { 'Math': 28,
                                'Science': 18,
                                'Econimics': 15},
                    'Ritika': { 'Math': 19,
                                'Science': 20,
                                'Econimics': 19},
                    'John': {   'Math': 11,
                                'Science': 22,
                                'Econimics': 17}
                }

# Iterate over key / value pairs of parent dictionary
for key, value in student_score.items():
    print(key, '--')
    # Again iterate over the nested dictionary
    for subject, score in value.items():
        print(subject, ' : ', score)

Output:

Mathew --
Math  :  28
Science  :  18
Econimics  :  15
Ritika --
Math  :  19
Science  :  20
Econimics  :  19
John --
Math  :  11
Science  :  22
Econimics  :  17

We first iterated over the items, i.e. key/value pairs of the dictionary, and for each pair printed the key. As value field is another dictionary, so we again iterated over the key-value pairs in this dictionary and printed its contents i.e. key/value pairs in separate lines.

Строки

Строка – это последовательность символов. Чаще всего строки – это просто некоторые наборы слов. Слова могут быть как на английском языке, так и  почти на любом языке мира.

Операции со строками

string извлекает символ в позиции i
string извлекает последний символ
string извлекает символы в диапазоне от i до j

Методы работы сос строками

string.upper() преобразует строку в верхний регистр
String.lower() преобразует в строку в нижний регистр
string.count(x) подсчитывает, сколько раз появляется x
string.find(x) позиция первой строки вхождения x
string.replace(x, y) заменяет x на y
string.strip(x) удаляет как начальные, так и конечные символы x
string.join (List) объединяет список строк

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if
moves it as the «header» of the block.

  • Current:

    env_base = os.environ.get("PYTHONUSERBASE", None)
    if env_base:
        return env_base
    
  • Improved:

    if env_base := os.environ.get("PYTHONUSERBASE", None):
        return env_base
    

Avoid nested if and remove one indentation level.

  • Current:

    if self._is_special:
        ans = self._check_nans(context=context)
        if ans:
            return ans
    
  • Improved:

    if self._is_special and (ans := self._check_nans(context=context)):
        return ans
    

Code looks more regular and avoid multiple nested if.
(See Appendix A for the origin of this example.)

  • Current:

    reductor = dispatch_table.get(cls)
    if reductor:
        rv = reductor(x)
    else:
        reductor = getattr(x, "__reduce_ex__", None)
        if reductor:
            rv = reductor(4)
        else:
            reductor = getattr(x, "__reduce__", None)
            if reductor:
                rv = reductor()
            else:
                raise Error(
                    "un(deep)copyable object of type %s" % cls)
    
  • Improved:

    if reductor := dispatch_table.get(cls):
        rv = reductor(x)
    elif reductor := getattr(x, "__reduce_ex__", None):
        rv = reductor(4)
    elif reductor := getattr(x, "__reduce__", None):
        rv = reductor()
    else:
        raise Error("un(deep)copyable object of type %s" % cls)
    

tz is only used for s += tz, moving its assignment inside the if
helps to show its scope.

  • Current:

    s = _format_time(self._hour, self._minute,
                     self._second, self._microsecond,
                     timespec)
    tz = self._tzstr()
    if tz:
        s += tz
    return s
    
  • Improved:

    s = _format_time(self._hour, self._minute,
                     self._second, self._microsecond,
                     timespec)
    if tz := self._tzstr():
        s += tz
    return s
    

Lowering operator precedence

There are two logical precedences for the := operator. Either it should
bind as loosely as possible, as does statement-assignment; or it should bind
more tightly than comparison operators. Placing its precedence between the
comparison and arithmetic operators (to be precise: just lower than bitwise
OR) allows most uses inside while and if conditions to be spelled
without parentheses, as it is most likely that you wish to capture the value
of something, then perform a comparison on it:

pos = -1
while pos := buffer.find(search_term, pos + 1) >= 0:
    ...

Once find() returns -1, the loop terminates. If := binds as loosely as
= does, this would capture the result of the comparison (generally either
True or False), which is less useful.

Условный оператор if

Оператор if позволяет изменить порядок выполнения операторов в зависимости от истинности или ложности некоторого условия. Формат оператора может быть записан в двух формах: полной и неполной форме.

if  условие:    # блок if    <операторы>else:    # блок else    <операторы>

Блок инструкций if будет выполнен, если условие истинно. Если условие ложно, будет выполнен блок инструкций else.

В условном операторе  может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением.

Пример 5.  Записать следующее   выражение  на языке Python.Если a  >  0,  то  b  =  1,   иначе  a  =  0. 

print («Введите значение a: «) a = int(input())if a > :     b = 1       else:     b = print(«b = «, b)

Условный оператор  elif

if условие_1:   # блок if   <операторы>elif условие_2:   # первый блок elif   <операторы>elif условие_3:   <операторы>...else   # блок else   <операторы>   

Ключевое слово elifрасшифровывается, как else + if. Это конструкция позволяет  реализовать алгоритм  выбора   необходимого варианта из нескольких альтернативных вариантов.  Оператор elif позволяет упростить код. Сделать его легче читаемым и позволяет избежать написание несколько условий  if.

Когда исполняется инструкция if-elif-else, в первую очередь  проверяется условие_1.  Если условие истинно, тогда исполняется блок инструкций if .  Следующие условия и операторы пропускаются, и управление переходит к оператору  за  условным оператором if-elif-else.

Если условие_1 оказывается ложным, тогда управление переходит к следующему условию elif,  и проверяется условие_2.  Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются. Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок операторов else

 Пример.  

x = int(input())
y = int(input())if x > and y > print("Первая четверть")elif x > and y < print("Четвертая четверть")elif y > print("Вторая четверть")else: print("Третья четверть")

Библиотека math

Для проведения вычислений с действительными числами язык Python содержит много дополнительных функций, собранных в библиотеку, которая называется math. Для использования этих функций в начале программы необходимо подключить библиотеку, что делается командой

import math           # подключение модуля библиотеки

После подключения программа получает доступ ко всем функциям, методам и классам, содержащимся в нём. После подключения можно вызвать любую функцию из подключенной библиотеки по следующему правилу: указывается имя модуля и через точку имя функции

имя_модуля.имя_функции

Например, пусть мы хотим вызвать функцию вычисления Синус угла, задаваемого в радианахimport math y = sin(5)         # ошибка не подключен модуль mathx = math.sin(5)    # записываем имя модуля и через точку имя функции

Можно подключать не весь модуль, а какую-то его часть. Например, программист хочет использовать только одну функцию из математической библиотеки math. Если он подключит всю библиотеку, то будет добавлено более 40 функций, которые будут занимать место. Чтобы добавить в проект какую-то часть, используют ключевое слово from

from <имя подключаемого модуля> import <название функции>

Например.

from math import sin       # подключена только одна функция siny = sin(5)                 # операция выполненаx = cos(5)               # ошибка функция cos не подключена

Ниже приведен список основных функций модуля math. Некоторые из перечисленных функций (int, round, abs) являются стандартными и не требуют подключения модуля math для использования.

Method 4: Use the logging module

We can use Python’s logging module to print to the file. This is preferred over Method 2, where explicitly changing the file streams is not be the most optimal solution.

import logging

# Create the file
# and output every level since 'DEBUG' is used
# and remove all headers in the output
# using empty format=''
logging.basicConfig(filename='output.txt', level=logging.DEBUG, format='')

logging.debug('Hi')
logging.info('Hello from AskPython')
logging.warning('exit')

This will, by default, append the three lines to . We have thus printed to the file using , which is one of the recommended ways of printing to a file.

Основные операторы

Оператор

Краткое описание

+

Сложение (сумма x и y)

Вычитание (разность x и y)

*

Умножение (произведение x и y)

Деление
Внимание! Если x и y целые, то результат всегда будет целым числом! Для получения вещественного результата хотя бы одно из чисел должно быть вещественным. Пример: 40/5 → 8, а вот 40/5.0 → 8.0

=

Присвоение

+=

y+=x; эквивалентно y = y + x;

-=

y-=x; эквивалентно y = y — x;

*=

y*=x; эквивалентно y = y * x;

/=

y/=x; эквивалентно y = y / x;

%=

y%=x; эквивалентно y = y % x;

==

Равно

!=

не равно

Больше

=

больше или равно

Часть после запятой отбрасывается
4 // 3 в результате будет 125 // 6 в результате будет 4

**

Возведение в степень
5 ** 2 в результате будет 25

and

логическое И

or

логическое ИЛИ

not

логическое отрицание НЕ

Генерация случайных чисел (модуль random)

Python порождает случайные числа на основе формулы, так что они на самом деле не случайные, а, как говорят, псевдослучайные.

Модуль random позволяет генерировать случайные числа и  имеет большое множество важных для практики функций. Рассмотрим  основные функции:

random.random() - случайное число от 0 до 1.
random.randint(A, B) - случайное целое число N, A ≤ N ≤ B.
random.shuffle(list) перемешивает список случайным образом
random.choice(list) возвращает один случайный элемент из списка

Примеры

Функцияrandom.random()случайное число от 0 до 1.

import randomnumber = random.random()  # значение от 0.0 до 1.0print(number)number = random.random() * 100  # значение от 0.0 до 100.0print(number)

Функция    random.randint(A, B) — случайное целое число N, A ≤ N ≤ B

import randomnumber = random.randint(20, 35)  # значение от 20 до 35print(number)

функция random.shuffle(list) перемешивает список случайным образом

import randomnumbers =    # списокrandom.shuffle(numbers)print('numbers shuffle:',numbers)

Результат работы программы:

numbers shuffle:

функция  random.choice(list) возвращает один случайный элемент из списка

numbers =  random_number = random.choice(numbers)print('random_number:', random_number)

Атрибуты и методы класса

 Атрибуты класса

Характеристики  объекта, называются атрибутами и записываются в внутри конструктора с помощью переменной self.   Доступ к атрибутам осуществляется через переменную self.

Например, класс имеет атрибут  цвет – color, он должен быть записан как

     self.color

Методы  класса

Методы класса создаются посредством ключевого слова def , имени метода , слова self, которое всегда указывается как первый параметр метода

def имя метода(self, передаваемые параметры):       # тело метода

Пример. Создаем метод, который выводит на печать характеристики мяча

 def Show(self):       print("Мяч: ", self.color, self.size )

 Мы определили атрибуты класса и методы. Таким образом,  класс  для нашего мяча будет выглядеть так:

class Balldef __init__(self, color, size):         self.color =  color         self.size = size    def Show(self):       print("Мяч: ", self.color, self.size )

Special Characters in Python Print Function

The Python programming language allows you to use special characters by using escape characters. For example, within s1 (‘Hi there, \ “How are You?\”‘), we used \ character to escape double quotes within the print statement. Next, we used \ to escape ‘(single quote) in print (‘I Can\’t Do that’).

print function with special Characters output

The first print statement returns three new lines. And the last statement prints 5 new lines.

This print function example is the same as the above — however, this time, we used three empty lines in between the two strings Hi and Hello.

print function with empty lines output

In this example, we are using the New Line, Horizontal Tab, Vertical Tab, etc., in between a string to show you how they alter the output. For example, the first statement with \n prints Hi there, in the first line and How are You? in the next line.

print function with New Line, Horizontal Tab, and Vertical Tab output

Method 2: Redirect sys.stdout to the file

Usually, when we use the print function, the output gets displayed to the console.

But, since the standard output stream is also a handler to a file object, we can route the standard output to point to the destination file instead.

The below code is taken from our previous article on stdin, stdout and stderr. This redirects the to the file.

import sys
 
# Save the current stdout so that we can revert sys.stdou after we complete
# our redirection
stdout_fileno = sys.stdout
 
sample_input = 
 
# Redirect sys.stdout to the file
sys.stdout = open('output.txt', 'w')
 
for ip in sample_input:
    # Prints to the redirected stdout (Output.txt)
    sys.stdout.write(ip + '\n')
    # Prints to the actual saved stdout handler
    stdout_fileno.write(ip + '\n')
 
# Close the file
sys.stdout.close()
# Restore sys.stdout to our old saved file handler
sys.stdout = stdout_fileno

Output (Assume that is a newly created file)

:~# python output_redirection.py
Hi
Hello from AskPython
exit
:~# cat output.txt
Hi
Hello from AskPython
exit

Conversion Types in Python Print function

The list of conversion types that are available in the Python print function. 

  • %c – Returns a Single character.
  • %d – Returns a Decimal Integer
  • %i – for Long integer
  • %u – Returns an unsigned decimal integer
  • %e, %E – Returns the floating-point value in exponential notation. 
  • %f – Returns the floating-point value in fixed-point notation. 
  • %g – Returns the shorter value of %f and %e
  • %G – Returns the shorter value of %f and %E
  • %c – Returns a Single character
  • %o – Returns an Octal value
  • %r – Generates string with repr()
  • %s – Converts the value to a string using str() function.
  • %x, %X – Returns the Hexadecimal integer.

Let me use all the available conversion types. For this, we declared a few variables with a numeric value, string, decimal value, and a character.

print function conversion types output

Python print file example

Here, we are opening a file pythonSample.txt (if it exists). Otherwise, it creates that text file in the default directory. Next, the print function prints the statement inside that text file.

Print a dictionary line by line using json.dumps()

In python, json module provides a function json.dumps() to serialize the passed object to a json like string. We can pass the dictionary in json.dumps() to get a string that contains each key-value pair of dictionary in a separate line. Then we can print that string,

import json

# A dictionary of student names and their score
student_score = {   'Ritika': 5,
                    'Sam': 7, 
                    'John': 10, 
                    'Aadi': 8}

# Print contents of dict in json like format
print(json.dumps(student_score, indent=4))

Output

{
    "Ritika": 5,
    "Sam": 7,
    "John": 10,
    "Aadi": 8
}

We passed the dictionary object and count of indent spaces in json.dumps(). It returned a json like formatted string. Remember to import the json module for this approach.

Now, what if we have a nested python dictionary?

Special-casing conditional statements

One of the most popular use-cases is if and while statements. Instead
of a more general solution, this proposal enhances the syntax of these two
statements to add a means of capturing the compared value:

if re.search(pat, text) as match:
    print("Found:", match.group(0))

This works beautifully if and ONLY if the desired condition is based on the
truthiness of the captured value. It is thus effective for specific
use-cases (regex matches, socket reads that return '' when done), and
completely useless in more complicated cases (e.g. where the condition is
f(x) < 0 and you want to capture the value of f(x)). It also has
no benefit to list comprehensions.

Relative precedence of :=

The := operator groups more tightly than a comma in all syntactic
positions where it is legal, but less tightly than all other operators,
including or, and, not, and conditional expressions
(A if C else B). As follows from section
«Exceptional cases» above, it is never allowed at the same level as
=. In case a different grouping is desired, parentheses should be
used.

The := operator may be used directly in a positional function call
argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

# INVALID
x := 0

# Valid alternative
(x := 0)

# INVALID
x = y := 0

# Valid alternative
x = (y := 0)

# Valid
len(lines := f.readlines())

# Valid
foo(x := 3, cat='vector')

# INVALID
foo(cat=category := 'vector')

# Valid alternative
foo(cat=(category := 'vector'))

Most of the «valid» examples above are not recommended, since human
readers of Python source code who are quickly glancing at some code
may miss the distinction. But simple cases are not objectionable:

# Valid
if any(len(longline := line) >= 100 for line in lines):
    print("Extremely long line:", longline)

Итоговый пример

И для закрепления материала давайте напишем и разберём такую программку:

# Для вывода строк используем функцию print()
print("Привет!", "Сейчас посчитаем, сколько будет 6 * 8", sep='\n')

# Устанавливаем переменные
a=6
b=8

# Производим вычисления
print("Производим вычисления", end='... ')
print(a, "*", b, "=", a*b, sep='')

# И сохриним результат в файл
file = open('print.txt','a+')
print(a, "*", b, "=", a*b, sep='', file=file)
file.close()

print("Результат был записан в файл 'print.txt'")
print("Выполните команду 'cat print.txt',", end=' ')
print("чтобы посмотреть содержимое файла.")

Вот результат выполнения этой программы:

$ python3 hello.py 
Привет!
Сейчас посчитаем, сколько будет 6 * 8
Производим вычисления... 6*8=48
Результат был записан в файл 'print.txt'
Выполните команду 'cat print.txt', чтобы посмотреть содержимое файла.

$ cat print.txt
6*8=48

В официальной документации встроенная в Python функция print() описана .

Сводка

Имя статьи
Python 3. Вывод текста на консоль. Функция print()

Описание
В статье узнаем как в Python 3, с помощью встроенной функции print(), вывести текст на консоль. А для закрепления напишем небольшую программу

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector