使用Python的max返回两个相等的大值（python 返回两个值）

25-02-13 14

在本文中，我们将详细介绍使用Python的max返回两个相等的大值的各个方面，并为您提供关于python返回两个值的相关解答，同时，我们也将为您带来关于2个相同的字符串“不相等”[Python]、py

在本文中，我们将详细介绍使用Python的max返回两个相等的大值的各个方面，并为您提供关于python 返回两个值的相关解答，同时，我们也将为您带来关于2个相同的字符串“不相等” [Python]、python – 在几乎相等的部分和返回边界中拆分列表、Python-在Python中，比较float与几乎相等的最佳方法是什么？、Python两个对象相等的原理的有用知识。

本文目录一览：

使用Python的max返回两个相等的大值（python 返回两个值）
2个相同的字符串“不相等” [Python]
python – 在几乎相等的部分和返回边界中拆分列表
Python-在Python中，比较float与几乎相等的最佳方法是什么？
Python两个对象相等的原理

使用Python的max返回两个相等的大值（python 返回两个值）

我正在使用Python的max函数在名为的字典中找到最大的整数count，以及相应的键（不太确定我说的是否正确；我的代码对自己的解释可能比对它的解释要好）。字典count与相似{''a'':100, ''b'': 210}，依此类推。

number = count[max(count.items(), key=operator.itemgetter(1))[0]]highest = max(count, key=count.get)

如果其中有两个相等的最大值，该怎么办？如果我有{''a'': 120, ''b'': 120, ''c'':100}，这只会找到和中的第一个，a而b不是两者。

答案1

小编典典

想法是找到最大值并获取与该值对应的所有键：

count = {''a'': 120, ''b'': 120, ''c'': 100}highest = max(count.values())print([k for k, v in count.items() if v == highest])

2个相同的字符串“不相等” [Python]

通过搜索发现了类似的问题，但我是一位新的（糟糕的）程序员，无法理解答案。

我有一个.txt文件，其中包含多个字符串，以’-‘分隔。我使用拆分将一些字符串分成变量，其中两个相等，但是在if语句中它们不相等。

f_nmr, f_Question, f_1, f_2, f_3, f_answer = file.readline().split(''-'')print(f_2)print(f_answer)if f_2 == f_answer:    print("Yes")elif f_2 != f_answer:    print("No")

这将产生以下结果：

瑞典

没有

在两个“ Sweden”字符串之前和之后都有一个空格，并且它们都用大写字母“ S”编写，但不相等吗？我在哪里搞砸了？

答案1

小编典典

最后一个元素包括换行符。让我们以这个输入文件为例：

$ cat file.txtSweden-Sweden

现在，让我们阅读以下内容：

>>> a, b = open(''file.txt'').readline().split(''-'')>>> a,b(''Sweden'', ''Sweden\n'')>>> a == bFalse

解决方案是删除换行符：

>>> a, b = open(''file.txt'').readline().rstrip(''\n'').split(''-'')>>> a == bTrue

python – 在几乎相等的部分和返回边界中拆分列表

我想拆分列表并返回边界,因此在扩展中不应该存在单个元素.

例如

split(list(range(1,101)),2) 
# should return 
[[1,50],[51,100]]

split(list(range(1,3)
# should return
[[1,33],[34,66],[67,6)),2],[3,5]] # Ideally last element should merge with last if last one has no pair.

到目前为止我试过了

def split(l,n):
    x = list(range(1,l+1))
    return [x[i:i+n] for i in range(0,len(x),int(len(x)/n))]

print(split(20,2))

返回[[1,[11,12]]而不是[[1,10],20]]

解决方法

def csplit(m,n):
    div_ = m//n
    step = div_ if div_ > 1 else 2  # determine step for range function (at least 2 'alternate steps')
    lis = []
    for i in range(1,m+1,step):
        if (m-(i+max(1,div_-1))) > 1:
            # append list only if remains at least two elements remains 
            lis.append([i,i+max(1,div_-1)])
        else:
            if not m == i:
                # in case if m and i not equal and not more then one element left then construct list which include that element
                lis.append([i,m])
            break  # break the loop from iterating any further
    return lis

if __name__ == "__main__":
    print(csplit(100,2))
    print(csplit(100,3))
    print(csplit(5,3))

输出：

[[1,100]]
[[1,5]]

同一个衬垫：

def csplit(m,n):
    return [[i,m//n-1)] if (m-(i+max(1,m//n-1))) > 1 else [i,m] for i in range(1,max(m//n,2)) if not i==m]

Python-在Python中，比较float与几乎相等的最佳方法是什么？

在Python中，比较float与几乎相等的最佳方法是什么？

答案1

小编典典

Python 3.5添加了PEP 485中描述的math.isclose和cmath.isclose功能。

如果你使用的是Python的早期版本，则等效功能在文档中给出。

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

rel_tol是一个相对容差，它乘以两个参数中的较大者；当值变大时，它们之间的允许差异也会变大，同时仍将它们视为相等。

abs_tol是在所有情况下均按原样应用的绝对公差。如果差异小于这些公差中的任何一个，则认为值相等。

Python两个对象相等的原理

概述

大部分的python程序员平时编程的时候，很少关心两个对象为什么相等，因为教程和经验来说，他们就应该相等，比如1==1就应该返回True，可是当我们想要定义自己的对象或者修改默认的对象行为时，通常会因为不了解原理而导致各种奇奇怪怪的错误。

两个对象如何相等

两个对象如何才能相等要比我们想象的复杂很多，但核心的方法是重写__eq__方法，这个方法返回True，则表示两个对象相等，否则，就不相等。相反的，如果两个对象不相等，则重写__ne__方法。
默认情况下，如果你没有实现这个方法，则使用父类(object)的方法。父类的方法比较是的两个对象的ID(可以通过id方法获取对象ID)，也就是说，如果对象的ID相等，则两个对象也就相等。因此，我们可以得知，默认情况下，对象只和自己相等。例如：


>>> class A(object):
...     pass
...
>>>
>>> a = A()
>>> b = A()
>>> a == a
True
>>> a == b
False
>>> id(a)
4343310992
>>> id(b)
4343310928

Python2程序员经常犯的一个错误是，只重写了__eq__方法，而没有重写__ne__方法，导致不可预计的错误。而Python3会自动重写__ne__方法，如果你没有重写的话。

对象的Hash方法

Python里可Hash的对象，都有一个数字ID代表了它在python里的值，这个ID是由对象的__hash__方法返回的。因此，如果想让一个对象可Hash，那必须实现__hash__方法和之前提到的__eq__方法。和对象相等一样，默认情况下，对象的__hash__方法继承自Object对象，而Object对象的__hash__方法只计算对象ID，因此两个对象始终拥有两个不一样的hash id，不管他们是多么相似。
当我们把一个不可Hash的对象加入到set或者dict时，会发生什么了？

>>> set().add({})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: ''dict''
unhashable type: ''dict''

原因是set()和dict()使用对象的hash值作为内部索引，以便能快速索引到指定对象。因此，同一个对象返回相同的hash id就很重要了。

对象的Hash值在它的生命周期内不能改变

如果你想定义一个比较完美的对象，并且实现了__eq__和__hash__方法来定义对象的比较行为和hash值，那么你就需要保证对象的相关属性不能发生更改。不然会导致很诡异的错误，比如下面的例子。

>>> class C:
...     def __init__(self, x):
...         self.x = x
...     def __repr__(self):
...         return "C({"+str(self.x)+"})"
...     def __hash__(self):
...         return hash(self.x)
...     def __eq__(self, other):
...         return (
...             self.__class__ == other.__class__ and
...             self.x == other.x
...         )
>>> d = dict()
>>> s = set()
>>> c = C(1)
>>> d[c] = 42
>>> s.add(c)
>>> d, s
({C(1): 42}, {C(1)})
>>> c in s and c in d  # c is in both!
True
>>> c.x = 2
>>> c in s or c in d   # c is in neither!?
False
>>> d, s
({C(2): 42}, {C(2)})   # but...it''s right there!

在我们没有修改对象的属性时(c.x=2)之前，所有行为都符合预期。当我们通过c.x=2时修改属性后，执行c in s or c in d返回False，但是内容却是修改后的，是不是很奇怪。这也就解释了为什么str、tuple是可Hash的，而list和dict是不可hash的。

因此我们可以得出结论，如果两个对象相等的话，那它们的hash值必然也是相等的。

总结

讲了这么多有什么用了。

当我们遇到unhashable type这个异常时，我们能够知道为什么报这个错误。
如果定义了一个可比较的对象，那么最好保证对象hash值相关的属性在生命周期内不能发生改变，不然会发生意想不到的错误。

转载自我的博客捕蛇者说

关于使用Python的max返回两个相等的大值和python 返回两个值的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于2个相同的字符串“不相等” [Python]、python – 在几乎相等的部分和返回边界中拆分列表、Python-在Python中，比较float与几乎相等的最佳方法是什么？、Python两个对象相等的原理等相关知识的信息别忘了在本站进行查找喔。

本文标签：