python 在一个范围内,寻找另一个数字的所有整数倍数,并计算一共有多少个倍数

就是统计频度,los是一个tuple或者list类的对象,unique是去除了重复的,frequency是对应于unique的频度统计.
遍历los,如果当前元素不在unique中,unique和frequency都添加一位,前者添加0,后者添加当前元素. 对于当前元素,由于不管第一次遇到或者第n次遇到,都找出在unique中的索引.然后把frequency中加1
最后result中每个元素就是无重复的los中的元素和其频度的二元list

up_limit = int(input("please enter a positive integer:"))
print(" the Fibonacci sequence up to %d:" %(up_limit))
t1,t2=0,1
a=[t1,t2]
while 1:
t1,t2=t2,t1+t2
if t2<=up_limit:
a.append(t2)
else:
break
print(','.join(str(i) for i in a))

暂时只能想到这样的,结果是排序后的键列表.
d = {'a':3,'c':4,'b':3,'d':2,'f':4,'e':2}
result = []
keys = sorted(d,key=lambda k:d[k])
for k in keys:
if not result:
result.append(k)
elif d[k] == d[result[-1]] and k < result[-1]:
result.insert(len(result) - 1,k)
else:
result.append(k)
print result

我晕.....编译软件 都不会自己搜索下载 还学P的编程啊?? python 最新是3.X 3.X和2.X 有一些语法区别

x = 5
y = 2
if x%y == 0:
pass # 当x能够整除y时,执行xx操作

def Q_2(): n = input("Enter n:") term = input("Enter number of terms to sum: ") s = 0 for i in range(term): s += n/(2.0*i+1) print s def Q_3(): name = input("Enter a file name:") f = open(name,'r') lines = 0 char = 0 words = 0 for line in f: line = line.strip().split() lines += 1 for word in line: words += 1 chars +=len(word) f.close() print lines print words print chars def Q_4(): n = input("Enter length in inch: ") print n,"inches = ",n * 2.54,"cm" def Q_7(): name = input("Enter a file name:") f = open(name,'r') w = open("anotherFile.txt",'w') for line in f: line = line.strip().split() name = line[0][:-1] score = int(line[1]) if score >= 90: g = "A" elif score >=80: g = "B" elif score >=70: g = "C" elif score >=60: g = "D" else: g = "F" w.write(name+":",g) w.write("n") f.close() w.close() 写了半天，多给点分吧

def new_dict(dict1, dict2):
newdict = {}
newdict.update(dict1)
newdict.update(dict2)
d = newdict.copy()
for i in d.iterkeys():
if dict1.has_key(i) and dict2.has_key(i):
newdict.pop(i)
return newdict

con = { }
data = raw_input( 'input:' )
con[ 'singular' ] = len( [ x for x in data if int( x ) % 2 ] )
con[ 'even' ] = len( data ) - con[ 'singular' ]
print( con )

太简单，我都差点不好意思回答了。def area(self):
""" (Rectangle) -> number

Return the area of this rectangle.
>>> r = Rectangle(10, 20)
>>> r.area()
200
"""
return self.width * self.height

你最后那个b/(2.0+a)结果怎么是5啊?正确的应该是如下：
>>> a = 3
>>> b = 4
>>> b/(2+a)
0
>>> b/(2.0+a)
0.80000000000000004
之所以b/(2+a)的结果是0,是因为b是整数,(2+a)也是整数,所以整数除整数结果还是整数,自然就把小数点给去掉了；而b/(2.0+a)的结果是0.80000000000000004,是因为(2.0+a)是浮点数,当整数遇到浮点数时,最后结果就要是浮点数,这是规定,所以结果是0.80000000000000004.

你好：
你自己已经写好了；
只不过再加一些,判断语句就行了：
像try.except；等
或者说我没理解好.

This paper,the python (Python molurus Linnaeus) of the digestive,respiratory,circulatory and urogenital systems form a preliminary structure report.Python found in the pancreas,liver,lung morphology has some special.A serpent's the dirty triangular in section and section,the lobules,Liver as a leaf,right lung than the left lung long ,This with the relevant reports are not unanimous

你好：
第一个参数是你要查找的元素,就是你想要找谁
第二个参数是：从那个位置开始（从0计数）
第三个参数是：结束的位置

16.
def all_pairs(xs,ys):
xy_list=[]
for x in xs:
for y in ys:
xy=(x,y)
xy_list.append(xy)
return(xy_list)
all_pairs([1,2,3], ['a','b'])

17.
def stringify_pairs(pairs):
xystr_list=[]
for xy in pairs:
(x, y)=xy
xystr=str(x)+str(y)
xystr_list.append(xystr)
return(xystr_list)
stringify_pairs([(1,"hi"),(True,False),(3,4)])

class Circle:

""" A circle with a radius. """

def __init__(self, r):
""" (Circle, number)

Create a circle with a radius r.

>>> c = Circle(10)
>>> c.radius
10
"""
self.radius = r


def tester():
c = Circle(10)
print c.radius

if __name__ == "__main__":
tester()

*表示输出时字符所占的宽度.在'%.*s%*.s'%(2, "abce", 3, "324223")这个例子中,第一个*表示输出的字符所占的宽度为2,输出的字符对象是‘abcd’,但由于宽度制定为2,所以只会输出‘ab’.同理,第二个*表示输出的字符所占宽度为3,故而输出‘324’.

$ python
Python 2.7.3 (default, Jan2 2013, 16:53:07)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def round_sum(*args):
...return sum(map(lambda x: round(x, -1), args))
...
>>> round_sum(16, 17, 18)
60.0
>>> round_sum(12, 13, 14)
30.0
>>> round_sum(6, 4, 4)
10.0
>>>

os.walk

import socket的话
要用socket.AF_INET
因为AF_INET这个值在socket的名称空间下
from socket import*
是把socket下的所有名字引入当前名称空间

最本质的区别：第一种方法得出的a是列表,而第二种的a是字典
用python语句表达来看就是：
1.type(a) == list
2.type(a) == dict
在交互式界面下显示：
第一种：
>>> a
[{'name':'fokil'}]
此时a是一个列表,他具有列表的一切方法和属性,但不具备任何字典的方法和属性.列表可以有N个元素,元素的类型是任意的,与列表本身无关.而此时的a有一个元素,该元素是一个字典——但这并不代表整个列表a带有任何字典的性质.明白?
第二种：
>>> a
{'name':['fokil']}
同上,此时a是一个字典,具有字典的一切方法和属性,但不具备任何列表的方法和属性.字典可以有N个元素,每个元素由一对key和内容的组合构成.key可以是任何单一对象的类型（不能是列表或字典——但可以是元组.当然,还可以是数字、字符/字符串,甚至是文件对象）,而key对应的内容则可以是任意类型的.在此时,a中只有一个元素,key是一个字符串,而内容则是一个含有一个字符串元素的列表——同样,这不意味着a具有任何的列表性质
总而言之,严格的讲：没有“字典列表”或“列表字典”这种概念
只有一个列表,他包含的元素的类型是字典——当然,列表中的元素可以是不同类型的,譬如：
a = [1, 'test', [2,3,4], {'name':'fokil'}]
同理,只有一个字典,他包含的元素中的一部分是列表（当然,key部分不可能是列表）.当然,也有可能是不同类型的元素：
a = {1:'b',(1,2,3):[4,5,6],'test':{'test2':['test3']}}

没有用过nltk这个机器学习的库.不过从语法解析上看.你的格式不对.我略略查了一下,它的语法应该是这样子S -> 'NP' | 'VP'PP -> 'P' | 'NP' 你修改一下看看.另外它的noterminals似乎是一个特殊含义.不是种换行符.下面是一个较完整的示例-def cfg_demo():
"""
A demonstration showing how C{ContextFreeGrammar}s can be created and used.
""" from nltk import nonterminals, Production, parse_cfg # Create some nonterminals
S, NP, VP, PP = nonterminals('S, NP, VP, PP')
N, V, P, Det = nonterminals('N, V, P, Det')
VP_slash_NP = VP/NP print 'Some nonterminals:', [S, NP, VP, PP, N, V, P, Det, VP/NP]
print ' S.symbol() =>', `S.symbol()`
print print Production(S, [NP]) # Create some Grammar Productions
grammar = parse_cfg("""
S -> NP VP
PP -> P NP
NP -> Det N | NP PP
VP -> V NP | VP PP
Det -> 'a' | 'the'
N -> 'dog' | 'cat'
V -> 'chased' | 'sat'
P -> 'on' | 'in'
""") print 'A Grammar:', `grammar`
print ' grammar.start() =>', `grammar.start()`
print ' grammar.productions() =>',
# Use string.replace(...) is to line-wrap the output.
print `grammar.productions()`.replace(',', ',n'+' '*25)
print print 'Coverage of input words by a grammar:'-def cfg_demo():
"""
A demonstration showing how C{ContextFreeGrammar}s can be created and used.
"""
from nltk import nonterminals, Production, parse_cfg
# Create some nonterminals
S, NP, VP, PP = nonterminals('S, NP, VP, PP')
N, V, P, Det = nonterminals('N, V, P, Det')
VP_slash_NP = VP/NP
print 'Some nonterminals:', [S, NP, VP, PP, N, V, P, Det, VP/NP]
print ' S.symbol() =>', `S.symbol()`
print
print Production(S, [NP])
# Create some Grammar Productions
grammar = parse_cfg("""
S -> NP VP
PP -> P NP
NP -> Det N | NP PP
VP -> V NP | VP PP
Det -> 'a' | 'the'
N -> 'dog' | 'cat'
V -> 'chased' | 'sat'
P -> 'on' | 'in'
""")
print 'A Grammar:', `grammar`
print ' grammar.start() =>', `grammar.start()`
print ' grammar.productions() =>',
# Use string.replace(...) is to line-wrap the output.
print `grammar.productions()`.replace(',', ',n'+' '*25)
print
print 'Coverage of input words by a grammar:'- from nltk import nonterminals, Production, parse_cfg # Create some nonterminals S, NP, VP, PP = nonterminals('S, NP, VP, PP') N, V, P, Det = nonterminals('N, V, P, Det') VP_slash_NP = VP/NP print 'Some nonterminals:', [S, NP, VP, PP, N, V, P, Det, VP/NP] print ' S.symbol() =>', `S.symbol()` print print Production(S, [NP]) # Create some Grammar Productions grammar = parse_cfg(""" S -> NP VP PP -> P NP NP -> Det N | NP PP VP -> V NP | VP PP Det -> 'a' | 'the' N -> 'dog' | 'cat' V -> 'chased' | 'sat' P -> 'on' | 'in' """) print 'A Grammar:', `grammar` print ' grammar.start() =>', `grammar.start()` print ' grammar.productions() =>', # Use string.replace(...) is to line-wrap the output. print `grammar.productions()`.replace(',', ',n'+' '*25) print print 'Coverage of input words by a grammar:' print grammar.covers(['a','dog']) print grammar.covers(['a','toy']) toy_pcfg1 = parse_pcfg(""" S -> NP VP [1.0] NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15] Det -> 'the' [0.8] | 'my' [0.2] N -> 'man' [0.5] | 'telescope' [0.5] VP -> VP PP [0.1] | V NP [0.7] | V [0.2] V -> 'ate' [0.35] | 'saw' [0.65] PP -> P NP [1.0] P -> 'with' [0.61] | 'under' [0.39] """) toy_pcfg2 = parse_pcfg(""" S -> NP VP [1.0] VP -> V NP [.59] VP -> V [.40] VP -> VP PP [.01] NP -> Det N [.41] NP -> Name [.28] NP -> NP PP [.31] PP -> P NP [1.0] V -> 'saw' [.21] V -> 'ate' [.51] V -> 'ran' [.28] N -> 'boy' [.11] N -> 'cookie' [.12] N -> 'table' [.13] N -> 'telescope' [.14] N -> 'hill' [.5] Name -> 'Jack' [.52] Name -> 'Bob' [.48] P -> 'with' [.61] P -> 'under' [.39] Det -> 'the' [.41] Det -> 'a' [.31] Det -> 'my' [.28] """)

import re
def get_poem_lines(poem):
return re.split(r's*n+s*', poem.strip())

import random
usernum=0
computernum=0
for i in range(3):
input("----------------------------------n请按回车键投骰子")
num1=random.randint(1,6)
num2=random.randint(1,6)
tmpall1=num1+num2
print("你投的点数为"+str(num1)+"和"+str(num2)+",总数是"+str(tmpall1))
print("计算机开始投骰子...")
num3=random.randint(1,6)
num4=random.randint(1,6)
tmpall2=num3+num4
print("计算机投的点数为"+str(num3)+"和"+str(num4)+",总数是"+str(tmpall2))
if tmpall1>tmpall2:
print("你赢了本局")
elif tmpall1print("计算机赢了本局")
else:
print("双方平局")
usernum=usernum+tmpall1
computernum=computernum+tmpall2

if usernum>computernum:
print("#########################n你赢了比赛")
elif usernumprint("#########################n计算机赢了比赛")
else:
print("#########################n双方打平")看看是不是你要的

我没记错的话 u是Unicode的意思 表面这个字符串是用Unicode编码的
{u'last_running_time':u'2014-07-01 17:22:15'}
这应该是一个 字典
key是字符串
与之对应的value也是个字符串 而且这两个字符串都是用Unicode编码

NINT是四舍五入取整
在python中用round直接完成.
算法上其实是加0.5后再截尾取整
3.4 +0.5得3.9 ...截尾得3
3.6 +0.5得4.1 ...截尾得4

math.exp() - 自然指数函数 e^x
math.sin() - 正弦函数 sin(x)
math.cos() - 余弦函数 cos(x)
math.e - 数学自然数 = 2.71828.

这个简单.假设你要N个p t组合,p 和 t的范围是 [pmin,pmax],[tmin,tmax].:
import random
N = 100
pmin = 0
pmax = 1000
tmin = 0
tmax = 100
r = random.Random()
r.seed() #刷新随即数种子
for i in range(N)
p = r.randint(pmin,pmax)
t = r.randint(rmin,rmax)
s = p*t
print p,t,s
可以把N pmin pmax tmin tmax,设置为你需要的参数.

程序如下,使用while(i

用加法呗 字数

y = [1, 2, 3, 4, 6, 7]
x = [2, 4, 6, 2, 6, 3]
print x[y.index(max(y))]

Pseudocode是伪代码的意思,题意是让你用Python把这段伪代码的逻辑实现出来#!/usr/bin/env pythondef swap(alist,index1,index2):tmp = alist[index1]alist[index1] = alist[index2]alist[index2] = tmpdef bubble_so...

把你的shebang改成“#!/usr/local/bin/python2.6”试试.可能你的python2.6没有在$PATH里面,所以env不知道.

很久之前自己写的了,用的就是高级一点的穷举,还挺快的.
附带一个gui
求给分啊
两个文件,cui负责算数gui是界面,亲测可运行的
")
Button(text = "计算", command = calculate).pack()
initvariable()
drawframe()

ifile=raw_input('input:')
ofile=raw_input('output:')
tmp=[]
with open(ifile,'r') as f0:
for i in f0:
if i!='' and i[0]!='#':
tmp.append(i.split())
with open(ofile,'w') as f1:
f1.writelines(['Total animals = %d'%len(tmp),
'Dangerous = %d'%len(filter(lambda x:x[3]=='dangerous',tmp)),
'Brown and dangerous = %d'%len(filter(lambda x:x[3]=='dangerous' and x[0]=='brown',tmp)),
'Large and safe = %d'%len(filter(lambda x:x[1]=='large' and x[3]=='safe',tmp)),
'Safe with red color or hard flesh = %d'%len(filter(lambda x:x[0]=='red' or x[2]=='hard' and x[3]=='safe',tmp))])

拼写错误:
hgh = x
改成high = x

题主是用的什么库?python里本身没有“向量”的数据结构,只有List.

total = sum([prices[fruit] * stock[fruit] for fruit in prices]) 是这样吗

x = d.keys()
x.sort()
x

选 B。 list可以存放任意类型，但不是有序的，否则也不会有sort方法了。len实际上通过__len__来实现的，对string 和list都支持。string、list都可变，python不可变的是tuple

# -*- coding:utf-8 -*-
import string
mystring = 'apple苹果橘子orange'
english = []
chinese = []
for i in mystring.decode('utf-8'):
if i in string.ascii_letters:
english.append(i)
else:
chinese.append(i)
print 'English:'+''.join(english)
print 'Chinese:'+''.join(chinese)

datas = [1,2,3,4]
s = d = 0
for i in datas:
if i%2 == 0:
d+=1
else:
s+=1
if s > d:
print '奇数多'
elif s < d:
print '偶数多'
else:
print '一样多'

p.sort(reverse=True)
for i in p:
del mylist[i]
这样是删掉index是2,5,6,7,8的,如果你要第2,5,6,7,8项的话,应该是del mylist[i-1]

en_dict = {}
stop_en_dict = {}

for key in stop_en_dict.keys():
if key in en_dict:
del en_dict[key]

print en_dict

不知道你给的数据是10进还是16进的,两个都写一下好了def digit_sum_16( number ):
con = 0
while number:
con += number 0xF
number >>= 4
return con


def digit_sum_10( number ):
con = 0
while number:
con += number % 10
number /= 10
return con

a = "5“ ''给a赋值,字符5
b = a ''给b赋值,b值等于a值,即字符5
c = b * 4 ’‘b*4指四个b值相加,因为是字符所以结果是5555,其结果为字符串
print(c) ’‘输出c
c = int (c) ’‘赋值c为整形,即5千5百5十5
print ( c * 2) ’‘c*2即指数值c乘以2,即5555x2的值11110

dict是一种散列表结构,就是说数据输入后按特征已经被散列了,有自己的顺序.本身不记录原输入顺序.
如果一定需要输入顺序,建议
方案1,不使用dict,使用元组的列表,比如[('sam',''),('beta',''),('ccc',''),('abc','')]
这种结构是记录输入顺序的、有序的,也能方便地转换成dict.
方案2,另用一列表记录下输入时的顺序,比如['sam','beta','ccc','abc']