20个Python代码，短小精悍，用处无穷

       当今Python编程语言的潮流已经成为不可阻挡的趋势，Python以其较高的可读性和简洁性备受程序员的喜爱。而Python编程中的一些小的技巧，运用的恰当，会让你的程序事半功倍。以下的20个小的程序段，看似非常的简单，但是却非常的有技巧性，并且对个人的编程能力是一个很好的检验，大家应该在日常的编程中多多使用，多多练习。

1、字符串的翻转

#方法一：字符串切片
str1 = "hello world"
print(str1[::-1])  #dlrow olleh

# 方法二：使用reduce函数
from functools import reduce 
#每次取一个 翻转再连接起来
print(reduce(lambda x,y:y+x, str1))  #dlrow olleh

#方法三：列表的reverse方法
l = list(str1)  #['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
l.reverse()
l_reverse = "".join(l)
print(l_reverse)  #dlrow olleh

# 方法四：python3 reversed函数
s = list(reversed(str1))  #['d', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']
s_reverse = "".join(s)
print(s_reverse)  #dlrow olleh

#方法五：使用递归函数
def func(s):
    if len(s) < 1:
        return s
    return func(s[1:]) + s[0]
result = func(str1)
print(result)  #dlrow olleh

#方法六：使用栈
l = list(str1)
l1 = ""
while(len(l)>0):
    # pop() 函数用于移除列表中的一个元素（默认最后一个元素）,并且返回该元素的值
    l1 += l.pop()
print(l1)

#方法七：for循环
l = list(str1)
for i in range(int(len(l)/2)):
    temp = l[i]
    l[i] = l[len(l)-i-1]
    l[len(l)-i-1] = temp
print("".join(l))  #dlrow olleh

2、判断字符串是否是回文

str2 = "abccba"
str3 = "abcde"

def func(string):
    if string == string[::-1]:
        print("该字符串是回文字符串")
    else:
        print("该字符串不是回文字符串")

func(str2)  #该字符串是回文字符串
func(str3)  #该字符串不是回文字符串

3、单词大小写

str2 = "i love python"
# 单词首字母大写
print(str2.title())  #I Love Python
# 所有字母大写
print(str2.upper())  #I LOVE PYTHON
#字符串首字母大写
print(str2.capitalize())  #I love python 

面对一个字符串，想将里面的单词首字母大写，只需要调用title()函数，而所有的字母大写只需要调用upper()函数，字符串首字母大写则是调用capitalize()函数即可。

4、字符串的拆分

str4 = "I love python"
str4_1 = "I/love/python"
str4_2 = "  I love python  "
print(str4.split())  #默认是按照空格进行拆分，返回的是列表
print(str4_1.split("/"))
print(str4_2.strip())  #默认去除字符串左右两边的空格，返回的是字符串
print(type(str4_2.strip()))
"""
['I', 'love', 'python']
['I', 'love', 'python']
I love python
<class 'str'>
"""

字符串的拆分可以直接利用split函数，进行实现，返回的是列表，而strip函数用于移除字符串头尾指定的字符（默认为空格或换行符）。

5、将列表中的字符串合并

list5 = ["I","love","python"]
print(" ".join(list5))  #I love python

#去除字符串中的不需要的字符
import re
str5 = "I/ love. python"
# \W+:所有非单词字符 +表示贪婪匹配1—无穷大个
print(" ".join(re.split("\W+", str5)))   #I love python

这一条可以认为是第4条的反例，这里是将列表中的字符串合并为字符串。第4条可以与第5条结合，来去除字符串中不想留下的项。

6、寻找字符串中唯一的元素

str6 = "wwweeerftttg"
print(set(str6))  #{'e', 't', 'w', 'g', 'f', 'r'}
print("".join(set(str6)))  #etwgfr
#对于列表的筛查 
list6 = [2, 4, 5, 6, 9, 2, 7, 1, 2]
print(set(list6))  #{1, 2, 4, 5, 6, 7, 9}
print(list(set(list6)))  #[1, 2, 4, 5, 6, 7, 9]

在Python中，对于唯一值的筛查，首先应该想到对于set的利用，set可以帮助我们快速的筛查重复的元素，上述程序中，set不仅可以对字符串，而且还可以针对列表进行筛查。

7、将元素进行重复

str7 = "python"
list7 = [1,2,3]
#乘法表述
print(str7 *2)
print(list7 * 2)

str7_1 = ""
list7_1 = []
#加法表述
for i in range(2):
    str7_1 += str7
    list7_1.extend(list7)  #extend()没有返回值，但会在原来的列表末尾追加可迭代对象中的元素

print(str7_1)
print(list7_1)

将元素进行重复，可以采用“乘法”的形势，直接乘以原来的元素，也可以采用“加法”的形式，更方便理解。

8、基于列表的扩展

list8 = [2, 2, 2, 2]
print([2*x for x in list8])  #[4, 4, 4, 4]

#列表的展开
list8 = [[1, 2, 3], [4, 5, 6], [4, 3], [1]]
print([i for k in list8 for i in k])  #[1, 2, 3, 4, 5, 6, 4, 3, 1]

基于列表的扩展，可以充分利用列表的特性和Python语法的简洁性，来产生新的列表，或者将嵌套的列表进行展开。

9. 将列表展开

from iteration_utilities import deepflatten

#方法一
list9 = [[12, 5, 3], [2, 4, [5], [6, 9, 7]], [5, 8, [9, [10, 12]]]]
print(list(deepflatten(list9)))
print("===========================")

#方法二
def flatten(lst):
    res = []
    for i in lst:
        if isinstance(i, list):
            res.extend(flatten(i))
        else:
            res.append(i)
    return res
print(flatten(list9))
"""
[12, 5, 3, 2, 4, 5, 6, 9, 7, 5, 8, 9, 10, 12]
===========================
[12, 5, 3, 2, 4, 5, 6, 9, 7, 5, 8, 9, 10, 12]
"""

首先，方法1中 ，我们调用的是iteration_utilities 中的deepflatten函数，第二种方法直接采用递归的方法，我们自己来实现复杂列表的展平，便可以得到展开后的列表。

10、二值交换

a = 1
b = 2
#方法一
a, b = b, a
print(a, b)  #此时a = 2, b = 1
#方法二
c = a + b
a = c - a
b = c - a
print(a, b)  #此时a = 1, b = 2,恢复交换之前的值

Python中的二值交换，可以直接采用交换的方式，如上图的方法1，而方法2所示的方法，借助第三个变量，来实现了两个数值的交换。

11、统计列表中元素的频率

from collections import Counter
list11 = ["P", "p", "Y", "y", "t", "t", "h", "o", "o", "o", "n"]
count = Counter(list11)
print(count)  #Counter({'o': 3, 't': 2, 'P': 1, 'p': 1, 'Y': 1, 'y': 1, 'h': 1, 'n': 1})
print(count["p"])  #1
#most_common(n):代表获取数量最多的前n个元素，如果不传参数，代表返回所有结果
print(count.most_common(1))  #[('o', 3)]

#手动实现
dict1 = {}
for i in list11:
    if i in dict1:
        dict1[i] += 1
    else:
        dict1[i] = 1

print(max(dict1, key=lambda x:dict1[x]))  #o

我们可以直接调用collections中的Counter类来统计元素的数量，当然也可以自己来实现这样的统计，但是从简洁性来讲，还是以Counter的使用比较方便。

 

12、判断字符串所含元素是否相同

from collections import Counter
str12_1, str12_2, str12_3 = "qwert", "qertw", "reqtw"
cn_str12_1, cn_str12_2, cn_str12_3= Counter(str12_1),\
                                    Counter(str12_2),\
                                    Counter(str12_3)
if (cn_str12_1 == cn_str12_2 and cn_str12_2 == cn_str12_3):
    print("三个字符串所含元素相同")  #三个字符串所含元素相同

Counter函数还可以用来判断字符串中包含的元素是否相同，无论字符串中元素顺序如何，只要包含相同的元素和数量，就认为其是相同的。

13、将数字字符串转化为数字列表

str13 = "2345343"
#方法一
list13_1 = list(map(int, str13))
print(list13_1)
print("=============")
#方法二
list13_2 = [int(i) for i in str13]
print(list13_2)
"""
[2, 3, 4, 5, 3, 4, 3]
=============
[2, 3, 4, 5, 3, 4, 3]
"""

上述程序中，方法1利用的map函数，map函数可以将str19中的每个元素都执行int函数，其返回的是一个迭代器，利用list函数来将其转化为列表的形式。注意，在Python2中执行map函数就会直接返回列表，而Python3做了优化，返回的是迭代器，节省了内存。

14、使用try-except-finally模块

a = 1
b = 4
try:
    a.append(b)
except AttributeError as e:
    print("'a'不是一个列表！")
else:
    print(a)
finally:
    print("程序结束")

print("===============")
a = []
b = 4
try:
    a.append(b)
except AttributeError as e:
    print("'a'不是一个列表")
else:
    print(a)
finally:
    print("程序结束")
"""
'a'不是一个列表！
程序结束
===============
[4]
程序结束
"""

 

当我们在执行程序时，可能会遇到某些不可预知的错误，使用try-except可以帮助我们去捕获这些错误，然后输出提示。注意，如果需要程序无论是否出错，都要执行一些程序的化，需要利用finally来实现。

15、使用enumerate() 函数来获取索引-数值对

str15 = "Python"
list13 = [1, 2, 3, 4, 5]
for i,j in enumerate(str15):
    print(i,j)
print("===========")
for i,j in enumerate(list13):
    print(i,j)
"""
0 P
1 y
2 t
3 h
4 o
5 n
===========
0 1
1 2
2 3
3 4
4 5
"""

 

enumerate() 函数用于将一个可遍历的数据对象(如上图的列表，字符串)组合为一个索引序列。

16、代码执行消耗时间

import time
start = time.time()

#代码块
num = 0
for i in range(1000000):
    num = i
#打印消耗时间
print("共消耗时间：", time.time() - start, "s")  #共消耗时间： 0.046874284744262695 s

 

利用time()函数，在核心程序开始前记住当前时间点，然后在程序结束后计算当前时间点和核心程序开始前的时间差，可以帮助我们计算程序执行所消耗的时间。

17、检查对象的内存占用情况

import sys
str17 = "a"
str17_1 = "aaddf"
num17 = 32
print(sys.getsizeof(str17))  #50
print(sys.getsizeof(str17_1))  #54
print(sys.getsizeof(num17))  #28

 

在Python中可以使用 sys.getsizeof 方法可以查看 python 对象的内存占用，单位：字节 (byte)，实际上是调用了 __sizeof__ 方法

18、字典的合并

dict1 = {"a":1, "b":2}
dict2 = {"c":3, "d":4}
#方法一
combined_dict = {**dict1, **dict2} #先对两个字典解包 再将其合并成一个新的字典
print(combined_dict)
print("===================")
#方法二
dict1.update((dict2))  #批量更新字典
print(dict1)
"""
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
===================
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
"""

 

在Python3中，提供了新的合并字典的方式，如方法一所示，此外Python3还保留了Python2的合并字典的方式，如方法二所示。

19、随机采样

import random
str19 = "wewewe"
list19 = [1, 2, 4, 5, 6]

n_samples = 3
print(random.sample(list19, n_samples))
print(random.sample(str19, n_samples))
"""
[2, 6, 1]
['w', 'e', 'e']
"""

 

使用random.sample()函数，可以从一个序列中选择n_samples个随机且独立的元素。

20、检查唯一性

list20 = [1, 2, 3, 4, 5, 6]
list20_1 = [1, 2, 2, 4, 5, 6]

def ifUnque(seq):
    if(len(seq) == len(set(seq))):
        print("该列表中元素都是唯一的")
    else:
        print("该列表中元素不都是唯一的")

ifUnque(list20)  #该列表中元素都是唯一的
ifUnque(list20_1)  #该列表中元素不都是唯一的

 

通过检查列表长度是否与set后的列表长度一致，来判断列表中的元素是否是独一无二的。

 

结束语

这20个短小精悍的小例子还是非常实用的，尤其是对菜鸟来说，多练习一下对功力提升大有裨益！读百遍，看千遍，不然自己动手敲一边。