上周内容回顾

目录

常用内置函数

  1. 关键字 :abs

    求整型或浮点型的绝对值

    l = -123
print(abs(l))  # 123
print(abs(-12.2))  # 12.2

  2. 关键字：all

    指定数据集中所有的数据对应的布尔值为True时返回结果就是True，否则就是False

    l = ['lu',1,2,0]
print (all(l))  # False

  3. 关键字：any

    指定数据集中的数据有一个是True那么返回结果就是True，否则就是False

    l = ['lu',1,2,0]
print (any(l))  # True

  4. 关键字：bin、oct、hex

    将十进制转换为相对应的进制数

    bin（）  # 将括号内的十进制转为二进制数
oct（）  # 将括号内的十进制数转为八进制数
hex（）  # 将括号内的十进制数转为十六进制数

  5. 关键字：bytes

    将字符串编码为参数内相对应的进制数

    l = '我是类型转换'
print(bytes(l,'utf8'))  
# b'\xe6\x88\x91\xe6\x98\xaf\xe7\xb1\xbb\xe5\x9e\x8b\xe8\xbd\xac\xe6\x8d\xa2'
print(str(b'\xe6\x88\x91\xe6\x98\xaf\xe7\xb1\xbb\xe5\x9e\x8b\xe8\xbd\xac\xe6\x8d\xa2','utf8'))

  6. 关键字：callable

    判断当前指定的名字是否可以加括号调用,结果以布尔值的形式返回

     name = 'jason'
def index(): pass
print(callable(name))  # False
print(callable(index))  # True

  7. 关键字：chr、ord

    根据字符编码表ASCII编码表上存在的字符做出相对应的转换。

    print(chr(65))  # A   将数字转换成ASCII编码表所对应的字符
print(ord('A'))  # 65 将字符转换成ASCII编码表所对应的数字

  8. 关键字：dir

    查看指定数据类型能执行的内置方法有哪些。

    print(dir(123))
print(dir('123'))

  9. 关键字：divmod

    算出指定俩位参数之间的整数和余数，

    print(divmod(600, 25))  # (24, 0)
print(divmod(599, 25))  # (23, 24)
print(divmod(601, 25))  # (24, 1)
print(599//25) # 23
print(599%25) # 24
 print(601//25)  # 24
print(601%25)  # 1
# 相当于我们学的数学运算中的取整 取余的结合。

# 可以使用在网站分页制作上。
def a(x, y):    # 粗略的分页器
    k,l = divmod(x, y)
    print(k)  # 20
    print(l)  # 1
    if l:
        k += 1
    print(f'制作网页需要{k}页')  # 制作网页需要21页
# a(601,30)

  10. 关键字：enumerate

    枚举，对于一个可迭代对象enumerate将其组成一个索引序列，利用它可以同时获得索引和值

    dict1 = {}
list1 = ['a','b','c',]
res  =enumerate(list1)
print(list(res))
# [(0, 'a'), (1, 'b'), (2, 'c')]
for x,y in enumerate(list1,start=1):  # 不写start 默认从0开始
    dict1[x] = y
print(dict1)  # {1: 'a', 2: 'b', 3: 'c'}

  11. 关键字：eval、exec

    识别字符串中的python代码并运行

    print('print("我是谁")')  # print("我是谁")
eval('print("我是谁")')  # 我是谁  eval只能识别简单一点的
exec('print("我是谁")')  # 我是谁  exec 可以识别逻辑复杂一点的

  12. 关键字：globals

    查看局部名称空间的内置函数

    print(globals())

  13. 关键字：isinstance

    判断指定数据是不是你猜想的类型，返回结果是True和False

    print(isinstance('123', int))  # False
print(isinstance('123', str))  # True

  14. 关键字：pow

    求幂次放和数学运算中的**一样

    print(pow(10,3))  # 1000
print(10**3)  # 1000#

  15. 关键字：round

    四舍五入

    print(round(3.3,)) # 3
print(round(3.3,1)) #  3.3 参数2 控制几位

可迭代对象

  • 什么是可迭代对象

    迭代就是更新换代的意思，每次迭代都是基于上一次的成果之上。

    # 代码演示
count = 0
  while n < 10:
        print(n)
        n += 1

  • 如何判断是否为可迭代对象

    可迭代对象能够支持for循环

    	内置有__iner__方法的都叫做可迭代对象
什么是内置
		通过句点符号直接能够点出来的都叫内置

__xxx__ 针对双下划线开头和结尾的方法统一读作双下xxx

    可迭代对象：

    字符串、列表、字典、元组、集合、文件（其中文件本身也是迭代器对象）

    不可迭代对象：

    整型、浮点型、布尔值、函数名。

    # int  # 整型不是可迭代对象
# float  # 浮点型不是可迭代对象
# str  # 字符串是可迭代对象
# list  # 列表是可迭代对象
# dict  # 字典是可迭代对象
# tuple  # 元组是可迭代对象
# set  # 集合是可迭代对象
# bool  # 布尔值不是可迭代对象
# def index():  # 函数名不是可迭代对象
#     print()
# f = open(r'01 考题讲解.py','r',encoding='utf8')  # 文件对象是可迭代对象

迭代器对象

  • 迭代器对象

    迭代器对象给我们提供了一种不依赖索引取值的方式

  • 如何判断迭代器对象

    内置有 __ iter __ 和 __ next __ 方法的对象都被称之为迭代器对象

  • 可迭代对象与迭代器对象的关系

    可迭代对象在调用 __ iter __ 内置方法后会转变为迭代器对象

    迭代器对象在调用 __ iter __内置方法后其还是迭代器对象本身

  • 迭代器对象迭代取值

    res = 'jason'.__iter__()  # res已经是迭代器对象
print(res.__next__())  # j
print(res.__next__())  # a
print(res.__next__())  # s
print(res.__next__())  # o
print(res.__next__())  # n
print(res.__next__())  # 没有了直接报错

d1 = {'name':'jason','pwd':123} 
res = d1.__iter__()
print(res.__next__())
print(res.__next__())

l1 = [11, 22, 33, 44, 55, 66, 77, 88]
# 需求:不使用for循环 依次打印出列表中所有的数据值
# 1.先将列表变成迭代器对象
res = l1.__iter__()
# 2.定义一个计数器
count = 0
# 3.编写while循环
while count < len(l1):
    print(res.__next__())
    count += 1

  • 迭代器反复使用

    1. 当一个可迭代对象每次重复调用 __ iter __内置方法的时候都是在可迭代对象本身产生的了一个新的迭代器对象

      # 每次都是产生了一个新的迭代器对象,
l = [11, 22, 33, 44]
# print(l.__iter__().__next__())  # 11  
# print(l.__iter__().__next__())  # 11
# print(l.__iter__().__next__())  # 11
# print(l.__iter__().__next__())  # 11

    2. 当一个迭代器对象在重复调用 __ iter __ 和 __ next __的时候都是在迭代器对象本身产生了一个新的迭代器对象。

      # 每次使用的都是一个迭代器对象
l = [11, 22, 33, 44]
res = l.__iter__()
print(res.__iter__().__next__())  # 11 
print(res.__iter__().__next__())  # 22
print(res.__iter__().__next__())  # 33
print(res.__iter__().__next__())  # 44

    3. 针对双下的简写方式

      res = l.__iter__()  
iter(l)
# 可以简写iter(l)
res.__next__() 
next(res1)
# 可以简写next(res1)

    4. 迭代器对象的特殊地方

      可迭代对象，迭代器对象，，通过打印操作无法直接看出内部数据情况。

      它们相当于是一个工厂你要数据它们就临时帮你造一个数据。

      这个时候它们可以帮我们节省内存空间。

for循环的本质

  • 语法结构

    for 变量名 in 可迭代对象：

    for循环体代码

    for循环在运行时的低层原理

    1. for会自动将in后面的数据调用 __ iter __ 方法改变为迭代器对象

    2. 之后每次循环调用 __ next __ ()取值

    3.最后 __ next __ 会报错 for 循环能够直接自动处理报错改正常结束！！！

异常处理

  • 什么是异常

    异常就是程序运行的过程中出现的错误导致整个程序直接结束！！！

    也就是我们所说的bug！！！

  • 异常的结构

    1. 关键字line所在行，精确的提示你哪一行代码出现的问题

      下方也会列出，出错的代码。

    2. 最后一行冒号的左侧，提示信息是错误的类型

    3. 最后一行冒号右侧，提示错误的具体原因

  • 异常的类型

    异常的类型有很多种，以下简单的列举几种。

    NameError  
IndexError 
KeyError
SyntaxError
TypeError

  • 异常的分类

    1. 语法异常

      语法异常是指在编写代码过程中语法不全、语法格式不规范等导致的。

      是我们在编写代码中不允许出现的，一旦出现立即改正。

    2. 逻辑异常

      逻辑异常是指在编写代码过程中，可能会因为思想中的情况与现实中代码不一致

      这种问题可以出现，出现后改正即可，问题不大!!!

异常处理方式

  • 基本语法结构

    try:
    name 
    """可能会出错的代码（被try监控）"""
except NameError as e：
"""except(关键字) NameError(错误类型) as e：（e就是具体错误的原因）"""
	name = 'jason' # 对应错误类型的解决措施

  • 方式1

    可以使用多个也可以使用单个，这种方式针对性很强。需要写入准确的错误类型

    或者如下填写多个所猜测的不确定类型，但是一旦错误类型不匹配同样抛出异常。

    try:
    name 
except NameError as e：
	name = 'jason' # 对应错误类型的解决措施
except 错误类型1 as e:  # e就是具体错误的原因
	对应错误类型1的解决措施
except 错误类型2 as e:  # e就是具体错误的原因
	对应错误类型2的解决措施
except 错误类型3 as e:  # e就是具体错误的原因
	对应错误类型3的解决措施
except 错误类型4 as e:  # e就是具体错误的原因
	对应错误类型4的解决措施

  • 方式2

    万能处理异常

    # 示例1
try：

  123+'hello'
"""万能异常处理方式1"""
except Exception as e:
"""对应的解决措施"""
# 示例2
try：
	d = {'name':'jason'}
	d['pwd']
"""万能异常处理方式21"""
except BaseException as e：
"""对应的解决措施"""
异常处理的其他补充

  • else 与 finally结合使用

    try:
    name ='jason'
except Exception as e:
    print(1111)"""try监测的代码出现问题则会执行此代码"""
else:
    print(222222)
    """try监测的代码没有出现异常则会执行else的子代码"""
finally:
    print(333333)
    """try监测的代码无论是否出现异常都会执行finally的子代码"""

  • 断言

    断言语句是一种调试工具，用来测试某个断言条件，如果断言条件为True

    则程序继续正常执行，如果是false则会抛出异常。

    name = 'jason'  # 通过一系列的手段获取来的数据
assert isinstance(name, list)  # 断言数据属于什么类型 如果不对则直接报错 对则正常执行下面的代码
print('针对name数据使用列表相关的操作')

  • 主动抛出异常

    关键字：raise

    name = input("username>>>:").strip()
if name == 'jason':
    """条件成立后主动抛出异常"""
    raise Exception（'提示错误信息'）
    """raise后面的异常类型不写，默认抛出当前错误类型
       如果有写错误类型则抛出当前所写类型，异常类型后面的提示代码
       如果有写则返回该提示信息如果没有则没有
    """
else
    print('判断不成立后执行的结果')
"""
异常捕获能尽量少用就尽量少用
被try监测的代码能少就少，节省内存资源消耗！！！

"""

  • 异常处理练习

    使用while+异常处理可以实现for循环功能

    list1 = [1,2,3,4,5,6]
res = list1.__iter__()
while True:
    try:
        print(res.__next__())
    except Exception:
            break

生成器对象

  • 什么是生成器

    生成器的本质其实就是迭代器对象

    只不过迭代器是解释器给我们提供的，而生成器是我们直接定义的.

  • 生成器对象的作用

    生成器对象可以优化代码，是一种不依赖索引取值的通用方式

  • 生成器对象代码实现

    函数+关键字yield的使用

    """
当函数体代码中有yield关键字
那么函数名第一次加括号调用不会执行函数体代码
而是由普通的函数变成了生成器对象
"""
def index():
    print('我是函数体代码1')
    yield '我是返回值1'
    print('我是函数体代码2')
    yield '我是返回值1'
print(index())
# <generator object index at 0x0000021DE9F5CAC0>
res = index()
print(res)
# <generator object index at 0x0000025F24A4CAC0>
# 此时的res就是一个生成器对象也就是迭代器对象

res.__next__()  # 我是函数体代码1
res.__next__()  # 我是函数体代码2
"""
yield可以在函数体代码中出现多次
每次调用__next__方法都会触发执行函数体代码
直到遇到yield代码停留在此处，等待下一次调用
"""
print(res.__next__())
print(res.__next__())
# 我是函数体代码1
# 我是返回值1
# 我是函数体代码2
# 我是返回值1

"""
yield后面如果有数据值 则会像return一样返回出去
如果有多个数据值逗号隔开 那么也会自动组织成元组返回
"""

  • 课堂练习

    编写生成器实现内置函数range方法的功能

    def my_range(x, y=0, z=1):
    z = abs(z)
    if y:
        x, y = y, x
    while y < x:
        yield y
        y += z
for i in my_range(1,10,2):
    print(i)  # 1、3、5、7、9
yield的其它用法

  • yield与send结合用法

    yield不单单可以向外返回数据还可以接受数据

    def index(name,food=None):
    print(f'{name}准备干午饭!!!')
    while True:
        food = yield
        print(f'{name}正在{food}')
res = index('jason')
res.__next__()
# 传值给yield并自动调用__next__方法
res.send('吃生蚝')  # jason正在吃生蚝
res.send('吃烤羊腰子')  # jason正在吃烤羊腰子
res.send('做大宝剑')  # jason正在做大宝剑
# 生成器res调用send方法可以向yield传值，并调用__next__方法
生成器表达式

  • 什么是生成器表达式

    可以简单的理解为使用for能够快速的构造一个生成器对象。

    tuple1 = ( i for i in range(10) )
print(tuple1)  # <generator object <genexpr> at 0x00000249C8ACCAC0>
# 此时的tuple1就是一个生成器对象，可以多次调用__next__方法将其依次取出。
print(tuple1.__next__())  # 0
print(tuple1.__next__())  # 1
print(tuple1.__next__())  # 2
# 也可以使用类型转换将其转换为列表类型全部取出。
print(list(tuple1))  # [3, 4, 5, 6, 7, 8, 9]

# 面试题
def add(n, i):  # 普通函数 返回两个数的和  求和函数
    return n + i
def test():  # 生成器
    for i in range(4):
        yield i
g = test()  # 激活生成器
for n in [1, 10]:
    g = (add(n, i) for i in g)
    """
    第一次for循环
        g = (add(n, i) for i in g)
    第二次for循环
        g = (add(10, i) for i in (add(10, i) for i in g))
    """
res = list(g)
print(res)

#A. res=[10,11,12,13]
#B. res=[11,12,13,14]
#C. res=[20,21,22,23]
#D. res=[21,22,23,24]
ps:掌握技巧即可 无需深究 纯粹为了考试而出 没有多少实际意义 嵌套不符合编程规范

迭代取值与索引取值的差异

索引取值

  • 优点：可以随意并反复的获取任意数据值

  • 缺点：针对无序的容器类型无法使用索引取值

    示例：

    l1 = [11, 22, 33, 44, 55]
print(l1[0])
print(l1[1])
print(l1[0])
迭代取值

  • 优点：提供了一种不依赖索引取值的方式

  • 缺点：取值一旦开始只能依次往下取值不能重复取之前的值。

    示例：

    l1 = [11, 22, 33, 44, 55]
res = l1.__iter__()
print(res.__next__())
print(res.__next__())
print(res.__next__())

模块的简介

  • 什么是模块

    模块可以看成是一些功能的结合体

    使用模块就相当于拥有了结合体所有的功能

模块的分类

  • 内置模块

    解释器自带的模块，通过import加上模块名像将其导入后通过模块名加点的方式直接调用其内部代码。

    示例：

    import time  # 导入模块关键字、模块名
	time.time	# 调用模块内的代码

  • 第三方模块

    别人写好的模块，存于网络之上，使用前提前下载好。

  • 自定义模块

    自己编写的代码存储与py文件中，文件名就是后续导入的模块名

    模块名不能与python中的内置模块名起冲突。

  • 模块的表现形式

    1. py文件（又被称之为模块文件）
    2. 含有多个py文件的文件夹（按照模块功能的不同划分不同的文件夹储存）
    3. 已被编译为共享库或DLL的c或C++扩展(了解)
    4. 使用C编写并链接到python解释器的内置模块(了解)

模块导入的俩种句式

导入模块句式1

import+模块名

首先执行文件为one.py，需要导入的是two.py

  1. 在执行文件内运行代码，先产生执行文件one.py的名称空间，将里面的名字存入one.py名称空间内。
  2. import two导入two.py文件。
  3. 产生被导入文件的名称空间后，并运行文件内的代码将产生的名字存储在该名称空间内
  4. 使用two.index（）就是向two.py名称空间索要名字index调用。
导入模块句式2

from（模块名） import（模块名称空间的名字）

指明道姓的导入，可以简单的理解为我只需要从模块名称空间内拿到我指定的名字其他的不需要

  1. 首先执行one.py，产生一个名称空间
  2. 然后执行被导入two.py文件，产生一个名称空间，并运行代码将名字存入名称空间
  3. 在执行文件中获取到指定的名字，指向被导入文件的名称空间
俩种句式的差异

  • import one

    优点：通过one点的方式可以使用到模块内所有的名字，而且不会和执行文件起冲突

    缺点: one什么都可以点，有时候并不像让所有的名字都能够被使用

  • from one import index ，get_num

    优点：指明道姓的使用指定的名字，并且不需要用模块名加点的方式调用

    缺点：名字及其容易产生冲突（绑定关系被修改）

模块的其他知识

  • 起别名

    多个模块文件名相同，比如多人写的模块需要结合到一起使用

    但魔魁名字又是相同的这个时候可以考虑到使用起别名这个方法

    from one import index as one_index
from two import index as two_index
print(one_index)
print(two_index)

  • 导入多个指定名字

    import time, sys, os
# 上述导入方式建议多个模块功能相似才能适应 不相似尽量分开导入
import time
import os
import sys

from md import money, read1, read2	
# 上述导入方式是推荐使用的 因为多个名字出自于一个模块文件

  • 全部导入

    需求:需要使用模块名称空间中很多名字 并且只能使用from...import句式
 	from md import *  # *表示所有
 针对*号的导入还可以控制名字的数量
 在模块文件中可以使用__all__ = [字符串的名字]控制*能够获取的名字
循环导入问题

  • 什么是循环导入

    可以理解为俩个文件彼此相互导入彼此，

这样导入容易出现报错现象，使用彼此的名字可能是在没有准备好的情况就使用了。

如何解决循环导入保存现象，彼此在使用彼此名字之前 先准备好。

循环导入将来尽量避免出现!!! 如果真的避免不了 

就想办法让所有的名字在使用之前提前准备好。

判断文件类型

学习完模块之后 以后我们的程序运行起来可能涉及到的文件就不止一个

所有的py文件中都自带一个__name__内置名
	当py文件是执行文件的时候 __name__的结果是__main__
	当py文件是被导入文件的时候 __name__的结果是模块名(文件名)
    
__name__主要用于开发模块的作者测试自己的代码使用
	if __name__ == '__main__':
    	当文件是执行文件的时候才会执行if的子代码
        

上述判断一般只出现整个程序的启动文件中

ps:在pycharm中可以直接编写main按tab键自动补全

模块的查找顺序

  1. 导入一个文件，然后再导入的过程中删除该文件发现还可以使用

    """
1.先去内存中查找
2.再去内置中查找
3.再去sys.path中查找(程序系统环境变量)  下面详细的讲解
"""
	 import md
    import time

    time.sleep(15)
    print(md.money)

  2. 创建一个跟内置模块名相同的文件名

    	 # import time
    # print(time.time())
    from time import name
    print(name)
	 ps:创建模块文件的时候尽量不要与内置模块名冲突

  3. 导入模块的时候一定要知道谁是执行文件

    所有的路径都是参照执行文件来的

    	 import sys
    sys.path.append(r'D:\pythonProject\day22\xxx')
    import mdd
    print(mdd.name)
"""
1.通用的方式
	sys.path.append(目标文件所在的路径)
2.利用from...import句式
	起始位置一定是执行文件所在的路径
	from xxx import mdd
"""

绝对导入和相对导入

只要涉及到模块导入，那么SYS.path永远以执行文件为准

  • 绝对导入

    其实就是以执行文件所在的sys.psth为其实位置，一层层查找导入。

    使用from句式

    from ccc import b

    from ccc.ddd.eee import

  • 相对导入

    储备知识

    . 在路径中的意思是，当前路径
    .. 在路径中的意思是，上一层路径
    ../.. 在路径中的意思是，上上一层路径

    相对导入可以不参考执行文件所在的路径，直接以当前模块文件为准

    只能再模块文件中使用，不能在执行文件中使用

    相对导入在项目比较复杂的情况下使用可能会出错，尽量少用推荐使用绝对导入

包的概念

  • 什么是包

    包就是内部不含有 __ init __ .py文件的文件夹，可以简单的理解它就是一个文件夹

  • 包的使用

    包的内部存放多个模块文件，仅仅是为了方便的管理模块文件

  • 具体使用

    import 包名

    导入包名其实就是导入里面 __ init __ .py文件，其内部有哪些模块你就能用哪些模块，也可以跨过 __ init __ .py文件直接导入包里面的其他模块文件

    其中不同版本的解释器在包的概念上有着不同的区分

    python2版本 文件夹下必须有 __ init __ .py才能被当作包
    python3版本 文件夹下有没有 __ init __ .py文件都是包

编程思想的进阶

  1. 小白阶段

    按照需求从上往下堆叠代码（面条版）

  2. 函数阶段

    将代码按照功能的不同封装成不同的函数

  3. 模块阶段

    根据功能的不同拆分不同的模块文件

  • 目的就是为了更加方便快捷的管理资源。

软件目录开发规范

模块阶段，拆分不同模块的文件还需要有文件夹，有了多个文件夹

我们所使用后的所有程序目录都要有一定的规范，也便于管理。

文件夹名称 作用 模块文件名
bin 存储程序的启动文件 start.py
conf 存储程序的配置文件 settings.py
core 存储程序的核心逻辑 src.py
lib 存储程序的公共功能 common.py
db 存储程序的数据文件 userinfo.txt
log 存储程序的日志文件 log.log
interrsace 存储程序的接口文件 user.py、orde.py、goods.py
readme 编写程序的说明、介绍、广告等
requirements.txt 存储程序所需的第三方模块和版本

我们在编写软件的时候 可以不完全遵循上面的文件名
start.py可以放在bin文件夹下也可以直接放在项目根目录
db文件夹等我们学到真正的项目会被数据库软件替代
log文件夹等我们学到真正的项目会被专门的日志服务替代

常用内置模块

collections模块

  • 具名元组 from collections import namedtuple

    from collections import namedtuple  
point = namedtuple('二维坐标系',['x','y'])
 res = point(20,3)
 print(point)  # 二维坐标系(x=20, y=3)

  • 双端队列 from collections import deque

    from collections import deque 
q = deque(['a','l','s'])
print(q)
q.append('x')
q.appendleft('a')
print(q)
q.pop()
q.popleft()
print(q)

  • 有序字典 from collections import OrderedDict

    from collections import OrderedDict 
od = OrderedDict([('name','jason'),('age',18),('salary',3000.1)])
print(od)

  • 默认值字典 from collections import defaultdict

    from collections import defaultdict  
d = defaultdict(k1=[],k2=[])
print(d)  # # defaultdict(None, {'k1': [], 'k2': []})

  • 统计数据种字符的个数 from collections import Counter

    from collections import Counter 
a = 'asdfgasdfasdasaasdfg'
print(Counter(a))
#Counter({'a': 6, 's': 5, 'd': 4, 'f': 3, 'g': 2})
time模块，时间模块

  • 表达时间的三种方式

    1. 时间戳 time.time

      计算1970年一月一号零时零分零秒到当前时间，以秒为单位。

      time_stamp= time.time()
print(time_stamp)
# 1657795246.6333282

    2. 结构化时间

      2.1以UTC时间为准计算当前的时间 time.gmtime

      structured_time = time.gmtime()
print(structured_time)
"""
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14,
tm_hour=10, tm_min=43, tm_sec=53,
tm_wday=3, tm_yday=195, tm_isdst=0)

      2.2以本地时间为准计算当前时间 time.localtime

      local_time = time.localtime()
print(local_time)
"""
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14, 
tm_hour=19, tm_min=1, tm_sec=41, 
tm_wday=3, tm_yday=195, tm_isdst=0)

"""

    3. 格式化时间 time.strftime

      以个格式化的方式计算当前时间

      format_time = time.strftime('%Y-%m-%d %H:%M:%S')
print(format_time)  # 2022-07-14 18:50:04

    4. 结构化时间转时间戳

      change = time.mktime(local_time)
print(change)  # 1657796654.0

    5. 格式化时间转结构化

      change3 = time.strptime('2022-07-14 18:50:04','%Y-%m-%d %H:%M:%S')
print(change3)
"""
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14, 
tm_hour=18, tm_min=50, tm_sec=4,
 tm_wday=3, tm_yday=195, tm_isdst=-1)
"""
datetime模块

与time模块相似，都是与时间相关的模块

import datetime  # 导入模块
# datetime    年月日 时分秒
res = datetime.datetime.today()
# 2022-07-15 09:53:46.004000 

# date 年月日
res1 = datetime.date.today()  # 2022-07-15

print(res.year)
print(res.month)
print(res.weekday())
print(res.isoweekday())
date        年月日

tl = datetime.timedelta(days=3)
print(res1 + tl)  # 2022-07-18
print(res1 - tl)  # 2022-07-12
"""
timedelta括号内有很多参数 没有的时间可以通过换算得来
"""

print(datetime.datetime.now())
print(datetime.datetime.utcnow())
c =datetime.datetime(2017, 5, 23, 12, 20)
print('指定日期：',c)
os模块

os模块主要是跟当前程序所在的操作系统打交道

  • os.mkdir 只创建单级目录（文件夹）

    只能创建单级目录，不能创建多级目录。

    import os
os.mkdir('文件夹名称')

  • os.makedirs 可创建单级或多级目录（文件夹）

    可以创建单个或者多个目录

    import os
os.makedirs('文件夹名称')

  • os.rmdir 删除单级目录（文件夹）

    只能删除单个目录，且目录内不能有任何数据。

    import os
os.rmdir('文件夹名称')

  • os.removedirs 删除多级目录

    可以删除多级目录，由内而外递归删除空目录，只能有数据的目录才停止

    import os
os.removedirs('文件夹名称')

  • os.listdir 列举指定路径下的文件名称（文件、目录）

    将指定路径下的所有文件及目录列举出来组成一个列表

    print(os.listdir())  
# ['.idea', '01 datetime模块.py', '02 os模块.py', 'ccc']
print(os.listdir(r'D:\\')

  • os.rename 重命名文件

    用代码实现将文件名称重新命名

    os.rename('旧文件名','新文件名')

  • os.remove 删除文件

    将指定的文件直接删除

    os.remove(r'文件名')

  • os.getcwd 获取当前所在的绝对路径

     print(os.getcwd())  # D:\pythonProject\day24

  • chdir 切换当前路径

    os.chdir(r'..')
# ..切换到上层路径
# ../..切换到上上层路径

  • os.path.abspath 获取当前文件所在的绝对路径

    print(os.path.abspath(__file__))

  • os.path.dirname 获取当前文件所在的目录路径

    print(os.path.dirname(__file__))

  • os.path.exists 判断路径是否存在指定的文件、目录。

    此方法文件和目录都可以使用。返回结果为True或False

    print(os.path.exists(r'ATM'))  # True

  • os.path.isdir 判断路径是否存在指定的目录

    此方法只判断路径下是否有指定的目录，文件不行。返回结果为True或False

    print(os.path.isdir(r'ccc'))  # True

  • os.path.file 判断路径是否存在指定的文件

    此方法只判断路径下是否有指定的文件，目录不行。返回结果为True或False

    print(os.path.isfile(r'01 datetime模块.py'))  # True

  • os.path.join 拼接路径

    将指定的俩个路径拼接到一起。

    join方法可以自动识别当前所在的操作系统并自动切换正确的分隔符

    res = os.path.join(absolute_path, relative_path)
print(res)

  • os.path.getsize 获取文件的大小

    获取文件中所有数据共计多大单位，以bytes为单位

    print(os.path.getsize(r'02 os模块.py'))  # 2363
print(os.path.getsize(r'a.txt'))  # 17
sys模块

sys模块主要是跟python解释器打交道

print(sys.path)  # 结果是列表
print(sys.version)  # 查看解释器信息
print(sys.platform)  # 查看当前平台
res = sys.argv
'''需求 命令行执行当前文件必须要提供用户名和密码 否则不准执行'''
if len(res) == 3:
    username = res[1]
    password = res[2]
    if username == 'jason' and password == '123':
        print('您可以正在执行该文件')
    else:
        print('用户名或密码错误')
else:
    print('请填写用户名和密码 二者不可或缺')
# 上述校验也可以使用异常捕获实现(课下实现)
json模块

  • json模块也称之为序列化模块

    json模块是不同编程语言之间数据交互必备的模块(处理措施)

  • json格式的数据应该是什么

    数据基于网络传输肯定是二进制 那么在python中只有字符串可以调用encode方法转成二进制数据 所以json格式的数据也属于字符串

  • ​ json格式的数据有一个非常明显的特征
    ​ 首先肯定是字符串 其次引号是标志性的双引号

    d = {'name': 'jason', 'pwd': 123}
# 需求:将上述字典保存到文件中 并且将来读取出来之后还是字典
# with open(r'b.txt','w',encoding='utf8') as f:
#     f.write(str(d))
# with open(r'b.txt','r',encoding='utf8') as f:
#     data = f.read()
#     print(data, type(data))

# import json
# res = json.dumps(d)  # 序列化    将其他数据类型转换成json格式字符串
# print(res, type(res))
# {"name": "jason", "pwd": 123} <class 'str'>
# d1 = {"name": "jason", "pwd": 123}
# print(d1)  # {'name': 'jason', 'pwd': 123}
# res1 = json.loads(res)  # 反序列化   将json格式字符串转换成对应编程语言中的数据类型
# print(res1, type(res1))  # {'name': 'jason', 'pwd': 123} <class 'dict'>

# import json
# with open(r'b.txt','w',encoding='utf8') as f:
#     # f.write(json.dumps(d))
#     json.dump(d, f)  # 直接让字典写入文件(json自动帮你完成转换)
# with open(r'b.txt','r',encoding='utf8') as f:
#     # data = f.read()
#     # res = json.loads(data)
#     # print(res, type(res))
#     res = json.load(f)
#     print(res, type(res))

"""
dumps()     将其他数据类型转换成json格式字符串
loads()     将json格式字符串转化成对应的数据类型

dump()      将其他数据数据以json格式字符串写入文件
load()      将文件中json格式字符串读取出来并转换成对应的数据类型
"""
posted @   瓮小辉  阅读(20)  评论(0)  编辑  收藏  举报
相关博文：
·  今日内容回顾7.13
·  今日内容回顾7.11
·  【python基础】第27回 周总结
·  【2022-07-17】上周内容回顾
·  【7.17 】 周总结
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
点击右上角即可分享
微信分享提示
SQL AI 助手