记第一个对我有实际作用的程序（逃）

发表于 更新于 分类于 本文字数： 1.7k 阅读时长 ≈ 6 分钟

问题的起因（挖坑原因）：

  1. 玩乐器的同学知道，简谱上的不同调之间的转换不如五线谱上方便，我原来最先是参照转调表一个一个人工查找 😥 太累，后来就想写个程序完成了。
  2. ———关于调，不懂的可以百毒一下。。。就是与起始音 do 的位置，或者末音 la 的位置（这不是小调了吗，不管，乐理也不太精通，如有大神求指出）

问题的实现：

  1. 脑洞昨天太大 😓，明明只是一个会 C 调的，你干嘛要写个转换任意调的。。。。
    原始目的只是想任意调转成 C，后来写着写着觉得这样这程序太弱了（虽然本来就不强)，就临时想转成任意调了。。。。于是有琢磨了一会就有了实现。。。

  2. 实现思路：当初第一目的——任意调到 C，最初是想通过 if 一句一句判断进行实现。。。。后来想写任意调后发现不现实，因为会有 C(6,2)，15 种可能，每个 if 下还要再进行判断是否是 1，2，3，4，这类的简谱名，这样会造成程序的冗长与无用。。。于是就放弃了

  3. 于是想到了 Python 的 dict 数据结构，使用 key-value 对，便可以便捷的实现调之间转换，只需提前输入好 dict

实现过程中的问题：

  1. 我就不应该用 command line（命令行）来获取输入数据 🙈

  2. 命令行输入的数据我要考虑各种间隔，因为 input()函数获取的输入是“**“中的所有字符，其中考虑如何实现区分，b7,7 ，8 这类输入都头疼了我好久。。

    b7 在 input()中会当成 b 和 7 两个单独的字符，而我想表示的是低音 7，

    cmd

    7，8 在 input()中也会傻不拉唧的把逗号（，）也识别进入，我要想办法去除符号后才能进行数据操作

问题的解决

  1. input()的问题，假设用户配合，全用空格分开，便可利用.split(" ")方法进行去除，之后便可传入列表就行操作
  2. 函数中局部变量和函数定义好后，不会自行调用真是够了

一些感想

  1. 变量名要取好，我这么一点我都有时忘记了这个变量是干嘛（水平太差）

  2. 函数中的变量尽量与函数外的变量不要重名，我这个就是重名的，有时搞不懂为何会没有输出，就是因为函数中变量是局部的

  3. 写什么要先写好第一目的，不要想我这样，写着写着又想写其他目的了，也不要想我一样边写边调试，大部分时间都废在找 bug 和纠错上了。。。。当然因为我是写着写着就想别的目的了，所以边写边调试还是没什么问题的。。。（我觉得）

垃圾代码

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#一时兴起想写的转换简谱调的代码，可以实现任意调之间的转换，啪啪啪，如果在字典中
#有的话。。。字典还没填完备，暂时只有其他调的全音，还无半音
#因为字典还不完备，任意调之间的转换可能会出问题，转c调是没问题的
#（啪啪，打脸，@_@，原本只是想任意调转c，后来脑洞又开，写任意调了）
#命令行版本。。command line version。我觉得还是函数版本好写，不管了以后有空再补
#输入
print("Please enter the original an'dand ambition tune(use space splite)")
tuneer = input("The default is to C:")
'''#b表示低音，#表示升（半音阶），g表示高音，用b#表示低半音，用g#表示高半音'''
putin = input("please enter number:")
first1 = ""
listin1 = []
listin2 = []
listout1 = []
listout2 = []
listoutTemp = []
listTemp = []
changekey = {}
changekey2 = {}

# #如有空格去除后再操作
# first1 =""
# listin1 = []
# listin2 = []
# listout1 = []
# first1 = putin.strip()
# final1 = first1.split(" ")
# for i in final1:
    # listin1.append(i)
# print(listin1)
# #对tune去除
# first2 =""
# first2 = tuneer.strip()
# final2 = first2.split(" ")
# for i in final2:
    # listin2.append(i)
# print(listin2)

#清除空格和转换大小写，默认到c调
def checkspace(listin):
    '''#b表示低音，#表示升（半音阶），g表示高音，用b#表示低半音，用g#表示高半音'''
    listTemp = ""
    listTemp = listin.strip()
    listlow = listTemp.lower()
    listOut = listlow.split(" ")
    if len(listOut) == 1:
        listOut.append("c")
    return listOut

#获取原始输入
listin1 = checkspace(putin)
formtuneer = checkspace(tuneer)
tuneerin = formtuneer[0]
tuneerout = formtuneer[1]

#b表示低音，#表示升（半音阶），g表示高音，用b#表示低升半音，用g#表示高半音

#keys
GtoC = {"1" : "b5", "2" : "b6", "3" : "b7", "4" : "1", "5" : "2", "6": "3",
"7" : "#4", "g1" : "5", "g2":"6","g3":"7","g4":"g1","g5":"g2","g6":"3",
"g7":"g#4","gg1":"g5"}
AtoC = {"b7" : "#5", "1" : "b6", "2" : "b7", "3" : "#1", "4" : "2", "5" : "3",
"6" : "#4", "7" : "#5", "g1" : "6", "g2" : "7", "g3" : "g#1", "g4" : "g2",
"g5" : "g3", "g6" : "g#4" }
BtoC = {"b6" : "b#5", "b7":"b#6", "1" : "b7", "2" : "#1", "3" : "#2", "4" : "3",
"5" : "#4", "6" : "#5", "7" : "#6", "g1" : "7", "g2" : "g#1", "g3" : "g#2",
"g4" : "g3", "g5" : "g#4"}
DtoC = {"b4" : "b5", "b5" : "b6", "b6" : "b7", "b7" : "#1", "1" : "2",
"2" : "3", "3" : "#4", "4" : "5", "5" : "6", "6" : "7", "7" : "g#1",
"g1" : "g2", "g3" : "g#4", "g4" : "g5"}
EtoC = {"b3" : "b#5", "b4" : "b6", "b5" : "b7", "b6" : "#1", "b7" : "#2",
"1" : "3", "2" : "#4", "3" : "#5", "4" : "6", "5" : "7", "6" : "g#1",
"7" : "g#2", "g1" : "g3", "g2" : "g#4"}
FtoC = {"b2" : "b5", "b3" : "b6", "b4" : "b#6", "b5" : "1", "b6" : "2",
"b7" : "3", "1" : "4", "2" : "5", "3" : "6", "4" : "#6", "5" : "g1", "6" : "g2",
"7" : "g3", "g1" : "g4", "g2" : "g5"}

Fulltunekey = {"g":GtoC, "a" : AtoC, "b" : BtoC, "d" : DtoC,
"e" : EtoC, "f" : FtoC}

#Anykeys，key转换
def inverse(dict):
    dictout = {v : k for k,v in dict.items()}
    return dictout

CtoG = inverse(GtoC)
CtoA = inverse(AtoC)
CtoB = inverse(BtoC)
CtoD = inverse(DtoC)
CtoE = inverse(EtoC)
CtoF = inverse(FtoC)

Fulltuneanykey = {"g" : CtoG, "a" : CtoA, "b" : CtoB, "d" : CtoD,
"e" : CtoE, "f" : CtoF}

#转换key-values对 （first 全到C)
def dictoc(tuneerin,tuneerout):
    if tuneerin == "a":
        changekey = Fulltunekey["a"]
    elif tuneerin == "g":
        changekey = Fulltunekey["g"]
    elif tuneerin == "b":
        changekey = Fulltunekey["b"]
    elif tuneerin == "d":
        changekey = Fulltunekey["d"]
    elif tuneerin == "e":
        changekey = Fulltunekey["e"]
    elif tuneerin == "f":
        changekey = Fulltunekey["f"]
    return changekey
# def dicany(tuneerin,tuneerout):
    # if tuneerin != "c":
        # changekey = Fulltunekey[tuneerin]

#判断输出，如不是C，再进行转换
def dictoany(tuneerout):
    if tuneerout == "a":
        changekey2 = Fulltuneanykey["a"]
    elif tuneerout == "g":
        changekey2 = Fulltuneanykey["g"]
    elif tuneerout == "b":
        changekey2 = Fulltuneanykey["b"]
    elif tuneerout == "d":
        changekey2 = Fulltuneanykey["d"]
    elif tuneerout == "e":
        changekey2 = Fulltuneanykey["e"]
    elif tuneerout == "f":
        changekey2 = Fulltuneanykey["f"]
    return changekey2

#强制全部到c调
def alltoC(tuneerin):
    changekey = dictoc(tuneerin, tuneerout)
    for i in listin1:
        listout1.append(changekey[i])
    #print(listout1)
    return listout1


# print(listout1)
def ctoall(tuneerout):
    if tuneerout != "c":
        changekey2 = dictoany(tuneerout)
        listout1 = alltoC(tuneerin)
        for i in listout1:
            listout2.append(changekey2[i])
    return listout2
# ctoall(tuneerout)
# print(listout2)

# if tuneerout != "c":
    # dicany(tuneerout)
    # for i in listoutTemp:
        # listout1.append(changekey[i])
    # print(listout1)


#最后输出
def checkout(tuneerin,tuneerout):
    if tuneerout == "c":
        alltoC(tuneerin)
        print(tuneerin,listin1)
        print("->")
        print("c",listout1)
    else:
        listout2 = ctoall(tuneerout)
        print(tuneerin,listin1)
        print("->")
        print(tuneerout,listout2)
    return

checkout(tuneerin,tuneerout)


#AtoC = {"b7" : "#5", "1" : "b6", "2" : "b7", "3" : "#1", "4" : "2",
"5" : "3", "6" : "#4", "7" : "#5", "g1" : "6", "g2" : "7", "g3" : "g#1",
"g4" : "g2", "g5" : "g3", "g6" : "g#4" }
# if tuneerout == "c":
    # for i in listin1:
        # listout1.append(changekey[i])
    # print(listout1)

如有大神愿意改良或者提出修改的话。。。求到 Github 地址

感激不尽。。。。（半路出家，最近更快期末了，压力山大 ）