当前位置：首页 > news >正文

Python使用方式介绍

news 文章来源：https://blog.csdn.net/Sheng_Q/article/details/137597345 2024/10/31 11:36:06

1.安装与版本和IDE

1.1 python2.x和python3.x区别

python2在2020已经不再维护，目前主流开发使用python3. 二者语法上略有区别：输入输出、数据处理、异常和默认编码等，如:python3中字符串为Unicode字符串，使用UTF-8编码，而python2默认使用ASCII编码。python2和python3对应的包管理工具分别是pip和pip3. 另外，Python3引入了一些高级解释器特性，如协程、类型提示、异步编程等。
软件升级过程中，设计时不考虑向下相容(减少累赘)，因此python3不完全兼容python2. 可通过Python3自带的工具2to3对python文件进行转换，类似前端的ES6转ES5。

linux系统默认自带python2, python3一般需要手动安装, 可以参考: Python3安装教程。

说明：以下以python3为例进行介绍。

1.2 python的IDE

个人推荐 PyCharm和Spyder，其中: Spyder是免费的，Pycharm的社区办是免费，而专业版收费。

2.工具包管理工具的使用和配置

python3使用pip3包管理工具处理依赖问题，类似java开发者用到的Maven.

2.1 配置三方包的镜像源和下载路径

镜像源配置:

镜像源配置可以通过命令(pip3 config set)或者配置文件方式进行修改，本文以配置文件方式进行说明。

windows系统中, 通过echo %APPDATA%查看pip文件夹所在路径，修改%APPDATA%/pip/pip.ini配置文件:

[global]
timeout = 6000
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn

修改完成后，可通过pip命令查看是否修改成功:

D:\demo>pip3 config list
global.index-url='https://pypi.tuna.tsinghua.edu.cn/simple'
global.timeout='6000'
global.trusted-host='pypi.tuna.tsinghua.edu.cn'

Linux系统中, 通过修改~/.pip/pip.conf配置文件:

[root@seong bin]# cat ~/.pip/pip.conf
[global]
index-url = http://mirrors.tencentyun.com/pypi/simple
trusted-host = mirrors.tencentyun.com

修改完成后，可通过pip命令查看是否修改成功:

[root@seong bin]# ./pip3 config list
global.index-url='http://mirrors.tencentyun.com/pypi/simple'
global.trusted-host='mirrors.tencentyun.com'

下载路径配置:

配置文件中通过target指定依赖包存放的地址.

[root@seong bin]# cat ~/.pip/pip.conf
[global]
index-url = http://mirrors.tencentyun.com/pypi/simple
trusted-host = mirrors.tencentyun.com
target = D:\xxx\Lib\site-packages

或者：

pip3 config set global.target D:\xxx\Lib\site-packages

2.2 IDE配置镜像源和安装路径

这里以pycharm进行介绍，使用pycharm管理项目时，可以选择Project venv或者Custom environment或者使用Conda环境。
Project venv(Virtual Environment)是一种基于Python的虚拟环境，可为每个项目创建独立的Python环境，确保依赖包与其他项目相互隔离，避免版本冲突，较为常用。此时依赖包存放于项目根路径的.venv/Lib/site-packages目录下。
Custom environment支持手动指定Python解释器的路径。可以使用系统中已经安装的Python解释器或者虚拟环境。此时共用指定python环境的依赖包(而不需要单独维护一份)。

2.3 使用requirements.txt文件

requirements.txt 文件用于记录项目的依赖包以及版本信息, 用于项目的依赖管理。在一台机器上将某个项目的依赖导出为requirements.txt ，在另一台机器上可以根据requirements.txt 下载该项目的所有依赖包。

格式如下所示:

s
a>=1.0
b>=1.0, <1.1
c==2.0

可以用==精确指定版本号，也可以使用 >= 或 < 或完全不指定，由python根据依赖关系确定。

生成requirements.txt

# pip freeze会把当前环境(或虚拟环境)下所依赖的所有包信息写入到requirements.txt文件中
# pip list会比pip freeze多几个包(pip , wheel , setuptools等)
pip freeze > requirements.txt# 推荐使用pipreqs导出依赖包
# pipreqs仅导出程序所用到的包， 通过python3 -m pip install pipreqs 安装pipreqs
pipreqs ./ --encoding=utf8

使用requirements.txt导入依赖

#根据requirements.txt配置下载依赖项
pip install -r requirements.txt

2.4 pip3常用操作命令

#1.查看已安装的三方包列表
pip list#2.安装包
pip install 包名
pip install 包名==版本号
pip install .whl安装包名 #通过.whl安装包安装
pip install -r requirements.txt #通过requirements.txt配置文件安装#3.卸载包
pip uninstall 包名#4.升级包
pip install -U 包名#5.查看包信息
pip show 包名

其中，通过pip install安装包时，可以通过 -i 指定使用的镜像源，如:

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/ django

2.5 离线依赖包使用方式

#1.准备requirements.txt文件
pipreqs ./ --encoding=utf8#2.生成离线依赖包
# -r 指定requirements.txt文件（生成的离线包中包含requirements.txt指定的依赖项）
# -d 指定离线包的保存路径
# 最终会生成很多.whl文件
pip download -r requirements.txt -d packages/#3.指定从离线依赖包中安装依赖项
# -r 需要安装的依赖项
# --no-index 禁止从PyPI索引依赖包
# -find-links指定索引依赖包的路径
pip install -r ./requirements.txt --no-index --find-links=./packages

在步骤2中生成的.whl文件，可以导入至无法联网的机器后，可以通过.whl文件安装依赖包。

3.脚本运行原理

python类似java使用解释器+虚拟机的方式实现跨平台：python源码经过解释器和编译器生成 pyc 字节码文件，有PVM虚拟机读取pyc文件并执行。对于不同的平台有不同的PVM，将pyc文件的指令翻译为CPU指令执行。

4.包和模块的概念

4.1 包的概念

包可以将多个模块和子包组成在一起，每个包下需要有一个_ _init_ _.py文件，否则包会被当做普通目录对待。
包下的多个模块构成一个整体，可通过同一个包导入其他代码中。

4.2 模块的概念

每个python文件是一个模块，模块用于对逻辑进行封装，减少代码的耦合度。python中存在3种类型的模块：内置模块、三方模块、自定义模块;
[1] 内置模块：python自带的模块，如os提供操作系统的IO访问功能，math数学运算, random随机数，json解析json文件，datetime处理日期和时间相关;
[2] 三方模块：第三方开发的模块，可以通过pip安装后，再导入使用；如django提供web能力;
[3] 自定义模块：自己开发的py文件。

4.3 导入模块

#导入模块，可通过as 进行别名
import 模块
import 模块 as m1# 从模块中导入类、函数、变量等，可通过as进行别名
from 模块 import 函数
from 模块 import 函数1, 函数2
from 模块 import 函数1 as f1, 函数2 as f2

4.3 import机制

当你导入一个模块时，Python会执行该模块的代码，从而创建该模块的命名空间。这个命名空间包含了模块中定义的所有函数、类、变量等。本质上，就是将导入的模块复制到当前文件中，但是会通过命名空间进行封装。import语句导入指定的模块时会执行三个步骤：[1] 找到模块文件；[2] 编译成字节码；[3] 依次执行

说明：模块仅初始导入时才会执行上述步骤，后续的导入会从内存中加载的模块对象。

4.4 案例介绍

1.同级目录下，可以直接导入

-- a.py
-- b.py#在a.py中导入b模块
import b

2.模块a位于上一层级

-- a.py
-- pkg-- __init__.py-- b.py#在a.py中导入b模块
import pkg.b #或者 from pkg import b

3.其他场景

sys.path是一个列表数据结构，包含了解释器搜索模块的路径。当导入一个模块时，解释器会按照sys.path中的顺序逐个搜索模块的位置，都找不到会报错。 sys.path包含当前目录、python标准库所在目录、第三方库所在目录。其他场景时(如模块a位于模块b的下一层级)，sys.path因不包含模块b的路径而找不到模块，因此需要手动将路径加入到sys.path列表中。

case1:模块a位于下一层级

-- b.py
-- pkg-- __init__.py-- a.py# 此时，可通过添加父路径完成
sys.path.append(str(Path(__file__).resolve().parents[1]))
# 或者
import os
sys.path.append(os.getcwd())import b

此时，模块a导入模块b需要两个步骤：
[1] 将模块b所在路径添加到解析器的模块搜索路径sys.path；
[2] 导入模块b.

case2:嵌套导入

--root__init__.pyroot.py--pkg1__init__.py model1.py--pkg2__init__.pymodel2.py--pkg3__init__.pymodel3.py

root.py导入pkg1.model1模块，pkg1.model1导入pkg1.pkg2.model2模块，pkg1.pkg2.model2导入pkg1.pkg2.pkg3.model3模块。

代码如下：

#root.py
from pkg1.model1 import action1print("root model name is " + __name__)
action1()-------------------------------------------------------#model1.py
import sys
from pathlib import Pathsys.path.append(str(Path(__file__).resolve().parents[0]))
from pkg2.model2 import action2def action1():print("model-1 name is " + __name__)action2()-------------------------------------------------------#model2.py
import sys
from pathlib import Pathsys.path.append(str(Path(__file__).resolve().parents[0]))
from pkg3.model3 import action3def action2():print("model-2 name is " + __name__)action3()-------------------------------------------------------#model3.py
def action3():print("model-3 name is " + __name__)

执行结果如下:

root model name is __main__
model-1 name is pkg1.model1
model-2 name is pkg2.model2
model-3 name is pkg3.model3

上述使用相对路径时，在每个文件通过sys.path.append(str(Path(__file__).resolve().parents[0]))将当前所在目录进入了sys.path路径。

5.变量和基本类型

Python中定义变量不需要指定变量类型，函数和类的属性也不需要指定类型。python中变量只能使用字母数字和下划线组成，一般使用小写字母加下划线组成，常量使用大些字母和下划线组成。

5.1 基本变量类型

python中常用的变量类型包括：数值类型、布尔类型、字符串类型、列表类型、元组类型、集合和字典类型。其中，布尔的字面量为True和False。

5.2 空对象

python使用None表示空对象。

a = None
b = None
print(a is None)
print(b is not None)
print(a==b)#代码运行结果如下:
True
False
True

5.3 查看对象类型

可以通过type(obj) 查看对象的类型，如下所示:

a = None
print("None is: %s" % type(a))b = 1
print("1 is: %s" % type(b))c = 'hello'
print("'hello' is: %s" % type(c))
d = []
print("[] is: %s" % type(d))
e = ()
print("() is: %s" % type(e))#代码运行结果如下:
None is: <class 'NoneType'>
1 is: <class 'int'>
'hello' is: <class 'str'>
[] is: <class 'list'>
() is: <class 'tuple'>

6.字符串

python中字符串可以用单引号或者双引号包含，为不可变类型，常用操作如下:

str = "abc123"
#字符串长度
len(str)#字符串切片
str[startIndex:endIndex] 从开始索引截取到结束索引，前开后闭
str[-3:] 最后3个字符
str[:3] 前3个字符
str[:] 整个字符串#数组转字符串
arr = ["a", "b", "c"]
"_".join(arr) 得到 “a_b_c”字符串
#任何对象转字符串
str(obj)#是否已特定字符串开头或者结尾
str.startswith('abc')
str.endswith('abc')
#删除前缀
str.removeprefix(“ss”)#字符串删除左右空格(返回的是处理后的字符串，但是原始字符串不变)
str.strip() 删除左右空格
str.lstrip()删除左边空格
str.rstrip()删除右边空格#f表达式
f"{变量名}{表达式}"#字符串替换
"test%stest%stest%s" % ("1","2","3") 得到 "test1test2test3" 
#也可以直接使用+对字符串进行拼接，需要注意整数等非字符需要使用str(int_temp)转字符串后才可以拼接，而使用%s替换不需要

7.集合类型

7.1 列表

列表中可以存多个不同类型的数据, 常用方法如下:

arr = [1, 2, "ss", True]#根据下标获取数据
arr[0]
#遍历方式
for item in arr:print(item)
#列表长度
len(arr)
#判断是否在数组中
print("ss" in arr)
print("ss" not in arr)#在列表尾部添加一个元素
arr.append("ss")
#在指定的小标位置插入数据
arr.insert(0,"s1")#remove删除数据
arr.remove("ss")
#clear情况列表, 此时列表等于[]
arr.clear();#分片，前开后闭地截取
arr[startIndex,endIndex]
arr[0:3] 获取前3个，即arr[0],arr[1],arr[2]
arr[:]截取全部
arr[:3]前3个
arr[-3:]最后三个

7.2 元组

元组的使用方式与列表相同，区别在于元组创建后不可修改。

tuple_temo = (1, 2, "ss", True)#根据下标获取数据
tuple_temo[0]#遍历方式
for item in tuple_temo:print(item)#获取元组长度
len(tuple_temo)#判断是否在元组中
print("ss" in tuple_temo)
print("ss" not in tuple_temo)#分片，前开后闭地截取
tuple_temo[startIndex,endIndex]
tuple_temo[0:3] 获取前3个，tuple_temo[0],tuple_temo[1],tuple_temo[2]
tuple_temo[:]截取全部
tuple_temo[:3]前3个
tuple_temo[-3:]最后三个

7.3 字典

由多个键值对组成：键必须为不可变类型，如字符串、数值、元组等；值可以是数字、字符串、列表、字典。

#字典用{}表示
dict_temp={}#根据键获取值
dict_temp.get("key") 或者 dict_temp['key']
#获取key列表
dict_temp.keys()
#获取value列表
dict_temp.values()
#获取(键, 值) 元组列表
dict_temp.items()for key,value in dict_temp.items():print(f"key is {key}, value is {value}.")# 根据Key删除元素    
del dict_temp['key']#修改和添加
dict_temp['key1'] = "value1"

8.条件判断和循环逻辑

8.1 条件判断

python使用 == 和 != 表示是否相等和是否不等，使用 and 和 or 和 not表示与或非逻辑；python中只有if语句，没有switch-case语句。

int score = 99;
if score >=80:print("优秀")
elif score >= 70:print("良")
elif score >= 60:print("及格")
else if score >0:print("不及格")
else:pass

由于python使用缩进的方式替代了{}，当处理逻辑为空时，可以使用pass语句占位。

8.2 循环逻辑

for循环

#循环10次
for i in range(0,10):pass#遍历列表
arr = [1, 2, 3, 's']
for item in arr:print(arr)

while循环, 在python中没有do-while循环, while用法案例如下:

while 条件:语句#案例
num = 10
while num > 0:num = num -1;

另外，继续下次循环语句continue和中断循环语句break的用法同java.

9.异常处理与自定义异常

9.1 try-except逻辑

try:#语句1
except:#语句2

当语句1执行过程中遇到异常时，会执行语句2.
注意，不建议这么使用，会将异常信息吞掉，需要指定异常对象，如下所示：

try:#语句1
except 异常类型 as exception:print(exception)#语句2

当需要处理所有的异常类型时, 执行Exception(是所有异常类的父对象)：

try:#语句1
except Exception as exception:print(exception)#语句2

9.2 try-except-else逻辑

try:#语句1
except Exception as exception:print(exception)#语句2
else:#不发生异常执行的逻辑

9.3 try-except-else-finally逻辑

try:#语句1
except Exception as exception:print(exception)#语句2
else:#不发生异常执行的逻辑
finally:#无论是否有异常都执行的语句

9.4 自定义异常

自定义异常需要继承Exception类:

class MyException(Exception):def __init__(self, msg):self.msg = msg# 设置抛出异常的描述信息def __str__(self):return f'MyException occured, msg is {self.msg}'

使用raise抛出异常(类似java的throw)，使用案例如下:

def main():try:raise MyException("消息异常")except Exception as exception:print(exception)main()

运行结果如下:

MyException occured, msg is 消息异常

10.方法的定义和使用

10.1函数使用方式

将功能相似的函数一般放在一个模块里，在使用的地方通过导入的方式使用函数, 从而提高代码的可维护性。

函数的定义

命名规范：函数用小写字母加下划线命名。

def print_name():print("ewen seong")#带有参数的函数名
def print_name(first_name, last_name):print(f"{first_name}{last_name}")#函数可以有返回语句，用于返回一个或多个结果
def print_name(first_name, last_name):name = f"{first_name}{last_name}"print(name)return name#函数定义时，可以指定参数的默认值
def print_name(first_name, last_name="seong"):print(f"{last_name}{first_name}")

函数的调用

#通过参数的顺序进行传参调用
print_name("ewen", "seong")#通过指定形参名进行调用，不需要按照顺序
print_name(first_name="ewen", last_name="seong")
#等价于
print_name(last_name="seong"，first_name="ewen")

10.2 main函数

python与java和C不同，没有固定的main函数格式(按顺序解析执行)。可以手动指定main方法，并作为程序的执行入口，使代码组织更加清晰、易于维护。

if __name__ == "__main__":#main函数执行逻辑

此时，只有当前文件作为运行文件(被导入则不会执行)，才会执行main函数内部的逻辑。

11.类的定义和使用

11.1 类的定义

类名使用首字母大写的驼峰格式，同java;

class MyClass(object):def __init__(self, id, name):self.__id = idself.name = namedef get_id(self):return self.__iddef __set_id(self, id):self.__id = id

[1] 使用class关键字定义python类，所有类的基类为object对象，因此class MyClass(object)等价于class MyClass；
[2] 以双下划线__开头的方法和属性为私有属性，不能使用对象直接访问；否则，可以通过对象直接访问;
[3] 类中存在一个__init__方法，当通过类构造对象时，会调用该方法，初始化对象;
[4] 类中定义的方法中包含一个self对象，指代当前对象本身；方法被调用时，不需要用户传递。

11.2 类的使用

#直接通过类名以及__init__方法的入参进行构造类对象
myObj1 = MyClass(110, "name-110")#通过对象调用公有方法
print(myObj1.get_id())#通过对象获取公有属性
print(myObj1.name)

运行得到结果如下:

110
name-110

当强行访问私有方法或者私有属性时，会报错:

myObj1 = MyClass(110, "name-110")
#通过对象获取私有属性，报错
print(myObj1.__id)Traceback (most recent call last):File "E:\Data\2024\4\4.7-4.12\48\V5pythonDemo\V5pythonDemo\test\other_module.py", line 17, in <module>print(myObj1.__id)^^^^^^^^^^^
AttributeError: 'MyClass' object has no attribute '__id'myObj1 = MyClass(110, "name-110")
#通过对象调用私有方法，报错
myObj1.__set_id(111)
Traceback (most recent call last):File "E:\Data\2024\4\4.7-4.12\48\V5pythonDemo\V5pythonDemo\test\other_module.py", line 18, in <module>myObj1.__set_id(111)^^^^^^^^^^^^^^^
AttributeError: 'MyClass' object has no attribute '__set_id'

11.3 继承

子类继承父类时，拥有父类所有的属性和方法。注意：需要在子类的初始化函数中，调用父类的初始化方法。

class MySubClass(MyClass):def __init__(self, id, name, age):super().__init__(id, name)self.age = agedef get_age(self):return self.agedef print_msg(self):print(f"id is {super().get_id()}, name is {self.name}, age is  {self.age}")mySubClass = MySubClass(110,"sy",100)
print(mySubClass.get_id())
print(mySubClass.name)
mySubClass.print_msg()

运行结果如下所示:

110
sy
id is 110, name is sy, age is  100

说明: 子类继承父类后，拥有了所有父类的属性和方法，但是只能访问公有的属性和方法；

12.日志框架

12.1 配置日志格式

log_config.py中定义日志格式、日志级别、日志文件路径等信息

import loggingdef init_log(log_filename='app.log', level=logging.INFO):# 设置日志格式log_format = logging.Formatter('%(asctime)s - %(module)s - %(levelname)s - %(message)s',datefmt='%Y-%m-%d %H:%M:%S')# 配置根日志记录器logger = logging.getLogger()logger.setLevel(level)# 文件处理器file_handler = logging.FileHandler(log_filename)file_handler.setLevel(level)file_handler.setFormatter(log_format)# 流处理器（控制台输出）console_handler = logging.StreamHandler()console_handler.setLevel(level)console_handler.setFormatter(log_format)# 为根日志记录器添加处理器logger.addHandler(file_handler)logger.addHandler(console_handler)# 返回根日志记录器实例return logger

12.2 在入口函数中引用setup_logging方法

from log_config import init_logif __name__ == "__main__":init_log()

12.3 在其他模块中直接使用logging日志对象

import loggingdef print_log():logging.info("日志信息")

打印结果如下:

2024-04-14 15:49:26 - other_module - INFO - 这是other_module.py中的日志信息

13.读写文件

python程序常需要从json和yaml、properties文件中读取数据，本章节仅读取json文件为例介绍python读取文件的方式。

从指定路径读取json文件, 返回字典类型

import json
import loggingdef read_json_file(file_path):try:data = Nonelogging.debug("Begin to read json data from file %s", file_path)with open(file_path, 'r') as file:data = json.load(file)except Exception as exception:logging.info("Exception occurs during read json data, file is %s, exception is %s", file_path, exception)finally:return dataresult = read_json_file("a.json")
logging.info("result is %s, type is %s.",result,type(result))