将包含所有字符串的列表转换为小写或大写

它可以用列表理解来完成

>>> [x.lower() for x in ["A", "B", "C"]]
['a', 'b', 'c']
>>> [x.upper() for x in ["a", "b", "c"]]
['A', 'B', 'C']

或map函数

>>> list(map(lambda x: x.lower(), ["A", "B", "C"]))
['a', 'b', 'c']
>>> list(map(lambda x: x.upper(), ["a", "b", "c"]))
['A', 'B', 'C']

列表理解是我的做法，这是“python”的方式。下面的文字记录展示了如何将一个列表全部转换为大写，然后再转换回小写:

pax@paxbox7:~$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.


>>> x = ["one", "two", "three"] ; x
['one', 'two', 'three']


>>> x = [element.upper() for element in x] ; x
['ONE', 'TWO', 'THREE']


>>> x = [element.lower() for element in x] ; x
['one', 'two', 'three']

mylist = ['Mixed Case One', 'Mixed Case Two', 'Mixed Three']
print(list(map(lambda x: x.lower(), mylist)))
print(list(map(lambda x: x.upper(), mylist)))

>>> list(map(str.lower,["A","B","C"]))
['a', 'b', 'c']

除了更容易阅读(对许多人来说)，列表推导式也在速度竞赛中获胜:

$ python2.6 -m timeit '[x.lower() for x in ["A","B","C"]]'
1000000 loops, best of 3: 1.03 usec per loop
$ python2.6 -m timeit '[x.upper() for x in ["a","b","c"]]'
1000000 loops, best of 3: 1.04 usec per loop


$ python2.6 -m timeit 'map(str.lower,["A","B","C"])'
1000000 loops, best of 3: 1.44 usec per loop
$ python2.6 -m timeit 'map(str.upper,["a","b","c"])'
1000000 loops, best of 3: 1.44 usec per loop


$ python2.6 -m timeit 'map(lambda x:x.lower(),["A","B","C"])'
1000000 loops, best of 3: 1.87 usec per loop
$ python2.6 -m timeit 'map(lambda x:x.upper(),["a","b","c"])'
1000000 loops, best of 3: 1.87 usec per loop

对于这个例子，理解是最快的

$ python -m timeit -s 's=["one","two","three"]*1000' '[x.upper for x in s]'
1000 loops, best of 3: 809 usec per loop


$ python -m timeit -s 's=["one","two","three"]*1000' 'map(str.upper,s)'
1000 loops, best of 3: 1.12 msec per loop


$ python -m timeit -s 's=["one","two","three"]*1000' 'map(lambda x:x.upper(),s)'
1000 loops, best of 3: 1.77 msec per loop

一个学生问，另一个有同样问题的学生回答:)

fruits=['orange', 'grape', 'kiwi', 'apple', 'mango', 'fig', 'lemon']
newList = []
for fruit in fruits:
newList.append(fruit.upper())
print(newList)

解决方案:

>>> s = []
>>> p = ['This', 'That', 'There', 'is', 'apple']
>>> [s.append(i.lower()) if not i.islower() else s.append(i) for i in p]
>>> s
>>> ['this', 'that', 'there', 'is','apple']

此解决方案将创建一个单独的列表，其中包含小写项，而不管它们的原始大小写。如果原大小写为大写，则list s将包含list p中相应项的小写字母。如果列表项的原始大小写在list p中已经是小写，则list s将保留该项的大小写并保持其小写。现在你可以使用list s代替list p。

如果你的目的是通过一次转换来匹配另一个字符串，你也可以使用str.casefold()。

>>>str="Hello World";
>>>print(str.lower());
hello world
>>>print(str.upper());
HELLO WOLRD
>>>print(str.casefold());
hello world

如果你试图将列表中的所有字符串转换为小写，你可以使用pandas:

import pandas as pd


data = ['Study', 'Insights']


pd_d = list(pd.Series(data).str.lower())

输出:

['study', 'insights']

上面答案的一个更简单的版本是@Amorpheuses给出的在这里。

使用val中的值列表:

valsLower = [item.lower() for item in vals]

使用f = open()文本源，这对我来说工作得很好。

你可以尝试使用:

my_list = ['india', 'america', 'china', 'korea']


def capitalize_list(item):
return item.upper()


print(list(map(capitalize_list, my_list)))

这里有另一个解决方案，但我不建议使用它。因为之前没有添加这个解决方案，所以把它放在这里完成这个主题。

import timeit


def foo1():
L = ["A", "B", "C", "&"]
return [x.lower() for x in L]
def foo2():
L = ["A", "B", "C", "&"]
return "%".join(L).lower().split("%")


for i in range(10):
print("foo1", timeit.timeit(foo1, number=100000))
print("foo2", timeit.timeit(foo2, number=100000), end="\n\n")

foo1 0.0814619
foo2 0.058695300000000006


foo1 0.08401910000000004
foo2 0.06001100000000004


foo1 0.08252670000000001
foo2 0.0601641


foo1 0.08721100000000004
foo2 0.06254229999999994


foo1 0.08776279999999992
foo2 0.05946070000000003


foo1 0.08383590000000007
foo2 0.05982449999999995


foo1 0.08354679999999992
foo2 0.05930219999999997


foo1 0.08526650000000013
foo2 0.060690699999999875


foo1 0.09940110000000013
foo2 0.08484609999999981


foo1 0.09921800000000003
foo2 0.06182889999999985