Python Third Day

A.三元運算

　　- 三元運算（三目運算），是對簡單的條件語句的縮寫。

# 書寫格式
 
result = 值1 if 條件 else 值2
 
# 若是條件成立，那麼將 「值1」 賦值給result變量，不然，將「值2」賦值給result變量

B.函數

　　- 定義函數

def 函數名(參數):
    ...
    函數體
    ...
    返回值（return）

 

　　函數的定義主要有以下要點：

　　　　- def：表示函數的關鍵字
　　　　- 函數名：函數的名稱，往後根據函數名調用函數
　　　　- 函數體：函數中進行一系列的邏輯計算，如：發送郵件、計算出 [11,22,38,888,2]中的最大數等...
　　　　- 參數：爲函數體提供數據
　　　　- 返回值：當函數執行完畢後，能夠給調用者返回數據。

　　- 參數
　　函數的有三中不一樣的參數：

　　　　- 普通參數

# ######### 定義函數 ######### 

# name 叫作函數func的形式參數，簡稱：形參
def func(name):
    print name

# ######### 執行函數 ######### 
#  'wupeiqi' 叫作函數func的實際參數，簡稱：實參
func('wupeiqi')

　　　　- 默認參數

def func(name, age = 18):
    
    print "%s:%s" %(name,age)

# 指定參數
func('wupeiqi', 19)
# 使用默認參數
func('alex')

注：默認參數須要放在參數列表最後

　　　　- 動態參數

def func(*args):

    print args


# 執行方式一
func(11,33,4,4454,5)

# 執行方式二
li = [11,2,2,3,3,4,54]
func(*li)

def func(**kwargs):

    print args


# 執行方式一
func(name＝'wupeiqi',age=18)

# 執行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)

def func(*args, **kwargs):

    print args
    print kwargs

 

C.文件操做

 

  1 class TextIOWrapper(_TextIOBase):
  2     """
  3     Character and line based layer over a BufferedIOBase object, buffer.
  4     
  5     encoding gives the name of the encoding that the stream will be
  6     decoded or encoded with. It defaults to locale.getpreferredencoding(False).
  7     
  8     errors determines the strictness of encoding and decoding (see
  9     help(codecs.Codec) or the documentation for codecs.register) and
 10     defaults to "strict".
 11     
 12     newline controls how line endings are handled. It can be None, '',
 13     '\n', '\r', and '\r\n'.  It works as follows:
 14     
 15     * On input, if newline is None, universal newlines mode is
 16       enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
 17       these are translated into '\n' before being returned to the
 18       caller. If it is '', universal newline mode is enabled, but line
 19       endings are returned to the caller untranslated. If it has any of
 20       the other legal values, input lines are only terminated by the given
 21       string, and the line ending is returned to the caller untranslated.
 22     
 23     * On output, if newline is None, any '\n' characters written are
 24       translated to the system default line separator, os.linesep. If
 25       newline is '' or '\n', no translation takes place. If newline is any
 26       of the other legal values, any '\n' characters written are translated
 27       to the given string.
 28     
 29     If line_buffering is True, a call to flush is implied when a call to
 30     write contains a newline character.
 31     """
 32     def close(self, *args, **kwargs): # real signature unknown
 33         關閉文件
 34         pass
 35 
 36     def fileno(self, *args, **kwargs): # real signature unknown
 37         文件描述符  
 38         pass
 39 
 40     def flush(self, *args, **kwargs): # real signature unknown
 41         刷新文件內部緩衝區
 42         pass
 43 
 44     def isatty(self, *args, **kwargs): # real signature unknown
 45         判斷文件是不是贊成tty設備
 46         pass
 47 
 48     def read(self, *args, **kwargs): # real signature unknown
 49         讀取指定字節數據
 50         pass
 51 
 52     def readable(self, *args, **kwargs): # real signature unknown
 53         是否可讀
 54         pass
 55 
 56     def readline(self, *args, **kwargs): # real signature unknown
 57         僅讀取一行數據
 58         pass
 59 
 60     def seek(self, *args, **kwargs): # real signature unknown
 61         指定文件中指針位置
 62         pass
 63 
 64     def seekable(self, *args, **kwargs): # real signature unknown
 65         指針是否可操做
 66         pass
 67 
 68     def tell(self, *args, **kwargs): # real signature unknown
 69         獲取指針位置
 70         pass
 71 
 72     def truncate(self, *args, **kwargs): # real signature unknown
 73         截斷數據，僅保留指定以前數據
 74         pass
 75 
 76     def writable(self, *args, **kwargs): # real signature unknown
 77         是否可寫
 78         pass
 79 
 80     def write(self, *args, **kwargs): # real signature unknown
 81         寫內容
 82         pass
 83 
 84     def __getstate__(self, *args, **kwargs): # real signature unknown
 85         pass
 86 
 87     def __init__(self, *args, **kwargs): # real signature unknown
 88         pass
 89 
 90     @staticmethod # known case of __new__
 91     def __new__(*args, **kwargs): # real signature unknown
 92         """ Create and return a new object.  See help(type) for accurate signature. """
 93         pass
 94 
 95     def __next__(self, *args, **kwargs): # real signature unknown
 96         """ Implement next(self). """
 97         pass
 98 
 99     def __repr__(self, *args, **kwargs): # real signature unknown
100         """ Return repr(self). """
101         pass
102 
103     buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
104 
105     closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
106 
107     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
108 
109     errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
110 
111     line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
112 
113     name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
114 
115     newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
116 
117     _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
118 
119     _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

View Code

 

 

 

　　- 打開文件
　　　　打開文件時，須要指定文件路徑和以何等方式打開文件，打開後，便可獲取該文件句柄，往後經過此文件句柄對該文件操做。
　　　　打開文件的模式有：
　　　　　　r ，只讀模式【默認模式，文件必須存在，不存在則拋出異常】
　　　　　　w，只寫模式【不可讀；不存在則建立；存在則清空內容】
　　　　　　x， 只寫模式【不可讀；不存在則建立，存在則報錯】
　　　　　　a， 追加模式【可讀；   不存在則建立；存在則只追加內容】
   
　　　　"+" 表示能夠同時讀寫某個文件
　　　　　　r+， 讀寫【可讀，可寫】
　　　　　　w+，寫讀【可讀，可寫】
　　　　　　x+ ，寫讀【可讀，可寫】
　　　　　　a+， 寫讀【可讀，可寫】
 
　　　　"b"表示以字節的方式操做
　　　　　　rb  或 r+b
　　　　　　wb 或 w+b
　　　　　　xb 或 w+b
　　　　　　ab 或 a+b
  
　　注：以b方式打開時，讀取到的內容是字節類型，寫入時也須要提供字節類型，不能指定編碼

 

　　- 文件內置函數flush

　　flush原理：

1. 文件操做是經過軟件將文件從硬盤讀到內存
2. 寫入文件的操做也都是存入內存緩衝區buffer（內存速度快於硬盤，若是寫入文件的數據都從內存刷到硬盤，內存與硬盤的速度延遲會被無限放大，效率變低，因此要刷到硬盤的數據咱們統一往內存的一小塊空間即buffer中放，一段時間後操做系統會將buffer中數據一次性刷到硬盤）
3. flush即，強制將寫入的數據刷到硬盤

滾動條：

import sys,time for i in range(10): sys.stdout.write('#') sys.stdout.flush() time.sleep(0.2)

open函數詳解

1. open()語法 open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])

open函數有不少的參數，經常使用的是file，mode和encoding

file文件位置，須要加引號

mode文件打開模式，見下面3

buffering的可取值有0，1，>1三個，0表明buffer關閉（只適用於二進制模式），1表明line buffer（只適用於文本模式），>1表示初始化的buffer大小； encoding表示的是返回的數據採用何種編碼，通常採用utf8或者gbk；

errors的取值通常有strict，ignore，當取strict的時候，字符編碼出現問題的時候，會報錯，當取ignore的時候，編碼出現問題，程序會忽略而過，繼續執行下面的程序。 newline能夠取的值有None, \n, \r, 」, ‘\r\n'，用於區分換行符，可是這個參數只對文本模式有效；

closefd的取值，是與傳入的文件參數有關，默認狀況下爲True，傳入的file參數爲文件的文件名，取值爲False的時候，file只能是文件描述符，什麼是文件描述符，就是一個非負整數，在Unix內核的系統中，打開一個文件，便會返回一個文件描述符。

2. Python中file()與open()區別 二者都可以打開文件，對文件進行操做，也具備類似的用法和參數，可是，這兩種文件打開方式有本質的區別，file爲文件類，用file()來打開文件，至關於這是在構造文件類，而用open()打開文件，是用python的內建函數來操做，建議使用open

3. 參數mode的基本取值

Character	Meaning
‘r'	open for reading (default)
‘w'	open for writing, truncating the file first
‘a'	open for writing, appending to the end of the file if it exists
‘b'	binary mode
‘t'	text mode (default)
‘+'	open a disk file for updating (reading and writing)
‘U'	universal newline mode (for backwards compatibility; should not be used in new code)

r、w、a爲打開文件的基本模式，對應着只讀、只寫、追加模式； b、t、+、U這四個字符，與以上的文件打開模式組合使用，二進制模式，文本模式，讀寫模式、通用換行符，根據實際狀況組合使用、

常見的mode取值組合

 1 r或rt 默認模式，文本模式讀  2 rb 二進制文件  3  4 w或wt 文本模式寫，打開前文件存儲被清空  5 wb 二進制寫，文件存儲一樣被清空  6  7 a 追加模式，只能寫在文件末尾  8 a+ 可讀寫模式，寫只能寫在文件末尾  9 10 w+ 可讀寫，與a+的區別是要清空文件內容 11 r+ 可讀寫，與a+的區別是能夠寫到文件任何位置 

- with用法

with open('a.txt','w') as f:

- 修改文件

import os with open('a.txt','r',encoding='utf-8') as read_f,\ open('.a.txt.swap','w',encoding='utf-8') as write_f: for line in read_f: if line.startswith('hello'): line='哈哈哈\n' write_f.write(line) os.remove('a.txt') os.rename('.a.txt.swap','a.txt')
- 做業
編寫數據庫，基於文件實現增刪改查功能

  1 #!/usr/bin/python
  2 # -*- coding:utf-8 -*-
  3 
  4 
  5 def user_input():  # SQL語句輸入入口
  6     sql_count = 0
  7     sql_text = input("SQL>")
  8     if sql_text == 'exit':
  9         return "exit"
 10     elif sql_text == "":
 11         return "continue"
 12     while sql_text.endswith(';') != 1:        # 實現換行輸入， ";"做爲結束符
 13         sql_count += 1
 14         sql_user = input("%s>" % sql_count)
 15         sql_text = sql_text + " " + sql_user
 16     sql_text = sql_text.split(";")             # 去除";"號
 17     sql_text = sql_text[0]
 18     sql_text = sql_text.upper()                # 所有轉換爲大寫格式
 19     sql_text = sql_text.split(" ")             # 以空格爲分割符，生成列表
 20     while '' in sql_text:
 21         sql_text.remove('')                    # 去除多餘的空元素
 22     return sql_text
 23 
 24 
 25 def sql_analysis(sql_user_list):
 26     sql_cut = sql_user_list[0]
 27     if sql_cut == "SELECT":
 28         sql_user_dict = sql_select_analysis(sql_user_list)
 29     elif sql_cut == "INSERT":
 30         sql_user_dict = sql_insert_analysis(sql_user_list)
 31     elif sql_cut == "UPDATE":
 32         sql_user_dict = sql_update_analysis(sql_user_list)
 33     elif sql_cut == "DELETE":
 34         sql_user_dict = sql_delete_analysis(sql_user_list)
 35     else:
 36         sql_user_dict = "err"
 37     return sql_user_dict
 38 
 39 
 40 def sql_select_analysis(sql_user_list):
 41     sql_user_dict = {
 42         'func': "select",
 43         'SELECT': [],
 44         'FROM': [],
 45         'WHERE': [],
 46         'LIMIT': []
 47     }
 48     key = "SELECT"
 49     for item in sql_user_list:
 50         if item in sql_user_dict.keys():
 51             key = item
 52             continue
 53         if item not in sql_user_dict.keys():
 54             sql_user_dict[key].append(item)
 55     if sql_user_dict.get('WHERE'):
 56         sql_user_dict['WHERE'] = sql_where_analysis(sql_user_dict.get('WHERE'))
 57     return sql_user_dict
 58 
 59 
 60 def sql_insert_analysis(sql_user_list):
 61     sql_user_dict = {
 62         'func': "insert",
 63         'INSERT': [],
 64         'INTO': [],
 65         'VALUES': []
 66     }
 67     key = "INSERT"
 68     for item in sql_user_list:
 69         if item in sql_user_dict.keys():
 70             key = item
 71             continue
 72         if item not in sql_user_dict.keys():
 73             sql_user_dict[key].append(item)
 74     return sql_user_dict
 75 
 76 
 77 def sql_update_analysis(sql_user_list):
 78     sql_user_dict = {
 79         'func': "update",
 80         'UPDATE': [],
 81         'SET': [],
 82         'WHERE': []
 83     }
 84     key = "UPDATE"
 85     for item in sql_user_list:
 86         if item in sql_user_dict.keys():
 87             key = item
 88             continue
 89         if item not in sql_user_dict.keys():
 90             sql_user_dict[key].append(item)
 91     if sql_user_dict.get('WHERE'):
 92         sql_user_dict['WHERE'] = sql_where_analysis(sql_user_dict.get('WHERE'))
 93     return sql_user_dict
 94 
 95 
 96 def sql_delete_analysis(sql_user_list):
 97     sql_user_dict = {
 98         'func': "delete",
 99         'DELETE': [],
100         'FROM': [],
101         'WHERE': [],
102     }
103     key = "DELETE"
104     for item in sql_user_list:
105         if item in sql_user_dict.keys():
106             key = item
107             continue
108         if item not in sql_user_dict.keys():
109             sql_user_dict[key].append(item)
110     if sql_user_dict.get('WHERE'):
111         sql_user_dict['WHERE'] = sql_where_analysis(sql_user_dict.get('WHERE'))
112     return sql_user_dict
113 
114 
115 def sql_where_analysis(sql_where_list):
116     where_key = ['AND', 'OR', 'NOT']
117     where_char = ""
118     where_list = []
119     for item in sql_where_list:
120         if item not in where_key:
121             where_char += item
122             continue
123         if item in where_key:
124             where_char = sql_where_analysis_second(where_char)
125             where_list.append(where_char)
126             where_list.append(item)
127             where_char = ""
128     else:
129         where_char = sql_where_analysis_second(where_char)
130         where_list.append(where_char)
131     return where_list
132 
133 
134 def sql_where_analysis_second(where_char):
135     key = ['>', '<', '=']
136     res = []
137     char = ''
138     opt = ''
139     tag = False
140     for i in where_char:
141         if i in key:
142             tag = True
143             if len(char) != 0:
144                 res.append(char)
145                 char = ''
146             opt += i   # opt='<='
147         if not tag:
148             char += i  # char='10'
149         if tag and i not in key:
150             tag = False
151             res.append(opt)
152             opt = ''
153             char += i  # char='1'
154     else:
155         res.append(char)
156     if len(res) == 1:
157         res = list(res[0].partition('LIKE'))
158     return res
159 
160 
161 def sql_manage(sql_user_dict):
162     if sql_user_dict["func"] == "select":
163         if sql_user_dict['FROM']:
164             db_txt = sql_from_manage(sql_user_dict['FROM'])
165             if db_txt == "err":
166                 return "err01"
167         else:
168             return "err01"
169         if sql_user_dict['WHERE']:
170             db_txt = sql_where_manage(sql_user_dict['WHERE'], db_txt)
171         if sql_user_dict['LIMIT']:
172             db_txt = sql_limit_manage(sql_user_dict['LIMIT'], db_txt)
173             if db_txt == "err":
174                 return "err02"
175         if sql_user_dict['SELECT']:
176             db_txt = sql_select_manage(sql_user_dict['SELECT'], db_txt)
177             if db_txt == "err":
178                 return "err02"
179         else:
180             return "err02"
181         return db_txt
182     elif sql_user_dict["func"] == "update":
183         if sql_user_dict['UPDATE']:
184             db_txt = sql_from_manage(sql_user_dict['UPDATE'])
185             if db_txt == "err":
186                 return "err01"
187         else:
188             return "err01"
189         if sql_user_dict['WHERE']:
190             db_txt = sql_where_manage(sql_user_dict['WHERE'], db_txt)
191         if sql_user_dict['SET']:
192             db_txt = sql_set_manage(sql_user_dict['SET'], sql_user_dict['UPDATE'], db_txt)
193             if db_txt == "err":
194                 return "err02"
195         else:
196             return "err02"
197         return db_txt
198     elif sql_user_dict["func"] == "insert":
199         if sql_user_dict['VALUES']:
200             db_txt = sql_values_manage(sql_user_dict['VALUES'])
201             if db_txt == 'err':
202                 return "err02"
203         else:
204             return "err02"
205         if sql_user_dict['INTO']:
206             db_txt = sql_into_manage(sql_user_dict['INTO'], db_txt)
207             if db_txt == 'err':
208                 return "err01"
209         else:
210             return "err01"
211         return db_txt
212     elif sql_user_dict["func"] == "delete":
213         if sql_user_dict['FROM']:
214             db_txt = sql_from_manage(sql_user_dict['FROM'])
215             all_db = db_txt
216             if db_txt == "err":
217                 return "err01"
218         else:
219             return "err01"
220         if sql_user_dict['WHERE']:
221             db_txt = sql_where_manage(sql_user_dict['WHERE'], db_txt)
222         if not sql_user_dict['DELETE']:
223             db_txt = sql_delete_manage(all_db, db_txt, sql_user_dict['FROM'])
224             return db_txt
225         else:
226             return "err02"
227 
228 
229 def sql_select_manage(select_txt, db_txt):
230     if select_txt[0] == "*":
231         return db_txt
232     else:
233         user_txt = select_txt[0].split(",")
234         temp = ['ID', 'NAME', 'AGE', 'PHONE', 'DEPT', 'DATE']
235         for key in user_txt:
236             if key not in temp:
237                 return "err"
238         user_dict = {}
239         user_list = []
240         for item in db_txt:
241             for user_key, user_value in item.items():
242                 if user_key in user_txt:
243                     user_dict.setdefault(user_key, user_value)
244             user_list.append(user_dict)
245             user_dict = {}
246         return user_list
247 
248 
249 def sql_from_manage(from_list):
250     from_txt = from_list[0]
251     from_txt = from_txt.translate(str.maketrans('.', '/'))
252     import os
253     if os.path.exists(from_txt):
254         f1 = open(from_txt, 'r', encoding='utf-8')
255         content = f1.read()
256         f1.close()
257         user_attr_list = []
258         db_str_list = content.split('\n')
259         for item in db_str_list:
260             temp = item.split('|')
261             v = {
262                 'ID': temp[0],
263                 'NAME': temp[1],
264                 'AGE': temp[2],
265                 'PHONE': temp[3],
266                 'DEPT': temp[4],
267                 'DATE': temp[5]
268             }
269             user_attr_list.append(v)
270         return user_attr_list
271     else:
272         return "err"
273 
274 
275 def sql_where_manage(where_list, db_text):
276     user_list = []
277     for db_txt in db_text:
278         res = []
279         for exp in where_list:
280             if type(exp) is list:
281                 exp_k, opt, exp_v = exp
282                 if exp[1] == '=':
283                     opt = "%s=" % exp[1]
284                 if db_txt[exp_k].isdigit():
285                     dic_v = int(db_txt[exp_k])
286                     exp_v = int(exp_v)
287                 else:
288                     dic_v = "'%s'" % db_txt[exp_k]
289                 if opt != 'LIKE':
290                     exp = str(eval("%s%s%s" % (dic_v, opt, exp_v)))
291                 else:
292                     if exp_v in dic_v:
293                         exp = 'True'
294                     else:
295                         exp = 'False'
296             res.append(exp)
297         key = ['AND', 'OR', 'NOT']
298         for item in res:
299             if item in key:
300                 res[res.index(item)] = item.lower()
301         res = eval(' '.join(res))
302         if res:
303             user_list.append(db_txt)
304     return user_list
305 
306 
307 def sql_limit_manage(limit_list, db_txt):
308     i = 0
309     user_list = []
310     if limit_list[0].isdigit():
311         limit_int = int(limit_list[0])
312     else:
313         return "err"
314     for item in db_txt:
315         if i < limit_int:
316             user_list.append(item)
317             i += 1
318         else:
319             break
320     return user_list
321 
322 
323 def sql_set_manage(set_list, file_list, db_txt):
324     all_txt = sql_from_manage(file_list)
325     sql_delete_manage(all_txt, db_txt, file_list)
326     set_str = "".join(set_list)
327     set_list = []
328     set_txt = ""
329     user_list = []
330     for i in set_str:
331         if i == ',':
332             if set_txt != "":
333                 set_list.append(set_txt)
334             user_list.append(set_list)
335             set_list = []
336             set_txt = ""
337             continue
338         if i == '=':
339             if set_txt != "":
340                 set_list.append(set_txt)
341             set_list.append(i)
342             set_txt = ""
343         else:
344             set_txt += i
345     else:
346         if set_txt != "":
347             set_list.append(set_txt)
348         if set_list:
349             user_list.append(set_list)
350     for item in user_list:
351         if len(item) != 3:
352             return "err"
353         exp_k, opt, exp_v = item
354         for n in db_txt:
355             if exp_k not in n.keys():
356                 return "err"
357             n[exp_k] = exp_v
358     db_str_list = []
359     for item in db_txt:
360         temp = "%s|%s|%s|%s|%s|%s" % (item['ID'], item['NAME'], item['AGE'], item['PHONE'], item['DEPT'], item['DATE'])
361         db_str_list.append(temp)
362     for i in db_str_list:
363         sql_into_manage(file_list, i)
364     return_txt = "已修改%d行" % (len(db_txt))
365     return_list = [return_txt]
366     return return_list
367 
368 
369 def sql_into_manage(from_list, db_txt):
370     from_txt = from_list[0]
371     from_txt = from_txt.translate(str.maketrans('.', '/'))
372     import os
373     if os.path.exists(from_txt):
374         f1 = open(from_txt, 'a', encoding='utf-8')
375         db_txt = "\n%s" % (db_txt,)
376         f1.write(db_txt)
377         f1.close()
378         return ['添加完成！']
379     else:
380         return "err"
381 
382 
383 def sql_values_manage(user_list):
384     values_txt = user_list[0]
385     db_txt = ""
386     for i in values_txt:
387         if i in ['(', ')']:
388             continue
389         db_txt += i
390     db_txt = db_txt.split(",")
391     if len(db_txt) != 6:
392         return "err"
393     n = "|"
394     db_txt = n.join(db_txt)
395     return db_txt
396 
397 
398 def sql_delete_manage(all_list, user_list, file_name):
399     for line in user_list:
400         all_list.remove(line)
401     db_str_list = []
402     for item in all_list:
403         temp = "%s|%s|%s|%s|%s|%s" % (item['ID'], item['NAME'], item['AGE'], item['PHONE'], item['DEPT'], item['DATE'])
404         db_str_list.append(temp)
405     db = "\n".join(db_str_list)
406     file_name = file_name[0]
407     file_name = file_name.translate(str.maketrans('.', '/'))
408     f1 = open(file_name, 'w', encoding="utf-8")
409     f1.write(db)
410     f1.close()
411     return ['已刪除！']
412 
413 
414 def sql_main():
415     while True:
416         sql_txt = user_input()
417         if sql_txt == 'exit':
418             break
419         elif sql_txt == 'continue':
420             continue
421         sql_txt = sql_analysis(sql_txt)
422         if sql_txt == "err":
423             print("語法錯誤！")
424             continue
425         sql_txt = sql_manage(sql_txt)
426         if sql_txt == "err01":
427             print("查詢表不存在或爲空！")
428             continue
429         elif sql_txt == "err02":
430             print("語法有誤！")
431             continue
432         for line in sql_txt:
433             print(line)
434 
435 if __name__ == '__main__':
436     sql_main()

View Code