文件处理，函数

文件打开的模式

#！/usr/bin/env python
# Author:hongjie.gao

# r模式是默认的模式。只读，文件不存在则报错
# f=open('a.txt',encoding='utf-8')            # 默认以读的方式打开
# print(f.read())
# f.write('11111 ')          # 不可写
#  print('====>',f.read())       # 读所有,读出来bytes类型，open函数把bytes类型decode（'utf-8'）=====>str
#  print('====>',f.read())

# print(f.readlines())        #读所有，结果放入列表中

# print(f.readline(),end='')       # 一次读一行
# print(f.readline(),end='')

# f.close()


# W:只写模式，如果文件存在则清空，如果文件不存在则新建
# f=open('a.txt',mode='w',encoding='utf-8')
# f=open('b.txt',mode='w',encoding='utf-8')
# print(f.read())
# print(f.write('1111 '))   # 一定要自己加换行符
# print(f.write('2222 '))     #unicode----encode--->bytes
# print(f.write('3333 '))

# l=['44444 ','55555 ','66666 ']
# for line in l:
#     f.write(line)
# print(f.writelines(['44444 ','55555 ','66666 ','777777 ']))
#
# print(f.writable())     # 是不是可写
# f.close()

# a:追加写模式(日志)：如果文件存在则把光标移动到文件末尾，如果文件不存在则新建
# f=open('c.txt','a',encoding='utf-8')
# f.write('3333333 ')
# f.writelines(['555555 ','666666 '])
# f.close()


# with open('a.txt',encoding='utf-8') as f:
#     # # lines=f.readlines()
#     # # for line in lines:
#     # #     print(line,end='')
#     #
#     # for line in f:
#     #     print(line,end='')

#
# with open('a.txt',mode='rt',encoding='utf-8') as f:
#     for line in f:
#         print(type(line),end='')

# with open('nb.png',mode='rt',encoding='utf-8') as f:
#     pass

# b：以bytes的形式去操作文件内容,不转码,不能指定编码
# with open('nb.png',mode='rb',encoding='utf-8') as f:  #不能带字符编码
#     f.read()

# with open('nb.png',mode='rb') as f:
#     print(f.read())

# with open('a.txt',mode='rb') as f:
#     data=f.read()
#     print(data.decode('utf-8'))

# with open('d.txt','wb') as f:
#     f.write('哈哈哈哈哈hello'.encode('utf-8'))
#
# with open('d.txt','ab') as f:
#     f.write('h哈哈哈哈哈hell '.encode('utf-8'))
#


# 了解部分：
# print(f.readable())     # 是不是可读的
# print(f.writable())

文件操作

#！/usr/bin/env python
# Author:hongjie.gao
encoding='utf-8'

# 打开
f=open('a.txt',mode='r',encoding='utf-8')
# 读/写
# data=f.read()
# print(data)
# 关闭
# print(f)
# del f   #回收python资源（自动回收）
# f.close()             #回收操作系统的资源


# 流程分析：
# 1.向操作系统发起系统调用
# 2.操作系统打开这个文件，返回一个文件句柄给应用程序
# 3.在应用程序中把文件句柄赋值给一个变量

# 注意两点
# 1.打开一个文件对应两部分，一个是python级别的文件句柄，另外一个是操作系统打开的文件（默认打开文件的编码是以操作系统的
# 编码为准，除非open（）指定encoding='编码'）
# 2.当文件操作完毕后，应该回收两部分资源
# del f  回收应用程序资源（python解释器自动的垃圾回收机制已经替我们做了）
# f.close  回收操作系统资源




# 上下文管理
with open('a.txt',mode='r',encoding='utf-8') as f:
    print(f.read())

补充---bool值

#！/usr/bin/env python
# Author:hongjie.gao
# bool值，所有的 数据类型都自带布尔值
# 布尔值为假的情况：0，空，None

# 数字类型，当x=0时为假
#
# x=1
# print(bool(x))
#
# if x:
#     print('ok')

# 列表类型：当列表为空时为假（空字符串，空元组，空字典，空集合）
x=[]
print(bool(x))

为何要定义函数

#！/usr/bin/env python
# Author:hongjie.gao

# 组织结构混乱，可读性差
# 代码冗余
# 无法统一管理，维护难度极大

# 具备某一功能的工具即函数

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

# 函数分类：
# 1：内置函数：python解释器自带的函数，python解释器启动就会定义好这些函数
# len()
# max()
# min()
# sum()
 # 2：自定义函数
 # 语法：
 # def 函数名(参数1,参数2,...):
 #     """注释"""
 #     函数体
 #     return 返回值

#  实现以下功能
'''
==========
==========
hello word
==========
==========
'''
# 定义阶段
def tell_tag():
    print('==========')

def tell_msg(msg):
    print(msg)
#调用阶段
tell_tag()
tell_tag()
tell_msg('hello word')
tell_tag()
tell_tag()
定义函数的三种模式

#！/usr/bin/env python
# Author:hongjie.gao
# # 定义无参函数
# def main():
#     while True:
#         user=input('>>:').strip()
#         # if len(user)==0:continue
#         if not user:continue
#         password=input('>>:')
#         res = auth(user,password)
#         if res:
#             print('login successful')
#         else:
#             print('login err')



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

# def auth(user,pwd):
#     if user == 'egen' and pwd == '123':
#         return True
#     else:
#         return False
# main()



        # def   my_max(x,y):
#     if x > y:
#         return x
#     else:
#         return y
# res=my_max(1,3)
# print(res)
#


# 空函数

def foo(user,pwd):
    pass

函数定义阶段干了什么

#！/usr/bin/env python
# Author:hongjie.gao

# 函数在定义阶段只检测语法，不执行代码
# def func():
#     print('aaaaa')
#     xxxxxx
#     yyyyyyy
#     zzzz
#     dadada
    # if
    # print('dadadadad')

print(func)  # 不报错（查看函数在内存地址的位置）
func()      # 会报错

先定义后使用

#！/usr/bin/env python
# Author:hongjie.gao

# 1.函数的使用必须遵循先定义，后调用
# 2.函数的定义，就相当于在定义一个变量，如果没有定义而直接调用，就相当于在引用一个不存在的变量名

# 定义阶段
# def foo():
#     print('from foo')
#     bar()   # 不报错
# # 调用阶段
# foo()           # 包错
#

# 1.不报错
# 定义阶段
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
# 调用阶段
foo()

# 2.不报错
# 定义阶段
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
# 调用阶段
foo()

调用函数

#！/usr/bin/env python
# Author:hongjie.gao

# 1.调用函数 ：函数名（）
# 需要注意：先通过名字找到函数的内存地址，然后加（）调用




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

# def foo():
#     print('1111')
#     return 1
#     # print('2222')
#     # return 2
#     # print('33333')
#     # return 3
# res=foo()
# print('函数调用完毕：',res)

# 注意第二点
# 返回的值可以是任意类型
# def foo():
#     return [1,2,3]
# res=foo()
# print('函数调用完毕：',type(res))

# 注意第三点：
#没有return,pyrhon会默认返回None
# def foo():
#     pass
# res=foo()
# print('函数调用完毕：',res,type(res))
# 可以返回一个值======》值
# 可以用逗号分隔，返回多个值====》tuple
# def foo():
#     return 1,2,[],{'a':1}
# res=foo()
# print('函数调用完毕：',res,type(res))



# 3.调用函数的三种形式
def foo():
    print('from foo')
    return 123

#
# foo()

#
# res=foo()
# print(res)

#
res=foo()*10
print(res)

 

函数的参数

#！/usr/bin/env python
# Author:hongjie.gao

# 形参：在定义函数时，括号内的参数称为形参
# 特点：形参就是变量名
# def foo(x,y):
#     print(x)
#     print(y)


# 实参：在调用函数时，括号内的参数称为实参
# 特点：实参就是变量值

# 在调用阶段实参（变量值）才会绑定到形参（变量名）
# 调用结束后解除绑定



# 参数的分类
# 位置参数：按照从左到右的顺序依次定义的参数
         #位置形参：必须被传值，并且多一个不行，少一个不行
#       # 位置实参：与形参按照位置一一对应
# def foo(x, y):
#     print(x)
#     print(y)
#
# foo('egon',1)
#

# 关键字实参  ：指的是按照name=value的形式，指名道姓的给name传值
# def foo(name, age):
#     print(name)
#     print(age)
#
# foo(age=18,name='egon')
# 关键字实参需要注意的问题是：
# def foo(name, age,sex):
#     print(name)
#     print(age)
#     print(sex)
#
# foo('egon',18,'male')
# print('=======>')
# foo(age=18,name='egon',sex='male')
# print('======>')
# foo('egon',sex='male',age=18)
# w问题一：语法规定：位置实参必须在关键字实参前面



# 三：默认参数：在定义函数阶段，已经为形参赋值了，在定义阶段已经赋值，意味着在调用阶段可以不传值
# 注意的问题：
#       1.默认参数的值，只在定义时赋值一次
#       2.位置形参应该在默认参数的前面
#       3.默认参数的值应该是不可变类型
# def foo (x,y=10):
#     print(x,y)
# foo(1)
# foo(x=1)
# foo(1,y=11)

# def register (name,age,sex='male'):
#     print(name,age,sex)
#
# register('egon',18)
# register('wsb',20)
# register('alex',38,None)

'''
四：可变长参数：
实参的可变长度指的是：实参值得个数是不固定
而实参的定义形式无非两种：1.位置实参 2.关键字实参
针对这两种形式的实参个数不固定，相应的，形参也要有两种解决方案
*
**
'''
# 针对按照位置定义的溢出的那部分实参，形参用：*args
# def func(x,y,z,*args):   #args=(4,5,6)
#     print(x,y,z)
#     print(args)
# func(1,2,3)
# func(1,2,3,4,5,6)
# func(1,2,3,*[4,5,6])  #func(1,2,3,4,5,6)
# func(*[1,2,3,4,5,6])     #func(1,2,3,4,5,6)

# def func(x,y,z):
#     print(x,y,z)
#
# l=[1,2,3]
# func(*l)

# # 针对按照关键字定义的溢出的那部分实参，形参用：**kwargs
# def foo(x,y,**kwargs):      # kwargs={'z': 11, 'a': 21, 'b': 90}
#     print(x,y)
#     print(kwargs)
# foo(y=2,x=1,z=11,a=21,b=90)

# def foo(a,b,*args,**kwargs):
#     print(a,b)
#     print(args)
#     print(kwargs)
# # foo(1,2,3,x=22,y=33)
#
# foo(1,2,*[3],**{'x':22,'y':33})   #foo(1,2,3,x=22,y=33)

# def home(name,age,sex):
#     print(name,age,sex)
#
#
# def wrapper(*args,**kwargs):
#     print(args)
#     print(kwargs)
#
# wrapper(1,2,3,4,a=1,b=2)



# 命名关键字参数（了解），
# 形参在*后定义的参数称之为命名关键字参数
# 它的特性是：传值时必须按照关键字实参的形式传值
def foo(a,b,*,x,y):
    print(a,b,x,y)
foo(1,2,x=3,y=4)


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

 

函数的对象

#函数是第一类对象：函数可以当做数据来使用
def foo():
    print('from foo')

#可以被引用
# f=foo
# # print(f)
# f()

#可以当做参数传入一个函数
# def wrapper(x):
#     # print(x)
#     x()
# wrapper(foo)



#可以当做函数的返回值
# def wrapper():
#     return foo
#
# f=wrapper()
# print(f is foo)

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

# l=[foo,1,2]
# l[0]()

data_dir='/usr/local/mysql/data'
def select(sql):
    print('select功能: ',sql)

def insert(sql):
    print('insert功能: ', sql)

def update(sql):
    print('update功能: ', sql)

def delete(sql):
    print('delete功能: ', sql)

def alter(sql):
    print('alter功能：',sql)

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 函数的嵌套定义：在定义一个函数内部，又定义了一个函数
def f1():
    def f2():
        def f3():
            print('from f3')
        f3()
    x=1
    f2()
    print(x)
f1()

# f2()
# print(x)

 

名称空间和作用域

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


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

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

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

加载顺序：先内置，再全局，最后局部
查找名字的顺序：先局部，再全局，最后内置

'''

# x=10
# if x > 3:
#     y=2
#
# def foo(a,b): #a='aaaa' b='bbbb'
#     m=11111
#     n=2222
#     def bar():pass
#
# foo('aaaa','bbbb')


# max=10
# def f1():
#     max='f1'
#     def f2():
#         max='f2'
#         print(max)
#     f2()
#
# # f1()
# print(max)


'''
作用域：
全局作用域：包含内置名称空间的名字与全局名称空间的名字
            全局存活，全局有效

局部作用域：包含局部名称空间的名字
            临时存活，局部有效

'''



#
# x=1011111111111111111111111111111111111111111
# def f1(a):
#     y='fffffffffffffffffffffffffffffff1'
#     print(locals())
#     print(globals())


# print(globals())
# print(dir(globals()['__builtins__']))

# print(locals() is globals())


# f1(12321312312312312312312312312312312312313213)




#作用域关系，在函数定义时，就已经固定了，与调用位置无关
# x=10000000000000000000000000
# def f1():
#     def f2():
#         # x='123123123123123123123123123123123'
#         print(x)
#     return f2
#
# f=f1()
#
# # print(f)
#
#
# def func():
#     x=123
#     f()
# x='hello'
# func()





#global nonlocal
# x=1
# def f1():
#     global x
#     x=10
# f1()
# print(x)



x=1
def f1():
    x=2
    def f2():
        nonlocal x
        x=111111
    f2()
    print(x)

f1()