我写的 Python 代码，同事都说好

人生苦短，代码都说我用 Python。同事

程序员的代码都说追求就是不写代码，早日财务自由。同事不对，代码都说一不小心把实话说出来了，同事应该是代码都说将代码写得简洁，优雅。同事

Python 程序员的代码都说追求则是 Pythonic，正好在 Python 这门语言中，同事「隐藏」了特别多方法，代码都说可以使代码变得简洁，同事优雅，代码都说与众不同。同事

我在这里总结了一些常用操作，代码都说特别是关于列表和字典，分享给大家。

第一个字母大写

这个方法有点意思，无意中发现的。

>>> s = "programming is awesome"

>>> print(s.title())

Programming Is Awesome列表合并

第一种方式：使用 +。

>>> a + b

[1, 2, 3, 4, 5, 6]

第二种方式：使用 extend 关键字。

>>> a.extend(b)

>>> a

[1, 2, 3, 4, 5, 6]

后两种方式明显更加优雅，推荐使用。需要说明的一点是，如果列表很大的源码库话，+ 会比较慢，使用 extend 更好。

列表元素去重

使用 set() 对列表元素进行去重。

>>> a = [1, 2, 3, 4, 2, 3]

>>> list(set(a))

[1, 2, 3, 4]列表排序

使用 sort() 或内建函数 sorted() 对列表进行排序。它们之间的区别有两点：

sort() 方法是对原列表进行操作，而 sorted() 方法会返回一个新列表，不是在原来的基础上进行操作。sort() 是应用在列表上的方法，而 sorted() 可以对所有可迭代的对象进行排序操作。# sort()

>>> a = [1, 2, 3, 4, 2, 3]

>>> a.sort()

>>> a

[1, 2, 2, 3, 3, 4]

>>>

>>> a = [1, 2, 3, 4, 2, 3]

>>> a.sort(reverse=True)

>>> a

[4, 3, 3, 2, 2, 1]

# sorted()

>>> a = [1, 2, 3, 4, 2, 3]

>>> sorted(a)

[1, 2, 2, 3, 3, 4]

>>> a = [1, 2, 3, 4, 2, 3]

>>> sorted(a, reverse=True)

[4, 3, 3, 2, 2, 1]遍历列表的索引和元素对

使用 enumerate() 函数可以同时输出索引和元素值。

>>> a = [python, go, java]

>>> for i, v in enumerate(a):

... print(i, v)

# output

0 python

1 go

2 java查找列表中出现最频繁的元素

使用 max() 函数可以快速查找出一个列表中出现频率最高的某个元素。

>>> a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]

>>> b = max(set(a), key=a.count)

>>> b

4

需要说明的一点是，当列表中有两个元素出现的次数相同时，会返回第一个出现的元素。

>>> a = [1, 2]

>>> b = max(set(a), key=a.count)

>>> b

1统计列表中所有元素的出现次数

前面的代码给出了出现最频繁的值。香港云服务器如果想要知道列表中所有元素的出现次数，那么可以使用 collections 模块。

collections 是 Python 中的一个宝藏模块，它提供了很多特性。Counter 方法正好可以完美解决这个需求。

>>> from collections import Counter

>>>

>>> a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]

>>> Counter(a)

Counter({ 4: 4, 2: 2, 3: 2, 1: 1, 5: 1})将两个列表合并为字典

使用 zip() 函数，可以将两个列表合并成字典。

>>> a = [one, tow, three]

>>> b = [1, 2, 3]

>>> dict(zip(a, b))

{ one: 1, tow: 2, three: 3}

求两个列表的交集，并集和差集。

# list_operate.py

def main():

list_a = [1, 2, 3, 4, 5]

list_b = [4, 5, 6, 7, 8]

# 求交集的两种方式

res_a = [i for i in list_a if i in list_b]

res_b = list(set(list_a).intersection(set(list_b)))

print(f"res_a is: { res_a}")

print(f"res_b is: { res_b}")

# 求并集

res_c = list(set(list_a).union(set(list_b)))

print(f"res_c is: { res_c}")

# 求差集的两种方式，在B中但不在A中

res_d = [i for i in list_b if i not in list_a]

res_e = list(set(list_b).difference(set(list_a)))

print(f"res_d is: { res_d}")

print(f"res_e is: { res_e}")

if __name__ == __main__:

main()字典创建# 1、创建空字典

a = { }

b = dict()

# 2、有初始值，从输入的便利程度来说，我更喜欢第二种

a = { a: 1, b: 2, c: 3}

b = dict(a=1, b=2, c=3)

# 3、key 来自一个列表，而 value 相同, 使用 fromkeys，那是相当的优雅

keys = [a, b, c]

value = 100

d = dict.fromkeys(keys, value)

# 4、key 来自一个列表，而 value 也是一个列表，使用 zip

keys = [a, b, c]

values = [1, 2, 3]

d = dict(zip(keys, values))字典合并m = { a: 1}

n = { b: 2, c: 3}

# 合并，两种方式

# 1、使用 update

m.update(n)

# 2、云南idc服务商使用

**{ **m, **n}判断 key 是否存在

在 Python2 中判断某个 key 是否存在，可以使用 has_key，但这个方法在 Python3 中已经被移除了。

另一种方法是使用 in 关键字，不仅兼容 Python2 和 Python3，速度还更快，强烈推荐。

d = { a: 1, b: 2}

if a in d:

print(hello) 获取字典中的值d = { a: 1, b: 2}

# 1、直接用 key 取值，但这种方式不好，如果 key 不存在会报错，推荐使用 get

a = d[a]

# 2、使用 get，如果 key 不存在还可以赋默认值

a = d.get(a)

c = d.get(c, 3)字典遍历d = { a: 1, b: 2, c: 3}

# 遍历 key

for key in d.keys():

pass

# 遍历 value

for value in d.values():

pass

# 遍历 key 和 value

for key, value in d.items():

pass字典推导式

列表推导式和字典推导式是我相当喜欢的功能，简洁高效。map 和 filter 我都已经快不会用了。

l = [1, 2, 3]

{ n: n * n for n in l}

{ 1: 1, 2: 4, 3: 9}字典按 key 或 value 排序d = { a: 1, b: 2, e: 9, c: 5, d: 7}

# 按 key 排序

sorted(d.items(), key=lambda t: t[0])

# 按 key 倒序

sorted(d.items(), key=lambda t: t[0], reverse=True)

# 按 value 排序

sorted(d.items(), key=lambda t: t[1])

还有一个需求是我在开发过程经常碰到的，就是有一个列表，列表的元素是字典，然后按字典的 value 对列表进行排序。

l = [{ name: a, count: 4}, { name: b, count: 1}, { name: d, count: 2}, { name: c, count: 6}]

sorted(l, key=lambda e: e.__getitem__(count))

# 倒序

sorted(l, key=lambda e: e.__getitem__(count), reverse=True)