Как изменить true на false питон

What operation do I need to do to always get a False value to become True or to get a True value to become False? In other words, what do I do to switch the Boolean value of a given variable?

What operation do I need to do to always get a False value to become True or to get a True value to become False?
In other words, what do I do to switch the Boolean value of a given variable?

    new_dict = {}
    for i in range(1, 101):
        new_dict[i] = False

    i = 2
    while i < 101:
        for x in range(1, 101):
            if new_dict[x] % i == 0:
                a = new_dict[x]
                new_dict[x] = not a
        i += 1
    for a in new_dict:
        print 'Light #%d --> %r' % (a, new_dict[a])

The output below is only True. From this, I understand that what I did for some reason is not changing every other value to False. Why is this happening?

Does anyone have any idea why?

    Light #1 --> True
    Light #2 --> True
    Light #3 --> True
    Light #4 --> True
    Light #5 --> True
    Light #6 --> True
    Light #7 --> True
    Light #8 --> True
    Light #9 --> True
    Light #10 --> True
    Light #11 --> True
    Light #12 --> True
    Light #13 --> True
    Light #14 --> True
    Light #15 --> True
    Light #16 --> True
    Light #17 --> True
    Light #18 --> True
    Light #19 --> True
    Light #20 --> True
    Light #21 --> True
    Light #22 --> True
    Light #23 --> True
    Light #24 --> True
    Light #25 --> True
    Light #26 --> True
    Light #27 --> True
    Light #28 --> True
    Light #29 --> True
    Light #30 --> True
    Light #31 --> True
    Light #32 --> True
    Light #33 --> True
    Light #34 --> True
    Light #35 --> True
    Light #36 --> True
    Light #37 --> True
    Light #38 --> True
    Light #39 --> True
    Light #40 --> True
    Light #41 --> True
    Light #42 --> True
    Light #43 --> True
    Light #44 --> True
    Light #45 --> True
    Light #46 --> True
    Light #47 --> True
    Light #48 --> True
    Light #49 --> True
    Light #50 --> True
    Light #51 --> True
    Light #52 --> True
    Light #53 --> True
    Light #54 --> True
    Light #55 --> True
    Light #56 --> True
    Light #57 --> True
    Light #58 --> True
    Light #59 --> True
    Light #60 --> True
    Light #61 --> True
    Light #62 --> True
    Light #63 --> True
    Light #64 --> True
    Light #65 --> True
    Light #66 --> True
    Light #67 --> True
    Light #68 --> True
    Light #69 --> True
    Light #70 --> True
    Light #71 --> True
    Light #72 --> True
    Light #73 --> True
    Light #74 --> True
    Light #75 --> True
    Light #76 --> True
    Light #77 --> True
    Light #78 --> True
    Light #79 --> True
    Light #80 --> True
    Light #81 --> True
    Light #82 --> True
    Light #83 --> True
    Light #84 --> True
    Light #85 --> True
    Light #86 --> True
    Light #87 --> True
    Light #88 --> True
    Light #89 --> True
    Light #90 --> True
    Light #91 --> True
    Light #92 --> True
    Light #93 --> True
    Light #94 --> True
    Light #95 --> True
    Light #96 --> True
    Light #97 --> True
    Light #98 --> True
    Light #99 --> True
    Light #100 --> True

The question here How do I get the opposite (negation) of a Boolean in Python? and here python how to «negate» value : if true return false, if false return true seem to be the same but in my case, that simple concept is simply not working…

Thanks, I really appreciate all the help guys!!!

Источник

Содержание:развернуть

  • Преобразования

  • Другие типы → bool

  • bool → str

  • bool → int

  • Логический тип и операторы

Логический тип данных (bool) (или булевый тип) это примитивный тип данных, который принимает 2 значения — истина или ложь.

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

  • True — истина;
  • False — ложь.

True и False пишутся с большой буквы. Если написать с маленькой true, интерпретатор выдаст ошибку: NameError: name 'true' is not defined

True и False являются экземплярами класса bool который в свою очередь является подклассом int Поэтому True и False в Python ведут себя как числа 1 и 0. Отличие только в том, как они выводятся на экран.

>>> True
True
>>> type(True)
<class 'bool'>
>>> isinstance(True, int)
True
>>> True == 1
True
>>> True + 4 # True это число 1
5
>>> 5 * False # False это число 0
0

boolobject.c содержит реализацию булевого типа в CPython.

Часто логический тип данных используется в ветвлениях if. Если результат выполнения True — выполняется соответствующая ветка.

>>> a = 10
>>> if a < 0:
print("меньше 0")
elif a == 0:
print("равно 0")
else:
print("больше 0")

больше 0

Цикл while работает аналогичным образом — цикл выполняется до тех пор, пока логическое выражение True.

>>> count = 5
>>> while count:
print("count = {}".format(count))
count -= 1

count = 5
count = 4
count = 3
count = 2
count = 1

Преобразования

Другие типы → bool

В Python для приведения других типов данных к булевому типу, используется функция bool() Работает эта функция по следующему соглашению:

👉 Функция bool() вернет True:

  • непустая строка (в том числе если это один или несколько пробелов);
  • ненулевое число (в том числе меньшее единицы, например -5);
  • непустой список/кортеж (даже если он содержит один пустой элемент, например пустой кортеж);
  • функция.

>>> bool("python")
True
>>> bool(" ")
True
>>> bool(1)
True
>>> bool(-5)
True
>>> bool([1,2,3])
True
>>> bool((0,1))
True
>>> bool([()])
True
>>> def test():
return "test"

>>> bool(test)
True

👉 Функция bool() вернет False:

  • пустая строка;
  • нулевое число;
  • пустой список/кортеж.

>>> bool("")
False
>>> bool(0)
False
>>> bool([])
False
>>> bool(())
False

bool → str

Бывают ситуации, когда нам необходимо получить True и False в строковом представлении. Если выполнить код ниже, он вызовет ошибку:

print("answer is " + True)
TypeError: can only concatenate str (not "bool") to str

Ошибка произошла потому, что Python не выполняет неявное приведение типов (как например JavaScript), так как неявное приведение может маскировать логические ошибки.

Для вывода на экран булевого значения, необходимо привести его к строке:

>>> answer = True
>>> print("my answer is " + str(True))
my answer is True

или используйте форматирование строки:

print("my answer is {}".format(True))

bool → int

Встроенная функция int() преобразует логическое значение в 1 или 0.

>>> int(True)
1
>>> int(False)
0

Аналогичного результата можно добиться умножением логического типа на единицу:

>>> True * 1
1
>>> False * 1
0

Логический тип и операторы

Операторы — это своего рода функционал, представленный в виде символов (например + ==) или зарезервированных слов (например and not).

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

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

>>> 1 == 5
False
>>> 1 != 5
True
>>> 1 > 5
False
>>> 1 < 5
True
>>> 1 >= 5
False
>>> 1 <= 5
True

Логические операторы:

>>> (1 + 1 == 2) or (2 * 2 == 5)
True
>>> (1 + 1 == 2) and (2 * 2 == 5)
False
>>> (1 + 1 == 2) and not (2 * 2 == 5)
True

Подробно про операторы в Python:

Источник

Given a string list, convert the string truth values to Boolean values using Python.

Input : test_list = ["True", "False", "True", "False"] 
Output : [True, False, True, False] 
Explanation : String booleans converted to actual Boolean.

Method 1: Convert String to Boolean in Python using bool()

The bool() method in general takes only one parameter(here x), on which the standard truth testing procedure can be applied. If no parameter is passed, then by default it returns False.

Python3

string = "GeeksforGeeks"

bool_value = bool(string)

print(bool_value)

Output:

True

Time Complexity: O(1) -> (built-in function)

Space Complexity: O(1)

Method 2: Convert String to Boolean in Python using eval()

Python eval() function parse the expression argument and evaluate it as a Python expression and runs Python expression(code) within the program.

Python3

Output:

False

Time Complexity: O(1)

Auxiliary Space: O(1)

Method 3:  Convert String to Boolean in Python using list comprehension

In this, we check for just the true value, and the rest of the values are automatically converted to a False boolean.

Python3

test_list = ["True", "False", "TRUE",

             "FALSE", "true", "false"]

print("The original list : ",

      test_list)

res = [ele.lower().capitalize()

       == "True" for ele in test_list]

print("The converted Boolean values : ", res)

Output

The original list : ['True', 'False', 'True', 'True', 'False']
The converted Boolean values : [True, False, True, True, False]

Time Complexity: O(1)

Auxiliary Space: O(1)

Method 4:  Convert String to Boolean in Python using map() + lambda

In this, we apply the same approach, just a different way to solve the problem. The map() is used to extend the logic of values computed by the lambda function.

Python3

test_list = ["True", "False", "TRUE",

             "FALSE", "true", "false"]

print("The original list : ", test_list)

res = list(map(lambda ele: ele.lower().

               capitalize() == "True", test_list))

print("The converted Boolean values : ",res)

Output:

The original list : ['True', 'False', 'True', 'True', 'False']
The converted Boolean values : [True, False, True, True, False]

Time Complexity: O(n)

Space Complexity: O(n)

Источник

Понятие приведения типов в Python

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

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

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

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

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

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

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

Приведение к типу bool

Во время преобразования к типу 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

В случае приведения к типу 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

В случае приведения к типу 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

В случае приведения к типу 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

В случае приведения к типу 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

К типу 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

К типу 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

К типу 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

К типу 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() – приведение к множеству.
  • В операциях, например, с различными типами чисел или же в условных инструкциях и выражениях интерпретатор неявно (автоматически) преобразует объекты к общему типу. Однако в большинстве
    случаев это не так, поэтому следует внимательно следить за текущим типом переменной и при необходимости самостоятельно осуществлять явное приведение к нужному типу.

Помогите проекту, подпишитесь!

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

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

Python для начинающих
На страницу подписки

Вопросы и задания для самоконтроля

1. Каким будет результат сложения двух переменных a = 5 и b = ‘7’? А если их
перемножить?

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

Ответ. В первом случае мы получим ошибку, т.к. оператор сложения подразумевает наличие операндов одного типа, но интерпретатор в общем случае
не занимается автоматическим приведением типов, оставляя эту обязанность программистам. А вот умножение строки на число предусмотрено заранее, поэтому на выходе мы получим строку
‘77777’.

2. Приведите пример ситуации, в которой интерпретатор осуществляет неявное приведение к нужному типу.

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

Ответ. Примерами могут служить: преобразование к вещественному типу при сложении целого и вещественного числа
(5 + 0.3) или же преобразование объектов к логическому типу в условных инструкциях и выражениях (1 if ‘ok’ else 0).

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

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

Ответ. В кортежи, списки или множества при явном приведении типа могут быть преобразованы только итерируемые объекты. Преобразовать, например,
число в список не получится.

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: 'пять'}

Быстрый переход к другим страницам

Источник

Автор перевода Алексей Морозов

Значения вместо булевых переменных

В Python, как и в других языках, есть логический тип переменных bool, который имеет всего два значения: True (истина) и False (ложь). Его возвращают логические операторы (например сравнение чисел или проверка присутствия элемента в списке), и именно этот тип обычно используется в if и while. Тем не менее, явно использовать bool или операторы необязательно: существуют правила, по которым значение любого типа приводится к True или False.

Прим. пер. По-английски это называется truthy и falsy, то есть «примерно-но-не-совсем-истинные», «истинноватые» значения. Общепринятого русского перевода нет, но в этой статье под истинным или ложным значением объекта всегда подразумеваются именно эти штуки, а булевы значения везде названы True и False.

Вот как это работает:

>>> a = 5

>>> if a:
    print(a)
# Вывод
5

>>> a = 0

>>> if a:
    print(a)

# Ничего не выводится

Булев контекст

Любое значение в Python при необходимости может интерпретироваться как True или False в соответствии с правилами языка. Об этом написано и в документации:

Любой объект может быть протестирован на истинность и использован в условиях if и while, а также как операнд булевых операций (and, or, not).

Если объект используется таким образом, то он находится в булевом контексте. Грубо говоря, это такое место в коде, которое требует от объекта значения либо True, либо False.

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

Любой объект, для которого определен метод __len__, возвращающий для этого объекта 0, является falsy. Документация:

По умолчанию объект считается истинным, если его класс не определяет метод __bool__, возвращающий для объекта False, или метод __len__, возвращающий для него ноль.

Последовательности и коллекции

  • пустой список: [];
  • пустой кортеж: ();
  • пустой словарь: {};
  • пустое множество: set();
  • пустая строка: «»;
  • пустой диапазон: range(0).

Нули любых численных типов

  • целочисленный ноль: 0;
  • ноль с плавающей точкой: 0.0;
  • комплексный ноль: 0j.

Константы

  • None;
  • False.

Объекты, которые приравниваются к True

Согласно документации:

По умолчанию любой объект имеет истинное значение.

В частности, истинными являются:

  • все непустые последовательности и коллекции (списки, кортежи, словари, множества, диапазоны и строки);
  • все ненулевые числа;
  • True.

Функция bool()

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

Возвращает булево значение, т. е. либо True, либо False. Аргумент x конвертируется с использованием стандартной процедуры проверки истинности.

Например:

>> bool(5)
True
>>> bool(0)
False

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

Зачем это нужно?

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

Допустим, у нас есть функция print_even(), которая принимает в качестве аргумента список или кортеж чисел и печатает его чётные элементы. Если список пустой, то выводится сообщение:

def print_even(data):
	if len(data) > 0:
		for value in data:
			if value % 2 == 0:
				print(value)
 	else:
 		print("Пустой список в аргументе")

Обратите внимание на эту строчку:

if len(data) > 0:

Её можно сократить до:

if data:

Если список пустой, data имеет ложное значение. Если он не пустой (то есть его длина больше нуля), то истинное. Тот же результат достигается меньшим количеством кода:

def print_even(data):
	if data:
		for value in data:
			if value % 2 == 0:
				print(value)
 	else:
 		print("Пустой список в аргументе")

Можно использовать истинные/ложные значения, чтобы выбросить исключение, если аргумент некорректен.

>>> def print_even(data):

	if not data:
		raise ValueError("The argument data cannot be empty")

	for value in data:
		if value % 2 == 0:
			print(value)

Если список data пустой:

  • data имеет ложное значение, эквивалентное False;
  • поэтому not data эквивалентно not False, то есть True;
  • поэтому условие if истинно;
  • поэтому бросается исключение.

Если список не пустой:

  • data имеет истинное значение, эквивалентное True;
  • поэтому not data эквивалентно not True, то есть False;
  • поэтому условие if ложно;
  • поэтому исключение не бросается.

Истинные и ложные значения произвольных объектов

Если вы хотите, чтобы у ваших объектов были не только истинные значения, можно добавить к классу метод __bool__() и задать в нём правила, по которым будет определяться истинность или ложность объекта.

Например, у нас есть вот такой класс:

>>> class Account:
	
	def __init__(self, balance):
		self.balance = balance

Поскольку у него нет специальных методов, все объекты этого класса имеют истинное значение:

>>> account1 = Account(500)
>>> bool(account1)
True
>>> account2 = Account(0)
>>> bool(account2)
True

Это можно исправить, добавив __bool__():

>>> class Account:
	def __init__(self, balance):
		self.balance = balance
		
	def __bool__(self):
		return self.balance > 0

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

>>> account1 = Account(500)
>>> bool(account1)
True
>>> account2 = Account(0)
>>> bool(account2)
False

Если у класса нет метода __bool__(), но есть метод __len__(), то истинность объекта определяется истинностью того, что возвращает __len__().

Вот так работает механизм, позволяющий использовать любые объекты в качестве булевых. С его помощью можно сделать код проще и понятнее; важно только не забывать осмысленно называть переменные — какое-нибудь pabotat() if cnucok_2 else He_pabotat() никуда не годится что с булевским контекстом, что без него.

Адаптированный перевод «Truthy and Falsy Values in Python: A Detailed Introduction»

Источник

Понравилась статья? Поделить с друзьями:
  • Как изменить transform position unity
  • Как изменить ttl телевизора
  • Как изменить tpl
  • Как изменить touch id на iphone 7
  • Как изменить title через js