python入门详解 4

本章内容：

模块、以主程序形式运行、包、内置模块、第三方模块安装、字符编码、文件读写、
with语句、os模块、os.path模块

# author: ljt
# 2023/6/14 20:00

# 模块
# python中一个 .py 文件就是一个模块module
# 一个模块可以包含 n 多个函数，类（包含类属性、类方法、实例属性、实例方法、静态方法），语句
# 导入模块
#    import module_name [as alias_name]
#    from module_name import func/var/cls
#    from module_name import *


# 以主程序形式运行
# 在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以检查该变量，
#   以确定他们在哪个模块中执行。如果一个模块不是被导入到其它程序中执行，那么它可能
#   在解释器的顶级模块中执行。顶级模块的__name__变量的值为__main__

"""
举例如下
# 1.
# 在 a.py 中有如下
def add(a, b):
    return a + b

print(add(10, 20))
# 则当 run a.py 时，会得到 30

# 2.
# 在 b.py 中有如下
import a
print(a.add(100, 200))
# 则当 run b.py 时，会得到 30 300. 但是我们其实期望得到的只有 300，30 是a.py运行的结果

# 3.
# 将 a.py 修改如下
def add(a, b):
    return a + b

if __name__ == '__main__':
    print(add(10, 20))
# 则当 run b.py 时，会只得到 300. run 那个.py文件中的 __name__ 会被赋值为__main__
"""

# 包
# 包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
# 包与目录的区别--包含__ini__.py文件的目录称为包，目录里通常不包含__init__.py文件
# import package_name.module_name [as alias_name]

# 使用 import 方式进行导入时，只能跟包名或模块名
# import package_name / module_name
# 使用 from...import...方式，可以导入模块，函数，变量
# from package_name import module_name
# from module_name.module_name import func/var


# python常用的内置模块
# sys--与python解释器及其环境操作相关的标准库
# time--提供与时间相关的各种函数的标准库
# os--提供了访问操作系统服务功能的标准库
# calendar--提供了与日期相关的各种函数的标准库
# urllib--用于读取来自网上（服务器）的数据标准库
# json--用于使用JSON序列化和反序列化对象
# re--用于在字符串中执行正则表达式匹配和替换
# math--提供标准算术运算函数的标准库
# decimal--用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
# logging--提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

import sys
import time
import urllib.request

print(sys.getsizeof(24))  # the size of object in bytes
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())


# 第三方模块安装 pip install module_name
# 第三方模块使用 import module_name
import schedule
import time

def job():
    print('haha')

schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

# 字符编码
# python的解释器使用的是 Unicode（内存）
# .py文件在磁盘上使用utf-8存储（外存）

# 如果一个x.py只有下面这一个语句，则它是采用默认的utf-8编码方式
# 验证：在文件夹中找到x.py，使用记事本打开它，选'另存为..'，则会看到编码方式是utf-8
print('你好，中国')

# 如果一个x.py只有下面这两个语句，则它是采用的是其它编码方式
# 验证：在文件夹中找到x.py，使用记事本打开它，选'另存为..'，则会看到编码方式是ANSI
#encoding=gbk
print('你好，中国')


# 文件读写
# 文件读写俗称“IO操作”
# 内置函数open()创建文件对象
# file = open('file_name', 'mode', encoding='utf-8')

f = open('test.txt', 'r', encoding='utf-8')
print(f.readlines())  # 将文件内容读出到一个列表中
f.close()

# 按文件中数据的组织形式，文件分为以下两大类：
#   文本文件--存储的是普通‘字符’文本，默认为unicode字符集，可以使用记事本程序打开
#   二进制文件--把数据内容用‘字节’进行存储，无法用记事本打开，必须使用专用的软件打开，比如mp3音频文件，jpg图片，.doc文档等

# r--以只读模式打开文件，文件的指针将会放在文件的开头
# w--以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头
# a--以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追究内容，文件指针在原文件末尾
# b--以二进制方式打开文件，不能单独使用，需要与其它模式一起使用，rb/wb
# +--以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+
f = open('test.txt', 'r', encoding='utf-8')
print(f.readlines())
f.close()

# 复制照片
f1 = open('刘芳菲.jpg', 'rb')
f2 = open('alice.jpg', 'wb')
f2.write(f1.read())
f1.close()
f2.close()


# 文件对象常用方法
# read([size])--从文件中读取size个字节或字符的内容返回。如省略[size]则读取到文件末尾，即一次读取文件所有内容
# readline()--从文本文件中读取一行内容
# readlines()--把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
# write(str)--将字符串str内容写入文件
# writelines(s_lsit)--将字符串列表s_list写入文本文件，不添加换行符
# seek(offset[,whence])--把文件指针移动到新的位置，offset表示相对于whence的位置
#     offset--为正往结束方向移动，为负往开始方向移动
#     whence--不同的值代表不同含义，0-从文件头开始计算（默认值），1-从当前位置开始计算，2-从文件末尾开始计算
# tell()--返回文件指针的当前位置
# flush()--把缓冲区的内容写入文件，但不关闭文件
# close()--把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
f = open('test.txt', 'r', encoding='utf-8')
print(f.read())
print(f.read(2))  # pr，文件指针在文件开头，读取2个字符
print(f.readline())  # int a new line，读取指针开始的，其所在行的数据
print(f.readlines())  # ['520\n', 'print a new line\n', '520\n']，读取指针开始，所有行
f.close()

f = open('test.txt', 'a+', encoding='utf-8')
f.write('ljt')
f.write('\n')
lst = ['learn', 'hard', 'very']
f.writelines(lst)
f.close()

f = open('test.txt', 'r', encoding='utf-8')
f.seek(2)
print(f.readline())
print(f.tell())
f.close()


# with语句（上下文管理器）
# with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确关闭，以此来达到释放资源的目的。
# with open('file_name', 'mode') as alias_file_name:
#     alias_file_name.read()
#     离开运行时上下文，自动调用上下文管理器的特殊方法__exit__()
print(open('test.txt', 'r'))
with open('test.txt', 'r') as f:
    print(f.read())

"""
上下文管理器原理模拟
MyContentMgr实现了特殊方法__enter__(),__exit__(),则该类对象遵守了上下文管理器协议
该类对象的实例对象称为上下文管理器
MyContentMgr() -- 这就是一个上下文管理器
"""
class MyContentMgr(object):
    def __enter__(self):
        print('enter method')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit method')

    def show(self):
        print('show method')

with MyContentMgr() as file:  # 相当于file=MyContentMgr()
    file.show()  # enter method， show method， exit method


# os 模块
# os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句
#   的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
# os模块与os.path模块用于对目录或文件进行操作

import os
# 直接执行命令
os.system('notepad.exe')  # 打开记事本
os.system('calc.exe')  # 打开计算器
# 直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\ClassIn\\ClassIn.exe')  # 打开classin

# getcwd()--返回当前的工作目录
# listdir(path)--返回指定路径下的文件和目录信息
# mkdir(path[, mode])--创建目录
# makedirs(path1/path2...[, mode])--创建多级目录
# rmdir(path)--删除目录
# removedirs(path1/path2...)--删除多级目录
# chdir(path)--将path设置为当前工作目录

print(os.getcwd())
lst = os.listdir('../python')
print(lst)

os.mkdir('newdir')
os.makedirs('a/b/c')
os.rmdir('newdir')
os.removedirs('a/b/c')
os.chdir('E:\\LJT\\script\\python\\package1')
print(os.getcwd())
os.chdir('E:\\LJT\\script\\python')
print(os.getcwd())

# os.path模块操作目录
# abspath(path)--用于获取文件或目录的绝对路径
# exists(path)--用于判断文件或目录是否存在，如果存在返回True，否则返回False
# join(path, name)--将目录与目录或者文件名拼接起来
# splitext()--分离文件名和扩展名
# basename(path)--从一个目录中提取文件名
# dirname(path)--从一个路径中提取文件路径，不包括文件名
# isdir(path)--用于判断是否为路径
import os.path
print(os.path.abspath('test.py'))
print(os.path.exists('test.py'), os.path.exists('test8.py'))
print(os.path.join('E:\\LJT\\script\\python', 'test.py'))  # 注意转义字符
print(os.path.split('E:\\LJT\\script\\python\\test.py'))  # ('E:\\LJT\\script\\python', 'test.py')
print(os.path.splitext('test.py'))  # ('test', '.py')
f_name, ext = os.path.splitext('test.py')
print(os.path.basename('E:\\LJT\\script\\python\\test.py'))  # test.py
print(os.path.dirname('E:\\LJT\\script\\python\\test.py'))  # E:\LJT\script\python
print(os.path.isdir('E:\\LJT\\script\\python\\test.py'))

# 课堂随练
# 列出指定目录下的所有.py文件
import os

d = os.getcwd()
lst = os.listdir(d)  # 文件和目录信息
lst1 = os.walk(d)
print(lst1)

for file_name in lst:
    if file_name.endswith('.py'):
        print(file_name)

# 递归检索所有路径
import os

# get current work directory
cd = os.getcwd()
cd = os.path.join(cd, 'test-walk')

print('------------------------------')
ct = os.walk(cd)
# ct is a tuple with many items, and each item has three sub-items, dirpath, dirname and filename.
# the dirname is a list, if it is not empty, then join(dirpath, dirname) to the new dirpath to recursive
# the filename is a list, if it is not empty, then join(dirpath, filename) can get the absolute path of the file
for dir_path, dir_name, file_name in ct:
    # print('in', dir_path, 'has', len(file_name), 'files:',end=' ')
    # for i in file_name:
    #     print(i, end=', ')
    # print('\n')
    print('------------------------------')
    for dir in dir_name:
        print(os.path.join(dir_path, dir))
    for file in file_name:
        print(os.path.join(dir_path, file))