一、字符编码和文件处理复习
字符编码：把人类的字符翻译成计算机能识别的数字
字符编码表：就是一张字符与数字对应关系的表 ASCII GBK UTF-8 UNICODE
内存默认字符编码格式UNICODE
硬盘存入数据以bytes存储数据
UNICODE------>encode('utf-8')------>bytes
bytes-------->decode('utf-8')------>unicode
原则：字符是以什么格式编码的，就要以什么格式解码
PS：
python3中的字符串分为两种：
x='egon' 存成UNICODE
y=x.encode('utf-8') 存成bytes
python2中的字符串也分为两种：
x=u'egon' 与python3中的字符串一样
y='alex' 与python3中的bytes一样
文件处理的常用操作
#r文本模式的读，在文件不存在，不会创建新文件 f=open('a.txt','r',encoding='utf-8') #不指定encode模式会以os默认方式打开，windows默认是GBK。 print(f.read()) #文件内容全部列出。不推荐此方式，占用内存空间较大。 print(f.readable()) #判断文件是否可读或可写 print(f.writable()) print(f.readline()) #读单行和多行 print(f.readlines()) f.close() #不做f.close() os会占用资源 #w文本模式的写,文件存在则清空，不存在则创建 # f=open('a.txt','w',encoding='utf-8') f=open('b.txt','w',encoding='utf-8') print(f.writable()) print(f.readable()) f.write('哈哈哈哈 ') # 为换行符 f.write('哈哈哈哈 ') f.writelines(['1111 ','222 ']) #a文本模式的追加,文件存在光标跳到文件末尾，文件不存在创建 f=open('b.txt','a',encoding='utf-8') print(f.writable()) print(f.tell()) #tell告知光标所在字节位置，相对于文件头而言。 f.write('3333 ') f.write('44444 ') #r+,w+,a+ #r+读时可写 w+写时可读 a+最加时可读 #rb模式即直接从硬盘中读取bytes bytes不是最终的二进制 f=open('a.txt','rb') #b模式不需要指定encoding方式，否则会有报错 print(f.read()) #wb模式 f=open('a.txt','wb') f.write('你好啊'.encode('utf-8')) #写入的是字节码，需要encode过程 print(f) f.close() print(f) print(f.read) print(f.readable) f.read() #ab模式 with open('file.txt','w',encoding='utf-8') as f: #不需要执行f.clost()，运行完成后会自动关闭f f.write('1111 ') f=open('test.jpg','rb') #图片格式或其他任意格式文件都可以通过二进制方式读取到 print(f.read()) #图片格式或其他任意格式文件都可以通过下列二进制方式复制 with open('test.jpg','rb') as read_f,open('test1.jpg','wb') as write_f: # write_f.write(read_f.read()) for line in read_f: write_f.write(line)
文件处理的其他了解操作：
f=open('a.txt','r',encoding='utf-8') print(f.read(3)) #3为读取字符个数 r模式 f.close()
f=open('a.txt','rb')
#unicode模式 1个字符时3个字节butes 解码时需3个的倍数
print(f.read(7).decode('utf-8')) #6为读取字节个数 rb模式
# print(f.read(3).decode('utf-8'))
f.close()
f=open('a.txt','rb')
print(f.read(3))
print(f.tell())
f.seek(3,0) #光标回到字节位置，相对于文件开头
print(f.tell())
print(f.read(3).decode('utf-8'))
f=open('a.txt','rb')
print(f.read(3))
print(f.tell())
f.seek(3,1) #1模式（当前光标为参照物） 向后移动几个字节
print(f.tell())
print(f.read().decode('utf-8'))
f=open('a.txt','rb')
f.seek(0,2) #2模式(结尾光标为参照物)
print(f.tell())
print(f.read())
#f.seek（） 1和2模式必须要在b模式下进行
#windows cmd命令行下执行tail
#python3 tail.py -f access.log
import time
import sys
with open(r'%s' %sys.argv[2],'rb') as f: #%s windows路径直接写可能在cmd下报错
f.seek(0,2)
while True:
line=f.readline()
if line:
print(line)
else:
time.sleep(0.2)
with open('acess.log','a') as f:
f.write('1111 ')
with open('a.txt','r+',encoding='utf-8') as f:
f.truncate(2) #从文件开头开始截取2个字节 a.txt只剩下2个字节
with open('a.txt','r',encoding='utf-8') as f:
# l=f.readlines()
# print(l)
# for line in l:
# print(line,end='')
# res=f.read()
# print(type(res))
for line in f.read():
print(line)
l=[1,2,3,4,5]
# for index in range(len(l)):
# # print(index)
# print(l[index])
for item in l:
# print(index)
print(item)
#windows cmd下调用脚本
import sys
#python3 copy.py source.file target.file
if len(sys.argv) < 3:
print('Usage:python3 copy.py source.file target.file')
sys.exit()
#r'C:UsersAdministratorPycharmProjectspython18期周末班day3 est.jpg'
with open(r'%s' %sys.argv[1],'rb') as read_f,
open(r'%s' %sys.argv[2],'wb') as write_f:
for line in read_f:
write_f.write(line)
# python3 tail.py -f access.log
import time
import sys
with open(r'%s' % sys.argv[2], 'rb') as f:
f.seek(0, 2)
while True:
line = f.readline()
if line:
print(line.decode('utf-8'),end='')
else:
time.sleep(0.2)
二、函数定义调用参数对象
问题：
复杂度增大
组织结构不清晰
可读性差
代码冗余
可扩展性和可维护性差
解决问题：
工具就是具备某一种功能的物件，就是程序中的函数的概念
事先准备工具的过程称为函数的定义
遇到特定的场景拿来就用称为函数调用
函数的使用：
1 先定义
2 再调用
函数的定义与变量的定义类似，没有事先定义变量，而直接引用变量，会报错
没有事先定义函数，而直接调用，就相当于在引用一个不存在的变量名
函数在定义阶段发生了什么事情？？？
只检测语法，不执行代码
函数的定义语法
def 函数名(arg1,arg2,arg3):
"注释"
函数体
return 返回值
函数名一般是动词
参数、、、
return:函数内部可以有多个return，但只能执行一次，函数就结束调用，
并且会把return后的值作为函数执行的结果返回
#定义的三种形式
'''
无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
空函数：设计代码结构
'''
''' ********************** hello egon ********************** ''' def print_star(): print('*'*10) def print_msg(): print('hello egon') print_star() print_star() print_msg() print_star() print_star()
def func():
asdf #asdf=111111
#定义阶段
def foo():
print('from foo')
bar()
# print(foo)
def bar():
print('from bar')
#调用阶段
foo()
def my_max(x,y):
if x > y:
# print(x)
return x
else:
# print(y)
return y
res=my_max(1,2)
print(res)
res=max(1,2)
print(res)
def foo():
print('-=----')
return 123
print('-=----')
print('-=----')
print('-=----')
foo()
def select(sql):
'''select function'''
print(sql)
#sql=['select', '*', 'from', 'mysql.user;']
def insert(sql):
'''insert function'''
pass
def update(sql):
'''update function'''
pass
def delete(sql):
'''delete function'''
pass
#select * from mysql.user;
def main():
while True:
sql=input('>>: ').strip()
if not sql:continue
cmd_info=sql.split()
cmd=cmd_info[0]
if cmd == 'select':
select(cmd_info)
main()
函数的返回值：
#函数的返回值 #函数内部可以有多个return，但是只能执行一次，函数就结束调用，并且会把return后的值作为函数执行的结果返回 def func(): print('from func') return [1,2,3],'a',1,{'a':3} res=func() print(res) ''' 大前提：return的返回值没有类型限制 1. 没有return：返回None，等同于return None 2. return 一个值：返回该值 3. return val1,val2,val3:返回(val1,val2,val3) ''' def my_max(x,y): if x > y: return x else: return y my_max(1,2) #语句形式 res=my_max(1,2)*10 #表达式形式 # res1=my_max(1,2) # res2=my_max(res1,3) res2=my_max(my_max(1,2),3) #函数调用可以当做另外一个函数的参数 print(res2)
函数的参数：
#形参：在定义函数时，括号内的参数成为形参 #特点：形参就是变量名 def foo(x,y): #x=1,y=2 print(x) print(y) #实参：在调用函数时，括号内的参数成为实参 #特点：实参就是变量值 foo(1,2) #在调用阶段实参（变量值）才会绑定形参（变量名） #调用结束后，解除绑定 #参数的分类 #位置参数：按照从左到右的顺序依次定义的参数 #位置形参：必须被传值，并且多一个不行，少一个也不行 #位置实参：与形参按照位置一一对应 # def foo(x,y): # print(x) # print(y) # foo('egon',1,2) #关键字实参：指的是按照name=value的形式，指名道姓地给name传值 # def foo(name,age): # print(name) # print(age) # foo('egon',18) # foo(age=18,name='egon') #关键字实参需要注意的问题是： # def foo(name,age,sex): # print(name) # print(age) # print(sex) # foo('egon',18,'male') # print('======>') # foo(sex='male',age=18,name='egon') # foo('egon',sex='male',age=18) #问题一:语法规定位置实参必须在关键字实参的前面 # foo('egon',sex='male',age=18) #问题二:一定不要对同一个形参传多次值 # foo('egon',sex='male',age=18,name='egon1') # foo('male',age=18,name='egon1') #默认形参：在定义阶段，就已经为形参赋值，意味在调用阶段可以不用传值 # def foo(x,y=1111111): # print(x) # print(y) # foo(1,'a') # def register(name,age,sex='male'): # print(name,age,sex) # register('asb',73) # register('wsb',38) # register('ysb',84) # register('yaya',28,'female') #默认参数需要注意的问题 #问题一:默认参数必须放在位置参数之后 # def foo(y=1,x): # print(x,y) #问题二：默认参数只在定义阶段赋值一次，而且仅一次 # x=100 # def foo(a,b=x): # print(a,b) # x=111111111111111111111111111111 # foo('egon') #问题三：默认参数的值应该定义成不可变类型
可变长参数：
#可变长参数指的是实参的个数多了 #实参无非位置实参和关键字实参两种 #形参必须要两种机制来分别处理按照位置定义的实参溢出的情况：* #跟按照关键字定义的实参溢出的情况：** # def foo(x,y,*args): #nums=(3,4,5,6,7) # print(x) # print(y) # print(args) # foo(1,2,3,4,5,6,7) #* # foo(1,2) #* #*args的扩展用法 # def foo(x,y,*args): #*args=*(3,4,5,6,7) # print(x) # print(y) # print(args) # # foo(1,2,3,4,5,6,7) #* # foo(1,2,*(3,4,5,6,7)) #foo(1,2,3,4,5,6,7) # def foo(x,y=1,*args): # # print(x) # print(y) # print(args) # # foo('a','b',*(1,2,3,4,5,6,7)) #foo('a','b',1,2,3,4,5,6,7) # # foo('egon',10,2,3,4,5,6,9,y=2) #报错 # foo('egon',10,2,3,4,5,6,9) # def foo(x,y,**kwargs): #nums={'z':3,'b':2,'a':1} # print(x) # print(y) # print(kwargs) # foo(1,2,z=3,a=1,b=2) #** # def foo(x,y,**kwargs): #kwargs={'z':3,'b':2,'a':1} # print(x) # print(y) # print(kwargs) # foo(1,2,**{'z':3,'b':2,'a':1}) #foo(1,2,a=1,z=3,b=2) # def foo(x, y): # # print(x) # print(y) # # foo(**{'y':1,'x':2}) # foo(y=1,x=2) # def foo(x,*args,**kwargs):#args=(2,3,4,5) kwargs={'b':1,'a':2} # print(x) # print(args) # print(kwargs) # foo(1,2,3,4,5,b=1,a=2) #这俩东西*args，**kwargs干甚用？？？ def register(name,age,sex='male'): print(name) print(age) print(sex) # def wrapper(*args,**kwargs): #args=(1,2,3) kwargs={'a':1,'b':2} # # print(args) # # print(kwargs) # register(*args,**kwargs) # # register(*(1, 2, 3),**{'a': 1, 'b': 2}) # # register(1, 2, 3,a=1,b=2) # wrapper(1,2,3,a=1,b=2) import time # def register(name,age,sex='male'): # # start_time=time.time() # print(name) # print(age) # print(sex) # time.sleep(3) # stop_time=time.time() # print('run time is %s' %(stop_time-start_time)) # def wrapper(*args, **kwargs): #args=('egon',) kwargs={'age':18} # start_time=time.time() # register(*args, **kwargs) # stop_time=time.time() # print('run time is %s' %(stop_time-start_time)) # wrapper('egon',age=18) # register('egon',18) #命名关键字参数: 在*后面定义的形参称为命名关键字参数，必须是被以关键字实参的形式传值 # def foo(name,age,*args,sex='male',group): # print(name) # print(age) # print(args) # print(sex) # print(group) # # foo('alex',18,19,20,300,group='group1') def foo(name,age=18,*args,sex='male',group,**kwargs): pass
函数的对象：
#函数是第一类的对象：指的是函数可以被当做数据传递 def foo(): print('from foo') #1 被赋值 # f=foo # print(f) # f() #2 可以当做参数传入 # def wrapper(func): # # print(func) # func() # wrapper(foo) #3 可以当做函数的返回 def wrapper(func): return func # res=wrapper(foo) # print(res) #4 可以当做容器类型的元素 # cmd_dic={ # 'func':foo # } # # print(cmd_dic) # cmd_dic['func']() def select(sql): '''select function''' print('select----->',sql) #sql=['select', '*', 'from', 'mysql.user;'] def insert(sql): '''insert function''' print('insert---->',sql) def update(sql): '''update function''' print('update----->',sql) def delete(sql): '''delete function''' print('delete---->',sql) def alter(sql): print('alter===>',sql) cmd_dic = { 'insert': insert, 'update': update, 'delete': delete, 'select': select, 'alter':alter, } #select * from mysql.user; def main(): while True: sql=input('>>: ').strip() if not sql:continue cmd_info=sql.split() cmd=cmd_info[0] if cmd in cmd_dic: cmd_dic[cmd](cmd_info) else: print('cmd not exists') main()