DC's blog
DC
2022-11-11
目录

开胃小菜

# 流程控制

# 输出数字1到10
i = 1
while i <= 10:
    if i != 7:
        print(i, end=' ')
    i += 1
    
i = 1
while i <= 10:
    if i == 7:
      	i+=1
      	continue
    print(i, end=' ')
    i += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
# 九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f'{i} * {j} == {i*j}', end='\t')
    print()


# -- 递归. <薄弱点+1>
def f(i):
    if i >= 1:
        f(i - 1)
        item = ['%d*%d=%d' % (j, i, i * j) for j in range(1, i + 1)]
        print('\t'.join(item))


f(9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 打印金字塔
num = 6
for i in range(1, num):
    print(' ' * (num - i) + "*" * (i * 2 - 1))
# 重点在于思考 当前层数与当前层星星数以及前空格数的关系
1
2
3
4
# 简单的登陆程序
password = 123
can_error = 3

def user_login(pwd):
    global can_error
    if eval(pwd) != password:
        can_error -= 1
        if can_error == 0:
            return 0
        return 1
    else:
        return 2

while True:
    pwd = input('pwd ===>:')
    res = user_login(pwd)
    if res == 0:
        print('锁定')
        break
    elif res == 2:
        print('成功登陆！')
        break
    elif res == 1:
        print(f'输入错误,您还有{can_error}次机会...')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 字符串

# 进制转换
# -- 二进制转十进制
def text(b):
    b_list = b.split()
    new_str = []
    for i in b_list:
        new_str.append(str(int(i, 2)))

    return '.'.join(new_str)

# -- 十进制转二进制
b = ' '.join([str(bin(int(i))) for i in '10.3.9.12'.split('.')])
print(text(b))
1
2
3
4
5
6
7
8
9
10
11
12
# 映射替换
# --  maketrans translate
txt = "Google Runoob Taobao!"
x = "mSa"
y = "eJo"
z = "odnght"  # -- 设置删除的字符
mytable = ''.maketrans(x, y, z)
# {109: 101, 83: 74, 97: 111, 111: None, 100: None, 110: None, 103: None, 104: None, 116: None}
print(mytable) # 这里一共有12个键值对
# 尽管o是需要删除的字符,但通过替换得到的o是不会删除的
print(txt.translate(mytable))  # Gle Rub Tobo!
1
2
3
4
5
6
7
8
9
10
# 'k:1|k1:2|k2:3'

将'k:1|k1:2|k2:3|k3:4'转换为字典

my_str = 'k:1|k1:2|k2:3|k3:4'
my_dict = {}
for item in my_str.split('|'):
    k, v = item.split(':')
    my_dict[k] = eval(v)

print(my_dict)
1
2
3
4
5
6
7
# 字符串压缩

'aaabbcccd' -> 'a3b2c3d1'

my_str2 = 'aaabbcccd'

def str_reduce(count_set):
    res = ''
    for item in count_set:
        num = my_str2.count(item)
        res += item + str(num)
    return res

print(str_reduce('abcd'))

my_str3 = 'aaabbcccd'
my_dict3 = {}
res = ''
for i in my_str3:
    my_dict3[i] = my_dict3.get(i, 0) + 1
for k, v in my_dict3.items():
    res += k
    res += str(v)
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 浮点数判断
def is_float(data:str) ->bool:
  print(type(data), type(eval(data)))
  return isinstance(eval(data),float)

print(is_float('3.12'))
'''
<class 'str'> <class 'float'>
True
'''
1
2
3
4
5
6
7
8
9
# 打印进度条
'''
# -- 问题1:控制打印进度条的宽度
print('%-50s'%'#')       #  `-`代表左对齐,总长度为50,不够默认用空白填补
print('%s%%'% 50)        #  50%  %在''中存在特殊的意义,需要用%对%进行转义
print('%%-%ds' % 50)     #  %-50s 会将50先传给%d

res = '[%%-%ds]' % 10
print(res, type(res))    # [%-10s] <class 'str'>
print(res % '##')        # [##        ]

print(('[%%-%ds]' % 10) % '##')

# -- 问题2:用新的进度替换旧的 不换行+跳回行首打印
# 换行的概念:跳到下一行以及光标回到行首
# \n换行; \r跳到行首;  
print(('[%%-%ds]' % 10) % '#', end='\r')
print(('\r[%%-%ds]' % 10) % '#', end='')
print(('\r[%%-%ds]' % 10) % '##', end='')
'''
import time

def make_progress(percent, width=50):
    # -- 解决百分比大于1的问题
    if percent > 1: percent = 1
    # int(percent * width) # -- 根据百分比拿到要显示多少个井号(若width宽度为50,下载完就会有50个#)
    show_str = ('[%%-%ds]' % width) % (int(percent * width) * '#')
    # print('\r%s'% show_str,end='')
    # print('\r%s %s%%' % (show_str, int(percent * 100)), end='')
    print(f'\r{show_str} {int(percent*100)}%', end='')


total_size = 10214  # -- 数据总大小
recv_size = 0       # -- 收到数据总大小
while recv_size < total_size:
    time.sleep(0.1)  # -- 模拟网络延迟
    recv_size += 1024  # -- 每次下载1024个字节
    # -- 打印进度条
    # -- 注意哦,若total_size为1025,那么经过两次 recv_size为2048 百分比大于1
    percent = recv_size / total_size  # -- 下载的百分比
    make_progress(percent)
print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 列表

# 冒泡排序
arr = [2, 19, 16, 7, 3, 8]

# -- 内层循环进行的排序 而外层循环表明这样的排序从头要来好多次..
# -- flag是灵魂设置！
def bubbling(arr):
    for _ in range(len(arr) - 1):
        flag = False
        for j in range(len(arr) - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                flag = True
        if not flag:
            break
    return arr


print(bubbling(arr))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 列表合并

两个有序列表arr1,arr2,写个算法对这两个列表进行合并.(不可直接extend,然后调用sort)

# 注意审题 是两个有序列表！！！
def loop_merge_sort(arr1, arr2):
    temp = []
    while len(arr1) > 0 and len(arr2) > 0:
        if arr1[0] < arr2[0]:
            temp.append(arr1[0])
            del arr1[0]
        else:
            temp.append(arr2[0])
            del arr2[0]
    return temp


arr1 = [1, 2, 3, 67, 88, 99]
arr2 = [23, 44, 66, 67, 77, 90]

print(loop_merge_sort(arr1, arr2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 字典

# 相同键的值的和

统计两个字典相同键的值的和

def func_1(dict_1, dict_2):
    union_set = set(dict_1) | set(dict_2)
    v = dict()
    for i in union_set:
        v[i] = dict_1.get(i, 0) + dict_2.get(i, 0)
    return v

def func_2(dic_1, dic_2):
    for k in dic_2:
        if k not in dic_1:
            dic_1.update({k: dic_2[k]})
        else:
            dic_1[k] += dic_2[k]
    return dic_1

dict_1 = {'eyes': 8, 'the': 5, 'my': 3}
dict_2 = {'eyes': 2, 'looking': 1, 'my': 5}

print(func_1(dict_1, dict_2))
print(func_2(dict_1, dict_2))
'''
{'the': 5, 'looking': 1, 'eyes': 10, 'my': 8}
{'eyes': 10, 'the': 5, 'my': 8, 'looking': 1}
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 字典排序
# -- name优先级最高,age其次  用元祖!!
alist = [{'name': 'a', 'age': 20}, {'name': 'a', 'age': 10}, {'name': 'b', 'age': 25}]
res = sorted(alist, key=lambda x: (x['name'], x['age']))
print(res)
1
2
3
4

# 集合

删除一个list里重复元素并保持它们原来的排序 key=l1.index

# -- dir输出的是数据类型的内建方法
>>> 'index' in dir(set)
False
>>> 'index' in dir(dict)
False
>>> 'index' in dir(list)
True
>>> 'index' in dir(str)
True
>>> 'index' in dir(tuple)
True

>>> a = []
>>> type(a.index)
<class 'builtin_function_or_method'>
>>> help(a.index)
Help on built-in function index:

index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
    Return first index of value.
    
    Raises ValueError if the value is not present.

>>> l1 = ['b','c','d','b','c','a','a']
>>> sorted(set(l1))
['a', 'b', 'c', 'd']
>>> sorted(l1,key=l1.index)
['b', 'b', 'c', 'c', 'd', 'a', 'a']
>>> sorted(set(l1),key=l1.index)
['b', 'c', 'd', 'a']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 递归

# 删除文件夹

递归删除某一文件(包含子文件和子文件夹)

import os

def del_files(path):
    for i in os.listdir(path):
        if '.py' in i:
            continue
        is_dir = os.path.join(path, i)
        if os.path.isdir(is_dir):
            del_files(is_dir)

        os.remove(is_dir)

"""
os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。
它不包括 . 和 .. 即使它在文件夹中

os.isdir() 判断某一路径是否为目录 返回bool值
os.join() 将目录和文件名合成一个路径
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 快速排序
data = [20, 30, 9, 54, 12, 24, 11]
# data = [9, 10, 11, 12]

def quick_sort(data, head, tail):
    # -- 若已经排序好了 移动后head与tail的值都为0 进入递归 '0 > -1'
    if head >= tail:
        return
    # -- low和height是为了记录进入递归后每次子序列的高低界限
    low = head
    height = tail
    pivot = data[head]
    while head < tail:
        while head < tail and data[tail] >= pivot:
            tail -= 1
        data[head] = data[tail]
        while head < tail and data[head] <= pivot:
            head += 1
        data[tail] = data[head]
    data[head] = pivot
    quick_sort(data, low, head - 1)  # 0
    # -- quick_sort(data, head + 1, tail) 不行
    #    因为执行完‘#0’后(里面会再嵌套执行#0 #1 直到依次return)
    #    再执行'#1' 这里的参数值会保留#0运行前作用域里的值 data 4 3 tail值是为3的而不是6
    quick_sort(data, head + 1, height)  # 1

quick_sort(data, 0, len(data) - 1)
print(data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 查找指定字段

查找嵌套字典中指定字段的值

data = {
    'time': '2022-2-22',
    'grp1': {
        'fld1': 1,
        'fld2': 2
    },
    'fld6': 11,
    'fld7': 7,
    'fld46': 8,
}
fields = 'fld2|fld3|fld7|fld19'

# -- 这里很有意思哦!!! res={}
def select(data, fields, res={}):
    # res = {}
    fields_list = fields.split('|')
    for field in fields_list:
        for key in data:
            if field == key:
                res[key] = data[key]
            elif type(data[key]) == dict:
                select(data[key], fields)
                # res.update(select(data[key], fields))

    return res


print(select(data, fields))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 目录操作

递归复制目录并清空指定文件的内容

import shutil
import os

src_file = 'python后端之旅/0_python面向过程/ATM_shopping'
target_path = 'D:/desktop/111'

# -- shutil.copytree中的target_path参数路径不能事先存在
if os.path.exists(target_path):
    # -- 递归删除文件夹
    shutil.rmtree(target_path)

# -- 递归复制源路径里的文件,可以指定忽略的文件
shutil.copytree('python后端之旅/0_python面向过程/ATM_shopping', target_path, \
                ignore=shutil.ignore_patterns('__pycache__', '.idea', '*.json', '*.log'\
                                              ,'*.pic'),copy_function=shutil.copy2)

# -- 递归文件夹,清除.py和.md文件的内容
def truncate_file(path):
    for i in os.listdir(path):  # -- 获取该目录下的所有文件和子目录
        if '.py' in i or '.md' in i:
            file_path = os.path.join(path, i)
            with open(file_path, 'r+', encoding='utf8') as f:
                f.truncate()
            continue
        is_dir = os.path.join(path, i)
        if os.path.isdir(is_dir):
            truncate_file(is_dir)


truncate_file(target_path)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 其它

# yml目录的制作
import os


# -- 将path路径下的md文件组织成这个格式！“- 计算机网络储备: 4_网络并发编程/0_计算机网络储备.md”
def change_to_yml(path):
    res = os.listdir(path)  # -- 得到的目录文件先后顺序是乱的
    res.remove("assets")
    # -- 加eval是为了按照数字排序 ["1","10","2"] [1,2,10]
    res = sorted(res, key=lambda item: eval(item.split("_")[0]))

    for item in res:
        if item.endswith("md"):
            temp = item.split(".")
            k = temp[0].split("_")[1]
            v = os.path.basename(path) + "/" + item
            print(f"- {k}: {v}")


if __name__ == "__main__":
    path = "/Users/One_Piece/Desktop/Dc_IT/docs/4_网络并发编程"
    change_to_yml(path)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 取md文档中的图片
# -- 想要取到md文件中所有图片的名字 比如: ![](./assets/1.png)里的1.png
import re

path = "/Users/One_Piece/Desktop/Dc_IT/docs/5_db/0_基础/0_install_db.md"

with open(path, "r", encoding="utf-8") as f:
    a = f.read()

# -- \将[]()这些括号给转义 ()取出我们想要的内容!!
want_move_pic_list = re.findall("!\[.*\]\(.*/(.*)\)", a)

# -- Ps: 取两个列表的交集 set(list_1)&set(list_2)
1
2
3
4
5
6
7
8
9
10
11
12
模块导入与包
饶头训练

← 饶头训练→

最近更新
01
卷积神经网络
01-17
02
过拟合与欠拟合的处理
01-16
03
Mnist分类任务
01-16
更多文章>
Theme by Vdoing | Copyright © 2023-2025 DC | One Piece