Python基础

基本数据类型

Python 中的标准数据类型主要分为两类：

不可变数据类型：这些类型的对象一旦创建，其值就不能改变。
- 数字（Number）：包括整数（int）、浮点数（float）、布尔值（bool）和复数（complex）。
- 字符串（String）：由字符组成的序列。
- 元组（Tuple）：与列表类似，但不可变，无法通过下标修改值。
可变数据类型：这些类型的对象可以在原地进行修改。
- 列表（List）：使用方括号 [] 表示的有序集合。
- 集合（Set）：使用大括号 {} 表示的无序不重复元素集。
- 字典（Dictionary）：使用大括号 {} 表示的键值对集合。

需要注意的是，可变数据类型在修改值时，其内存地址（可以使用 id() 函数查看）保持不变；而不可变数据类型在值改变时，会生成新的对象，内存地址也会发生变化。

基本数据结构

Python 提供了多种内置数据结构，常用的有列表、元组、集合和字典。

列表（List）：
- 特点：可变的有序集合，支持存储不同类型的对象。
- 常规操作：
  - 获取元素：通过下标访问，如 num[0] 获取第一个元素；通过切片获取子列表，如 num[3:5] 获取第4到第5个元素。
  - 添加元素：
    - append(value)：在列表末尾添加元素。
    - insert(index, value)：在指定位置插入元素。
    - extend([value1, value2, ...]) 或 num + [value1, value2, ...]：连接两个列表。
元组（Tuple）：
- 特点：不可变的有序集合。
- 常规操作：
  - 访问元素：通过下标获取值，但无法修改。
  - 方法：
    - index(value, [start, [stop]])：获取指定元素在元组中的位置。
    - count(value)：统计指定元素在元组中出现的次数。
集合（Set）：
- 特点：无序且不重复的元素集合。
- 常规操作：
  - 添加元素：使用 add(value) 方法。
  - 删除元素：使用 remove(value) 或 discard(value) 方法。
  - 集合运算：支持并集、交集、差集等操作。
字典（Dictionary）：
- 特点：键值对的无序集合，键必须是不可变类型，且唯一。
- 常规操作：
  - 获取值：通过键访问对应的值，如 dict[key]。
  - 添加/修改：dict[key] = value。
  - 删除元素：使用 del dict[key] 或 dict.pop(key)。

Python 编码规范

遵循良好的编码规范有助于提高代码的可读性和可维护性。以下是一些常见的 Python 编码规范：

代码编码：

1、国际惯例，文件编码和 Python 编码格式全部为 utf-8 ，例如：在 Python 代码的开头，要统一加上 # -- coding: utf-8 --。

2、Python 代码中，非 ascii 字符的字符串，请需添加u前缀

3、若出现 Python编码问题，可按照以下操作尝试解决：
java 复制代码
```
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
```
代码布局：
- 缩进：使用4个空格进行缩进，避免使用制表符（Tab）。
- 每行长度：每行代码不超过79个字符。
- 空行：
  - 函数和类定义之间使用两个空行分隔。
  - 类中的方法之间使用一个空行分隔。
命名规范：
- 变量名、函数名：使用小写字母，单词之间以下划线分隔，如 my_variable。
- 类名：使用首字母大写的单词（驼峰命名法），如 MyClass。
- 常量：使用全大写字母，单词之间以下划线分隔，如 MY_CONSTANT。

注释：

块注释：用于解释一段代码的目的或逻辑，通常位于代码之前。

yaml 复制代码

# We use a weighted dictionary search to find out where i is in
# the array.  We extrapolate position based on the largest num
# in the array and the array size and then do binary search to
# get the exact number.

if i & (i-1) == 0:        # true iff i is a power of 2

行内注释：用于解释某行代码的作用，注释应与代码之间保持至少两个空格的距离。
ini 复制代码
```
x = x + 1                 # Compensate for border
```

文档字符串（Docstring）：用于描述模块、类或函数的功能，应使用三重引号包围，并遵循特定的格式。

python 复制代码

"""A user-created :class:`Response <Response>` object.
    
Used to xxx a :class: `JsonResponse <JsonResponse>`, which is xxx

:param data: response data
:param file: response files
    
Usage::

    >>> import api
    >>> rep = api.Response(url="http://www.baidu.com")
"""

代码提交规范

每次代码提交必须有备注说明，注明本次提交做了哪些修改

commit 分类：

lua 复制代码

bugfix: -------- 线上功能 bug
sprintfix: ----- 未上线代码修改 （功能模块未上线部分bug）
minor: --------- 不重要的修改（换行，拼写错误等）
feature: ----- 新功能说明

导入顺序：

顺序：

标准库导入。
第三方库导入
项目本身

python 复制代码

YES:
import os
import sys
from subprocess import Popen, PIPE      # PEP8

NO:
import sys, os

多线程

Python 多线程概述

多线程允许程序中同时执行多个任务，其优点包括：

后台处理：长时间任务可以放到后台运行，不阻塞主线程；
提高用户体验：界面响应（如进度条显示）不被耗时任务阻塞；
任务并行：在 I/O 密集型任务（例如文件读写、网络通信）中，多线程有助于提高效率；
资源共享：线程共享进程内存，但每个线程都有自己的上下文（如指令指针、堆栈指针等）。

需要注意的是，线程之间共享数据时可能会出现同步问题（例如数据竞争），这时就需要使用锁（Lock）或队列（Queue）来协调线程操作。

线程的基本使用

Python 提供两个模块支持线程：

低级模块： thread（Python 2.x）
高级模块： threading（推荐使用，支持 Python 2 和 3）

threading 模块的常用方法

线程状态与统计
- threading.currentThread() 返回当前线程对象。
- threading.enumerate() 返回一个包含所有正在运行线程的列表（指线程启动后、结束前的线程，不包含未启动或已终止的线程）。
- threading.activeCount() 返回当前活动线程的数量，与 len(threading.enumerate()) 相同。
Thread 类方法 threading.Thread 类封装了线程对象，它主要提供以下方法：
- run() 定义线程执行的代码（线程活动）。通常重写这个方法来定义线程执行的任务。
- start() 启动线程，这会调用线程对象内部的 run() 方法。
- join([timeout]) 阻塞调用线程直到当前线程终止（正常退出或抛出异常），也可以设置超时时间。
- isAlive()（在 Python 3 中命名为 is_alive()）检查线程是否仍处于活动状态。
- getName() 返回线程名称。
- setName(name) 设置线程名称。

2.1 使用 thread 模块（Python 2.x 示例）

python 复制代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import thread
import time

# 定义线程要执行的函数
def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print "%s: %s" % (threadName, time.ctime(time.time()))

# 创建并启动两个线程
try:
    thread.start_new_thread(print_time, ("Thread-1", 2, ))
    thread.start_new_thread(print_time, ("Thread-2", 4, ))
except:
    print "Error: unable to start thread"

# 主线程保持运行
while 1:
    pass

说明： 使用 thread.start_new_thread() 启动线程，每个线程都从指定函数入口开始执行。由于是低级接口，主线程需要保持运行（例如用无限循环）以防止程序提前退出。

2.2 使用 threading 模块

示例1：继承 Thread 类创建线程

python 复制代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import threading
import time

exitFlag = 0

class MyThread(threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay

    def run(self):
        print "Starting " + self.name
        print_time(self.name, self.delay, 5)
        print "Exiting " + self.name

def print_time(threadName, delay, count):
    while count:
        if exitFlag:
            # 退出当前线程（此方法不推荐使用，可以直接 return）
            return
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        count -= 1

# 创建两个线程
thread1 = MyThread(1, "Thread-1", 1)
thread2 = MyThread(2, "Thread-2", 2)

thread1.start()
thread2.start()

print "Exiting Main Thread"

说明： 使用 threading.Thread 的子类，重写 run() 方法来定义线程执行的任务。调用 start() 方法启动线程，线程自动调用 run() 方法。

示例2：线程同步 ------ 使用 Lock

当多个线程同时访问共享数据时，需要使用锁来避免数据竞争。

python 复制代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay

    def run(self):
        print "Starting " + self.name
        # 获得锁
        threadLock.acquire()
        print_time(self.name, self.delay, 3)
        # 释放锁
        threadLock.release()

def print_time(threadName, delay, count):
    while count:
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        count -= 1

threadLock = threading.Lock()
threads = []

# 创建两个线程
thread1 = MyThread(1, "Thread-1", 1)
thread2 = MyThread(2, "Thread-2", 2)

thread1.start()
thread2.start()

threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()

print "Exiting Main Thread"

说明： 使用 threading.Lock() 对共享资源进行保护。调用 acquire() 方法获取锁，在访问共享数据后调用 release() 释放锁。这样可确保同一时刻只有一个线程在执行临界区代码。

示例3：线程安全队列 ------ 使用 Queue 模块

多线程环境下，使用 Queue 可以方便地实现线程间通信，并保证线程安全。

Queue模块中的常用方法:

Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() 实际上意味着等到队列为空，再执行别的操作

python 复制代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import Queue
import threading
import time

exitFlag = 0

class MyThread(threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q

    def run(self):
        print "Starting " + self.name
        process_data(self.name, self.q)
        print "Exiting " + self.name

def process_data(threadName, q):
    while not exitFlag:
        # 获取队列锁
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# 创建新线程
for tName in threadList:
    thread = MyThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
    pass

exitFlag = 1

# 等待所有线程完成
for t in threads:
    t.join()

print "Exiting Main Thread"

说明： 该示例中，通过 Queue.Queue 创建一个线程安全队列。线程在执行时首先获取队列锁，再检查队列是否为空，若不为空则取出数据进行处理。这样能够在多个线程之间安全地传递数据。

总结

多线程优势：可以将长时间任务放到后台处理、提升界面响应、实现任务并行（尤其适合 I/O 密集型任务）。
线程创建 ：可以使用低级 thread 模块或更推荐的 threading 模块，后者提供了更丰富的 API，如 start(), join(), isAlive(), setName(), getName() 等。
线程同步：使用 Lock 对共享资源进行保护，避免数据竞争和不一致问题。
线程通信：利用 Queue 模块实现线程间的安全数据传递，是实现生产者/消费者模式的常用方法，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。

Logging 模块

Python 的 logging 模块为应用程序和第三方模块提供了通用的日志系统。它支持多种日志输出方式（如输出到文件、HTTP、SMTP、Socket 等），并提供了多级日志记录。

日志共分为五个等级（从低到高）：

DEBUG：详细的调试信息，通常用于诊断问题；
INFO：确认程序按预期运行的信息；
WARNING：警告信息，表示程序中可能出现异常或潜在问题（例如磁盘空间不足），但程序仍能运行；
ERROR：错误信息，记录程序未能执行某个功能的情况；
CRITICAL：严重错误，通常表示程序可能无法继续运行。

默认日志级别是 WARNING，即只有 WARNING、ERROR 和 CRITICAL 级别的日志会被记录。

常用日志方法

logging 模块对应这五个等级分别提供了以下方法：

logging.debug(...)
logging.info(...)
logging.warning(...)
logging.error(...)
logging.critical(...)

示例代码

下面的示例代码展示了如何配置 logging 模块并记录日志到文件：

python 复制代码

import logging

# 配置日志输出到文件 recommender.log
logging.basicConfig(
    filename="recommender.log", 
    format='%(asctime)s:%(levelname)s: %(message)s', 
    level=logging.INFO  # 这里设置日志级别为 INFO，低于 INFO 的 DEBUG 日志将不会记录
)

# 示例变量
count = 123

# 记录信息
logging.info("当前 count 的值：%d", count)
logging.info('hbase connection closed')

# 模拟捕获异常并记录错误日志
try:
    raise Exception("配置加载失败")
except Exception as e:
    logging.error('Load config, %s', str(e))

执行上述代码后，会在文件 recommender.log 中记录格式化后的日志信息，例如：

ruby 复制代码

2020-01-01 12:00:00,123:INFO: 当前 count 的值：123
2020-01-01 12:00:00,456:INFO: hbase connection closed
2020-01-01 12:00:00,789:ERROR: Load config, 配置加载失败

Jieba模块

jieba 基于Python的中文分词工具,安装使用非常方便,直接pip即可,2/3都可以,功能强悍特点

支持三种分词模式：

精确模式：试图将句子最精确地切分，适合文本分析。
全模式：扫描出句子中所有可能的词语，速度快，但不能解决歧义。
搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适用于搜索引擎分词。

此外，jieba 还支持关键词提取（jieba.analyse）和词性标注（jieba.posseg）等功能。

python 复制代码

import jieba.posseg as pseg
words = pseg.cut(text)

import jieba

seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
print("Full Mode: " + "/ ".join(seg_list))  # 全模式

seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
print("Default Mode: " + "/ ".join(seg_list))  # 精确模式

seg_list = jieba.cut("他来到了网易杭研大厦")  # 默认是精确模式
print(", ".join(seg_list))

seg_list = jieba
    .cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造") 
    # 搜索引擎模式
print(", ".join(seg_list))

`re` 模块（正则表达式模块）

功能概述

正则表达式是用于描述字符串模式的工具，Python 的 re 模块提供了 Perl 风格的正则表达式模式，可用于字符串的匹配、查找、替换等操作。

主要函数及用法

re.compile(pattern[, flags])：
- 作用：将正则表达式模式字符串编译成一个正则表达式对象（Pattern 对象），这样可以提高多次使用该模式时的效率，并且该对象有一系列方法用于匹配和替换。
- 示例：

python 复制代码

import re

def remove_html_tags(data):
    p = re.compile(r'<.*?>')
    return p.sub('', data)

这里 re.compile(r'<.*?>') 编译了一个用于匹配 HTML 标签的正则表达式，p.sub('', data) 则将 data 字符串中所有匹配到的 HTML 标签替换为空字符串。

`os` 模块（操作系统接口模块）

功能概述

os 模块提供了与操作系统进行交互的功能，使 Python 程序能够编写与平台无关的代码。

常用方法

os.name ：返回当前操作系统的名称，如 'nt' 表示 Windows，'posix' 表示 Linux/Unix。
os.getcwd() ：获取当前 Python 脚本的工作目录。
os.listdir(path='.') ：返回指定目录下的所有文件和目录名。
os.remove(path) ：删除指定路径的文件。
os.system(command) ：在操作系统的 shell 中执行指定的命令。
os.sep ：返回当前操作系统使用的路径分隔符，如 Windows 是 '\'，Linux 是 '/'。
os.linesep ：返回当前操作系统使用的行终止符，如 Windows 是 '\r\n'，Linux 是 '\n'。
os.path.split(path) ：将路径拆分为目录名和文件名两部分。
os.path.isfile(path) ：判断指定路径是否为文件。
os.path.isdir(path) ：判断指定路径是否为目录。
os.path.exists(path) ：判断指定路径是否存在。
os.path.abspath(path) ：返回指定路径的绝对路径。
os.path.normpath(path) ：规范路径字符串的形式。
os.path.getsize(path) ：返回文件的大小，如果是目录则返回 0。
os.path.splitext(path) ：分离文件名和扩展名。
os.path.join(path1, path2, ...) ：连接多个路径部分。
os.path.basename(path) ：返回路径中的文件名部分。
os.path.dirname(path) ：返回路径中的目录名部分。

`decimal` 模块

decimal 模块提供了十进制浮点运算支持，主要用于定点数和浮点数的小数运算。它实现的定点和浮点算术运算符采用的是大多数人熟悉的运算模型，而非程序员熟悉的计算机硬件实现的 IEEE 浮点数运算。在 Python 2.4 及以后的版本中均可使用该模块。

核心类：Decimal：小数值通常表示为 Decimal 类的实例。可以通过构造函数创建 Decimal 对象，构造函数接受整数或字符串作为参数。由于浮点数本身存在精度问题，不能直接将浮点数据作为参数传递给 Decimal 构造函数。

创建 Decimal 对象

使用整数：

scss 复制代码

from decimal import Decimal
d1 = Decimal(10)
print(d1)  # 输出: 10

使用字符串：

ini 复制代码

d2 = Decimal('3.14')
print(d2)  # 输出: 3.14

避免使用浮点数直接创建 ：由于浮点数存在精度问题，直接使用浮点数创建 Decimal 对象会导致结果不准确。例如：

scss 复制代码

d3 = Decimal(1.1)
print(d3)  # 输出: 1.100000000000000088817841970012523233890533447265625

从浮点数转换为 Decimal 类型

可以使用 Decimal.from_float() 类方法将浮点数转换为精确的小数表示。

scss 复制代码

from decimal import Decimal
result = Decimal.from_float(12.222)
print(result)  
# 输出: Decimal('12.2219999999999995310417943983338773250579833984375')

设定有效数字

通过 getcontext().prec 可以设定运算结果的有效数字位数。

scss 复制代码

from decimal import Decimal, getcontext
getcontext().prec = 6
result = Decimal(1) / Decimal(7)
print(result)  # 输出: Decimal('0.142857')

四舍五入，保留指定小数位数

使用 quantize() 方法可以对 Decimal 对象进行四舍五入，保留指定的小数位数。

sql 复制代码

from decimal import Decimal
result = Decimal('50.5679').quantize(Decimal('0.00'))
print(result)  # 输出: Decimal('50.57')

将 Decimal 结果转换为字符串

可以直接使用 str() 函数将 Decimal 对象转换为字符串。

scss 复制代码

from decimal import Decimal
str_result = str(Decimal('3.40').quantize(Decimal('0.0')))
print(str_result)  # 输出: '3.40'

`sys` 模块

sys 模块提供了一系列有关 Python 运行环境的变量和函数，可用于获取命令行参数、管理模块搜索路径、控制程序退出、处理编码、操作标准输入输出流以及获取系统平台信息等。

sys.argv

功能：实现从程序外部向程序传递参数，是一个包含命令行参数的字符串列表，脚本的名称总是列表的第一个参数。
使用示例：

python 复制代码

import sys

# 打印脚本名
print(sys.argv[0])

# 打印第一个参数
if len(sys.argv) > 1:
    print(sys.argv[1])

# 打印从第一个参数开始的所有参数
print(sys.argv[1:])

# 打印第一个到第三个参数（不包含第三个）
print(sys.argv[1:3])

# 按步长为 2 打印第一个到第五个参数
print(sys.argv[1:5:2])

# 打印最后一个参数
if sys.argv:
    print(sys.argv[-1])

# 反转打印所有参数
print(sys.argv[::-1])

sys.path

功能：包含输入模块的目录名列表，是获取指定模块搜索路径的字符串集合。可以将写好的模块放在 sys.path 中的某个路径下，在程序中使用 import 语句就能正确找到该模块，也可以自定义添加模块路径。
使用示例：

python 复制代码

import sys

# 打印当前模块搜索路径
print(sys.path)

# 自定义添加模块路径
sys.path.append("自定义模块路径")

sys.exit([arg])

功能：用于程序中间的退出，arg = 0 为正常退出。一般情况下程序执行到主程序末尾，解释器会自动退出，但如果需要中途退出程序，可以调用该函数，它带有一个可选的整数参数返回给调用它的程序，表示可以在主程序中捕获对 sys.exit 的调用（0 是正常退出，其他为异常），也可以使用字符串参数表示错误不成功的报错信息。
使用示例：

python 复制代码

import sys

try:
    # 模拟某种条件
    if True:
        sys.exit(0)  # 正常退出
    else:
        sys.exit("出错信息")  # 异常退出并输出错误信息
except SystemExit as e:
    if isinstance(e.code, int):
        print(f"程序以状态码 {e.code} 退出")
    else:
        print(f"程序退出，错误信息: {e.code}")

sys.modules

功能：是一个全局字典，Python 启动后就加载在内存中。每当导入新的模块，sys.modules 会自动记录该模块。当第二次再导入该模块时，Python 会直接到字典中查找，从而加快程序运行的速度，它拥有字典所拥有的一切方法。
使用示例：

python 复制代码

import sys
import math

# 查看 sys.modules 中是否已记录 math 模块
if 'math' in sys.modules:
    print("math 模块已在 sys.modules 中记录")

# 打印 sys.modules 中 math 模块的信息
print(sys.modules['math'])

sys.getdefaultencoding() / sys.setdefaultencoding() / sys.getfilesystemencoding()

sys.getdefaultencoding() ：获取系统当前编码，一般默认为 ascii。
sys.setdefaultencoding() ：设置系统默认编码，在执行 dir(sys) 时不会看到这个方法，在解释器中执行不通过，可以先执行 reload(sys)（Python 2 中），再执行 setdefaultencoding('utf8')，此时将系统默认编码设置为 utf - 8。在 Python 3 中，sys.setdefaultencoding() 已被移除，编码设置方式有所不同。
sys.getfilesystemencoding() ：获取文件系统使用编码方式，Windows 下返回 'mbcs'，mac 下返回 'utf - 8'。
使用示例（Python 2） ：

python 复制代码

import sys

# 获取系统当前编码
print(sys.getdefaultencoding())

# 获取文件系统使用编码方式
print(sys.getfilesystemencoding())

# Python 2 中设置系统默认编码
# reload(sys)
# sys.setdefaultencoding('utf8')

sys.stdin, sys.stdout, sys.stderr

功能：stdin、stdout 和 stderr 变量包含与标准 I/O 流对应的流对象。如果需要更好地控制输出，而 print 不能满足需求时可以使用它们，也可以替换它们，从而重定向输出和输入到其他设备，或者以非标准的方式处理它们。
使用示例：

python 复制代码

import sys

# 从标准输入读取一行数据
data = sys.stdin.readline()
print(f"你输入的是: {data}")

# 重定向标准输出到文件
original_stdout = sys.stdout
with open('output.txt', 'w') as f:
    sys.stdout = f
    print("这行输出会被写入到 output.txt 文件中")
sys.stdout = original_stdout

sys.platform

功能：获取当前系统平台，如 win32、Linux 等。
使用示例：

python 复制代码

import sys

print(f"当前系统平台是: {sys.platform}")

sys 模块为 Python 程序与运行环境之间的交互提供了丰富的功能。sys.argv 方便从命令行传递参数；sys.path 可管理模块搜索路径；sys.exit 能控制程序的退出；sys.modules 有助于提高模块导入的效率；编码相关函数可处理系统和文件系统的编码；标准 I/O 流对象可实现输入输出的灵活控制；sys.platform 能获取系统平台信息。通过合理使用这些变量和函数，可以编写出更健壮、更灵活的 Python 程序。

JSON 模块

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写。在 Python 中，通过内置的 json 模块即可完成 JSON 的编码（将 Python 对象转换为 JSON 字符串）和解码（将 JSON 字符串转换为 Python 对象）的操作。

1.1 json.dumps

功能： 将 Python 对象编码成 JSON 格式的字符串。

基本语法：

ini 复制代码

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
           allow_nan=True, cls=None, indent=None, separators=None,
           encoding="utf-8", default=None, sort_keys=False, **kw)

常用参数说明：

ensure_ascii：默认 True，会将非 ASCII 字符转义。如果设置为 False，则会输出 Unicode 字符。
indent：指定缩进空格数，用于格式化输出（如设置为 4 则输出格式化的 JSON）。
separators ：指定分隔符，通常传入 (',', ': ') 使输出更紧凑或更易读。
sort_keys：如果为 True，则会根据键对字典进行排序。

示例代码：

ini 复制代码

import json

data = [{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}]
# 基本用法
json_str = json.dumps(data)
print(json_str)
# 输出示例（字典键顺序可能不同）：
# [{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

# 格式化输出
formatted_str = json.dumps({'a': 'Runoob', 'b': 7},
                           sort_keys=True, indent=4,
                           separators=(',', ': '))
print(formatted_str)
# 输出：
# {
#     "a": "Runoob",
#     "b": 7
# }

1.2 json.loads

功能： 将 JSON 格式的字符串解码成 Python 对象。

基本语法：

css 复制代码

json.loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
           parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

示例代码：

css 复制代码

import json

json_data = '{"a":1,"b":2,"c":3,"d":4,"e":5}'
data = json.loads(json_data)
print(data)
# 输出示例：
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

1.3 Python 原始类型与 JSON 类型的对照

Python 类型	JSON 类型
dict	object
list, tuple	array
str, unicode	string
int, long, float	number
True	true
False	false
None	null

2. 第三方库 demjson

demjson 是一个第三方 JSON 处理库，不仅可以编码和解码 JSON 数据，还提供了 JSONLint 风格的格式化和校验功能。

2.1 demjson.encode

功能： 将 Python 对象编码为 JSON 格式字符串。

基本语法：

ini 复制代码

demjson.encode(obj, nest_level=0)

示例代码：

scss 复制代码

#!/usr/bin/python
import demjson

data = [{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}]
json_str = demjson.encode(data)
print(json_str)
# 输出：
# [{"a":1,"b":2,"c":3,"d":4,"e":5}]

2.2 demjson.decode

功能： 将 JSON 格式字符串解码为 Python 对象。

基本语法：

scss 复制代码

demjson.decode(txt)

示例代码：

css 复制代码

#!/usr/bin/python
import demjson

json_str = '{"a":1,"b":2,"c":3,"d":4,"e":5}'
data = demjson.decode(json_str)
print(data)
# 输出示例（键顺序可能不同）：
# {u'a': 1, u'b': 2, u'c': 3, u'd': 4, u'e': 5}

总结

内置 json 模块 提供了 json.dumps 和 json.loads 两个基本函数，能够满足大多数数据交换需求，且内置模块性能稳定，易于使用。
demjson 为第三方库，除了基本的 JSON 编解码功能外，还支持格式化和校验，适用于对 JSON 格式要求更严格的场景。

日常使用

数据分析库

NumPy：用于科学计算的基础包，提供高性能的多维数组对象和相关操作。
Pandas：构建在NumPy之上的数据分析库，提供了DataFrame和Series数据结构，方便数据清洗、处理和分析。
Matplotlib：用于创建静态、动画和交互式可视化的绘图库，常与NumPy和Pandas结合使用。
Seaborn：基于Matplotlib的高级可视化库，提供更美观和简洁的绘图接口，适用于统计图表的绘制。
SciPy：构建在NumPy之上的科学计算库，提供如数值积分、优化、信号处理等功能。
Scikit-learn：机器学习库，提供各种监督和非监督学习算法，以及数据预处理、模型选择和评估等工具。
Keras：高级神经网络API，能够运行在TensorFlow、Theano等之上，简化深度学习模型的构建和训练。

javascript 复制代码

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from sklearn.model_selection import train_test_split
from keras.models import Sequential

NumPy科学计算包

NumPy是Python中用于科学计算的基础包，提供了高效的多维数组对象ndarray，以及丰富的数学函数库。

一维数组处理：

python 复制代码

import numpy as np

# 定义一维数组
a = np.array([2, 0, 1, 5, 8, 3])
print('原始数据:', a)

# 输出最小值、最大值及形状
print('最小值:', a.min())
print('最大值:', a.max())
print('形状:', a.shape)

# 数据切片
print('切片操作:')
print(a[:-2])  # 输出除最后两个元素外的所有元素
print(a[-2:])  # 输出最后两个元素
print(a[:1])   # 输出第一个元素

# 排序
a.sort()
print('排序后:', a)

二维数组处理：

php 复制代码

# 定义二维数组
c = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])

# 获取值
print('形状:', c.shape)
print('获取值:', c[1][0])  # 获取第二行第一列的值
print('获取某行:', c[1][:])  # 获取第二行的所有值
print('获取某行并切片:', c[0][:-1])  # 获取第一行除最后一个元素外的所有值
print('获取第3列:', c[:, 2])  # 获取第三列的所有值

# 调用sin函数
print(np.sin(np.pi / 6))

# 范围定义
print(np.arange(0, 4))

Pandas数据分析包

Pandas是Python中用于数据分析的强大工具，提供了快速便捷的DataFrame和Series数据结构。

读写文件：

ini 复制代码

import pandas as pd

# 从Excel文件读取数据
data = pd.read_excel('data.xlsx', header=None)
print(data)

# 写入Excel文件
data.to_excel('output.xlsx', sheet_name='Sheet1')

# 从CSV文件读取数据
data = pd.read_csv('data.csv')
print(data)

# 写入CSV文件
data.to_csv('output.csv', index=False)

Series的创建与操作：

python 复制代码

from pandas import Series

# 通过列表创建Series
a = Series([4, 7, -5, 3])
print('创建Series:')
print(a)

# 创建带有索引的Series
b = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
print('创建带有索引的Series:')
print(b)

# 通过字典创建Series
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
c = Series(sdata)
print('通过字典创建Series:')
print(c)

Matplotlib画图包

Matplotlib是Python中最常用的绘图库，适用于创建各种静态、动态和交互式可视化图表。

绘制柱状图：

ini 复制代码

import numpy as np
import matplotlib.pyplot as plt

# 数据
N = 3
ind = np.arange(N)
width = 0.35
values = [25, 32, 34]

# 绘制柱状图
plt.bar(ind, values, width, color='r', label='Values')
plt.xlabel('Category')
plt.ylabel('Values')
plt.title('Sample Bar Chart')
plt.xticks(ind + width / 2, ('A', 'B', 'C'))
plt.legend()
plt.show()

绘制饼图：

ini 复制代码

import matplotlib.pyplot as plt

# 数据
labels = ['A', 'B', 'C']
sizes = [45, 30, 25]
explode = (0, 0, 0.1)

# 绘制饼图
plt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)
plt.title('Sample Pie Chart')
plt.show()

Gensim模块（自然语言处理库）

基本概念回顾

语料 (Corpus) ：即所有文档的集合。每篇文档经过预处理后转为词袋（稀疏向量）表示。
向量 (Vector) & 稀疏向量：文本特征向量表示，通常只存储非零的 (word_id, count) 元组。
模型 (Model) ：如 TF-IDF、LSI、LDA 等，它们将文本从一种向量表示转换为另一种表示（例如主题向量）。

功能概述

gensim 是一个用于主题建模、文档索引和相似性检索的 Python 库，提供了高效的自然语言处理工具。

常用子模块

corpora：用于处理文本语料库，提供了各种语料库的表示和存储方式。
models：包含了各种机器学习模型，如词袋模型、TF-IDF 模型、LDA 模型等。
similarities：用于计算文本之间的相似度。

在 gensim 中，这些步骤可以实现文档语义分析和相似度计算，从而在文本检索、聚类和主题发现等任务中发挥重要作用。

这段代码的主要目标是：

预处理文本数据：将原始文档（通常为分词后的词列表）转换为 gensim 所支持的稀疏向量表示（词袋模型）。
构建模型：首先构建 TF-IDF 模型以加权原始词袋向量，再通过主题模型（默认使用 LSI 模型）将向量转换到低维主题空间。
生成相似度索引 ：利用 gensim 提供的 similarities.MatrixSimilarity 生成文档相似度矩阵，后续可以用于信息检索或文档聚类等任务。

代码解析

1 预处理部分

ini 复制代码

dictionary = corpora.Dictionary(documents)
corpus = [dictionary.doc2bow(doc) for doc in documents]

Dictionary ：通过 corpora.Dictionary(documents) 对所有文档中出现的词构建字典，每个词被映射为一个唯一的整数 ID。
Corpus ：利用 doc2bow 方法，将每个文档转换为"词袋"（Bag-of-Words）表示，即一个稀疏向量，元素为 (word_id, count) 的元组。

2 模型训练部分

ini 复制代码

python复制编辑tfidf = models.tfidfmodel.TfidfModel(corpus=corpus)
topic_model = model(tfidf[corpus], id2word=dictionary, num_topics=10)

TF-IDF 模型 ：models.tfidfmodel.TfidfModel(corpus=corpus) 对词袋向量进行加权，提升区分度。
主题模型：使用 model参数（默认为 models.LsiModel）对加权后的向量进行训练，此处训练出 10 个主题。
- 注意：传入的 model 参数可以替换为其它主题模型（如 LDA、HDP 等），只需保证输入数据与字典保持一致即可。

2 输出与相似度计算

ini 复制代码

for topic in topic_model.print_topics():
    logging.info(topic)
return similarities.MatrixSimilarity(topic_model[tfidf[corpus]],
        num_best=max_posts + 1)

打印主题 ：通过 print_topics() 方法输出每个主题的关键词分布，便于调试和理解模型。
相似度矩阵 ：使用 similarities.MatrixSimilarity 将所有文档转换到主题向量空间后生成一个相似度索引。参数 num_best 设置返回相似度最高的文档个数（加 1 是为了包含查询文档本身）。

使用示例完整代码

ini 复制代码

from gensim import corpora, models, similarities
import logging

def generate_similarity_index(documents, max_posts, model=models.LsiModel):
    # 生成词典和词袋表示
    dictionary = corpora.Dictionary(documents)
    corpus = [dictionary.doc2bow(doc) for doc in documents]
    
    # 训练 TF-IDF 模型
    tfidf = models.tfidfmodel.TfidfModel(corpus=corpus)
    
    # 训练主题模型（默认使用 LSI 模型），生成 10 个主题
    topic_model = model(tfidf[corpus], id2word=dictionary, num_topics=10)
    
    # 输出主题内容（调试用）
    for topic in topic_model.print_topics():
        logging.info(topic)
    
    # 返回相似度矩阵索引对象，num_best 为返回的最相似文档数量
    return similarities.MatrixSimilarity(topic_model[tfidf[corpus]],
                                         num_best=max_posts + 1)

`argparse` 模块（命令行参数解析模块）

功能概述

argparse 是 Python 标准库中用于处理命令行参数的模块，可帮助开发者编写可读性好、易于使用的命令行程序。

使用步骤

导入模块 ：import argparse
创建解析对象 ：parser = argparse.ArgumentParser()
添加命令行参数和选项 ：parser.add_argument()
解析命令行参数 ：args = parser.parse_args()

示例

ini 复制代码

import argparse

parser = argparse.ArgumentParser(description='Hbase rowkey')
parser.add_argument('--rowkey', type=str, help='Hbase rowkey string')
args = parser.parse_args()

`datetime` 模块（日期和时间处理模块）

功能概述

datetime 模块是 Python 处理日期和时间的标准库，提供了日期、时间的创建、转换和计算等功能。

常用方法

datetime.now() ：获取当前日期和时间。
datetime.strptime(date_string, format) ：将字符串转换为 datetime 对象，需要指定日期和时间的格式化字符串。
datetime.strftime(format) ：将 datetime 对象格式化为字符串，同样需要指定格式化字符串。

示例

python 复制代码

from datetime import datetime

# 获取当前日期和时间
now = datetime.now()
print(now)

# 字符串转换为 datetime 对象
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday)

# datetime 对象转换为字符串
print(now.strftime('%a, %b %d %H:%M'))

itertools 模块

1. 笛卡尔积：itertools.product(*iterables, repeat=1)

product 函数返回输入可迭代对象的笛卡尔积，相当于嵌套的循环。如果设置 repeat 参数，它会将输入重复指定次数。

bash 复制代码

import itertools

# 示例1：两个字符串的笛卡尔积
for item in itertools.product('AB', '12'):
    print(''.join(item), end=' ')
# 输出: A1 A2 B1 B2

# 示例2：自身的笛卡尔积，重复2次
for item in itertools.product('AB', repeat=2):
    print(''.join(item), end=' ')
# 输出: AA AB BA BB

2. 排列：itertools.permutations(iterable, r=None)

permutations 函数返回输入可迭代对象中元素的所有长度为 r 的排列，默认情况下，r 为可迭代对象的长度。

bash 复制代码

import itertools

# 示例：长度为2的排列
for item in itertools.permutations('ABC', 2):
    print(''.join(item), end=' ')
# 输出: AB AC BA BC CA CB

3. 组合：itertools.combinations(iterable, r)

combinations 函数返回输入可迭代对象中元素的所有长度为 r 的组合，组合中的元素按输入顺序排序，不包含重复元素。

bash 复制代码

import itertools

# 示例：长度为2的组合
for item in itertools.combinations('ABC', 2):
    print(''.join(item), end=' ')
# 输出: AB AC BC

4. 组合（包含自身重复）：itertools.combinations_with_replacement(iterable, r)

combinations_with_replacement 函数返回输入可迭代对象中元素的所有长度为 r 的组合，允许同一元素在组合中出现多次。

bash 复制代码

import itertools

# 示例：长度为2的组合，包含自身重复
for item in itertools.combinations_with_replacement('ABC', 2):
    print(''.join(item), end=' ')
# 输出: AA AB AC BB BC CC

5. 生成列表的所有非空子集

要生成列表的所有非空子集，可以使用 combinations 函数，并遍历所有可能的长度。

scss 复制代码

import itertools

list1 = ['version', 'last_ver_day', 'qid']
all_combinations = []
for r in range(1, len(list1) + 1):
    combinations_object = itertools.combinations(list1, r)
    all_combinations.extend(combinations_object)

print(all_combinations)
# 输出: [('version',), ('last_ver_day',), ('qid',), ('version', 'last_ver_day'), ('version', 'qid'), ('last_ver_day', 'qid'), ('version', 'last_ver_day', 'qid')]

代码换行

1. 使用反斜杠（``）

在需要换行的地方添加反斜杠，表示当前行未结束，下一行是其延续。

ini 复制代码

a = 1
b = 2
c = a + \
    b
print(c)  # 输出：3

需要注意的是，反斜杠后面不能有空格或其他字符，否则会导致语法错误。

2. 使用括号

将表达式放在括号内，Python 会自动将括号内的多行内容视为一个整体，无需使用反斜杠。

ini 复制代码

result = (1 + 2 + 3 +
          4 + 5 + 6)
print(result)  # 输出：21

这种方法适用于圆括号 ()、方括号 [] 和花括号 {}，常用于函数参数、列表、字典等。

3. 使用三引号（''' 或 """）

对于多行字符串，可以使用三引号将字符串括起来。

ini 复制代码

long_string = """这是一个
包含多行的
字符串。"""
print(long_string)

输出：

复制代码

这是一个
包含多行的
字符串。

三引号内的字符串会保留换行符和空白符。

4. 使用隐式行连接

当一对括号、方括号或花括号内的内容未结束时，Python 会自动将下一行视为当前行的延续。

scss 复制代码

numbers = [    1, 2, 3,    4, 5, 6]
print(numbers)  # 输出：[1, 2, 3, 4, 5, 6]

这种方法无需使用反斜杠，代码更为简洁。

Json数据转换为Python DataFrame

1. 使用 pd.read_json()

对于结构相对简单的 JSON 数据，可以直接使用 pd.read_json() 函数将其读取为 DataFrame。

makefile 复制代码

import pandas as pd

# JSON 数据字符串
json_data = '''
[
    {"Name": "Alice", "Age": 25, "City": "New York"},
    {"Name": "Bob", "Age": 30, "City": "Los Angeles"},
    {"Name": "Charlie", "Age": 35, "City": "Chicago"}
]
'''

# 将 JSON 数据读取为 DataFrame
df = pd.read_json(json_data)
print(df)

输出：

markdown 复制代码

     Name  Age           City
0    Alice   25       New York
1      Bob   30    Los Angeles
2  Charlie   35        Chicago

pd.read_json() 适用于扁平化的 JSON 数据，对于嵌套结构的数据，需要使用其他方法。

2. 使用 pd.json_normalize()

对于嵌套的 JSON 数据，pd.json_normalize() 函数可以将其展平成表格结构。

arduino 复制代码

import pandas as pd
import json

# 嵌套的 JSON 数据
json_data = '''
{
    "school_name": "ABC primary school",
    "class": "Year 1",
    "students": [
        {"id": "A001", "name": "Tom", "math": 60, "physics": 66, "chemistry": 61},
        {"id": "A002", "name": "James", "math": 89, "physics": 76, "chemistry": 51},
        {"id": "A003", "name": "Jenny", "math": 79, "physics": 90, "chemistry": 78}
    ]
}
'''

# 将 JSON 数据加载为字典
data = json.loads(json_data)

# 使用 json_normalize 展平嵌套的 JSON 数据
df = pd.json_normalize(data, record_path=['students'], meta=['school_name', 'class'])
print(df)

输出：

sql 复制代码

   id   name  math  physics  chemistry       school_name   class
0  A001    Tom    60       66         61  ABC primary school  Year 1
1  A002  James    89       76         51  ABC primary school  Year 1
2  A003  Jenny    79       90         78  ABC primary school  Year 1

在上述示例中，record_path 参数指定了需要展平的嵌套列表路径，meta 参数用于保留顶层的元数据。

根据 JSON 数据的结构，选择适当的方法将其转换为 Pandas DataFrame，以方便后续的数据分析和处理。

字符串列表转换为整数列表

1. 使用列表推导式

列表推导式提供了一种简洁明了的方式来遍历列表，并对每个元素应用转换操作。

ini 复制代码

# 原始字符串列表
str_list = ['22', '44', '66', '88']

# 使用列表推导式将字符串转换为整数
int_list = [int(x) for x in str_list]
print(int_list)  # 输出: [22, 44, 66, 88]

2. 使用 map() 函数

map() 函数可以将指定的函数应用于可迭代对象的每个元素。在 Python 2 中，map() 返回一个列表；而在 Python 3 中，map() 返回一个迭代器，因此需要使用 list() 将其转换为列表。

ini 复制代码

# 原始字符串列表
str_list = ['22', '44', '66', '88']

# 使用 map() 函数将字符串转换为整数
int_list = list(map(int, str_list))

print(int_list)  # 输出: [22, 44, 66, 88]

Python连接

1. 使用Python连接Elasticsearch：

首先，安装elasticsearch库：

复制代码

pip install elasticsearch

然后，使用以下代码连接Elasticsearch并执行基本操作：

ini 复制代码

from datetime import datetime
from elasticsearch import Elasticsearch

# 连接到Elasticsearch，默认连接到localhost:9200
es = Elasticsearch()

# 创建索引（如果不存在）
index_name = "my-index"
if not es.indices.exists(index=index_name):
    es.indices.create(index=index_name)

# 插入数据
doc = {
    "any": "data",
    "timestamp": datetime.now()
}
es.index(index=index_name, doc_type="_doc", id=1, body=doc)

# 查询数据
response = es.get(index=index_name, doc_type="_doc", id=1)
print(response['_source'])

2. 使用Python连接MySQL：

首先，安装pymysql库：

复制代码

pip install pymysql

然后，使用以下代码连接MySQL并执行基本操作：

python 复制代码

import pymysql

# 连接到MySQL数据库
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database'
)

try:
    with connection.cursor() as cursor:
        # 创建表
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS users (
                id INT AUTO_INCREMENT PRIMARY KEY,
                name VARCHAR(255),
                age INT
            )
        """)

        # 插入数据
        cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ('Alice', 30))
        connection.commit()

        # 查询数据
        cursor.execute("SELECT * FROM users")
        result = cursor.fetchall()
        for row in result:
            print(row)
finally:
    connection.close()

3. 使用Python连接HBase：

首先，安装happybase库：

复制代码

pip install happybase

然后，使用以下代码连接HBase并执行基本操作：

python 复制代码

import happybase

# 连接到HBase
connection = happybase.Connection('localhost')
connection.open()

# 创建表（如果不存在）
table_name = 'my_table'
if table_name not in connection.tables():
    connection.create_table(
        table_name,
        {'cf': dict()}
    )

# 获取表
table = connection.table(table_name)

# 插入数据
table.put(b'row1', {b'cf:name': b'Alice', b'cf:age': b'30'})

# 查询数据
for key, data in table.scan():
    print(f"Row key: {key.decode('utf-8')}")
    for column, value in data.items():
        print(f"  {column.decode('utf-8')}: {value.decode('utf-8')}")

connection.close()

4. 使用Python连接ActiveMQ：

首先，安装stomp.py库：

复制代码

pip install stomp.py

然后，使用以下代码连接ActiveMQ并发送/接收消息：

python 复制代码

import time
import stomp

class MyListener(stomp.ConnectionListener):
    def on_error(self, headers, message):
        print(f"Received an error: {message}")

    def on_message(self, headers, message):
        print(f"Received a message: {message}")

# 连接到ActiveMQ
conn = stomp.Connection([('localhost', 61613)])
conn.set_listener('', MyListener())
conn.start()
conn.connect('admin', 'admin', wait=True)

# 订阅队列
conn.subscribe(destination='/queue/test', id=1, ack='auto')

# 发送消息
conn.send(body='Hello, ActiveMQ!', destination='/queue/test')

# 等待消息
time.sleep(2)

# 断开连接
conn.disconnect()

简单爬虫

urllib

python 复制代码

#coding:utf-8
import urllib
import re
import requests
import sys
reload(sys)
sys.setdefaultencoding('utf8')

避免中文乱码，同时中文在集合中也容易出现乱码，需要循环打印
# link = "http://www.sohu.com/"
# headers = {'User-Agent' : 'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'}
# r = requests.get(link, headers= headers)
# html = r.text
# title_list = re.findall('href=".*?".<strong>(.*?)</strong>',html)
# print (title_list)

for i in range(10):
    # url = "https://www.qidian.com/mm/all"
    url = "https://www.qidian.com/mm/all?orderId=&style=1&pageSize=20&siteid=0&pubflag=0&hiddenField=0&page="+str(i)
url比较规则可以直接爬多个页面
    print(url)
    page = urllib.urlopen(url)#打开网页
    htmlcode = page.read()#读取页面源码
    # print htmlcode#在控制台输出
查找所需标签
    title = re.findall('<h4><a href=".*?".(.*?)</a></h4>',htmlcode)
    for t in  title:
 过滤不需要的标签
        string = re.sub(u'[a-zA-Z0-9'「!:："#$%&'()*+,-./:;<=>?@，。?★、...【】《》？""''！[\]^_`{|}~]+', "".decode("utf8"),t)
        print (string.strip())

日常问题

"Java gateway process exited" 异常

错误信息 Exception: Java gateway process exited before sending its port number

1. JDK 路径问题

在 Windows 系统中，路径包含空格或特殊符号有时会导致程序无法正确识别路径，从而引发各种问题。就像你提到的，将 JDK 从 C:\Program Files\Java 重新安装到 C:\Java 是一种可行的解决办法，因为新路径不包含空格。

2. 设置环境变量

在使用 PySpark 时，需要正确设置相关的环境变量，例如 SPARK_HOME。你在代码前加入的以下代码就是在设置 SPARK_HOME 环境变量：

lua 复制代码

import os
os.environ['SPARK_HOME'] = "D:\spark-2.2.0-bin-hadoop2.7\spark-2.2.0-bin-hadoop2.7"

不过，这里有一个小问题，在 Python 字符串中，反斜杠 `` 是转义字符，为了避免转义问题，你应该使用原始字符串或者对反斜杠进行转义，修改后的代码如下：

python 复制代码

import os
# 使用原始字符串
os.environ['SPARK_HOME'] = r"D:\spark-2.2.0-bin-hadoop2.7\spark-2.2.0-bin-hadoop2.7"
# 或者对反斜杠进行转义
# os.environ['SPARK_HOME'] = "D:\spark-2.2.0-bin-hadoop2.7\spark-2.2.0-bin-hadoop2.7"

ValueError: Input contains NaN处理

问题描述

在使用 Pandas 处理数据时，出现 ValueError: Input contains NaN, infinity or a value too large for dtype('float64') 错误。此错误表明输入数据里包含缺失值（NaN）、无穷值（infinity）或者对于 float64 数据类型而言过大的值。

问题分析

该错误通常在对数据进行数值计算、机器学习模型训练等操作时出现，因为这些操作往往要求输入数据是有效的数值类型，而 NaN、无穷值或过大的值会干扰计算过程，导致程序抛出异常。

解决步骤

检查数据中的缺失值

代码示例：

python 复制代码

import pandas as pd
import numpy as np

# 读取数据
data_test = pd.read_csv('test.csv')

# 检查数据中是否有缺失值
print(np.isnan(data_test).any())

结果解读：
- 若输出为 False，表示对应特征的特征值中无缺失值。
- 若输出为 True，则表示存在缺失值。

处理缺失值

删除有缺失值的行：
- 代码示例：

ini 复制代码

# 假设 train 是你的数据 DataFrame
train.dropna(inplace=True)

说明：dropna() 方法会删除包含任何缺失值的行，inplace=True 表示直接在原数据上进行修改。之后可以再次使用 np.isnan(train).any() 检查数据中是否还有缺失值。
填充缺失值：
- 代码示例：

bash 复制代码

# 假设 train 是你的数据 DataFrame
train.fillna('100')

说明：fillna() 方法用于填充缺失值，这里将缺失值填充为字符串 '100'。你可以根据实际需求选择合适的填充值，例如使用数值（如均值、中位数）、特定字符串等。

额外注意事项

无穷值和过大值的处理 ：除了缺失值，错误信息还提到了无穷值和过大值。你可以使用 np.isfinite() 函数检查数据中是否存在无穷值，对于过大值，可能需要对数据进行归一化或缩放处理。
数据类型检查 ：确保数据的类型符合你的预期，有时候数据类型不匹配也可能导致该错误。可以使用 data_test.dtypes 查看数据各列的数据类型。

"Requirement already up - to - date" 问题解决

问题描述

出现 Requirement already up-to-date: pip in c:\python36\lib\site-packages 提示，推测是在更新 pip 等依赖时出现的相关情况，结合后续内容，问题核心可能围绕在 Windows 系统同时安装 Python 2 和 Python 3 时遇到的环境配置、使用便捷性以及可能因路径问题产生的错误。

问题分析

路径空格问题 ：在 Windows 系统中，Program Files 路径包含空格，某些程序在处理包含空格的路径时可能会出现错误，所以建议将 Python 2 和 Python 3 直接安装在 C 盘根目录下，避免路径中的空格带来潜在问题。
版本区分问题 ：同时安装 Python 2 和 Python 3 时，系统默认的 python.exe 可能会产生混淆，为了方便同时使用这两个版本，需要对可执行文件名进行区分。

解决方案步骤

安装 Python 2 和 Python 3

将 Python 2 安装到 C:\python27 文件夹下。
将 Python 3 安装到 C:\python36 文件夹下。

重命名 Python 3 的可执行文件

为了避免 Python 2 和 Python 3 的可执行文件冲突，方便在命令行中分别调用这两个版本，需要将 Python 3 安装目录下的 python.exe 重命名为 python3.exe。具体操作如下：

打开文件资源管理器，定位到 C:\python36 文件夹。
找到 python.exe 文件，右键点击该文件，选择 "重命名"。
将文件名修改为 python3.exe。

验证安装和配置

打开命令提示符（CMD）。
输入 python --version，应该显示 Python 2 的版本信息。
输入 python3 --version，应该显示 Python 3 的版本信息。

额外注意事项

环境变量配置：确保 C:\python27和 C:\python36 都已经添加到系统的环境变量 PATH中，这样系统才能找到相应的可执行文件。可以通过以下步骤检查和配置环境变量：
- 右键点击 "此电脑"，选择 "属性"。
- 点击 "高级系统设置"，在弹出的窗口中选择 "环境变量"。
- 在 "系统变量" 中找到 PATH 变量，点击 "编辑"。
- 确保 C:\python27 和 C:\python36 都已经包含在 PATH 变量的值中，如果没有，可以点击 "新建" 添加。
pip 使用 ：由于重命名了 Python 3 的可执行文件，对应的 pip 命令也需要做相应调整。使用 Python 2 时，直接使用 pip 命令；使用 Python 3 时，需要使用 python3 -m pip 来调用 Python 3 的 pip 工具。例如，要使用 Python 3 的 pip 安装包，可以执行 python3 -m pip install package_name。

Python基础

Python基础

基本数据类型

基本数据结构

Python 编码规范

多线程

Python 多线程概述

线程的基本使用

Logging 模块

Jieba模块

re 模块（正则表达式模块）

os 模块（操作系统接口模块）

decimal 模块

sys 模块

JSON 模块

日常使用

数据分析库

NumPy科学计算包

Pandas数据分析包

Matplotlib画图包

Gensim模块（自然语言处理库）

argparse 模块（命令行参数解析模块）

datetime 模块（日期和时间处理模块）

itertools 模块

代码换行

Json数据转换为Python DataFrame

字符串列表转换为整数列表

Python连接

简单爬虫

日常问题

"Java gateway process exited" 异常

ValueError: Input contains NaN处理

"Requirement already up - to - date" 问题解决

额外注意事项

`re` 模块（正则表达式模块）

`os` 模块（操作系统接口模块）

`decimal` 模块

`sys` 模块

`argparse` 模块（命令行参数解析模块）

`datetime` 模块（日期和时间处理模块）