Python使用方式介绍

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__.py
 root.py
 --pkg1
  __init__.py 
  model1.py
    --pkg2
   __init__.py
   model2.py
            --pkg3
             __init__.py
                model3.py

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

代码如下：

#root.py
from pkg1.model1 import action1

print("root model name is " + __name__)
action1()

-------------------------------------------------------

#model1.py
import sys
from pathlib import Path

sys.path.append(str(Path(__file__).resolve().parents[0]))
from pkg2.model2 import action2

def action1():
    print("model-1 name is " + __name__)
    action2()

-------------------------------------------------------

#model2.py
import sys
from pathlib import Path

sys.path.append(str(Path(__file__).resolve().parents[0]))
from pkg3.model3 import action3


def 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 = id
        self.name = name

    def get_id(self):
        return self.__id

    def __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 = age

    def get_age(self):
        return self.age

    def 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 logging

def 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_log

if __name__ == "__main__":
    init_log()

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

import logging

def 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 logging


def read_json_file(file_path):
    try:
        data = None
        logging.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 data


result = read_json_file("a.json")
logging.info("result is %s, type is %s.",result,type(result))

运行结果如下:

DEBUG - Begin to read json data from file a.json
INFO - result is {'name': 'sy', 'id': '110'}, type is <class 'dict'>.

说明: python使用open函数与文件建立关联，可以选择’r’ 读操作，'w’写操作。案例中使用with open ... as ... 形式与java的try-with-resource相似，执行完毕后会自动关闭文件。

14.执行shell命令

python中执行shell命令是python脚本的一个重要功能，该功能依赖于python提供的subprocess模块。
将python执行shell命令的逻辑封装在utils模块下:

#utils.py文件
import logging
import subprocess


def shell_execute(cmd, need_log=True):
    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    if need_log:
        logging.debug('pid(%s) cmd = %s' % (p.pid, cmd))
        data = b''
        for c in iter(lambda: p.stdout.read(1), b''):
            if c != b'\n':
                data = data + c
            else:
                try:
                    logging.debug('pid(%s) %s' % (p.pid, data.decode('utf-8')))
                except:
                    pass
                data = b''
    p.wait()
    if need_log:
        logging.debug('pid(%s) returncode = %s' % (p.pid, p.returncode))
    return p.returncode == 0


def shell_execute_with_output(cmd, need_log=True):
    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    logging.debug('pid(%s) cmd = %s' % (p.pid, cmd))
    output = []
    data = b''
    for c in iter(lambda: p.stdout.read(1), b''):
        if c != b'\n':
            data = data + c
        else:
            if need_log:
                try:
                    logging.debug('pid(%s) %s' % (p.pid, data.decode('utf-8')))
                except:
                    pass
            output.append(data.decode('utf-8'))
            data = b''
    p.wait()
    logging.debug('pid(%s) returncode = %s' % (p.pid, p.returncode))
    return p.returncode == 0, output

上述shell_execute方法仅执行命令，无返回值；shell_execute_with_output返回一个长度为2的列表对象，第一个元素为命令是否执行成功(True表示命令执行成功)，第二个命令表示执行命令得到的结果。

使用案例:

from utils import shell_execute, shell_execute_with_output


def action():
    shell_execute("mkdir -p /test/test/test1")
    shell_execute("mkdir -p /test/test/test2")
        
    result = shell_execute_with_output("ls -al /test/test/")
    print("cmd execute: %s" % result[0])
    for each_item in result[1]:
        print(each_item)


if __name__ == "__main__":
    action()

执行结果如下:

[root@seong bin]# python application.py
cmd execute: True
总用量 0
drwxr-xr-x 4 root root 30 4月   9 09:20 .
drwxr-xr-x 3 root root 17 4月   9 09:20 ..
drwxr-xr-x 2 root root  6 4月   9 09:20 test1
drwxr-xr-x 2 root root  6 4月   9 09:20 test2