掌握逻辑比较，控制流，在numpy阵列和熊猫数据框架上过滤-DEV365 开发者社区

在这篇文章中，我们将了解不同的比较运营商，如何将它们与布尔运营商结合在一起，并如何在控制结构中使用布尔的结果。布尔逻辑是Python程序中决策的基础。我们还可以使用逻辑来学习pandas dataframes的数据，这是一种数据范围的技术，这些技能必须是数据的科学家。

。

比较运营商

比较运营商是运营商，可以告诉两个价值观，并导致了一个布尔。

数字比较

从最简单的意义上讲，我们可以在数字上使用这些操作员。例如，如果我们要检查2是否小于3，则我们的键入2小于符号3。

print(2 < 3)

output:
True

因为2比3少，我们得到了True。 br>

print(5 == 6)

output:
False

这是有意义的，因为5不是等于6。

print(5 <= 6)

output:
True

是真的，但也比6较小的6是真的。

print(6 <= 6)

output:
True

当然，我们也可以直接使用比较操作员来代表这些整数。

x = 5
y = 6
print(x < y)

output:
True

弦之间的比较

所有这些运营商也可以为字符串工作。

print("abc" < "acd")

output:
True

根据字母秩序，秩序，秩序，coes the coes'，结果是真的。

是真的。

整数和字符串之间的比较

让我们找到比较一个字符串和整数的工作。

print(2 < "abc")

output:
TypeError: '<' not supported between instances of 'int' and 'str'

我们遇到了一个错误（TypeError: '<' not supported between instances of 'int' and 'str'）。

整数和浮点之间的比较

不同的数字类型，例如floats and integers，是例外。

print(3 < 4.12)

output:
True

这次没有错误。通常，始终确保我们在同一类型的对象之间进行比较。

比较numpy阵列

当我们在numpy数组lengths上与整数22进行比较时，会出现另一个例外。这很好。

import numpy as np
lengths = np.array([21.85, 20.97, 21.75, 24.74, 21.44])
print(type(lengths))
print(lengths > 22)

output:
<class 'numpy.ndarray'>
[False False False  True False]

numpyâture of我们想要比较lengths中的每个元素与22，然后返回对应的布尔值。在这些场景的背后。元素的比较。这是简洁的，非常有效的代码，数据科学家喜欢！

我们还可以比较两个numpy的阵列。喜欢这吗？

house1 = np.array([18.0, 20.0, 10.75, 9.50])
house2 = np.array([14.0, 24.0, 14.25, 9.0])
print(house1 < house2)

output:
[False  True  True False]

看来，house1中的居住房和卧室比相应的地区小。

比较器

这是总结所有比较运算符的表。

比较器	含义
<	小于
<=	小于或等于
>	大于
> =	大于或等于
==	等于
！=	不等于

我们已经熟悉其中一些。除了不相等的!=外，它们都非常简单。感叹号后面是平等的标志代表不平等。这是平等的对立面。

平等

检查是否有两个python值，或变量是平等的，您可以使用==。

print(2 == (1 + 1))
print("PYTHON" != "python")
print(True != False)
print("Python" != "python")

output:
True
True
True
True

编写一个代码，以查看True等于False。

# Comparison of booleans
print(True == False)

output:
False

编写python code to检查是否不等于45。

# Comparison of integers
print(( -3 * 15 ) != 45)

output:
True

询问python strings "python"和"Python"是否相等。

# Comparison of strings
print("python" == "Python")

output:
False

请注意，字符串对案例敏感。

# Compare a boolean with an integer
print(True == 1)
print(True == 2)

output:
True
False

a布尔是inter -Integer：True符合1，False对应于0。

比更大的

我们还谈论了比标准更少的符号，<和>在python中。。

print(3 < 4)
print(3 <= 4)
print("alpha" <= "beta")

output:
True
True
True

请记住，为了进行弦的比较，python确定了基于字母顺序的关系。

检查x是否比-13更大。

# Comparison of integers
x = -4 * 3
print(x >= -13)

output:
True

检查True是否大于False。

# Comparison of booleans
print(True > False)

output:
True

记住，True是1，而False是0kouâ。

布尔运营商

我们可以通过进行比较操作来生产布尔值。下一步是结合这些布尔人。我们可以为此使用布尔操作员。最常见的三个是

and，
or和
not.

`and`

and操作员正如我们期望的那样工作。只有两个布尔人本身都是True。

case1	case2	case1 `and` case2
true	true	true
true	false	false
false	true	false
false	false	false

print(True and True)
print(True and False)
print(False and True)
print(False and False)

output:
True
False
False
False

相反，我们也可以使用比较的结果。假设我们拥有一个可变的x，与8相同。 x比5和x大于15。

x = 8
print(x > 5 and x < 15)

output:
True

正如我们已经了解到的，第一部分将对True进行评估。第二部分还将评估True。因此，这种表达的结果是True and True，是True。这是有道理的，因为8位于5和15之间。

`or`

or操作员的工作原理类似，但区别在于，至少只有一个布尔值是True。

case1	case2	case1 `or` case2
true	true	true
true	false	true
false	true	true
false	false	false

print(True or True)
print(True or False)
print(False or True)
print(False or False)

output:
True
True
True
False

在这里我们也可以与变量进行组合，例如，这是一个例子，它可以检查一个可变的y，它等于3，比5或高于10的3。

y = 3
print(y < 5 or y > 10)

output:
True

3比5少了。

`not`

最后，让我们的not运算符。它简单地否定了布尔值，我们使用它。不是真的。布尔的运营，然后想否定这一点。

print(not True)
print(not False)

output:
False
True

嵌套布尔操作员

让我们将布尔运算符带到另一个级别。

请注意，not比and和or具有更高的优先级。

x = 8
y = 9
not(not(x < 3) and not(y < 8 or y > 14))

output:
False

正确！x < 3是False。

在numpy阵列上过滤

现在，对于numpy阵列，事物是不同的。很容易找到，因此，lengths比22是一个。

print(lengths)
print(lengths > 21)
print(lengths < 22)

output:
[21.85 20.97 21.75 24.74 21.44]
[ True False  True  True  True]
[ True  True  True False  True]

现在，我们尝试将它们与and运算符相结合。

print(lengths > 21 and lengths < 22)

output:
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

糟糕，python返回koud99。显然，它不像布尔人的阵列。

numpy提供了这些“阵列等效”，and，or和not功能，

logical_and，
logical_or和
logical_not.

找到lengths在21和22之间，我们将使用这些功能。再次，我们期望从numpy那里，and的操作是执行的。

print(np.logical_and(lengths > 21, lengths < 22))

output:
[ True False  True False  True]

仅选择这些lengths在21和22之间，我们可以在广场上使用booleans的阵列。

print(lengths[np.logical_and(lengths > 21, lengths < 22)])

output:
[21.85 21.75 21.44]

再次，numpy wins no to not's to not'''''还是非常表达的python gody。

布尔运算符上的numpy阵列

之前，像<和>=这样的运营运营商与Numpy的阵列合作。要使用这些运营商与numpy一起使用，我们将需要np.logical_and()，np.logical_or()和np.logical_not()。

生成布尔数阵列，回答以下问题：

my_house中的哪个区域比18.5或更小的10？

# house1 greater than 18.5 or smaller than 10
print(np.logical_or(house1 > 18.5, house2 < 10))

output:
[False  True False  True]

哪个区域比house1和house2中的11小？

# Both house1 and house2 smaller than 11
print(np.logical_and(house1 < 11, house2 < 11))

output:
[False False False  True]

pandas dataframes上过滤

Numpy阵列可用于进行比较操作和以元素的方式进行布尔操作。现在，让我们在大熊猫数据框架上使用这些知识。 Click here下载countries.csv文件。首先，让我们使用PANDAS从CSV文件导入countries数据集。

import pandas as pd
countries = pd.read_csv('countries.csv', index_col=0)
print(countries)

output:
       country    capital  population
IND      India  New Delhi  1393409030
MMR    Myanmar     Yangon    54806010
THA   Thailand    Bangkok    69950840
SGP  Singapore  Singapore     5453570
CHN      China    Beijing  1412360000

假设您现在想保留国家，因为这是大于100,000,000的，这是三个步骤。

首先，我们希望从countries获得人口。
接下来，我们在此专栏上进行了比较。
最后，我们应该在数据框架上使用此结果。

步骤1：获取专栏

因此，从countries中获取koude132 columter133。让我们用方括号做这件事，例如。

print(type(countries['population']))
print(countries['population'])

output:
<class 'pandas.core.series.Series'>
IND    1393409030
MMR      54806010
THA      69950840
SGP       5453570
CHN    1412360000
Name: population, dtype: int64

这个loc替代品和这个iloc版本也可以很好地工作。

print(countries.loc[:, 'population'])

output:
IND    1393409030
MMR      54806010
THA      69950840
SGP       5453570
CHN    1412360000
Name: population, dtype: int64

print(countries.iloc[:, 2])

output:
IND    1393409030
MMR      54806010
THA      69950840
SGP       5453570
CHN    1412360000
Name: population, dtype: int64

步骤2：比较

接下来，我们进行了比较。从以前，我们的人口大于100,000,000的人口大于100,000,000，比以前更大的100000000''

print(countries['population'] > 100000000)

output:
IND     True
MMR    False
THA    False
SGP    False
CHN     True
Name: population, dtype: bool

现在，我们将获得一个包含布尔值的系列。。

is_huge = countries['population'] > 100000000
print(is_huge)

output:
IND     True
MMR    False
THA    False
SGP    False
CHN     True
Name: population, dtype: bool

步骤3：``dataFrame''

最终步骤正在使用这个布尔式系列is_huge到子集pandas dataframe。

print(countries[is_huge])

output:
    country    capital  population
IND   India  New Delhi  1393409030
CHN   China    Beijing  1412360000

正好是我们想要的：只有人口大于100000000的国家，即印度和中国。

概括

让我们总结一下：我们选择了该专栏，在population栏上进行了比较，并将其存储为is_huge'，我们可以使用koudexe130'''这些典型的命令。但是，我们也可以写这条线。

print(countries[countries['population'] > 100000000])

output:
    country    capital  population
IND   India  New Delhi  1393409030
CHN   China    Beijing  1412360000

太好了！

布尔亚运营商pandas dataframe

现在，我们还没有使用布尔运算符。在这里的功能。让我们编写的守则保持了10,000,000至90,000,000的人口。

print(countries)

output:
       country    capital  population
IND      India  New Delhi  1393409030
MMR    Myanmar     Yangon    54806010
THA   Thailand    Bangkok    69950840
SGP  Singapore  Singapore     5453570
CHN      China    Beijing  1412360000

print(np.logical_and(countries['population'] > 10000000, countries['population'] < 90000000))

output:
IND    False
MMR     True
THA     True
SGP    False
CHN    False
Name: population, dtype: bool

唯一的事情是将这个代码放在广场内 - 适当地将其放到subset''中。

print(countries[np.logical_and(countries['population'] > 10000000, countries['population'] < 90000000)])

output:
      country  capital  population
MMR   Myanmar   Yangon    54806010
THA  Thailand  Bangkok    69950840

现在我们知道了

的比较运营商

<
<=
>
>=
==
!=

我们也知道如何结合布尔的结果，使用布尔运营商，例如

and，
or和
not.

控制流

我们可以使用这些概念来改变我们的程序的行为。

koud156，
else和
elif.

如果

假设我们有一个变量x，等于4。

x = 4
if x % 2 == 0:
    print('x is even.')

output:
x is even.

2的模量运算符koud161将返回0，如果x甚至是。

让我们将此与一般食谱进行比较。请注意，结束时，我们简单地说，我们简单地说，我们简单地说，这是一个事实。继续使用一些python守则，没有缩进，python Will Will Will Will Will'''不是这一声明的一部分。在if语句中有更多的线条，例如，这是可能的。

x = 4
if x % 2 == 0:
    print('Cheching if x (', x, ') is divisible by 2...')
    print('x is even.')

output:
Cheching if x ( 4 ) is divisible by 2...
x is even.

如果我们运行的话，现在要打印两个线条。如果我们将x更改为3和Rerun'，您可以看到这一点。

x = 3
if x % 2 == 0:
    print('Cheching if x (', x, ') is divisible by 2...')
    print('x is even.')

output:

没有输出。

别的

好吧，我们可以简单地使用else语句，例如。

x = 3
if x % 2 == 0:
    print('x is even.')
else:
    print('x is odd.')

output:
x is odd.

如果我们以x等于3进行了运行，那么条件不是真的，那么''''''''''''''''''''''''''''需要指定条件。

埃利夫

我们可以考虑到甚至是更定制的行为。一个例子。

x = 3
if x % 2 == 0: # False
    print('x is divisible by 2.')
elif x % 3 == 0: # True
    print('x is divisible by 3.')
else:
    print('x is not divisible by both 2 & 3.')

output:
x is divisible by 3

如果xâequals 3，则第一个条件是False，所以要检查下一个条件。

现在假设x quats 6. if和elif条件在此情况下持有True。

x = 6
if x % 2 == 0: # True
    print('x is divisible by 2.')
elif x % 3 == 0: # never reach here
    print('x is divisible by 3.')
else:
    print('x is not divisible by both 2 & 3.')

output:
x is divisible by 2.

nop.当我们编写python脚本时，“不相应的打印输出”可能是非常强大的。

在这篇文章中，我们学会了逻辑比较，控制流程，并在numpy array和pandas dataframe上进行过滤。

Read the original article.

Connect & Discuss with us on LinkedIn