Python学习笔记——20个python编程技巧

转自：https://zhuanlan.zhihu.com/p/138991734

以下的20个小程序段，看似非常的简单，但是却非常的有技巧性，并且对个人的编程能力是一个很好的检验，应该在日常的编程中多多使用，多多练习。

1.字符串的翻转

字符串的翻转，首先最简单的方法就是利用切片的操作，来实现翻转，其次可以利用reduce函数来实现翻转，在python3中，reduce函数需要从functools中进行导入。

#方法1：切片
str1 = "hello world"
print(str1[::-1]) 

#方法2：reduce函数
from functools import reduce
print(reduce(lambda x,y:y+x,str1)) # 使用 lambda 匿名函数

输出：

dlrow olleh
dlrow olleh

方法1：python的序列切片
Sequence[start : end : step] 起始索引：结束索引：步长

• start和end填空，前者表示最开始，后者表示最后一个, 同时为空的时候，表示取所有。至于方向，取决于step。
• step为正，则从左到右切片，如果 start > end，则为空
• step为负，则从右到左切片，如果 start < end，则为空

总结：step 为正表示从左到右切片，反之为右到左；然后根据index 依次切片。

方法2：
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

• 用法：reduce(function, iterable[, initializer])
• 参数：
  function – 函数，有两个参数
  iterable – 可迭代对象
  initializer – 可选，初始参数
• 返回值：返回函数计算结果

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

该例也可以看作是第一例的应用，利用字符串的翻转来判断字符是否是回文字符串。

str9 = "abccba"
str9_1 = "abcde"

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

输出：

该字符是回文字符串
该字符不是回文字符串

3.单词大小写

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

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

输出：

I Love Python
I LOVE PYTHON
I love python

4.字符串的拆分

split函数：拆分字符串（默认按照空格拆分），返回的是列表
strip函数：移除字符串头尾指定的字符（默认为空格或换行符），返回字符串

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'>

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

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

# 直接合并列表
list8 = ['I','love','Python']
print(' '.join(list8))

# 去除字符串中不需要的字符，再合并
str8 = "I/ love. Python"
print(' '.join(re.split('\W+',str8))) #'\W'代表任意一个非单词字符，'+'可以匹配非单词字符一次或者无限次，只能匹配最前

输出：

I love Python
I love Python

re.split()：用正则表达式进行分割，即能够按照所能匹配的字串将字符串进行切分，使用前需要引入包import re。

• 用法：re.split(pattern, string[, maxsplit=0, flags=0])
• 参数：
  pattern：匹配的字符串
  string：需要切分的字符串
  maxsplit：分隔次数，默认为0(即不限次数)
  flags：标志位，用于控制正则表达式的匹配方式，比如：是否区分大小写
• 返回值：切分后的字符串列表

Python 正则表达式
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种特定的格式匹配。

字符	功能
.	匹配任意1个字符(除了\n)
[]	匹配[ ]中列举的单个字符
\d	匹配数字,也就是0-9
\D	匹配非数字,也就是匹配不是数字的字符
\s	匹配空白符,也就是空格\tab
\S	匹配非空白符,\s取反
\w	匹配单词字符, a-z, A-Z, 0-9, _
\W	匹配非单词字符, \w取反

字符	功能
*	匹配前一个字符出现0次多次或者无限次,可有可无,可多可少
+	匹配前一个字符出现1次多次或则无限次,直到出现一次
?	匹配前一个字符出现1次或者0次,要么有1次,要么没有
{m}	匹配前一个字符出现m次
{m,}	匹配前一个字符至少出现m次
{m,n}	匹配前一个字符出现m到n次

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

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

str3 = "wwweeerftttg"
print(''.join(set(str3)))

#对于列表的筛查
list1 = [2,4,5,6,7,1,2]
print(list(set(list1)))

输出：

ftgwer
[1, 2, 4, 5, 6, 7]

set() ：创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。返回新的集合对象。

7.将元素进行重复

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

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

str3 = "python"
list2 = [1,2,3]
str3_1 = ""
list2_1 = []
# 加法表述
for i in range(2): # range(2)等价于range(0,2)且小于2
	str3_1 += str3
	list2_1.extend(list2)
print(str3_1)
print(list2_1)

输出：

pythonpython
[1, 2, 3, 1, 2, 3]
pythonpython
[1, 2, 3, 1, 2, 3]

8.基于列表的扩展

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

list3 = [2,2,2,2]
print([2*x for x in list3])

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

输出：

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

链表推导式 List Comprehension：是一种方便简单的语法形式，可以利用它将一个列表经过过滤后转换成另一个列表，也可以利用它将函数应用于列表中的元素。
① [表达式 for 变量 in 列表 ]
② [表达式 for 变量 in 列表 if 条件]

9. 将列表展开

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

from iteration_utilities import deepflatten

list17 = [[12,5,3],[2,4,[5],[6,9,7]],[5,8,[9,[10,12]]]]

# 方法1 deepflatten()
print(list(deepflatten(list17)))
print("====================================")

# 方法2 递归
def flatten(lst):
	res = []
	for i in lst:
		if isinstance(i,list):
			res.extend(flatten(i))
		else：
			res.append(i)
	return res
print(flatten(list17))

输出：

[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]

List添加元素的方法：

• extend() ：用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
• append()：用于在列表末尾添加新的对象。

用法的区别：

1. append可以添加单个元素，也可以添加可迭代对象；extend只能添加可迭代对象。
2. 在添加可迭代对象时，append在添加后不改变添加项的类型；而extend在添加后，会将添加项进行迭代，迭代的元素挨个添加到被添加的数组中。

例子：

a=[1, 2, '3', '1']
a.extend([1,2])
print(a)
 
b=[1, 2, '3', '1']
b.append([1,2])
print(b)

输出：

[1, 2, '3', '1', 1, 2]
[1, 2, '3', '1', [1, 2]]

10.二值交换

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

a = 1
b = 2

# 方法1
a, b = b, a
print(a, b) # 此时a = 2, b = 1

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

输出：

2 1
1 2

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

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

from collections import Counter
list10 = ['P', 'p', 'Y', 'y', 't', 't', 'h', 'o', 'o', 'o', 'n']
count = Counter(list10)
print(count)
print(count['P'])
print(count.most_common(1))

# 手动实现
dict1 = {}
for i in list10:
	if i in dict1:
		dict1[i] += 1
	else:
		dict1[i] = 1
print(max(dict1, key=lambda x:dict1[x]))

输出：

Counter({'o': 3, 't': 2, 'h': 1, 'n': 1, 'Y': 1, 'p': 1, 'y': 1, 'P': 1})
1
[('o',3)]
o

lambda：定义一个匿名函数
lambda 传入的参数:要执行的语句
（这条语句执行完之后，就会返回一个值，也就是函数的返回值）
例子：这语句相当于定义了一个函数，其中 x 相当于传入的参数， x+2 是要执行的语句

lambda x:x+2

使用这个函数：

f = lambda x:x+2
f(3)

输出：

9

实际上，上述代码相当于

def f(x):
   return x+2

key=lambda 变量:变量[维数]

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

key=lambda x:dict1[x] 为对前面的对象 dict1 根据第 x 维数据的值进行排序。

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

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

str11_1,str11_2,str11_3 = "qwert", "qertw", "reqtw"
cn_str11_1, cnstr11_2, cn_str11_3 = Counter(str11_1), Counter(str11_2), Counter(str11_3)
if(cn_str11_1 == cnstr11_2 and cnstr11_2 == cnstr11_3):
	print("三个字符串所含元素相同")

输出：

三个字符串所含元素相同

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

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

str19 = "2345343"

# 方法1
list19_1 = list(map(int, str19))
print(list19_1)
print("=======================")

# 方法2
list19_2 = [int(i) for i in str19]
print(list19_2)

输出：

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

14.使用try-except-finally模块

当我们在执行程序时，可能会遇到某些不可预知的错误，使用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]
程序结束

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

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

str13 = "Python"
list13 = [1,2,3,4,5]
for i,j in enumerate(str13):
	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

16.代码执行消耗时间

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

import time
start = time.time()

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

输出：

共消耗时间：0.07881712913513184 s

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

在python中可以使用sys.getsizeof来查看元素所占内存的大小。

import sys

str14 = "a"
str14_1 = "aaddf"
num14 = 32
print(sys.getsizeof(str14))
print(sys.getsizeof(num14))
print(sys.getsizeof(str14_1))

输出：

50
28
54

18.字典的合并

在python3中，提供了新的合并字典的方式，如方法1所示，此外python3还保留了python2的合并字典的方式，如方法2所示。

# 方法1
dict1 = {'a':1,'b':2}
dict2 = {'c':3,'d':4}
combined_dict = {**dict1, **dict2}
print(combined_dict)
print("============================")

# 方法2
dict1 = {'a':1,'b':2}
dict2 = {'c':3,'d':4}
dict1.update(dict2)
print(dict1)

输出：

{'d':4, 'a':1, 'b':2, 'c':3}
============================
{'d':4, 'a':1, 'b':2, 'c':3}

19.随机采样

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

import random

list18 = [1,2,4,5,6]
strl8 = "wewewe"

n_samples = 3
print(random.sample(list18,n_samples))
print(random.sample(str18,n_samples))

输出：

[6, 4, 5]
['e', 'e', 'w']

20.检查唯一性

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

str20 = [1,2,3,4,5,6]
str20_1 = [1,2,2,4,5,6]

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

输出：

该列表中元素都是唯一的
该列表中元素不都是唯一的