相关疑难解决方法(0)

加入清单:

>>> ''.join([ str(_) for _ in xrange(10) ])
'0123456789'

join 必须采取迭代.

显然,join这个论点是[ str(_) for _ in xrange(10) ],这是一个列表理解.

看这个:

>>>''.join( str(_) for _ in xrange(10) )
'0123456789'

现在,join这个论点只是str(_) for _ in xrange(10),不[],但结果是一样的.

为什么？是否str(_) for _ in xrange(10)也会产生一个列表或一个可迭代？

我正在尝试使用以下方法打印出Python路径文件夹:

import sys
print sys.path

输出是这样的:

>>> print sys.path
['.', '/usr/bin', '/home/student/Desktop', '/home/student/my_modules', '/usr/lib/pyth
on2.6', '/usr/lib/python2.6/plat-linux2', '/usr/lib/python2.6/lib-tk', '/usr/lib/pyth
on2.6/lib-old', '/usr/lib/python2.6/lib-dynload', '/usr/local/lib/python2.6/dist-pack
ages', '/usr/lib/python2.6/dist-packages', '/usr/lib/python2.6/dist-packages/PIL', '/
usr/lib/python2.6/dist-packages/gst-0.10', '/usr/lib/pymodules/python2.6', '/usr/lib/
python2.6/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.6/gtk-2.0', '/usr/lib/p
ython2.6/dist-packages/wx-2.8-gtk2-unicode']

如何将它们打印成单独的行,以便我可以正确解析它们？

它应该是这样的:

/usr/bin
/home/student/Desktop
/home/student/my_modules
etc

我正在回答这个问题,我更喜欢这里的生成器表达并使用它,我认为它会更快,因为生成器不需要先创建整个列表:

>>> lis=[['a','b','c'],['d','e','f']]
>>> 'd' in (y for x in lis for y in x)
True

Levon在他的解决方案中使用了列表理解,

>>> lis = [['a','b','c'],['d','e','f']]
>>> 'd' in [j for i in mylist for j in i]
True

但是当我做这些LC的时间结果比生成器快时:

~$ python -m timeit -s "lis=[['a','b','c'],['d','e','f']]" "'d' in (y for x in lis for y in x)"
    100000 loops, best of 3: 2.36 usec per loop
~$ python -m timeit -s "lis=[['a','b','c'],['d','e','f']]" "'d' in [y for x in lis for y …

我想创建一个接受短文本并以所谓的Jaden Case模式返回的函数，其中每个单词的首字母均为大写（我可以找到的最佳参考）。

例如"Hi, I'm twenty years old"应该返回"Hi I'm Twenty Years Old"。

我已经尝试过自己解决此问题，但是撇号后的字母变成大写字母，而实际上不应该。

我的尝试：

def toJadenCase(string):
    for letter in string:
        if letter == "\'" :
            letter[+1].lowercase()
        else:
            return string.title()
    return string

我正在尝试用str.joinPython实现我自己的方法，例如： ''.join(['aa','bbb','cccc'])returns 'aabbbcccc'。我知道使用 join 方法进行字符串连接会导致线性（结果的字符数）复杂性，并且我想知道如何做到这一点，因为在'+'for 循环中使用运算符会导致二次复杂性，例如：

res=''
for word in ['aa','bbb','cccc']:
  res = res +  word

由于字符串是不可变的，因此每次迭代都会复制一个新字符串，从而导致运行时间成二次方。但是，我想知道如何在线性时间内完成它或找到''.join确切的工作原理。

我在任何地方都找不到线性时间算法，也找不到 str.join(iterable) 的实现。任何帮助深表感谢。

可以说我有这个字符串"abcd"

现在我想用'd'替换所有'a',我想用'a'替换所有''s'.问题是string.replace在这种情况下不起作用.

"ABCD" .replace( '一个', 'd').代替( 'd', 'a')的

ABCA

预期输出为"dbca"

我怎么会这样做？

我想从给定的字符串创建一个新的字符串,使用替换的大写和小写.

我已经尝试迭代字符串并首先将大写字母更改为新字符串,然后再将小写字母改为另一个新字符串.

def myfunc(x):
    even = x.upper()
    lst = list(even)
    for itemno in lst:
        if (itemno % 2) !=0:
            even1=lst[1::2].lowercase()
        itemno=itemno+1   
    even2=str(even1)
    print(even2)

由于我无法更改给定的字符串,因此我需要一种创建新字符串备用上限的好方法.

难道一个比较有效的方法来扩展字符串有人知道，例如fred，是字符串的长度plaintext-这样fred会变成fredfredf-比这个？

# key='fred', msg='plaintext'?

def keypad(key, msg):
    while len(key) < len(msg):
        key += key
    key = key[:len(msg)]
    return key

我有一个基于 Orm 的对象列表。我现在想连接一些由“|”分隔的属性 （管道），然后使用“\n”连接所有对象。

我试过：

class A(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

obj_list = [A("James", 42), A("Amy", "23")]
"\n".join("|".join(o.name, o.age for o in obj_list))

File "<console>", line 1
SyntaxError: Generator expression must be parenthesized if not sole Argument

究竟什么必须加括号？

有什么提示吗？

保护你。

我有以下句子

a = "you don't need a dog"

和一本字典

dict =  {"don't": "do not" }

但我不能使用字典来使用下面的代码映射句子中的单词:

''.join(str(dict.get(word, word)) for word in a)

输出:

"you don't need a dog"

我究竟做错了什么？