python学习 day10

模块

模块，用一坨代码实现了某个功能的代码的集合。

模块分为三种：

自定义模块
第三方模块
内置模块

模块的导入：

1、import 模块

2、from 模块 import 模块中的功能

区别：

import:一般简单的.py文件我们可以使用

例如：

import re #直接调用模块
re.findall() #然后直接使用模块的方法

from模式：用于复杂文件的操作

1、当一个单一的.py里面包含很多功能的时候

例如：dome.py

#！/usr/bin/env python
#！ -*- coding:utf-8 -*-
def f1():
    return "f1"
def f2():
    return "f2"

如果调用其中的f1()或者f2()；可以这样写

from dome import f1
ret = f1()
print(ret)

#### 同时调用2个功能
from dome import f1,f2
ret1 = f1()
ret2 = f2()
print(ret1)
print(ret2)

在实际运用中；我们一般是将所有的功能放在一个文件夹中

如：创建一个目录myfile；然后里面创建一个文件lib

然后将功能放于lib下面

此时通过myfile目录下的test.py调用demo.py里面的方法

from lib.demo import f1
ret1 = f1()
print(ret1) # 1

#### 同时接收2个方法
from lib.demo import f1,f2
ret1 = f1()
ret2 = f2()
print(ret1) # 1
print(ret2) # 2

分析：上面的代码是直接将demo中的f1()和f2()方法直接导入；所以在使用中可以直接使用方法

同样也可以这样操作：(将放权全部导入，用父文件进行配和调用)

from lib import demo
ret1 = demo.f1()
print(ret1) # 1

分析：上面的操作是将demo中的方法全部导入；所以要调用的时候；必须由主文件执行方法

如果使用 import 导入会怎样？

import lib.demo
demo.f1()  # 报错

ret = lib.demo.f1()
print(ret) #1

注意：

1、使用import操作文件中的代码文件中的方法的时候；必须将引入时候输入的文件名；输完整才能正确调用方法；不然会出错

2、从例子中可以看出；使用import导入文件关联的代码的时候确实比from麻烦

小技巧：

使用from的时候导入文件的时候可以重新指定文件的名字。

from lib.demo import f1 as ch
ret = ch()
print(ret) # 1

问题：为什么我们可以通过from或import导入成功？

是因为from或import将文件夹自动加进了sys.path里面

同时还要注意：你执行那个文件；那个文件就会加到sys.path里面

os模块(系统相关的模块)

用于提供系统级别的操作：

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径-->linux下的pwd
os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: (\'.\')
os.pardir                   获取当前目录的父目录字符串名：(\'..\')
os.makedirs(\'dir1/dir2\')    可生成多层递归目录
os.removedirs(\'dirname1\')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(\'dirname\')         生成单级目录；相当于shell中mkdir dirname
os.rmdir(\'dirname\')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(\'dirname\')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
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)     如果文件存在，返回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所指向的文件或者目录的最后修改时间

方法

os.stat("path/filename"):获取文件/目录信息

获取的信息；包含了文件的很多信息；其中st_size：显示的就是文件大小

import os
ret = os.stat("test.txt")
print(ret)

结果显示：(一部分)

os.path.split(path)：将path分割成目录和文件名组成元组返回

import os
ret = os.path.split("D:\Python练习\Python学习\day11\test.py")
print(ret) # (\'D:\\Python练习\\Python学习\', \'day11\test.py\')

os.path.dirname(path)：返回path的目录。其实就是os.path.split(path)的第一个元素

import os
ret = os.path.dirname("D:\Python练习\Python学习\day11\\test.txt")
print(ret) # D:\Python练习\Python学习\day11

os.path.exists(path)：如果文件存在，返回True；如果path不存在，返回False

import os
ret = os.path.exists("D:\\Python练习\\Python学习\\day11\\test.py")
print(ret) # True

os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

import os
s1 = "D:"
s2 = "home"
s3 = "index"
ret = os.path.join(s1, s2, s3)
print(ret) # D:home\index

os.path.isabs()：判断是不是绝对路径

os.path.isfile()：判断是不是一个文件

os.path.isdir()：判断是不是一个目录

sys模块(与解释器相关)

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关

方法

注意：要在终端运行文件；在pycharm里直接运行不行

sys.argv: 命令行参数List，第一个元素是程序本身路径；

能获取传入脚本的参数

test.py文件本身：

import sys
print(sys.argv)

然后；我们就通过用户传入脚本的参数进行相应的操作

test.py原文件代码

import sys
print(sys.argv)
if sys.argv[1] == "haha":
    print("你真逗")
else:
    print("滚")

结果显示：

注意：传入参数的方式；在执行函数的时候；空格然后将要传入的参数接在后面；如果有多个；用空格隔开

sys.path：返回模块的搜索路径，初始化时使用Python PATH环境变量的值；获取的结果是个列表。

问题：那当我操作当前文件；此时我们又想操作其他盘的文件的时候；怎么办？

根据上面我们知道；import和from能导入文件；都是将文件增加进sys.path中；而sys.path结果又是列表；

所以；我们想到；可以一样将想操作盘的地址也增加进sys.path

使用列表的方法；append();如：

import sys

sys.path.append("F:")

分析：上面的代码；结果；不管你在那个盘操作；都可以操作 F盘里的文件

总结：

1、导入的路径就是sys.path显示出来的路径

2、文件之间的层级关系可以通过 . 来表示；如：lib.demo：表示lib文件夹下面的demo

3、要想导入文件；必须将文件增加进sys.path

4、python中有个优化进制；如果文件导入了；后面再重复导入的话；后面的导入的功能是失效的

5、想让自己的模块能被全局调用；则将自己的模块放入 site-packages 目录下即可

6、python文件下\\lib\\site-packages:存放所有第三方安装的模块

7、模块查找顺序；首先是当前目录；然后根据环境变量里面的路径挨着寻找

sys.exit(n)：退出程序，正常退出时exit(0)

n ：如果是字符串；则是退出后显示的内容

choice = input("你想退出吗？")
if choice == "y" or choice == "Y":
    exit("GoodBye") # 等价于 sys.exit("GoodBye")

如果是数字：

sys.version：获取python解释器版本的信息

sys.platform：返回操作系统平台名称

win32:就表示windows系统

linux2：linux系统

sys.stdout.write()：在屏幕上写入内容

在python2.7环境下操作

技巧：在linux下一切皆是文件；

问题：print也可以向屏幕输出东西，他们的区别？

在具体点：

print：我们知道；都是打印一次换行一次的；

既然能在一行显示；而且能重复；那我们就可以让一个东西重复；利用：time.sleep()：控制延迟时间；这样达到制作进度条的效果；

sys.stdout.flush():强制刷新屏幕

在带百分比的进度条例子中；如果不加这个；结果：屏幕有缓冲区；不刷新的话；会等到结果全部完成后一次性显示在屏幕上；

如果加上；会将代码执行的过程一步步的显示在屏幕上；-->会显示过程

sys.stdin.read():在屏幕上读取内容

进度条代码

import sys
import time


def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = \'\r%d%%\' % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == \'__main__\':
    for i in range(0, 100):
        time.sleep(0.1)
        view_bar(i, 100)

View Code

hashlib(加密)

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

注意：md5密码是不能反解的；但是可以通过撞库的方式破解；

撞库：将所有的字符串进行加密；然后将加密后的结果与md5的结果进行比较进而破解

注意：在实际开发中；只要涉及用户登陆的：

1、密码必须进行加密

2、在进行登陆验证的时候；密码通过正解方式(即加密方式)；比较他们加完密之后的结果(因为md5不能反解)

hashlib.md5()：创建一个md5对象；进行md5加密。

hashlib.md5().update(bytes("要加密的字符串", encoding="utf-8"))：对传入的字符串进行加密

hashlib.md5().hexdigest():获取加密的结果

下面是hashlib创建的不同对象；不同算法的案例：

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes(\'admin\', encoding=\'utf-8\'))
print(hash.hexdigest())
print(hash.digest())


######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes(\'admin\', encoding=\'utf-8\'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes(\'admin\', encoding=\'utf-8\'))
print(hash.hexdigest())


# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes(\'admin\', encoding=\'utf-8\'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes(\'admin\', encoding=\'utf-8\'))
print(hash.hexdigest())

案例

在创建md5对象的时候对其进行创建加密；相当于对后面的update进行了双重加密

hmac：加密模块

python内置还有一个 hmac 模块，它内部对我们创建 key 和内容进行进一步的处理然后再加密

import hmac

h = hmac.new(bytes(\'898oaFs09f\',encoding="utf-8"))
h.update(bytes(\'admin\',encoding="utf-8"))
print(h.hexdigest())

注意：

1、原理和md5的加密原理一样；只是简化了而已

2、推荐使用md5

实例：md5是实现密码加密登陆和注册

import hashlib

def ipt():
    username = input("请输入用户名：")
    pwd = input("请输入密码：")
    return username,pwd

def zhuce():
    username,pwd = ipt()
    hash = hashlib.md5(bytes("jayafs0", encoding="utf-8"))
    hash.update(bytes(pwd, encoding="utf-8"))
    temp = username + "&" + hash.hexdigest()
    with open("test.txt", "a", encoding="utf-8") as f:
        f.write(temp)
    return True

def denglu():
    username, pwd = ipt()
    with open("test.txt", "r", encoding="utf-8") as f:
        for line in f:
            li = line.strip().split("&")
            hash = hashlib.md5(bytes("jayafs0", encoding="utf-8"))
            hash.update(bytes(pwd, encoding="utf-8"))
            if li[0] == username and hash.hexdigest() == li[1]:
                return True

change = input("1、注册  2、登陆")
if change == "1":
    ret1 = zhuce()
    if ret1:
        print("注册成功")
elif change == "2":
    ret2 = denglu()
    if ret2:
        print("登陆成功")
    else:
        print("登陆失败")

View Code

time模块

常用方法

import time

# print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
# print(time.altzone)  #返回与utc时间的时间差,以秒计算\
# print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
# print(time.localtime()) #返回本地时间 的struct time对象格式
# print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式

# print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
#print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上


# 日期字符串 转成  时间戳
# string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
# print(string_2_struct)
# #
# struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
# print(struct_2_stamp)

#将时间戳转为字符串格式
# print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
# print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式

常用方法

time.sleep()：暂停；

可以接收数字参数；表示暂停的时间；以秒(s)为单位

time.time():获取时间戳

时间戳：从1970年1月1日凌晨(0:00)开始到现在过去了多少秒。

原因：1970年unix系统才诞生

import time
import datetime
print(time.time())  # 结果1476848639.042887

time.ctime():获取当前系统时间的字符串格式

import time
import datetime
print(time.ctime())  # 结果Wed Oct 19 11:44:59 2016

此方法还可以将时间戳转化为字符串格式

time.ctime(time.time()-86400):获取昨天系统相对于此时的时间字符串

分析：86400：是一天24小时转化成秒后的结果

time.gmtime()：返回当前时间的一个时间对象(UTC)-->一个struct_time格式

中国出去东8区；UTC时间和中国时间差8个小时

import time
import datetime
ret = time.gmtime(time.time())
print(ret)
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=19, tm_hour=3, tm_min=55, tm_sec=43, tm_wday=2, tm_yday=293, tm_isdst=0)

返回一个对象我们可以通过里面的值名获取对应的值：

import time
import datetime
ret = time.gmtime()
print(ret)
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=19, tm_hour=3, tm_min=55, tm_sec=43, tm_wday=2, tm_yday=293, tm_isdst=0)

print(ret.tm_year) # 2016
print(ret.tm_mon)  # 10

组合里面的数据

import time
import datetime
ret = time.gmtime()
print(ret)
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=19, tm_hour=3, tm_min=55, tm_sec=43, tm_wday=2, tm_yday=293, tm_isdst=0)

print(str(ret.tm_year) + "-" + str(ret.tm_mon) + "-" + str(ret.tm_mday)) # 2016-10-19
print("%s-%s-%s" % (ret.tm_year, ret.tm_mon, ret.tm_mday)) # 2016-10-19

time.localtime():返回本地时间；就是当前操作系统的时间-->是一个struct_time格式

import time
print(time.localtime(time.time()))
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=19, tm_hour=18, tm_min=31, tm_sec=38, tm_wday=2, tm_yday=293, tm_isdst=0)

time.mktime():与time.localtime()功能相反；将struct_time格式转回成时间戳的格式

接收一个时间对象

import time
print(time.mktime(time.localtime())) # 1476886767.0

time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()):将时间对象(struct_time格式)转化成指定的字符串格式

import time
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
# 结果 16-10-19 14:28:40 和本地时间差 8小时

####本地时间
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 结果 本地时间 16-10-19 22:34:25

分析：

Y：(大写的) 代表年
m：代表月
d：代表日
H：(大写的) 代表小时
M：(大写的) 代表分钟
S：(大写的) 代表秒

time.strptime()：和time_strftime相反；将字符串格式转化成struct_time格式

import time
# May 17,2016
print(time.strptime("05 17,2016", "%m %d,%Y"))
# 2016/10/19
print(time.strptime("2016/10/19", "%Y/%m/%d"))
# 10/19/2016
print(time.strptime("10/19/2016", "%m/%d/%Y"))

结果显示：(一个片段)

datetime模块

#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

#
# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2,seconds=10000)) #时间替换

方法

datetime.date.today():打印当前系统的时间；输出格式 2016-01-01

import datetime
print(datetime.date.today()) # 2016-10-19

datetime.date.fromtimestamp(time.time())：将时间戳转化成日期：格式2000-01-01

import time
import datetime
ret = datetime.date.fromtimestamp(time.time())
print(ret) # 结果 2016-10-19

datetime.datetime.now()：打印当前的时间

import datetime
print(datetime.datetime.now()) # 2016-10-19 23:25:20.770609

datetime.datetime.now().timetuple():将但当前时间转换成时间对象；struct_time格式

datetime.datetime.strptime("2016/01/01 10:00", "%Y/%m%d %H:%M")：将字符串转换成日期的格式；2000-01-01 10：00：00

import datetime
ret = datetime.datetime.strptime("2016/01/01 10:00", "%Y/%m/%d %H:%M")
print(ret) # 结果 2016-01-01 10:00:00

datetime.datetime.now()+datetime.timedelta(-3):时间相加减

括号中的-3；默认是3天；都是在系统当前时间的基础上加减的

下面代码；是在当前的日期；时间的基础上后退三天

import datetime
ret = datetime.datetime.now() + datetime.timedelta(-3)
print(ret) # 结果 2016-10-16 23:35:28.062617

####上面代码和下面的代码结果一样
ret = datetime.datetime.now() - datetime.timedelta(3)
print(ret) # 结果 2016-10-16 23:35:28.062617

注意：它们的区别在中间的 + -符号；和后面后好中数的符号

问题：如果要改变周，小时，分钟，秒...？

小时：(加，减同理)

import datetime
ret = datetime.datetime.now() + datetime.timedelta(hours = 3)
print(ret) # 结果在当前时间的基础上加三小时

分钟：(加，减同理)

import datetime
ret = datetime.datetime.now() + datetime.timedelta(minutes = 30)
print(ret) # 结果在当前时间的基础上加30分钟

秒：(加，减同理)

import datetime
ret = datetime.datetime.now() + datetime.timedelta(seconds = 10)
print(ret) # 结果在当前时间的基础上加10秒

.replace():时间替换

import datetime
ret = datetime.datetime.now().replace(2000,1,1,1,1,1)
print(ret) # 结果2000-01-01 01:01:01.109518

注意：

1、会将当前系统时间替换成传入参数的时间

2、输入的不是字符串，就是直接的数

3、参数会按照年，月，日，时，分，秒...这样的顺序自动排下去

问题：如果要单独改变其中的某一行那？

import datetime
ret = datetime.datetime.now().replace(year = 2000, month = 1, minute = 30)
print(ret) # 结果2000-01-19 23:30:00.580603

分析：要改变其中的某一项的时候；只需要指定此项的名称 = 改变的值；就可以

注意：

1、输入的不是字符串

2、更改单项的时候的书写格式

pickle：模块

引入：一个商城网站；一般都有很多用户；用户对应的也有很多信息；信息的存储一般都是按字节码来存储的。但是我们创建信息的时候却是以列表，字典之类的形式进行创建编辑显示的；

文件的存储是按字节码存储的；那么拿出来的时候也是字节码；同时如果要写入的话也必须是字节码才能写入；儿而字符串转换字节码可以用byets()方法；但是列表，字典；使用bytes()方法会报错！那要将列表，字典转换成字节码；过车工嗯复杂；所以python给我们提供了pickle模块；能简单轻松的将列表，字典转化成字节码

pickle.dumps():转换成字节形式

import pickle
li = ["haha", 11, "你好"]
dic = {
    "name":"你好",
    "age":18
}
print(pickle.dumps(li))
print(type(pickle.dumps(li)))
print(pickle.dumps(dic))

结果显示：(一部分)

pickle.loads():将pickle.dumps()转换成字节码转化为存储之前的类型

如果你之前使用pickle.dumps()将列表转换成字节形式的；那么使用pickle.loads()；能将此字节形式转换为原型列表形式；

如果是字典；效果是一样的

import pickle
li = ["haha", 11, "你好"]
dic = {
    "name":"你好",
    "age":18
}
print(pickle.dumps(li))
print(pickle.dumps(dic))

#### 将字节码转换为原型
print(pickle.loads(pickle.dumps(li)))
print(pickle.loads(pickle.dumps(dic)))

结果显示：(一部分)

pickle.dump(obj,file):将obj转换成字节的形式并写入file指定的文件中

1、obj:是操作的对象

2、file:是要写入的文件

import pickle
dic = {
    "name":"你好",
    "age":18,
    "sex":"男"
}

with open("test.txt", "wb") as f:
    pickle.dump(dic, f) # 会直接将文件转换成字节码形式；然后传入test.txt文件

test.txt文件的显示：

pickle.load(file):接收一个文件；将文件内容中的字节码转换成原本的形式

接着上面的test.txt文件操作的

import pickle
with open("test.txt", "rb") as f:
    ret = pickle.load(f)
    print(ret) # 结果 {\'sex\': \'男\', \'age\': 18, \'name\': \'你好\'}

注意：dumps(), loads(), dump(), load():相对来说，dump()和load()是操作文件；dumps()和loads()操作具体的内容

字符串格式化

python的字符串格式化有2种方式：百分号方式、format方式

区别：百分号方式相对来说比较老；而format方式比较现先进，企图替换古老方式；目前两者并存

1、百分号方式

语法： %[(name)][flags][width].[precision]typecode:百分号支持的内类型

1、(name) 可选，用于选择指定的key

2、flags 可选，可供选择的值有

+ 右对齐；正数前加正号，负数前加负号
- 左对齐；正数前无符号，负数前加符号
空格右对齐；正数前加空格，负数前加负号
0 右对齐；正数前无序号，负数前加符号；用0填充空白处

注意：绿色是相对于数字的

3、width 可选，占有宽度

4、.precision 可选，小数点后保留的位数

5、typecode：必选

s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置

r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置

c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置

o，将整数转换成八进制表示，并将其格式化到指定位置

x，将整数转换成十六进制表示，并将其格式化到指定位置

d，将整数、浮点数转换成十进制表示，并将其格式化到指定位置，只能接收整型数字；不然会报错

e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）

E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）

f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）-->四舍五入的

F，同上

g，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）

G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）

%，当字符串中存在格式化标志(即占位符)时，需要用 %%表示一个百分号

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

常用的格式化

tpl = "i am %s" % "alex"

tpl = "i am %s age %d" % ("alex", 18)

tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}

tpl = "percent %.2f" % 99.97623-->保留2为小数

tpl = "i am %(pp).2f" % {"pp": 123.425556, }

tpl = "i am %(pp).2f %%" % {"pp": 123.425556, }

2、format方式

语法： [[fill]align][sign][#][0][width][,][.precision][type]

1、fill 【可选】空白处填充的字符

2、align 【可选】对齐方式（需配合width使用）

<，内容左对齐

>，内容右对齐(默认)

＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字

^，内容居中

3、sign 【可选】有无符号数字

+，正号加正，负号加负；

-，正号不变，负号加负；

空格，正号空格，负号加负；

4、# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示

5、，【可选】为数字添加分隔符，如：1,000,000

6、width 【可选】格式化位所占宽度

7、.precision 【可选】小数位保留精度

8、type 【可选】格式化类型-->前面要加：

传入” 字符串类型 “的参数

1、s，格式化字符串类型数据

2、空白，未指定类型，则默认是None，同s

传入“ 整数类型 ”的参数

1、b，将10进制整数自动转换成2进制表示然后格式化

2、c，将10进制整数自动转换为其对应的unicode字符

3、d，十进制整数

4、o，将10进制整数自动转换成8进制表示然后格式化；

5、x，将10进制整数自动转换成16进制表示然后格式化（小写x）

6、X，将10进制整数自动转换成16进制表示然后格式化（大写X）

传入“ 浮点型或小数类型 ”的参数

1、e，转换为科学计数法（小写e）表示，然后格式化；

2、E，转换为科学计数法（大写E）表示，然后格式化;

3、f ，转换为浮点型（默认小数点后保留6位）表示，然后格式化；

4、F，转换为浮点型（默认小数点后保留6位）表示，然后格式化；

5、g，自动在e和f中切换

6、G，自动在E和F中切换

7、%，显示百分比（默认显示小数点后6位）

常用格式化：

tpl = "i am {}, age {}, {}".format("seven", 18, \'alex\')


tpl = "i am {}, age {}, {}".format(*["seven", 18, \'alex\'])


tpl = "i am {0}, age {1}, really {0}".format("seven", 18)


tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])


tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)


tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})


tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])


tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)


tpl = "i am {:s}, age {:d}".format(*["seven", 18])


tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)-->指定接收参数的类型


tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})

tpl = "numbers: {:b},{:o},{:d},{:x},{:X},{:f},{:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tpl = "numbers: {:b},{:o},{:d},{:x},{:X},{:f},{:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)

tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

注意：当指定名称的时候；一定要注意以列表方式、元组方式和字典方式传入的写法

更多格式化操作：https://docs.python.org/3/library/string.html