Типы данных

global ключевое слово

Мы можем получить доступ к глобальной переменной внутри функции. Но мы не можем это изменить. Мы должны использовать ключевое слово чтобы изменить значение глобальной переменной внутри функции.

name = "Python"

def foo():
    print(name)

foo()
print(name)

# Output
# Python
# Python

Посмотрим, что произойдет, когда мы попытаемся изменить значение внутри функции.

>>> name = "Python"
>>> def foo():
...     print(name)
...     name = "Java"
... 
>>> 
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'name' referenced before assignment
>>> 
>>> print(name)
Python
>>> 

Причина проста. Когда мы используем оператор присваивания для изменения значения «name», он начинает обрабатываться как локальная переменная. Таким образом, доступ к нему внутри функции print() сбрасывает, потому что он не определен в этот момент.

Давайте используем ключевое слово global, чтобы изменить значение глобальной переменной.

>>> name = "Python"
>>> 
>>> def foo():
...     global name
...     print(name)
...     name = "Java"
... 
>>> print(name)
Python
>>> foo()
Python
>>> print(name)
Java
>>> 

Как объявить переменную в Python?

Python — это язык с динамической типизацией. Нам не нужно указывать тип переменной при ее объявлении. Переменная определяется знаком равенства. Левая часть содержит имя переменной, а правая часть — значение.

Давайте посмотрим на несколько примеров объявления.

x = 1  # number
s = "Hello"  # string
t = (1, 2)  # tuple
l =   # list
d = {"1": "A", "2": "B"}  # dictionary

Python также поддерживает множественное назначение. Мы можем определить несколько переменных одновременно, используя множественное присваивание.

a = b = c = 100
print(a, b, c)  # 100 100 100

Мы также можем присвоить последовательность списку переменных. В этом случае количество элементов в последовательности должно быть равно количеству переменных.

a, b, c = 1, 2, "Hello"
print(a, b, c)  # 1 2 Hello

a, b, c = (1, 2, 3)
print(a, b, c)  # 1 2 3

a, b, c = 
print(a, b, c)  # 1 2 3

a, b, c = "098"
print(a, b, c)  # 0 9 8

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

>>> a,b = (1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>> 
>>> a,b,c,d = (1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
>>> 

Создание списков на Python

  • Создать список можно несколькими способами. Рассмотрим их.

1. Получение списка через присваивание конкретных значений

Так выглядит в коде Python пустой список:

s =   # Пустой список

Примеры создания списков со значениями:

l = 25, 755, -40, 57, -41   # список целых чисел
l = 1.13, 5.34, 12.63, 4.6, 34.0, 12.8   # список из дробных чисел
l = "Sveta", "Sergei", "Ivan", "Dasha"   # список из строк
l = "Москва", "Иванов", 12, 124   # смешанный список
l = , , , 1, , 1, 1, 1,    # список, состоящий из списков
l = 's', 'p', 'isok', 2 # список из значений и списка

2. Списки при помощи функции List()

Получаем список при помощи функции List()

empty_list = list() # пустой список
l = list ('spisok')  # 'spisok' - строка
print(l) # - результат - список

4. Генераторы списков

  • В python создать список можно также при помощи генераторов, — это довольно-таки новый метод:
  • Первый простой способ.

Сложение одинаковых списков заменяется умножением:

# список из 10 элементов, заполненный единицами
l = 1*10
# список l = 

Второй способ сложнее.

l = i for i in range(10)
# список l = 

или такой пример:

c = c * 3 for c in 'list'
print (c) # 

Пример:
Заполнить список квадратами чисел от 0 до 9, используя генератор списка.

Решение: 

l = i*i for i in range(10)

еще пример:

l = (i+1)+i for i in range(10)
print(l) # 

Случайные числа в списке:

from random import randint 
l = randint(10,80) for x in range(10)
# 10 чисел, сгенерированных случайным образом в диапазоне (10,80)

Задание Python 4_1:
Создайте список целых чисел от -20 до 30 (генерация).

Результат:

Задание Python 4_2:
Создайте список целых чисел от -10 до 10 с шагом 2 (генерация list).

Результат:

Задание Python 4_3:
Создайте список из 20 пятерок (генерация).

Результат:

Задание Python 4_4:
Создайте список из сумм троек чисел от 0 до 10, используя генератор списка (0 + 1 + 2, 1 + 2 + 3, …).

Результат:

Задание Python 4_5 (сложное):
Заполните массив элементами арифметической прогрессии. Её первый элемент, разность и количество элементов нужно ввести с клавиатуры.
  
* Формула для получения n-го члена прогрессии: an = a1 + (n-1) * d

Простейшие операции над списками

  • Списки можно складывать (конкатенировать) с помощью знака «+»:
l = 1, 3 + 4, 23 + 5
 
# Результат:
# l = 
33, -12, 'may' + 21, 48.5, 33 # 

или так:

a=33, -12, 'may'
b=21, 48.5, 33
print(a+b)# 

Операция повторения:

,,,1,1,1 * 2 # , , , , , ]

Пример:
Для списков операция переприсваивания значения отдельного элемента списка разрешена!:

a=3, 2, 1
a1=;
print(a) # 

Можно!

Задание 4_6:
В строке записана сумма натуральных чисел: ‘1+25+3’. Вычислите это выражение. Работать со строкой, как со списком.

Начало программы:

s=input('введите строку')
l=list(str(s));

Как узнать длину списка?

Функция print

Функция print выводит переданные в неё аргументы в стандартный поток вывода. Что же такое стандартный поток вывода? Standart output или stdout называется потоком вывода, местом, куда мы выводим наш текстовый контент. По умолчанию стандартный поток вывода равен sys.stdout и поэтому вывод осуществляется в консоль.

Функция print все переданные в неё аргументы в стандартный поток вывода. Например:

print(1)
print(‘Hello world!’)
print(False)
print(1.5, 2.0, 10, True, ‘username’)
print(‘Hello’ + ‘ ‘ + ‘world’ + ‘!’)
# 1
# Hello world!
# False
# 1.5 2.0 10 True username
# Hello world!

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

# Во-первых:
print(1)
print(2)
# 1
# 2
# Во-вторых:
print(‘Hello’, ‘world’)
# Hello world

В обоих случаях мы можем изменить стандартное поведение. Рассмотрим первый параметр функции print — end, в него передается строка, которая напечатается после всех аргументов функции print.

print(1, end=’ ‘)
print(2, end=’ ‘)
print(3, end=’ ‘)
# 1 2 3

print(1, end=»-»)
print(2, end=’-‘)
print(3, end=»-»)
# 1-2-3-

print(1, end=’-я выведусь после первого print-‘)
print(2, end=’-a я после второго-‘)
print(3, end=’-я выведусь после третьего-‘)
# 1-я выведусь после первого print-2-a я после второго-3-я выведусь после третьего-

Рассмотрим второй параметр функции print — sep, sep от английского separator (разделитель). По умолчанию параметр sep равен ‘ ‘. Время для экспериментов ╰(▔∀▔)╯.

print(1, 2, 3, 4)
print(1, 2, 3, 4, sep=’+++’)
print(1, 2, 3, 4, sep=’разделитель’)
print(1, 2, 3, 4, sep='(◕‿◕)’)
print(1, 2, 3, 4, sep='(ノ◕ヮ◕)ノ*:・゚✧’)
# 1 2 3 4
# 1+++2+++3+++4
# 1разделитель2разделитель3разделитель4
# 1(◕‿◕)2(◕‿◕)3(◕‿◕)4
# 1(ノ◕ヮ◕)ノ*:・゚✧2(ノ◕ヮ◕)ノ*:・゚✧3(ノ◕ヮ◕)ノ*:・゚✧4

Решение задач

1. Поэкспериментируйте с переводом в различные типы данных

2. Пользователь вводит свое имя и фамилию. Выведите:

Hello, имя фамилия
# На месте слов с % должны быть введенные данные

3. Посчитайте сумму трех введенных целых чисел

4. Посчитайте сумму трех введенных дробных чисел. Подумайте в какой тип данных нужно преобразовать значение, возвращенное функцией input

5. Дано число, выведите предыдущее и следущее за ним числа в таком формате:

# Число равно 10

Число предшествующее числу 10 равно 9

Число следующее за числом 10 равно 11

6. Вводятся имя и возраст. Выведите, где введенное имя = Максим, а возраст = 20

Привет, Максим! Ваш возраст равен 20!

Вложенные циклы

Итак, мы с вами
рассмотрели два оператора циклов: while и for. Все эти циклы
можно комбинировать друг с другом. То есть, создавать вложенные циклы (цикл
внутри цикла).

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

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

Тогда мы делаем первый цикл от 1 до N и вложенный от
1 до M

A =  1,2,3, 4,5,6 
N=2; M=3
for i in range(N):
    for j in range(M):
       print(Aij)
    print()

Или для подсчета
вот такой двойной суммы ряда

Программа будет выглядеть так:

S=; M=10; N=5
for i in range(1,N+1):
    for j in range(1,M+1):
        S += i*j
print(S)

Мы здесь сначала
пробегаем все значения j от 1 до M при
фиксированном i=1, затем,
значение i увеличивается
на 1, становится 2 и при этом i снова пробегаются значения j от 1 до M. И так пока i не превысит
значение N. То есть,
второй цикл вложен вот в этот первый. И таких вложений можно делать сколько
угодно.

Вот так работают
операторы циклов в Python и теперь вы знаете как их можно
применять на практике.

Видео по теме

Python 3 #1: установка и запуск интерпретатора языка

Python 3 #2: переменные, оператор присваивания, типы данных

Python 3 #3: функции input и print ввода/вывода

Python 3 #4: арифметические операторы: сложение, вычитание, умножение, деление, степень

Python 3 #5: условный оператор if, составные условия с and, or, not

Python 3 #6: операторы циклов while и for, операторы break и continue

Python 3 #7: строки — сравнения, срезы строк, базовые функции str, len, ord, in

Python 3 #8: методы строк — upper, split, join, find, strip, isalpha, isdigit и другие

Python 3 #9: списки list и функции len, min, max, sum, sorted

Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear

Python 3 #11: списки — инструмент list comprehensions, сортировка методом выбора

Python 3 #12: словарь, методы словарей: len, clear, get, setdefault, pop

Python 3 #13: кортежи (tuple) и операции с ними: len, del, count, index

Python 3 #14: функции (def) — объявление и вызов

Python 3 #15: делаем «Сапер», проектирование программ «сверху-вниз»

Python 3 #16: рекурсивные и лямбда-функции, функции с произвольным числом аргументов

Python 3 #17: алгоритм Евклида, принцип тестирования программ

Python 3 #18: области видимости переменных — global, nonlocal

Python 3 #19: множества (set) и операции над ними: вычитание, пересечение, объединение, сравнение

Python 3 #20: итераторы, выражения-генераторы, функции-генераторы, оператор yield

Python 3 #21: функции map, filter, zip

Python 3 #22: сортировка sort() и sorted(), сортировка по ключам

Python 3 #23: обработка исключений: try, except, finally, else

Python 3 #24: файлы — чтение и запись: open, read, write, seek, readline, dump, load, pickle

Python 3 #25: форматирование строк: метод format и F-строки

Python 3 #26: создание и импорт модулей — import, from, as, dir, reload

Python 3 #27: пакеты (package) — создание, импорт, установка (менеджер pip)

Python 3 #28: декораторы функций и замыкания

Python 3 #29: установка и порядок работы в PyCharm

Python 3 #30: функция enumerate, примеры использования

Файлы в Python

В целом различают два типа файлов (и работы с ними):

  • текстовые файлы со строками неопределенной длины;
  • двоичные (бинарные) файлы (хранящие коды таких данных, как, например, рисунки, звуки, видеофильмы);

Этапы работы с файлом:

  1. открытие файла;
  • режим чтения,
  • режим записи,
  • режим добавления данных.

работа с файлом;
закрытие файла.

В python открыть файл можно с помощью функции open с двумя параметрами:

  • имя файла (путь к файлу);
  • режим открытия файла:
  • «r» – открыть на чтение,
  • «w» – открыть на запись (если файл существует, его содержимое удаляется),
  • «a» – открыть на добавление.

В коде это выглядит следующим образом:

Fin = open ( "input.txt" ) 
Fout = open ( "output.txt", "w" ) 
  # работа с файлами 
Fout.close() 
Fin.close()

Работа с текстовыми файлами в Питон

Чтение из файла происходит двумя способами:

  1. построчно с помощью метода readline:

файл input.txt:
1
2
3

str1 = Fin.readline() # str1 = 1
str2 = Fin.readline() # str2 = 2

метод read читает данные до конца файла:

файл input.txt:
1
2
3

str = Fin.read() 
''' 
str = 1
2
3
'''

Для получения отдельных слов строки используется метод split, который по пробелам разбивает строку на составляющие компоненты:

str = Fin.readline().split()
print(str)
print(str1)

Пример:
В файле записаны два числа. Необходимо суммировать их.

файл input.txt:
12 17

ответ:
27

Решение: 

  1. способ:
Fin = open ( "D:/input.txt" ) 
str = Fin.readline().split()
x, y = int(str), int(str1)
print(x+y)

способ:

...
x, y = int(i) for i in s
print(x+y)

* Функция int преобразует строковое значение в числовое.

В python метод write служит для записи строки в файл:

Fout = open ( "D:/out.txt","w" ) 
Fout.write ("hello")

Запись в файл можно осуществлять, используя определенный
шаблон вывода. Например:

Fout.write ( "{:d} + {:d} = {:d}\n".format(x, y, x+y) )

В таком случае вместо шаблонов {:d} последовательно подставляются значения параметров метода format (сначала x, затем y, затем x+y).

Аналогом «паскалевского» eof (если конец файла) является обычный способ использования цикла while или с помощью добавления строк в список:

  1. while True: 
       str = Fin.readline() 
       if not str: break
  2. Fin = open ( "input.txt" ) 
    lst = Fin.readlines() 
    for str in lst: 
        print ( str, end = "" ) 
    Fin.close()
  3. подходящий способ для Python:
for str in open ( "input.txt" ): 
   print ( str, end = "" )

Задание Python 9_1:
Считать из файла input.txt 10 чисел (числа записаны через пробел). Затем записать их произведение в файл output.txt.

Рассмотрим пример работы с массивами.

Пример:
Считать из текстового файла числа и записать их в другой текстовый файл в отсортированном виде.

Решение: 

  • Поскольку в Python работа с массивом осуществляется с помощью структуры список, то количество элементов в массиве заранее определять не нужно.
  • Считывание из файла чисел:
lst =  
while True:
   st = Fin.readline() 
   if not st: break 
   lst.append (int(st))

Сортировка.
Запись отсортированного массива (списка) в файл:

Fout = open ( "output.txt", "w" ) 
Fout.write (str(lst)) # функция str преобразует числовое значение в символьное
Fout.close()

Или другой вариант записи в файл:

for x in lst: 
    Fout.write (str(x)+"\n") # запись с каждой строки нового числа

Задание Python 9_2:
В файле записаны в целые числа. Найти максимальное и минимальное число и записать в другой файл.

Задание Python 9_3:
В файле записаны в столбик целые числа. Отсортировать их по возрастанию суммы цифр и записать в другой файл.

Рассмотрим на примере обработку строковых значений.

Пример:
В файл записаны сведения о сотрудниках некоторой фирмы в виде:

Иванов 45 бухгалтер

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

Решение: 

  • Поскольку сведения записаны в определенном формате, т.е. вторым по счету словом всегда будет возраст, то будем использовать метод split, который разделит слова по пробелам. Под номером 1 в списке будет ити возраст:
st = Fin.readline() 
data = st.split() 
stAge = data1 
intAge = int(stAge)

Более короткая запись будет выглядеть так:

st = Fin.readline() 
intAge = int(st.split()1)

Программа выглядит так:

while True: 
  st = Fin.readline() 
  if not s: break 
  intAge = int (st.split()1)

Но лучше в стиле Python:

for st in open ( "input.txt" ): 
   intAge = int (st.split()1) 
   if intAge < 40: 
      Fout.write (st)

Задание Python 9_4:
В файл записаны сведения о детях детского сада:

Иванов иван 5 лет

Необходимо записать в текстовый файл самого старшего и самого младшего.

Как напечатать тип?

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

count = 1  # number
print(type(count))
str_message = "Hello"  # string
print("str_message type is", type(str_message))
tuple_ints = (1, 2)  # tuple
print("tuple_ints type is", type(tuple_ints))
list_of_numbers =   # list
print(type(list_of_numbers))
numbers_letters_dict = {"1": "A", "2": "B"}  # dictionary
print("numbers_letters_dict type is", type(numbers_letters_dict))

Вывод:

<class 'int'>
str_message type is <class 'str'>
tuple_ints type is <class 'tuple'>
<class 'list'>
numbers_letters_dict type is <class 'dict'>

Операторы присваивания Python

Оператор «=» присваивает значение, расположенное справа, переменной слева. Например, v = 23 присваивает значение числа 23 переменной v.

В программировании часто используют составные операторы присваивания. Они соединяют арифметический оператор с оператором «=». Поэтому для сложения мы используем оператор «+» с оператором «=», чтобы получить составной оператор «+=». Пример:

w = 5
w += 1
print(w)

Вывод

6

Сначала мы задаём переменной  значение . Затем используем составной оператор присваивания , чтобы прибавить число справа, к переменной, расположенной слева, и присвоить результат переменной .

Составные операторы присваивания часто используются в циклах for:

for x in range (0, 7):
    x *= 2
    print(x)

Вывод

0
2
4
6
8
10
12

При помощи for можно автоматизировать процесс использования оператора «. Он умножает переменную на число , а затем присваивает полученный результат переменной  для следующей итерации цикла.

В Python предусмотрен составной оператор присваивания для каждой арифметической операции:

y += 1          # добавить число и присвоить результат
y -= 1          # отнять число и присвоить результат
y *= 2          # умножить на число и присвоить результат
y /= 3          # разделить на число и присвоить результат
y // = 5        # разделить без остатка на число и присвоить результат
y **= 2         # возвести в степень и присвоить результат
y %= 3          # вернуть остаток от деления и присвоить результат

Составные операторы присваивания полезны в тех случаях, когда переменная должна увеличиваться или уменьшаться с помощью инкремента. А также когда необходимо автоматизировать некоторый процесс в создаваемой программе.

Практическая работа

В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.

Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции . В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция , тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция , ее тело содержит выражение вывода на экран слова «Отрицательное».

Понятно, что вызов должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения и предшествовать или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.

Часть I: Коллекции: Списки / массивы

  • В языке Python отсутствует такая структура, как «массив». Для работы с массивами используются списки.
  • Cписки — это изменяемые последовательности в отличие от строк.
  • Представим строку как объект в памяти, в этом случае, когда над строкой выполняются операции конкатенации и повторения, то сама строка не меняется, но в результате выполнения операции в другом месте памяти создается другая строка.Пример:
    Так, например, в Питоне нельзя переприсваивать значение для отдельных символов строки.Программа выдаст ошибку!
s="aaa";
s1="b";
print(s1)

Изменять строку можно только, работая с ней, как с объектом (метод , например):

s1="breKeKeKeKs"; 
s1=s1.replace('Ke','XoXo',2) 
s1 # breXoXoXoXoKeKs

8 ответов

Лучший ответ

Нет, обычный способ —

В вашем случае вы можете использовать , если хотите, чтобы они были целыми числами, а не строками

Не используйте для этого. Посмотрим, что произойдет, если пользователь вводит

29

John La Rooy
19 Окт 2009 в 11:02

Вы можете использовать этот метод для ввода входных данных в одну строку

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

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

И взять список в качестве входных данных

Amber Bhanarkar
19 Янв 2020 в 13:38

Или ты можешь сделать это

Tunaki
27 Янв 2016 в 12:09

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

1

Bart Van Loon
19 Окт 2017 в 22:23

Вы можете прочитать 2 значения типа int, используя это в python 3.6.1

1

Sai Gopi Me
29 Авг 2017 в 01:43

Сначала прочитайте всю строку в строку вроде

Затем используйте цикл for, как это

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

1

Pinkoo
28 Фев 2015 в 05:18

Я новичок в этом деле. Сделал небольшое исследование с сайта python.org и немного взломал, чтобы заставить это работать. Функция raw_input снова вернулась, вместо input . Вот что я придумал:

Конечно, код не такой элегантный, как однострочные, использующие scanf в C или cin в C ++. Код Python ближе к Java (который использует совершенно другой механизм, чем C, C ++ или Python), так что каждая переменная должна рассматриваться отдельно.

В Python функция raw_input получает символы с консоли и объединяет их в одну строку в качестве выходных данных. Когда в левой части оператора присваивания находится только одна переменная, функция split разбивает эту строку на список из String .

В нашем случае, когда мы ожидаем две переменные, мы можем получить значения в них, используя разделенный запятыми список их идентификаторов. Значения String затем присваиваются перечисленным переменным. Если мы хотим выполнить арифметику с этими значениями, нам нужно преобразовать их в числовой тип данных int (или float ), используя встроенный в Python int Функция strong> или float .

Я знаю, что эта публикация является ответом на очень старую публикацию, и, возможно, знания уже давно стали «общеизвестными». Тем не менее, я был бы признателен за публикацию, подобную этой, а не за то, что мне пришлось потратить несколько часов на поиск и взлом, пока я не придумал, как мне казалось, самое элегантное решение, которое можно представить в классе CS1.

5

Professor Richard
2 Янв 2015 в 21:58

Вы также можете прочитать из sys.stdin

10

MAK
19 Окт 2009 в 18:04

sys.stdin

Модуль Python предоставляет нам все три файловых объекта для stdin, stdout и stderr. В качестве объекта входного файла мы используем . Это похоже на файл, где вы можете открывать и закрывать его, как и любые другие файлы в Python.

Давайте разберемся на простом примере:

import sys

stdin_fileno = sys.stdin

# Keeps reading from stdin and quits only if the word 'exit' is there
# This loop, by default does not terminate, since stdin is open
for line in stdin_fileno:
    # Remove trailing newline characters using strip()
    if 'exit' == line.strip():
        print('Found exit. Terminating the program')
        exit(0)
    else:
        print('Message from sys.stdin: ---> {} <---'.format(line))

Вывод

Hi
Message from sys.stdin: ---> Hi
 <---
Hello from AskPython
Message from sys.stdin: ---> Hello from AskPython
 <---
exit
Found exit. Terminating the program

Выше фрагмент кода продолжает чтение входных данных из и выводит сообщение на консоли ( ) до тех пор , слово не встречаются.

Примечание. Обычно мы не закрываем объект файла по умолчанию, хотя это разрешено. Итак, — допустимый код Python.

Теперь, когда мы немного знаем о , перейдем к .

Доступ к элементам

Мы можем получить доступ к элементам списка с помощью index. Значение индекса начинается с 0.

>>> vowels_list = 
>>> vowels_list
'a'
>>> vowels_list
'u'

Если индекс не входит в диапазон, возникает IndexError.

>>> vowels_list
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> 

Мы также можем передать отрицательное значение индекса. В этом случае элемент возвращается от конца к началу. Допустимый диапазон значений индекса — от -1 до — (длина).

Это полезно, когда нам нужен определенный элемент быстро, например, последний элемент, второй последний элемент и т. д.

>>> vowels_list = 
>>> vowels_list  # last element
'u'
>>> vowels_list  # second last element
'e'
>>> vowels_list
'a'

Примеры создания и изменения классов «на лету» при помощи type():

Например, следующие два определения создают идентичные объекты.

>>> class Foo(object):
...       bar = True
>>> Foo = type('Foo', (), {'bar'True})

Класс , созданный через метакласс можно использовать как обычный класс:

>>> Foo
# <class '__main__.Foo'>
>>> f = Foo()
>>> f.bar
# True

# можно наследоваться от него
>>>   class FooChild(Foo): pass
...
>>> FooChild
# <class '__main__.FooChild'>
>>> FooChild.bar # bar унаследован от Foo
# True

Добавим методы в класс . Для этого определим функцию и добавим ее как атрибут.

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar' echo_bar})
>>> hasattr(Foo, 'echo_bar')
# False
>>> hasattr(FooChild, 'echo_bar')
# True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
# True

# после динамического создания класса добавим еще один метод 
>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
# True
Добавить комментарий

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

Adblock
detector