一、#文件处理
#打开
# 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\n')
# # f.write('2222222\n')
# # f.write('333333\n')
# l=['4444\n','5555\n','66666\n']
# # for line in l:
# # f.write(line)
# f.writelines(['444\n','5555\n','66666\n'])#可以直接把列表传进去
# f.close()
#a，追加写模式,不存在则新建,存在则在文件原有基础上追加
# f=open('b.txt','a',encoding='utf-8')
# f.write('aaa\n')
# f.writelines(['444\n','5555\n','66666\n'])
#遍历文件
# 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\n')
#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()
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
