Python的基础使用

2023-01-20

字数：2.9k字 | 预计阅读时长：11分钟

本文主要介绍Python的基本使用，旨在快速入门Python，或者查找需要的内容，文章参考Python。

1.Python环境配置和编译器设置

1.1手动添加镜像源

该操作是为了可以在使用Python指令时，快速下载相关包，避免超时或者魔法。

pip install 下载的模块名 -i https://pypi.tuna.tsinghua.edu.cn/simple
#例如：pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple，下载numpy模块
常用的镜像：
清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学：https://pypi.mirrors.ustc.edu.cn/simple/

1.2好用的插件/汉化

TabNine和汉化包，在settings里的插件可以找到。记得设置代理，改成默认的即可（原来的需要手动添加，我用了魔法，不一定不用梯子的话能保证下载速度）。

2.Python注释

2.1单行注释

"#"+注释内容

2.2多行注释

左键选中我们需要注释的代码，松开，按：Ctrl+/，就完成相同效果注释。（也可以一行一行加注释）

取消注释
左键选中我们需要取消注释的代码，松开，按：Ctrl+/。

3.Python的变量

在python中，进行赋值时会创建变量：python中没有用于声明变量的指令，在进行第一次赋值时会自动创建变量，且对于同一名字的变量，会因为赋值的不同而导致变量的数据类型改变（我觉得用习惯C及其派生的语言：CPP，Java之类的会觉得python的数据管理会好混乱）。

3.1强制数据类型转化

如果需要指定某一数据类型，可使用强制数据类型转换：


x = str(3)         # x will be '3'

y = int(3)    # y will be 3
    
z = float(3)  # z will be 3.0

3.2Python变量名命名规则

变量名必须以字母或下划线字符开头
变量名不能以数字开头
变量名称只能包含字母数字字符和下划线（Az、0-9 和 _ ）
变量名区分大小写（age、Age和AGE是三个不同的变量）

常见的命名法则：

骆驼法则：除了第一个单词外，每个单词都以大写字母开头

1	myNameIs = "Nagisa"

帕斯卡法则：每个单词都以大写字母开头

1	MyNameIs = "Nagisa"

蛇形法则：每个单词由下划线字符分隔

1	My_Name_Is = "Nagisa"

(1)变量的命名规则要求用“匈牙利法则”。
即开头字母用变量的类型，其余部分用变量的英文意思、英文的缩写、中文全拼或中文全拼的缩写,要求单词的第一个字母应大写。
即：变量名=变量类型+变量的英文意思(或英文缩写、中文全拼、中文全拼缩写)
对非通用的变量，在定义时加入注释说明，变量定义尽量可能放在函数的开始处。
见下表：

类型	首字母	例子
bool	用b开头	b标志寄存器
int	用i开头	iCount
short int	用n开头	nStepCount
long int	用l开头	lSum
char	用c开头	cCount
unsigned char	用by开头
float	用f开头	fAvg
double	用d开头	dDeta
unsigned int(WORD)	用w开头	wCount
unsigned long int(DWORD)	用dw开头	dwBroad
字符串	用s开头	sFileName
用0结尾的字符串	用sz开头	szFileName

(2)指针变量命名的基本原则为：

对一重指针变量的基本原则为：“p”+变量类型前缀+命名，如一个float*型应该表示为pfStat。对二重指针变量的基本规则为：“pp”+变量类型前缀+命名。对三重指针变量的基本规则为：“ppp”+变量类型前缀+命名。
(3)全局变量用g_开头,如一个全局的长型变量定义为g_lFailCount。即：变量名=g_+变量类型+变量的英文意思(或缩写)。此规则还可避免局部变量和全局变量同名而引起的问题。
(4)静态变量用s_开头,如一个静态的指针变量定义为s_plPerv_Inst。即：变量名=s_+变量类型+变量的英文意思(或缩写)
(5)对枚举类型(enum)中的变量，要求用枚举变量或其缩写做前缀。并且要求用大写。如：

enum cmEMDAYS
{
EMDAYS_MONDAY;
EMDAYS_TUESDAY;
……
};
123456

(6)对struct、union变量的命名要求定义的类型用大写。并要加上前缀，其内部变量的命名规则与变量命名规则一致。
结构一般用S开头，如：

struct ScmNPoint
{
int nX;//点的X位置
int nY; //点的Y位置
};
12345

联合体一般用U开头，如:

union UcmLPoint
{
LONG lX;
LONG lY;
}
12345

(7)对常量(包括错误的编码)命名，要求常量名用大写，常量名用英文表达其意思。当需要由多个单词表示时，单词与单词之间必须采用连字符“_”连接。

如：#define CM_FILE_NOT_FOUND CMMAKEHR(0X20B) 其中CM表示类别。

(8)对const 的变量要求在变量的命名规则前加入c_。即：c_+变量命名规则；示例：const char* c_szFileName;

3.3函数的命名规范

(1)函数的命名应该尽量用英文(或英文缩写、中文全拼、中文全拼缩写)表达出函数完成的功能——函数名应准确描述函数的功能。遵循动宾结构的命名法则，函数名中动词在前,并在命名前加入函数的前缀，函数名的长度不得少于8个字母。函数名首字大写，若包含有两个单词的每个单词首字母大写。如果是OOP 方法，可以只有动词(名词是对象本身)。示例：

LONG GetDeviceCount(……);
void print_record( unsigned int rec_ind ) ;
intinput_record( void ) ;
unsigned char get_current_color( void ) ;
1234

(2)避免使用无意义或含义不清的动词为函数命名。如使用process、handle等为函数命名，因为这些动词并没有说明要具体做什么。

(3)必须使用函数原型声明。函数原型声明包括：引用外来函数及内部函数，外部引用必须在右侧注明函数来源：模块名及文件名；内部函数，只要注释其定义文件名——和调用者在同一文件中(简单程序)时不需要注释。
应确保每个函数声明中的参数的名称、类型和定义中的名称、类型一致。

3.4函数参数命名规范

(1)参数名称的命名参照变量命名规范。
(2)为了提高程序的运行效率，减少参数占用的堆栈，传递大结构的参数，一律采用指针或引用方式传递。
(3)为了便于其他程序员识别某个指针参数是入口参数还是出口参数，同时便于编译器检查错误，应该在入口参数前加入const标志。

如：……cmCopyString(const CHAR * c_szSource, CHAR * szDest)

文件名(包括动态库、组件、控件、工程文件等)的命名规范文件名的命名要求表达出文件的内容，要求文件名的长度不得少于5个字母，严禁使用象file1,myfile之类的文件名。

4.Python数据类型

默认情况下，python有以下几种数据类型：

 文本类型： 
 str

 数字类型： 
 int, 
 float, 
 complex

 序列类型： 
 list, 
 tuple, 
 range

 映射类型： 
 dict

 套装类型： 
 set, 
 frozenset    

 布尔类型： 
 bool  

 二进制类型： 
 bytes, 
 bytearray, 
 memoryview

想要获取变量的数据类型时，可使用：

1	type()#返回变量的数据类型

[ f(x_1; w, b) = 0.8 \times 1 + 0.5 = 1.3 ]

[ L(w, b) = \frac{1}{3}[(1.3 - 2)^2 + (1.3 - 4)^2 + (1.3 - 6)^2] = \frac{1}{3}(0.49 + 6.76 + 19.36) = 8.53 ]
$$
MSE=
n
1

∑
i=1
n

(y
i

−f(x
i

))
2
$$

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.Enhancer;
import java.lang.reflect.Method;

public class ControllerInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在方法执行前执行增强逻辑
        System.out.println("Before method execution");

        // 调用原始方法
        Object result = proxy.invokeSuper(obj, args);

        // 在方法执行后执行增强逻辑
        System.out.println("After method execution");

        return result;
    }
}

public class MyController {
    public void myControllerMethod() {
        System.out.println("Inside the original method");
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyController.class);
        enhancer.setCallback(new ControllerInterceptor());

        MyController myController = (MyController) enhancer.create();
        myController.myControllerMethod();
    }
}

[bot] 根据你提供的代码，我注意到你尝试在AdminController中使用CGLIB来实现方法拦截和增强。然而，通常情况下，我们不会直接在Controller类中使用CGLIB进行方法拦截和增强，而是通过AOP来完成这个任务。以下是我修改后的代码示例，以符合使用规则：

首先，创建一个切面类MyAspect来实现方法拦截和增强：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.controller.AdminController.*(..))")
    public void beforeAdminMethodExecution(){
        System.out.println("Before method execution");
        // 在这里可以添加需要执行的逻辑
    }
}

然后，确保你的AdminController被正确标记为@Controller，以及适当地进行RequestMapping：

import org.springframework.stereotype.Controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/admin")
public class AdminController {
    @Autowired(required = false)
    private AdminService adminService;

    @RequestMapping("/index")
    public String toIndex() {
        return "index";
    }

    @RequestMapping("/toAdminIndex")
    public String toAdminIndex() {
        // 方法逻辑
        return "adminIndex";
    }
}

最后，在你的Spring配置类中使用@EnableAspectJAutoProxy来启用自动代理功能，并将MyAspect类注册到Spring容器中：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.ComponentScan;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.example") // 替换为你的包名
public class AppConfig {
    // 其他配置内容
}

在这个示例中，MyAspect类使用了@Aspect和@Before注解来定义了一个切面，用于在AdminController的方法执行前插入逻辑。AdminController类被标记为@Controller，并使用@RequestMapping来定义请求映射。

在Spring的配置类中，我们使用了@EnableAspectJAutoProxy来启用注解驱动的AOP，并使用@ComponentScan来扫描指定包下的组件。

通过以上修改，你可以使用AOP的方式实现方法拦截和增强，而不需要直接在AdminController中使用CGLIB。希望这能帮助你解决问题。如果你有任何疑问，欢迎随时向我询问。

import openai
import pandas as pd
import json
import time
# 设置 OpenAI API 密钥
openai.api_key = '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'

# 读取 JSON 文件
json_file_path = 'en.json'
with open(json_file_path, 'r', encoding='utf-8') as file:
    data = json.load(file)

# 创建一个空的 DataFrame，用于存储翻译结果
translated_df = pd.DataFrame(columns=['image_id', 'caption', 'translation'])

# 循环处理每个 caption
for entry in data['annotations']:
    image_id = entry['image_id']
    caption = entry['caption']

    # 打印当前对话的内容
    print(f"Image ID: {image_id}")
    print(f"User: {caption}")

    # 发送请求到 OpenAI API 进行翻译
    response = openai.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a professional cardiologist."},
            {"role": "user", "content": f"Translate the following English text to Chinese and give your advice in Chinese:\n\n{caption}\n\nTranslation:"},
        ]
    )

    # 提取翻译结果
    translation = response.choices[0].message.content
    print(f"Assistant: {translation}")
    new_row = pd.DataFrame({'image_id': [image_id], 'caption': [caption], 'translation': [translation]})
    translated_df = pd.concat([translated_df, new_row], ignore_index=True)
    time.sleep(30)
    excel_file_path = 'translations.xlsx'
    translated_df.to_excel(excel_file_path, index=False)

# 保存翻译结果到 Excel 文件


print(f"翻译完成，已保存到 {excel_file_path}")