STL-string类的使用及其模拟实现

string类的使用

       string 类是 C++ 标准库提供的用于处理字符串的类,它相比 C 语言中的字符串处理函数更为高级、灵活和安全。

       string 类提供了丰富的成员函数和操作符,用于处理字符串的拼接、查找、替换、截取、插入等操作。string 类自动处理字符串的内存分配和释放,不会像 C 语言中的字符数组那样容易出现缓冲区溢出等安全问题。使用 string 类能够有效避免许多与字符数组相关的安全漏洞。string 类是 C++ 标准模板库(STL)中的一部分,学习 string 类也是为了更好地理解和使用 STL 的其他组件,如向量、链表、映射等。

string类对象的常见构造:

string类对象的容量接口:

string类对象的元素访问:

string类对象的Iterators(迭代器)接口:

string类对象的修改:

npos
     npos 是 std::string 类中的一个静态常量成员,用于表示无效或未找到的位置。它是一个特殊的 std::string::size_type 类型的常量,通常被定义为 std::string::npos,其值在不同的编译器和实现中可能不同,但通常被设为 -1 或一个非常大的值,用于表示在字符串中未找到指定的子串或字符。

    npos 主要用于字符串查找操作,比如在使用 find()、rfind()等成员函数时,当查找失败或没有找到指定的子串或字符时,这些函数通常会返回 std::string::npos 来表示无效的位置。

注意:npos 的值是一个非常大的无符号整数,因此在比较 std::string::size_type 类型的值时,应使用无符号类型的比较方式,避免可能出现的错误。比如使用 pos != std::string::npos 来判断是否找到了指定的子串或字符。

string类的模拟实现

      std::string 是一个类模板,模拟实现它需要深入理解类和对象的概念,包括构造函数、析构函数、成员函数、成员变量等。通过实现一个类似 std::string 的类,你可以更好地理解类的设计和使用。

class string
{
public:
    typedef char* iterator;
    typedef const char* const_iterator;
    iterator begin()
    {
        return _str;
    }
    iterator end() {
        return _str + _size;
    }
    iterator begin() const
    {
        return _str;
    }
    iterator end() const{
        return _str + _size;
    }
    /*string() 
        :_str(new char[1])
        ,_size(0)
        ,_capacity(0)
    {
        _str[0] = '\0';
    }*/
  
    string(const char* str = "")
        :_size(strlen(str))//不包括'\0'的大小
    {
        _capacity = _size==0 ? 3 : _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    string(const string& s)
        :_size(s._size)
        ,_capacity(s._capacity)
    {
        _str = new char[s._capacity+1];
        strcpy(_str, s._str);
    }
    // 传统写法
    string& operator=(const string& s) {
        if (this != &s) {
            /*delete[] _str;
            _str = new char[s._capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
            return *this;*/

            char* tmp = new char[s._capacity + 1];
            strcpy(tmp, s._str);
            delete[] _str;
            _str = tmp;

            _size = s._size;
            _capacity = s._capacity;
        }
    }
    // 现代写法 
    void swap(string& tmp)
    {
        ::swap(_str, tmp._str);
        ::swap(_size, tmp._size);
        ::swap(_capacity, tmp._capacity);
    }
    string(const string& s)
        :_str(nullptr)
        , _size(0)
        , _capacity(0)
    {
        string tmp(s._str);
        swap(tmp);
    }
    ~string() {
        delete[] _str;
        _str = nullptr;
        _size = _capacity = 0;
    }
    string to_string(int value)
    {
        bool flag = true;
        if (value < 0)
        {
            flag = false;
            value = 0 - value;
        }

        string str;
        while (value > 0)
        {
            int x = value % 10;
            value /= 10;

            str += ('0' + x);
        }

        if (flag == false)
        {
            str += '-';
        }

        std::reverse(str.begin(), str.end());
        return str;
    }
    const char* c_str() {
        return _str;
    }
    const char& operator[](size_t pos) const {
        assert(pos < _size);
        return _str[pos];
    }
    char& operator[](size_t pos) {
        assert(pos < _size);
        return _str[pos];
    }
    size_t size() const{
        return _size;
    }
    size_t capacity() const {
        return _capacity;
    }

    //string& operator=(const string& s)
    //{
    //    if (this != &s)
    //    {
    //        //string tmp(s._str);
    //        string tmp(s);
    //        swap(tmp); // this->swap(tmp);
    //    }

    //    return *this;
    //}
    string& operator=(const string& s)
    {
        if (this != &s) //防止自己给自己赋值
        {
            string tmp(s); //用s拷贝构造出对象tmp
            swap(tmp); //交换这两个对象
        }
        return *this; //返回左值(支持连续赋值)
    }
    //不修改成员变量数据的函数,最好都加上const
    bool operator>(const string& s) const {
        return strcmp(_str, s._str) > 0;
    }
    bool operator==(const string& s) const {
        return strcmp(_str, s._str) == 0;
    }
    bool operator>=(const string& s) const {
        return *this > s || *this == s;
    }
    bool operator<(const string& s) const {
        //return strcmp(_str, s._str) < 0;
        return !(*this >= s);
    }
    bool operator<=(const string& s) const {
        //return *this < s || *this == s;
        return !(*this > s);
    }
    //扩容
    void reserve(size_t n) {
        if (n > _capacity) {
            char* tmp = new char[n + 1];
            strcpy(tmp, _str);
            delete[] _str;
            _str = tmp;
            _capacity = n;
        }
    }
    void resize(size_t n, char ch = '\0') {
        if (n <= _size) {
            //删除数据--保留前n个
            _size = n;
            _str[_size] = '\0';
        }
        else {
            if (n > _capacity) {
                reserve(n);
            }
            size_t i = _size;
            while (i < n) {
                _str[i] = ch;
                ++i;
            }
            _size = n;
            _str[_size] = '\0';
        }
    }
    void push_back(char ch) {
        /*if (_size + 1 > _capacity) {
            reserve(_capacity * 2);
        }
        _str[_size] = ch;
        ++_size;
        _str[_size] = '\0';*/
        insert(_size, ch);
    }
    void append(const char* str) {
        //size_t len = strlen(str);
        //if (_size + len > _capacity) {
        //    reserve(_size + len);
        //}
        //strcpy(_str + _size, str);
        strcat(_str,str);
        //_size += len;
        insert(_size, str);
    }
    string& operator+=(char ch) {
        push_back(ch);
        return *this;
    }
    string& operator+=(const char* str) {
        append(str);
        return *this;
    }
    string& insert(size_t pos, char ch) {
        assert(pos <= _size);
        if (_size + 1 > _capacity) {
            reserve(2 * _capacity);
        }
        //int end = _size;
        //while (end >= (int)pos) {//有符号跟无符号类型比较会发生整型提升变成无符号类型
        //    _str[end + 1] = _str[end];
        //    --end;
        //}
        size_t end = _size+1;
        while (end > pos) {
            _str[end] = _str[end-1];
            --end;
        }
        _str[pos] = ch;
        ++_size;
        return *this;
    }
    string& insert(size_t pos, const char* str) {
        assert(pos <= _size);
        size_t len = strlen(str);
        if (_size + len > _capacity) {
            reserve(_size + len);
        }
        //挪动数据
        size_t end = _size + len;
        while (end > pos+len-1) {
            _str[end] = _str[end - len];
            --end;
        }
        /*size_t end = _size;
        for (size_t i = 0; i < _size + 1; ++i) {
            _str[end] = _str[end - len];
            --end;
        }*/
        //拷贝插入
        strncpy(_str + pos, str, len);
        _size += len;
        return *this;
    }
    string& erase(size_t pos, size_t len = npos) {
        assert(pos < _size);
        if (len == npos || pos + len >= _size) {
            _str[pos] = '\0';
            _size = pos;
        }
        else {
            strcpy(_str + pos, _str + pos + len);
            _size -= len;
        }
        return *this;
    }
    //swap(s1,s2);
    //s1.swap(s2);比上面更高效
    void swap(string& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    size_t find(char ch,size_t pos=0) {
        assert(pos < _size);
        for (size_t i = pos; i < _size; ++i) {
            if (_str[i] == ch) {
                return i;
            }
        }
        return npos;
    }
    size_t find(const char* str, size_t pos = 0) {
        assert(pos < _size);
        char* p = strstr(_str + pos, str);
        if (p == nullptr) {
            return npos;
        }
        else {
            return p - str;
        }
    }
    void clear() {
        _str[0] = '\0';
        _size = 0;
    }
private:
    char* _str;
    size_t _size;
    size_t _capacity;

    //static const size_t npos;
    static const size_t npos = -1;

    //static const double npos = -1.0;//错误,只针对整型
};

//const size_t string::npos = -1;

ostream& operator<<(ostream& out, const string& s) {
    for (auto ch : s) {
        out << ch;
    }
    return out;
}
istream& operator>>(istream& in, string& s) {
    s.clear();
    char ch=in.get();
    char buff[128];
    size_t i = 0;
    while (ch != ' ' && ch != '\n') {
        buff[i++] = ch;
        if (i == 127) {
            buff[127] = '\0';
            s += buff;
            i = 0;
        }
        ch= in.get();
    }
    if (i !=0) {
        buff[i] = '\0';
        s += buff;
    }
    return in;
}

构造函数

//构造函数
    /*string() 
        :_str(new char[1])
        ,_size(0)
        ,_capacity(0)
    {
        _str[0] = '\0';
    }*/
    //string(const char* str=nulltr)不可以,strlen检测不到'\0'会崩
    //string(const char* str='\0')不可以,类型不匹配
    //string(const char* str="\0")可以,但是C语言规定常量字符串后面会有默认'\0'会造成歧义
    string(const char* str = "")
        :_size(strlen(str))//不包括'\0'的大小
    {
        _capacity = _size==0 ? 3 : _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }

构造函数我们可以用无参和带参的构造,但是最好的方式是全缺省,const char* str = “” 是构造函数的默认参数。

拷贝构造

浅拷贝:拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间。其中一个对象的改动会对另一个对象造成影响。
深拷贝:深拷贝是指源对象与拷贝对象互相独立。其中任何一个对象的改动不会对另外一个对象造成影响。

因为我们并不希望源对象与拷贝对象存在关系,所以我们需要实例化出新的对象再进行拷贝。

传统写法:

 string(const string& s)
        :_size(s._size)
        ,_capacity(s._capacity)
    {
        _str = new char[s._capacity+1];
        strcpy(_str, s._str);
    }

现代写法:

void swap(string& s) {
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_capacity, s._capacity);
}

string(const string& s)

:_str(nullptr)

, _size(0)

, _capacity(0)

{

string tmp(s._str);

swap(tmp);

}

swap 函数的实现会交换当前对象和临时对象的内存空间资源,而临时对象会在析构时释放资源。

这种实现方式通过避免了不必要的内存拷贝,从而提高了拷贝构造函数的性能。

赋值运算符重载

传统写法:

string& operator=(const string& s) {
        if (this != &s) {
            /*delete[] _str;
            _str = new char[s._capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
            return *this;*/

            char* tmp = new char[s._capacity + 1];
            strcpy(tmp, s._str);
            delete[] _str;
            _str = tmp;

            _size = s._size;
            _capacity = s._capacity;
        }
    }

现代写法:

//现代写法2
string& operator=(const string& s)
{
    if (this != &s) //防止自己给自己赋值
    {
        string tmp(s); //用s拷贝构造出对象tmp
        swap(tmp); //交换这两个对象
    }
    return *this; //返回左值(支持连续赋值)
}

析构函数

~string() {
    delete[] _str;
    _str = nullptr;
    _size = _capacity = 0;
}

扩容

void reserve(size_t n) {
    if (n > _capacity) {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
}

获取对应位置字符

const char& operator[](size_t pos) const {
    assert(pos < _size);
    return _str[pos];
}
char& operator[](size_t pos) {
    assert(pos < _size);
    return _str[pos];
}

改变字符串大小


void resize(size_t n, char ch = '\0') {
    if (n <= _size) {
        //删除数据--保留前n个
        _size = n;
        _str[_size] = '\0';
    }
    else {
        if (n > _capacity) {
            reserve(n);
        }
        size_t i = _size;
        while (i < n) {
            _str[i] = ch;
            ++i;
        }
        _size = n;
        _str[_size] = '\0';
    }
}

迭代器

iterator begin()
{
    return _str;
}
iterator end() {
    return _str + _size;
}
iterator begin() const
{
    return _str;
}
iterator end() const{
    return _str + _size;
}

数字转字符串


string to_string(int value)
    {
        bool flag = true;
        if (value < 0)
        {
            flag = false;
            value = 0 - value;
        }

        string str;
        while (value > 0)
        {
            int x = value % 10;
            value /= 10;

            str += ('0' + x);
        }

        if (flag == false)
        {
            str += '-';
        }

        std::reverse(str.begin(), str.end());
        return str;
    }

字符/字符串任意位置插入

string& insert(size_t pos, char ch) {
    assert(pos <= _size);
    if (_size + 1 > _capacity) {
        reserve(2 * _capacity);
    }
    //int end = _size;
    //while (end >= (int)pos) {//有符号跟无符号类型比较会发生整型提升变成无符号类型
    //    _str[end + 1] = _str[end];
    //    --end;
    //}
    size_t end = _size+1;
    while (end > pos) {
        _str[end] = _str[end-1];
        --end;
    }
    _str[pos] = ch;
    ++_size;
    return *this;
}
string& insert(size_t pos, const char* str) {
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity) {
        reserve(_size + len);
    }
    //挪动数据
    size_t end = _size + len;
    while (end > pos+len-1) {
        _str[end] = _str[end - len];
        --end;
    }
    /*size_t end = _size;
    for (size_t i = 0; i < _size + 1; ++i) {
        _str[end] = _str[end - len];
        --end;
    }*/
    //拷贝插入
    strncpy(_str + pos, str, len);
    _size += len;
    return *this;

字符/字符串的追加

void push_back(char ch) {
    /*if (_size + 1 > _capacity) {
        reserve(_capacity * 2);
    }
    _str[_size] = ch;
    ++_size;
    _str[_size] = '\0';*/
    insert(_size, ch);
}
void append(const char* str) {
    //size_t len = strlen(str);
    //if (_size + len > _capacity) {
    //    reserve(_size + len);
    //}
    //strcpy(_str + _size, str);
    strcat(_str,str);
    //_size += len;
    insert(_size, str);
}
string& operator+=(char ch) {
    push_back(ch);
    return *this;
}
string& operator+=(const char* str) {
    append(str);
    return *this;
}
}

从任意位置删除n个字符


string& erase(size_t pos, size_t len = npos) {
    assert(pos < _size);
    if (len == npos || pos + len >= _size) {
        _str[pos] = '\0';
        _size = pos;
    }
    else {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }
    return *this;
}

查找字符/字符串

size_t find(char ch,size_t pos=0) {
    assert(pos < _size);
    for (size_t i = pos; i < _size; ++i) {
        if (_str[i] == ch) {
            return i;
        }
    }
    return npos;
}
size_t find(const char* str, size_t pos = 0) {
    assert(pos < _size);
    char* p = strstr(_str + pos, str);
    if (p == nullptr) {
        return npos;
    }
    else {
        return p - str;
    }
}

将字符串置空

void clear() {
    _str[0] = '\0';
    _size = 0;
}

获取字符串

const char* c_str() {
    return _str;
}

比较运算符重载

bool operator>(const string& s) const {
    return strcmp(_str, s._str) > 0;
}
bool operator==(const string& s) const {
    return strcmp(_str, s._str) == 0;
}
bool operator>=(const string& s) const {
    return *this > s || *this == s;
}
bool operator<(const string& s) const {
    //return strcmp(_str, s._str) < 0;
    return !(*this >= s);
}
bool operator<=(const string& s) const {
    //return *this < s || *this == s;
    return !(*this > s);
}

流提取和流插入运算符重载

ostream& operator<<(ostream& out, const string& s) {
    for (auto ch : s) {
        out << ch;
    }
    return out;
}
istream& operator>>(istream& in, string& s) {
    s.clear();
    char ch=in.get();
    char buff[128];
    size_t i = 0;
    while (ch != ' ' && ch != '\n') {
        buff[i++] = ch;
        if (i == 127) {
            buff[127] = '\0';
            s += buff;
            i = 0;
        }
        ch= in.get();
    }
    if (i !=0) {
        buff[i] = '\0';
        s += buff;
    }
    return in;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/829296.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Linux:强制用户访问加密(强制让用户使用https访问)

Linux&#xff1a;强制用户访问加密&#xff08;强制让用户使用https访问&#xff09; [rootserver100 ~]# vim /etc/nginx/conf.d/vhosts.conf# 修改扩展配置文件如下#下面是对访问http进行重写&#xff0c;自动导向到https server{listen 80;server_name login.timinglee.o…

Leetcode哈希表刷题(一)

给你两个字符串&#xff1a;ransomNote 和 magazine &#xff0c;判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以&#xff0c;返回 true &#xff1b;否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。 示例 1&#xff1a; 输入&#xff…

MySQL双层游标嵌套循环方法

文章目录 1、需求描述2、思路3、创建存储过程 1、需求描述 1、在项目中&#xff0c;需要将A表中主键id&#xff0c;逐个取出&#xff0c;作为条件&#xff0c;在B表中去逐一查询&#xff0c;将B表查询到的结果集&#xff08;A表B表关系&#xff1a;一对多&#xff09;&#xf…

在CentOS7中wget命令显示not found怎么解决

实验需要&#xff0c;在本机上安装了一个CentOS7虚拟机&#xff0c;运行wget命令时显示not found。按照网上的教程&#xff0c;使用命令sudo yum install wget&#xff0c;依然失败。 怎么回事呢&#xff1f;会不会是网络的原因呢&#xff1f;想到这&#xff0c;ping了一下www…

达梦(DM) SQL日期操作及分析函数

达梦DM SQL日期操作及分析函数 日期操作SYSDATEEXTRACT判断一年是否为闰年周的计算确定某月内第一个和最后一个周末某天的日期确定指定年份季度的开始日期和结束日期补充范围内丢失的值按照给定的时间单位查找使用日期的特殊部分比较记录 范围处理分析函数定位连续值的范围查找…

DNA序列k-mers哈希映射和相似序列查找

对DNA序列的k-mer进行哈希映射和相似序列查找是生物信息学中常见的任务之一。使用哈希函数对DNA序列的k-mer进行映射&#xff0c;并使用哈希表进行相似序列的查找。这种方法可以加速相似序列的搜索&#xff0c;并在处理大规模DNA序列数据时具有较好的性能。 哈希函数是一种将输…

C++系列-输入输出

&#x1f308;个人主页&#xff1a;羽晨同学 &#x1f4ab;个人格言:“成为自己未来的主人~” C输入和输出 我们都知道C语言的输出是用printf函数来实现的&#xff0c;那么C呢&#xff0c;它的实现逻辑是什么呢&#xff0c;让我们一起来看一下&#xff0c; #include<i…

docker入门级命令

基本概念 docker的连个基本概念&#xff1a;镜像、容器。 docker镜像可以理解为是存储docker安装包的地方&#xff0c;比如&#xff1a;mcr.microsoft.com/mssql/server:2017-latest是sqlserver的docker镜像。 可以通过docker pull命令拉取远程镜像到本地。比如&#xff1a;…

K8S 调试运行中报错的 Pod

开始调试有问题的 Pod 准备环境 创建一个例子用于测试&#xff1a; apiVersion: apps/v1 kind: Deployment metadata:name: nginx-deploymentnamespace: apps spec:selector:matchLabels:app: nginxreplicas: 2template:metadata:labels:app: nginxspec:containers:- name: …

Linux系统安全及应用(1)

目录 一.账号安全控制 系统账号清理 二.密码安全控制 密码安全控制 三.命令历史限制 命令历史限制 四.限制su切换用户 1&#xff09;将信任的用户加入到wheel组中 2&#xff09;修改su的PAM认证配置文件 ​编辑五.PAM认证的构成 六.使用sudo机制提升权限…

android 上传视频

1.在页面按钮或图标控件中添加点击事件&#xff0c;并调用选择文件动作 //点击图片选择视频按钮事件public void uploadvideo(View view){Intent intent new Intent(Intent.ACTION_GET_CONTENT); // 选择文件动作intent.setType("video/*"); …

python数据分析与可视化

Python数据分析与可视化是数据科学领域的重要技能&#xff0c;它涉及到使用Python语言及其丰富的库来分析数据、提取信息、并将其转换为易于理解的图表和图形。以下是Python数据分析与可视化的一些关键点&#xff1a; ### 1. 数据分析库 - **Pandas**&#xff1a;用于数据处理…

IDEA离线安装插件

1、下载地址 https://plugins.jetbrains.com/idea 如果去其他编辑器&#xff0c;点击下拉&#xff0c;选择即可。 2.搜索 在输入框输入关键词&#xff0c;按照提示选择即可&#xff0c;点击搜索按钮&#xff0c;查看结果。 3、选择版本 按照自己的版本选择合适的版本 4、安…

8086:qemu执行汇编

正文 环境&#xff1a;macOS M1。 QEMU&#xff08;Quick EMUlator&#xff09;是一个开源的虚拟机监视器&#xff0c;可以模拟多种硬件平台&#xff0c;包括处理器架构、设备和操作系统。QEMU具有以下主要功能和用途&#xff1a; 硬件模拟器&#xff1a;QEMU可以模拟多种处理…

TP8 利用jwt 生成token

使用Composer安装依赖库&#xff0c;终端切换到项目根目录输入如下 composer require firebase/php-jwt 下面是示例代码&#xff1a; <?php namespace app\common\base;use Firebase\JWT\JWT; use Firebase\JWT\Key;class Token {/*** 创建 token* param array $data 必填…

linux的SSH(远程登录)服务

目录 1.SSH远程管理 1.1 SSH的概述 1.2 OpenSSH服务器 1.3 SSH端口、配置文件 2.服务端重要配置 3.登录验证方式 3.1 密码验证 3.2 密钥对验证 4.使用 SSH 客户端程序 4.1 ssh 远程登录 4.2 scp 远程复制 4.3 sftp文件传输 5.创建使用密钥对 6.TCP Wrappers访问控…

CLIP论文笔记:Learning Transferable Visual Models From Natural Language Supervision

导语 会议&#xff1a;ICML 2021链接&#xff1a;https://proceedings.mlr.press/v139/radford21a/radford21a.pdf 当前的计算机视觉系统通常只能识别预先设定的对象类别&#xff0c;这限制了它们的广泛应用。为了突破这一局限&#xff0c;本文探索了一种新的学习方法&#x…

机器学习之sklearn基础教程

Scikit-learn&#xff08;简称sklearn&#xff09;是一个广泛使用的机器学习库。 1. **安装sklearn**&#xff1a;推荐使用Anaconda进行安装&#xff0c;以避免配置和环境问题。也可以直接通过pip命令安装&#xff1a;pip install scikit-learn。 2. **数据集生成**&#xff1…

如何在 CentOS VPS 上配置 vsftpd 使用 SSL/TLS

介绍 FTP&#xff08;文件传输协议&#xff09;是一种在本地和远程服务器之间传输文件的方式。尽管非常流行和普遍&#xff0c;但由于其设计中固有的安全性缺失&#xff0c;使用这种文件传输方法已经不再受欢迎。 一个非常有能力的替代方案是SFTP&#xff0c;如上所述。该协议…

conda修改当前环境中的python版本

1. 首先查看当前的python版本 python -V 2. 进入已经激活的conda环境&#xff0c;搜索库中有无想要的python版本(若有想安装的版本可跳过) conda search --full --name python 3. 安装库中存在且符合要求的python版本即可(以python3.8.1为例) conda install python3.8.1