Python урок 1. арифметические действия и конструкции

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

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

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

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

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

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

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

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

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

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

Генерация списков, словарей и множеств

Генерация списков, словарей и множеств командами в одну строку — наиболее мощные и характерные фичи языка Python. Всё это великолепие работает и с форматированными строками. Вот список из форматированных строк, созданный на основе другого списка:

Форматированная строка может содержать и генератор списка, с этим проблем нет, — тогда она выдаст строку, состоящую из вычисленного списка, а не из команды генератора.

Со словарями и множествами дело обстоит чуть иначе — в основном из-за наличия фигурных скобок. Поэтому для того, чтобы строка была в виде словаря, а не в виде текста генератора, надо добавлять пробелы между внутренними и внешними фигурными скобками.

Числовые литералы

Числовые литералы неизменяемы. Числовые литералы могут принадлежать к следующим четырем различным числовым типам.

Int(числа с целым знаком)	Long(длинные целые числа)	float(с плавающей запятой)	Complex(сложные)
Числа(могут быть как положительными, так и отрицательными) без дробной части, например: 100	Целые числа неограниченного размера, за которыми следует строчная или прописная буква L, например: 87032845L	Действительные числа с целой и дробной частью, например: -26,2	В форме a + bj, где a – действительная часть, а b – мнимая часть комплексного числа. например: 3.14j

Пример числовых литералов:

x = 0b10100 #Binary Literals
y = 100 #Decimal Literal 
z = 0o215 #Octal Literal
u = 0x12d #Hexadecimal Literal

#Float Literal
float_1 = 100.5 
float_2 = 1.5e2

#Complex Literal 
a = 5+3.14j

print(x, y, z, u)
print(float_1, float_2)
print(a, a.imag, a.real)

Выход:

20 100 141 301
100.5 150.0(5+3.14j) 3.14 5.0

Строки

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

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

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) объединяет список строк

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.

Special-casing comprehensions

Another common use-case is comprehensions (list/set/dict, and genexps). As
above, proposals have been made for comprehension-specific solutions.

1. where, let, or given:

   stuff = [(y, x/y) where y = f(x) for x in range(5)]
   stuff = [(y, x/y) let y = f(x) for x in range(5)]
   stuff = [(y, x/y) given y = f(x) for x in range(5)]
   

   This brings the subexpression to a location in between the ‘for’ loop and
   the expression. It introduces an additional language keyword, which creates
   conflicts. Of the three, where reads the most cleanly, but also has the
   greatest potential for conflict (e.g. SQLAlchemy and numpy have where
   methods, as does tkinter.dnd.Icon in the standard library).

2. with NAME = EXPR:

   stuff = [(y, x/y) with y = f(x) for x in range(5)]
   

   As above, but reusing the with keyword. Doesn’t read too badly, and needs
   no additional language keyword. Is restricted to comprehensions, though,
   and cannot as easily be transformed into «longhand» for-loop syntax. Has
   the C problem that an equals sign in an expression can now create a name
   binding, rather than performing a comparison. Would raise the question of
   why «with NAME = EXPR:» cannot be used as a statement on its own.

3. with EXPR as NAME:

   stuff = [(y, x/y) with f(x) as y for x in range(5)]
   

   As per option 2, but using as rather than an equals sign. Aligns
   syntactically with other uses of as for name binding, but a simple
   transformation to for-loop longhand would create drastically different
   semantics; the meaning of with inside a comprehension would be
   completely different from the meaning as a stand-alone statement, while
   retaining identical syntax.

Scope of the target

An assignment expression does not introduce a new scope. In most
cases the scope in which the target will be bound is self-explanatory:
it is the current scope. If this scope contains a nonlocal or
global declaration for the target, the assignment expression
honors that. A lambda (being an explicit, if anonymous, function
definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a
list, set or dict comprehension or in a generator expression (below
collectively referred to as «comprehensions») binds the target in the
containing scope, honoring a nonlocal or global declaration
for the target in that scope, if one exists. For the purpose of this
rule the containing scope of a nested comprehension is the scope that
contains the outermost comprehension. A lambda counts as a containing
scope.

The motivation for this special case is twofold. First, it allows us
to conveniently capture a «witness» for an any() expression, or a
counterexample for all(), for example:

if any((comment := line).startswith('#') for line in lines):
    print("First comment:", comment)
else:
    print("There are no comments")

if all((nonblank := line).strip() == '' for line in lines):
    print("All lines are blank")
else:
    print("First non-blank line:", nonblank)

Second, it allows a compact way of updating mutable state from a
comprehension, for example:

# Compute partial sums in a list comprehension
total = 0
partial_sums = 
print("Total:", total)

However, an assignment expression target name cannot be the same as a
for-target name appearing in any comprehension containing the
assignment expression. The latter names are local to the
comprehension in which they appear, so it would be contradictory for a
contained use of the same name to refer to the scope containing the
outermost comprehension instead.

For example, is invalid: the for
i part establishes that i is local to the comprehension, but the
i := part insists that i is not local to the comprehension.
The same reason makes these examples invalid too:

 for j in range(5)] # INVALID
                       # INVALID
                      # INVALID

While it’s technically possible to assign consistent semantics to these cases,
it’s difficult to determine whether those semantics actually make sense in the
absence of real use cases. Accordingly, the reference implementation will ensure
that such cases raise SyntaxError, rather than executing with implementation
defined behaviour.

This restriction applies even if the assignment expression is never executed:

     # INVALID
  # INVALID

For the comprehension body (the part before the first «for» keyword) and the
filter expression (the part after «if» and before any nested «for»), this
restriction applies solely to target names that are also used as iteration
variables in the comprehension. Lambda expressions appearing in these
positions introduce a new explicit function scope, and hence may use assignment
expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table
analyser cannot easily detect when names are re-used between the leftmost
comprehension iterable expression and the rest of the comprehension), named
expressions are disallowed entirely as part of comprehension iterable
expressions (the part after each «in», and before any subsequent «if» or
«for» keyword):

                    # INVALID
  # INVALID
]       # INVALID
        # INVALID

A further exception applies when an assignment expression occurs in a
comprehension whose containing scope is a class scope. If the rules
above were to result in the target being assigned in that class’s
scope, the assignment expression is expressly invalid. This case also raises
SyntaxError:

class Example:
      # INVALID

(The reason for the latter exception is the implicit function scope created
for comprehensions — there is currently no runtime mechanism for a
function to refer to a variable in the containing class scope, and we
do not want to add such a mechanism. If this issue ever gets resolved
this special case may be removed from the specification of assignment
expressions. Note that the problem already exists for using a
variable defined in the class scope from a comprehension.)

Встроенные функции

print (x, sep = 'y') печатает x объектов, разделенных y

len (x) возвращает длину x (s, L или D)

min (L ) возвращает минимальное значение в L

max (L) возвращает максимальное значение в L

sum (L) возвращает сумму значений в диапазоне L

range(n1,n2,n) (n1, n2, n) возвращает последовательность чисел от n1 до n2 с шагом n

abs (n) возвращает абсолютное значение n

round (n1, n) возвращает число n1, округленное до n цифр

type (x) возвращает тип x (string, float, list, dict…)

str (x) преобразует x в string 

list (x) преобразует x в список

int (x) преобразует x в целое число

float (x) преобразует x в число с плавающей запятой

help (s) печатает справку о x

map (function, L) Применяет функцию к значениям в L

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.

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

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
  

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

We can do this in a single line using json module’s dumps() function i.e.

import json

# 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}
                }


print(json.dumps(student_score, indent=4))

Output:

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

Advertisements

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

Оператор

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

+

Сложение (сумма 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

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

Print a dictionary line by line by iterating over keys

We can iterate over the keys of a dictionary one by one, then for each key access its value and print in a separate line i.e.

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

# Iterate over the keys in dictionary, access value & print line by line
for key in student_score:
    print(key, ' : ', student_score)

Output:

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

Although by this approach we printed all the key value pairs line by line this is not an efficient method as compared to the previous one because to access one key-value pair, we are performing two operations.

A numeric example

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large
as the n’th root of x, this algorithm returns the floor of the n’th
root of x (and roughly doubling the number of accurate bits per
iteration):

while a > (d := x // a**(n-1)):
    a = ((n-1)*a + d) // n
return a

It’s not obvious why that works, but is no more obvious in the «loop
and a half» form. It’s hard to prove correctness without building on
the right insight (the «arithmetic mean — geometric mean inequality»),
and knowing some non-trivial things about how nested floor functions
behave. That is, the challenges are in the math, not really in the
coding.

If you do know all that, then the assignment-expression form is easily
read as «while the current guess is too large, get a smaller guess»,
where the «too large?» test and the new guess share an expensive
sub-expression.

To my eyes, the original form is harder to understand:

while True:
    d = x // a**(n-1)
    if a <= d:
        break
    a = ((n-1)*a + d) // n
return a

Создание Подстроки Python С Помощью Метода Split

Split strings-это еще одна функция, которая может быть применена в Python, давайте посмотрим на строку “Python Pool Best Place to Learn Python”. Сначала здесь мы разделим строку с помощью командного слова. разделитесь и получите результат.

Выход

Чтобы лучше понять это, мы увидим еще один пример разделения, вместо пробела (‘ ‘) мы заменим его на (‘r’), и он разделит строку везде, где в строке упоминается ‘r’

Выход

Примечание: В Python строки неизменяемы.

Строковые методы Python

Метод в Python похож на функцию, но он работает “на” объекте. Если переменная s рассматривается как строка, то код s.lower() запускает метод lower() на этом строковом объекте и затем возвращает результат (эта концепция метода, работающего на объекте, является одной из основных идей, составляющих Объектно-ориентированное программирование, ООП)

Python substring имеет довольно много методов, которые строковые объекты могут вызывать для выполнения часто встречающихся задач (связанных со строкой). Например, если требуется, чтобы первая буква строки была заглавной, можно использовать метод capitalize (). Ниже приведены все методы строковых объектов. Кроме того, включены все встроенные функции, которые могут принимать строку в качестве параметра и выполнять некоторую задачу.

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.

Getting Specific Environment Variable Value

Since os.environ is a dictionary object, we can get the specific environment variable value using the key.

import os

home_dir =os.environ
username = os.environ
print(f'{username} home directory is {home_dir}')

Output:

However, this way to get the environment variable will raise KeyError if the environment variable is not present.

>>> import os
>>> env_var = input('Please enter the environment variable name:\n')
Please enter the environment variable name:
data
>>> print(os.environ)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/os.py", line 678, in __getitem__
    raise KeyError(key) from None
KeyError: 'data'
>>>

A better way to get the environment variable is to use the dictionary get() function. We can also specify the default value if the environment variable is not present.

>>> import os
>>> env_var = input('Please enter the environment variable name:\n')
Please enter the environment variable name:
data
>>> print(os.environ.get(env_var))
None
>>> print(os.environ.get(env_var, 'CSV'))
CSV

Операции над словарями 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())

Python print() function

The print() function in Python is used to print a specified message on the screen. The print command in Python prints strings or objects which are converted to a string while printing on a screen.

Syntax:

print(object(s))

How to Print a simple String in Python?

More often then not you require to Print strings in your coding construct.

Here is how to print statement in Python 3:

Example: 1

To print the Welcome to Guru99, use the Python print statement as follows:

print ("Welcome to Guru99")

Output:

Welcome to Guru99

In Python 2, same example will look like

print "Welcome to Guru99"

Example 2:

If you want to print the name of five countries, you can write:

print("USA")
print("Canada")
print("Germany")
print("France")
print("Japan")

Output:

USA
Canada
Germany
France
Japan

How to print blank lines

Sometimes you need to print one blank line in your Python program. Following is an example to perform this task using Python print format.

Example:

Let us print 8 blank lines. You can type:

print (8 * "\n")

or:

print ("\n\n\n\n\n\n\n\n\n")

Here is the code

print ("Welcome to Guru99")
print (8 * "\n")
print ("Welcome to Guru99")

Output

Welcome to Guru99







Welcome to Guru99

Print end command

By default, print function in Python ends with a newline. This function comes with a parameter called ‘end.’ The default value of this parameter is ‘\n,’ i.e., the new line character. You can end a print statement with any character or string using this parameter. This is available in only in Python 3+

Example 1:

print ("Welcome to", end = ' ') 
print ("Guru99", end = '!')

Output:

Welcome to Guru99!

Example 2:

# ends the output with ‘@.’

print("Python" , end = '@')

Output:

Python@

Генерация случайных чисел (модуль 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)

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

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

# Для вывода строк используем функцию 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(), вывести текст на консоль. А для закрепления напишем небольшую программу