python学习生涯 day6-9

最新推荐文章于 2023-01-03 20:33:38 发布

煮雪烧茶

最新推荐文章于 2023-01-03 20:33:38 发布

阅读量360

点赞数 1

本文链接：https://blog.csdn.net/blessingchacha/article/details/109035956

版权

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)

这个代码值得还好研究
在这里插入图片描述
这么多内容要怎么记呢？切勿死记硬背，在学习的过程中，边用边记吧，与诸君共勉！

煮雪烧茶

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python学习生涯 day6-9

0 一些关于生成器的遗留题目0 )一段处理文件的代码def check_file(filename, aim): with open(filename, encoding='utf-8') as f: for i in f: if aim in i: yield ig = check_file('/Users/gaoye/Documents/lol.txt', '迭代器')for i in g: print(
复制链接

扫一扫