利用Pycharm与Anconda进行python开发

爱学习的易老师

已于 2024-09-13 19:59:53 修改

阅读量2.8k

点赞数 14

文章标签： python pycharm ide conda

于 2024-09-13 17:59:33 首次发布

本文链接：https://blog.youkuaiyun.com/qq_39650423/article/details/142215810

版权

配置Pycharm

1.前往jetbrains官网下载Pycharm，或直接在百度搜索Pycharm，Pycharm分为社区版和专业版。社区版完全免费，专业版可以免费试用30天。
注意：不要下载到盗版收费的Pycharm。
注意：建议使用Pycharm专业版，凡是专业版可以去淘宝购买激活码，请支持正版。

2.创建一个新项目：
创建时选择Python解释器，由于我们是使用Anaconda进行环境管理，所以我们直接选择先前配置好的环境。
在这里插入图片描述

如果你找不到自己的配置环境，请点击Add Interpreter添加环境。
在这里插入图片描述
我们选择添加本地的解释器。并选择conda环境

注意：如果你的Anaconda在安装时安装到了自定义目录，你可能需要手动指定你的conda.bat。
然后你可以选择使用当前已经存在的环境。

环境创建完成后可以进入项目
在这里插入图片描述
进入后请运行print输出hello word。

当你在Python中编写一个脚本，并且这个脚本可以独立运行时，通常会在脚本的末尾看到这样的代码结构：

if __name__ == '__main__':
    # 这里是主程序的入口
    main()

这段代码的作用是检查当前模块是否作为主程序运行。如果是直接运行这个脚本（而不是导入到其他脚本中），那么 __name__ 变量会被设置为 '__main__'，因此 if __name__ == '__main__': 会判断为真，从而执行缩进下的代码块。

如果不使用 if __name__ == '__main__': 结构，而是将所有的代码都写在文件的顶层，那么当脚本被导入到其他模块时，所有顶级代码都会被执行，这可能不是你想要的行为，特别是在脚本中包含了一些初始化或者只应该在运行时调用的代码时。

但是，如果你确定你的脚本不会被其他脚本导入，或者脚本本身就是一个简单的脚本，没有复杂的导入逻辑，那么你可以直接将你希望首先执行的代码放在脚本的顶部。例如：

def main():
    print("Hello, world!")

# 直接调用
main()

这样写也是完全有效的，而且对于简单的脚本来说更加简洁。然而，在开发较大的项目或可复用的模块时，使用 if __name__ == '__main__': 是一种标准的做法，它能够提供更好的封装性和灵活性。

下面的写法也可以正确运行。当时如果下面这个文件被当作包引用的话这个print_hi(‘Pycharm’)也会被运行。
在这里插入图片描述

3.通义灵码的使用
前往File–setting界面，选择plugins(插件)
在这里插入图片描述
安装通义灵码：

使用通义灵码–以此自然语言处理编程。
我们可以在上面写注释，下面则会自动生成代码。

Python开发

让我们专注于 Python 和 Java 在基本控制结构（顺序、选择、循环）以及类和对象方面的写法区别。下面是一些示例代码，展示了这两种语言在这几个方面的不同之处。

顺序结构

顺序结构是最基本的代码执行方式，按照代码出现的顺序依次执行。

Python

print("Hello, World!")
x = 5
y = 10
z = x + y
print(z)

Java

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
        int x = 5;
        int y = 10;
        int z = x + y;
        System.out.println(z);
    }
}

选择结构

选择结构允许根据条件执行不同的代码块。

Python

age = 20
if age >= 18:
    print("成年人")
else:
    print("未成年人")

Java

public class Main {
    public static void main(String[] args) {
        int age = 20;
        if (age >= 18) {
            System.out.println("成年人");
        } else {
            System.out.println("未成年人");
        }
    }
}

循环结构

循环结构用于重复执行一段代码直到满足某个条件。

Python

for i in range(5):
    print(i)

i = 0
while i < 5:
    print(i)
    i += 1

Java

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }

        int i = 0;
        while (i < 5) {
            System.out.println(i);
            i++;
        }
    }
}

类和对象

类是一种定义对象的数据结构和方法的方式，对象则是类的一个实例。

Python

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        print(f"我的名字叫 {self.name}，我今年 {self.age} 岁。")

person = Person("Alice", 30)
person.introduce()

Java

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("我的名字叫 " + name + "，我今年 " + age + " 岁。");
    }

}
// 假设主文件为另一个文件，且引入了类
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.introduce();
    }
}

私有类和公有类

私有成员只能在定义它们的类内部访问，而公有成员可以从外部访问。

Python

Python 中并没有严格的私有成员概念，但可以通过命名约定来表示私有成员，即以双下划线开头的成员被认为是私有的。

class MyClass:
    def __init__(self):
        self.public_attribute = "Public"
        self.__private_attribute = "Private"

    def get_private(self):
        return self.__private_attribute

obj = MyClass()
print(obj.public_attribute)  # 公有属性可以直接访问
print(obj.get_private())     # 私有属性通过公共方法访问

Java

Java 中使用 private 关键字来定义私有成员，使用 public 关键字来定义公有成员。

public class MyClass {
    public String publicAttribute = "Public";
    private String privateAttribute = "Private";

    public String getPrivateAttribute() {
        return privateAttribute;
    }
}

// 假设主文件为另一个文件，且引入了类
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(obj.publicAttribute);  // 公有属性可以直接访问
        System.out.println(obj.getPrivateAttribute());  // 私有属性通过公共方法访问
    }
}

好的，让我们继续探讨 Java 和 Python 在数组与列表、字典（Java 中称为 Map）以及变量命名规则方面的区别。

数组与列表

数组和列表都是用来存储一组元素的数据结构，但在 Java 和 Python 中，它们的实现和使用方式有所不同。

Python

在 Python 中，列表（list）是一种动态数组，可以存储不同类型的元素，并且可以在运行时改变大小。

# 创建列表
numbers = [1, 2, 3]
mixed = ["apple", 42, True]

# 访问元素
print(numbers[0])  # 输出: 1

# 修改元素
numbers[0] = 100

# 添加元素
numbers.append(4)

# 删除元素
numbers.remove(2)

# 遍历列表
for num in numbers:
    print(num)

Java

在 Java 中，数组是固定大小的数据结构，只能存储相同类型的元素。此外，Java 还提供了 List 接口及其实现类（如 ArrayList）来提供动态数组的功能。

// 创建数组
int[] numbers = new int[]{1, 2, 3};
Object[] mixed = new Object[]{"apple", 42, true};

// 访问元素
System.out.println(numbers[0]);  // 输出: 1

// 修改元素
numbers[0] = 100;

// 使用 ArrayList
import java.util.ArrayList;
import java.util.List;

List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);

// 添加元素
numList.add(4);

// 删除元素
numList.remove(Integer.valueOf(2));

// 遍历 List
for (Integer num : numList) {
    System.out.println(num);
}

字典（Map）

字典（在 Python 中称为 dictionary 或 dict）是一种键值对的数据结构。在 Java 中，这种结构称为 Map。

Python

在 Python 中，字典是由键值对组成的集合，键必须是不可变的类型。

# 创建字典
data = {"name": "Alice", "age": 30}

# 访问元素
print(data["name"])  # 输出: Alice

# 修改元素
data["age"] = 31

# 添加元素
data["city"] = "New York"

# 删除元素
del data["age"]

# 遍历字典
for key, value in data.items():
    print(f"{key}: {value}")

Java

在 Java 中，Map 接口提供了键值对映射的功能，常用实现类包括 HashMap 和 TreeMap。

import java.util.HashMap;
import java.util.Map;

// 创建 HashMap
Map<String, Integer> data = new HashMap<>();
data.put("name", 30);

// 访问元素
System.out.println(data.get("name"));  // 输出: 30

// 修改元素
data.put("name", 31);

// 添加元素
data.put("city", 3);

// 删除元素
data.remove("age");

// 遍历 Map
for (Map.Entry<String, Integer> entry : data.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}