函数基础

'''
1. 组织结构混乱，可读性差
2. 代码冗余
3. 无法统一管理，维护难度极大
具备某一功能的工具即函数
函数的使用的必须遵循：先定义，后调用
'''

#函数分类：两大类

#1 内置函数：python解释器自带的函数，python解释器启动就会定义好这些函数
len()
max()
min()
sum()

#2 自定义函数：

#语法：
# def 函数名(参数1,参数2,...):
# """注释"""
# 函数体
# return 返回值
#定义阶段 可以不用参数和返回值，但必须要函数体
def tell_tag():
print('===========')

#调用阶段

tell_tag() #加（）调用tell_tag函数

#函数就和定义一个变量是一个意思，也都要先定义再调用，特殊处就是函数的值可以加（）调用
print(tell_msg) #输出的是内存地址，函数名=内存地址

#函数在定义阶段，只检测语法，不执行代码

#1.函数的使用必须遵循：先定义，后调用

#2.函数的定义，就相当于在定义一个变量，如果没有定义而直接调用，就相当于在引用一个不存在的变量名

#定义函数的三种形式
#无参 ()里面不填函数

#有参：函数体的代码，需要外部传入的值

#空函数 pass 可以搭建架构，然后一个一个实现

#1 调用函数：函数名(),
#需要注意：先通过名字找到函数的内存地址，然后加括号调用，执行里面的代码 做了两件事

#2 函数的返回值：return
#注意的第一点：
#在调用函数的过程中，一旦执行到return，就会立刻终止函数，并且把return后的结果当做本次调用的返回值返回
#函数体内可以有多个return，但是只能执行一次

#注意的第二点：
#返回的值，可以是任意类型 str,list等
#注意的第三点：
#没有return：默认返回None
#可以返回一个值===>值
#可以用逗号分隔，返回多个值===>tuple

#3:调用函数的三种形式：  1. 直接调用    2. 调用赋值 赋值是return的值    3. 函数运算赋值 运算的是return的值

#函数的参数

#形参与实参

#形参：在函数定义阶段，括号内定义的参数的称为形参,就相当于变量名
#实参：在函数调用阶段，括号内定义的参数的称为实参，就相当于变量值
#在调用阶段，实参的值会绑定给形参，在调用结束后，解除绑定
def foo(x,y): #形参 x=1,y=2
print(x,y)
foo(1,2) #实参

#参数的分类：

一：位置参数
位置形参：必须被传值的参数，多一个不行，少一个也不行
位置实参：从左到右依次赋值给形参
二：关键字参数：在函数调用阶段，按照key=value的形式定义实参
可以不依赖位置而指名道姓地给形参传值
需要注意的问题（可以与位置实参混用，但是）：
1. 位置实参必须在关键字实参的前面
2. 不能为一个形参重传值

三：默认参数：在定义函数阶段，已经为形参赋值了，在定义阶段已经赋值，意味着在调用阶段
可以不传值
注意的问题：
1 默认参数的值，只在定义时赋值一次
2 位置形参应该在默认参数的前面
3 默认参数的值应该是不可变类型

四：可变长参数 *args **kwargs
实参可变长度指的是：实参值的个数是不固定
而实参的定义形式无非两种：1、位置实参，2、关键字实参
针对这两种形式的实参个数不固定，相应的，形参也要有两种解决方案: *  **
#针对按照位置定义的溢出的那部门实参，形参：*args

#针对按照关键字定义的溢出的那部分实参，形参：**kwargs

#五：命名关键字参数(了解):
# 形参中，在*后定义的参数称之为命名关键字参数，
# 它的特性是；传值时，必须按照关键字实参的形式传值

# 排序： 位置参数，默认参数，*args，命名关键字参数，**kwargs

函数的对象

#函数是第一类对象：函数可以当做数据来使用

#可以被引用

#可以当做参数传入一个#可以当做函数的返回值函数

#可以当做容器类型的一个元素

#容器中的一个元素
func_dic={
    'select':select,
    'update':update,
    'insert':insert,
    'delete':delete,
    'alter':alter
}

def main():
    while True:
        inp=input('>>: ').strip()
        if not inp:continue
        sql=inp.split()
        cmd=sql[0]
#        if cmd == 'select':
#            select(sql)
#        elif cmd == 'update':
#            update(sql)
#        elif cmd == 'insert':
#            insert(sql)
#        elif cmd == 'delete':
#            delete(sql)
        if cmd in func_dic:        #简化优化
            func_dic[cmd](sql)
        else:
            print('command not found')

main()

#函数的嵌套

#1 函数的嵌套调用:在调用一个函数的过程中，又调用其他的函数

#求两个值的最大值
def my_max2(x,y):
if x > y:
return x
else:
return y

#求四个值得最大值
def my_max4(a,b,c,d):
res1=my_max2(a,b)
res2=my_max2(res1,c)
res3=my_max2(res2,d)
return res3

res=my_max4(1,2,3,4)
print(res)

#2 函数的嵌套定义：在定义一个函数内部，又定义了一个函数

#注意调用层级

#名称空间和作用域

名称空间：存放名字与值绑定关系的地方

内置名称空间：

存放的是：内置的名字与值的绑定关系
生效：python解释器启动
失效：Python解释器关闭

全局名称空间

存放的是：文件级别定义的名字与值的绑定
生效：执行python文件时，将该文件级别定义的名字与值的绑定关系存放起来
失效：文件执行完毕

局部名称空间

存放的是：函数内部定义的名字与值的绑定关系
生效：调用函数时，临时生效
失效：函数调用结束

#python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
加载顺序：先内置，再全局，最后局部
查找名字的顺序：先局部，再全局，最后内置

作用域：

全局作用域：包含内置名称空间的名字与全局名称空间的名字

　　全局存活，全局有效

局部作用域：包含局部名称空间的名字

　　临时存活，局部有效

#查看作用域：globals(),locals()
# LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
# locals 是函数内的名字空间，包括局部变量和形参
# enclosing 外部嵌套函数的名字空间（闭包中常见） #f2()上有f1(),下有f3()
# globals 全局变量，函数定义所在模块的名字空间
# builtins 内置模块的名字空间

#global 全局   nonlocal 函数内部一层一层往上找，没有则报错

#注意：作用域关系，在函数定义时，就已经固定了，与调用位置无关

###模拟sql语句（时间不足，不够完善，没有insert的自增功能）###

#coding:utf-8
'''
编写sql命令语句
'''
import os
#定义数据库存放目录
data_dir='C:/Users/lenovo/PycharmProjects/19期/day3/'
#把sql切片，提取命令信息，分发给匹配函数执行， select * from db1.info where id>4 and id<20 limit 3
def sql_parse(sql):
    '''
    把sql语句解析成可执行的语句
    :param sql:
    :return:
    '''
    sql_l=sql.split(' ')
    # print(sql_l)
    sql_dic={
        'select':select_parse,
        'insert':insert_parse,
        'update':update_parse,
        'delete':delete_parse,
    }
    func=sql_l[0]  #取列表的第一个字符串
    res=''
    if func in sql_dic:
        res=sql_dic[func](sql_l)   #执行匹配函数
    # print(res)
    return res

def select_parse(sql_l):
    '''
    把sql定义可查询的语法结构,用handle_parse()解析
    :param sql_l:
    :return:
    '''
    sql_dic={
        'func':select,
        'select':[], #查询字段
        'from':[],   #数据.表
        'where':[],  #过滤条件
        'limit':[],  #limit条件
    }
    return handle_parse(sql_l,sql_dic)

def insert_parse(sql_l):  #insert into db1.info values 39 王朝 24 17000106910 DBA 2017-09-18 18:39:56
    '''
    把sql定义可插入的语法结构,用handle_parse()解析
    :param sql_l:
    :return:
    '''
    sql_dic={
        'func':insert,
        'into':[],
        'values':[],
    }
    return handle_parse(sql_l,sql_dic)

def update_parse(sql_l): #update db1.info set name='alex' where id=21 and name='王朝'
    '''
    把sql定义可更新的语法结构,用handle_parse()解析
    :param sql_l:
    :return:
    '''
    sql_dic={
        'func':update,
        'update':[],
        'set':[],
        'where':[]
    }
    return handle_parse(sql_l,sql_dic)

def delete_parse(sql_l):  #delete from db1.info where id=3
    '''
    把sql定义可删除的语法结构,用handle_parse()解析
    :param sql_l:
    :return:
    '''
    sql_dic={
        'func':delete,
        'from':[],
        'where':[],
    }
    return handle_parse(sql_l,sql_dic)

def handle_parse(sql_l,sql_dic):
    '''
    执行解析操作
    :param sql_l:
    :return:
    '''
    # print(sql_l,sql_dic)
    # print(sql_l.index('select'))
    for k in sql_dic:
        if k not in sql_l:continue
        start_index=int(sql_l.index(k)+1)
        for addindex in range(start_index,len(sql_l)):
            if sql_l[addindex] in sql_dic:break
            sql_dic[k].append(sql_l[addindex])
            # sql_dic['k']=sql_l[int(sql_l.index('k'))+1:int(sql_l.index('from'))]
        # print(sql_dic[k])
    # print(sql_dic)
    return sql_dic

#sql执行函数
def sql_action(sql_dic):
    '''

    :return:
    '''
    sql_dic['func'](sql_dic)

def select(sql_dic):
    filter=''
    limit_filter=''
    count=0
    l=sql_dic['from'][0].split('.')
    # print(l)
    rf=data_dir+'/'.join(l)
    # wf=data_dir+l[0]+'/.swap.bak'
    # print(rf)
    if sql_dic['where']:
        for i in sql_dic['where']:
            filter = filter + i.replace('=', '==') + ' '
        # print(filter)
    if sql_dic['limit']:
        limit_filter = int(sql_dic['limit'][0])
    for i in sql_dic['select']:
        sel_filter = i.split(',')
    with open(rf, 'r', encoding='utf-8') as read_file:
        for line in read_file:
            l=line.split()
            id=int(l[0])
            name=l[1]
            age=int(l[2])
            phone=l[3]
            job=l[4]
            entry_date=l[5]
            entry_time=l[6]
            if filter:
                if eval(filter):
                    if limit_filter:
                        if count==limit_filter:break
                    if sel_filter[0]=='*':
                        print(line)
                        count+=1
                    else:
                        for i in range(len(sel_filter)):
                            print(eval(sel_filter[i]),end=' ')
                        print()
                        count+=1
            else:
                if limit_filter:
                    if count == limit_filter: break
                if sel_filter[0] == '*':
                    print(line)
                    count += 1
                else:
                    for i in range(len(sel_filter)):
                        print(eval(sel_filter[i]),end=' ')
                    print()
                    count += 1



def insert(sql_dic):
    filter=''
    l=sql_dic['into'][0].split('.')
    # print(l)
    rf=data_dir+'/'.join(l)
    add_line=' '.join(sql_dic['values'])+'
'
    with open(rf, 'a', encoding='utf-8') as add_file:
        add_file.write(add_line)

def update(sql_dic):
    filter=''
    l=sql_dic['update'][0].split('.')
    # print(l)
    rf=data_dir+'/'.join(l)
    wf=data_dir+l[0]+'/.swap.bak'
    # print(wf)
    # 'id=21' -->id == 21
    # sql_dic['where']-->int(i[0])==21
    # print(sql_dic['where'])
    if sql_dic['where']:
        for i in sql_dic['where']:
            filter = filter + i.replace('=', '==') + ' '
    # print(filter,type(eval(filter)))
    for i in sql_dic['set']:
        set_filter = i.split('=')
    # print(set_filter,type(set_filter))
    with open(rf, 'r', encoding='utf-8') as read_file,
        open(wf,'w',encoding='utf-8') as write_file:
        for line in read_file:
            l=line.split()
            id=int(l[0])
            name=l[1]
            age=int(l[2])
            phone=l[3]
            job=l[4]
            entry_date=l[5]
            entry_time=l[6]
            if filter:
                if eval(filter):
                    line=line.replace(eval(set_filter[0]),set_filter[1])
                    # print(eval(set_filter[0]),set_filter[1])
                    # print(line)
                write_file.write(line)
            else:
                line = line.replace(eval(set_filter[0]), set_filter[1])
                write_file.write(line)
    os.remove(rf)
    os.rename(wf,rf)

def delete(sql_dic):
    filter=''
    l=sql_dic['from'][0].split('.')
    # print(l)
    rf=data_dir+'/'.join(l)
    wf=data_dir+l[0]+'/.swap.bak'
    if sql_dic['where']:
        for i in sql_dic['where']:
            filter = filter + i.replace('=', '==') + ' '
    with open(rf, 'r', encoding='utf-8') as read_file, 
        open(wf, 'w', encoding='utf-8') as write_file:
        for line in read_file:
            l = line.split()
            id = int(l[0])
            name = l[1]
            age = int(l[2])
            phone = l[3]
            job = l[4]
            entry_date = l[5]
            entry_time = l[6]
            if filter:
                if eval(filter):continue
                write_file.write(line)
            else:
                write_file.write()
    os.remove(rf)
    os.rename(wf, rf)


#主函数
if __name__=='__main__':
    while True:
        sql=input('sql>').strip()
        if sql == 'exit':break
        if not sql:continue
        sql_dic=sql_parse(sql)
        sql_action(sql_dic)
        # select(sql_dic)
        # update(sql_dic)
        # delete(sql_dic)