Python函数与类

Posted on Edited on In Views:
Symbols count in article: 12k Reading time ≈ 11 mins.
Python函数式编程与面对对象编程。

[TOC]

Python函数与类

例子

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
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
#!/usr/bin/env python3
#-*- coding:utf-8 -*-
__author__ = 'QCF'

import os
import platform
import itertools
import time

def main():
    '''主程序'''
    global RawList # 原始数据列表
    RawList = []
    global DenyList # 非法字符列表
    DenyList = [' ','','@']
    global LastList # 最终密码列表
    LastList = []
    global MinLen # 密码最小长度
    MinLen = 6
    global MaxLen # 密码最大长度
    MaxLen = 16
    global Timeout
    Timeout = 3
    global Flag
    Flag = 0
    RunDictionary = {
'0':Exit,
'1':GetRawList,
'2':AddDenyList,
'3':ClearRawList,
'4':SetRawList,
'5':ModifyPasswordLen,
'6':CreatePasswordList,
'7':ShowPassword,
'8':CreatePasswordFile
}

    while True:
        MainMenu()
        op = input('输入选项：')
        if op in map(str,range(len(RunDictionary))):
            RunDictionary.get(op)()
        else:
            TipMainMenuInputError()
            continue

def MainMenu():
    '''主菜单'''
    global RawList
    global DenyList
    global LastList
    global Flag
    Clear() # 清屏
    print('||')
    print('=' * 40)
    print('||')
    print('|| 0：退出程序')
    print('|| 1：输入原始密码列表')
    print('|| 2：添加非法字符到列表')
    print('|| 3：清空原始密码列表')
    print('|| 4：设置原始密码列表')
    print('|| 5：改变默认密码长度({:d}-{:d})'.format(MinLen, MaxLen))
    print('|| 6：创建密码列表')
    print('|| 7：显示所有密码')
    print('|| 8：创建密码字典文件')
    print('||')
    print('=' * 40)
    print('||')
    print('当前非法字符列表为：{}'.format(DenyList))
    print('当前原始密码元素为：{}'.format(RawList))
    print('共有密码{:d}个'.format(len(LastList)))
    
    if Flag:
        print('已在当前目录创建密码字典文件dic.txt')
    else:
        print('未创建密码字典文件')

def Clear():
    '''清屏函数'''
    OS = platform.system() # 获取系统信息
    if (OS == u'Windiws'): # 表示已Unicode字符串储存，避免控制台与python编码不同造成问题
        os.system('cls') # Windows下清屏命令为'cls'
    else:
        os.system('clear') # Linux下清屏命令为'clear'

def TipMainMenuInputError():
    '''错误提示'''
    Clear()
    print('只能输入0-7的整数，等待{:d}s后重新输入。'.format(Timeout))
    time.sleep(Timeout)

def Exit():
    exit()

def GetRawList():
    '''获取原始密码列表'''
    Clear()
    global DenyList
    global RawList
    print('输入回车后直接退出')
    print('当前原始密码列表为：{}'.format(RawList))
    st = None
    while not st == '':
        st = input('请输入密码元素字符串：')
        if st in DenyList:
            print('这个字符串是预先设定的非法字符串')
            continue
        else:
            RawList.append(st)
            Clear()
            print('输入回车后直接退出')
            print('当前原始密码列表为：{}'.format(RawList))

def AddDenyList():
    '''添加非法字符串'''
    Clear()
    global DenyList
    print('输入回车后直接退出')
    print('当前非法字符为：{}'.format(DenyList))
    st = None
    while not (st == ''):
        st = input('请输入需要添加的非法字符串：')
        DenyList.append(st)
        Clear()
        print('输入回车后直接退出')
        print('当前非法字符串列表为：{}'.format(DenyList))

def ClearRawList():
    '''清空原始密码列表'''
    global RawList
    RawList = []

def SetRawList():
    '''设置原始密码列表'''
    global RawList
    global DenyList
    a = set(RawList)
    b = set(DenyList)
    RawList = []
    for str in set(a - b):
        RawList.append(str)

def ModifyPasswordLen():
    '''修改默认密码长度'''
    Clear()
    global MinLen
    global MaxLen
    while True:
        print("当前密码长度为{:d},{:d}".format(MinLen, MaxLen))
        min = input("请输入密码最小长度：")
        max = input("请输入密码最大长度：")
        try:
            MinLen = int(min)
            MaxLen = int(max)
        except ValueErrir:
            print("密码长度只能输入整数6-18")
            break
        if (MinLen not in range(6,19)) or (MaxLen not in range(6,19)):
            print("密码长度只能输入整数6-18")
            MinLen = 6
            MaxLen = 16
            continue
        if MinLen == MaxLen:
            res = input("确定将密码长度限定为{:d}吗？（Y/N）".format(MinLen))
            if res not in list('YyNn'):
                print("输入错误，请重新输入！")
                continue
            elif res in list('Yy'):
                print("已将密码长度限定为{:d}".format(MinLen))
                break
            else:
                pass
        elif MinLen > MaxLen:
            res = input("密码最小最大长度输入错误,是否交换最小最大长度？（Y/N）")
            if res not in list('YyNn'):
                print("输入错误，请重新输入！")
                continue
            elif res in list('Yy'):
                temp = MinLen
                MinLen = MaxLen
                Maxlen = temp
                print("密码长度为：({:d}-{:d})".format(MinLen, MaxLen))
            else:
                print("密码最小最大长度输入错误，请重新输入！")
        else:
            print("设置完毕，等待{:d}s后返回菜单。".format(Timeout))
            time.sleep(Timeout)
            break

def CreatePasswordList():
    '''创建密码列表'''
    global RawList
    global LastList
    global MaxLen
    global MinLen
    titleList = []
    swapcaseList = []
    for st in RawList:
        swapcaseList.append(st.swapcase()) # 字符串大小写转换
        titleList.append(st.title()) # 标题化字符串（大写开头）

    sub1 = [] # Raw + title + swapcase
    sub2 = [] # sub1全排列列表
    for st in set(RawList + titleList + swapcaseList): # 生成全元素列表
        sub1.append(st)
    for i in range(2, len(sub1) + 1): # 生成全元素全排列列表
        sub2 += list(itertools.permutations(sub1,i))
    for tup in sub2:
        PW = ''
        
        #
        for subPW in tup:
            PW += subPW
        #
        if len(PW) in range(MinLen, MaxLen + 1):
            LastList.append(PW)
        else:
            pass

def ShowPassword():
    '''显示密码'''
    global LastList
    global Timeout
    # 格式化输出
    for i in range(len(LastList)):
        if i % 4 == 0:
            print("%s\n" % LastList[i])
        else:
            print("%s\t" % LastList[i])
    print('\n')
    print("显示{:d}s，回到主菜单。".format(Timeout))
    time.sleep(Timeout)

def CreatePasswordFile():
    '''创建密码字典文件'''
    global Flag
    global LastList
    print("在当前目录下创建字典文件：dic.txt")
    time.sleep(Timeout)
    with open('./dic.txt','w+') as fp:
        for PW in LastList:
            fp.write(PW)
            fp.write('\n')
    Flag = 1


if __name__ == '__main__':
    main()

函数之间的关系一目了然

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
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#!/usr/bin/env python3
#-*- coding:utf-8 -*-
__author__ = 'QCF'

import os
import platform
import itertools
import time

class MakePassword(object):
    def __init__(self):
        self.RawList = []
        self.DenyList = [' ','','@']
        self.LastList = []
        self.MinLen = 6
        self.MaxLen = 16
        self.Timeout = 3
        self.Flag = 0
        self.RunDictionary = {
'0':self.Exit,
'1':self.GetRawList,
'2':self.AddDenyList,
'3':self.ClearRawList,
'4':self.SetRawList,
'5':self.ModifyPasswordLen,
'6':self.CreatePasswordList,
'7':self.ShowPassword,
'8':self.CreatePasswordFile
}
        self.main()

    def main(self):
        while True:
            self.MainMenu()
            op = input('输入选项：')
            if op in map(str,range(len(self.RunDictionary))):
                self.RunDictionary.get(op)()
            else:
                self.TipMainMenuInputError()
                continue

    def MainMenu(self):
        self.Clear() # 清屏
        print('||')
        print('=' * 40)
        print('||')
        print('|| 0：退出程序')
        print('|| 1：输入原始密码列表')
        print('|| 2：添加非法字符到列表')
        print('|| 3：清空原始密码列表')
        print('|| 4：设置原始密码列表')
        print('|| 5：改变默认密码长度({:d}-{:d})'.format(self.MinLen, self.MaxLen))
        print('|| 6：创建密码列表')
        print('|| 7：显示所有密码')
        print('|| 8：创建密码字典文件')
        print('||')
        print('=' * 40)
        print('||')
        print('当前非法字符列表为：{}'.format(self.DenyList))
        print('当前原始密码元素为：{}'.format(self.RawList))
        print('共有密码{:d}个'.format(len(self.LastList)))
    
        if self.Flag:
            print('已在当前目录创建密码字典文件dic.txt')
        else:
            print('未创建密码字典文件')

    def Clear(self):
        OS = platform.system() # 获取系统信息
        if (OS == u'Windiws'): # 表示已Unicode字符串储存，避免控制台与python编码不同造成问题
            os.system('cls') # Windows下清屏命令为'cls'
        else:
            os.system('clear') # Linux下清屏命令为'cl

    def TipMainMenuInputError(self):
        self.Clear()
        print('只能输入0-7的整数，等待{:d}s后重新输入。'.format(self.Timeout))
        time.sleep(self.Timeout)

    def Exit(self):
        exit()

    def GetRawList(self):
        self.Clear()
        print('输入回车后直接退出')
        print('当前原始密码列表为：{}'.format(self.RawList))
        st = None
        while not st == '':
            st = input('请输入密码元素字符串：')
            if st in self.DenyList:
                print('这个字符串是预先设定的非法字符串')
                continue
            else:
                self.RawList.append(st)
                self.Clear()
                print('输入回车后直接退出')
                print('当前原始密码列表为：{}'.format(self.RawList))

    def AddDenyList(self):
        self.Clear()
        print('输入回车后直接退出')
        print('当前非法字符为：{}'.format(self.DenyList))
        st = None
        while not (st == ''):
            st = input('请输入需要添加的非法字符串：')
            self.DenyList.append(st)
            self.Clear()
            print('输入回车后直接退出')
            print('当前非法字符串列表为：{}'.format(self.DenyList))

    def ClearRawList(self):
        self.RawList = []

    def SetRawList(self):
        a = set(self.RawList)
        b = set(self.DenyList)
        self.RawList = []
        for str in set(a - b):
            self.RawList.append(str)

    def ModifyPasswordLen(self):
        self.Clear()
        while True:
            print("当前密码长度为{:d},{:d}".format(self.MinLen, self.MaxLen))
            min = input("请输入密码最小长度：")
            max = input("请输入密码最大长度：")
            try:
                self.MinLen = int(min)
                self.MaxLen = int(max)
            except ValueErrir:
                print("密码长度只能输入整数6-18")
                break
            if (self.MinLen not in range(6,19)) or (self.MaxLen not in range(6,19)):
                print("密码长度只能输入整数6-18")
                self.MinLen = 6
                self.MaxLen = 16
                continue
            if self.MinLen == self.MaxLen:
                res = input("确定将密码长度限定为{:d}吗？（Y/N）".format(self.MinLen))
                if res not in list('YyNn'):
                    print("输入错误，请重新输入！")
                    continue
                elif res in list('Yy'):
                    print("已将密码长度限定为{:d}".format(MinLen))
                    break
                else:
                    pass
            elif self.MinLen > self.MaxLen:
                res = input("密码最小最大长度输入错误,是否交换最小最大长度？（Y/N）")
                if res not in list('YyNn'):
                    print("输入错误，请重新输入！")
                    continue
                elif res in list('Yy'):
                    temp = self.MinLen
                    self.MinLen = self.MaxLen
                    self.Maxlen = temp
                    print("密码长度为：({:d}-{:d})".format(self.MinLen, self.MaxLen))
                else:
                    print("密码最小最大长度输入错误，请重新输入！")
            else:
                print("设置完毕，等待{:d}s后返回菜单。".format(self.Timeout))
                time.sleep(self.Timeout)
                break

    def CreatePasswordList(self):
        titleList = []
        swapcaseList = []
        for st in self.RawList:
            swapcaseList.append(st.swapcase()) # 字符串大小写转换
            titleList.append(st.title()) # 标题化字符串（大写开头）

        sub1 = [] # Raw + title + swapcase
        sub2 = [] # sub1全排列列表
        for st in set(self.RawList + titleList + swapcaseList): # 生成全元素列表
            sub1.append(st)
        for i in range(2, len(sub1) + 1): # 生成全元素全排列列表
            sub2 += list(itertools.permutations(sub1,i))
        for tup in sub2:
            PW = ''
        
            #
            for subPW in tup:
                PW += subPW
            #
            if len(PW) in range(self.MinLen, self.MaxLen + 1):
                self.LastList.append(PW)
            else:
                pass

    def ShowPassword(self):
        # 格式化输出
        for i in range(len(self.LastList)):
            if i % 4 == 0:
                print("%s\n" % self.LastList[i])
            else:
                print("%s\t" % self.LastList[i])
        print('\n')
        print("显示{:d}s，回到主菜单。".format(self.Timeout))
        time.sleep(self.Timeout)

    def CreatePasswordFile(self):
        print("在当前目录下创建字典文件：dic.txt")
        time.sleep(self.Timeout)
        with open('./dic.txt','w+') as fp:
            for PW in self.LastList:
                fp.write(PW)
                fp.write('\n')
        self.Flag = 1


if __name__ == '__main__':
    mp = MakePassword()

一些知识

Python类方法、静态方法与实例方法

静态方法是指无需实例参与即可调用的方法(不需要self参数)，在调用过程中，直接在类之后使用.号运算符调用。

Python2中，静态方法必须使用@staticmethod装饰器来声明。

Python 3中，不需要声明为静态方法，但是这样的话只能通过类去调用这个方法，如果通过实例调用这个方法会引发异常。

1
2
3
4
5
6
7
8
9
10
# python3
class ClassA(object):
    def func_A():
        print('Hello Python!')

if __name__ == '__main__':
    ClassA.func_A()
    # 使用实例调用会引发异常
    ca = ClassA()
    ca.func_A()

类方法

if __name__ == '__main__'

“Make a script both importable and executable”

使一个模块既可以导入到别的脚本正常使用，另外也可自己执行。

**__name__是一个系统会调用的变量，如果在模块内，则为__main__**，如果在模块外导入，则为该模块的名字。

就像：假如你叫小明.py，在朋友眼中，你是小明(__name__ == '小明')；在你自己眼中，你是你自己(__name__ == '__main__')。

可以当作程序入口来使用