python第三天

一、#文件处理

#打开
# f=open('a.txt',mode='r',encoding='utf-8')
# #读、写
# data=f.read()
# print(data)
# #关闭：
# # print(f)
# del f#回收的是python的资源
# f.close()#回收的是操作系统的
# print(f)
# f.read()
#流程分析
#1、向操作系统发起系统调用
#2、操作系统打开这个文件，返回一个文件句柄给应用程序
#3、在应用程序中把文件句柄赋值给一个变量


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


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

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

二、#文件的打开模式

# #r模式是默认的打开模式，只读，文件不存在则报错
# f=open('a.txt',encoding='utf-8')
# # print('>>>',f.read())
# # print('>>',f.read())#由于第一次执行光标会移到最后一行，所以执行第二次的时候就没有内容了
# # print(f.readline(),end='')#一次读一行的内容，加end=‘’是为了去掉换行符
# # print(f.readline())
# # print(f.readlines())#一次读所有，结果放入列表中
# f.close()


#w只写模式:如果文件存在则清空，如果不存在则新建，不可读
# f=open('b.txt',mode='w',encoding='utf-8')
# # f.write('111111
')
# # f.write('2222222
')
# # f.write('333333
')
# l=['4444
','5555
','66666
']
# # for line in l:
# #     f.write(line)
# f.writelines(['444
','5555
','66666
'])#可以直接把列表传进去
# f.close()

#a，追加写模式,不存在则新建,存在则在文件原有基础上追加
# f=open('b.txt','a',encoding='utf-8')
# f.write('aaa
')
# f.writelines(['444
','5555
','66666
'])

#遍历文件
# with open('a.txt',mode='r',encoding='utf-8') as f:
#不推荐使用
#       # lines=f.readlines()
#       # for line in lines:
#       #  print(line,end='')
#推荐使用
#  for line in f:
#      print(line,end='')

#b:以bytes的形式去操控文件内容
# with open('a.txt',mode='rb') as f:
#    data=f.read()
#    print(data.decode('utf-8'))

# with open('d.txt', mode='wb') as f:
#     f.write('哈哈哈'.encode('utf-8'))

三#文件操作的其他方法

#以文本的格式读，n代表的是字符个数
# with open('a.txt','r',encoding='utf-8') as f:
#     data=f.read(3)
#     print(data)
#以b的格式读，n代表的是字节个数
# with open('a.txt','rb',) as f:
#     data=f.read(3)
#     print(data.decode('utf-8'))


#tell:告诉你当前光标的位置
# with open('a.txt','r',encoding='utf-8') as f:
#     data=f.read()
#     print(f.tell())
#     print(data)
#seek
#读两次文件内容
# with open('a.txt','r',encoding='utf-8') as f:
#     data1=f.read()
#     print(data1)
#     print(f.tell())
#     # f.seek(0)#把光标移到最开始的位置
#     data2=f.read()
#     print(data2)
#0:文件开头1：当前位置2：文件末尾
with open('a.txt','rb') as f:
    f.read(1)
    f.seek(5,1)
    # print(f.read())
    print(f.read().decode('utf-8'))

# with open('access.log','a') as f:
#     f.write('aaaaa
')

#truncate
# with open('a.txt','a',encoding='utf-8') as f:
#     f.truncate(3)

四、#文件修改

#把硬盘的数据全部读入内存，在内存中修改，最后保存
# import os
# with open('e.txt','r',encoding='utf-8') as read_f,
#         open('.e.txt','w',encoding='utf-8') as write_f:
#     data=read_f.read()
#     data=data.replace('alex','sb')
#     write_f.write(data)
# os.remove('e.txt')
# os.rename('.e.txt','e.txt')
#方式二：一行一行的读，一行一行的改
# import os
# with open('e.txt','r',encoding='utf-8') as read_f,
#         open('.e.txt','w',encoding='utf-8') as write_f:
#     for line in read_f:
#         line=line.replace('alex','sb')
#         write_f.write(line)
# os.remove('e.txt')
# os.rename('.e.txt','e.txt')

五、#用文件当做数据库

# with open('db.txt','r',encoding='utf-8') as f:
#     for line in f:
#         use_l=line.split(',')
#         print(use_l[1],int(use_l[2]))
六#为何要用函数

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

具备某一功能的工具即函数
函数的使用必须遵循：先定义，后使用
'''
#函数分类：
# 1、内置函数：python解释器自带函数，python解释器启动就会定义好这些函数
# len()
# max()
# min()
# sum()
#2、自定义函数
#语法
# def 函数名（参数1，参数2，...)
# #....注释.....
#      函数体
#      return 返回值
#定义阶段
# def tell_tag():
#     print('======')
# def tell_msg(msg):
#     print(msg)
# #调用阶段
# tell_tag()
# tell_msg('hello world')
# tell_tag()

七#函数定义阶段

# #函数定义阶段：只检测语法，不执行代码
# def ful():
#     print('aaaaa')
#     xxxxx
#     bbbbb
#     ccccc
#
# ful()
八#先定义后使用

#1、函数的使用必须遵循先定义后使用
# 2、函数的定义就想当于定义一个变量，如果没有定义就直接使用，就相当于在引用一个不存在的变量名
# #定义阶段
# def foo():
#     print('hello')
#     bar()#NameError: name 'bar' is not defined，定义的时候没有语法错误不会报错
# #调用阶段
# foo()
#定义阶段
# 
# def foo():
#     print('hello')
#     bar()
# def bar():
#     print('world')
# 
# #调用阶段
# foo()

九#定义函数的三种形式

# #1、无参函数
# 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 success')
#         else:
#             print('login erro')
# #2、有参函数：函数体的代码，需要外部传入的值
# def auth(user,pwd):
#     if user == 'egon' 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)





# #3、空函数
# def select():
#     '''
#     查询功能
#     :param sql:格式化后的sql
#     :return:
#     '''
#     pass
# def update():
#     pass
# def insert():
#     pass
# def delete():
#     pass
十#调用函数

#1、调用函数：函数名（），
#需要注意：先通过名字找到函数的内存地址，然后加括号调用
#2、函数的返回值return
#函数在调用函数的过程中一旦执行到return，就会立刻种植函数，并且把return后的结果当做本次调用的返回值
#函数体内可以有多个return，但是只能执行一次
# def foo():
#     print('111')
#     return 1
#     print('2222')
#     return 2
#     print('3333')
#     return 3
# res=foo()
# print(res)
#注意的第二点
#返回的值可以是任意类型
# def foo():
#     return [1,2,3]
# res=foo()
# print(type(res))
#注意的第三点
#没有return，默认返回None
#可以返回一个值===>>值
#可以用逗号分隔，返回多个值===>>tuple
# def foo():
#     return 1,2,3,[1,2],{1,2,3}
# res=foo()
# print(res,type(res))

# #3调用函数的三种形式
# def foo():
#     print('123')
#     return 456
# #第一种
# # foo()#没有返回值
# #第二种：有返回值
# # res=foo()
# # print(res)
# 
# 
# #第三种:把函数的返回值放到一个表达式中
# res=foo()*10
# print(res)
十一#函数参数

#形参：在定义函数时，括号内的参数称为形参
#特点：形参是变量名
# def foo(x,y):
#     print(x)
#     print(y)
#实参：在调用函数时，括号内的参数称为实参
#特点：实参是变量值
# foo(1,2)
#在调用阶段实参才会绑定形参，调用结束后解除绑定

#参数的分类
#位置参数:按照从左往右的顺序依次定义的参数
#位置形参：必须被传值，多一个不行，少一个不行
#位置实参：与形参按照位置一一对应
#关键字实参：值得是按照key=value的形式，指名道姓的给x传值
# def foo(x,y):
#     print(x)
#     print(y)
# foo(y='egon',x=2)
#关键字实参需要注意的问题：
# 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',age=18,sex='male')

#问题一:语法规定位置实参必须在关键字实参的前面
# foo('egon',sex='male',age=18)
#问题二：一定不要对同一个形参传多次值
# foo('egon',sex='male',age=18,name='egon1')

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

# def register(name,age,sex='male'):
#     print(name,age,sex)
# register('egon',18)
# register('ws',19,'female')

# x='male'
# def register(name,age,sex=x):
#     print(name,age,sex)
# register('egon',18)
# register('ws',19,'female')

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


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

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

# def foo(x,y,z):
#     print(x,y,z)
# dic={'x':1,'y':9,'z':2}
# foo(**dic)

# def home(name,age,sex):
#     print('from home====>>',name,age,sex)
#
# def wrapper(*args,**kwargs):#args=(1,2,3,4,5,6,7),kwargs={'c':3,'b':2,'a':1}
#      home(*args,**kwargs)
# # wrapper(1,2,3,4,5,6,7,a=1,b=2,c=3)
# wrapper('egon',sex='male',age=19)
##命名关键字参数:形参中，在*后定义的参数称之为命名关键字参数
#它的特性是：传值是，必须按照关键字实参的形式传值
# def foo(x,y,*,a,b):
#     print(x,y,a,b)
# foo(1,2,b=3,a=4)

#位置参数，默认参数，*args,命名关键字参数，**kwargs
十二#函数对象

#1、函数是第一类对象：函数可以当做数据来使用
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,foo)
#可以当做容器类型的一个元素
# data_dir='usr/local/mysql/data'
# def update(sql):
#     print('update功能: ',sql)
# def delete(sql):
#     print('delete功能: ', sql)
# def select(sql):
#     print('select功能: ', sql)
# def insert(sql):
#     print('insert功能: ', sql)
# def alter(sql):
#     print('alter功能：',sql)
# func_dir={
#     'select':select,
#     'insert':insert,
#     'update':update,
#     'delete':delete,
#     'alter':alter
# }
# def main():
#     while True:
#         inp=input(">>: ").strip()
#         if not inp:continue
#         sql=inp.split()
#         cmd=sql[0]
#         # if cmd == 'slect':
#         #     select(sql)
#         # elif cmd =='update':
#         #     update(sql)
#         # elif cmd =='insert':
#         #     insert(sql)
#         # elif cmd =='delete':
#         #     delete(sql)
#         if cmd in func_dir:
#            func_dir[cmd](sql)
#         else:
#             print('command not find')
# main()
十三#名称空间与作用域

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


内置名称空间：
    存放的是：内置的名字与值的绑定关系
    生效：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()