9mod5在计算机里什么意思_百度知道
9mod5在计算机里什么意思
od余数 用法及意义是，可写成2^100≡6。　　再比如说2的100次方的个位是什么，用“mod”来代表几进制。（mod10）　　特别是进制，mod为c　　例如:a除以b余数为c：a mod b=c说明：a≡b(mod c) 的意思是 a和b除以c后余数相同　　读作a与b同余
其他类似问题
为您推荐：
计算机的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Python程序员的10个常见错误 - 博客 - 伯乐在线
& Python程序员的10个常见错误
& 14.4K 阅读
关于Python
是一门解释性的，面向对象的，并具有动态语义的高级编程语言。它高级的内置数据结构，结合其动态类型和动态绑定的特性，使得它在快速应用程序开发（）中颇为受欢迎，同时Python还能作为脚本语言或者胶水语言讲现成的组件或者服务结合起来。Python支持模块（modules）和包（packages），所以也鼓励程序的模块化以及代码重用。
Python简单、易学的语法可能会误导一些Python程序员（特别是那些刚接触这门语言的人们），可能会忽略某些细微之处和这门语言的强大之处。
考虑到这点，本文列出了“十大”甚至是高级的Python程序员都可能犯的，却又不容易发现的细微错误。（注意：本文是针对比《》稍微高级一点读者，对于更加新手一点的Python程序员，有兴趣可以读一读那篇文章）
常见错误1：在函数参数中乱用表达式作为默认值
Python允许给一个函数的某个参数设置默认值以使该参数成为一个可选参数。尽管这是这门语言很棒的一个功能，但是这当这个默认值是可变对象（）时，那就有些麻烦了。例如，看下面这个Python函数定义：
&&& def foo(bar=[]):
# bar是可选参数，如果没有指明的话，默认值是[]
bar.append(&baz&)
# 但是这行可是有问题的，走着瞧…
return bar
人们常犯的一个错误是认为每次调用这个函数时不给这个可选参数赋值的话，它总是会被赋予这个默认表达式的值。例如，在上面的代码中，程序员可能会认为重复调用函数foo() （不传参数bar给这个函数），这个函数会总是返回‘baz’，因为我们假定认为每次调用foo()的时候（不传bar），参数bar会被置为[]（即，一个空的列表）。
那么我们来看看这么做的时候究竟会发生什么：
[&baz&, &baz&]
[&baz&, &baz&, &baz&]
嗯？为什么每次调用foo()的时候，这个函数总是在一个已经存在的列表后面添加我们的默认值“baz”，而不是每次都创建一个新的列表？
答案是一个函数参数的默认值，仅仅在该函数定义的时候，被赋值一次。如此，只有当函数foo()第一次被定义的时候，才讲参数bar的默认值初始化到它的默认值（即一个空的列表）。当调用foo()的时候（不给参数bar），会继续使用bar最早初始化时的那个列表。
由此，可以有如下的解决办法：
&&& def foo(bar=None):
if bar is None:
# 或者用 if not bar:
bar.append(&baz&)
return bar
常见错误2：不正确的使用类变量
看下面一个例子：
&&& class A(object):
&&& class B(A):
&&& class C(A):
&&& print A.x, B.x, C.x
看起来没有问题。
&&& B.x = 2
&&& print A.x, B.x, C.x
嗯哈，还是和预想的一样。
&&& A.x = 3
&&& print A.x, B.x, C.x
我了个去。只是改变了A.x，为啥C.x也变了？
在Python里，类变量通常在内部被当做字典来处理并遵循通常所说的方法解析顺序（）。因此在上面的代码中，因为属性x在类C中找不到，因此它会往上去它的基类中查找（在上面的例子中只有A这个类，当然Python是支持多重继承（multiple inheritance）的）。换句话说，C没有它自己独立于A的属性x。因此对C.x的引用实际上是对A.x的引用。（B.x不是对A.x的引用是因为在第二步里B.x=2将B.x引用到了2这个对象上，倘若没有如此，B.x仍然是引用到A.x上的。——译者注）
常见错误3：在异常处理时错误的使用参数
假设你有如下的代码：
l = [&a&, &b&]
... except ValueError, IndexError:
# 想捕捉两个异常
Traceback (most recent call last):
File &&stdin&&, line 3, in &module&
IndexError: list index out of range
这里的问题在于except语句不会像这样去接受一系列的异常。并且，在Python 2.x里面，语法except Exception, e是用来将异常和这个可选的参数绑定起来（即这里的e），以用来在后面查看的。因此，在上面的代码中，IndexError异常不会被except语句捕捉到；而最终ValueError这个异常被绑定在了一个叫做IndexError的参数上。
在except语句中捕捉多个异常的正确做法是将所有想要捕捉的异常放在一个元组（）里并作为第一个参数给except语句。并且，为移植性考虑，使用as关键字，因为Python 2和Python 3都支持这样的语法，例如：
l = [&a&, &b&]
... except (ValueError, IndexError) as e:
常见错误4：误解Python作用域的规则
Python的作用域解析是基于叫做（Local（本地），Enclosing（封闭），Global（全局），Built-in（内置））的规则进行操作的。这看起来很直观，对吧？事实上，在Python中这有一些细微的地方很容易出错。看这个例子：
&&& x = 10
&&& def foo():
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &&stdin&&, line 2, in foo
UnboundLocalError: local variable 'x' referenced before assignment
这是怎么回事？
这是因为，在一个作用域里面给一个变量赋值的时候，Python自动认为这个变量是这个作用域的本地变量，并屏蔽作用域外的同名的变量。
很多时候可能在一个函数里添加一个赋值的语句会让你从前本来工作的代码得到一个UnboundLocalError。（感兴趣的话可以读一读文章。）
在使用列表（）的时候，这种情况尤为突出。看下面这个例子：
&&& lst = [1, 2, 3]
&&& def foo1():
lst.append(5)
# 这没有问题...
&&& foo1()
[1, 2, 3, 5]
&&& lst = [1, 2, 3]
&&& def foo2():
lst += [5]
# ... 这就有问题了！
&&& foo2()
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &&stdin&&, line 2, in foo
UnboundLocalError: local variable 'lst' referenced before assignment
嗯？为什么foo2有问题，而foo1没有问题？
答案和上一个例子一样，但是更加不易察觉。foo1并没有给lst赋值，但是foo2尝试给lst赋值。注意lst+=[5]只是lst=lst+[5]的简写，由此可以看到我们尝试给lst赋值（因此Python假设作用域为本地）。但是，这个要赋给lst的值是基于lst本身的（这里的作用域仍然是本地），而lst却没有被定义，这就出错了。
常见错误5：在遍历列表的同时又在修改这个列表
下面这个例子中的代码应该比较明显了：
&&& odd = lambda x : bool(x % 2)
&&& numbers = [n for n in range(10)]
&&& for i in range(len(numbers)):
if odd(numbers[i]):
del numbers[i]
# 这不对的：在遍历列表时删掉列表的元素。
Traceback (most recent call last):
File &&stdin&&, line 2, in &module&
IndexError: list index out of range
遍历一个列表或者数组的同时又删除里面的元素，对任何有经验的软件开发人员来说这是个很明显的错误。但是像上面的例子那样明显的错误，即使有经验的程序员也可能不经意间在更加复杂的程序中不小心犯错。
所幸，Python集成了一些优雅的编程范式，如果使用得当，可以写出相当简化和精简的代码。一个附加的好处是更简单的代码更不容易遇到这种“不小心在遍历列表时删掉列表元素”的bug。例如列表推导式（）就提供了这样的范式。再者，列表推导式在避免这样的问题上特别有用，接下来这个对上面的代码的重新实现就相当完美：
&&& odd = lambda x : bool(x % 2)
&&& numbers = [n for n in range(10)]
&&& numbers[:] = [n for n in numbers if not odd(n)]
# 啊，这多优美
&&& numbers
[0, 2, 4, 6, 8]
常见错误6：搞不清楚在闭包（closures）中Python是怎样绑定变量的
看这个例子：
&&& def create_multipliers():
return [lambda x : i * x for i in range(5)]
&&& for multiplier in create_multipliers():
print multiplier(2)
期望得到下面的输出：
但是实际上得到的是：
这是由于Python的后期绑定（late binding）机制导致的，这是指在闭包中使用的变量的值，是在内层函数被调用的时候查找的。因此在上面的代码中，当任一返回函数被调用的时候，i的值是在它被调用时的周围作用域中查找（到那时，循环已经结束了，所以i已经被赋予了它最终的值4）。
解决的办法比较巧妙：
&&& def create_multipliers():
return [lambda x, i=i : i * x for i in range(5)]
&&& for multiplier in create_multipliers():
print multiplier(2)
这下对了！这里利用了默认参数去产生匿名函数以达到期望的效果。有人会说这很优美，有人会说这很微妙，也有人会觉得反感。但是如果你是一名Python程序员，重要的是能理解任何的情况。
常见错误7：循环加载模块
假设你有两个文件，a.py和b.py，在这两个文件中互相加载对方，例如：
在a.py中：
return b.x
在b.py中：
print a.f()
首先，我们试着加载a.py：
&&& import a
没有问题。也许让人吃惊，毕竟有个感觉应该是问题的循环加载在这儿。
事实上在Python中仅仅是表面上的出现循环加载并不是什么问题。如果一个模块以及被加载了，Python不会傻到再去重新加载一遍。但是，当每个模块都想要互相访问定义在对方里的函数或者变量时，问题就来了。
让我们再回到之前的例子，当我们加载a.py时，它再加载b.py不会有问题，因为在加载b.py时，它并不需要访问a.py的任何东西，而在b.py中唯一的引用就是调用a.f()。但是这个调用是在函数g()中完成的，并且a.py或者b.py中没有人调用g()，所以这会儿心情还是美丽的。
但是当我们试图加载b.py时（之前没有加载a.py），会发生什么呢：
&&& import b
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &b.py&, line 1, in &module&
File &a.py&, line 6, in &module&
File &a.py&, line 4, in f
return b.x
AttributeError: 'module' object has no attribute 'x'
恭喜你，出错了。这里问题出在加载b.py的过程中，Python试图加载a.py，并且在a.py中需要调用到f()，而函数f()又要访问到b.x，但是这个时候b.x却还没有被定义。这就产生了AttributeError异常。
解决的方案可以做一点细微的改动。改一下b.py，使得它在g()里面加载a.py：
import a # 只有当g()被调用的时候才加载
print a.f()
这会儿当我们加载b.py的时候，一切安好：
&&& import b
1 # 第一次输出，因为模块a在最后调用了‘print f()’
1 # 第二次输出，这是我们调用g()
常见错误8：与Python标准库模块命名冲突
Python的一个优秀的地方在于它提供了丰富的库模块。但是这样的结果是，如果你不下意识的避免，很容易你会遇到你自己的模块的名字与某个随Python附带的标准库的名字冲突的情况（比如，你的代码中可能有一个叫做email.py的模块，它就会与标准库中同名的模块冲突）。
这会导致一些很粗糙的问题，例如当你想加载某个库，这个库需要加载Python标准库里的某个模块，结果呢，因为你有一个与标准库里的模块同名的模块，这个包错误的将你的模块加载了进去，而不是加载Python标准库里的那个模块。这样一来就会有麻烦了。
所以在给模块起名字的时候要小心了，得避免与Python标准库中的模块重名。相比起你提交一个“”去向上要求改一个标准库里包的名字，并得到批准来说，你把自己的那个模块重新改个名字要简单得多。
常见错误9：不能区分Python 2和Python 3
看下面这个文件foo.py：
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def bad():
bar(int(sys.argv[1]))
except KeyError as e:
print('key error')
except ValueError as e:
print('value error')
在Python 2里，运行起来没有问题：
$ python foo.py 1
$ python foo.py 2
value error
但是如果拿到Python 3上面玩玩：
$ python3 foo.py 1
Traceback (most recent call last):
File &foo.py&, line 19, in &module&
File &foo.py&, line 17, in bad
UnboundLocalError: local variable 'e' referenced before assignment
这是怎么回事？“问题”在于，在Python 3里，在except块的作用域以外，异常对象（exception object）是不能被访问的。（原因在于，如果不这样的话，Python会在内存的堆栈里保持一个引用链直到Python的垃圾处理将这些引用从内存中清除掉。更多的技术细节可以参考。）
避免这样的问题可以这样做：保持在execpt块作用域以外对异常对象的引用，这样是可以访问的。下面是用这个办法对之前的例子做的改动，这样在Python 2和Python 3里面都运行都没有问题。
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def good():
exception = None
bar(int(sys.argv[1]))
except KeyError as e:
exception = e
print('key error')
except ValueError as e:
exception = e
print('value error')
print(exception)
在Py3k里面运行：
$ python3 foo.py 1
$ python3 foo.py 2
value error
（顺带提一下，我们的“”里讨论了从Python 2移植代码到Python 3时需要注意的其他重要的不同之处。）
常见错误10：错误的使用__del__方法
假设有一个文件mod.py中这样使用：
import foo
class Bar(object):
def __del__(self):
foo.cleanup(self.myhandle)
然后试图在another_mod.py里这样：
import mod
mybar = mod.Bar()
那么你会得到一个恶心的AttributeError异常。
为啥呢？这是因为（参考），当解释器关闭时，模块所有的全局变量会被置为空（None）。结果便如上例所示，当__del__被调用时，名字foo已经被置为空了。
使用atexit.register()可以解决这个问题。如此，当你的程序结束的时候（退出的时候），你的注册的处理程序会在解释器关闭之前处理。
这样理解的话，对上面的mod.py可以做如下的修改：
import foo
import atexit
def cleanup(handle):
foo.cleanup(handle)
class Bar(object):
def __init__(self):
atexit.register(cleanup, self.myhandle)
这样的实现方式为在程序正常终止时调用清除功能提供了一种干净可靠的办法。显然，需要foo.cleanup决定怎么处理绑定在self.myhandle上的对象，但你知道怎么做的。
Python 是一门非常强大且灵活的语言，它众多的机制和范式能显著的提高生产效率。不过，和任何一款软件或者语言一样，对它的理解或认识不足的话，常常是弊大于利的，并会处于一种“一知半解”的状态。
多熟悉Python的一些关键的细微的地方，比如（但不局限于）本文中提到的这些问题，可以帮你更好的使用这门语言的同时帮你避免一些常见的陷阱。
感兴趣的话可以读一读这篇“”，了解一些能够区分Python程序员的面试题目。
希望您能在本文学到有用的地方，并欢迎您的反馈。
关于作者：
为作者带来更多读者；为读者筛选优质内容；专注IT互联网。
o 109 回复
最新评论（期待您也参与评论）
汇集优质的Python技术文章和资源。人生苦短，我用Python！
JavaScript, CSS, HTML5 这里有前端的技术干货！
关注安卓移动开发业界动态，分享技术文章和优秀工具资源。
关注iOS移动开发业界动态，分享技术文章和优秀工具资源。
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线博客团队正试图以我们微薄的力量，把优秀的原创/译文分享给读者，做一个小而精的精选博客，为“快餐”添加一些“营养”元素。
欢迎关注更多频道
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选博客文章
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
（加好友请注明来意）
网站使用问题
请在询问或者反馈
& 2015 伯乐在线
赞助云主机的海词问答和网友补充：
相关词典网站：mod 模运算到底是什么？
mod 模运算到底是什么？
09-03-09 & 发布
模p运算 给定一个正整数p，任意一个整数n，一定存在等式 n = kp + r 其中k、r是整数，且 0 ≤ r & p，称呼k为n除以p的商，r为n除以p的余数。 对于正整数p和整数a,b，定义如下运算： 取模运算：a mod p 表示a除以p的余数。 模p加法：(a + b) mod p ，其结果是a+b算术和除以p的余数，也就是说，(a+b) = kp +r，则 (a+b) mod p = r。 模p减法：(a-b) mod p ，其结果是a-b算术差除以p的余数。 模p乘法：(a × b) mod p，其结果是 a × b算术乘法除以p的余数。 可以发现,模p运算和普通的四则运算有很多类似的规律，如： 规律 公式 结合率 ((a+b) mod p + c)mod p = (a + (b+c) mod p) mod p ((a*b) mod p * c)mod p = (a * (b*c) mod p) mod p 交换率 (a + b) mod p = (b+a) mod p (a × b) mod p = (b × a) mod p 分配率 ((a +b)mod p × c) mod p = ((a × c) mod p + (b × c) mod p) mod p 简单的证明其中第一个公式： ((a+b) mod p + c) mod p = (a + (b+c) mod p) mod p 假设 a = k1 p + r1 b = k2 p + r2 c = k3 p + r3 a+b = (k1 + k2) p + (r1 + r2) 如果(r1 + r2) &= p ，则 (a+b) mod p = (r1 + r2) -p 否则 (a+b) mod p = (r1 + r2) 再和c进行模p和运算，得到 结果为 r1 ＋ r2 + r3的算术和除以p的余数。 对右侧进行计算可以得到同样的结果，得证。 模p相等 如果两个数a、b满足a mod p = b mod p，则称他们模p相等，记做 a ≡ b mod p可以证明，此时a、b满足 a = kp + b，其中k是某个整数。 对于模p相等和模p乘法来说，有一个和四则运算中迥然不同得规则。在四则运算中，如果c是一个非0整数，则 ac = bc 可以得出 a =b 但是在模p运算中，这种关系不存在，例如： (3 x 3) mod 9 = 0 (6 x 3) mod 9 = 0 但是 3 mod 9 = 3 6 mod 9 =6 定理（消去律）：如果gcd(c,p) ＝ 1 ，则 ac ≡ bc mod p 可以推出 a ≡ b mod p 证明： 因为ac ≡ bc mod p 所以ac = bc + kp，也就是c(a-b) = kp 因为c和p没有除1以外的公因子，因此上式要成立必须满足下面两个条件中的一个 1) c能整除k 2) a = b 如果2不成立，则c|kp 因为c和p没有公因子，因此显然c|k，所以k = ck' 因此c(a-b)kp可以表示为c(a-b) =ck'p 因此a-b = k'p，得出a ≡ b mod p 如果a = b，则a ≡ b mod p 显然成立 得证 欧拉函数 欧拉函数是数论中很重要的一个函数，欧拉函数是指：对于一个正整数n，小于n且和n互质的正整数的个数，记做：φ(n)，其中φ(1)被定义为1，但是并没有任何实质的意义。 定义小于n且和n互质的数构成的集合为Zn，称呼这个集合为n的完全余数集合。 显然，对于素数p，φ(p)= p -1.对于两个素数p、q，他们的乘积n = pq 满足φ(n) =(p-1)(q-1) 证明：对于质数p,q，满足φ(n) =(p-1)(q-1) 考虑n的完全余数集Zn = { 1,2,....,pq -1} 而不和n互质的集合由下面三个集合的并构成： 1) 能够被p整除的集合{p,2p,3p,....,(q-1)p} 共计q-1个 2) 能够被q整除的集合{q,2q,3q,....,(p-1)q} 共计p-1个 3) {0} 很显然，1、2集合中没有共同的元素，因此Zn中元素个数 ＝ pq - (p-1 + q- 1 + 1) = (p-1)(q-1) 欧拉定理 对于互质的整数a和n，有aφ(n) ≡ 1 mod n 证明： 首先证明下面这个命题： 对于集合Zn={x1,x2,...,xφ(n)}，考虑集合 S = {ax1 mod n,ax2mod n,...,axφ(n)mod n} 则S = Zn 1) 由于a,n互质，xi也与n互质，则axi也一定于p互质，因此 任意xi，axi mod n 必然是Zn的一个元素 2) 对于Zn中两个元素xi和xj，如果xi ≠ xj 则axi mod n ≠ axi mod n，这个由a、p互质和消去律可以得出。 所以，很明显，S=Zn 既然这样，那么 （ax1 × ax2×...×axφ(n)）mod n = （ax1 mod n × ax2mod n × ... × axφ(n)mod n）mod n = （x1 × x2 × ... × xφ(n)）mod n 考虑上面等式左边和右边 左边等于(aφ(n) × （x1 × x2 × ... × xφ(n)）mod n) mod n 右边等于x1 × x2 × ... × xφ(n)）mod n 而x1 × x2 × ... × xφ(n)）mod n和p互质 根据消去律，可以从等式两边约去，就得到： aφ(n) ≡ 1 mod n 推论：对于互质的数a、n，满足aφ(n)+1 ≡ a mod n 费马定理a是不能被质数p整除的正整数，则有ap-1 ≡ 1 mod p证明这个定理非常简单，由于φ(p) = p-1，代入欧拉定理即可证明。同样有推论：对于不能被质数p整除的正整数a，有ap ≡ a mod p 参考资料：
请登录后再发表评论!
模p运算 给定一个正整数p，任意一个整数n，一定存在等式 n = kp + r 其中k、r是整数，且 0 ≤ r & p，称呼k为n除以p的商，r为n除以p的余数。 对于正整数p和整数a,b，定义如下运算： 取模运算：a mod p 表示a除以p的余数。 模p加法：(a + b) mod p ，其结果是a+b算术和除以p的余数，也就是说，(a+b) = kp +r，则 (a+b) mod p = r。 模p减法：(a-b) mod p ，其结果是a-b算术差除以p的余数。 模p乘法：(a × b) mod p，其结果是 a × b算术乘法除以p的余数。 可以发现,模p运算和普通的四则运算有很多类似的规律，如： 规律 公式 结合率 ((a+b) mod p + c)mod p = (a + (b+c) mod p) mod p ((a*b) mod p * c)mod p = (a * (b*c) mod p) mod p 交换率 (a + b) mod p = (b+a) mod p (a × b) mod p = (b × a) mod p 分配率 ((a +b)mod p × c) mod p = ((a × c) mod p + (b × c) mod p) mod p 简单的证明其中第一个公式： ((a+b) mod p + c) mod p = (a + (b+c) mod p) mod p 假设 a = k1 p + r1 b = k2 p + r2 c = k3 p + r3 a+b = (k1 + k2) p + (r1 + r2) 如果(r1 + r2) &= p ，则 (a+b) mod p = (r1 + r2) -p 否则 (a+b) mod p = (r1 + r2) 再和c进行模p和运算，得到 结果为 r1 ＋ r2 + r3的算术和除以p的余数。 对右侧进行计算可以得到同样的结果，得证。 模p相等 如果两个数a、b满足a mod p = b mod p，则称他们模p相等，记做 a ≡ b mod p可以证明，此时a、b满足 a = kp + b，其中k是某个整数。 对于模p相等和模p乘法来说，有一个和四则运算中迥然不同得规则。在四则运算中，如果c是一个非0整数，则 ac = bc 可以得出 a =b 但是在模p运算中，这种关系不存在，例如： (3 x 3) mod 9 = 0 (6 x 3) mod 9 = 0 但是 3 mod 9 = 3 6 mod 9 =6 定理（消去律）：如果gcd(c,p) ＝ 1 ，则 ac ≡ bc mod p 可以推出 a ≡ b mod p 证明： 因为ac ≡ bc mod p 所以ac = bc + kp，也就是c(a-b) = kp 因为c和p没有除1以外的公因子，因此上式要成立必须满足下面两个条件中的一个 1) c能整除k 2) a = b 如果2不成立，则c|kp 因为c和p没有公因子，因此显然c|k，所以k = ck' 因此c(a-b)kp可以表示为c(a-b) =ck'p 因此a-b = k'p，得出a ≡ b mod p 如果a = b，则a ≡ b mod p 显然成立 得证 欧拉函数 欧拉函数是数论中很重要的一个函数，欧拉函数是指：对于一个正整数n，小于n且和n互质的正整数的个数，记做：φ(n)，其中φ(1)被定义为1，但是并没有任何实质的意义。 定义小于n且和n互质的数构成的集合为Zn，称呼这个集合为n的完全余数集合。 显然，对于素数p，φ(p)= p -1.对于两个素数p、q，他们的乘积n = pq 满足φ(n) =(p-1)(q-1) 证明：对于质数p,q，满足φ(n) =(p-1)(q-1) 考虑n的完全余数集Zn = { 1,2,....,pq -1} 而不和n互质的集合由下面三个集合的并构成： 1) 能够被p整除的集合{p,2p,3p,....,(q-1)p} 共计q-1个 2) 能够被q整除的集合{q,2q,3q,....,(p-1)q} 共计p-1个 3) {0} 很显然，1、2集合中没有共同的元素，因此Zn中元素个数 ＝ pq - (p-1 + q- 1 + 1) = (p-1)(q-1) 欧拉定理 对于互质的整数a和n，有aφ(n) ≡ 1 mod n 证明： 首先证明下面这个命题： 对于集合Zn={x1,x2,...,xφ(n)}，考虑集合 S = {ax1 mod n,ax2mod n,...,axφ(n)mod n} 则S = Zn 1) 由于a,n互质，xi也与n互质，则axi也一定于p互质，因此 任意xi，axi mod n 必然是Zn的一个元素 2) 对于Zn中两个元素xi和xj，如果xi ≠ xj 则axi mod n ≠ axi mod n，这个由a、p互质和消去律可以得出。 所以，很明显，S=Zn 既然这样，那么 （ax1 × ax2×...×axφ(n)）mod n = （ax1 mod n × ax2mod n × ... × axφ(n)mod n）mod n = （x1 × x2 × ... × xφ(n)）mod n 考虑上面等式左边和右边 左边等于(aφ(n) × （x1 × x2 × ... × xφ(n)）mod n) mod n 右边等于x1 × x2 × ... × xφ(n)）mod n 而x1 × x2 × ... × xφ(n)）mod n和p互质 根据消去律，可以从等式两边约去，就得到： aφ(n) ≡ 1 mod n 推论：对于互质的数a、n，满足aφ(n)+1 ≡ a mod n 费马定理a是不能被质数p整除的正整数，则有ap-1 ≡ 1 mod p证明这个定理非常简单，由于φ(p) = p-1，代入欧拉定理即可证明。同样有推论：对于不能被质数p整除的正整数a，有ap ≡ a mod p
请登录后再发表评论!
MOD是取模运算，例如求8的模运算，所得的结果就可看作八进制数的基类数字0-7， 如:6mod8=6,9mod8=1,8mod8=0    也就是取余运算
请登录后再发表评论!
请登录后再发表评论!