Bool object is not iterable ошибка

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

Да, в операциях с различными типами чисел или же в условных инструкциях и выражениях интерпретатор неявно (автоматически) преобразует объекты к общему типу. Однако в большинстве случаев это
не так, поэтому следует внимательно следить за текущим типом переменной и при необходимости самостоятельно осуществлять явное приведение к нужному типу.

Приведением типа называется процесс преобразования значения одного типа данных в значение другого типа.

Как уже упоминалось ранее, для преобразования различных типов данных между собой в Python доступен целый ряд встроенных функций (конструкторов типов):

• bool() – приведение к логическому типу,
• int() – приведение к целочисленному типу,
• float() – приведение к вещественному типу,
• complex() – приведение к комплексному числу,
• str() – приведение к строковому типу,
• tuple() – приведение к кортежу,
• list() – приведение к списку,
• dict() – приведение к словарю,
• set() – приведение к множеству.

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

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

Во время преобразования к типу bool (логический тип данных) следующие значения рассматриваются как
False:

• само значение False,
• значение None,
• нулевые числовые значения 0, 0.0 и 0+0j,
• пустая строка «»,
• пустые объекты: [], tuple(), {}, dict().

Все остальные значения преобразуются в значение True, включая число -1, поскольку оно представляет собой обычное
отрицательное число, отличное от нуля (см. пример №1). Тоже самое касается коллекций с одним нулевым значением, например,
[0], {0.0}, (0,), а также непустых строк, например,
‘0’ или ‘0.0’.

# False.        
print('bool(None):', bool(None))       
# False.        
print('bool(0):', bool(0))         
# False.        
print('bool(0.0):', bool(0.0))        
# False.        
print('bool(0+0j):', bool(0+0j))        
# False.        
print('bool(""):', bool(''))        
# False.        
print('bool([]):', bool([]))        
# False.        
print('bool({}):', bool({}))        
# False.        
print('bool(tuple()):', bool(tuple()))        
# False.        
print('bool(dict()):', bool(dict()))        

print()

# True.        
print('bool("0"):', bool('0'))        
# True.        
print('bool(-1):', bool(-1)) 
# True.        
print('bool([False]):', bool([False])) 
# True.        
print('bool({0,}):', bool({0,}))        
# True.        
print('bool((0,)):', bool((0,)))

bool(None): False
bool(0): False
bool(0.0): False
bool(0+0j): False
bool(""): False
bool([]): False
bool({}): False
bool(tuple()): False
bool(dict()): False

bool("0"): True
bool(-1): True
bool([False]): True
bool({0,}): True
bool((0,)): True














		
			

Пример №1. Приведение к типу bool.

В случае приведения к типу int (целые числа):

• Логическое значение True преобразуется в 1,
  False – в 0.
• Вещественные числа просто усекаются до целой части. Например, в случае приведения вещественного числа -37.9
  к целочисленному типу оно будет преобразовано в число -37.
• Если строка содержит верную запись целого числа в десятичной системе счисления, то интерпретатор в процессе приведения строки к целочисленному типу вернет это число.
• Если строка num_str содержит верное представлением целого числа в системе счисления с указанным основанием base,
  то преобразовать ее можно в целое число при помощи конструктора типа с двумя аргументами int(num_str, base=10)
  (подробнее здесь).

Для других типов данных приведение к целочисленному типу не определено, поэтому попытка такого преобразования приведет к ошибке (см. пример №2).

# 1.        
print('int(True): ', int(True))          
# 0.        
print('int(False): ', int(False))       
# 53.        
print('int("+53"): ', int('+53'))            
# -7.        
print('int(-7.33): ', int(-7.33))        
# 0.        
print('int(.33): ', int(.33))        

# int() argument must be a ...        
# print('int(5.2+1.3j): ', int(5.2+1.3j))        
        
# int() argument must be a ...        
# print('int(None): ', int(None))         
        
# invalid literal for ...        
# print('int(""): ', int(''))        

# invalid literal for ...        
# print('int("3.7"): ', int('3.7'))         

# int() argument must be a ...        
# print('int([5]): ', int([5]))

int(True): 1
int(False): 0
int("-53"): -53
int(-7.33): -7
int(.33): 0


















		
			

Пример №2. Приведение к типу int.

В случае приведения к типу float (вещественные числа):

• Логическое значение True преобразуется в 1.0,
  False – в 0.0.
• Целые числа преобразуются в вещественные простым добавлением нулевой дробной части. Например, целое отрицательное число -37
  будет преобразовано в число -37.0.
• Если строка содержит верное представление целого числа в десятичной системе счисления, то интерпретатор в процессе приведения строки к вещественному типу вернет это число, добавив к нему
  нулевую дробную часть. При этом допускаются начальные и конечные пробельные символы, а также знаки плюса и минуса. Например, строка, содержащая запись целого отрицательного числа
  с пробелами ‘ -105 ‘ будет преобразовано в число -105.0.
• Если строка содержит верное представление вещественного числа в десятичной системе счисления, то интерпретатор в процессе приведения строки к вещественному типу вернет это число.
  При этом допускаются начальные и конечные пробельные символы, а также знаки плюса и минуса. Например, строка, содержащая запись вещественного отрицательного числа с пробелами
  ‘ -1.5 ‘ будет преобразовано в число -1.5.
• Также строка может представлять значения ‘NaN’, ‘Infinity’ или ‘-Infinity’.

Для других типов данных приведение к вещественному типу не определено, поэтому попытка такого преобразования приведет к ошибке (см. пример №3).

# 1.0.        
print('float(True): ', float(True))          
# 0.0.        
print('float(False): ', float(False))       
# 53.0.        
print('float(" +53"): ', float(' +53'))            
# -7.33.        
print('float("-7.33"): ', float('-7.33'))        
# 0.013.        
print('float("1.3e-2 "): ', float('1.3e-2 '))        
# nan.        
print('float("NaN"): ', float('NaN'))        
# -inf.        
print('float(" -Infinity "): ', float(' -Infinity '))        

# float() argument must be a string...        
# print('float(5.2+1.3j): ', float(5.2+1.3j))        
        
# float() argument must be a string...        
# print('float(None): ', float(None))         
        
# could not convert string to float...        
# print('float(""): ', float(''))        

# float() argument must be a string...        
# print('float([5]): ', float([5]))

float(True): 1.0
float(False): 0.0
float(" +53"): 53.0
float("-7.33"): -7.33
float("1.3e-2 "): 0.013
float("NaN"): nan
float(" -Infinity "): -inf

















		
			

Пример №3. Приведение к типу float.

В случае приведения к типу complex (комплексные числа):

• Логическое значение True преобразуется в (1+0j),
  False – в 0j.
• Целые и вещественные числа преобразуются в комплексные простым добавлением нулевой мнимой части +0j. Например, отрицательное вещественное число
  -3.7 будет преобразовано в комплексное число (-3.7+0j).
• Если строка содержит верное представление комплексного числа, то интерпретатор в процессе приведения строки к комплексному типу вернет это число. При этом допускаются начальные и
  конечные пробельные символы, а также знаки плюса и минуса как перед действительной, так и мнимой частью. Однако пробелов между действительной и мнимой частями быть не должно! Например,
  строка, содержащая запись комплексного числа с пробелами ‘ -5.5+0.2j ‘ будет преобразовано в число (-5.5+0.2j).

Для других типов данных приведение к комплексному типу не определено, поэтому попытка такого преобразования приведет к ошибке (см. пример №4).

# (1+0j).        
print('complex(True):', complex(True))          
# 0j.        
print('complex(False):', complex(False))       
# (5.9-3.2j).        
print('complex(" +5.9-3.2j"):', complex(' +5.9-3.2j'))        
# (53+0j).        
print('complex(" 53"):', complex(' 53'))            
# (-7.33+0j).        
print('complex(" -7.33 "):', complex(' -7.33 '))        
# (0.013+0j).        
print('complex("1.3e-2 "):', complex('1.3e-2 '))        
# (nan+0j).        
print('complex("NaN"):', complex('NaN'))        
# (-inf+0j).        
print('complex(" -Infinity "):', complex(' -Infinity '))        
        
# complex() arg is a malformed string.       
# print('complex("5.2 + 1.3j"):', complex('5.2 + 1.3j'))        
        
# complex() first argument must be...        
# print('complex(None):', complex(None))         
        
# complex() arg is a malformed string.        
# print('complex(""):', complex(''))        

# complex() first argument must be...        
# print('complex([5]):', complex([5]))

complex(True): (1+0j)
complex(False): 0j
complex(" +5.9-3.2j"): (5.9-3.2j)
complex(" 53"): (53+0j)
complex(" -7.33 "): (-7.33+0j)
complex("1.3e-2 "): (0.013+0j)
complex("NaN"): (nan+0j)
complex(" -Infinity "): (-inf+0j)


















		
			

Пример №4. Приведение к типу complex.

В случае приведения к типу str (строки) интерпретатор просто вернет строковое представление объекта, которое представлено методом приводимого объекта
object.__str__() (см. пример №5).

# True.        
print('str(True):', str(True))          
# False.        
print('str(False):', str(False))       
# (5.9-3.2j).        
print('str+5.9-3.2j:', str(+5.9-3.2j))        
# 53.        
print('str(53):', str(+53))            
# -7.33.        
print('str(-7.33):', str(-7.33))        
# 0.013.        
print('str(1.3e-2):', str(1.3e-2))        
# None.        
print('str(None):', str(None))        
# [0.5, 1,5].        
print('str([0.5, 1,5]):', str([0.5, 1,5]))                
# {'one', 'two'}.        
print("str({'one', 'two'}):", str({'one', 'two'}))                 
# (2, '3').        
print("str((2, '3')):", str((2, '3')))        
# {1: [2, True]}.        
print('str({1: [2, True]}):', str({1: [2, True]}))

str(True): True
str(False): False
str+5.9-3.2j: (5.9-3.2j)
str(53): 53
str(-7.33): -7.33
str(1.3e-2): 0.013
str(None): None
str([0.5, 1,5]): [0.5, 1, 5]
str({'one', 'two'}): {'one', 'two'}
str((2, '3')): (2, '3')
str({1: [2, True]}): {1: [2, True]}









		
			

Пример №5. Приведение к типу str.

К типу tuple (кортежи) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в кортежи с ключами, теряя свои значения
(см. пример №6).

# ('a', 'b', 'c').        
print("tuple('abc'):", tuple('abc'))         
# (1, 2, 3).        
print('tuple([1, 2, 3]):', tuple([1, 2, 3]))                
# ('one', 'two').        
print("tuple({'one', 'two'}):", tuple({'one', 'two'}))                 
# (1, 2).        
print("tuple({1: 'one', 2: 'two'}):", tuple({1: 'one', 2: 'two'}))                
# ('one', 'two').        
print("tuple({'one': 1, 'two': 2}):", tuple({'one': 1, 'two': 2}))         
# (1, 2, 3).        
print("tuple(range(1, 4)):", tuple(range(1, 4)))        

# bool object is not iterable.        
# print('tuple(True): ', tuple(True))
          
# int object is not iterable.        
# print('tuple(53): ', tuple(53))
            
# NoneType object is not iterable.        
# print('tuple(None): ', tuple(None))

tuple('abc'): ('a', 'b', 'c')
tuple([1, 2, 3]): (1, 2, 3)
tuple({'one', 'two'}): ('one', 'two')
tuple({1: 'one', 2: 'two'}): (1, 2)
tuple({'one': 1, 'two': 2}): ('one', 'two')
tuple(range(1, 4)): (1, 2, 3)













		
			

Пример №6. Приведение к типу tuple.

К типу list (списки) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в списки с ключами, теряя свои значения
(см. пример №7).

# ['a', 'b', 'c'].        
print("list('abc'):", list('abc'))         
# [1, 2, 3].        
print('list((1, 2, 3)):', list((1, 2, 3)))                
# ['one', 'two'].        
print("list({'one', 'two'}):", list({'one', 'two'}))                 
# [1, 2].        
print("list({1: 'one', 2: 'two'}):", list({1: 'one', 2: 'two'}))                
# ['one', 'two'].        
print("list({'one': 1, 'two': 2}):", list({'one': 1, 'two': 2}))         
# [1, 2, 3].        
print("list(range(1, 4)):", list(range(1, 4)))        

# bool object is not iterable.        
# print('list(True): ', list(True))          

# int object is not iterable.        
# print('list(53): ', list(53))            

# NoneType object is not iterable.        
# print('list(None): ', list(None))

list('abc'): ['a', 'b', 'c']
list((1, 2, 3)): [1, 2, 3]
list({'one', 'two'}): ['one', 'two']
list({1: 'one', 2: 'two'}): [1, 2]
list({'one': 1, 'two': 2}): ['one', 'two']
list(range(1, 4)): [1, 2, 3]













		
			

Пример №7. Приведение к типу list.

К типу set (множества) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в множества с ключами, теряя свои значения
(см. пример №8).

# {'a', 'b', 'c'}.        
print("set('abc'):", set('abc'))         
# {1, 2, 3}.        
print('set((1, 2, 3)):', set((1, 2, 3)))                
# {1, 2}.        
print("set({1: 'one', 2: 'two'}):", set({1: 'one', 2: 'two'}))                
# {'one', 'two'}.        
print("set({'one': 1, 'two': 2}):", set({'one': 1, 'two': 2}))         
# {1, 2, 3}.        
print("set(range(1, 4)):", set(range(1, 4)))        

# bool object is not iterable.        
# print('set(True): ', set(True))          

# int object is not iterable.        
# print('set(53): ', set(53))            

# NoneType object is not iterable.        
# print('set(None): ', set(None))

set('abc'): {'b', 'a', 'c'}
set((1, 2, 3)): {1, 2, 3}
set({1: 'one', 2: 'two'}): {1, 2}
set({'one': 1, 'two': 2}): {'one', 'two'}
set(range(1, 4)): {1, 2, 3}












		
			

Пример №8. Приведение к типу set.

К типу dict (словари) напрямую могут быть преобразованы только итерируемые объекты, содержащие пары значений, в которых первые элементы становятся ключами
словаря, а вторые – его значениями. Например, это могут быть списки, кортежи или множества, содержащие в качестве своих элементов другие списки, кортежи или множества из двух элементов
(см. пример №9). При этом следует помнить, что только хешируемые (неизменяемые) объекты могут быть ключами словаря или элементами множества.

# {1: 'a', 2: 'b'}.        
print("dict([[1, 'a'], (2, 'b')]):", dict([[1, 'a'], (2, 'b')]))         
# {1: 'a', 2: 'b'}.        
print("dict([(1, 'a'), {2, 'b'}]):", dict([(1, 'a'), {2, 'b'}]))         

# {1: 'a', 2: 'b'}.        
print("dict(((1, 'a'), {2, 'b'})):", dict(((1, 'a'), {2, 'b'})))              
# {1: 'a', 2: 'b'}.        
print("dict(({1, 'a'}, [2, 'b'])):", dict(({1, 'a'}, [2, 'b'])))              

# {1: 'a', 2: 'b'}.        
print("dict({(1, 'a'), (2, 'b')}):", dict({(1, 'a'), (2, 'b')}))        


# unhashable type: list (списки не могут быть ключами).        
# print("dict([[[1], 'a'], (2, 'b')]):", dict([[[1], 'a'], (2, 'b')]))        

# unhashable type: list (список - недопустимый эл-т мн-ва).        
# print("dict({[1, 'a'], (2, 'b')}):", dict({[1, 'a'], (2, 'b')}))                

# dictionary update sequence element #0 has length 3; 2 is required.        
# print("dict([(1, 'a'), {2, 'b'}]):", dict([(1, 'a', 3), {2, 'b'}]))        

# bool object is not iterable.        
# print('dict(True): ', dict(True))

dict([[1, 'a'], (2, 'b')]): {1: 'a', 2: 'b'}
dict([(1, 'a'), {2, 'b'}]): {1: 'a', 2: 'b'}
dict(((1, 'a'), {2, 'b'})): {1: 'a', 2: 'b'}
dict(({1, 'a'}, [2, 'b'])): {1: 'a', 2: 'b'}
dict({(1, 'a'), (2, 'b')}): {2: 'b', 1: 'a'}


















		
			

Пример №9. Приведение к типу dict.

• Для преобразования различных типов данных между собой в Python доступен целый ряд встроенных функций (конструкторов типов):
  bool() – приведение к логическому типу, int() – приведение к целочисленному типу,
  float() – приведение к вещественному типу, complex() – приведение к комплексному числу,
  str() – приведение к строковому типу, tuple() – приведение к кортежу,
  list() – приведение к списку, dict() – приведение к словарю,
  set() – приведение к множеству.
• В операциях, например, с различными типами чисел или же в условных инструкциях и выражениях интерпретатор неявно (автоматически) преобразует объекты к общему типу. Однако в большинстве
  случаев это не так, поэтому следует внимательно следить за текущим типом переменной и при необходимости самостоятельно осуществлять явное приведение к нужному типу.

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

• Доступ ко всем ответам на вопросы и решениям задач.
• Возможность загрузки учебных кодов и программ на свой компьютер.
• Доступ ко всем тренажерам и видеоурокам (когда появятся).
• Возможность внести свой скромный вклад в развитие проекта и мира во всем мире,
  а также выразить свою благодарить автору за его труд. Нам очень нужна ваша поддержка!

На страницу подписки

4. В каких случаях интерпретатор возбудит ошибки?

Показать решение.

print(bool([False]))     

print(int('7.5'))         

print(float(None))          
                       
print(float('0.55'))          
        
print(str(None))          
        
print(list(range(1, 5)))            
        
print(dict([[[5], 'пять']]))             
        
print(dict([[5, 'пять']]))

# True.        
print('bool([False]):', bool([False]))     

# invalid literal for ...        
# print('int("7.5"): ', int('7.5'))         

# float() argument must be a string...        
# print('float(None): ', float(None))          
                       
# 0.55.        
print('float("0.55"): ', float('0.55'))          
        
# None.        
print('str(None):', str(None))          
        
# [1, 2, 3, 4].        
print("list(range(1, 5)):", list(range(1, 5)))            
        
# unhashable type: list (списки не могут быть ключами).        
# print("dict([[[5], 'пять']]):", dict([[[5], 'пять']]))             
        
# {5: 'пять'}.        
print("dict([[5, 'пять']]):", dict([[5, 'пять']]))

bool([False]): True
float("0.55"):  0.55
str(None): None
list(range(1, 5)): [1, 2, 3, 4]
dict([[5, 'пять']]): {5: 'пять'}