用Python编写一个简易的图书管理系统

2019-12-07

预期功能

  1.本系统包括登录主界面、管理系统主界面以及各功能分支界面。
  2.登录界面可以实现用户注册、用户登录和退出程序的功能。
  3.管理系统主界面可以实现增加书籍、删除书籍、查阅书籍信息、修改书籍信息、查看所有书籍信息、返回登录界面和退出程序的功能。其中书籍信息包括书名、作者、出版社、定价和数目。

用户的注册和登录

  在编写程序之前，我们需要导入sys库，并且创建两个空列表books和users，用来存储书籍和用户的信息。除此之外，我们还需要设置一个标志flag，用来判断用户是否成功登录系统。 

1
2
3
4
5
import sys

books = []
users = []
flag = False

  我们编写两个函数login()和register()，分别用来实现用户的注册和登录的功能。
  函数login()代码如下： 

1
2
3
4
5
6
7
8
9
10
11
def login():
    print('请输入用户名：', end='')
    username = input()
    print('请输入密码：', end='')
    password = input()
    if [username, password] in users:
        print('\033[0;32m登录成功！\033[0m')
        flag = True
        fun()
    else:
        print('\033[0;31m用户名或密码错误！请重新登录！\033[0m')

  函数register()代码如下： 

1
2
3
4
5
6
7
def register():
    print('请输入用户名：', end='')
    username = input()
    print('请输入密码：', end='')
    password = input()
    users.append([username, password])
    print('\033[0;32m注册成功！\033[0m')

注：上述代码中的\033[0;32m及类似代码表示设定字体样式和颜色，语法为\033[显示方式;前景色;背景色m。函数login()中调用了函数fun()，后者是管理系统主界面函数，会在下面提到。

登录主界面

  登录界面中，我们需要考虑到用户的错误输入的相关处理。最好的方法是使用try-except语句。代码如下所示： 

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
def main():
    while True:
        print('\n\n')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        print('*************欢迎来到图书管理系统*************')
        print('************Made by Chen Chunhan************')
        print('********************************************')
        print('*************** 1.Log in     ***************')
        print('*************** 2.Register   ***************')
        print('*************** 0.Exit       ***************')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        try:
            num = int(input('请输入对应的数字：'))
            if num == 1:
                login()
            elif num == 2:
                register()
            elif num == 0:
                print('\033[0;36m再见！\033[0m')
                sys.exit(0)
            else:
                print('\033[0;31m输入错误！请重新输入！\033[0m')
        except ValueError:
            print('\033[0;31m输入错误！请重新输入！\033[0m')

管理系统主界面

  管理系统中有增加书籍、删除书籍、查阅书籍信息、修改书籍信息、查看所有书籍信息、返回登录界面和退出程序七大功能。我们之前提到，书籍的信息是通过列表来存储的，在管理系统主界面函数中，这一点将得到很好的体现。程序的代码实现比较简单，在此不再赘述。
  我们定义管理系统主界面的函数fun()。因为main()已经被用过了，我也想不出有什么更好的名字，姑且用fun()来将就一下。在fun()中，我们也要用到try-except语句来对可能出现的用户错误输入进行处理。
  其中，在“查看所有书籍信息”的时候，我们需要把所有书籍信息按表格的形式输出，这样显得更加简洁直观。为实现这个功能，我们在程序开头导入第三方库prettytable中的PrettyTable模块： 

1
from prettytable import PrettyTable

在这里，笔者使用的是Anaconda。对于第三方库prettytable的安装，我们在开始菜单中找到Anaconda Prompt，单击鼠标右键→更多→以管理员身份运行，输入命令pip install prettytable，等待安装完成即可。安装后，我们可以运行代码import prettytable，如果没有报错即为安装成功。

  函数fun()代码如下： 

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
def fun():
    while True:
        print('\n\n')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        print('**********  1.More Books          **********')
        print('**********  2.Delete Books        **********')
        print('**********  3.Search for Books    **********')
        print('**********  4.Change Information  **********')
        print('**********  5.View All Books      **********')
        print('**********  6.Back to Main Menu   **********')
        print('**********  0.Exit                **********')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        try:
            num = int(input('请输入对应的数字：'))
            print('\n')
            if num == 1:
                bookname = input('请输入书名：')
                author = input('请输入作者：')
                press = input('请输入出版社：')
                price = input('请输入书籍定价：')
                amount = input('请输入书籍数目：')
                books.append([bookname, author, press, price, amount])
                print('\n\033[0;32m添加书籍成功！\033[0m')
            elif num == 2:
                bookname = input('请输入书名：')
                author = input('请输入作者：')
                press = input('请输入出版社：')
                price = input('请输入书籍定价：')
                amount = input('请输入书籍数目：')
                if [bookname, author, press, price, amount] in books:
                    books.remove([bookname, author, press, price, amount])
                    print('\n\033[0;32m删除书籍成功！\033[0m')
                else:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
            elif num == 3:
                bookname = input('请输入书名：')
                j = 0
                for i in books:
                    if i[0] == bookname:
                        j = 1
                        print('书名：', i[0])
                        print('作者：', i[1])
                        print('出版社：', i[2])
                        print('定价：', i[3])
                        print('数目：', i[4])
                if j == 0:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
                print('\n查找结束\n')
            elif num == 4:
                bookname = input('请输入要修改的书名：')
                author = input('请输入要修改的作者：')
                press = input('请输入要修改的出版社：')
                price = input('请输入要修改的书籍定价：')
                amount = input('请输入要修改的书籍数目：')
                if [bookname, author, press, price, amount] in books:
                    books.remove([bookname, author, press, price, amount])
                    bookname = input('请输入修改后的书名：')
                    author = input('请输入修改后的作者：')
                    press = input('请输入修改后的出版社：')
                    price = input('请输入修改后的书籍定价：')
                    amount = input('请输入修改后的书籍数目：')
                    books.append([bookname, author, press, price, amount])
                    print('\n\033[0;32m修改书籍成功！\033[0m')
                else:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
            elif num == 5:
                table = PrettyTable(['书名', '作者', '出版社', '定价', '数目'])
                for i in books:
                    table.add_row(i)
                print(table)
            elif num == 6:
                main()
            elif num == 0:
                print('\033[0;36m再见！\033[0m')
                sys.exit(0)
            else:
                print('\033[0;31m输入错误！请重新输入！\033[0m')
        except ValueError:
            print('\033[0;31m输入错误！请重新输入！\033[0m')

  到此，对于这个程序的所有功能，我们都编写了对应的函数来实现。

完整的图书管理系统代码

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
import sys
from prettytable import PrettyTable

books = []
users = []
flag = False


def login():
    print('请输入用户名：', end='')
    username = input()
    print('请输入密码：', end='')
    password = input()
    if [username, password] in users:
        print('\033[0;32m登录成功！\033[0m')
        flag = True
        fun()
    else:
        print('\033[0;31m用户名或密码错误！请重新登录！\033[0m')


def register():
    print('请输入用户名：', end='')
    username = input()
    print('请输入密码：', end='')
    password = input()
    users.append([username, password])
    print('\033[0;32m注册成功！\033[0m')


def main():
    while True:
        print('\n\n')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        print('*************欢迎来到图书管理系统*************')
        print('************Made by Chen Chunhan************')
        print('********************************************')
        print('*************** 1.Log in     ***************')
        print('*************** 2.Register   ***************')
        print('*************** 0.Exit       ***************')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        try:
            num = int(input('请输入对应的数字：'))
            if num == 1:
                login()
            elif num == 2:
                register()
            elif num == 0:
                print('\033[0;36m再见！\033[0m')
                sys.exit(0)
            else:
                print('\033[0;31m输入错误！请重新输入！\033[0m')
        except ValueError:
            print('\033[0;31m输入错误！请重新输入！\033[0m')


def fun():
    while True:
        print('\n\n')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        print('**********  1.More Books          **********')
        print('**********  2.Delete Books        **********')
        print('**********  3.Search for Books    **********')
        print('**********  4.Change Information  **********')
        print('**********  5.View All Books      **********')
        print('**********  6.Back to Main Menu   **********')
        print('**********  0.Exit                **********')
        print('********************************************')
        print('********************************************')
        print('********************************************')
        try:
            num = int(input('请输入对应的数字：'))
            print('\n')
            if num == 1:
                bookname = input('请输入书名：')
                author = input('请输入作者：')
                press = input('请输入出版社：')
                price = input('请输入书籍定价：')
                amount = input('请输入书籍数目：')
                books.append([bookname, author, press, price, amount])
                print('\n\033[0;32m添加书籍成功！\033[0m')
            elif num == 2:
                bookname = input('请输入书名：')
                author = input('请输入作者：')
                press = input('请输入出版社：')
                price = input('请输入书籍定价：')
                amount = input('请输入书籍数目：')
                if [bookname, author, press, price, amount] in books:
                    books.remove([bookname, author, press, price, amount])
                    print('\n\033[0;32m删除书籍成功！\033[0m')
                else:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
            elif num == 3:
                bookname = input('请输入书名：')
                j = 0
                for i in books:
                    if i[0] == bookname:
                        j = 1
                        print('书名：', i[0])
                        print('作者：', i[1])
                        print('出版社：', i[2])
                        print('定价：', i[3])
                        print('数目：', i[4])
                if j == 0:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
                print('\n查找结束\n')
            elif num == 4:
                bookname = input('请输入要修改的书名：')
                author = input('请输入要修改的作者：')
                press = input('请输入要修改的出版社：')
                price = input('请输入要修改的书籍定价：')
                amount = input('请输入要修改的书籍数目：')
                if [bookname, author, press, price, amount] in books:
                    books.remove([bookname, author, press, price, amount])
                    bookname = input('请输入修改后的书名：')
                    author = input('请输入修改后的作者：')
                    press = input('请输入修改后的出版社：')
                    price = input('请输入修改后的书籍定价：')
                    amount = input('请输入修改后的书籍数目：')
                    books.append([bookname, author, press, price, amount])
                    print('\n\033[0;32m修改书籍成功！\033[0m')
                else:
                    print('\n\033[0;31m该书籍不存在！自动返回...\033[0m')
            elif num == 5:
                table = PrettyTable(['书名', '作者', '出版社', '定价', '数目'])
                for i in books:
                    table.add_row(i)
                print(table)
            elif num == 6:
                main()
            elif num == 0:
                print('\033[0;36m再见！\033[0m')
                sys.exit(0)
            else:
                print('\033[0;31m输入错误！请重新输入！\033[0m')
        except ValueError:
            print('\033[0;31m输入错误！请重新输入！\033[0m')


main()

  这里不便给出运行实例，大家可以自己试一试。

写在最后

  以上就是用Python编写一个简易的图书管理系统的全部内容。这个管理系统还有很多需要优化的地方，我会在后续逐渐改良。如果有什么好的想法，欢迎与我联系！
  我的邮箱：1398635912@qq.com

Python在生物学领域的简单应用——处理DNA序列

2019-11-23

DNA的反向互补序列

  假设我们有一串DNA序列，存在一个名为“dna.txt”的文本文档中。那么，我们该如何用Python输出它的反向序列、互补序列以及反向互补序列呢？
  在这之前，我们不妨定义一个函数，用来打开并读取txt文件。我们把这个函数命名为read_seq()，这个函数的参数为我们的文件路径。需要注意的一点是，在dna.txt文件中，存在着换行符\n和回车符\r（如下图所示），而我们只需要用到代表碱基序列的大写字母。我们可以用replace()方法来替换掉它们。
Alt
  最终，我们定义的read_seq()函数如下： 

1
2
3
4
5
6
def read_seq(inputfile):
    file = open(inputfile, "r")
    seq = file.read()
    seq = seq.replace("\n", "")
    seq = seq.replace("\r", "")
    return seq

  接下来，我们需要定义dna_complement()，dna_reverse()和dna_revcomp()三个函数。在定义dna_complement()函数的时候，和上面替换换行符和回车符同样的道理，我们可以用replace()方法来替换字符串中代表碱基的大写字母。而定义后两个函数明显容易得多，我们只需要让字符串反向输出就可以了。我们定义的dna_complement()，dna_reverse()和dna_revcomp()三个函数如下所示： 

1
2
3
4
5
6
7
def dna_complement(seq):
    seq = seq.upper()
    seq = seq.replace('A', 'T')
    seq = seq.replace('T', 'A')
    seq = seq.replace('C', 'G')
    seq = seq.replace('G', 'C')
    return seq
1
2
3
def dna_reverse(seq):
    seq = seq.upper()
    return seq[::-1]
1
2
3
def dna_revcomp(seq):
    seq = seq.upper()
    return dna_complement(seq)[::-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
25
26
27
28
29
30
31
32
33
def dna_complement(seq):
    seq = seq.upper()
    seq = seq.replace('A', 'T')
    seq = seq.replace('T', 'A')
    seq = seq.replace('C', 'G')
    seq = seq.replace('G', 'C')
    return seq


def dna_reverse(seq):
    seq = seq.upper()
    return seq[::-1]


def dna_revcomp(seq):
    seq = seq.upper()
    return dna_complement(seq)[::-1]


def read_seq(inputfile):
    file = open(inputfile, "r")
    seq = file.read()
    seq = seq.replace("\n", "")
    seq = seq.replace("\r", "")
    return seq


if __name__ == '__main__':
    dna = read_seq("E:\\python_pycharm\\一些Python程序练习\\DNA\\dna.txt")
    print(dna)                          # 原DNA序列
    print(dna_complement(dna))          # DNA互补序列
    print(dna_reverse(dna))             # DNA反向序列
    print(dna_revcomp(dna))             # DNA反向互补序列

  输出结果如下： 

1
2
3
4
GGTCAGAAAAAGCCCTCTCCATGTCTACTCACGATACATCCCTGAAAACCACTGAGGAAGTGGCTTTTCAGATCATCTTGCTTTGCCAGTTTGGGGTTGGGACTTTTGCCAATGTATTTCTCTTTGTCTATAATTTCTCTCCAATCTCGACTGGTTCTAAACAGAGGCCCAGACAAGTGATTTTAAGACACATGGCTGTGGCCAATGCCTTAACTCTCTTCCTCACTATATTTCCAAACAACATGATGACTTTTGCTCCAATTATTCCTCAAACTGACCTCAAATGTAAATTAGAATTCTTCACTCGCCTCGTGGCAAGAAGCACAAACTTGTGTTCAACTTGTGTTCTGAGTATCCATCAGTTTGTCACACTTGTTCCTGTTAATTCAGGTAAAGGAATACTCAGAGCAAGTGTCACAAACATGGCAAGTTATTCTTGTTACAGTTGTTGGTTCTTCAGTGTCTTAAATAACATCTACATTCCAATTAAGGTCACTGGTCCACAGTTAACAGACAATAACAATAACTCTAAAAGCAAGTTGTTCTGTTCCACTTCTGATTTCAGTGTAGGCATTGTCTTCTTGAGGTTTGCCCATGATGCCACATTCATGAGCATCATGGTCTGGACCAGTGTCTCCATGGTACTTCTCCTCCATAGACATTGTCAGAGAATGCAGTACATATTCACTCTCAATCAGGACCCCAGGGGCCAAGCAGAGACCACAGCAACCCATACTATCCTGATGCTGGTAGTCACATTTGTTGGCTTTTATCTTCTAAGTCTTATTTGTATCATCTTTTACACCTATTTTATATATTCTCATCATTCCCTGAGGCATTGCAATGACATTTTGGTTTCGGGTTTCCCTACAATTTCTCCTTTACTGTTGACCTTCAGAGACCCTAAGGGTCCTTGTTCTGTGTTCTTCAACTGTTGAAAGCCAGAGTCACTAAAAATGCCAAACACAGAAGACAGCTTTGCTAATACCATTAAATACTTTATTCCATAAATATGTTTTTAAAAGCTTGTATGAACAAGGTATGGTGCTCACTGCTATACTTATAAAAGAGTAAGGTTATAATCACTTGTTGATATGAAAAGATTTCTGGTTGGAATCTGATTGAAACAGTGAGTTATTCACCACCCTCCATTCTCT
CCACACAAAAACCCCACACCAACACAACACACCAAACAACCCACAAAACCACACACCAACACCCAAAACACAACAACAACCAAACCCACAAACCCCAACCCACAAAACCCAAACAAAAACACAAACACAAAAAAAACACACCAAACACCACACCAACAAAACACACCCCCACACAACACAAAAAAACACACAACCCACACCCCAAACCCAAAACACACAACCACACAAAAAAACCAAACAACAACAACACAAAACCACCAAAAAAACCACAAACACACCACAAAACAAAAAAACAAAACAACACACCCCACCACCCAACAACCACAAACAACACAACAACAACACAACACACAAACCAACACAAACACACACAACAACCACAAAAAACACCAAAACCAAAACACACACCAACACACACAAACAACCCAACAAAAACAACAAACACAACAACCAACAACACACACAAAAAAAACAACAACAAACCAAAAAACCACACACCACCACACAAAACACACAAAAACAAAAACACAAAAACCAACAACAACACAACCACAACACAAAACACACAACCCAAACACAACAACACCAAACCCCAACAACCCACAAACAACACCAACAACCACACCACCACACACACCAACCAACAACACCACCAAACACAAACACACACAAACCACAACAAAAACACACACAAACACCACCCCACCCCCCAACCACACACCACACCAACCCAAACAAACCACAACCACCAACACACAAAACAACCCAAAAAACAACAAACACAAAAAACAAACAACAAAAACACCAAAAAAAAAAAAACACAACAAACCCACACCCAAACCAAACACAAAAACCAAACCCCAAACCCAACAAAAACACCAAAACACAACACCAACACACACCCAAACCCACCAACAACACACAACAACAACACAACAAACCCACACACACAAAAAAACCCAAACACACAACACACCAAACCAAAAACCAAAAAAAACAAAAAACCAAAAAAAACAAAAAAAAACCAACAAACAACAACCAAACCACCACACACCAAAACAAAAAAAACACAAACCAAAAAAACACAACAACAAAACAAAACAAAACACCAACCAAACACAAACAAACACACACAAAAACACCACCCACCAAACACA
TCTCTTACCTCCCACCACTTATTGAGTGACAAAGTTAGTCTAAGGTTGGTCTTTAGAAAAGTATAGTTGTTCACTAATATTGGAATGAGAAAATATTCATATCGTCACTCGTGGTATGGAACAAGTATGTTCGAAAATTTTTGTATAAATACCTTATTTCATAAATTACCATAATCGTTTCGACAGAAGACACAAACCGTAAAAATCACTGAGACCGAAAGTTGTCAACTTCTTGTGTCTTGTTCCTGGGAATCCCAGAGACTTCCAGTTGTCATTTCCTCTTTAACATCCCTTTGGGCTTTGGTTTTACAGTAACGTTACGGAGTCCCTTACTACTCTTATATATTTTATCCACATTTTCTACTATGTTTATTCTGAATCTTCTATTTTCGGTTGTTTACACTGATGGTCGTAGTCCTATCATACCCAACGACACCAGAGACGAACCGGGGACCCCAGGACTAACTCTCACTTATACATGACGTAAGAGACTGTTACAGATACCTCCTCTTCATGGTACCTCTGTGACCAGGTCTGGTACTACGAGTACTTACACCGTAGTACCCGTTTGGAGTTCTTCTGTTACGGATGTGACTTTAGTCTTCACCTTGTCTTGTTGAACGAAAATCTCAATAACAATAACAGACAATTGACACCTGGTCACTGGAATTAACCTTACATCTACAATAAATTCTGTGACTTCTTGGTTGTTGACATTGTTCTTATTGAACGGTACAAACACTGTGAACGAGACTCATAAGGAAATGGACTTAATTGTCCTTGTTCACACTGTTTGACTACCTATGAGTCTTGTGTTCAACTTGTGTTCAAACACGAAGAACGGTGCTCCGCTCACTTCTTAAGATTAAATGTAAACTCCAGTCAAACTCCTTATTAACCTCGTTTTCAGTAGTACAACAAACCTTTATATCACTCCTTCTCTCAATTCCGTAACCGGTGTCGGTACACAGAATTTTAGTGAACAGACCCGGAGACAAATCTTGGTCAGCTCTAACCTCTCTTTAATATCTGTTTCTCTTTATGTAACCGTTTTCAGGGTTGGGGTTTGACCGTTTCGTTCTACTAGACTTTTCGGTGAAGGAGTCACCAAAAGTCCCTACATAGCACTCATCTGTACCTCTCCCGAAAAAGACTGG
ACACAAACCACCCACCACAAAAACACACACAAACAAACACAAACCAACCACAAAACAAAACAAAACAACAACACAAAAAAACCAAACACAAAAAAAACAAAACCACACACCACCAAACCAACAACAAACAACCAAAAAAAAACAAAAAAAACCAAAAAACAAAAAAAACCAAAAACCAAACCACACAACACACAAACCCAAAAAAACACACACACCCAAACAACACAACAACAACACACAACAACCACCCAAACCCACACACAACCACAACACAAAACCACAAAAACAACCCAAACCCCAAACCAAAAACACAAACCAAACCCACACCCAAACAACACAAAAAAAAAAAAACCACAAAAACAACAAACAAAAAACACAAACAACAAAAAACCCAACAAAACACACAACCACCAACACCAAACAAACCCAACCACACCACACACCAACCCCCCACCCCACCACAAACACACACAAAAACAACACCAAACACACACAAACACAAACCACCACAACAACCAACCACACACACCACCACACCAACAACCACAACAAACACCCAACAACCCCAAACCACAACAACACAAACCCAACACACAAAACACAACACCAACACAACAACAACCAAAAACACAAAAACAAAAACACACAAAACACACCACCACACACCAAAAAACCAAACAACAACAAAAAAAACACACACAACAACCAACAACACAAACAACAAAAACAACCCAACAAACACACACAACCACACACAAAACCAAAACCACAAAAAACACCAACAACACACACAAACACAACCAAACACACAACACAACAACAACACAACAAACACCAACAACCCACCACCCCACACAACAAAACAAAAAAACAAAACACCACACAAACACCAAAAAAACCACCAAAACACAACAACAACAAACCAAAAAAACACACCAACACACAAAACCCAAACCCCACACCCAACACACAAAAAAACACAACACACCCCCACACAAAACAACCACACCACAAACCACACAAAAAAAACACAAACACAAAAACAAACCCAAAACACCCAACCCCAAACACCCAAACCAACAACAACACAAAACCCACAACCACACACCAAAACACCCAACAAACCACACAACACAACCACACCCCAAAAACACACC

把DNA编码链转录为mRNA

  我们同样通过定义函数的方式来实现DNA编码链的转录。根据生物学相关知识，我们只需要把DNA编码链的T替换成U即可得到mRNA（在此我们忽略DNA的启动子与终止子）。代码实现如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def transcription(seq):
    # 这里我们假设给定DNA序列为编码链
    seq = seq.upper()
    seq = seq.replace('T', 'U')
    return seq


def read_seq(inputfile):
    file = open(inputfile, "r")
    seq = file.read()
    seq = seq.replace("\n", "")
    seq = seq.replace("\r", "")
    return seq


if __name__ == '__main__':
    dna = read_seq("E:\\python_pycharm\\一些Python程序练习\\DNA\\dna.txt")
    print(dna)                          # 原DNA序列（编码链）
    print(transcription(dna))           # 转录出的mRNA序列

根据DNA编码链序列或mRNA序列翻译出蛋白质序列

  我们先来讨论根据DNA编码链翻译蛋白质。定义一个新函数dna_translate()。在定义函数的过程中，我们需要思考一个问题：众所周知，mRNA翻译蛋白质是从起始密码子开始翻译，到终止密码子停止翻译。如果不考虑这个问题的话很有可能会得到错误的结果。定义函数如下： 

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
import re


def dna_translate(seq):
    table = {
        'ATA': 'I', 'ATC': 'I', 'ATT': 'I', 'ATG': 'M',
        'ACA': 'T', 'ACC': 'T', 'ACG': 'T', 'ACT': 'T',
        'AAC': 'N', 'AAT': 'N', 'AAA': 'K', 'AAG': 'K',
        'AGC': 'S', 'AGT': 'S', 'AGA': 'R', 'AGG': 'R',
        'CTA': 'L', 'CTC': 'L', 'CTG': 'L', 'CTT': 'L',
        'CCA': 'P', 'CCC': 'P', 'CCG': 'P', 'CCT': 'P',
        'CAC': 'H', 'CAT': 'H', 'CAA': 'Q', 'CAG': 'Q',
        'CGA': 'R', 'CGC': 'R', 'CGG': 'R', 'CGT': 'R',
        'GTA': 'V', 'GTC': 'V', 'GTG': 'V', 'GTT': 'V',
        'GCA': 'A', 'GCC': 'A', 'GCG': 'A', 'GCT': 'A',
        'GAC': 'D', 'GAT': 'D', 'GAA': 'E', 'GAG': 'E',
        'GGA': 'G', 'GGC': 'G', 'GGG': 'G', 'GGT': 'G',
        'TCA': 'S', 'TCC': 'S', 'TCG': 'S', 'TCT': 'S',
        'TTC': 'F', 'TTT': 'F', 'TTA': 'L', 'TTG': 'L',
        'TAC': 'Y', 'TAT': 'Y', 'TAA': '_', 'TAG': '_',
        'TGC': 'C', 'TGT': 'C', 'TGA': '_', 'TGG': 'W'
    }
    start_sit = re.search('ATG', seq)
    protein = ""
    for sit in range(start_sit.end() - 3, len(seq), 3):
        protein += table[seq[sit:sit + 3]]
        if table[seq[sit:sit + 3]] == '_':
            break
    return protein

  完整代码如下： 

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
import re


def dna_translate(seq):
    table = {
        'ATA': 'I', 'ATC': 'I', 'ATT': 'I', 'ATG': 'M',
        'ACA': 'T', 'ACC': 'T', 'ACG': 'T', 'ACT': 'T',
        'AAC': 'N', 'AAT': 'N', 'AAA': 'K', 'AAG': 'K',
        'AGC': 'S', 'AGT': 'S', 'AGA': 'R', 'AGG': 'R',
        'CTA': 'L', 'CTC': 'L', 'CTG': 'L', 'CTT': 'L',
        'CCA': 'P', 'CCC': 'P', 'CCG': 'P', 'CCT': 'P',
        'CAC': 'H', 'CAT': 'H', 'CAA': 'Q', 'CAG': 'Q',
        'CGA': 'R', 'CGC': 'R', 'CGG': 'R', 'CGT': 'R',
        'GTA': 'V', 'GTC': 'V', 'GTG': 'V', 'GTT': 'V',
        'GCA': 'A', 'GCC': 'A', 'GCG': 'A', 'GCT': 'A',
        'GAC': 'D', 'GAT': 'D', 'GAA': 'E', 'GAG': 'E',
        'GGA': 'G', 'GGC': 'G', 'GGG': 'G', 'GGT': 'G',
        'TCA': 'S', 'TCC': 'S', 'TCG': 'S', 'TCT': 'S',
        'TTC': 'F', 'TTT': 'F', 'TTA': 'L', 'TTG': 'L',
        'TAC': 'Y', 'TAT': 'Y', 'TAA': '_', 'TAG': '_',
        'TGC': 'C', 'TGT': 'C', 'TGA': '_', 'TGG': 'W'
    }
    start_sit = re.search('ATG', seq)
    protein = ""
    for sit in range(start_sit.end() - 3, len(seq), 3):
        protein += table[seq[sit:sit + 3]]
        if table[seq[sit:sit + 3]] == '_':
            break
    return protein


def read_seq(inputfile):
    file = open(inputfile, "r")
    seq = file.read()
    seq = seq.replace("\n", "")
    seq = seq.replace("\r", "")
    return seq


if __name__ == '__main__':
    dna = read_seq("E:\\python_pycharm\\一些Python程序练习\\DNA\\dna.txt")
    print(dna)
    print(dna_translate(dna)[:-1])

  在上面程序的第43行print(dna_translate(dna)[:-1])，在最后加上[:-1]的目的是“删除”掉DNA序列末尾的_（下划线）。输出结果如下： 

1
2
GGTCAGAAAAAGCCCTCTCCATGTCTACTCACGATACATCCCTGAAAACCACTGAGGAAGTGGCTTTTCAGATCATCTTGCTTTGCCAGTTTGGGGTTGGGACTTTTGCCAATGTATTTCTCTTTGTCTATAATTTCTCTCCAATCTCGACTGGTTCTAAACAGAGGCCCAGACAAGTGATTTTAAGACACATGGCTGTGGCCAATGCCTTAACTCTCTTCCTCACTATATTTCCAAACAACATGATGACTTTTGCTCCAATTATTCCTCAAACTGACCTCAAATGTAAATTAGAATTCTTCACTCGCCTCGTGGCAAGAAGCACAAACTTGTGTTCAACTTGTGTTCTGAGTATCCATCAGTTTGTCACACTTGTTCCTGTTAATTCAGGTAAAGGAATACTCAGAGCAAGTGTCACAAACATGGCAAGTTATTCTTGTTACAGTTGTTGGTTCTTCAGTGTCTTAAATAACATCTACATTCCAATTAAGGTCACTGGTCCACAGTTAACAGACAATAACAATAACTCTAAAAGCAAGTTGTTCTGTTCCACTTCTGATTTCAGTGTAGGCATTGTCTTCTTGAGGTTTGCCCATGATGCCACATTCATGAGCATCATGGTCTGGACCAGTGTCTCCATGGTACTTCTCCTCCATAGACATTGTCAGAGAATGCAGTACATATTCACTCTCAATCAGGACCCCAGGGGCCAAGCAGAGACCACAGCAACCCATACTATCCTGATGCTGGTAGTCACATTTGTTGGCTTTTATCTTCTAAGTCTTATTTGTATCATCTTTTACACCTATTTTATATATTCTCATCATTCCCTGAGGCATTGCAATGACATTTTGGTTTCGGGTTTCCCTACAATTTCTCCTTTACTGTTGACCTTCAGAGACCCTAAGGGTCCTTGTTCTGTGTTCTTCAACTGTTGAAAGCCAGAGTCACTAAAAATGCCAAACACAGAAGACAGCTTTGCTAATACCATTAAATACTTTATTCCATAAATATGTTTTTAAAAGCTTGTATGAACAAGGTATGGTGCTCACTGCTATACTTATAAAAGAGTAAGGTTATAATCACTTGTTGATATGAAAAGATTTCTGGTTGGAATCTGATTGAAACAGTGAGTTATTCACCACCCTCCATTCTCT
MSTHDTSLKTTEEVAFQIILLCQFGVGTFANVFLFVYNFSPISTGSKQRPRQVILRHMAVANALTLFLTIFPNNMMTFAPIIPQTDLKCKLEFFTRLVARSTNLCSTCVLSIHQFVTLVPVNSGKGILRASVTNMASYSCYSCWFFSVLNNIYIPIKVTGPQLTDNNNNSKSKLFCSTSDFSVGIVFLRFAHDATFMSIMVWTSVSMVLLLHRHCQRMQYIFTLNQDPRGQAETTATHTILMLVVTFVGFYLLSLICIIFYTYFIYSHHSLRHCNDILVSGFPTISPLLLTFRDPKGPCSVFFNC

  类似地，我们可以把上面几个程序综合一下，实现“DNA—(转录)→mRNA—(翻译)→蛋白质”的完整过程。代码如下： 

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
import re


def mrna_translate(seq):
    table = {
        'AUA': 'I', 'AUC': 'I', 'AUU': 'I', 'AUG': 'M',
        'ACA': 'T', 'ACC': 'T', 'ACG': 'T', 'ACU': 'T',
        'AAC': 'N', 'AAU': 'N', 'AAA': 'K', 'AAG': 'K',
        'AGC': 'S', 'AGU': 'S', 'AGA': 'R', 'AGG': 'R',
        'CUA': 'L', 'CUC': 'L', 'CUG': 'L', 'CUU': 'L',
        'CCA': 'P', 'CCC': 'P', 'CCG': 'P', 'CCU': 'P',
        'CAC': 'H', 'CAU': 'H', 'CAA': 'Q', 'CAG': 'Q',
        'CGA': 'R', 'CGC': 'R', 'CGG': 'R', 'CGU': 'R',
        'GUA': 'V', 'GUC': 'V', 'GUG': 'V', 'GUU': 'V',
        'GCA': 'A', 'GCC': 'A', 'GCG': 'A', 'GCU': 'A',
        'GAC': 'D', 'GAU': 'D', 'GAA': 'E', 'GAG': 'E',
        'GGA': 'G', 'GGC': 'G', 'GGG': 'G', 'GGU': 'G',
        'UCA': 'S', 'UCC': 'S', 'UCG': 'S', 'UCU': 'S',
        'UUC': 'F', 'UUU': 'F', 'UUA': 'L', 'UUG': 'L',
        'UAC': 'Y', 'UAU': 'Y', 'UAA': '_', 'UAG': '_',
        'UGC': 'C', 'UGU': 'C', 'UGA': '_', 'UGG': 'W'
    }
    start_sit = re.search('AUG', seq)
    protein = ""
    for sit in range(start_sit.end() - 3, len(seq), 3):
        protein += table[seq[sit:sit + 3]]
        if table[seq[sit:sit + 3]] == '_':
            break
    return protein


def transcription(seq):
    # 这里我们假设给定DNA序列为编码链
    seq = seq.upper()
    seq = seq.replace('T', 'U')
    return seq


def read_seq(inputfile):
    file = open(inputfile, "r")
    seq = file.read()
    seq = seq.replace("\n", "")
    seq = seq.replace("\r", "")
    return seq


if __name__ == '__main__':
    dna = read_seq("E:\\python_pycharm\\一些Python程序练习\\DNA\\dna.txt")
    print(dna)                          # 原DNA序列（编码链）
    mrna = transcription(dna)
    print(mrna)                         # 转录出的mRNA序列
    print(mrna_translate(mrna)[:-1])    # 翻译出的蛋白质序列

写在最后

  如果你有什么更好的想法，欢迎给我留言。
  我的邮箱：1398635912@qq.com

二维数组应用——用C语言实现10行等腰杨辉三角

2019-11-18

杨辉三角简介

  杨辉三角是中国数学史上的一个伟大成就。它是二项式系数在三角形中的一种几何排列。在欧洲叫被称为帕斯卡三角形。帕斯卡（1623-1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。杨辉三角是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。
Alt
  我们把行数定义为n，即第一行为n=1，第二行为n=2，以此类推。我们不难发现如下规律：
  1.每行的第一个数字和最后一个数字为1；
  2.从n=3开始，每个数等于它上方两个数之和，即第(n+1)行的第m个数等于第n行的第(m-1)个数和第m个数之和；
  3.第n行的数字有n项，第m个数和第(n-m+1)个数相等。
  接下来，我们先利用C语言的二维数组的相关知识，试着打印出一个10行直角杨辉三角吧。

10行直角杨辉三角

  我们刚刚已经分析了杨辉三角的相关性质，接下来我们用C语言先来编写一个直角的杨辉三角。代码实现如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#define N 10

int main(void)
{
	int arr[N][N] = { 0 };
	int i = 0;
	for (i = 0; i < N; i++)
	{
		int j = 0;
		for (j = 0; j <= i; j++)
		{
			if ((0 == j) || (i == j))
				arr[i][j] = 1;
			else
				arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
			printf("%4d", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

  输出结果如下： 

1
2
3
4
5
6
7
8
9
10
1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5  10  10   5   1
1   6  15  20  15   6   1
1   7  21  35  35  21   7   1
1   8  28  56  70  56  28   8   1
1   9  36  84 126 126  84  36   9   1

从直角三角形到等腰三角形的进阶

  我们已经成功写出了直角杨辉三角。接下来，我们来试着在它的基础上修改一下代码，让它能打印出等腰杨辉三角。
  我们之前用C语言写过打印金字塔图形的程序。想要打印出等腰的金字塔图形，就要找出一些规律，通过控制行与列来控制何时打印空格，何时打印星号。实现从直角杨辉三角到等腰杨辉三角的进阶也是同样的道理，我们要试图控制空格的输出，来达到等腰三角形的效果。
  最终用C语言实现如下： 

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
#include <stdio.h>
#define N 10

int main(void)
{
	int arr[N][N] = { 0 };
	int i = 0;
	for (i = 0; i < N; i++)
	{
		int m = 0;
		for (m = 0; m < N - i; m++)
			printf("  ");
		int j = 0;
		for (j = 0; j <= i; j++)
		{
			if ((0 == j) || (i == j))
				arr[i][j] = 1;
			else
				arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
			printf("%4d", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

  输出结果如下： 

1
2
3
4
5
6
7
8
9
10
                  1
                1   1
              1   2   1
            1   3   3   1
          1   4   6   4   1
        1   5  10  10   5   1
      1   6  15  20  15   6   1
    1   7  21  35  35  21   7   1
  1   8  28  56  70  56  28   8   1
1   9  36  84 126 126  84  36   9   1

写在最后

  以上就是关于用C语言实现等腰杨辉三角的全部内容。如果有什么更好的想法，欢迎大家留言讨论。
  我的邮箱：1398635912@qq.com
  参考资料：百度百科【杨辉三角】(链接：link)

用Python实现四种简单的排序算法

2019-11-08

排序算法概述

  所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。
  在算法中，排序算法分为冒泡排序，选择排序，插入排序，快速排序，归并排序，希尔排序，基数排序，堆排序，计数排序，桶排序等。接下来，我们从最简单的冒泡排序说起。

冒泡排序

  冒泡排序(Bubble sort)重复地走访过要排序的元素列，依次比较两个相邻的元素。如果顺序错误，就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），故名“冒泡排序”。
  冒泡排序的平均时间复杂度为O(n^2^)。它是一种稳定排序算法。
Alt
  下面我们用Python来实现这个算法（注：我使用的版本为Python 3.7.4，下同）。我编写的是降序排列，代码实现如下： 

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
# 冒泡排序
nums = []

print('冒泡排序（降序排序）')
while True:
    print('请输入你想排列的数字个数：')
    try:
        x = int(input())
        for i in range(x):
            a = int(input('请输入第' + str(i + 1) + '个整数：'))
            nums.append(a)
    except ValueError:
        print('输入错误，请重新输入：')

    for j in range(len(nums) - 1):
        for k in range(len(nums) - j - 1):
            if nums[k] < nums[k + 1]:
                nums[k], nums[k + 1] = nums[k + 1], nums[k]
    print(nums)

    jud = input('您是否想要继续？(Y/N)')
    while jud != 'Y' and jud != 'N':
        jud = input('输入错误，请重新输入：')
    if jud == 'Y':
        nums.clear()
        continue
    else:
        print('再见！')
        break

选择排序

  选择排序(Selection sort)第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（或最大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。我们在这里讨论直接选择排序。
  选择排序的平均时间复杂度为O(n^2^)，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。与冒泡排序不同，选择排序是一种不稳定排序算法。
Alt  下面我们用Python来实现这个算法。升序排列代码如下： 

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
# 选择排序
nums = []

print('选择排序（升序排序）')
while True:
    print('请输入你想排列的数字个数：')
    try:
        x = int(input())
        for i in range(x):
            a = int(input('请输入第' + str(i + 1) + '个整数：'))
            nums.append(a)
    except ValueError:
        print('输入错误，请重新输入：')

    for j in range(len(nums)):
        mini = j
        for k in range(j + 1, len(nums)):
            if nums[mini] > nums[k]:
                mini = k
        nums[mini], nums[j] = nums[j], nums[mini]
    print(nums)

    jud = input('您是否想要继续？(Y/N)')
    while jud != 'Y' and jud != 'N':
        jud = input('输入错误，请重新输入：')
    if jud == 'Y':
        nums.clear()
        continue
    else:
        print('再见！')
        break

插入排序

  插入排序(Insertion sort)的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加1的有序数据。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这种算法适用于少量数据的排序。我们在这里讨论直接插入排序。
  插入排序的平均时间复杂度为O(n^2^)。它也是一种稳定排序算法。
Alt  用Python实现升序插入排序如下： 

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
# 插入排序
nums = []

print('插入排序（升序排序）')
while True:
    print('请输入你想排列的数字个数：')
    try:
        x = int(input())
        for i in range(x):
            a = int(input('请输入第' + str(i + 1) + '个整数：'))
            nums.append(a)
    except ValueError:
        print('输入错误，请重新输入：')

    for i in range(1, len(nums)):
        for j in range(i, 0, -1):
            if nums[j] < nums[j - 1]:
                nums[j], nums[j - 1] = nums[j - 1], nums[j]
            else:
                break
    print(nums)

    jud = input('您是否想要继续？(Y/N)')
    while jud != 'Y' and jud != 'N':
        jud = input('输入错误，请重新输入：')
    if jud == 'Y':
        nums.clear()
        continue
    else:
        print('再见！')
        break

快速排序

  快速排序(Quick sort)是对冒泡排序的一种改进。它选择（或设立）一个分界值，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比分界值大，另一部分的所有数据都比分界值小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。它的核心思想是“分治+递归”。
  快速排序的平均时间复杂度为O(nlog2n)。它是一种不稳定排序算法。
Alt  我们用Python来实现升序快速排序，代码如下： 

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
# 快速排序
from typing import List

nums: List[int] = []
print('快速排序（升序排序）')


def quick_sort(data):
    if len(data) >= 2:
        mid = data[len(data) // 2]
        left = []
        right = []
        data.remove(mid)
        for num in data:
            if num >= mid:
                right.append(num)
            else:
                left.append(num)
        return quick_sort(left) + [mid] + quick_sort(right)
    else:
        return data


while True:
    print('请输入你想排列的数字个数：')
    try:
        x = int(input())
        for i in range(x):
            a = int(input('请输入第' + str(i + 1) + '个整数：'))
            nums.append(a)
    except ValueError:
        print('输入错误，请重新输入：')

    print(quick_sort(nums))

    jud = input('您是否想要继续？(Y/N)')
    while jud != 'Y' and jud != 'N':
        jud = input('输入错误，请重新输入：')
    if jud == 'Y':
        nums.clear()
        continue
    else:
        print('再见！')
        break

写在最后

  在第一次听说排序算法的时候，“算法”这两个字于我而言像是难以企及的高度。我觉得它离我很遥远，无论是从学习进度上来说还是从难度上来说。想要去接触并了解几种简单的排序算法这一想法，萌生于昨天的Python程序设计基础课。老师先是让我们对两个数进行排序，接着是三个数、四个数……一次一次地编写程序太麻烦、太枯燥，也太低效了。我知道运用Python的列表包含的sort()方法可以直接把一堆数字进行升降序排列，那么，用排序算法的话又该如何去写呢？这对我来说，无疑是一个新的挑战。而挑战，往往是最有乐趣的。
  经过在网上查阅大量资料之后，我对这四种简单的排序算法有了新的认识，并且成功用Python实现。虽然耗时较长，但我觉得这是非常有意义的。另外，在查阅资料的过程中，我也了解到了每个基本的排序算法都会有自己的优化方法。学无止境，我在接下来的学习中还要再深入学习其他排序算法以及算法的优化。
  如果有什么好的想法，欢迎在下方评论留言，也可以通过发电子邮件的方式与我联系，共同讨论，共同进步。
  我的邮箱：1398635912@qq.com

增强程序可用性——关于程序的用户错误输入的处理

2019-11-05

前言

  今天的计导课上，老师让我上台完成他上一次布置的作业——用Python判断一个三位数是否为水仙花数。这道题目其实非常简单，用Python 3.6实现如下： 

1
2
3
4
5
6
7
8
num = int(input('请输入一个三位数：'))
a = num // 100          #百位
b = num // 10 % 10      #十位
c = num % 10            #个位
if(num == pow(a,3) + pow(b,3) + pow(c,3)):
    print("%d是水仙花数" %num)
else:
    print("%d不是水仙花数" %num)

  下面给出两组输出样例： 

1
2
请输入一个三位数：123
123不是水仙花数
1
2
请输入一个三位数：153
153是水仙花数

  当我以为这道题就这么讲完了的时候，老师突然提出了一个新的问题：当用户输入的不是一个三位数的话该怎么处理呢？确实，如果想要编写出一个可用性较强的程序，我们必须要创建一个更友好的用户界面。这样的界面会使交互式的数据输入更轻松，并且减轻了用户错误输入的影响。

初步实现

  老师又叫了一个同学上去修改这个程序。这个同学修改后的程序如下： 

1
2
3
4
5
6
7
8
9
10
11
num = int(input('请输入一个三位数：'))
if not(num in range(100,1000)):
    print('输入错误！')
else:
    a = num // 100          #百位
    b = num // 10 % 10      #十位
    c = num % 10            #个位
    if(num == pow(a,3) + pow(b,3) + pow(c,3)):
        print("%d是水仙花数" %num)
    else:
        print("%d不是水仙花数" %num)

  下面给出一组输入错误的输出样例： 

1
2
请输入一个三位数：1234
输入错误！

  这样修改程序之后确实达到了老师的要求——提示用户输入错误。课堂上关于这一问题的讨论也就到此为止。然而，不可否认的是，修改过后的程序虽然加强了容错性，但它仍旧是个可用性不强的程序。这体现在两个方面：第一，程序只可以进行一次水仙花数的判断，用户想要再一次进行判断的话需要重新Run Module；第二，假使用户不慎输入错误，没有输入一个三位数，那么程序也会就此结束，不会给用户重新输入的机会。针对这两点问题，我们又该如何改进呢？

改进——创建更为友好的用户界面

  对于上面所说的第一个问题，我们可以给程序加上一个while True:的无限循环。想要终止这个程序的话，我们只需要按Ctrl+C键。当然，更好的做法是在程序的最后加上一个if判断语句：如果用户输入“Y”的话，程序会继续下一次的运行；如果用户输入“N”的话，程序结束运行。
  第二个问题又该如何解决呢？我在第一时间想到的是while循环，如果用户输入错误的话，程序执行while循环，并给用户重新输入的机会。不过，由于刚开始有些大脑短路，我并没有将这一想法用代码来实现，实在是有点蠢……
  最终用Python 3.6实现如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
while True:
    num = int(input('请输入一个三位数：'))
    while(num not in range(100,1000)):
        num = int(input('输入错误，请重新输入：'))
    a = num // 100          #百位
    b = num // 10 % 10      #十位
    c = num % 10            #个位
    if(num == pow(a,3) + pow(b,3) + pow(c,3)):
        print("%d是水仙花数" %num)
    else:
        print("%d不是水仙花数" %num)
    j = input('您是否想要继续？(Y/N)')
    while(j != 'Y' and j != 'N'):
        j = input('输入错误，请重新输入：')
    if(j == 'Y'):
        continue
    else:
        print('再见！')
        break

  下面给出一组详细的输出样例： 

1
2
3
4
5
6
7
8
9
10
11
12
请输入一个三位数：1234
输入错误，请重新输入：123
123不是水仙花数
您是否想要继续？(Y/N)Y
请输入一个三位数：153
153是水仙花数
您是否想要继续？(Y/N)Y
请输入一个三位数：100
100不是水仙花数
您是否想要继续？(Y/N)M
输入错误，请重新输入：N
再见！

  显然，这样改进之后，我们用代码成功地实现了“创建更为友好的用户界面”的想法。

写在最后

  有这样一句话：程序的核心部分往往只占20%，其余的80%都是为了增强它的容错性和可用性。我们学习编程也有一段时间了，在设计程序的时候，我们又是否考虑过程序的可用性呢？我想，大部分人应该都不会去想这个问题，或者是想到了这个问题却又没有用代码来实现。从今天开始，我们是不是应该要思考一下，如何让自己的程序对使用者更为友好呢？
  如果有什么想法的话，欢迎联系我，我期待着你们的留言！
  我的邮箱：1398635912@qq.com

C语言、Python与金字塔图形

2019-11-02

前言

  昨天在和朋友看电影的时候，一个在南开大学就读的高中同学给我发来这样一道题目：

  输出一个大小为n的金字塔，金字塔是一个等腰三角形，大小为n的金字塔底层有n个*，每一层*的个数都是下一层的个数减2，第一层的*在最中央。因为这个问题太简单了，所以要求金字塔的顶可以朝上下左右四个方向。

  当时正是电影最为精彩的部分，所以我并没有对这道题太过在意。我只是大致看了一下，然后回复同学说“我现在在看电影”就退出了QQ的聊天框。到了晚上，我突然想起了还有这么一道题，也突然觉得这道题可以让我的无聊的晚上变得有趣起来。高中同学发来这道题的时候说要用C++编写程序，但是我对C++一无所知。最后，我还是决定试一下，用C语言和Python来完成这道题目。

初步的想法

  在离开实验室走回宿舍的路上，我一直在思考这道题该如何去完成。我想起了之前在刷Python编程练习100例的时候写过的类似的一个程序，使用Python 3.6编写如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from sys import stdout

for i in range(4):
    for j in range(2 - i + 1):
        stdout.write(' ')
    for k in range(2 * i + 1):
        stdout.write('*')
    print()

for i in range(3):
    for j in range(i + 1):
        stdout.write(' ')
    for k in range(4 - 2 * i + 1):
        stdout.write('*')
    print()

  输出结果如下： 

1
2
3
4
5
6
7
   *
  ***
 *****
*******
 *****
  ***
   *

  当时写这个编程练习的时候，我的想法是先把图形分成前4行和后3行两部分来看，它们分别有不同的规律，可以利用for循环的嵌套，第1层控制行，第2层控制列，实现金字塔图形的输出。这样看来，同学问我的那道题，只不过是这道题的“进阶版”。
  题目中要求用户键入w/a/s/d来输出不同塔尖方向的金字塔。对于这一点，我们可以把w/a/s/d四个方向分成四部分，使用if-else if-else语句（或者在C语言中使用switch语句，Python没有switch语句）分类讨论。

用C语言实现

  如果觉得金字塔的规律不容易找出来，我们不妨找一张草稿纸，在纸上画一画。这里省略掉找规律的过程。程序源代码如下： 

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
#include <stdio.h>
#include <stdlib.h>
int main (void)
{
	int num, i, j, h; 
	char direction; 
	printf ("请输入塔底长度和塔尖方向(w/a/s/d)，使用空格分隔开："); 
	scanf ("%d %c", &num, &direction); 
	h = (num + 1) / 2; 
	switch (direction)
	{
		case 'w':
			for (i = 1; i <= h; i++)
			{
				for (j = 1; j <= num; j++)
				{
					if (j > h - i && j < h + i)
					    printf ("%c", '*'); 
					else
					    printf (" "); 
				}
				printf ("\n"); 
			}
			break;  
		case 'a':
			for (i = 1; i <= num; i++)
			{
				for (j = 1; j <= h; j++)
				{
					if (j > h - i && j > i - h)
					    printf ("%c", '*'); 
					else
					    printf (" "); 
				}
				printf ("\n"); 
			}
			break; 
		case 's':
			for (i = 1; i <= h; i++)
			{
				for (j = 1; j <= num; j++)
				{
					if (j >= i && j <= num - i + 1)
					    printf ("%c", '*'); 
					else
					    printf (" "); 
				}
				printf ("\n"); 
			}
			break; 
		case 'd':
			for (i = 1; i <= num; i++)
			{
				for (j = 1; j <= h; j++)
				{
					if (j <= i && j <= 2 * h - i)
					    printf ("%c", '*'); 
					else
					    printf (" "); 
				}
				printf ("\n"); 
			}
			break; 
		default:
			printf ("Error! \n"); 
	}
	system ("pause"); 
	return 0; 
}

  下面给出几组输出样例： 

1
2
3
4
5
6
7
请输入塔底长度和塔尖方向(w/a/s/d)，使用空格分隔开：11 w
     *
    ***
   *****
  *******
 *********
***********
1
2
3
4
5
6
7
8
9
10
请输入塔底长度和塔尖方向(w/a/s/d)，使用空格分隔开：9 a
    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *
1
2
3
4
5
6
7
8
请输入塔底长度和塔尖方向(w/a/s/d)，使用空格分隔开：13 s
*************
 ***********
  *********
   *******
    *****
     ***
      *
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
请输入塔底长度和塔尖方向(w/a/s/d)，使用空格分隔开：17 d
*
**
***
****
*****
******
*******
********
*********
********
*******
******
*****
****
***
**
*

用Python 3.6实现

  在用Python来编写的时候，我从sys库中导入了stdout方法。在Python中，sys.stdout是一个文件对象，它对应解释器的标准输出流。此外，在Python中，文件对象sys.stdin和sys.stderr分别对应解释器的标准输入流和标准出错流。在此不再赘述，如果感兴趣的话可以自行查阅资料了解。
  使用Python 3.6编写的程序源代码如下： 

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
from sys import stdout

num = int(input('请输入金字塔塔底长度：'))
direction = input('请输入金字塔塔尖方向(w/a/s/d)：')
h = (num + 1) // 2

if(direction == 'w'):
    for i in range(1,h + 1):
        for j in range(1,num + 1):
            if((j > h - i) and (j < h + i)):
                stdout.write('*')
            else:
                stdout.write(' ')
        stdout.write('\n')
        
elif(direction == 'a'):
    for i in range(1,num + 1):
        for j in range(1,h + 1):
            if((j > h - i) and (j > i - h)):
                stdout.write('*')
            else:
                stdout.write(' ')
        stdout.write('\n')
        
elif(direction == 's'):
    for i in range(1,h + 1):
        for j in range(1,num + 1):
            if((j >= i) and (j <= num - i + 1)):
                stdout.write('*')
            else:
                stdout.write(' ')
        stdout.write('\n')

elif(direction == 'd'):
    for i in range(1,num + 1):
        for j in range(1,h + 1):
            if((j <= i) and (j <= 2 * h - i)):
                stdout.write('*')
            else:
                stdout.write(' ')
        stdout.write('\n')

else:
    print('Error! ')

  由于Python程序的输出结果与上面的C程序的输出结果相似，下面只给出一组输出样例： 

1
2
3
4
5
6
7
8
9
请输入金字塔塔底长度：7
请输入金字塔塔尖方向(w/a/s/d)：a
   *
  **
 ***
****
 ***
  **
   *

写在最后

  以上就是我对于金字塔图形这个经典编程练习的一些想法。输出金字塔图形的编程方法不唯一，欢迎与我进行交流。
  我的邮箱：1398635912@qq.com

用Python输出自幂数

2019-11-02

自幂数是什么

  自幂数是指一个n位数，它的每个位上的数字的n次幂之和等于它本身。例如：当n为3时，153即是n为3时的一个自幂数。
  自幂数包括独身数、水仙花数、四叶玫瑰数、五角星数、六合数、北斗七星数、八仙数、九九重阳数、十全十美数等。

从水仙花数说起

  今天的计导课上，老师布置了一项作业：用Python输出所有的水仙花数。水仙花数即为当n=3时的自幂数。用Python 3.6编写代码如下： 

1
2
3
4
5
6
7
for num in range(100,1000):
    i = num % 10                     #个位
    k = int(num / 100)               #百位
    j = int((num - k * 100) / 10)    #十位
    sum = i ** 3 + j ** 3 + k ** 3
    if(num == sum):
        print('%d' %num)

  它的思路是将三位数的个位、十位、百位分解，然后分别用个位、十位、百位的三次方作和，判断所求的和与原来的三位数是否相等，如果相等即为水仙花数。
  另一种解法如下所示：

1
2
3
4
5
6
7
for i in range(100,1000):
    num = str(i)
    sum = 0
    for j in num:
        sum = sum + int(j)**3
    if(sum == i):
        print(i)

从水仙花数到其他自幂数

  通过上面所说的思路，我们可以用Python写出四叶玫瑰数、五角星数等其他自幂数。
  下面是用Python 3.6编写的四叶玫瑰数程序： 

1
2
3
4
5
6
7
8
for num in range(1000,10000):
    i = num % 10                             #个位
    l = num // 1000                          #千位
    k = (num % 1000) // 100                  #百位
    j = (num % 100) // 10                    #十位
    sum = pow(i,4) + pow(j,4) + pow(k,4) + pow (l,4)
    if(num == sum):
        print(num)

  接下来是用Python 3.6编写的五角星数程序： 

1
2
3
4
5
6
7
8
9
for num in range(10000,100000):
    a = num // 10000            #万位
    b = (num % 10000) // 1000   #千位
    c = (num % 1000) // 100     #百位
    d = (num % 100) // 10       #十位
    e = num % 10                #个位
    sum = pow(a,5) + pow(b,5) + pow(c,5) + pow(d,5) + pow(e,5)
    if(num == sum):
        print(num)

  如果你愿意的话，还可以试着用这种思路编写六合数、北斗七星数……十全十美数。

可以输出你想要的自幂数的终极版本

  当我把我写好的程序发到课堂的交流群的时候，一个同学问我：“能用一个程序把所有的自幂数输出出来吗？”答案是肯定的。
  考虑到自幂数实在太多，我的想法是，首先让用户键入想要的自幂数的位数，然后使用if条件语句和for循环语句达到想要的结果。
  用Python编写的最终版本如下： 

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
import math
while True:
    n=int(input("请输入自幂数位数：\n"))
    if(n == 1):
        print("独身数:")
        print("0\t")
    elif(n == 2):
        print("两位自幂数:")
        print("没有自幂数！")
    elif(n == 3):
        print("水仙花数:")
    elif(n == 4):
        print("四叶玫瑰数:")
    elif(n == 5):
        print("五角星数:")
    elif(n == 6):
        print("六合数:")
    elif(n == 7):
        print("北斗七星数:")
    elif(n == 8):
        print("八仙数:")
    elif(n == 9):
        print("九九重阳数:")
    elif(n == 10):
        print("十全十美数:")
    else:
        print("其它自幂数:")
    for i in range(int(math.pow(10,n-1)),int(math.pow(10,n))):
        num = 0
        for j in str(i):
            num += int(math.pow(int(j),n))
        if(i == num):
            print(i)

写在最后

  以上就是用Python输出自幂数的全部内容了。写这个程序的思路不唯一，我只是用我认为最简单易懂的方法写出了这个程序。我也相信肯定有更为简便的方法来实现它。如果你有不同的思路，欢迎联系我，我非常期待你们的来信！
  我的邮箱：1398635912@qq.com

使用Hexo+Github搭建属于自己的博客

2019-10-31

前言

前几天，我尝试用Hexo+Github搭建了属于我自己的博客。几经波折，当最后我成功搭建之后，喜悦感、成就感、自豪感油然而生。接下来我给大家分享一下搭建博客的经验。
我的电脑系统为Windows 10家庭中文版，系统类型为64位操作系统，基于x64的处理器。

相关步骤

Step 1：安装Node.js和配置Node.js环境

我们进入Node.js的官网，下载这个12.13.0版本的Node.js并安装它。
安装好之后，我们来检测一下PATH环境变量是否配置了Node.js。
打开cmd，输入命令path之后，输出了如下结果：
avatar
可以看出，环境变量中已经包含了D:\nodejs。
打开cmd，输入命令node -v和npm -v，我们可以看到版本号。这说明我们已经安装成功了。

Step 2：安装Git和配置Git环境

我们进入Git官网，下载最新的Git 2.23.0版本。
进入安装向导，选择安装位置之后，安装向导会让我们选择组件。在这里我选择的是Additional icons、Windows Explorer integration、Git LFS(Large File Support)、Associate .git\ configuration files with the default text editor以及Associate .sh files to be run with Bash*。接下来，一路Next之后，点击Install，我们成功安装好了Git。
这里不得不提的是，我们如何判断自己是否安装成功了呢？其实，安装成功之后有一个典型的象征，就是在电脑上任何位置单击鼠标右键之后，都能够出现这两个选项：Git GUI Here和Git Bash Here。不妨动手试一试，一旦出现上述两个选项，恭喜你，你已经成功安装了Git。

Step 3：Github账户注册和新建Repository

这个没什么好说的。只有一点需要注意：
在新建Repository的时候，Repository name必须遵守账户名.github.io的格式，否则接下来很可能会出现棘手的问题。我们还需要勾选下方的“Initialize this repository with a README”。

Step 4：安装Hexo

首先，你需要在自己认为合适的地方新建一个文件夹。我是在D盘新建了一个名为blog的文件夹。接下来，在cmd中进入该文件夹。
1.输入npm install hexo -g，开始安装Hexo。
2.在安装好之后，输入hexo -v，如果出现了一串版本号，说明Hexo已经安装成功了。
3.输入hexo init，初始化该文件夹。需要说明的是，这一步所花费的时间可能会有些长，保持耐心。
4.当看到Start blogging with Hexo!的时候，你距离成功完成这一个Step已经很近了。输入npm install，安装所需组件。
5.输入hexo g，开始你的首次体验吧！
6.输入hexo s，开启服务器，访问该网址。有些电脑可能会遇到这样一个问题：在访问网址的时候，页面一直无法跳转。这可能是因为端口被占用了。遇到这种问题该怎么办呢？我们按Ctrl+C键停止服务器。【注意！！！这里的Ctrl+C并不是复制的意思！！！】接着，我们输入hexo server -p 端口号来改变端口号。试着访问一下这个新的网址吧！

Step 5：将Hexo和Github联系起来

1.如果是第一次的话，我们需要先设置Git的user name和user email。 单击右键，选择“Git Bash Here”。输入git config --global user.name "用户名"来设置user name。输入git config --global user.email "邮箱号"来设置user email。
2.输入cd ~/.ssh，检查是否有.ssh文件夹。这里我要偷偷说一句，其实没有也没什么关系的。
3.输入ls，列出该文件下的内容。
4.输入ssh-keygen -t rsa -C "邮箱号"，连按三次Enter键，生成密钥。最后我们得到了id_rsa和id_rsa.pub两个文件。
5.输入eval "$(ssh-agent -s)"，添加密钥到ssh-agent。
6.输入ssh-add ~/.ssh/id_rsa，添加生成的SSH key到ssh-agent。
7.登录Github，在头像下找到Settings，添加SSH。我们点击“New SSH key”，新建一个SSH key。在“Title”栏写blog，“Key”栏中将id_rsa.pub里面的内容复制粘贴上去。【id_rsa.pub文件的存储路径为C:\Users\Administrator\.ssh，右键选择打开方式，选择用记事本打开即可。】
8.输入ssh -T git@github.com，测试是否成功添加了SSH。如果你看到了“Hi 用户名! ”，那么恭喜你，你已经成功将Hexo和Github联系起来了！

Step 6：配置Deployment

在blog文件夹中，我们找到_config.yml文件，在末尾修改Repository值。Repository值是Github的Repository中的SSH。我们该如何找到它呢？在Repository右侧有一个绿色的框框，里面写着“Clone or download”，单击，再点击“Use SSH”就可以了。怎么样，很简单吧？

Step 7：新建一篇博客，生成并部署文章

打开cmd，输入hexo new post "Hello Hexo"，我们可以看到，这时候在D:\blog\source\_posts目录下已经创建了Hello-Hexo.md文件。
在生成并部署文章之前，我们还需要在cmd中输入npm install hexo-deployer-git --save，安装一个扩展。
使用编辑器编辑好文章之后，在cmd中输入hexo d -g，生成并部署文章。部署成功后访问http://用户名.github.io，我们就能看到我们写的文章了！

写在最后

看完这篇教程之后，你是不是也觉得使用Hexo+Github搭建属于自己的博客是一件很容易的事情呢？赶快动手试一试吧！
第一次写博客，如果有什么意见和建议想对我这个小白提的话，请联系我哟！
我的邮箱：1398635912@qq.com

如何用C语言和Python编写一个BMI指数计算器

2019-10-31

写在前面

  前些日子在学习C语言和Python的循环语句的时候，我心血来潮，想编写一个实用性较高的程序。想来想去，我决定编写一个BMI指数计算器。接下来，我将分享一下我编写这个程序的过程，希望给大家带来一些启发。

BMI指数计算器1.0

  首先，我们先来编写BMI指数计算器的核心部分。我们对这个程序进行分析，可以知道这个程序需要用户输入自己的身高(m)和体重(kg)值，再用体重除以身高的平方计算出BMI，最后使用printf()将其打印输出。话不多说，我们现在就开始吧。
  首先我们使用Python 3.6来编写它： 

1
2
3
4
5
6
7
8
9
10
11
12
13
print('**********BMI指数计算器**********')  
weight = float(input('Please input your weight by kilograms: '))  
height = float(input('Please input your height by metres: '))  
BMI = weight / (height**2)  
print('Your BMI is %.1f. ' %BMI)  
if(BMI < 18.5):  
    print('偏轻')  
elif(BMI <= 23.9 and BMI >= 18.5):  
    print('正常')  
elif(BMI >=24 and BMI <= 27.9):  
    print('超重')  
elif(BMI >= 28):  
    print('肥胖')

  使用C语言编写它： 

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
#include <stdio.h>
int main (void)
{
	printf ("********************BMI指数计算器********************\n"); 
	float weight, height, BMI; 
	char a[0]; 
	printf ("Please input your weight by kilograms: "); 
	scanf ("%f", &weight); 
	printf ("Please input your height by metres: "); 
	scanf ("%f", &height); 
	BMI = weight / (height * height); 
	printf ("Your BMI is %.1f. \n", BMI); 
	if (BMI < 18.5)
	{
	    printf ("偏轻\n"); 
	}
	else if (BMI >= 18.5 && BMI <= 23.9)
	{
	    printf ("正常\n"); 
	}
	else if (BMI >= 24 && BMI <=27.9)
    {
	    printf ("超重\n"); 
    }
    else if (BMI >= 28)
    {
	    printf ("肥胖\n"); 
    }
    return 0; 
}

改进——BMI指数计算器2.0

  我们不难发现，在运行这个程序的时候，程序在计算一次之后就会结束运行。结束一次计算之后倘若还想继续新一次计算，我们需要再重新运行它。这在实际应用的时候是没有可操作性的。针对这个问题，我们来进行一次改进。
  相信大多数人会想到while循环语句，我们不妨试一试。
  下面是用Python 3.6编写的改进版程序。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print('**********BMI指数计算器**********')  
while True:  
    weight = float(input('Please input your weight by kilograms: '))  
    height = float(input('Please input your height by metres: '))  
    BMI = weight / (height**2)  
    print('Your BMI is %.1f. ' %BMI)  
    if(BMI < 18.5):  
        print('偏轻')  
    elif(BMI <= 23.9 and BMI >= 18.5):  
        print('正常')  
    elif(BMI >=24 and BMI <= 27.9):  
        print('超重')  
    elif(BMI >= 28):  
        print('肥胖')

  我们用C语言也同样可以实现。 

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
#include <stdio.h>
int main (void)
{
	printf ("********************BMI指数计算器********************\n"); 
	while (1)
	{ 
	    float weight, height, BMI; 
	    printf ("Please input your weight by kilograms: "); 
	    scanf ("%f", &weight); 
	    printf ("Please input your height by metres: "); 
	    scanf ("%f", &height); 
	    BMI = weight / (height * height); 
	    printf ("Your BMI is %.1f. \n", BMI); 
	    if (BMI < 18.5)
	    {
		    printf ("偏轻\n"); 
	    }
	    else if (BMI >= 18.5 && BMI <= 23.9)
	    {
		    printf ("正常\n"); 
	    }
	    else if (BMI >= 24 && BMI <=27.9)
	    {
		    printf ("超重\n"); 
	    }
	    else if (BMI >= 28)
	    {
		    printf ("肥胖\n"); 
	    }
	}
	return 0; 
}

新的问题与解决方案

  改进版的程序解决了上面提出的只能进行一次计算的问题，这很好。但新的问题又出现了——这个循环会一直进行下去。当我们想要结束计算的时候，我们没有可以退出程序的方法（除非我们强制关闭这个程序）。这又该怎么办呢？
  我想到的解决方案是在C程序中使用if语句。一次计算结束后，我们可以用printf()来输出“是否要继续”的字样。在用户键入“Y”之后，程序会执行continue继续下一次运行；相反地，如果键入的是“N”，程序执行break退出循环。当然了，我们还要考虑到用户不小心按错“Y”或者“N”的情况。
  改进Python程序的思路和改进C程序的思路类似。

再一次改进——BMI指数计算器3.0

  既然有了想法，让我们动手做起来，写出完美无缺的程序吧！
  我们先对Python程序进行改进，使它成为完美的最终版本。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
print('**********BMI指数计算器**********')
while True:
    weight = float(input('Please input your weight by kilograms: '))
    height = float(input('Please input your height by metres: '))
    BMI = weight / (height**2)
    print('Your BMI is %.1f. ' %BMI)
    if(BMI < 18.5):
        print('偏轻')
    elif(BMI <= 23.9 and BMI >= 18.5):
        print('正常')
    elif(BMI >=24 and BMI <= 27.9):
        print('超重')
    elif(BMI >= 28):
        print('肥胖')
    a = input('是否要继续？(Y/N)')
    if(a == 'Y'):
        continue
    elif(a == 'N'):
        break
    else:
        print('Error! \n')
        break

  下面是C语言编写的BMI指数计算器3.0最终版。 

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
#include <stdio.h>
int main (void)
{
	printf ("********************BMI指数计算器********************\n"); 
	while (1)
	{ 
	    float weight, height, BMI; 
	    char a[0]; 
	    printf ("Please input your weight by kilograms: "); 
	    scanf ("%f", &weight); 
	    printf ("Please input your height by metres: "); 
	    scanf ("%f", &height); 
	    BMI = weight / (height * height); 
	    printf ("Your BMI is %.1f. \n", BMI); 
	    if (BMI < 18.5)
	    {
		    printf ("偏轻\n"); 
	    }
	    else if (BMI >= 18.5 && BMI <= 23.9)
	    {
		    printf ("正常\n"); 
	    }
	    else if (BMI >= 24 && BMI <=27.9)
	    {
		    printf ("超重\n"); 
	    }
	    else if (BMI >= 28)
	    {
		    printf ("肥胖\n"); 
	    }
	    printf ("是否要继续？(Y/N)"); 
	    scanf ("%s", a); 
	    if (a[0] == 'Y')
		    continue; 
	    else if (a[0] == 'N')
		    break; 
		else
	    {
	    	printf ("Error! \n"); 
		}
		    break; 
	}
	return 0; 
}

写在最后

  希望我的这篇文章可以给大家带来一些启发。如果文章有一些错误，或者是有什么意见和建议的话，欢迎联系我。大家一起学习，共同进步！
  我的邮箱：1398635912@qq.com

Hello World

2019-10-28

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment