精华内容
下载资源
问答
  • 2019-04-06 14:18:56

    随着我们不断地在一个文件中添加新的功能, 就会使得文件变得很长。 即便使用了继承,也抑制不住类的成长。为了解决这一问题,我们可以将类存储在模块中, 然后在主程序中导入所需的模块,这样可以让文件尽可能保持整洁,从而实现更好的管理。

    导入类是一种很有效的编程方式。 这样我们就可以把大部分逻辑存储在独立的文件中,然后在主程序编写高级逻辑咯O(∩_∩)O哈哈~

    1 导入一个类

    假设有一个 User 类,文件名为 User.py,这个待导入的文件,一般称为模块:

    class User():
        '''账号信息'''
    
        def __init__(self, name, pwd):
            '''初始化'''
            self.name = name
            self.pwd = pwd
            # 登陆次数
            self.login_count = 0
    
        def print_login_count(self):
            '''打印登陆次数'''
            print('登陆次数=' + str(self.login_count))
    
        def update_login_count(self, num):
            '''更新登陆次数'''
            self.login_count = num
    
        def valid(self):
            '''是否验证通过'''
            print(self.name + ' 验证通过')

    我们再定义一个名为 deniro.py 的文件,来导入刚刚定义的 User 类:

    from User import User
    
    
    deniro = User('deniro', '1')
    print('账号名:' + deniro.name)

    运行结果:

    账号名:deniro

    2 导入一个模块多个类

    可以根据需要,在同一个模块中定义任意数量的类,不过这些在同一个模块中的类最好是相关的。

    我们在 User.py 中定义了一个 Privilege 类,并作为 User 类的属性:

    class User():
        '''账号信息'''
    
        def __init__(self, name, pwd):
            '''初始化'''
            self.name = name
            self.pwd = pwd
            # 登陆次数
            self.login_count = 0
            # 拥有的权限
            self.privileges = Privilege(['修改某某账号密码', '禁用某某账号'])
    
        def print_privileges(self):
            '''打印拥有的权限'''
            print(self.privileges.contents)
    
    ...
    
    
    
    
    
    
    class Privilege():
        '''权限'''
    
        def __init__(self, contents):
            self.contents = contents

    然后在新的文件中调用它:

    # 导入一个类
    from User import User
    
    
    deniro = User('deniro', '1')
    print('拥有的权限:' + str(deniro.privileges.contents))

    运行结果:

    拥有的权限:['修改某某账号密码', '禁用某某账号']

    3 导入多个类

    可以在一个模块中导入多个类, 用逗号分隔这些需要导入类。 导入后, 就可以根据应用场景,来创建任意数量的类实例。

    from User import User,Privilege
    
    p=Privilege(["删除账号权限"])
    print('权限内容:'+str(p.contents))

    运行结果:

    权限内容:['删除账号权限']

    4 导入模块

    我们还可以一次性导入整个模块, 这需要使用句点表示法来调用相应的类:

    import User
    
    ...
    
    p=User.Privilege(["删除账号权限"])
    ...

    4 导入所有类

    from User import *

    非必要,不使用这种导入方式,因为:

    1. 通过文件开头定义良好的 import 语句, 我们就可以清楚地知道使用了哪些类。但这种导入方式没有提供这种好处。
    2. 如果不小心导入了一个与本程序文件中同名的类, 就会引发难以诊断的错误。

    如果确实需要从一个模块中导入很多类,那么建议导入整个模块, 然后使用 module_name.class_name 语法来调用它们。

    5 在模块中导入另一个模块

    为了避免模块太大或者保证模块中的类都是相关的, 这时就需要将类分散到多个模块中。这样, 可能一个模块中的类会依赖另一个模块中的类。这种场景下, 我们就会在一个模块中导入另一个模块。因为导入语法相同,所以在此就不赘述啦O(∩_∩)O~

    建议一开始让代码结构尽可能简单。 即先尽可能在一个文件中完成所有的工作, 确定一切都能满足业务要求正确执行后,再将类移到独立的模块中。

    更多相关内容
  • 前言 随着我们不断地在一个文件中添加新的功能, 就会使得文件变...假设有一个 User ,文件名为 User.py,这个待导入的文件,一般称为模块: class User(): '''账号信息''' def __init__(self, name, pwd): '''
  • @Import注解:导入配置的四种方式&源码解析

    千次阅读 热门讨论 2021-03-06 17:02:46
    平时喜欢看源码的小伙伴,应该知道Spring...该注解是Spring用来导入配置的,等价于`Spring XML`中的`<import/>`元素。 本文将对该注解进行介绍,并通过实例演示它导入配置的四种方式,最后对该注解进行源码解析。

    微信搜索:码农StayUp
    主页地址:https://gozhuyinglong.github.io
    源码分享:https://github.com/gozhuyinglong/blog-demos

    平时喜欢看源码的小伙伴,应该知道Spring中大量使用了@Import注解。该注解是Spring用来导入配置类的,等价于Spring XML中的<import/>元素。

    本文将对该注解进行介绍,并通过实例演示它导入配置类的四种方式,最后对该注解进行源码解析。

    话不多说,走起~

    简介

    @Import注解的全类名是org.springframework.context.annotation.Import。其只有一个默认的value属性,该属性类型为Class<?>[],表示可以传入一个或多个Class对象。

    通过注释可以看出,该注解有如下作用:

    • 可以导入一个或多个组件类(通常是@Configuration配置类)
    • 该注解的功能与Spring XML中的<import/>元素相同。可以导入@Configuration配置类、ImportSelectImportBeanDefinitionRegistrar的实现类。从4.2版本开始,还可以引用常规组件类(普通类),该功能类似于AnnotationConfigApplicationContext.register方法。
    • 该注解可以在类中声明,也可以在元注解中声明。
    • 如果需要导入XML或其他非@Configuration定义的资源,可以使用@ImportResource注释。

    导入配置类的四种方式

    源码注释写得很清楚,该注解有四种导入方式:

    1. 普通类
    2. @Configuration配置类
    3. ImportSelector的实现类
    4. ImportBeanDefinitionRegistrar的实现类

    下面我们逐个来介绍~

    准备工作

    创建四个配置类:ConfigA、ConfigB、ConfigC、ConfigD。其中ConfigB中增加@Configuration注解,表示为配置类,其余三个均为普通类。

    ConfigA:

    public class ConfigA {
    
        public void print() {
            System.out.println("输出:ConfigA.class");
        }
    }
    

    ConfigB:

    @Configuration
    public class ConfigB {
    
        public void print() {
            System.out.println("输出:ConfigB.class");
        }
    
    }
    

    ConfigC:

    public class ConfigC {
    
        public void print() {
            System.out.println("输出:ConfigC.class");
        }
    
    }
    

    ConfigD:

    public class ConfigD {
        
        public void print() {
            System.out.println("输出:ConfigD.class");
        }
    
    }
    

    再创建一个主配置类Config,并试图通过@Resource注解将上面四个配置类进行注入。当然,这样是不成功的,还需要将它们进行导入。

    @Configuration
    public class Config {
    
        @Resource
        ConfigA configA;
    
        @Resource
        ConfigB configB;
    
        @Resource
        ConfigC configC;
    
        @Resource
        ConfigD configD;
    
    
        public void print() {
            configA.print();
            configB.print();
            configC.print();
            configD.print();
        }
    }
    

    方式一:导入普通类

    导入普通类非常简单,只需在@Import传入类的Class对象即可。

    @Configuration
    @Import(ConfigA.class)
    public class Config {
       ...
    }
    

    方式二:导入@Configuration配置类

    导入配置类与导入普通类一样,在@Import注解中传入目标类的Class对象。

    @Configuration
    @Import({ConfigA.class,
            ConfigB.class})
    public class Config {
        ...
    }
    

    方式三:导入ImportSelector的实现类

    ImportSelector接口的全类名为org.springframework.context.annotationImportSelector。其主要作用的是收集需要导入的配置类,并根据条件来确定哪些配置类需要被导入。

    该接口的实现类同时还可以实现以下任意一个Aware接口,它们各自的方法将在selectImport之前被调用:

    另外,该接口实现类可以提供一个或多个具有以下形参类型的构造函数:

    如果你想要推迟导入配置类,直到处理完所有的@Configuration。那么你可以使用DeferredImportSelector

    下面我们创建一个实现该接口的类 MyImportSelector。

    看下面示例:

    selectImports方法中,入参AnnotationMetadata为主配置类 Config 的注解元数据。
    返回值为目标配置类 ConfigC 的全类名,这里是一个数组,表示可以导入多个配置类。

    public class MyImportSelector implements ImportSelector {
        
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{"io.github.gozhuyinglong.importanalysis.config.ConfigC"};
        }
    }
    

    在配置类 Config 中导入 MyImportSelector 类。

    @Configuration
    @Import({ConfigA.class,
            ConfigB.class,
            MyImportSelector.class})
    public class Config {
        ...
    }
    

    方式四:导入ImportBeanDefinitionRegistrar的实现类

    该接口的目的是有选择性的进行注册Bean,注册时可以指定Bean名称,并且可以定义bean的级别。其他功能与ImportSelector类似,这里就不再赘述。

    下面来看示例:

    创建一个实现 ImportBeanDefinitionRegistrar 接口的类 MyImportBeanDefinitionRegistrar,并在 registerBeanDefinitions方法中注册 configD 类。
    入参 AnnotationMetadata为主配置类 Config 的注解元数据;BeanDefinitionRegistry参数可以注册Bean的定义信息。

    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            registry.registerBeanDefinition("configD", new RootBeanDefinition(ConfigD.class));
        }
    }
    

    在配置类 Config 中导入 MyImportBeanDefinitionRegistrar 类。

    @Configuration
    @Import({ConfigA.class,
            ConfigB.class,
            MyImportSelector.class,
            MyImportBeanDefinitionRegistrar.class})
    public class Config {
        ...
    }
    

    测试结果

    创建一个测试类 ImportDemo,看上面四个配置类是否被注入。

    public class ImportDemo {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
            Config config = ctx.getBean(Config.class);
            config.print();
        }
    }
    

    输出结果:

    输出:ConfigA.class
    输出:ConfigB.class
    输出:ConfigC.class
    输出:ConfigD.class
    

    通过输出结果可以看出,这四个配置类被导入到主配置类中,并成功注入。

    源码解析

    ConfigurationClassParser类为Spring的工具类,主要用于分析配置类,并产生一组ConfigurationClass对象(因为一个配置类中可能会通过@Import注解来导入其它配置类)。也就是说,其会递归的处理所有配置类。

    doProcessConfigurationClass

    其中的doProcessConfigurationClass方法是处理所有配置类的过程,其按下面步骤来处理:

    1. @Component注解
    2. @PropertySource注解
    3. @ComponentScan注解
    4. @Import注解
    5. @ImportResource注解
    6. @Bean注解
    7. 配置类的接口上的默认方法
    8. 配置类的超类
    @Nullable
    protected final SourceClass doProcessConfigurationClass(
        ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
        throws IOException {
    
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // 1.首先会递归的处理所有成员类,即@Component注解
            processMemberClasses(configClass, sourceClass, filter);
        }
    
        // 2.处理所有@PropertySource注解
        for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
            if (this.environment instanceof ConfigurableEnvironment) {
                processPropertySource(propertySource);
            }
            else {
                logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                            "]. Reason: Environment must implement ConfigurableEnvironment");
            }
        }
    
        // 3.处理所有@ComponentScan注解
        Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            for (AnnotationAttributes componentScan : componentScans) {
                // 配置类的注解为@ComponentScan-> 立即执行扫描
                Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                // 检查扫描过的BeanDefinition集合,看看是否有其他配置类,如果需要,递归解析
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }
    
        // 4.处理所有@Import注解
        processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    
        // 5.处理所有@ImportResource注解
        AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        if (importResource != null) {
            String[] resources = importResource.getStringArray("locations");
            Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            for (String resource : resources) {
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }
    
        // 6.处理标注为@Bean注解的方法
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }
    
        // 7.处理配置类的接口上的默认方法
        processInterfaces(configClass, sourceClass);
    
        // 8.处理配置类的超类(如果有的话)
        if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
                this.knownSuperclasses.put(superclass, configClass);
                // Superclass found, return its annotation metadata and recurse
                return sourceClass.getSuperClass();
            }
        }
    
        // 处理完成
        return null;
    }
    

    processImports

    processImports方法为处理@Import注解导入的配置类,是我们本篇的主题。

    该方法会循环处理每一个由@Import导入的类:

    1. ImportSelector类的处理
    2. ImportBeanDefinitionRegistrar类的处理
    3. 其它类统一按照@Configuration类来处理,所以加不加@Configuration注解都能被导入
    /**
     * 处理配置类上的@Import注解引入的类
     *
     * @param configClass 配置类,这里是Config类
     * @param currentSourceClass 当前资源类
     * @param importCandidates 该配置类中的@Import注解导入的候选类列表
     * @param exclusionFilter 排除过滤器
     * @param checkForCircularImports 是否循环检查导入
     */
    private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
                                Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
                                boolean checkForCircularImports) {
    	// 如果该@Import注解导入的列表为空,直接返回
        if (importCandidates.isEmpty()) {
            return;
        }
    	// 循环检查导入
        if (checkForCircularImports && isChainedImportOnStack(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
        }
        else {
            this.importStack.push(configClass);
            try {
                // 循环处理每一个由@Import导入的类
                for (SourceClass candidate : importCandidates) {
                    if (candidate.isAssignable(ImportSelector.class)) {
                        // 1. ImportSelector类的处理
                        Class<?> candidateClass = candidate.loadClass();
                        ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                                                                                       this.environment, this.resourceLoader, this.registry);
                        Predicate<String> selectorFilter = selector.getExclusionFilter();
                        if (selectorFilter != null) {
                            exclusionFilter = exclusionFilter.or(selectorFilter);
                        }
                        if (selector instanceof DeferredImportSelector) {
                            // 1.1 若是DeferredImportSelector接口的实现,则延时处理
                            this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                        }
                        else {
                            // 1.2 在这里调用我们的ImportSelector实现类的selectImports方法
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                            // 1.3 递归处理每一个selectImports方法返回的配置类
                            processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                        }
                    }
                    else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                         // 2. ImportBeanDefinitionRegistrar类的处理
                        Class<?> candidateClass = candidate.loadClass();
                        ImportBeanDefinitionRegistrar registrar =
                            ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                                                 this.environment, this.resourceLoader, this.registry);
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    }
                    else {
                        // 3. 其它类统一按照@Configuration类来处理,所以加不加@Configuration注解都能被导入
                        this.importStack.registerImport(
                            currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                        processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                    }
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                    "Failed to process import candidates for configuration class [" +
                    configClass.getMetadata().getClassName() + "]", ex);
            }
            finally {
                this.importStack.pop();
            }
        }
    }
    

    总结

    通过上面源码的解析可以看出,@Import注解主要作用是导入外部类的,并且普通类也会按照@Configuration类来处理。这大大方便了我们将自己的组件类注入到容器中了(无需修改自己的组件类)。

    源码分享

    完整代码请访问我的Github,若对你有帮助,欢迎给个⭐,感谢~~🌹🌹🌹

    https://github.com/gozhuyinglong/blog-demos/tree/main/spring-source-analysis/src/main/java/io/github/gozhuyinglong/importanalysis

    推荐阅读

    关于作者

    项目内容
    公众号码农StayUp(ID:AcmenStayUp)
    主页https://gozhuyinglong.github.io
    CSDNhttps://blog.csdn.net/gozhuyinglong
    掘进https://juejin.cn/user/1239904849494856
    Githubhttps://github.com/gozhuyinglong
    Giteehttps://gitee.com/gozhuyinglong

    展开全文
  • 我有一个存储所有.py文件的目录。bin/main.pyuser.py # where class User residesdir.py # where class Dir resides我想在main.py中使用...此外,如果user.py在子目录中,如何导入类User?bin/dir.pymain.pyusr/user...

    我有一个存储所有.py文件的目录。

    bin/

    main.py

    user.py # where class User resides

    dir.py # where class Dir resides

    我想在main.py中使用user.py和dir.py中的类。如何将这些python类导入main.py?此外,如果user.py在子目录中,如何导入类User?

    bin/

    dir.py

    main.py

    usr/

    user.py

    另请参见python中的答案:从子目录导入文件。

    我在这里回答了类似的问题

    Python 2

    在与文件相同的目录中生成一个名为__init__.py的空文件。这意味着对python来说,"可以从这个目录导入"。

    然后做…

    from user import User

    from dir import Dir

    如果文件在子目录中,也同样如此——在子目录中也放置一个__init__.py,然后使用常规的import语句,使用点表示法。对于每一级目录,您需要添加到导入路径。

    bin/

    main.py

    classes/

    user.py

    dir.py

    因此,如果目录名为"classes",那么您可以这样做:

    from classes.user import User

    from classes.dir import Dir

    Python 3

    与前一个相同,但如果不使用子目录,则在模块名称前面加一个.:

    from .user import User

    from .dir import Dir

    是否要求__init__.py为空?我想导入__init__.py包中的所有子模块,即为目录中的所有模块(文件)添加行:from Module1 impotr *。有可能吗?

    如果__init__.py不是空的,那么__init__.py中的任何内容都是在导入包时可用的(而没有导入__init__.py的内容根本不可用)。

    为什么需要一个__init__.py文件?如果我把这三个文件放在同一个目录下,运行main.py,它就可以从其他两个模块中运行import,不用它也可以。我错过了什么?

    因为这就是python标识允许导入的目录的方式。您正在运行的脚本的目录是一个例外,您总是可以从中导入。

    对不起,Amber,我把一个空的__init__.py文件放在我的2个子目录(gui/和logic/)中,但我仍然有ImportError: No module named 'player'的导入问题,这个player.py在logic/中,正如我告诉你的,这里有__init__.py文件。有什么问题?

    @nbro&amp;amber:fwiw,我认为与__init__.py相关的一些细微变化,能够在同一目录中导入其他模块。具体来说,与在python 2.7.8中工作的__init__.py文件本身所在目录中的其他模块的imports在python 3.4.1中失败。为了解决这个问题,我必须在每个目录前面加上子目录的名称和一个点(即import module必须改为import subdirectory.module)。幸运的是,这样做之后,它仍然可以在Python2.7.8中工作。

    @Martineau正是如此,它是一种更面向对象的模块导入方式。

    @NBO:由于其他模块与__init__.py在同一目录中,并且它以前不用前缀就可以工作,所以我认为这是一个bug……可能是由于在python 2.x到3.x之间发生了一些与模块和包导入有关的意外结果。

    我认为这个解决方案不适用于python 3

    我可以确认这个解决方案不再有效。您可能希望更正、修改或直接删除它。

    我同样也不认为这在Python3中有效。我认为这是因为我的模块只包含函数,没有类。

    啊,是的,我解决了。用途:从。如果模块没有类,则导入文件加载器

    你要做什么?你的in it.py文件里有东西?我试着从同一个文件夹导入,但找不到它。如果我在init.py上导入这两个文件,它会工作…但如果你试图从其他任何地方进口

    @如果__init__.py文件不是空的,那么模块将只包含__init__.py文件中定义的内容。因此,您的__init__.py需要从本地目录导入您希望其他文件能够从模块导入的任何内容。(空的__init__.py意味着只隐式引用目录的其余部分。)

    @琥珀行。但我该怎么做呢?做进口?这些进口产品应该怎样?导入childname?还是导入thisname.childname?.如何从每个子模块中导入子模块?也导入childname?

    顺便说一下,我发现:python.org/dev/peps/pep-0328/id8 pep 328专门讨论了相关的进口。

    这个答案的前几行很糟糕,根本不起作用。关于这里的工作答案:stackoverflow.com/a/41276151/129202

    我刚刚了解到(感谢Martineau的评论),为了从同一目录中的文件导入类,您现在可以用python 3编写:

    from .user import User

    from .dir import Dir

    刚换了三号Python。谢谢!这个评论真的节省了我一些时间!

    如果我尝试这个否,我会得到以下错误ValueError: Attempted relative import in non-package,但是当我改为from user import User时,错误会消失。

    我使用from.fileloader import fileloader和get importError:无法导入名称"fileloader"

    @Korpel:在stackoverflow.com/questions/11536764/&hellip;中的讨论之后,我逐渐意识到,上面给出的导入是否有效取决于以下因素:(1)如何调用脚本(是否为包)[2]执行时实际工作路径在何处[3]如何填充运行环境的路径变量

    @Dirk Haupt:见以上评论

    在您的main.py中:

    from user import Class

    其中,Class是要导入的类的名称。

    如果要调用Class的方法,可以使用以下方法调用它:

    Class.method

    注意,同一目录中应该有一个空的__init__.py文件。

    如果要导入的模块没有类,该怎么办?只是原始函数?在Python2中,我所要做的就是"导入模块"。不能在python 3中使用,也不能使用"import.module"

    如果不想将函数和类与您的混合,可以导入模块并通过其名称进行访问。

    import util # imports util.py

    util.clean()

    util.setup(4)

    或者可以将函数和类导入到代码中

    from util import clean, setup

    clean()

    setup(4)

    可以使用wildchar*将该模块中的所有内容导入到代码中

    from util import *

    clean()

    setup(4)

    为了使理解更简单:

    步骤1:让我们转到一个目录,所有目录都将包含在其中

    $ cd /var/tmp

    第2步:现在让我们制作一个class1.py文件,它有一个类名class1和一些代码

    $ cat > class1.py <

    class Class1:

    OKBLUE = '\033[94m'

    ENDC = '\033[0m'

    OK = OKBLUE +"[Class1 OK]:" + ENDC

    EOF

    第3步:现在让我们制作一个class2.py文件,它有一个类名class2和一些代码

    $ cat > class2.py <

    class Class2:

    OKBLUE = '\033[94m'

    ENDC = '\033[0m'

    OK = OKBLUE +"[Class2 OK]:" + ENDC

    EOF

    步骤4:现在让我们制作一个main.py,它将在两个不同的文件中使用Class1和Class2执行一次。

    $ cat > main.py <

    """this is how we are actually calling class1.py and  from that file loading Class1"""

    from class1 import Class1

    """this is how we are actually calling class2.py and  from that file loading Class2"""

    from class2 import Class2

    print Class1.OK

    print Class2.OK

    EOF

    第5步:运行程序

    $ python main.py

    输出将是

    [Class1 OK]:

    [Class2 OK]:

    如果这不起作用,而且main.py不能读取Class1或Class2,会发生什么?…我们遗漏了什么?

    from user import User

    from dir import Dir

    是from X import Y,不是import Y from X。

    这对我来说很有效,没有python 2.7和python 3.6的init.py文件。

    @imsrgadich只要您在包含文件的目录中运行python,它就可以工作。这是一个例外。查看此评论

    Python 3

    同directory。

    导入文件:log.py。

    进口类别:SampleApp()。

    import log

    if __name__ =="__main__":

    app = log.SampleApp()

    app.mainloop()

    目录是basic。

    档案导入:log.py。

    进口类别:SampleApp()。

    from basic import log

    if __name__ =="__main__":

    app = log.SampleApp()

    app.mainloop()

    只是太短暂了,创建一个文件__init__.pyis classes目录,然后将其导入到脚本中,如下所示

    from classes.myscript import *

    在这个答案中看到的通配符导入通常被认为是PEP8中描述的坏样式。

    麻烦你是对的,但你为什么不投一个老问题的票?

    展开全文
  • idea如何从数据库自动导入实体 1idea界面右边有一个Database按钮,单击打开数据库页面。 2单击左上角的加号按钮,选择第一项,选择自己的数据库。 3选择自己的数据库后将进入这个界面在User栏里输入自己的数据库...

    idea如何从数据库自动导入实体类
    1idea界面右边有一个Database按钮,单击打开数据库页面。
    在这里插入图片描述
    2单击左上角的加号按钮,选择第一项,选择自己的数据库。
    在这里插入图片描述
    3选择自己的数据库后将进入这个界面在User栏里输入自己的数据库用户名在Password栏里输入自己的数据库用户密码在Driver里选择自己的数据库种类和版本在Database栏里输入数据库名字
    在这里插入图片描述
    4键入数据库用户名和密码选择版本后点击Test Conncetion按钮进行测试,如果测试成功点击Ppply应用并ok
    在这里插入图片描述
    5链接数据库成功之后展开会显示数据库名和表名
    在这里插入图片描述
    6展开数据库后右击表名选择倒数第二栏生成脚本选择第二栏 导入目录在这里插入图片描述

    7找到自己项目的pojo包并ok
    在这里插入图片描述
    8导入成功之后,打开实体类删除第一行的包名,鼠标悬浮在类名上,重新导包
    在这里插入图片描述
    9打开实体类把实体类类型改为包装类然后删除下面的getset方法Alt+Insert键一键生成getset方法
    在这里插入图片描述
    如果对你有帮助请一键三连自动收藏。如果学习java有其他方面的问题可以私信联系我也可以加我qq进行沟通2368725753不要转载不要转载

    展开全文
  • Taskset嵌套子,FastHttpUser介绍,HttpUser介绍
  • 在Jsp中怎么导入Java

    万次阅读 2017-11-07 14:08:01
    2.在form.jsp中导入City <%@ page import="包名.类名" %> <%@ page import="struts2.City" %> 为什么需要在form.jsp中导入City? 如不导入City,那么List<City> cities=new ArrayList&...
  • django中内置的User类记录

    千次阅读 2018-04-15 15:48:42
    1.在做登录验证或者注册的时候,用内置的User类会方便许多,但是其中也有一些不同,特此记录先导入user类,然后创建一个类做一对一关联from django.contrib.auth.models import User class UserProfile(models....
  • 使用Jupyter notebook导入类

    千次阅读 2019-05-19 14:01:55
    但是如果直接引入自己写的.ipynb会报错 ModuleNotFoundError: No module named 'pizza'。 在网上找了个方法觉得挺好用 首先是创建一个Ipynb_importer.py文件,保存在同一个文件夹里,代码在底部 再在程序里...
  • Excel导入导出工具,使用注解实现,基于若依框架工具修改Maven依赖Java 代码使用案例 第六更,一个超级好用的工具,只需要在实体上加注解,就可以实现将 List 集合导出Excel,Excel数据导入生成 List ,支持...
  • Java操作百万数据量Excel导入导出工具(维护中)

    万次阅读 多人点赞 2018-06-28 15:12:17
    更新日志:(如果有更好的优化方案或者更高级的工具:欢迎评论或者私信) * 1.response.reset();注释掉reset,否在会出现跨域错误。 * 2.可导出多个单元、poi官方建议大数据量解决方案:SXSSFWorkbook。 * 3....
  • HuTool工具使用Excel文档的导入导出 前言 在日常的工作开发中,Excel的导入和导出是必不可少的,如果自己写相应的导入导出方法,会显得十分繁琐,本文采用Hutool工具实现的Excel导入导出功能,可以大幅度减少...
  • Django 自定义auth_user

    千次阅读 2019-01-03 21:15:37
    1 导入AbstractUser from django.contrib.auth.models ...2 创建类UserProfile并继承AbstractUser class UserProfile(AbstractUser): 3 创建自己需要的UserProfile字段 class UserProfile(AbstractUser): nick...
  • Oracle 导入、导出DMP(备份)文件

    千次阅读 2021-05-07 02:31:56
    一.Oracle导入备份文件步骤:我用的是Oracle 11g版本1.把数据库的备份文件:xx.DMP 拷贝到oracle安装目录下的dpdump文件夹中,比如我的路径是: D:\work\app\admin\orcl\dpdump在你的PLSQL Develop...
  • 编写程序admin.py,要求如下

    千次阅读 2020-06-14 21:44:34
    (1)导入模块user中的User类 (2)编写Admin类继承User类,并添加新的权限角色属性role(127代表超级管理,126代表老师,100代表学生) (3)重写login登录方法,打印输出 用户名+“Admin login success!” (4)...
  • Django_使用django自带的user做外键

    千次阅读 2020-07-21 17:19:37
    一、使用django自带的user做外键,可以直接在model中使用。只需导入settings模块 使用方法: 在app应用(此处是Product应用)中的models.py文件,导入settings模块 # Product / models.py from django.db import ...
  • 9-1 餐馆:创建一个名为 Restaurant 的,其方法__init__()设置两个属性:restaurant_name 和 cuisine_type。创建一个名为 describe_restaurant()的方法和一个名为 open_restaurant()的方法,其中前者打印前述两项...
  • 以前用过POI、easyexcel等工具的导入导出功能,但总感觉太麻烦了,代码特别多,感觉并不是很好用。 今天给大家介绍一款新工具,java工具类库Hutool。 Hutool简介 Hutool是一个小而全的Java工具类库,通过静态方法...
  • java中import导入包的详解

    千次阅读 2021-03-31 19:51:41
    有可能需要调用其他的,或者其他中的对象,或者其他中的方法,或者其他某些特定的方法,这里需要调用的对象(或者是)有可能跟该文件不在一个包里,这个时候,就需要导入相应的包(包中相应的,甚至包括...
  • Django中内置的User模型

    万次阅读 2018-12-20 10:45:28
    User模型 User模型是这个框架的核心部分。他的完整的路径是在django.contrib.auth.models.User。 字段 内置的User模型拥有以下的字段: username: 用户名。150个字符以内。可以包含数字和英文字符,以及_、@、+、....
  • Java利用POI实现导入导出Excel表格demo

    千次阅读 2022-04-12 19:22:58
    Java Excel导入导出 一、Java利用POI实现导入导出Excel表格demo 1.引入依赖 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version&...
  • @MapperScan的注解,导入包为import tk.mybatis.spring.annotation.MapperScan; 不是org.mybaties.spring.annotation.MapperScan 否则会提示这个映射不到对应的表。
  • Python入门习题大全——导入Admin

    千次阅读 2020-04-11 13:20:41
    以为完成练习“权限”而做的工作为基础,将User、Privileges和Admin存储在一个模块中,再创建一个文件,在其中创建一个Admin 实例并对其调用方法show_privileges(),以确认一切都能正确地运行。 文件 usr.py 内容...
  • 如何在oracle中导入导出dmp文件

    千次阅读 2021-05-03 06:51:19
    Oracle数据导入导出imp/exp就相当于oracle数据还原与备份。exp命令可以把数据从远程数据库服务器导出到本地的dmp文件,imp命令可以把dmp文件从本地导入到远处的数据库服务器中。 利用这个功能可以构建两个相同的...
  • Java导入Excel文件如何对应属性对应的字段?Java导出Excel文件如何实现? 下面分为两段供各位测试,要是不懂或者实在不行可以评论一下,看到我会回复的 jar这些你们可以自己找,用maven也就是复制粘贴的事。 下面...
  • Django自带强大的User系统,为我们提供用户认证、权限、组等一系列功能,可以快速建立一个完整的后台功能。 但User模型并不能满足我们的需求,例如自带的User表中没有手机号码,而且对于国人来说表中的first_name和...
  • Java实现Excel导入和导出,看这一篇就够了(珍藏版)

    万次阅读 多人点赞 2021-12-17 13:45:43
    最近抽了两天时间,把Java实现表格的相关操作进行了封装,本次封装是基于POI的二次开发,最终使用只需要调用一个工具中的方法,就能满足业务中绝大部门的导入和导出需求。 环境准备 1. Maven 依赖 本次工具的...
  • 创建一个超级用户(email必要) set_password(pwd) 设置密码 创建用户要导入认证模型里的User,再用User对象去创建用户 from django.contrib.auth.models import User User.objects.create(username='laowang',...
  • Java实现Excel导入导出(附Demo)

    千次阅读 2022-02-17 17:10:33
    之前也写过Excel的导入导出功能,但是都是直接在方法中利用easyExcel来进行转化,但是一个大型的管理系统中,必然会有很多的Excel导入导出功能需求,因此整理了一个excel工具,附上对应已经实现的demo。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 261,597
精华内容 104,638
关键字:

怎么导入user类