布尔运算¶

print(10 or 'hello')  # 先对左侧求值，值为True则返回左侧的值,返回整数 10
print('hello' or 10)  # 先对左侧求值，值为True则返回左侧的值,返回'hello'
print(10 or '')       # 先对左侧求值，值为True则返回左侧的值,返回整数 10

print(0 or 'hello')   # 先对左侧求值，值为False则返回右侧的值,返回'hello'
print(0 or False)     # 先对左侧求值，值为False则返回右侧的值,返回False
print('' or [])       # 先对左侧求值，值为False则返回右侧的值,返回[]

print(0 and 'hello')   # 先对左侧求值，值为False则返回左侧的值,返回0
print(0 and False)     # 先对左侧求值，值为False则返回左侧的值,返回0
print('' and [])       # 先对左侧求值，值为False则返回左侧的值,返回''

print(10 and 'hello')  # 先对左侧求值，值为True则返回右侧的值,返回'hello'
print('hello' and 10)  # 先对左侧求值，值为True则返回右侧的值,返回整数 10
print(10 and '')       # 先对左侧求值，值为True则返回右侧的值,返回''

print(not 10)       # 10是非0整数，布尔值为True，取非结果为False
print(not '')       # ''，空字符串，布尔值为False，取非结果为True

if 10 or ' ':     # 10 and ' '布尔运算的值是10，条件运算结果为True
    print(True)   # 当10 and ''布尔运算值是True时，输出True
else:             # 否则
    print(False)  # 输出 False，执行此分支

print(bool(10 or ''))  # 先得到10 or ' '的结果为10，再用bool(10)返回True输出

birthdate = input('请输入出生日期: ') or '保密'
print(birthdate)                    # 无输入，直接回车时，输出'保密'

birthdate = input('请输入出生日期: ')  # 接收用户输入的出生日期或回车符
if birthdate:          # 当birthdate不为空字符串时，逻辑值检测结果为True
    print('你的生日是：', birthdate)   # 有输入时，输出用户输入的出生日期
else:                  # 无输入时（直接回车时），输出'保密'
    print('你的生日是：', '保密')

birthdate = input('请输入出生日期: ') or '保密'  # 布尔表达式的短路求值结果赋值给birthdate
print('你的生日是：', birthdate)  

import datetime # 导入datetime，用于计算程序运行时间


def prime(n):
    """接收正整数n,判断是否为素数,返回布尔值"""
    if n < 2:
        return False       # 0和1不是素数
    for i in range(2, n):  # 遍历(2, n-1)中的数
        if n % i == 0:     # 若在(2, n-1)中存在因子则不是素数
            return False   # 不是素数时返回False
    else:   # for语句遍历(2, n-1)中所有数,未发现因子存在时,才是素数
        return True        # 素数时返回True

    
start = datetime.datetime.now()  # 记录程序开始时间

for i in range(20000):
    # 利用短路提高效率
    if prime(i) and str(i) == str(i)[::-1]: # 先判断素数，再判断回文，效率低
        print(i,end=' ')
        
end = datetime.datetime.now()  # 记录程序结束时间
during = (end - start).seconds * 1000 + (end - start).microseconds / 1000  # 计算耗时，精确到毫秒 
print(f'\n耗时：{during}毫秒')

import datetime # 导入datetime，用于计算程序运行时间


def prime(n):
    """接收正整数n,判断是否为素数,返回布尔值"""
    if n < 2:
        return False       # 0和1不是素数
    for i in range(2, n):  # 遍历(2, n-1)中的数
        if n % i == 0:     # 若在(2, n-1)中存在因子则不是素数
            return False   # 不是素数时返回False
    else:   # for语句遍历(2, n-1)中所有数,未发现因子存在时,才是素数
        return True        # 素数时返回True

    
start = datetime.datetime.now()  # 记录程序开始时间

for i in range(20000):
    # 利用短路提高效率
    if str(i) == str(i)[::-1] and prime(i): # 先判断回文，再判断素数，效率高
        print(i,end=' ')
        
end = datetime.datetime.now()  # 记录程序结束时间
during = (end - start).seconds * 1000 + (end - start).microseconds / 1000   # 计算耗时，精确到毫秒 
print(f'\n耗时：{during}毫秒')

import datetime # 导入datetime，用于计算程序运行时间


def prime(n):
    """接收正整数n,判断是否为素数,返回布尔值"""
    if n < 2:
        return False       # 0和1不是素数
    for i in range(2, n):  # 遍历(2, n-1)中的数
        if n % i == 0:     # 若在(2, n-1)中存在因子则不是素数
            return False   # 不是素数时返回False
    else:   # for语句遍历(2, n-1)中所有数,未发现因子存在时,才是素数
        return True        # 素数时返回True


def reverse_number(num):
    """接收正整数n,判断是否为回文数,返回布尔值"""
    temp = num
    reverse_n = 0
    while temp > 0:
        reverse_n = reverse_n * 10 + temp % 10
        temp //= 10
    return num == reverse_n


start = datetime.datetime.now()  # 记录程序开始时间

for i in range(20000):
    # 利用短路提高效率
    if reverse_number(i) and prime(i): # 先判断回文，再判断素数，效率高
        print(i,end=' ')
        
end = datetime.datetime.now()  # 记录程序结束时间
during = (end - start).seconds * 1000 + (end - start).microseconds / 1000   # 计算耗时，精确到毫秒 
print(f'\n耗时：{during}毫秒')

year = int(input())  # 输入整数年份
# 参考前例，根据条件使用if...else...判断是否为闰年，并输出对应信息

# 参考答案：
year = input()  # 输入要检查的年份

is_leap_year = year % 4 == 0 and year % 100 != 0 or year % 400 == 0

if is_leap_year:
    print(year, '年是闰年')
else:
    print(year, '年不是闰年')

# 补充你的代码

print(1 or 0 and 2 )     # 输出 1
# 由于 or 优先级最低，最后参与运算，先计算0 and 2的值，整个表达式等价于在0 and 2上加括号
print(1 or (0 and 2))    # 输出 1

user_name = input()
password = input()
if user_name == 'root' or 'admin' and password == '123456': # 等价于(user_name == 'root') or ('admin' and password == '123456')
    print('登录成功')
else:
    print('登录失败')

user_name = input()
password = input()
if (user_name == 'root' or 'admin') and password == '123456': 
    print('登录成功')
else:
    print('登录失败')

user_name = input()
password = input()
if (user_name == 'root' or user_name == 'admin') and password == '123456': 
    print('登录成功')
else:
    print('登录失败')

user_name = input()
password = input()
if (user_name == 'admin' and password == '123456') or (user_name == 'root' and password == '123456'): 
    print('登录成功')
else:
    print('登录失败')

user_name = input()
password = input()
if user_name == 'root' or user_name == 'admin':
    if password == '123456': 
        print('登录成功')
else:
    print('登录失败')

print(4 * 2 ** 3)      # 先幂运算，再计算乘法，输出：32
print(3 + 4 * -2)      # 2先取反、与4相乘，再做加法，输出：-5
print(3 + 4 * 2 / 2)   # 先计算乘除法，除法运算结果为浮点数，输出：7.0
print(3 << 2 + 1)      # 加法优先级高，先2+1，3(11)左移3位变成24 (11000)

a = float(input())
b = float(input())
c = float(input())

# 三角形判定条件:边都为正数，任意两边之和大于第三边
if a <= 0 or b <= 0 or c <= 0 or (a + b) <= c or (a + c) <= b or (b + c) <= a:
    print('No')
# 直角三角形条件，两边平方和等于第三边
elif a * a + b * b == c * c or a * a + c * c == b * b or c * c + b * b == a * a:
    print('Yes')
else:
    print('No')

a = float(input())
b = float(input())
c = float(input())

shortest = min(a, b, c)  # 获得最短边长度
longest = max(a, b, c)   # 获得最长边长度
middle = sum([a, b, c]) - shortest - longest

# 若最小边为负值或长边小于等于其他两边之和时，构不成三角形
if shortest <= 0 or shortest + middle <= longest:
    print('NO')
    
# 两边短边长度平方和等于第三边长度平方为直角三角形
elif shortest ** 2 + middle ** 2 == longest ** 2:
    print('YES')
    
else:
    print('NO')