绝对导入与相对导入 包的概念 编程思想的转变 软件开发目录规范 常见内置模块(collections 和 time)

目录

• 绝对导入与相对导入
  • 只要涉及到模块的导入，那么sys.path永远以执行文件为准
  • 一、绝对导入
    • 1.定义
    • 2.解释
    • 3.扩展知识
  • 二、相对导入
    • 1.定义
    • 2..储备知识
    • 3.注意事项
• 包的概念
  • 一、如何理解包
  • 二、包的作用
  • 三、具体使用
    • 针对python3解释器，其实文件夹里面有没有__init__.py文件已经无所谓了，都是包
    • 但是针对python2解释器，文件夹下面必须要有__init__.py才能被当做包
• 编程思想的转变
  • 一、小白阶段
  • 二、函数阶段
  • 三、模块阶段
• 软件开发目录规范
  • 一、原因
  • 二、各种文件夹的作用
  • 三、扩展知识
• 常见内置模块
  • 一、collection模块：提供更多的数据类型
    • 1.namedtuple
    • 2.双端队列--deque
    • 3.OrderedDict
    • 4.defaultdict
    • 5.Counter
  • 二、time模块：时间模块

绝对导入与相对导入

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

一、绝对导入

1.定义

​ 以执行文件所在的sys.path为起始路径，往下一层层查找

from ccc import b
from ccc.ddd.eee import b

2.解释

​ 由于pycharm会自动将项目根目录添加到sys.path中，所以查找模块肯定不报错的方法就是永远从根目录往下一层层找。

3.扩展知识

​ 如果不是用pycharm运行，则需要将项目根目录添加到sys.path(针对项目根目录的绝对路径有模块可以帮我们获取 >>>: os模块)

import os.path

path = os.path.abspath('aaa')
print(path)
# D:\PycharmProjects\710new_week\aaa

二、相对导入

1.定义

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

2..储备知识

	.	..	../..
表示	在当前路径	往上一层的路径	上上一层路径

3.注意事项

​ 1.只能在模块文件中使用，不能在执行文件中使用

​ 2.相对导入在项目比较复杂的情况下，可能会出错

​ ps:相对导入尽量少用，推荐使用绝对导入

包的概念

一、如何理解包

不同角度	专业角度	直观角度
理解	内部含有__init__.py的文件夹	就是一个文件夹

二、包的作用

​ 内部存放多个py文件(模块文件)，为了更加方便的管理模块文件

三、具体使用

import 包名

​ 导入包名其实是导入里面的__init__.py文件(这个文件里有什么才能用什么)，但是也可以跨过__init__.py文件直接导入包里面的模块

import pacage.mk1,pacage.mk2
# 或
from pacage import mk1, mk2

针对python3解释器，其实文件夹里面有没有__init__.py文件已经无所谓了，都是包

但是针对python2解释器，文件夹下面必须要有__init__.py才能被当做包

编程思想的转变

一、小白阶段

​ 按照需求从上往下堆叠代码（面条版）---- 单文件

​ （相当于将所有文件全部存储在C盘并且不分类）

count = 1
user_name = ['jason', 'sbc', 'cba', 'lin']
pwd = '123123'
name = input('请输入用户名：')
while count < 3:
    for name1 in user_name:
        if name == name1:
            user_pwd = input('请输入密码：')
            if user_pwd == pwd:
                print('登陆成功！')
                exit()
            else:
                print('密码错误！再试一次！')
                count += 1
                break
        else:
            print('用户不存在！')
            break
if count == 3:
    for name1 in user_name:
        if name == name1:
            user_pwd = input('请输入密码：')
            if user_pwd == pwd:
                print('登陆成功！')
                exit()
            else:
                print('机会已用完！')
                exit()
        else:
            print('用户不存在！')
            break

二、函数阶段

​ 将代码按照功能的不同封装成不同的函数 ---- 单文件

​ （相当于将所有文件存在C盘，但分类存储）

user_data = {
    '1': {'name': 'jason', 'pwd': '123', 'access': ['1', '2', '3']},
    '2': {'name': 'kevin', 'pwd': '321', 'access': ['1', '2']},
    '3': {'name': 'oscar', 'pwd': '222', 'access': ['1']}
}

# 9.创建全局变量记录用户登录状态以及当前用户的执行权限
is_login = {
    'is_login': False,
    'access_list': []
}


def auth_user(func_id):
    def outer(func_name):
        def inner(*args, **kwargs):
            # 10.先判断当前用户是否登录
            if is_login.get('is_login'):
                # 11.获取当前用户执行权限
                access = is_login.get('access_list')
                # 12.判断当前函数编号是否在用户权限内
                if func_id in access:
                    res = func_name(*args, **kwargs)
                    return res
                else:
                    print('你没有当前功能编号为:%s 的函数执行权限' % func_id)
            else:
                # 1.先获取用户的身份编号
                user_id = input('请输入您的身份编号>>>:').strip()
                # 2.判断用户编号是否存在
                if user_id in user_data:
                    # 3.获取用户名和密码
                    username = input('username>>>:').strip()
                    password = input('password>>>:').strip()
                    # 4.根据用户编号获取真实用户字典数据
                    real_dict = user_data.get(user_id)
                    # 5.比较用户名和密码是否正确
                    if username == real_dict.get('name') and password == real_dict.get('pwd'):
                        # 6.获取当前用户可执行的函数编号
                        access = real_dict.get('access')  # ['1', '2']

                        # 10.保存用户登录状态并记录用户权限
                        is_login['is_login'] = True
                        is_login['access_list'] = access

                        # 7.判断当前用户是否含有当前被装饰函数的执行权限  假设当前被装饰函数功能编号是 func_id
                        if func_id in access:
                            # 8.用户拥有该函数的执行权限
                            res = func_name(*args, **kwargs)
                            return res
                        else:
                            print('你没有当前功能编号为:%s 的函数执行权限' % func_id)

        return inner

    return outer


@auth_user('1')  # 被装饰的函数 提前传入该函数的功能编号
def func1():
    print('from func1')


@auth_user('2')  # 被装饰的函数 提前传入该函数的功能编号
def func2():
    print('from func2')


@auth_user('3')  # 被装饰的函数 提前传入该函数的功能编号
def func3():
    print('from func3')


func1()
func2()
func3()

三、模块阶段

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

​ 目的：为了更方便、快捷、高效的管理资源

​ （相当于将所有文件，按照功能不同，分门别类的存储到不同的盘里）

软件开发目录规范

一、原因

​ 针对上述的第三个阶段，分模块文件多了以后需要文件夹来分类存储

​ 我们所使用的所有的程序目录都有一定的规范（有多个文件夹）

二、各种文件夹的作用

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

三、扩展知识

​ 我们在编写软件的时候，可以不完全遵循上面的文件名

1.start.py文件可以放在bin文件夹下也可以直接放在项目根目录
2.db文件夹到后面会被数据库软件代替
3.log文件到后面会被专门的日志服务替代

常见内置模块

一、collection模块：提供更多的数据类型

1.namedtuple

from collections import namedtuple

Point = namedtuple('二维坐标系', ['x', 'y'])
res1 = Point(1, 3)
res2 = Point(10, 49)
print(res1, res2)
print(res1.x)
print(res1.y)

point = namedtuple('三维坐标系', 'x y z')
res3 = point(1, 3, 44)
res4 = point(10, 30, 44)
print(res3, res4)

poker = namedtuple('扑克牌',['花色','点数'])
res5 = poker('♠','A')
res6 = poker('♥','A')
print(res5)
print(res6)

2.双端队列--deque

from collections import deque
q = deque()
q.append(111)
q.append(222)
q.append(333)
q.append(444)
q.appendleft(55555)
# 输出deque([55555, 111, 222, 333, 444])

3.OrderedDict

from collections import OrderedDict

d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d) 	# 输出{'a': 1, 'b': 2, 'c': 3}
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od) 	# 输出OrderedDict([('a', 1), ('b', 2), ('c', 3)])

4.defaultdict

l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 100]
res = {'k1': [], 'k2': []}
for i in l1:
    if i < 66:
        res.get('k1').append(i)
    else:
        res.get('k2').append(i)
print(res)
# 输出{'k1': [11, 22, 33, 44, 55], 'k2': [66, 77, 88, 99, 100]}
from collections import defaultdict
res = defaultdict(k1=[i for i in l1 if i < 66], k2=[i for i in l1 if i >= 66])
print(res)
# 输出defaultdict(None, {'k1': [11, 22, 33, 44, 55], 'k2': [66, 77, 88, 99, 100]})

5.Counter

res = 'abcdeabcdabcaba'
new_dict = {}
for i in res:
    if i not in new_dict:
        new_dict[i]=1
    else:
        new_dict[i] += 1
print(new_dict)
# 输出{'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}

from collections import defaultdict
res = 'abcdeabcdabcaba'
from  collections import Counter
res1 = Counter(res)
print(res1)
# 输出{'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}

二、time模块：时间模块

1.time.time() 时间戳
time1 = time.time()
# 1657789770.1801758

2.localtime 本地时间
time1 = time.localtime(time.time())  
print(time1)
# time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14, tm_hour=17, tm_min=2, tm_sec=48, tm_wday=3, tm_yday=195, tm_isdst=0)

3.strftime 格式化时间
time2 = time.strftime('%Y %m %d %H:%M:%S',time1) # 格式化时间
print(time2)
# 2022 07 14 17:02:48

4.gmtime 结构化时间(UTC时区的时间)
time3 = time.gmtime(time.time())
print(time3)  # 结构化时间
# time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14, tm_hour=9, tm_min=6, tm_sec=21, tm_wday=3, tm_yday=195, tm_isdst=0)

5.mktime 将结构化时间转成时间戳
time1 = time.mktime(s)
print(time1)
# 1657789999.0

6.sleep 睡眠时间
time.sleep(3) # 睡眠三秒

详细	作用
%y	两位数的年份
%Y	四位数的年份
%m	月份
%d	年月日的日
%H	时
%M	分
%S	秒
%w	周
%x	当地日期
%X	当地时间

标签：py,导入,tm,collections,user,模块,time,print
来源： https://www.cnblogs.com/Zhang614/p/16478553.html