python负无穷

㈠ python如何输入无穷大为啥不是int

float('inf') 表示正无穷，-float('inf') 或 float('-inf') 表示负无穷，inf 均可以写成 Inf，所以如果要输入无穷大就不能用int了。因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量一般要初始无穷大或者取第一个元素的值。

㈡ python中-17//4的值是什么

//是整除，且结果是向负无穷大方向（即数轴的负方向）取整，也就是向下取整，即取整为不大于除法结果的最大整数。

本来-17除以4等于-4.25，-4.25向负无穷大方向取整就是-5，亦即不大于-4.25的最大整数-5。

所以，-17//4等于-5。

㈢ python -9//2为什么不是-4

因为//是向下取整（即向数轴的负无穷大方向取整）。简单说就是求不大于商的最大整数。-9/2的商是-4.5，不大于-4.5的最大整数是-5（当然，-5也是在-4.5的左边，即负无穷大方向）。所以，-9//2等于-5。

㈣ python中36%-5为什么等于-1

36%-5根本就不等于-1，36%-5等于-4好吧？

下图是验证：

为什么36%-5等于-4？

因为%是求余数，余数=被除数-被除数//除数*除数。

而//是整除，对于python语言//是向下取整，即向负无穷大方向取整，结果是不大于商的最大整数。

36除以-5的商是-7.2，不大于-7.2的最大整数是-8，所以36//-5等于-8。

所以36%-5=36-(36//-5)*(-5)=36-(-8)*(-5)=36-40=-4。

㈤ 在python中为什么18%-5=-2而18%5等于3

18/-5=-3.6，同时python规定对于//（整除）的结果是向负无穷大方向（即数轴的左边）取整，所以18//-5=-4。

而对于18%-5，在python中是这样计算的：
18%-5=18-18//-5*(-5)=18-(-4)*(-5)=18-20=-2。

至于18%5，是这样计算的：18%5=18-18//5*5=18-3*5=3。其中，18//5也是向负无穷大方向取整，因18/5=3.6，所以18//5=3（因为3在3.6的左边）。

㈥ python分治法求二维数组局部峰值方法

python分治法求二维数组局部峰值方法
下面小编就为大家分享一篇python分治法求二维数组局部峰值方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
题目的意思大致是在一个n*m的二维数组中，找到一个局部峰值。峰值要求大于相邻的四个元素（数组边界以外视为负无穷），比如最后我们找到峰值A[j][i]，则有A[j][i] > A[j+1][i] && A[j][i] > A[j-1][i] && A[j][i] > A[j][i+1] && A[j][i] > A[j][i-1]。返回该峰值的坐标和值。
当然，最简单直接的方法就是遍历所有数组元素，判断是否为峰值，时间复杂度为O(n^2)
再优化一点求每一行（列）的最大值，再通过二分法找最大值列的峰值（具体方法可见一维数组求峰值），这种算法时间复杂度为O(logn)
这里讨论的是一种复杂度为O(n)的算法，算法思路分为以下几步：
1、找“田”字。包括外围的四条边和中间横竖两条边（图中绿色部分），比较其大小，找到最大值的位置。（图中的7）

2、找到田字中最大值后，判断它是不是局部峰值，如果是返回该坐标，如果不是，记录找到相邻四个点中最大值坐标。通过该坐标所在的象限缩小范围，继续比较下一个田字

3、当范围缩小到3*3时必定会找到局部峰值（也可能之前就找到了）
关于为什么我们选择的范围内一定存在峰值，大家可以这样想，首先我们有一个圈，我们已知有圈内至少有一个元素大于这个圈所有的元素，那么，是不是这个圈中一定有一个最大值？
可能说得有点绕，但是多想想应该能够理解，也可以用数学的反证法来证明。
算法我们理解后接下来就是代码实现了，这里我用的语言是python（初学python，可能有些用法上不够简洁请见谅），先上代码：
import numpy as np
def max_sit(*n): #返回最大元素的位置
temp = 0
sit = 0
for i in range(len(n)):
if(n[i]>temp):
temp = n[i]
sit = i
return sit
def dp(s1,s2,e1,e2):
m1 = int((e1-s1)/2)+s1 #row
m2 = int((e2-s1)/2)+s2 #col
nub = e1-s1
temp = 0
sit_row = 0
sit_col = 0
for i in range(nub):
t = max_sit(list[s1][s2+i], #第一排
list[m1][s2+i], #中间排
list[e1][s2+i], #最后排
list[s1+i][s2], #第一列
list[s1+i][m2], #中间列
list[s1+i][e2], #最后列
temp)
if(t==6):
pass
elif(t==0):
temp = list[s1][s2+i]
sit_row = s1
sit_col = s2+i
elif(t==1):
temp = list[m1][s2+i]
sit_row = m1
sit_col = s2+i
elif(t==2):
temp = list[e1][s2+i]
sit_row = e1
sit_col = s2+i
elif(t==3):
temp = list[s1+i][s2]
sit_row = s1+i
sit_row = s2
elif(t==4):
temp = list[s1+i][m2]
sit_row = s1+i
sit_col = m2
elif(t==5):
temp = list[s1+i][e2]
sit_row = s1+i
sit_col = m2
t = max_sit(list[sit_row][sit_col], #中
list[sit_row-1][sit_col], #上
list[sit_row+1][sit_col], #下
list[sit_row][sit_col-1], #左
list[sit_row][sit_col+1]) #右
if(t==0):
return [sit_row-1,sit_col-1]
elif(t==1):
sit_row-=1
elif(t==2):
sit_row+=1
elif(t==3):
sit_col-=1
elif(t==4):
sit_col+=1
if(sit_row<m1):
e1 = m1
else:
s1 = m1
if(sit_col<m2):
e2 = m2
else:
s2 = m2
return dp(s1,s2,e1,e2)
f = open("demo.txt","r")
list = f.read()
list = list.split("n") #对行进行切片
list = ["0 "*len(list)]+list+["0 "*len(list)] #加上下的围墙
for i in range(len(list)): #对列进行切片
list[i] = list[i].split()
list[i] = ["0"]+list[i]+["0"] #加左右的围墙
list = np.array(list).astype(np.int32)
row_n = len(list)
col_n = len(list[0])
ans_sit = dp(0,0,row_n-1,col_n-1)
print("找到峰值点位于：",ans_sit)
print("该峰值点大小为：",list[ans_sit[0]+1,ans_sit[1]+1])
f.close()

首先我的输入写在txt文本文件里，通过字符串转换变为二维数组，具体转换过程可以看我上一篇博客——python中字符串转换为二维数组。（需要注意的是如果在windows环境中split后的列表没有空尾巴，所以不用加list.pop()这句话）。有的变动是我在二维数组四周加了“0”的围墙。加围墙可以再我们判断峰值的时候不用考虑边界问题。

max_sit(*n)函数用于找到多个值中最大值的位置，返回其位置，python的内构的max函数只能返回最大值，所以还是需要自己写，*n表示不定长参数，因为我需要在比较田和十（判断峰值）都用到这个函数
def max_sit(*n): #返回最大元素的位置
temp = 0
sit = 0
for i in range(len(n)):
if(n[i]>temp):
temp = n[i]
sit = i
return sit
dp(s1,s2,e1,e2)函数中四个参数的分别可看为startx，starty，endx，endy。即我们查找范围左上角和右下角的坐标值。
m1,m2分别是row 和col的中间值，也就是田字的中间。
def dp(s1,s2,e1,e2):
m1 = int((e1-s1)/2)+s1 #row
m2 = int((e2-s1)/2)+s2 #col

依次比较3行3列中的值找到最大值，注意这里要求二维数组为正方形，如果为矩形需要做调整
for i in range(nub):
t = max_sit(list[s1][s2+i], #第一排
list[m1][s2+i], #中间排
list[e1][s2+i], #最后排
list[s1+i][s2], #第一列
list[s1+i][m2], #中间列
list[s1+i][e2], #最后列
temp)
if(t==6):
pass
elif(t==0):
temp = list[s1][s2+i]
sit_row = s1
sit_col = s2+i
elif(t==1):
temp = list[m1][s2+i]
sit_row = m1
sit_col = s2+i
elif(t==2):
temp = list[e1][s2+i]
sit_row = e1
sit_col = s2+i
elif(t==3):
temp = list[s1+i][s2]
sit_row = s1+i
sit_row = s2
elif(t==4):
temp = list[s1+i][m2]
sit_row = s1+i
sit_row = m2
elif(t==5):
temp = list[s1+i][e2]
sit_row = s1+i
sit_row = m2

判断田字中最大值是不是峰值，并找不出相邻最大值
t = max_sit(list[sit_row][sit_col], #中
list[sit_row-1][sit_col], #上
list[sit_row+1][sit_col], #下
list[sit_row][sit_col-1], #左
list[sit_row][sit_col+1]) #右
if(t==0):
return [sit_row-1,sit_col-1]
elif(t==1):
sit_row-=1
elif(t==2):
sit_row+=1
elif(t==3):
sit_col-=1
elif(t==4):
sit_col+=1
缩小范围，递归求解
if(sit_row<m1):
e1 = m1
else:
s1 = m1
if(sit_col<m2):
e2 = m2
else:
s2 = m2

return dp(s1,s2,e1,e2)
好了，到这里代码基本分析完了。如果还有不清楚的地方欢迎下方留言。
除了这种算法外，我也写一种贪心算法来求解这道题，只可惜最坏的情况下算法复杂度还是O(n^2),QAQ。
大体的思路就是从中间位置起找相邻4个点中最大的点，继续把该点来找相邻最大点，最后一定会找到一个峰值点，有兴趣的可以看一下，上代码：
#!/usr/bin/python3
def dp(n):
temp = (str[n],str[n-9],str[n-1],str[n+1],str[n+9]) #中 上 左 右 下
sit = temp.index(max(temp))
if(sit==0):
return str[n]
elif(sit==1):
return dp(n-9)
elif(sit==2):
return dp(n-1)
elif(sit==3):
return dp(n+1)
else:
return dp(n+9)
f = open("/home/nancy/桌面/demo.txt","r")
list = f.read()
list = list.replace(" ","").split() #转换为列表
row = len(list)
col = len(list[0])
str="0"*(col+3)
for x in list: #加围墙 二维变一维
str+=x+"00"
str+="0"*(col+1)
mid = int(len(str)/2)
print(str,mid)
p = dp(mid)
print (p)
f.close()
以上这篇python分治法求二维数组局部峰值方法就是小编分享给大家的全部内容了，希望能给大家一个参考

㈦ Python笔记-取模运算%

对于该算术运算符： % ，取模运算存在如下定理：

对于一个正整数 而言，一定存在等式 ，代表 可以被拆分成最多 个 并且余下一个 ，此时称 。

例如：正整数 17，存在等式 17 = 3 * 5 + 2，即 17 % 5 = 2.

这里介绍一下数学中的一种运算， 取余运算 。

两者在对正整数的运算中完全没有区别，但是对于负整数的运算，则会存在一定的区别。

但是要记住下面这句话，就可以很好的进行区分：

取余公式中的k要向0靠拢，也就是如果大于等于0，那就要向下取整；如果小于0，那就要向上取整。

取模公式中的k要向负无穷靠拢，不管什么情况，都是向下取整。

或者是

向上取整 math.ceil() 可以理解成 要选择大于等于该数值的整数部分的最小整数；

向下取整 math.floor() 可以理解成 要选择小于等于该数值的整数部分的最大整数。

也就是：

下面做些实际运算，加深一下印象：

㈧ 如何实现在python负无穷大

1.Python有特殊价值float('inf')和float('-inf')。
2. 碰巧的是，在Python 2，None小于的任意整数，所以你None。在Python 3你有（至少）有四种选择： 使用分钟（一）-1。 使用None，每当两个值，明确他们正在测试None。 定义一个包含一个整数或者-∞，正确的新数据类型。

㈨ python中5%-8等于多少

-13
-13。Python是一种极少数能声言兼具简单与功能强大的编程语言，它专注于如何解决问题，而非拘泥于语法与结构。问的是%操作符（字符串格式化，
stringformatting），说明如下，%
[(name)][flags][width].
[precision]typecode(name)为命名，flags
可以有+，，“或0+表示右对齐-表示左对齐“为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐0表示使用0填充。
此外，Python不允许使用0作为除数，否则将
会引发 ZeroDivisionError错误。
在有些编程语言中，0作为除数会得到无穷
大，包括正无穷大或负无穷大。
对于Python 2.x而言，它只提供了一个“/”运算
符，该运算符是Python 3.x中“/”和“//”的综合
版。对于Python 2.x中的“/”而言，它既是整除运算符，也是非整除运算符。规则如下：
·当两个操作数都是整数时，Python 2.x中的“/”就是整除运算符。
·当两个操作数有一个是浮点数（或两个都是浮点数）时，Python 2.x中的“/”就是非整除运算符。