python开发实用方法总结

0 一些关于生成器的遗留题目

0 )一段处理文件的代码

def check_file(filename, aim): with open(filename, encoding='utf-8') as f: for i in f: if aim in i: yield i


g = check_file('/Users/gaoye/Documents/lol.txt', '迭代器') for i in g: print(i.strip()) 

1）生成器是一个消耗品

def check(): for i in range(4): yield i


g = check() g1 = (i for i in g) g2 = (i for i in g) print(list(g1)) print(list(g2)) 

2)好一个陷阱

def add(n, i): return n+i def test(): for i in range(4): yield i


g = test() for n in [1, 10]: g = (add(n, i) for i in g) print(list(g)) 

提示：生成器表达式和生成器一样懒，不执行就不会生成值
上述代码只有在最后一行print(list(g))才会被执行

1 内置函数

内置函数有很多，这里只介绍比较少见的几种
0）reversed():保留原列表，返回一个反序的迭代器!

l = [1, 2, 3, 4, 5] l2 = reversed(l) print(l2) 

1)slice():切片

l = [1, 2, 3, 4, 5] sli = slice(1, 5, 2)#sli是一个切片规则，对哪个对象是没有被指出的 print(l[sli]) 

2)format():对输出结果格式化，也可以实现科学计数，进制转换等功能

print(format('end', '>20')) print(format('end', '<20')) print(format('end', '^20')) 

3)bytes():转换编码方式

print(bytes('你好', encoding='GBK’))#unicode转换成gbk编码方式 print(bytes('你好', encoding='utf-8'))#unicode转换成utf-8编码方式 

4）btyearray():
bytearray() 函数返回 bytearray 对象。
它可以将对象转换为 bytearray 对象，或者创建指定大小的空字节数组对象。

print(bytes('你好', encoding='utf-8')) print(bytearray('你好', encoding='utf-8')) 

Bytearray对其中的某个元素进行新的赋值不会生成一个新的列表
而bytes会生成一个新的列表
5)chr()和ord():两个关于ascII码的内置函数

print(ord('a')) print(chr(97)) 

注意：ord可以把字符转换成数字，chr可以把数字转换成字符，但是一次只能拿一个
6）repe():缩写成%r，在输出的时候连同字符串的’ ‘一并输出

egg = '织毛衣' print('我喜欢%r' % egg) print('我喜欢%s' % egg) 

7）all()和any()：两个关于bool值的内置函数

print(all(['123', ' ', 0])) print(all(['123', ' '])) print(all(['123', 0])) 

print(any(['123', ' ', 0])) print(any(['123', ' '])) print(any(['123', 0])) 

当bool值为0时，为假；当bool值不为0时，为真。
all():一假即假；any():一真即真

8）zip():拉链函数

l1 = [1, 2, 3, 4] l2 = ['a', 'b', 'c', 'd'] l3 = {'x', 'y', (13, 14)} print(zip(l1, l2, l3)) for i in zip(l1, l2, l3): print(i) 

注意：zip()返回的是一个迭代器
9）filter():过滤函数

def is_odd(i): return i % 2 == 1 ret = filter(is_odd, [1, 3, 4, 6, 9]) print(ret) for i in ret: print(i) ret1 = [i for i in [1, 3, 4, 6, 9] if i% 2 == 1] print(ret1) for i in ret1: print(i) 

和列表推导式的结果相同，不过filter（）过滤函数返回的是一个迭代器，节省了内存空间
100以内开平方为整数的数

from math import sqrt def func(num): return sqrt(num) % 1 == 0 ret = filter(func, range(101)) for i in ret: print(i) 

怎么判断一个数为整型还是浮点型呢？
用这个数对1取余，如果结果等于0则为整型，否则为浮点型
10）map():该函数的意义是对一个序列进行前面参数函数的操作，然后返回一个新的list

ret1 = map(abs, [1, -1, -2, -9]) for i in ret1: print(i) 

注意：Filter之后的元素个数可能会变少，而map后的元素个数不会改变
11）sorted():排序函数

l = [1, 2, -4, -7, 1] l.sort() print(l) l2 = sorted(l) print(l2) 

注意：Sorted（）和.sort()方法类似，不过sorted会产生一个新的列表，所以会占用更大的内存空间，而.sort()会对原来的列表进行修改，不会产生一个新的列表，当列表不大时，可以使用sorted（）方法

l = ['sdkhfisdhf', 'jhdsfi', 'hsfiha'] l2 = sorted(l, key=len) print(l2) 

按长度进行排序，也可以按绝对值进行排序，只需要将key=len换成abs就可以

l = [-23294, -2749274, 2091274] l2 = sorted(l, key=abs) print(l2) 

2匿名函数

格式： 变量 = lambda 参数：返回值
0）一个加法的匿名函数

add = lambda x, y: x+y print(add(1, 2)) 

1）字典中键值最大的键

dic = {'k1': 10, 'k2': 100, 'k3': 30} print(max(dic, key=lambda k: dic[k])) 

注意：对字典进行排序时，是对字典的键进行排序的，不过这个匿名函数返回了键值，所以利用键值对键进行排序

带key的五个内置函数：
max min filter sorted map ,这5个函数都可以与lambda合作（混合使用）
2) 将（‘a’, ‘b’）(‘c’, ‘d’)用匿名函数输出为[{‘a’: ‘c’}, {‘b’: ‘d’}]

ret = zip(('a', 'b'), ('c', 'd')) res = map(lambda i: {i[0]:i[1]}, ret) print(list(res)) 

这个题考到了三个知识点，zip函数 匿名函数和强制类型转换

3递归函数

在函数内部调用函数本身的函数就是递归函数，考虑到内存空间的问题，递归函数存在最大深度，最大深度一般为997或998

n = 0 def story(): global n print('nmsl') n += 1 print(n) story() story() 

同时也可以自定义设置最大深度（需要调用sys库）

import sys
sys.setrecursionlimit(10000) n = 0 def story(): global n print('nmsl') n += 1 print(n) story() story() 

递归的优点；程序简单
递归的缺点；占内存

用二分法查找某个值

算法的目的是为了优化程序，当然也可以用in 和for来实现，但是太无脑，有手就行

def find(l, aim, start=0, end=None): end = len(l) if end is None else end # end = 24 mid_index = (start + end) // 2 # mid_index = 12 18 if start <= end: if l[mid_index] < aim: # 41<67 return find(l, aim, start=mid_index+1, end=end) # find(l, aim, start=13, end=24) elif l[mid_index] > aim: return find(l, aim, start=start, end=mid_index-1) else: return mid_index else: return '找不到这个值' l = [2, 3, 5, 10, 15, 16, 18, 22, 26, 30, 32, 35, 41, 42, 43, 55, 56, 66, 67, 69, 72, 76, 82, 83, 88] ret = find(l, 67) print(ret) 

4 正则表达式

0）验证数字的正则表达式


1）验证字符的正则表达式
完整版点击添加链接描述

5 re模块

0）findall()

import re
ret = re.findall('[a-z]+', 'eva qqq txt') print(ret) 

返回所有符合匹配条件的结果，放在列表中
1）search()

import re
ret = re.search('q', 'eva qqq txt').group() print(ret) 

从前往后，找到一个符合条件的就返回，返回的变量需要调用group才能拿到结果，且不放在列表中，如果找不到，就报错
2）match

import re
ret = re.match('q', 'eva qqq txt').group() print(ret) 

从头开始匹配，找不到就报错，找到的结果同样也需要调用group才能拿到

import re
ret = re.match('e', 'eva qqq txt').group() print(ret) 

3）split()

import re
ret = re.split('[ab]', 'abdc') print(ret) 

按照正则规则来进行分割
4）sub()

import re
ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1) print(ret) 

注意：将数字替换成’H’，参数1表示只替换1个
5)subn()

import re
ret = re.subn('\d', 'H', 'eva3egon4yuan4') print(ret) 

注意：将数字替换成’H’，返回元组(替换的结果,替换了多少次)
6)compile()

import re
obj = re.compile('\d{3}') ret = obj.search('abc123eeee') print(ret.group()) 

注意：将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字#正则表达式对象调用search，参数为待匹配的字符串
一般来说，当一条正则规则需要反复使用，且这条正则规则很长，就会使用compile
7)findliter()

import re
ret = re.finditer('\d', 'ds3sy4784a') print(ret) # <callable_iterator object at 0x10195f940> print(next(ret).group()) print([i.group() for i in ret]) 

注意：finditer返回的是一个迭代器，且在这个迭代器中，每一个元素都需要再执行group才能成功取出，这里为什么最后没有拿出来3呢，可以好好思考一下

两个涉及优先级的问题

0）findall的优先级查询：
import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com') print(ret) ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com') print(ret) 

1 ）split的优先级查询

import re
ret = re.split("\d+", "eva3egon4yuan") print(ret) ret = re.split("(\d+)", "eva3egon4yuan") print(ret) 

2）？在正则表达式的三个作用
A）在量词的地方表示重复0次或者1次
B）在量词的后面表示惰性匹配
C）放在分组前面，取消分组优先（上述2点就是）

6 collections模块

0）namedtuple()生成可以使用名字来访问元素内容的tuple

from collections import namedtuple
Card = namedtuple('card', ['suits', 'number']) c1 = Card('♥️', '2') print(c1) print(c1.suits) print(c1.number) 

1)duque 双端队列
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections import deque
dq = deque(['a', 'b']) dq.append('1') dq.appendleft('2') dq.insert(2, '3') print(dq.pop()) print(dq.popleft()) print(dq.popleft()) print(dq) 

注意：deque也是一个消耗品
2）OrderedDict()
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)]) print(d) od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) print(od) 

3）defaultdict()
有如下值集合 [11,22,33,44,55,66,77,88,99,90…]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1’: 大于66 , ‘k2’: 小于66}
A)原始方法

values = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90] my_dict = {'k1': [], 'k2': []} for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value) print(my_dict) 

b）defaultdict()

from collections import defaultdict
values = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90] my_dict = defaultdict(list) for value in values: if value > 66: my_dict['k1'].append(value) else: my_dict['k2'].append(value) print(my_dict) 

4）Counter()
Counter的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似

from collections import Counter
c = Counter('abcdeabcdabcabahkshfk我爱你') print(c) 

7 time模块

表示时间的三种方式：
0）时间字符串：人能看懂的时间
1）时间戳： 计算机能够识别的时间
2）时间元组： 用来操纵时间的
0)时间字符串

import time print(time.strftime('%Y-%m-%d, %H:%M:%S')) print(time.strftime('%m-%d, %H:%M:%S')) print(time.strftime('%Y-%m-%d, %H:%M')) 

注意： 需要什么输出什么，一定要注意这些字母的大小写

1)时间戳

import time print(time.time()) 

2）时间元组

import time print(time.localtime()) 

三种时间方法的相互转化：

8 random模块

0）random 和 uniform

import random print(random.random()) print(random.uniform(3, 5)) 

注意：random是随机生成一个0～1的小数;uniform是随机生成一个a～b的小数
1）randint和randrange

import random print(random.randint(3, 5)) print(random.randrange(1, 10, 2)) 

注意：randint是随机生成一个a～b的整数（包含b）
randrange是随机生成一个a～b的整数，其中随机的间隔为c（不包含b）
2)choice和sample

import random print(random.choice([3, 5, 'fhsakhf', [1, 2, 3]])) print(random.sample([3, 5, 'fhsakhf', [1, 2, 3]], 2)) 

注意：将需要随机返回的内容放在一个列表当中，choice的返回值个数为1
而sample可以自定义返回值的个数
3)shuffle(): 打乱次序

import random
item = ['A', 'J', 'Q', 'K', 2, 3, 4, 5, 6, 7, 8, 9] (random.shuffle(item)) print(item) 

随机生成一个6位验证码

import random
code = '' for i in range(6): num = random.randint(0, 9) alf = chr(random.randint(65, 90)) add = random.choice([num, alf]) code = ''.join([code, str(add)]) print(code) 

这个代码值得还好研究

这么多内容要怎么记呢？切勿死记硬背，在学习的过程中，边用边记吧，与诸君共勉！

本文地址：https://blog.csdn.net/blessingchacha/article/details/109035956