python_day03 文件处理复习和函数定义调用参数对象

一、字符编码和文件处理复习

字符编码：把人类的字符翻译成计算机能识别的数字
字符编码表：就是一张字符与数字对应关系的表 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()