西维蜀黍

【Python】杂 - virtualenv 管理 Python 项目依赖

Background

virtualenv is a tool to create isolated Python environments.

The basic problem being addressed is one of dependencies and versions, and indirectly permissions. Imagine you have an application that needs version 1 of LibFoo, but another application requires version 2. How can you use both these applications? If you install everything into /usr/lib/python2.7/site-packages (or whatever your platform’s standard location is), it’s easy to end up in a situation where you unintentionally upgrade an application that shouldn’t be upgraded.

Or more generally, what if you want to install an application and leave it be? If an application works, any change in its libraries or the versions of those libraries can break the application.

Also, what if you can’t install packages into the global site-packages directory? For instance, on a shared host.

In all these cases, virtualenv can help you. It creates an environment that has its own installation directories, that doesn’t share libraries with other virtualenv environments (and optionally doesn’t access the globally installed libraries either).

总结来说，virtualenv 是用来隔离不同 Python 项目的开发与运行环境。一个典型的场景是，有一个基于 Python 2.7 的 Django 项目，基于的 Django 版本是 1.1，而同时我们本机上正在开发一个同样基于 Python 2.7 的 Django 项目，不同的是这个项目基于Django 1.2 版本。

我们通过 pip install django来安装 Django，而这个 Django 依赖包默认会保存在/usr/lib/python2.7/site-packages，且这两个项目均会通过访问 /usr/lib/python2.7/site-packages来完成我们的 Django 项目的编译。

这意味着，我们要么安装 1.1 的 Django 版本，要么安装 1.2的版本。

通过使用 virtualenv 后，它会在我们的工程文件夹下创建一个 venv 文件夹，里面包含了这个项目使用的 Python 可执行程序（或者称为 compiler 或者 interpreter）、所有依赖的第三方包。

最终，就解决了不同项目可能需要依赖不同版本的第三方包的问题。

  ...

Posted by Wei on 2019-10-08, Last Modified on 2025-08-11

【Python】Django - 连接 MySQL

MySQLdb（MySQL-python）

MySQL-python 又叫 MySQLdb，是 Python 连接 MySQL 最流行的一个驱动，很多框架都也是基于此库进行开发，遗憾的是它只支持 Python2.x，而且安装的时候有很多前置条件，因为它是基于C开发的库，在 Windows 平台安装非常不友好，经常出现失败的情况，现在基本不推荐使用，取代的是它的衍生版本。

# 前置条件
sudo apt-get install python-dev libmysqlclient-dev # Ubuntu
sudo yum install python-devel mysql-devel # Red Hat / CentOS

# 安装
pip install MySQL-python

安装完依赖，直接使用pip安装，MySQLdb模块的名字在pip上叫MySQL-python。

$ pip install MySQL-python

mysqlclient

由于 MySQL-python 年久失修，后来出现了它的 Fork 版本 mysqlclient，完全兼容 MySQLdb，同时支持 Python3.x，是 Django ORM的依赖工具，如果你想使用原生 SQL 来操作数据库，那么推荐此驱动。安装方式和 MySQLdb 是一样的。

# Windows安装
pip install some-package.whl

# linux 前置条件
sudo apt-get install python3-dev # debian / Ubuntu
sudo yum install python3-devel # Red Hat / CentOS
brew install mysql-connector-c # macOS (Homebrew)

pip install mysqlclient

PyMySQL

PyMySQL是一个纯Python写的MySQL客户端，它的目标是替代MySQLdb，可以在CPython、PyPy、IronPython和Jython环境下运行。PyMySQL在MIT许可下发布。

步骤

1 安装 pymysql

$ pip install pymysql

2 修改 settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'django',        #数据库名字
        'USER': 'root',          #账号
        'PASSWORD': '123456',      #密码
        'HOST': '127.0.0.1',    #IP
        'PORT': '3306',                   #端口
    }
}

3 init.py里面导入pymysql模块

# [your app in your project]/init.py

import pymysql
pymysql.install_as_MySQLdb()
  ...

Posted by Wei on 2019-10-08, Last Modified on 2025-08-11

【Python】杂 - pyenv 系统 Python 版本管理

Background

Understanding PATH

When you run a command like python or pip, your operating system searches through a list of directories to find an executable file with that name. This list of directories lives in an environment variable called PATH, with each directory in the list separated by a colon:

/usr/local/bin:/usr/bin:/bin

Directories in PATH are searched from left to right, so a matching executable in a directory at the beginning of the list takes precedence over another one at the end. In this example, the /usr/local/bin directory will be searched first, then /usr/bin, then /bin.

  ...

Posted by Wei on 2019-10-06, Last Modified on 2025-08-11

【Python】杂 - macOS 下设置 Python 默认版本

步骤

1 修改可执行文件路径

打开配置文件，指定 python 命令对应的可执行文件路径：

$ open ~/.bash_profile

增加以下：

export PATH=/usr/local/Cellar/python/3.7.4_1/bin:${PATH}

注意，如果是使用 oh-my-zsh，则需要修改添加以上内容到 ~/.zshrc中。

2 配置文件生效

$ source ~/.bash_profile
  ...

Posted by Wei on 2019-10-06, Last Modified on 2025-08-11

【Python】API - 时间表示

表示时间总共有 3 个相关的类

  • datetime.date：表示日期，Attributes: year, month, and day。
  • datetime.time：表示时间，Attributes: hour, minute, second, microsecond, and tzinfo。
  • datetime.dateime：表示日期和时间，Attributes: year, month, day, hour, minute, second, microsecond, and tzinfo。
  • datetime.timedelta：表示一个时间的差值
  ...

Posted by Wei on 2019-10-06, Last Modified on 2025-08-11

【MySQL】MySQL 8 + macOS 错误：Authentication plugin 'caching_sha2_password' cannot be loaded

错误信息

Authentication plugin ‘caching_sha2_password’ cannot be loaded: dlopen(/usr/local/mysql/lib/plugin/caching_sha2_password.so, 2): image not found

这是 MySQL 的问题，不是客户端问题，所以不管是用 Navicat Premium 还是 Sequel Pro 连接 MySQL，会碰到一样的错误。

解决方法

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'yourpassword';
  ...

Posted by Wei on 2019-10-06, Last Modified on 2025-08-11

【Python】I/O - 异步 I/O

asyncio

asyncio是Python 3.4版本引入的标准库，直接内置了对异步IO的支持。

asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO。

用asyncio实现Hello world代码如下：

import asyncio

@asyncio.coroutine
def hello():
    print("Hello world!")
    # 异步调用asyncio.sleep(1):
    r = yield from asyncio.sleep(1)
    print("Hello again!")

# 获取EventLoop:
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())
loop.close()

@asyncio.coroutine把一个generator标记为coroutine类型，然后，我们就把这个coroutine扔到EventLoop中执行。

hello()会首先打印出Hello world!，然后，yield from语法可以让我们方便地调用另一个generator。由于asyncio.sleep()也是一个coroutine，所以线程不会等待asyncio.sleep()，而是直接中断并执行下一个消息循环。当asyncio.sleep()返回时，线程就可以从yield from拿到返回值（此处是None），然后接着执行下一行语句。

把asyncio.sleep(1)看成是一个耗时1秒的IO操作，在此期间，主线程并未等待，而是去执行EventLoop中其他可以执行的coroutine了，因此可以实现并发执行。

我们用Task封装两个coroutine试试：

import threading
import asyncio

@asyncio.coroutine
def hello():
    print('Hello world! (%s)' % threading.currentThread())
    yield from asyncio.sleep(1)
    print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
  ...

Posted by Wei on 2019-09-24, Last Modified on 2025-08-11

【Python】线程 - ThreadLocal

ThreadLocal

import threading
    
# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

执行结果：

Hello, Alice (in Thread-A)
Hello, Bob (in Thread-B)

全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。

可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

  ...

Posted by Wei on 2019-09-24, Last Modified on 2025-08-11

【Python】Basics - 类

  ...

Posted by Wei on 2019-09-23, Last Modified on 2025-08-11

【Python】线程 - 锁

Situation

在多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响。而在多线程中，变量可以被多个线程共享，所以，被共享的变量可以被任何一个线程修改，因此，线程之间的共享数据最大的危险在于多个线程可以同时对它进行修改。

来看看多个线程同时操作一个共享变量，最终因为多线程的交替执行（interleaving），导致数据不一致的情况：

import time, threading

# 假定这是你的银行存款:
balance = 0

def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

我们定义了一个共享变量balance，初始值为0，并且启动两个线程，先存后取，理论上结果应该为0，但是，由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，balance的结果就不一定是0了。

原因是因为高级语言的一条语句在CPU执行时是若干条语句，即使一个简单的计算：

balance = balance + n

也分两步：

  1. 计算balance + n，存入临时变量中；
  2. 将临时变量的值赋给balance。

也就是可以看成：

x = balance + n
balance = x

由于x是局部变量，两个线程各自都有自己的x，当代码正常执行时：

初始值 balance = 0

t1: x1 = balance + 5 # x1 = 0 + 5 = 5
t1: balance = x1     # balance = 5
t1: x1 = balance - 5 # x1 = 5 - 5 = 0
t1: balance = x1     # balance = 0

t2: x2 = balance + 8 # x2 = 0 + 8 = 8
t2: balance = x2     # balance = 8
t2: x2 = balance - 8 # x2 = 8 - 8 = 0
t2: balance = x2     # balance = 0
    
结果 balance = 0

但是t1和t2是交替运行的，如果操作系统以下面的顺序执行t1、t2：

初始值 balance = 0

t1: x1 = balance + 5  # x1 = 0 + 5 = 5

t2: x2 = balance + 8  # x2 = 0 + 8 = 8
t2: balance = x2      # balance = 8

t1: balance = x1      # balance = 5
t1: x1 = balance - 5  # x1 = 5 - 5 = 0
t1: balance = x1      # balance = 0

t2: x2 = balance - 8  # x2 = 0 - 8 = -8
t2: balance = x2   # balance = -8

结果 balance = -8

究其原因，是因为修改balance需要多条语句，而执行这几条语句时，线程可能中断，从而导致多个线程把同一个对象的内容改乱了。

两个线程同时一存一取，就可能导致余额不对，你肯定不希望你的银行存款莫名其妙地变成了负数，所以，我们必须确保一个线程在修改balance的时候，别的线程一定不能改。

  ...

Posted by Wei on 2019-09-23, Last Modified on 2025-08-11

FEATURED TAGS
algorithm algorithmproblem architecturalpattern architecture aws blockchain c# cachesystem codis compile concurrentcontrol database dataformat datastructure debug design designpattern distributedsystem django docker domain engineering freebsd git golang grafana hackintosh hadoop hardware hexo http hugo ios iot java javaee javascript kafka kubernetes linux linuxcommand linuxio lock macos markdown microservices mysql nas network networkprogramming nginx node.js npm oop openwrt operatingsystem padavan performance programming prometheus protobuf python redis router security shell software testing spring sql systemdesign truenas ubuntu vmware vpn windows wmware wordpress xml zookeeper
ABOUT ME
avatar

🐒 Software engineer | 📷 Photographer | 👹 Urban explorer

FRIENDS