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

本文主要是介绍绝对导入与相对导入 包的概念 编程思想的转变 软件开发目录规范 常见内置模块(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:相对导入尽量少用，推荐使用绝对导入

包的概念

一、如何理解包

二、包的作用

​ 内部存放多个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()

三、模块阶段

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

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

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

软件开发目录规范

一、原因

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

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

二、各种文件夹的作用

三、扩展知识

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

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) # 睡眠三秒

这篇关于绝对导入与相对导入 包的概念 编程思想的转变 软件开发目录规范 常见内置模块(collections 和 time)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！