学习笔记

文件操作相关

文件的读取和写入

方法一：f =open('文件名','打开方法',encoding='编码')
方法二: with open('文件名','打开方法',encoding='编码') as f:

打开方式有：

'r'只读、'w'只写、'r+'读写、'w+'写读、'a'追加、'ab'二进制文件追加、'rb'二进制文件读取、'wb'二进制文件写入、

读取方法'r'，只读不能写入和追加，'rb'与'r'一样，但是读取的是二进制文件，'r+'常用，读写操作，读取后可写入。
写入方法'w'，只写不能读取和追加，'wb'与'w'一样，但是写入的是二进制文件，'w+'不常用，写读操作，写入后可读取。
读取方法'a'，文件的追加，'ab'与'a'一样，但是追加的是二进制文件。

读取及写入的函数：

read()函数，一次性读取文件对象的内容到变量，读取的内容还是字符串型。
readline()函数，读取整行，每次读取文件中一整行内容，包括'\n'，字符串型。
readlines()函数，读取所有行，读取时为列表，也可设置读取的文件大小，分批读取。
write()函数，一次性写入文件，写入时必须为字符串型。
writelines()函数,多行写入，写入数据可以为列表数据也可为字符串数据。

其他文件操作的方法：

close()函数，关闭文件，关闭后不能对文件读写。
flush()函数，刷新内存，主动控制缓存写入文件操作。
seek()函数，文件指针，设置文件中指针的位置
tell()函数，返回文件指针在文件中的位置。
truncate()函数，截取当前位置以后的字节数的字符串，如果不设置为文件尾。

通常对文件增删改查时，可使用'w'创建一个文件，用'r+'对文件读取后进行修改，使用seek()函数对文件的指针进行设定，使用truncata()函数对文件进行截取。通过write或writelines函数把缓存中的文件写入目标文件。

函数相关

定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需调用其函数名即可。

函数的参数：

形参：建立函数时所设置的参数名
实参：调用函数时传入对应形参的参数为实参
位置参数：按照顺序传入的参数，为位置参数。
默认参数：不特殊给定参数值时，有默认的参数值。
关键参数：指定参数值要传给的特定的参数
非固定参数：args,*kwargs 用星号和双星号表示的参数，可以传入多个参数。

函数的返回值：return 函数在没有制定返回值时，返回None，return在函数中为结束(终止)所以，在函数中return后面的语句将不会被执行。函数的返回值，永远且永久都只返回一个值，如果加'，'逗号，返回多个值的话，返回的结果为元组。

匿名函数：lambda 不能进行复杂运算，最多只能进行三元运算。

高阶函数：1，接受一个或多个函数作为输入。2，return 返回另外一个函数

函数递归：在函数中调用函数本身，形成递归函数，递归函数在条件结束时，逐层返回，执行被调用函数后未执行的语句。

内置函数

abs()求绝对值
dict()数据转成字典
help()帮助
min()取最小值
max()取最大值
all()判断是否为全部为真，0，空，false为假，其余为真。
bool()判断布尔型。
any()判断列表中只要有一个为真就为真。
dir()打印现在正在运行的所有变量
hex()十六进制将数字转换成16进制表示。
slice()定制切片规则
divmod()整除，得到整数和余数。
sorted()对所有可迭代的对象进行排序操作。
ascii()返回一个表示对象的字符串。
eval()把字符串转成代码，只能处理单行，但有返回值！
exec()把字符串转成代码，可处理多行，但没有返回值。
ord()将字符串转成ASCII码对应的字母表位置
chr()将数字转换成对应的ASCII码表内对应的字符。
sum()求和
bytearray()将字符编码转换成bytes型，达到对字符串中单个元素进行修改的目的。先要将不能修改的字符串转换成编码类型，然后再进行bytes转换，转换后对内容进行修改。修改后，在用encode解码，转回字符串。
map()根据提供的函数对指定的序列做映射，‘三剑客’之一
filter()根据提供的函数，过滤掉不符合的元素，将符合的生成一个新的列表。
reduce()根据提供的函数，进行累积操作。
print()打印输出
callable()判断能否被调用
frozenset()冻结集合
vars()返回对象属性值和属性值的字典对象。
locals()函数内部执行，返回函数内部局部变量的值，就是本地作用域中的变量。
globals()返回全局变量，无论在什么作用域内。
repr()函数将对象转化为解释器能读取的形式。
zip()将可迭代对象作为参数，按位对应合并成元组，对没有对应上的元素删除。
round()返回浮点数，四舍五入，可设置小数点后位数。
set()创建无序的元素集合，不重复的元素的集合

闭包

闭包就是外部调用函数内部函数，并且函数内部函数调用函数内部的值。

例如:
def cb(num):
    n = n + 1
    def cb2(num)
        print(n+num)
    return cb2

f = cb(2)
f(5)
结果：
8

装饰器

在符合“开放”-“封闭”原则的前提下，给代码加新功能。

自己总结结构模式：
def login(auth_type):
    #auth_type为装饰器带入的参数
    def outer(func):
        #装饰器外层，将被装饰的函数名带入
        def inner(*args,**kwargs):
            #需要装饰的内容
            return func(*args,**kwargs)
        return inner
    return outer

@login(装饰器参数)
def func():#需要装饰的函数
    #函数内部内容

func(*args,**kwargs) #函数的调用。

列表生成式

用一条语句完成列表的循环生成式。

公式：变量 = 【公式 for 变量 in 可迭代对象】

生成器 generator

简单的生成器，就需要将列表生成式的中括号，变成小括号'()'即可。生成器，生成后就是一个算法，是惰性的，只有当调用的时候才会返回值，用NEXT()函数来产生返回值，但当生成器结束时会报错，这时可以用for循环，结束时不会报错。while循环也会报错。

yield

可以将复杂的函数变成生成器，当调用函数生成器的时候。遇到yield函数被冻结，并返回一个值。再次调用时，执行yield下面未执行的语句，当再次遇到yield后冻结函数，并返回值。

send

send与next功能相同，但send可以给生成器传参数，初始调用生成器时，send不能传值，需要传一个None。或者用next（）执行第一次调用。

例如：
def func():         #函数生成器，因为函数中有yield
i = 0
while True:
    value = yield i      #接受外部传参数给value，返回 i 值。
    i += 1
    print(value)

c = func()      #C为生成器对象，
c.send(None)    #通过生成器对象c 对生成器传参 ，第一个值必须为空none
for i in range(10):
    s = c.send(i)
    print('--',s)

模块

在Python中，每一个.PY文件，就是一个模块。使用from...import...对模块进行调用。好处：大大提高代码的可维护性，代码可重用，还可以避免变量名的冲突。

当调用的模块名字过长时可以用as变量名，的形式给模块起个别名。如果想调用模块下所有的方法，使用星号'*'来调用所有,但这样的方法不是很好，所以最好不要使用。进入多级目录下调用模块使用'.'点号。

包 package

一个文件夹管理多个模块文件，这个文件就被称为包。要将文件夹变成一个包，需要在文件夹下建立一个文件init.py，文件可以为空。

跨模块导入

需要对导入路径进行设置，用到OS模块和SYS模块。为了能让路径在任何一个终端上都能找到准确的模块。需要得到绝对路径。

path = os.path.dirname(os.path.absname(__file__))
sys.path.append(path)
将需要导入的路径加入到路径索引目录中。

相对导入

当前模块与要导入的模块在同一级的目录中时，可以使用相对导入法导入，这样就省掉了一级一级写入from的问题了。相对导入用一个'.'点。

from . import *

time模块

时间模块，获得时间戳，将时间戳转换成日期时间的各种表现形式，也可以将日期时间表现形式转换成时间戳。

time.time() 获得1970至今的全部秒数
time.localtime()返回一个当前时间的时间对象。
time.gmtime()格林威治时间，返回的是UTC时间，可以传入时间戳。
time.mktime()把时间对象转成时间戳。
time.sleep()推迟调用线程的运行。
time.strftime()将时间对象格式化输出，time.strftime('%Y-%m-%d %H-%M-%S',t)
time.strptime()将字符串转成时间对象，time.strptime(s,'%Y-%m-%d %H-%M-%S')

时间转换的逻辑关系：

时间戳 >>time.gmtime() >>time.strftime() >>字符串时间

字符串时间 >>time.strptime() >>time.mktime() >>时间戳

datetime模块

最重要的功能就是时间运算和替换。

datetime.date:表示日期的类
datetime.datetime:表示日期时间的类
datetime.time:表示时间的类
datetime.timedelta: 表示时间间隔，即两个时间点的间隔。
datetime.datetime.now():返回当前的时间日期类型，可以使用timestamp()获取时间戳
datetime.date.fromtimestamp()：把一个时间戳转为datetime日期类型,吧一个人时间戳快速转成年，月，日。
datetime.datetime.fromtimestamp()：把一个时间戳转为datetime日期时间类型。

random模块

随机模块，可对数字和字符串操作。

random.randint():产生随机整数，例：random.randint(1,100)产生1至100之间的整数，包括1和100.
random.randrange():产生随机整数例:random.randrange(1,100)产生1至99之间的整数，不包含100.
random.random():产生随机浮点数例:random.random()产生一个小于1的浮点数。
random.choice():产生随机字符串字符例：random.choice('abc123#@!')
random.sample():在给定字符串中随机返回特定数量的字符。例:random.sample('abc123#@!',3)返回任意3个字符。
random.shuffle():洗牌,对有序序列或元组打乱顺序。例:random.shuffle(x) 将X序列打乱排列顺序

OS模块

文件/目录方法

os.getcwd() 返回python解释器所在的目录
os.listdir() 返回指定目录下的所有文件和目录名
os.remove() 删除一个文件
os.removedirs() 删除多个目录
os.path.isfile() 判断是否为文件
os.path.isdir() 判断是否为目录
os.path.isabs() 判断是否为绝对路径
os.path.exists() 判断是否为真的路径
os.path.split() 返回两个元素，一个是路径名，一个是文件名
os.path.splitext() 返回两个元素，一个是路径和文件名，一个是文件的扩展名。
os.path.dirname() 返回目录的目录名，就是上一级目录名。
os.path.abspath() 返回绝对路径
os.path.basename() 获取当前文件名，目录名
os.system() 运行shell命令，例：os.system('ls')
os.getenv() 拿到系统的环境变量,例:os.getenv('APPDATA')
os.environ() 拿到系统所有环境变量。
os.environ.setdefault() 修改系统变量，设置系统环境变量，仅程序运行时有效。
os.linesep 返回当前系统下的换行符。 win下是'\r\n' linux '\n' mac '\n'
os.name 获取当前的系统名。windows是'nt' linux/unix 是'posix'
os.rename() 将旧文件名改成新文件名。例:os.rename(old,new)
os.makedirs() 创建多级目录。例:os.makedirs(r'c:\python\test\')
os.mkdir() 创建单个目录
os.stat() 获取文件属性。例:os.stat(filename)
os.chmod() 修改文件权限与时间戳
os.path.getsize() 获取文件大小
os.path.join() 结合目录名与文件名。例：os.path.join('root','test','t.py') >>>'root/test/t.py'
os.chdir() 改变工作目录例:os.chdir(dirname) 改变当前工作目录到dirname下可用os.getcwd()查看
os.getterminalsize() 获取当前终端大小
os.kill() 杀死进程

SYS模块

sys.argv 程序外部向程序内部传递参数
sys.exit() 退出程序
sys.version 获取python解释程序的版本信息
sys.maxsize 最大INT值
sys.path 返回模块的搜索路径
sys.platform 返回操作系统平台名称
sys.stdout.write() 标准输出
sys.stdin.readline() 标准输入
sys.getrecursionlimit() 获取最大递归层数
sys.getdefaultencoding() 获取解释器默认编码
sys.getfilesystemencoding() 获取内存数据存储到文件里的默认编码

shutil模块

文件夹、文件压缩处理模块。

shutil.copyfileobj()将文件内容拷贝到新文件内。例:shutil.copyfileobj(open('file1','r'),open('file2','w'))
shutil.copyfile()拷贝文件。例:shutil.copyfile('f1.txt','f2.txt')
shutil.copymode()仅拷贝文件权限。
shutil.copystat()仅拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copy()拷贝文件和权限。
shutil.copy2()拷贝文件和状态。
shutil.copytree()递归拷贝文件。参数ignore=shutil.ignorepatterns()过滤指定文件。例:shutil.copytree('f1','f2',ignore=shutilpatterns('*.txt'，'init.py'）
shutil.rmtree()递归删除文件。例:shutil.rmtree('filename')
shutil.move()递归的移动文件，类似MV，可以作为修改文件名使用。例:shutil.move('f1.py','ff1.py')
shutil.makearchive()文件的压缩。压缩包种类有，“zip”, “tar”, “bztar”，“gztar”,路径设置，rootdir='../..'

例：变量 = shutil.make_archive('file','压缩种类','path&file')

变量：可以存储shutil压缩后的文件路径。

file:压缩后存储的位置，可以设置存储的路径，如:"/Users/sly/file"

压缩种类:“zip”, “tar”, “bztar”，“gztar”

path&file:设置要压缩的目录和名字。root_dir='/Users/sly/Downloads/'

json模块

轻量级数据交换模式

json.dump() 将变量内容写入文件。例：json.dump(data,file) 序列化内容到文件
json.dumps()将变量内容变成字符串。例：s = json.dumps(data) 序列化内容到变量
json.load()将文件内容读取到变量中。例:data = json.load(file) 反序列化文件内容到变量
json.loads()将字符串内容读取到变量中。例:data = json.loads(s) 反序列化变量内容到变量

注：json模块不能自己打开文件，所以需要在使用json模块序列化或反序列化文件的时候，需要提前打开文件。并且不能dump多次。load时会出错。只支持str,int,tuple,list,dict数据类型。

pickle模块

与json操作一样，但pickle存储的是bytes类型的数据。其扩展名为'.pkl'。pickle是python中独有的，支持所有数据类型。

pickle.dump()
pickle.dumps()
pickle.load()
pickle.loads()

shelve模块

shelve可以对pickle进行封装，并可以dump和load多次，采用的是key,value格式。是python中独有的。

例:
import shelve
f = shelve.open('filename')  #不需要扩展名，直接文件名即可。
name = ['sly','good']  
name_dic = {'sly':'lby','good':'cool'}
f['names'] = name  #持久化列表
f['info_dic'] = name_dic  #字典名和变量名可以不一致。
f.close()    #文件存储完是以 .bak（windows系统) .db （linux/unix系统)

读取时，先开打文件  f = shelve.open('filename')
然后按照字典读取方式读取。f['info_dic']['sly']   >>> 'lby'  文件+字典名+key

configparser模块

对配置文件操作。对配置文件的操作与字典操作一致，每个节点名就等同于字典的KEY，每个节点中的项目名是下一层的KEY，项目的值是VALUE。

例：
import configparser
conf = configparser.ConfigParser()   #建立配置文件操作对象
conf.read('filename.ini')         #读取配置文件  read()方法
conf.sections()                   #sections()方法，读取配置文件中所有节点名    
print(conf.options('group'))      #optinons()方法 读取节点内的key名
print(conf['group']['k2'])

conf.add_section('group3')        #添加节点
conf['group3']['name'] = 'sly'    #给新添加的节点添加配置信息。
conf['group3']['age'] = '36'

conf.set('group3','k1','v1')      #也可以使用set()添加节点配置信息
conf.remove_option('group1','k2')  #删除节点中具体的配置项目名
conf.remov_section('group1')        #删除节点

conf.write(open('filename.ini','w'))  #对配置文件操作完毕后必须要保存做write操作。

hashlib模块

hash散列，通过哈希算法加密的功能模块。　hashlib 是一个提供了一些流行的hash算法的 Python 标准库．其中所包括的算法有 md5, sha1, sha224, sha256, sha384, sha512. 另外，模块中所定义的 new(name, string=”) 方法可通过指定系统所支持的hash算法来构造相应的hash对象．

MD5：讯息摘要演算法。

MD5算法特点：

压缩性：任意长度的数据，算出的MD5值的长度都是固定的。
容易计算：从原数据计算出MD5值很容易。
抗修改性：对原数据进行任何改动，哪怕修改一个字节，生成的MD5值区别也会很大。
强抗碰撞：已知原数据和MD5，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。

例： import hashlib pwd = hashlib.md5() #创建哈希MD5对象 pwd.updata(b'sly' or 'sly'.encode('UTF-8')) #生成MD5加密数据。需要以编码形式加密。 pwd.hexdigits() #生成以16进制显示的MD5码，也可以选择其他进制显示形式。

password = pwd.hexdigits() 生成的MD5码，传给变量以供使用。

subprocess模块

系统交互模块

标准写法：

subprocess.run(['df','-h'],stderr=subprocess.PIPE,stdout=subprocess.PIPE,check=True)

PIPE：管道，意思是与机器通过管道进行互通从而进行系统的交互。
stdout = subprocess.PIPE 通过管道得到返回内容
stderr = subprocess.PIPE 通过管道得到错误返回内容

调用：通过对变量赋值生成对象。

如：a是生成的对象，在进行调用读取。

a.stdout 读取返回内容

a.stderr 读取错误信息

check = True 是非0报错，因为执行成功返回是0，如果非0就是执行错误，不设这个参数，执行语句不显示错误信息，刻在stderr中查看。

call()方法：执行命令，返回命令执行状态，0或非0。例:ret = subprocess.call(['ls','-l'])

popen()方法: 创建一个新的进程来执行。而run是在当前进程下执行。

常用参数：

args shell命令，可以使字符串或者序列类型（如：list,tuple)
stdin,stdout,stderr 分别表示程序的标准输入，输出，错误句柄。
preexec_fn 只在unix平台下有效，用于指定一个可执行对象，他将在之前被调用。
shell 与上一个相同
cwd 用于指定子进程的环境变量，如果env=None，紫禁城的环境变量将从父进程中继承。

logging模块

日志模块，日志分为5个级别。分别为：DEBUG,INFO,WARNING,ERROR,CRITICAL 从左至右依次增高。

基础使用方法

import logging
logging.basicConfig(filename='log_test.log',
                    level=logging.DEBUG,
                    format='%(asctime)s %(message)s,
                    datefmt='%Y-%m-%d) 

logging.info('msg')
logging.debug('msg')

基础设置中的format格式化参数

%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)t 当前时间，用UNIX标准的表示时间的浮点数表示
%(relativeCreated))d 输出日志信息时的至logger创建以来的毫秒数
%(asctime)s 字符串形式的当前时间，默认格式是 “年月日时分秒，毫秒”
%(thread)d 线程ID，可能没有
%(threadName)s 线程名，可能没有
%(process)d 进程ID，可能没有
%(message)s 用户输出的消息

logging模块的四个类

logger 提供了应用程序可以直接使用的接口
handler 将logger创建的日志记录发送到合适的目的输出
filter 提供了细度设备来决定输出哪条日志记录，也就是过滤输出记录
formatter 决定日志记录的最终输出格式。

高级用法：

例：
import logging
logger = logging.getLogger('loggername')   #生成一个logger对象
logger.setLevel(logging.DEBUG)          #对日志的全局级别进行设置

ch = logging.StreamHandler()        #设置屏幕输出对象
ch.setLevel(logging.DEBUG)          #设置屏幕输出日志级别

fh = logging.FileHandler('filename.log')    #设置文件输出对象，并设置输出文件名
fh.setLevel(logging.INFO)       #设置文件输出的日志级别

format_file = logging.formatter('%(asctime)s -- %(filename)s -- %(message)s')   #创建格式化输出格式

ch.setFormatter(format_file)    #将屏幕输出对象的输出格式设置为 参数中的格式
fh.setFormatter(format_file)    #将文件输出对象的输出格式设置为 参数中的格式

logger.addHandler(ch)       #将handler加入到logger 应用接口中
logger.addHandler(fh)       #将handler加入到logger 应用接口中

#实现同一个日志信息，屏幕和文件中共同显示。也可对该用法灵活运用，对logger对象更改不同的名字，来改变不同日志的输出位置。

logging模块下的handlers模块，提供了文件截断功能，分为为按文件大小截断和按时间间隔截断。handlers.RotatingFileHandler和handlers.TimeRotatingFileHandler两个方法。

re模块

强大的正则表达式模块。

re的匹配语法有以下几种：

re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub 匹配字符串替换
re.fullmatch 全部匹配

正则表达式太多太复杂了。。基本用法都大概了解。但真正使用的时候写不太明白。

posted @ 2018-05-29 20:45 sly27 阅读(146) 评论(0) 收藏举报

刷新页面返回顶部

Sly27