Python_文件操作编码函数和模块

文件操作

#data=open("yesterday",encoding="utf-8").read()
#print(data)
f = open("yesterday","a",encoding="utf-8") #文件句柄 文件的内存对象
#a = append 追加 不覆盖文件
#"r" "w" "a" "r+" 读追加写都行 读写  "w+" 写读 先创建一个文件在写读  "rb" 二进制文件格式的读写 "wb"
#data = f.read()
#print(data)
f.write("\n我爱北京天安门")
f.close()

f = open("yesterday","r",encoding="utf-8") #文件句柄 文件的内存对象
#print(f.readline()) #读一行 适合小文件读取
#print(f.readlines())
for index,line in enumerate(f.readlines()):
	if index==9:
	print("--------------")
	print(line.strip())
f.close()

# hige bige
count = 0
f = open("yesterday","r",encoding="utf-8") #文件句柄 文件的内存对象
for line in f:   #逐行读取
    if count==9:
        print("____________")
        count+=1    
        continue
    print(line.strip())
    count+=1
f = open("yesterday","r",encoding="utf-8") #文件句柄 文件的内存对象
print(f.tell()) #tell按字符结束
print(f.readline().strip())
print(f.tell())
f.seek(0) #回到某个位置
print(f.readline().strip())
print(f.encoding)
print(f.flush()) #及时存储
f.close()

#文件修改：全部加载到内存汇总进行修改；打开文件修改在写入另一个文件里面
f = open("yesterday","r",encoding="utf-8")
f1 = open("yesterday1","w",encoding="utf-8")
for line in f:
if "肆意的快乐" in line:
line = line.replace("等我享受","等Alex享受")
#print(line)
#line = "有那么多肆意的快乐等Alex享受"
f1.write(line)
f.close()
f1.close()

#with 打开文件，为了避免打开文件后忘记关闭，可以通过管理上下文，即
with open('log','r') as f:
#这种方式，当with代码块执行完毕后，内部会自动关闭并释放文件资源

编码和转码

函数
函数结构：def 函数名（参数）：
在函数中可使用return语句将值返回到调用函数的代码行
在函数中对列表做的任何修改都是永久的，若要禁止函数修改列表可使用function_name(list_name[:])

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

#一个函数定义会在当前符号表内引入函数名。 函数名指代的值（即函数体）有一个被 Python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字（即变量名），然后它也可以被当做函 数使用。 这可以作为通用的重命名机制

#函数
def func1():
	print("in the func1")
	return 0
#过程
def func2():
	print("in the func2")

def func3():
	print("in the func3")
	return 1,"Hello",["sdf"]
def test(x,y): #形参和实参 位置关系
	print(x,y)
x = func1()
y = func2() #python中过程也给了一个返回值none
[z1,z2,z3] = func3()
print(x)
print(y)
print(z2)
test(1,2) #位置参数调用：与形参一一对应
test(y=50,x=25) #关键字调用：与形参顺序无关 关键参数不能写在位置参数的前面

def func(x,y=2): #默认参数
print(x)
print(y)
func(1)
func(1,4)
#特点：调用参数非必须
#用途：默认安装值；连接数据库端口号

def test(*args): #参数组* 参数不固定 转换成元组的方式
#*args:接受n位置参数，转换成元组的形式
	print(args)
test(1,2,3,4,5,6)
test(*[1,2,3,4,5,6])
#**args：接受n个关键字参数，转换成字典的方式
def test2(**args): #传字典
	print(args)
test2(name="Alex",age=8,sex="F")
test2(**{"name":"Alex","age":8})

school = "Oldboy"

def change_name(name):
	global school #申明局部修改全局变量 不应该修改
	school = "USTC"
	print("Before change",name,school)
	name = "Alex" #这个函数就是这个变量的作用域
	print("after name",name)

name = "alex"
change_name(name)
print(name)
print(school)

#将函数存储在模块中
#导入整个模块
import pizza      
pizza.make_pizza()
#导入特定的函数
from pizza import make_pizza
make_pizza()
#使用as给函数起名字
from pizza import make_pizza as mp
mp()
#使用as给模块起名字
import pizza as p
p.make_pizza()

只有字符串和单独的整数这种是不能再函数的修改，列表 字典 集合 类等都是可以在函数中进行修改的
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归特性：

1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

def add(a,b,f):
	return f(a)+f(b)
res = add(-6,3,abs)
print((res))

装饰器：本质是函数，功能是装饰其他函数，就是为其他函数添加附加功能
原则：1.不能修改被装饰函数的源代码。2.不能修改被装饰函数的调用方式。
实现装饰器的知识储备：1.函数即“变量”2.高阶函数3.嵌套函数
高阶函数+嵌套函数=装饰器
内存存储机制

高阶函数：
1.把一个函数名当做实参传给另一个函数（在不修改被装饰函数源代码的情况下为其添加功能）
2.返回值中包含函数名（不修改函数的调用方式）



终极装饰器 无参数 有参数 装饰器本身带参数的

# Author:Richard
import time
user,passwd = "alex","123456"
def auth(auth_type):
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
            if auth_type == "loacl":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user==username and passwd==password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    return func(*args,**kwargs)
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type=="LDAP":
                print("现在头晕了  基本GG了")
        return wrapper
    return outer_wrapper
def index():
    print("Welcome to index page")
@auth(auth_type = "loacl")  #home = wrapper()
def home():
    print("Welcome to home page")
    return "from home!!!"
@auth(auth_type = "LDAP")
def bbs():
    print("Welcome to bbs page")
index()
home()
bbs()

生成器只有在调用时才会生成相应的数据，只记录当前的位置，只有一个__next__()方法

z=(i*2 for i in range(10))
print(z.__next__())
print(z.__next__())
print(z.__next__())

生成器一定是迭代器
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用iter（）获得一个迭代对象
b=iter(a)
模块
模块就是库，一个标准库（软件自带） 一个第三方库（下载安装）
系统有环境变量 python也有环境变量：
python的第三方库一般都在site-packages，标准库一般在lib里面
找模块默认在当前目录找，找不到再去其他目录去找
1.定义：
模块：用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能）本质就是.py结尾的python文件（文件名：test.py 对应模块的名字：test）
包：从逻辑上用来组织模块的，本质是一个文件夹或者目录，必须带有一个__init__.py文件
2.导入方法：
import module_name
import modelu1 导入模块
import module_name1,module_name2,module_name3
from modelu1 import * #导入所有的函数不用 吧modelu1所有文件在当前位置运行一下
from modelu1 import test1 as t #导入某个具体的
t()
3.import本质（路径搜索和搜索路径）：
导入模块的本质就是把python文件执行一遍
import module_name------>module_name.py文件一定要有路径------>module_name.py 路径------>sys.path
导入包的本质是解释包下面的__init__.py文件
4.模块分类：
a:标准库 内存模块
b:开源模块 Github里面有的
c:自定义模块

import module_alex
#module_alex = all code;
from mosule_alex import name
#name = "alex"  name变量拿到当前位置执行一遍
from . import test #导入当前目录所有的包

import packages
packages.test1()
packages.test.test()

from . import test #导入当前目录所有的包
print("Welcome to Init")
def test1():
	print('this is in the init test')

标准库
time和datetime

print(time.localtime())
print(help(time))
x = time.localtime()
print(x)
print(x.tm_year)
print(x.tm_yday)
help(x)

print(time.gmtime())
print(time.localtime(456354)) #时间戳转换成元组 一个UTC 一个UTC-8（本地情况）
print(time.time()) #获得当前时间戳
x = time.localtime()
xx1 = time.strftime("%Y-%m-%d %H:%M:%S",x)
print(xx1)
xx2 = time.strptime(xx1,"%Y-%m-%d %H:%M:%S")
print(xx2) 
print(time.ctime())  

#datetime模块
print(datetime.datetime.now()) #获取当前时间

random模块

import random
print(random.random()) #随机0-1浮点数
print(random.randint(1,3)) #随机1-3的整数
print(random.choice('asdhaskjdh')) #列表 字符串（序列类型）当中随机取值
a = [1,2,3,4,5,6]
print(a,random.shuffle(a))

os模块

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd  os.chdir(r"目录名")
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

shutil模块_高级的文件 文件夹 压缩包 处理模块

import shutil
f1 = open("123",encoding="utf-8")
f2 = open('321','w',encoding='utf-8')
shutil.copyfileobj(f1,f2) #用来赋值文件
f1.close()
f2.close()
shutil.copyfile("123",'111') #直接复制文件
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
shutil.make_archive('shutil_archive_test','zip',r'G:\程序使用练习\Python\Practice\untitled1\day5') #压缩文件

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
json模块
json，用于字符串 和 python数据类型间进行转换 将python中数据类型转成字符串，dumps 其他程序调用字典数据load即可
模块json让你能够将简单的python数据结构转存到文件中，并在程序运行再次运行的时候加载该文件中的数据 dump存储 load加载

import json
numbers = [1,2,3,4,5,6,7,8,9]
filename = 'numbers.json'
with open(filename,'w') as f_boj:
	json.dump(numbers,f_obj)

with open(filename,'w') as f_boj:
	numbers = json.load(f_obj)

不同语言之前的数据调换
pickle，用于python特有的类型 和 python的数据类型间进行转换 支持python之间所有格式的转换
shelve模块

import shelve

d = shelve.open('shelve_test') # 打开一个文件


class Test(object):
	def __init__(self, n):
	self.n = n


t = Test(123)
t2 = Test(123334)

name = ["alex", "rain", "test"]
d["test"] = name # 持久化列表
d["t1"] = t # 持久化类
d["t2"] = t2

d.close()

d = shelve.open('shelve_test')
print(d.get("test"))

re模块_正则表达式

print(re.match('^aa\d+',"aa123sdasd5465")) #前面匹配条件 后面字符串
#正则表达式 动态模糊匹配相关的字符串
#复杂在变化条件 了解常用的即可
import re
#print(re.match('^aa\d+',"aa123sdasd5465")) #前面匹配条件 后面字符串
x = re.match('^aa\d+',"aa123sdasd5465")
print(x.group())
############################
'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符结尾，同$
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

sys模块

import sys
print(sys.path) #打印环境变量
print(sys.argv) #打印相对路径