Python3 菜鸟教程 笔记7 -- 模块、输入和输出

$ 模块（摘要）

传送门：https://www.runoob.com/python3/python3-module.html

@ __name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

运行输出如下：

$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>
说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

@ 包
包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 表示一个包 A中的子模块 B 。

[例]
假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）-> eg: sound/包
现存很多种不同的音频文件格式，所以你需要一组模块，用来在不同的格式之间转换 -> eg: formats/文件格式转换子包
并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，创建人造立体声效果）-> eg: effects/声音效果子包

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，最简单的情况，放一个空的 :file:__init__.py就可以了。

(1) 使用import sound.effects.echo 导入子模块 sound.effects.echo
必须使用全名去访问子模块中的函数/方法:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

(2)使用 from sound.effects import echo 导入子模块 echo
可以这样访问其函数/方法:
echo.echofilter(input, output, delay=0.7, atten=4)

(3)使用 from sound.effects.echo import echofilter 直接导入一个函数或者变量
这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)

注意：
1.当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。
2.如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

(4)从一个包中导入*(不推荐)
导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
[例]在:file:sounds/effects/__init__.py中包含如下代码:
__all__ = ["echo", "surround", "reverse"]
这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。
 

$ 输入和输出

https://www.runoob.com/python3/python3-inputoutput.html

@ str.format()

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：
>>> print('{0} is {1}'.format('Today', 'Thursday'))
Today is Thursday
>>>

在":" 后传入一个整数, 可以保证该域至少有这么多的宽度。 
[例]
>>> for x in range(1, 7):
    print('{0:2d} ==> {1:3d} {2:4d}'.format(x, x*x, x*x*x))

    
 1 ==>   1    1
 2 ==>   4    8
 3 ==>   9   27
 4 ==>  16   64
 5 ==>  25  125
 6 ==>  36  216
>>> 
 

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
>>> print('{item}： ￥{price:.2f}'.format(price=128, item='canlendar'))
canlendar： ￥128.00
>>>

@ 旧式字符串格式化
"%" 操作符也可以实现字符串格式化。 
>>> print('Today is %s.' % 'Thursday')
Today is Thursday.
>>> print('One %s is ￥%5.2f.' % ('apple',5))
One apple is ￥ 5.00.

@ 读取键盘输入
>>> str = input("Please input your name：")
Please input your name：Eagle
>>> str
'Eagle'
>>> 
>>> age = int(input("How old are you:"))
How old are you:3
>>> age
3
>>> 

@ 读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode) 

完整的语法格式为：(传送门：https://www.runoob.com/python3/python3-file-methods.html)
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Friday.txt 文件内容如下：

Yesterday is Wednesday.
Today is Thursday.
Tomorrow is Friday!

（1）f.read()
[例]

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

输出结果：

Yesterday is Wednesday.
Today is Thursday.
Tomorrow is Friday!

（2）f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt", "r")

str = f.readline()
print(str)

# 关闭打开的文件
f.close()

输出结果：

Yesterday is Wednesday.

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt", "r")

str = f.readline()
str = f.readline()
str = f.readline()
print(str)

# 关闭打开的文件
f.close()

输出结果：

Tomorrow is Friday!

（3）f.readlines()
f.readlines() 将返回该文件中包含的所有行。

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt", "r")

str = f.readlines()
print(str)

# 关闭打开的文件
f.close()

输出结果：

['Yesterday is Wednesday.\n', 'Today is Thursday.\n', 'Tomorrow is Friday!']

另一种方式是迭代一个文件对象然后读取每行:

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt", "r")

for line in f:
    print(line, end='==')

# 关闭打开的文件
f.close()

输出结果：

Yesterday is Wednesday.
==Today is Thursday.
==Tomorrow is Friday!==

（4）f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

#!/usr/bin/python3

# 打开一个文件
f = open("Friday.txt", "w")

num = f.write( "I ate pancake this morning.\nI want to eat Youtiao for breakfast tomorrow!\n" )
print(num)
# 关闭打开的文件
f.close()

输出结果：

74

检查一下写入内容长度
>>> len("I ate pancake this morning.\nI want to eat Youtiao for breakfast tomorrow!\n")
74
>>>
查看Friday.txt内容更新为如下：
I ate pancake this morning.
I want to eat Youtiao for breakfast tomorrow!

说明：如果要写入一些不是字符串的东西, 那么将需要先进行转换:
s = str(value)
f.write(s)

（5）f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

当处理一个文件对象时, 使用 with 关键字是非常好的方式。
>>> with open('Friday.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True
>>>

 

@ pickle 模块
python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储 -> pickle.dump(obj, file, [,protocol])
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象 -> pickle.load(file)

步骤一，dump

#!/usr/bin/python3
import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'Spring': 'flowers',
         'Summer': ['ice-cream','swimming'],
         'Autumn': 'fruits',
         'Winter':'snow'
         }

data2 = 'Ha ha ha!'

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(data2, output)

output.close()

步骤二，load

#!/usr/bin/python3
import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()

输出结果：

{'Autumn': 'fruits',
 'Spring': 'flowers',
 'Summer': ['ice-cream', 'swimming'],
 'Winter': 'snow'}
'Ha ha ha!'

一个参考链接：https://cloud.tencent.com/developer/article/1406414