python知识点总结(五)

---

1、match、search、group、groups、findall的区别

match()和search()两者都是测试正则表达式与字符串是否匹配。不同的是，
match() 如果在字符串的开头有0个或更多个字符，符合正则表达式模式，返回相关匹配的实例对象；如果字符串不符合正则表达式模式则返回None；
而search()则不同，扫描整个字符串，如果产生了一个匹配正则模式就寻找到这个位置，返回相关匹配的对象。如果没有位置能够匹配这个模式则返回None。

import re
str="谢谢您的关注和支持:YZL40514131"
result=re.match('40514131',str)
result1=re.match('谢您',str)
result2=re.match('谢谢您',str)
print(result)			None
print(result1)			None
print(result2)			<re.Match object; span=(0, 3), match='谢谢您'>

import re
str="谢谢您的关注和支持:YZL40514131"
result3=re.search('14131',str)
print(result3)							<re.Match object; span=(16, 21), match='14131'>
result4=re.search('141310',str)			
print(result4)							None

通过re.match匹配成功，可以使⽤group⽅法来提取数据。
group() 同group(0)就是匹配正则表达式整体结果，
group(1) 列出第一个括号匹配部分，
group(2) 列出第二个括号匹配部分。

findall：在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。

2、进程、协程、线程的区别

1、进程是操作系统分配任务的基本单位，进程是python中正在运行的程序；当我们打开1个浏览器时就是开启了一个浏览器进程；
线程是进程中执行任务的基本单位（执行指令集），一个进程中至少有一个线程，当只有一个线程时，称为主线程。
2、进程的创建和销毁消耗资源多；
线程的创建和销毁消耗资源少。
3、线程的切换速度比较快。
4、多进程中，进程与进程之间不能进行通信，如果需要通信需要借助Queue、Pipe；
一个进程中有多个线程时：线程之间可以进行直接通信。
5、多进程可以利用多核CPU：多进程的主要目的是充分利用多核CPU资源。
多线程不可以利用多核CPU：多线程的主要目的是充分利用好某一个单核。
6、进程的启动速度要比线程的启动速度慢。
7、进程与进程是不可以共享同一个数据的（同一个全局变量）；
两个线程可以共享同一个进程中的一个数据（同一个全局变量）。
8、进程用到了Process类；
线程用到了Thread类。
9、进程可以独立存在；
线程不能独立存在，依赖进程存在。
10、多进程中不会出现数据混乱、死锁的问题；
多线程中会出现数据混乱、死锁的问题。

协程：
1、协程是一种用户态的轻量级线程，协程的调度完全由用户控制；这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。
2、协程一般是使用gevent库
3、一个线程也可以拥有多个协程

3、如何剖析Python代码的执行性能?

4、1,2,3,4,5,能组合成多少个互不相同且无重复的三位数

class S:
    def func(self, nums):
        result = []

        def dfs(path, used):
            if len(path) == 3:
                result.append(path[:])
                return

            for i in range(len(nums)):
                if used[i] == True:
                    continue
                used[i] = True
                path.append(nums[i])
                dfs(path, used)
                used[i] = False
                path.pop()

        dfs([], [False] * len(nums))
        return result


r = S()
nums = [1, 2, 3, 4, 5]
print(r.func(nums))

5、输入一个字符串，输出该字符串中字符的所有组合。

例如:
输入:1，2，3
输出:1，2，3，12，13，23，123(组合数，不考虑顺序，所以12和21是等价的)

class S123:
    def func(self, nums):
        result = []

        def dfs(path, used, startIndex):
            result.append(path[:])
            if len(path) == len(nums):
                return

            for i in range(startIndex, len(nums)):
                if i > 0 and nums[i] == nums[i - 1] and used[i - 1] == False:
                    continue
                elif used[i] == True:
                    continue
                used[i] = True
                path.append(nums[i])
                dfs(path, used, i + 1)
                used[i] = False
                path.pop()

        dfs([], [False] * len(nums), 0)
        return ''


r = S123()
nums = [1, 2, 3]
print(r.func(nums))

# a=[1, 2, 3]
# print(list(map(lambda x: str(x), a)))
b = [[1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]
c = [list(map(lambda x: str(x), i)) for i in b]
d = [''.join(i) for i in c]
print(d)
print([eval(i) for i in d])

6、把字符串aaabbcccd这种形式的字符串压缩成a3b2c3d1这种形式

class Sabc:
    def func(self, s):
        d = {}
        for i in s:
            if i not in d:
                d[i] = 1
            else:
                d[i] += 1
        return ''.join([k + str(v) for k, v in d.items()])


s = "aaabbcccd"
r = Sabc()
print(r.func(s))



# dd={'a': 3, 'b': 2, 'c': 3, 'd': 1}
# print([k + str(v) for k, v in dd.items()])
# print(''.join([k + str(v) for k, v in dd.items()]))

7、字符串 “123” 转换成 123，不使用内置 int()，要求代码最少

class S:
    def func(self, s):

        i = 0
        while i < len(s) and s[i] == " ":
            i += 1
        res = 0
        while i < len(s) and '0' <= s[i] <= '9':
            res = int(s[i]) + res * 10
            i += 1
        return res


r = S()
s = "123"
print(r.func(s))

8、如何实现"1,2,3"变成[“1”,“2”,“3”]；如何实现[“1”,“2”,“3”]变成[1,2,3]

s = "1,2,3"
print(s.split(","))
ss = ["1", "2", "3"]
print([eval(i) for i in ss])

---