Mikhail Murugov's questions

有一个json对象，其字段之一是一个json字符串，其中包含一个序列化的json对象，需要反序列化为多态类型。如何使用杰克逊注释来做到这一点？使用的版本是 Jackson 2.14.0。
如果在代码级别，那么您需要以某种方式更改data class以使测试通过：

data class Zoo(
    val animal: Animal
)

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type"
)
@JsonSubTypes(
    JsonSubTypes.Type(Cat::class, name = "cat"),
    JsonSubTypes.Type(Dog::class, name = "dog"),
)
interface Animal

data class Cat(
    val meow: String,
) : Animal

data class Dog(
    val woof: String,
) : Animal

class TestDeser {
    private val objectMapper: ObjectMapper = ObjectMapper().findAndRegisterModules()

    @Test
    fun testDeserialize() {
        val catJson = "{\"animal\":\"{\\\"type\\\":\\\"cat\\\",\\\"meow\\\":\\\"catValue\\\"}\"}"
        val dogJson = "{\"animal\":\"{\\\"type\\\":\\\"dog\\\",\\\"woof\\\":\\\"dogValue\\\"}\"}"

        val zooWithCat = this.objectMapper.readValue<Zoo>(catJson)
        val cat = zooWithCat.animal
        Assertions.assertTrue(cat is Cat)
        cat as Cat
        Assertions.assertEquals("catValue", cat.meow)

        val zooWithDog = this.objectMapper.readValue<Zoo>(dogJson)
        val dog = zooWithDog.animal
        Assertions.assertTrue(dog is Dog)
        dog as Dog
        Assertions.assertEquals("dogValue", dog.woof)
    }
}

我尝试过的：

1. 我尝试编写自己的JsonDeserializer：

   class MyDeserializer : StdDeserializer<Animal>(Animal::class.java) {
       override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Animal {
           val str = p.valueAsString
           return (p.codec as ObjectMapper).readValue(str)
       }
   }
   
   data class Zoo(
       @JsonDeserialize(using = MyDeserializer::class)
       val animal: Animal,
   )
   

   我将这种方法用于常规类型，而不是多态类型，并且它有效。对于多态类型，deserialize它甚至不进入方法。

2. 我想尝试使用Converter

   class MyConverter : StdConverter<String, Animal>() {
      override fun convert(value: String): Animal {
         TODO("Нет доступа к ObjectMapper :(")
      }
   }
   
   data class Zoo(
      @JsonDeserialize(converter = MyConverter::class)
      val animal: Animal,
   )
   

   但如果使用转换器ObjectMapper，则无法将字符串转换为 POJO

有一个实体：

@Entity
@Getter
@Setter
@NoArgsConstructor
public class Keys {
    private @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(
            name = "UUID",
            strategy = "org.hibernate.id.UUIDGenerator"
    )
    String id;

    private @Lob
    java.security.KeyPair keyPair;
    private Calendar expirationDate;

    public Keys(java.security.KeyPair keyPair, Calendar expirationDate) {
        this.keyPair = keyPair;
        this.expirationDate = expirationDate;
    }
}

和存储库：

public interface KeysRepository extends JpaRepository<Keys, String> {
}

必须执行删除所有早于过去时间的Keys操作expirationDate。显然，这个任务对应的是请求DELETE FROM Keys WHERE expirationDate < :1。但是在向接口添加方法时deleteAllByExpirationDateBefore(Calendar date)，deleteKeysByExpirationDateBefore(Calendar date)会deleteByExpirationDateBefore(Calendar date)记录请求：

Hibernate: 
    select
        keys0_.id as id1_0_,
        keys0_.expiration_date as expirati2_0_,
        keys0_.key_pair as key_pair3_0_ 
    from
        keys keys0_ 
    where
        keys0_.expiration_date<?
Hibernate: 
    delete 
    from
        keys 
    where
        id=?

也就是说，DROP FROM Keys WHERE expiration_date < ?首先选择所有满足的，而不是简单的，然后将它们逐个删除（delete from keys where id=?）。

问题：如何使它在调用方法时执行请求delete from keys where expiration_date < ?？不使用注解@Query。

有一个任务是在 SSH 上执行各种操作。例如，使用 SSH 通过 SSH 将文本写入文件

echo userInput > file

文本是用户输入。有哪些现成的解决方案可以逃避用户输入，从而避免 bash 注入？在 python 中，有一个内置的shlex模块，它带有必要的方法shlex.quote，对于 Java，我没有找到类似的东西。

有一项任务是将字符串日期解析为 类型的对象LocalDateTime。问题是字符串可以在点之后包含 1 到 9 个数字（毫秒）。或者它可能不包含毫秒，那么最后将没有任何意义。在这种情况下如何正确解析？

目前有人试图这样做：

String datePattern = "yyyy-MM-dd'T'HH:mm:ss[.SSSSSSSSS][.SSSSSS][.SSS]";

LocalDateTime dt = LocalDateTime.parse(dateString, DateTimeFormatter.ofPattern(datePattern));

自然，这种模式并不能捕获所有情况，因为 有人怀疑这样做原则上是否正确。

我也尝试了 pattern "yyyy-MM-dd'T'HH:mm:ss[.[S][S][S][S][S][S][S][S][S]]"，但是由于解析，没有获得该行中的日期（我认为由于[]不支持一个在另一个中的事实）。

要检查的代码：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

public class Main {
    public static void main(String[] args) {

        String datePattern = "yyyy-MM-dd'T'HH:mm:ss[.SSSSSSSSS][.SSSSSS][.SSS]";

        String dt_template = "2021-02-19T03:53:12%s";
        for (int i = 0; i < 10; ++i) {
            StringBuilder stringBuilder = new StringBuilder();
            if (i > 0) {
                stringBuilder.append('.');
            }

            for (int digits_count = 0; digits_count < i; ++digits_count) {
                stringBuilder.append('3');
            }

            String dateString = String.format(dt_template, stringBuilder.toString());
            try {
                LocalDateTime dt = LocalDateTime.parse(dateString, DateTimeFormatter.ofPattern(datePattern));
                System.out.println(dt);
            } catch (DateTimeParseException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

有一项任务是在查询字符串（URL 字符串中的参数）中序列化自定义类。类的一些字段必须是强制性的，一些是可选的。例如：

public class UserQueryParameters {
    String name; // *
    int age; // Не обязательно
    String sex; // Не обязательно
}

您需要以某种方式声明要序列化的字段（在 Java 现实中，这称为编组，排序），哪些不是，然后将生成的结构转换为形式的字符串

name=John&age=23

如何实施？

尝试使用lombok注释：

import lombok.Builder;
import lombok.Getter;

@Getter
@Builder
public class UserQueryParameters {
    String name; // *
    int age; // Не обязательно
    String sex; // Не обязательно
}

接下来，通过builder，形成一个填充字段的类实例：

UserQueryParameters params = UserQueryParameters.builder()
        .name("John")
        .sex("m")
        .build();

并通过反射形成查询字符串：

import java.lang.reflect.Field;

// ...

for (Field field : params.getClass().getDeclaredFields()) {
    if (field.get(params) != null) {
        addToQueryString(field.get(params));
    }
}

但是，显然，这样的解决方案是不合适的，因为。例如，对于一个int字段，不会是null，而是0。

《Effective Java, 2nd edition》一书的第 2 点有这个代码片段，作者希望防止空对象初始化。

class Example {
    private Example() {
        throw new AssertionError();
    }
}

我对抛出的异常类型感到困惑。

我不明白它为什么会兴奋AssertionError。无论是因为缺少更合适的异常类型，还是因为它应该如此简单。

据我了解，验证失败时会引发此异常assert。同样在javadoc中它只是说

[An AssertionError is] 抛出以指示断言失败。

但我没有看到这里执行任何断言（检查真假断言）。当然，“你不能实例化这个类的元素”这句话已经被违反了，但是按照这个逻辑，我们都应该AssertionError到处 raise，这显然不是我们正在做的。

不管需要什么，我都会让你兴奋

new IllegalStateException("Must not instantiate an element of this class")

它有什么问题？我什么时候应该AssertionError在本机代码中提出？

抱歉，我只是有点怀疑，因为我在自己的代码中经常使用这种模式，我想确保我做的一切都是正确的。

_{doplumi翻译的问题。}

我们需要一种从给定范围生成随机 IPv4 地址的方法。无法设置范围。我的谷歌搜索使我发现您可以使用该类来存储地址Inet4Address，但是：

• 根据文档，这个类的实例是用一个getByName可以抛出异常的方法实例化的UnknownHostException；
• 也就是说，问题在于，这个方法是一把瑞士刀，可以将经典的视图字符串192.168.0.1变成所需的对象，或者如果通过了就进行DNS名称解析domain.com。并且在解决的情况下，据我了解，可能会发生上述异常；
• 我想以经典方式设置地址范围，而无需进行 DNS 解析。那些。我确定UnknownHostException不会发生异常，但我必须绝对处理它。

使用此选项，我的代码结果如下：

import com.sun.tools.javac.util.Pair;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;


class IPRanges {
    static final ArrayList<Pair<InetAddress, InetAddress>> IPv4GlobalRanges = new ArrayList<Pair<InetAddress, InetAddress>>() {{
        try {
            add(new Pair<>(InetAddress.getByName("1.0.0.0"), InetAddress.getByName("9.255.255.255")));
            add(new Pair<>(InetAddress.getByName("11.0.0.0"), InetAddress.getByName("100.63.255.255")));
            add(new Pair<>(InetAddress.getByName("100.128.0.0"), InetAddress.getByName("126.255.255.255")));
            add(new Pair<>(InetAddress.getByName("128.0.0.0"), InetAddress.getByName("169.253.255.255")));
            add(new Pair<>(InetAddress.getByName("169.255.0.0"), InetAddress.getByName("172.15.255.255")));
            add(new Pair<>(InetAddress.getByName("172.32.0.0"), InetAddress.getByName("191.255.255.255")));
            add(new Pair<>(InetAddress.getByName("192.0.1.0"), InetAddress.getByName("192.0.1.255")));
            add(new Pair<>(InetAddress.getByName("192.0.3.0"), InetAddress.getByName("192.167.255.255")));
            add(new Pair<>(InetAddress.getByName("192.169.0.0"), InetAddress.getByName("198.17.255.255")));
            add(new Pair<>(InetAddress.getByName("198.20.0.0"), InetAddress.getByName("198.51.99.255")));
            add(new Pair<>(InetAddress.getByName("198.51.101.0"), InetAddress.getByName("203.0.112.255")));
            add(new Pair<>(InetAddress.getByName("203.0.114.0"), InetAddress.getByName("223.255.255.255")));
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }};
}

我不确定这是否是“正确”的做法，我不喜欢这样：

1. 填充范围必须通过 完成try ... catch，尽管我知道那里肯定不会出现异常；
2. 您需要一定范围的 IPv4 地址。如果您将结果显式InetAddress转换为Inet4Address，那么您将获得更大的代码表。

此外，所有构造函数Inet4Address都是私有的，这会阻止它们被直接调用（在我的情况下，这将解决问题）。

如何“正确”解决问题（具体来说，实例化一个描述 IPv4 地址的类的实例，而无需进行不必要的异常处理）？它不一定是Inet4Address，但我希望它是内置的，这样就没有不必要的依赖。

我想实现大约以下架构：

解释：

• Base- 类似于存储一些基本对象的存储实体；
• ChildN- 对存储在Base. 事实上，它们是接口，因为 不存储任何状态；
• static Mixin- 一个结合了所有方法的类ChildN。方法名称之间没有冲突。它的所有方法（即从 继承的方法ChildN）必须是静态的，无需实例化即可调用。

在python中，这个任务很容易通过多重继承来解决，在java中没有这样的事情。怎样成为？

我要实现的示例伪代码：

class Base {
    static protected final String someString = "01";
}

class Child1 extends Base {
    static public char get_0() {
        return someString.charAt(0);
    }
}

class Child2 extends Base {
    static public char get_1() {
        return someString.charAt(1);
    }
}

class MixIn extends Child1, Child2 {  // Так сделать нельзя

}

public class Main {
    public static void main(String[] args) {
        System.out.println(MixIn.get_0());  // Итоговое использование должно быть таким
        System.out.println(MixIn.get_1());
    }
}

有一个抽象类Foo

from abc import ABC

class Foo(ABC):
    pass

如何使此类的所有继承人的实例都必须声明一个成员self.foo？

我找到了实现抽象property类的解决方案，但这不是所需要的，因为该成员需要可用于读取和写入。

为什么

有一个基类Descriptor

from abc import ABC

class Descriptor(ABC):
    pass

描述符意味着它必须有一些字段（例如，self.fields = dict()）。例如，一个文件描述符：

class FileDescriptor(Descriptor):
    def __init__(self):
        self.fields = dict(
            name='name',
            path=PathDescriptor(),
            ...
        )

此外，还需要丰富这个描述符。例如，

    def enrich(self, data):
        self.fields.update(data)

并且应该也可以读取这个描述符的字段

file_desc = FileDescriptor()
file_desc.enrich(dict(name='new name'))
print(file_desc.fields['name'])

如果没有 . 在其中声明，就不可能实例化后代Descriptor（例如 ），这是必要的。如何正确实施？FileDescriptorself.fields

有人怀疑它们适合这项任务dataclasses，但我从未与他们合作过，到目前为止我不知道如何应用它以及它是否适用。

有一个任务是在不丢失信息的情况下将float值转换为类型值int（一个float值到一个int值），即，这样您就可以执行反向转换。如何实施？

重要的

在这种转换过程中必须保留顺序和总和，
即 对于任何a, b: float应该执行：

to_float(to_int(a) + to_int(b)) == a + b

to_int(a) < to_int(b) при a < b и т.д.

我在英文 SO 上找到了答案，其中float值结构是一点一点表示的，但我无法想象它如何应用于我的任务。

注意：我的任务也不NaN需要inf转换。

解决方案尝试

最初，想到用这些字节序列化pickle.dumps然后int从这些字节中获取，但这根本不是一个合理的解决方案，它根本不满足要求。

已经尝试通过数字的字节表示来实现这一点（Qwertiy♦ 的答案），它不存储总和。

在InfluxQL查询中有一个替换标记的任务。这些查询的语法由扩展的 Backus-Naur 形式定义。python-3.x中有哪些库来实现这个语法，以便解析 InfluQL 查询，获取令牌树并替换我需要的令牌？理想情况下，我还想看一个解析一些简单请求的例子。

有字节：

b = b'X:\xce\xa4\x91start\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0ende\x85\n\xe0'

有必要使用正则表达式从那里提取解码部分，然后处理解码部分（即字符串）。取出零件不是问题。re.Match问题是解码返回的所有组。
例子：

import re

b = b'X:\xce\xa4\x91start\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0ende\x85\n\xe0'
m = re.search(b"start(?P<decodable>.+)end", b)

print(m['decodable'])  # b'\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0'
print(m[0])  # b'start\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0end'
print(m[1])  # b'\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0'
m = decode_match(m, encoding='utf-8')  # Как реализовать подобное отображение?

# Ожидаемый результат:
print(m['decodable'])  # строка
print(m[0])  # startстрокаend
print(m[1])  # строка

可以有任意多的内部decode_match调用。bytes.decode

试图迭代m和解码，但是TypeError: 're.Match' object is not iterable

为了实验，我尝试解码零组：

m[0] = m[0].decode()

但TypeError: 're.Match' object does not support item assignment

问题描述

有一个cx-Oracle模块。我想装饰Cursor类的执行方法，以便它记录正在执行的请求：

import logging


class _QueryLogger:
    def __init__(self, execute_func):
        self._func = execute_func
        self._logger = logging.getLogger()

    def __call__(self, query: str):
        self._logger.log(level=logging.DEBUG, msg=query)
        return self._func(query)

然后，通过上下文管理器，返回带有修饰方法的游标对象execute：

import cx_Oracle
from credentials import credentials
from deco import _QueryLogger


class DbOracle:
    @contextmanager
    def _get_cursor(self):
        with cx_Oracle.Connection(**credentials) as conn:
            cursor = conn.cursor()
            cursor.execute = _QueryLogger(cursor.execute)  # Проблема здесь
            yield cursor

    def execute(self, query):
        with self._get_cursor() as cursor:
            cursor.execute(query)

使用时：

oracle = DbOracle()
oracle.execute("select * from v$version")

出现异常：

AttributeError: 'cx_Oracle.Cursor' object attribute 'execute' is read-only

问题

如何绕过？我想将日志记录添加到游标对象本身，通过它执行查询。

为什么

DbOracle 类有几种方法用于执行各种 SQL 查询。我想将日志记录附加到游标对象，以便在这些方法中的每一个中，请求在执行之前都不会被记录（读取，以避免代码重复）。

出于兴趣，我决定和班一起玩，发现了这么有趣的事情。假设我想创建一个datetime.datetime具有一个附加属性的类：

import datetime


class Foo(datetime.datetime):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)  # Вызываем конструктор родителя
        self.foo = 5 # Добавляем свой атрибут

尝试使用参数实例化类时：

f = Foo(2020, 1, 1)

我收到一个错误：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-6b5ccf5358aa> in <module>
----> 1 f = Foo(2020, 1, 1)

<ipython-input-1-31281291039f> in __init__(self, *args, **kwargs)
      4 class Foo(datetime.datetime):
      5     def __init__(self, *args, **kwargs):
----> 6         super().__init__(*args, **kwargs)  # Вызываем конструктор родителя
      7         self.foo = 5 # Добавляем свой атрибут
      8

TypeError: object.__init__() takes exactly one argument (the instance to initialize)

是什么导致了错误，我该如何实现我想要的？

复制粘贴的完整代码：

import datetime


class Foo(datetime.datetime):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)  # Вызываем конструктор родителя
        self.foo = 5 # Добавляем свой атрибут


f = Foo(2020, 1, 1)

有一行：

s = \
"""trash data
2020-06-23 09:55:48.672 log1
2020-06-23 09:59:28.617 log2
2020-06-23 09:59:28.617 log3
2020-06-23 10:00:51.234 log4
2020-06-23 10:00:51.234 log5"""

还有一个正则表达式：

pat = re.compile(r"^((\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}).+)$", flags=re.MULTILINE)

为什么pat.sub(s, "_")退货

"_"

而不是预期

"""trash data
_
_
_
_
_"""

? 在regex101 上，它按我的预期工作。

import re
pat = re.compile(r"^((\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}).+)$", flags=re.MULTILINE)

s = \
"""trash data
2020-06-23 09:55:48.672 log1
2020-06-23 09:59:28.617 log2
2020-06-23 09:59:28.617 log3
2020-06-23 10:00:51.234 log4
2020-06-23 10:00:51.234 log5"""

print(pat.sub(s, "_"))

不可能正确地表述问题，例如：

让它head像这样工作：从标准输入打印前 5 行，之后该过程立即结束。

cat some_file.txt | head -5

读取文件的内容some_file.txt。让它有超过5行。head打印前 5 行并退出。

在打印 5 行并完成后，文件本身是否会被some_file.txt读取到最后？head

有一个系统Linux。它有一个日志。在此日志中有以下格式的条目：

2020-04-24 14:00:58.870+0300:Some log
2020-04-24 14:00:58.872+0300:Some another log
2020-04-24 14:00:58.891+0300:And another

例如，有必要从此日志中获取最后 10 分钟的记录（有时需要花费最后几秒钟）。问题是日志可以分成几行，例如：

2020-04-24 14:00:58.870+0300:Some log
2020-04-24 14:00:58.872+0300:Some
another
log
2020-04-24 14:00:58.891+0300:And another

sed -n "/^$(date --date='10 min ago' '+%Y-%m-%d %H:%M:%S')/,\$p" log.log

该选项很好，但它不执行所需的操作（如果在调用命令的同一秒内没有日志，则不会找到任何内容）。

awk -v from_date="$(date --date='10 min ago' '+%Y-%m-%d %H:%M:%S')" -v to_date="date '+%Y-%m-%d %H:%M:%S'" '$0 > from_date && $0 < to_date || $0 ~ to_date' log.log

此选项更好，可以满足需要，但由于某些日志被分成几行而中断。

但是因为 我不强，我不知道该怎么做bash。

d=$(date --date='10 min ago' '+%Y-%m-%d %H:%M:%S'); tac log.log | (while read -r line; do ([[ $line =~ ([0-9]{4}-[0-9]{2}-[0-9]{2}.*) ]] && [[ "$line" > "$d" ]] && break) || echo $line; done;) | tac -

但在这种情况下，会显示整个日志。

d=$(date --date='10 min ago' '+%Y-%m-%d %H:%M:%S'); tac log.log | (while read -r line; do ([[ $line =~ ([0-9]{4}-[0-9]{2}-[0-9]{2}.*) && $d > $line ]] && (break)) || echo $line; done;) | tac -

在这种情况下，选择了真正必要的日期，但它不起作用break，并且显示的“旧”日志不是从该日期开始的。它也可以工作很长时间，因为我认为日志已被完全读取。

限制：

系统具有只读访问权限。那些。无法在那里上传一些文件、安装一些实用程序、配置现有实用程序的功能。

有一个系统Linux。它有一个日志。在此日志中有一个有效的json. 这json一个被分成几行。我确定这里面有一个值为 的json键。如何从此日志中获取包含此键和值的全部内容？阅读日志本身没有问题，只需将其拉出即可。 "id"12345jsonjson

grep -zo "{.*\"id\".*12345.*}" log.log
grep -ez "{.*\"id\".*12345.*}" log.log

不幸的是，我没有得到想要的结果。

2020-04-24 14:00:58.870+0300:Another string
2020-04-24 14:00:58.872+0300:Unusual json: {"some data": "another data"}
2020-04-24 14:00:58.891+0300:Answer from some service: {
 "event_id":"some id"
, "some information":"some value"
, "id":12345
, "timestamp":1587726058000
, "status":"ok"
,"some integer":100
, "category_scores":[
 {"id":"id1","value":123},
 {"id":"id2","score":234},
 {"id":"id3","score":100},
 {"id":"id4","score":299},
 {"id":"id5","score":600}
]
, "result":{"action":"some action","param":"0","action_code":"allow"}
, "service":{"request_id":1448
}}

{
 "event_id":"some id"
, "some information":"some value"
, "id":12345
, "timestamp":1587726058000
, "status":"ok"
,"some integer":100
, "category_scores":[
 {"id":"id1","value":123},
 {"id":"id2","score":234},
 {"id":"id3","score":100},
 {"id":"id4","score":299},
 {"id":"id5","score":600}
]
, "result":{"action":"some action","param":"0","action_code":"allow"}
, "service":{"request_id":1448
}}

是否有可能以某种方式覆盖标准类型的 JSONEncoder 行为？例如，我希望字典不是通过 序列化{}，而是通过序列化<>，这样字符串就不会被包裹在"等等中。此外，不知何故只需要处理一些标准类型

import json

print(json.dumps({"a": "5", "b": {"c": "d", "e": "f", "g": ["1", "2", 3]}}, indent=4))

结论：

{
    "a": "5",
    "b": {
        "c": "d",
        "e": "f",
        "g": [
            "1",
            "2",
            3
        ]
    }
}

我也想得到：

<
    a: 5,
    b: <
        c: d,
        e: f,
        g: [
            1,
            2,
            3
        ]
    >
>

有必要以“自定义”形式接收数据，不需要反序列化。

关于代码架构的问题。假设有很多elif's。在“top”条件下，表达式的结果不会在分支内使用。在较低的条件中，有一个条件if是在分支内部使用来自 'a 的表达式的结果。

问题：

如何编写代码以使该结果不会计算两次（在检查和分支内部时）并且不会再次计算（例如，如果第一个条件通过）？

def task(val):
    if val % 2:
        print("cond1")  # результат выражения не используется
    elif val % 3:
        print("cond2")
    elif val % 5:
        print(val % 5)  # Тут результат из if'а используется внутри ветки
                        # и высчитывается второй раз. Этого хотелось бы избежать
    else:
        print("else")


task(6)