正则表达式（含范例）

最新推荐文章于 2025-04-23 20:29:15 发布
最新推荐文章于 2025-04-23 20:29:15 发布
阅读量1.6w 收藏 4
点赞数 2
分类专栏： 个人笔记 字符串 文章标签： 正则表达式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Window_mouse/article/details/115286493
版权

正则表达式

正则表达式是一个应用广泛的程序类库。在项目开发中，String是一个重要的程序 类，String除了可以实现数据的接受、各类数据类型的转型外，其本身也支持正则表达式（Regular Expression），利用正则表达式可以方便地实现疏忽的拆分、替换、验证的操作。

正则表达式最早是从UINX系统的工具组件中发展而来的，在JDK 1.4以前如果需要使用到正则表达式的相关定义则需单独引入其他的.jar文件，而从JDK 1.4后，正则已经默认被JDK所支持，并且提供有java.util.regex开发包。与此同时，也针对了String类进行了一定修改，使其有方法直接支持正则处理。

范例1：正则表达式初体验

package edu.zhku.test;

public class RegularExpressionTestDemo01 {
    public static void main(String[] args) {
        //字符串对象
        String string = "123";
        //结构匹配（"\\d+"：判断是否为多为数字）
        if (string.matches("\\d+")) {
            //字符串转换为int类型
            int num = Integer.parseInt(string);
            System.out.println(num);
            //数字计算
            System.out.println(num * 2);
        }
    }
}

/*
输出结果：
123
246
*/

本程序主要功能是判断字符串的组成是否全部为数字，在本程序中通过一个给定的正则标记"\\d+"（判断是否为多为数字）并结合String类提供的mathes()方法实现验证匹配，如果匹配成功则将字符串转为int型进行计算。

1、常用正则标记

正则表达式中的核心操作是围绕着正则标记的定义实现的。在正则表达式的处理中，最为重要的就是正则匹配标记的使用，所有的正则标记都在java.util.regex.Pattern类中定义，下面列举一些常用的正则标记。

1、元字符：匹配单个字符
     a：表示匹配字母a
     \\：匹配转义字符"\"。
     \t：匹配转义字符"\t"
     \n：匹配转义字符"\n"
2、字符类：任意匹配里面的一个单个字符
     [abc]：表示可能是字母a、字母或者字母c
     [^abc]：表示不是字母a、b、c中的任意一个
     [a-zA-Z]：表示全部字母中的任意一个
     [0-9]：表示全部数字中的任意一个
3、边界匹配：在以后编写JavaScript的时候使用正则时会用到
     ^：表示一组正则的开始
     $：表示一组正则的结束
4、简写表达式：每一位出现的简写标记也只表达一位
     . ：表示任意的一位字符（不包括换行符）
     \d：表示任意的一个数字，等价于[0-9]
     \D：表示任意的一位非数字，等价于[^0-9]
     \w：表示任意的一位字母、数字、_，等价于[a-zA-Z0-9]
     \W：表示任意的一位非字母、数字、_，等价于[^a-zA-Z0-9]
     \s：表示任意的一位空格，例如，"\n"、"\t"等
     \S：表示任意的一个非空格
     \bword(\b)：标注字符的边界（全字匹配）    
5、限定符：之前的所有正则都是表示一位，如果想要表达多位，则就需要数量表示
     正则表达式？：此正则出现0次或者1次
     正则表达式*：此正则出现0次、1次或者多次
     正则表达式+：此正则出现1次或者多次
     正则表达式{n}：此正则出现正好n次
     正则表达式{n,}：此正则出现n次以上
     正则表达式{n,m}：此正则出现n~m次
6、逻辑表示：与、或、非
     正则表达式A正则表达式B：表示表达式A之后紧跟着表达式B
     正则表达式A|正则表达式B：表示表达式A或者是表达式B，二者任选一个出现
     （正则表达式）：将多个子表达式合成一个表示，作为一组出现
7、贪婪/懒惰匹配：
     贪婪匹配<.+>：默认贪婪匹配“任意字符”
     懒惰匹配<.+?>：懒惰匹配“任意字符”
    
//注：因为"."为元字符，所以将要将"."作为字符串时，应该使用转义字符"\"。

所以范例1的正则表达式"\\d+"，其中"\\"为转义字符“\”，所以就是“\d”和“正则表达式+”，表示正则表达式（表示任意的一个数字）出现1次或者多次，换句话说就是“判断是否为多为数字”。

2、String类正则的支持

正则表达式主要是进行字符串数据分析，为方便进行正则处理，在Java中对String类提供了改进。在JDK 1.4后，String类对正则有了直接的方法支持，常见的方法如表 1所示。

表 1 String类对正则的支持
方法名称类型描述
public boolean mathes(String regex)普通与指定正则匹配
public String replaceAll(String regex, String replacement)普通替换满足指定正则的全部内容
public String replaceFirst(String regex, String replacement)普通替换满足指定正则的首个内容
public String[] split(String regex)普通按照指定正则则全拆分
public String[] split(String regex, int limit)普通按照指定的正则拆分为指定个数

范例2：实现字符串替换（删除非字母与非数字）

package edu.zhku.test;

public class RegularExpressionTestDemo02 {
    public static void main(String[] args) {
        //要替换的原始数据
        String string = "www(*@(####@)(12121)Java";
        //删除 非字母[^a-zA-Z] 与 非数字[^0-9]
        String regex = "[^a-zA-Z0-9]+";
        System.out.println("删除非字母与非数字：" + string.replaceAll(regex, ""));
        System.out.println("原字符串：" + string);
        System.out.println("====================================");

        //其他变形版
        //删除 非字母[^a-zA-Z] 与 数字[0-9]
        //非字母正则表达式：[^a-zA-Z]
        String regex01 = "[^a-zA-Z]";
        //数字正则表达式：[0-9]
        String regex02 = "[0-9]";

        //将满足正则表达式的字符串替换为了""（将数字字符串替换为""）
        System.out.println("删除数字：" + string.replaceAll(regex02, ""));
        System.out.println("原字符串：" + string);
        System.out.println("====================================");

        //将满足正则表达式的字符串替换为了""（将非字母字符串替换为""）
        System.out.println("删除非字母：" + string.replaceAll(regex01, ""));
        System.out.println("原字符串：" + string);
    }
}

/*
删除非字母与非数字：www12121Java
原字符串：www(*@(####@)(12121)Java
====================================
删除数字：www(*@(####@)()Java
原字符串：www(*@(####@)(12121)Java
====================================
删除非字母：wwwJava
原字符串：www(*@(####@)(12121)Java
 */

本程序（除变形版）将字符串中所有非字母和非数字的内容通过正则进行匹配，由于可能包含有多个匹配内容，所以使用了“+”进行数量设置，并结合replaceAll()方法将匹配成功的内容替换为空格。

范例3：实现字符串拆分

package edu.zhku.test;
import java.util.Arrays;

//实现字符串拆分，保留数字内容
public class RegularExpressionTestDemo03 {
    public static void main(String[] args) {
        //定义原始数据
        String string = "(09@*1a23bbc456efg*@&)";
        System.out.println("原字符串：" + string);
        System.out.println();

        //定义正则
        String regex = "[^0-9]+";
        String[] strings = string.split(regex);
        System.out.println(Arrays.toString(strings));
        System.out.println();

        System.out.println(strings.length);
        System.out.println();

        for (String s : strings) {
            System.out.print(s + " ");
        }
    }
}

/*
程序执行结果：
原字符串：(09@*1a23bbc456efg*@&)

[, 09, 1, 23, 456]

5

 09 1 23 456
*/

本程序通过正则匹配字符串中的非数字字符，通过spilt()方法实现数据的拆分操作。简单理解本例子就是，将不是数字的字符或者字符串舍去，得到的数据片段作为字符串数组的元素（注意：得到的元素可以为空字符""）。

范例4：判断一个数据是否为小数，如果是小数则将其转为double类型

package edu.blog.test02;

//一个数据是否为小数，如果是小数则将其转为double类型
public class RegularExpressionTestDemo04 {
    public static void main(String[] args) {
        //定义原始数据
        String str01 = "22.22";
        String str02 = "2222";

        //定义正则
        String regex = "\\d+\\.{1}\\d+";
        //也可以定义为"\\d+(\\.\\d+)?"
      
        System.out.println("原字符串str01：" + str01);
        if (str01.matches(regex)) {
            System.out.println(Double.parseDouble(str01));
        } else {
            System.out.println("不是小数");
        }
        System.out.println("==========");
        System.out.println("原字符串str02：" + str02);
        if (str02.matches(regex)) {
            System.out.println(Double.parseDouble(str02));
        } else {
            System.out.println("不是小数");
        }
    }
}

/*
程序执行结果：
原字符串str01：22.22
22.22
==========
原字符串str02：2222
不是小数
 */

本程序在进行小数组成的正则判断需要考虑到小数点以及小数位的情况（即两者必须同时出现），其中部分正则表达式："\\.{1}"，表示小数点出现一次（注：因为".“为元字符，所以将要将”.“作为字符串时，应该使用转义字符”\"）。

也可以将正则表达式定义为："\\d+(\\.\\d+)?"，即将小数点和小数位同时绑定，出现1次以上。

范例5：判断一个字符串是否由日期组成，如果是由日期组成则将其转为Date类型

package edu.blog.test02;

import java.text.ParseException;
import java.text.SimpleDateFormat;

//判断一个字符串是否由日期组成，如果是由日期组成则将其转为Date类型
public class RegularExpressionTestDemo05 {
    public static void main(String[] args) throws ParseException {
        //定义原始数据
        String str01 = "2001-07-27";

        //定义正则
        String regex = "\\d{4}-\\d{2}-\\d{2}";

        System.out.println("原字符串str01：" + str01);
        if (str01.matches(regex)) {
            System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str01));
        }else {
            System.out.println("不是日期格式");
        }
    }
}

/*
程序执行结果：
原字符串str01：2001-07-27
Fri Jul 27 00:00:00 CST 2001
 */

本程序对给定的字符串进行日期格式检验，如果符合（只判断格式）则将字符串通过SimpleDateFormat类变为Date实例。

范例6：判断电话号码格式是否正确

package edu.blog.test02;

import java.text.ParseException;
import java.text.SimpleDateFormat;


/*
判断电话号码格式是否正确，本程序中电话号码的内容有以下4种情况：
电话号码类型1（7~8位数字）：87654321    "\\d{7,8}"
电话号码类型2（在电话号码前追加区号）：01087654321     "\\d{3,4}?\\d{7,8}"
电话号码类型3（区号单独包裹）：(010)-87654321      "(\\(\\d{3,4}\\)-)?\\d{7,8}"
电话号码类型4（11位手机号码）：12345678900        "\\d{11}"
综上："(\\d{3,4})|(\\(\\d{3,4}\\)-)?\\d{7,8}|\\d{11}"
*/

public class RegularExpressionTestDemo06 {
    public static void main(String[] args) throws ParseException {
        //定义原始数据
        String str01 = "87654321";
        String str02 = "01087654321";
        String str03 = "(010)-87654321";
        String str04 = "12345678900";

        //定义正则表达式
        String regex = "(\\d{3,4})|(\\(\\d{3,4}\\)-)?\\d{7,8}|\\d{11}";

        System.out.println("原字符串str01：" + str01);
        System.out.println("原字符串str02：" + str02);
        System.out.println("原字符串str03：" + str03);
        System.out.println("原字符串str04：" + str04);

        System.out.println("==================");

        Utils.isTelephoneFormat(str01, regex);
        Utils.isTelephoneFormat(str02, regex);
        Utils.isTelephoneFormat(str03, regex);
        Utils.isTelephoneFormat(str04, regex);
    }
}

class Utils {
    public static void isTelephoneFormat(String telephone, String regex) {
        if (telephone.matches(regex)) {
            System.out.println(telephone + " 是电话格式");
            return;
        }
        System.out.println(telephone + " 不是电话格式");
    }
}

/*
程序执行结果：
原字符串str01：87654321
原字符串str02：01087654321
原字符串str03：(010)-87654321
原字符串str04：12345678900
==================
87654321 是电话格式
01087654321 是电话格式
(010)-87654321 是电话格式
12345678900 是电话格式
 */

本程序通过一个正则表达式实现4种电话格式的匹配，在进行匹配时必须使用到“()”，所以需要使用“\\”的形式进行转义。

范例7：验证E-mail格式

package edu.blog.test02;

import java.text.ParseException;

/*
验证E-mail格式，现在要求一个合格的Email地址的组成规则如下：
1、E-mail的用户名可以由字母、数字、_所组成（不应该使用“_”开头）   "[a-zA-Z0-9]\\w+"
2、E-mail的域名可以由字母、数字、_、-所组成      "\\w+"
3、域名的后缀必须是.cn、.com、.net、.com.cn、.gov        "\\.(cn|com|net|com\\.cn|gov)"
格式：用户名+@+域名
例子：2222@163.com
 */
public class RegularExpressionTestDemo07 {
    public static void main(String[] args) throws ParseException {
        //定义原始数据
        String str01 = "www123@qq.com";
        String str02 = "_123@163.cn";
        String str03 = "123@asdas.com.cn";
        String str04 = "123@asasas.net";
        String str05 = "123@asasas.gov";
        String str06 = "123@asasas.com.cn.gov";

        //定义正则
        String regex = "[a-zA-Z0-9]\\w+" + "@" + "\\w+" + "\\.(cn|com|net|com\\.cn|gov)";

        System.out.println("原字符串str01：" + str01);
        System.out.println("原字符串str02：" + str02);
        System.out.println("原字符串str03：" + str03);
        System.out.println("原字符串str04：" + str04);
        System.out.println("原字符串str05：" + str05);
        System.out.println("原字符串str06：" + str06);

        System.out.println("=====================================");

        EmailUtils.isEmailFormat(str01, regex);
        EmailUtils.isEmailFormat(str02, regex);
        EmailUtils.isEmailFormat(str03, regex);
        EmailUtils.isEmailFormat(str04, regex);
        EmailUtils.isEmailFormat(str05, regex);
        EmailUtils.isEmailFormat(str06, regex);
    }
}

class EmailUtils {
    public static void isEmailFormat(String email, String regex) {
        if (email.matches(regex)) {
            System.out.println(email + " 是电子邮件格式");
            return;
        }
        System.out.println(email + " 不是电子邮件格式");
    }
}

/*
程序执行结果：
原字符串str01：www123@qq.com
原字符串str02：_123@163.cn
原字符串str03：123@asdas.com.cn
原字符串str04：123@asasas.net
原字符串str05：123@asasas.gov
原字符串str06：123@asasas.com.cn.gov
=====================================
www123@qq.com 是电子邮件格式
_123@163.cn 不是电子邮件格式
123@asdas.com.cn 是电子邮件格式
123@asasas.net 是电子邮件格式
123@asasas.gov 是电子邮件格式
123@asasas.com.cn.gov 不是电子邮件格式
 */

本程序按给定的E-mail组成进行正则验证，正则匹配结构如图 2-1所示。

图 2-1

范例8：RGB颜色值匹配

package edu.blog.test02;

import java.text.ParseException;

//RGB颜色值匹配，输出符合RGB规则的字符串
public class RegularExpressionTestDemo08 {
    public static void main(String[] args) throws ParseException {
        //定义原始数据
        String[] str01 = new String[]{
                "#00",
                "#ffffff",
                "#ffaaff",
                "#00hh00",
                "#aabbcc",
                "#000000",
                "#fffffff"
        };

        //定义正则
        String regex = "#[a-fA-F0-9]{6}\\b";

        //输出满足正则的字符串
        for (String string : str01) {
            if (string.matches(regex)) {
                System.out.println(string);
            }
        }
    }
}

/*
程序执行结果：
#ffffff
#ffaaff
#aabbcc
#000000
 */

范例9：Ipv4地址匹配

package edu.blog.test02;

import java.text.ParseException;

//Ipv4地址匹配，输出符合Ipv4地址规则的字符串
public class RegularExpressionTestDemo09 {
    public static void main(String[] args) throws ParseException {
        //定义原始数据
        String[] str01 = new String[]{
                "123",
                "255.255.255.0",
                "192.168.0.1",
                "0.0.0.0",
                "256.1.1.1",
                "123.123.0"
        };

        //定义正则
        String regex = "\\b((25[0-5]|2[0-4]\\d|[01]?\\d?\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d?\\d?)\\b";

        //输出满足正则的字符串
        for (String string : str01) {
            if (string.matches(regex)) {
                System.out.println(string);
            }
        }
    }
}

/*
程序执行结果：
255.255.255.0
192.168.0.1
0.0.0.0
 */

3、java.util.regex包支持

String类提供的正则标记只提供了基础的实现功能，如果对于正则操作有更加严格要求就需要直接使用regex开发包中提供的类。java.util.regex从JDK 1.4开始正式提供的正则表达式开发包，在此包中定义有两个核心的正则操作类：Pattern（正则模式）和Matcher（匹配）。

java.util.regex.Pattern类的主要功能是进行正则表达式的编译以及获取Matcher类实例，其常用方法如表 3-2所示。

表 3-1
方法类型描述
public static Pattern compile(String regex)普通指定正则表达式规则
public Matcher matcher(CharSequence input)普通获取Matcher类实例
public String[] split(CharSequence input)普通字符串拆分

Pattern类并没有提供构造方法，如果想取得Pattern类实例，则必须调用compile()方法。对于字符串的格式验证与匹配的操作，则可以通过matcher()方法获取Matcher类实例化完成。Matcher类常用方法如表 3-2所示。

表 3-2
方法类型描述
public boolean matches()普通执行验证
public String replaceAll(String replacement)普通字符串替换
public boolean find()普通是否有下一个匹配
public String group(int group)普通获取指定组编号的数据

范例1：使用Pattern类实现字符串拆分

package edu.blog.test02;

import java.util.regex.Pattern;

//使用Pattern类实现字符串拆分
public class RegexTestDemo01 {
    public static void main(String[] args) {
        //定义原始数据
        String str01 = "Java##Linux**Python";

        //定义正则表达式
        String regex = "[^a-zA-Z]+";

        //编译正则表达式
        Pattern pattern = Pattern.compile(regex);
        //字符串拆分
        String[] result = pattern.split(str01);
        for (String s : result) {
            System.out.print(s + " ");
        }
    }
}

/*
程序执行结果：
Java Linux Python
 */

本程序通过Pattern类中的compile()方法编译并获取了给定正则表达式Pattern实例化对象，随后利用split()方法按照定义的正则进行拆分。

范例2：使用Matcher类实现正则验证

package edu.blog.test02;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

//使用Matcher类实现正则验证
public class RegexTestDemo02 {
    public static void main(String[] args) {
        //定义原始数据
        String str01 = "2222";

        //定义正则表达式
        String regex = "\\d+";

        //编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        //获取Matcher实例化对象
        Matcher matcher = pattern.matcher(str01);

        System.out.println(matcher.matches());
    }
}

/*
程序执行结果：
true
 */

本程序首先通过Pattern的实例化对象获取了Matcher类对象，这样便可匹配给定的正则对字符串的组成结构。

范例3：使用Matcher类实现字符串替换

package edu.blog.test02;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

//使用Matcher类实现字符串替换
public class RegexTestDemo03 {
    public static void main(String[] args) {
        //定义原始数据
        String str01 = "12##Java45@@Python89!@#";
        System.out.println("原字符串str01：" + str01);

        //定义正则表达式
        String regex = "[^a-zA-Z0-9]+";

        //编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        //获取Matcher实例化对象
        Matcher matcher = pattern.matcher(str01);

        //字符串替换
        System.out.println(matcher.replaceAll(""));
    }
}

/*
程序执行结果：
原字符串str01：12##Java45@@Python89!@#
12Java45Python89
 */

本程序使用Matcher类中replaceAll()方法将字符串中与正则匹配的内容全部替换为空字符串并输出。

范例4：使用Matcher类实现数据分组操作

package edu.blog.test02;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

//使用Matcher类实现数据分组操作
public class RegexTestDemo04 {
    public static void main(String[] args) {
        //定义原始数据
        String str01 = "INSERT INTO dept{dept_id, dept_name,dept_age} VALUES (#{dept_id},#{dept_name},#{dept_age})";
        System.out.println("原字符串str01：" + str01);

        //定义正则表达式
        String regex = "#\\{\\w+\\}";

        //编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        //获取Matcher实例化对象
        Matcher matcher = pattern.matcher(str01);

        //是否有匹配成功的内容
        while (matcher.find()) {
            String data = matcher.group(0).replaceAll("#|\\{|\\}", "");
            System.out.print(data + " ");
        }
    }
}

/*
程序执行结果：
原字符串str01：INSERT INTO dept{dept_id, dept_name,dept_age} VALUES (#{dept_id},#{dept_name},#{dept_age})
dept_id dept_name dept_age 
 */

本程序利用Matcher类提供的分组操作功能，将给定的完整字符串按照分组原则依次匹配并取出。

注：此文章为本人学习中记录的笔记，若有错误，敬请指正。

pycharm+anaconda配置pytorch(CUDA10.2)
m0_55333280的博客
07-22 1327
选择相应的版本下载。但是官网最新版本的pytorch稳定版已经不支持cuda10.2的了，所以我去。中寻找，找到这三个文件并下载。
关于安装Pytorch中torch.cuda.is_available()为False的解决方案
DuShunX的博客
02-03 2347
解决torch.cuda.is_available()返回False
PyTorch和CUDA版本对应关系
weixin_42569956的博客
11-02 3万+
PyTorch和CUDA版本对应关系
cuda10.2对应的pytorch
weixin_35748962的博客
02-13 3082
PyTorch对应的CUDA版本是1.7。换句话说，如果您的计算机上安装了CUDA 10.2，您可以使用PyTorch 1.7。请注意，不同版本的PyTorch可能需要不同版本的CUDA，因此请确保您使用正确版本的PyTorch。 ...
【超详细教程】2025最新Pytorch安装教程（ PyTorch+CUDA+Anaconda+PyCharm）
最新发布
mahaimanyouzhe的博客
04-23 1217
亲爱的学弟学妹们好呀！我是你们的AI研究生学姐～今天要教大家一个超级实用的技能：如何从零开始配置PyTorch深度学习环境！还记得我大二时第一次接触深度学习的惨痛经历吗？环境配置就卡了整整两周，差点劝退我这个计算机系的女生😭 所以今天学姐就把踩过的所有坑都告诉你们，保证让你们一次配置成功！温馨小贴士：学姐已经把所有需要的安装包都打包好啦，国内下载超快，再也不用翻墙下载啦！文末有下载链接哦～亲爱的学弟学妹们，环境配置只是万里长征第一步，真正的挑战和乐趣在后面等着你们！
CUDA 10.2安装pytorch
collect230的博客
03-25 2592
cpu开头的是cpu版本的，可以直接跳过，我们看 cu开头的，cu102表示cuda10.2，cp38对应python3.8，按照需求下载就可以了。同理下载torchvision 和torchaudio。根据自己python版本和系统选择。2.所有torch版本。
CUDA（10.2）＋PyTorch安装加配置 详细完整教程
Ang_go的博客
01-05 5万+
CUDA安装 PyTorch安装
【cuda报错】torch.cuda.is_available()返回false解决方案
weixin_44955407的博客
06-12 1万+
-----2021.7.27更新------ 针对cp38做了适当解释，其余未作修改。
pytorch的安装（CUDA10.2+cuDNN8.3.3+torch1.10+​torchvision​0.11.1+python3.9）
Yao_Wan的博客
01-13 1万+
一、先根据电脑硬件的条件获取本身CUDA版本，据此以及表格比较得出cuDNN、torch、torchvision、python版本。 二、在NVIDIA官网下载CUDA和cuDNN，获取torch的下载链接，网页提供python3.9的下载链接 三、安装CUDA后，把cuDNN这个补丁装到CUDA里边，因为CUDA toolkit是CUDA的工具包，cuDNN是CUDA的加速器补丁；用环境为python3.9的pycharm执行官网的pip命令操作完成torch和torchvision的下载
2025 Jetson Nano极速部署yolov8或11：CUDA10.2适配PyTorch1.11+TorchVision预编译whl包
03-15
其次，CUDA10.2版本在官方渠道难以找到与其适配的PyTorch版本，这对于需要深度学习支持的YOLO来说是一个大问题。最后，手动编译环境时会遇到各种依赖项冲突，尤其是opencv和numpy等关键库的版本不兼容问题，这会大大...
安装cuda10.2对应的pytorch gpu
09-11
安装CUDA 10.2对应的PyTorch GPU版本的步骤如下： 1. 访问https://download.pytorch.org/whl/torch_stable.html，这是PyTorch稳定版本的下载页。 2. 在该页面中，找到与CUDA 10.2兼容的PyTorch和相关库的下载链接。...
cuda10.2对应的pytorch gpu
09-15
对于 CUDA 10.2，可以使用 PyTorch 的 GPU 版本。你可以通过以下命令安装适用于 CUDA 10.2 的 PyTorch GPU 版本： ```shell pip install torch==1.7.1+cu102 torchvision==0.8.2+cu102 torchaudio==0.7.2 -f ...
cuda10.2安装pytorch1.8
03-15
### CUDA 10.2环境下正确安装 PyTorch 1.8 的方法 为了在 CUDA 10.2 环境下正确安装 PyTorch 1.8，可以按照以下方式操作： #### 创建 Conda 虚拟环境 首先通过 `conda` 创建一个新的 Python 3.7 虚拟环境并激活它...
cuda10.2安装pytorch
01-11
### 如何在 CUDA 10.2 上安装 PyTorch 为了确保顺利安装适用于 CUDA 10.2 的 PyTorch 版本，建议通过 Anaconda 来管理依赖关系和环境。以下是具体操作指南： #### 创建并激活新的 Conda 环境 推荐先创建一个新的 ...
pytorch安装，torch.cuda.is_available()返回False解决方案
每天多学一点
04-10 1万+
pytorch安装 torch.cuda.is_available()返回False
【一文解决】已安装CUDA与Pytorch但torch.cuda.is_available()为False
热门推荐
乔卿的博客
06-15 13万+
已经安装CUDA与Pytorch。但执行如下Python脚本，输出结果为False，本文给出了尽可能详细全面的解决思路。
torch.cuda.is_available() is false
追随梦想，实现梦想
08-19 2065
torch.cuda.is_available() is false after installed cuda 9.1. Anyone can help me out?
【PyTorch】一文详细介绍 torch.cuda.is_available()
创作高质量博文，分享知识，共同进步！
04-05 1万+
🚀【PyTorch实战】一文掌握torch.cuda.is_available()，解锁GPU加速之旅！🔥 本文深入浅出地介绍了PyTorch中如何检查GPU是否可用，让你轻松驾驭GPU加速深度学习。从基础概念到进阶技巧，一文搞定！掌握GPU内存管理、CUDA错误处理，让你的深度学习模型训练更高效。还有最佳实践分享，助你在深度学习道路上驰骋。别等了，快来加入我们，一起享受GPU带来的速度与激情吧！#PyTorch #GPU加速 #深度学习 #torch.cuda.is_available()
CUDA10.2对应的pytorch1.8.0版本下载
naicha2的博客
04-14 762
CUDA10.2对应的pytorch1.8.0版本下载
pycharm torch.cuda.is_available()false
12-30
### 解决 PyCharm 中 `torch.cuda.is_available()` 返回 False 的问题 为了确保在 PyCharm 中能够正确识别 GPU 并使得 `torch.cuda.is_available()` 返回 True，可以按照以下建议操作： #### 创建并激活 Conda 环境 确保在一个专门的 Anaconda 环境下工作有助于隔离依赖项。通过命令行工具（Anaconda Prompt 或者 Terminal）来创建一个新的 conda 环境，并指定 Python 版本以及安装所需的包。 ```bash conda create -n myenv python=3.8 conda activate myenv ``` #### 安装 CUDA 和 PyTorch 确认所使用的 CUDA 工具包版本与显卡驱动兼容后，再利用 conda 命令安装特定版本的 PyTorch 及其配套组件 TorchVision。这一步骤对于让 PyTorch 正确检测到 GPU 至关重要[^2]。 ```bash conda install pytorch torchvision cudatoolkit=10.2 -c pytorch ``` #### 设置 PyCharm 使用正确的解释器 完成上述步骤之后，在 PyCharm 内部设置项目的 Python 解释器为刚才创建的那个 conda 环境中的解释器路径。这样做的目的是为了让 IDE 加载来自该虚拟环境中的一切资源，包括已经配置好的 CUDA 支持。 #### 测试配置有效性 最后，在新的会话中测试 `torch.cuda.is_available()` 函数的结果是否变为 True。如果一切正常的话，则表明现在可以在 PyCharm 下顺利调用 GPU 来加速计算任务了[^3]。 ```python import torch print(torch.cuda.is_available()) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

窝在角落里学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值