python 的笔记碎碎念

合集 - 笔记(3)

1.Python常见数据结构整理2024-07-182.some cute linux command2024-07-18

3.python 的笔记碎碎念2024-07-18

收起

计算你的python程序运行时间:

or:
$ python -m cProfile euler048.py

---

递归三定律

1. 递归算法必须有一个基本结束条件(最小规模问题的直接解决)
2. 递归算法必须能改变状态向基本结束条件演进(减小问题规模)
3. 递归算法必须调用自身(解决减小了规模的相同问题)

---

bottle传参

http://localhost:8080/command?param_name=param_value
In your code:
param_value = request.query.param_name

---

Time

import time

# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
2016-04-07 10:29:46

# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
Thu Apr 07 10:29:46 2016

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
1459175064.0

---

import datetime


def get_uid():
    now = datetime.datetime.now()
    strT = now.strftime('%Y%m%d%H%M%S%f')[:-3]
    uid = "{0}".format(strT)
    return uid

---

Map reduce

Map applies a function to all the items in an input_list. Here is the blueprint:

Blueprint

map(function_to_apply, list_of_inputs)


Most of the times we want to pass all the list elements to a function one-by-one and then collect the output. For instance:

items = [1, 2, 3, 4, 5]
squared = []
for i in items:
    squared.append(i**2)


Map allows us to implement this in a much simpler and nicer way. Here you go:

items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))


Most of the times we use lambdas with map so I did the same. Instead of a list of inputs we can even have a list of functions!

def multiply(x):
    return (x*x)
def add(x):
    return (x+x)

funcs = [multiply, add]
for i in range(5):
    value = list(map(lambda x: x(i), funcs))
    print(value)

# Output:
# [0, 0]
# [1, 2]
# [4, 4]
# [9, 6]
# [16, 8]


4.2. Filter


As the name suggests, filter creates a list of elements for which a function returns true. Here is a short and concise example:

number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)

# Output: [-5, -4, -3, -2, -1]


The filter resembles a for loop but it is a builtin function and faster.

Note: If map & filter do not appear beautiful to you then you can read about list/dict/tuplecomprehensions.


4.3. Reduce


Reduce is a really useful function for performing some computation on a list and returning the result. It applies a rolling computation to sequential pairs of values in a list. For example, if you wanted to compute the product of a list of integers.

So the normal way you might go about doing this task in python is using a basic for loop:

product = 1
list = [1, 2, 3, 4]
for num in list:
    product = product * num

# product = 24


Now let’s try it with reduce:

from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])

# Output: 24

---

python init

主要是用到python的包的概念，python __init__.py在包里起一个比较重要的作用
要弄明白这个问题，首先要知道，python在执行import语句时，到底进行了什么操作，按照python的文档，它执行了如下操作：
第1步，创建一个新的，空的module对象（它可能包含多个module）；
第2步，把这个module对象插入sys.module中
第3步，装载module的代码（如果需要，首先必须编译）
第4步，执行新的module中对应的代码。
---
私有的类方法
__private_method 两个下划线开头，声明该方法为私有方法，不能在类地外部调用
在类的内部调用slef.__private_methods
类的专有方法：
__init__  构造函数，在生成对象时调用
__del__   析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用

__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方

---

You have to compile it on OS X. The executable formats for OS X and Linux are different.
Compile it on the Mac so it adheres to the Mach-O object file format.

---

Old    '%s %s' % ('one', 'two')
New    '{} {}'.format('one', 'two')
Output    one two


Old    '%d %d' % (1, 2)
New    '{} {}'.format(1, 2)
Output    1 2


八进制：
'{:02X}'.format(15)
'%02x' % number

>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序'hello world’ 
>>> "{0} {1}".format("hello", "world") # 设置指定位置'hello world’ 
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置'world hello world’


print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数

site = {"name": "菜鸟教程", "url": "www.runoob.com”} 
print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数

my_list = ['菜鸟教程', 'www.runoob.com’]
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的

>>> print("{:.2f}".format(3.1415926))
3.14

# 转义大括弧
$ print ("{} 对应的位置是 {{0}}".format("runoob”))
runoob 对应的位置是 {0}

---

Requests

>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
u'{"type":"User"...'
>>> r.json()
{u'private_gists': 419, u'total_private_repos': 77, …}

---

*args and **kwargs

>>> def foo (*args, **kwargs):
...     if kwargs['in_port']:
...             print kwargs['in_port']
...     print args, kwargs
...
>>> foo(1,2, in_port='s1_p2')
s1_p2
(1, 2) {'in_port': 's1_p2'}

---

Web服务器网关接口（Python Web Server Gateway Interface，缩写为WSGI）是为Python语言定义的Web服务器和Web应用程序或框架之间的一种简单而通用的接口。

python中的小括号( )：代表tuple元组数据类型，元组是一种不可变序列。创建方法很简单，大多时候都是用小括号括起来的。

>>> tup = (1,2,3)
>>> tup
(1, 2, 3)
>>>
>>> ()    #空元组
()
>>> 
>>> 55,    #一个值的元组
(55,)

python中的中括号[ ]：代表list列表数据类型，列表是一种可变的序列。其创建方法即简单又特别，像下面一样：

>>> list('python')
['p', 'y', 't', 'h', 'o', 'n']

如果想创建一个空的列表，或是一个值的列表其方法同元组创建，只要使用不同括号即可。Pyhton列表list操作讲解更适合新手深入认识什么是列表。

python大括号{ }花括号：代表dict字典数据类型，字典是由键对值组组成。冒号':'分开键和值，逗号','隔开组。用大括号创建的方法如下：

>>> dic={'jon':'boy','lili':'girl'}
>>> dic
{'lili': 'girl', 'jon': 'boy'}
>>> 
>>> d = {}
>>> d = {'query':{}, 'slow':{}}
>>> d['slow'].update({'url1':'t1'})
>>> d
{'query': {}, 'slow': {'url1': 't1'}}
>>>

Python  字典(Dictionary)
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 }; dict2 = { 'abc': 123, 98.6: 37 };
访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
实例
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; 
print "dict['Name']: ", dict['Name']; 
print "dict['Age']: ", dict['Age'];
以上实例输出结果：
dict['Name']:  Zara
dict['Age']:  7
如果用字典里没有的键访问数据，会输出错误如下：
实例
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; 
print "dict['Alice']: ", dict['Alice'];
以上实例输出结果：
dict['Alice']: 
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'


修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
实例

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; 
dict['Age'] = 8; 
# update existing entry
dict['School'] = "DPS School”; 
# Add new entry 
print "dict['Age']: ", dict['Age']; 
print "dict['School']: ", dict['School'];
以上实例输出结果：
dict['Age']:  8
dict['School']:  DPS School


删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
实例
#!/usr/bin/python# 
-*- coding: UTF-8 -*- 
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; 
# 删除键是'Name’的条目
del dict['Name']; 
# 清空词典所有条目
dict.clear(); 
# 删除词典 
del dict ; 
print "dict['Age']: ", dict['Age']; 
print "dict['School']: ", dict['School'];
但这会引发一个异常，因为用del后字典不再存在：
dict['Age']:
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable
注：del()方法后面也会讨论。


字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
实例
#!/usr/bin/python 
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}; 
print "dict['Name']: ", dict['Name'];
以上实例输出结果：
dict['Name']:  Manni
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
实例
#!/usr/bin/python 
dict = {['Name']: 'Zara', 'Age': 7}; 
print "dict['Name']: ", dict['Name'];
以上实例输出结果：
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Zara', 'Age': 7};
TypeError: list objects are unhashable


字典内置函数&方法
Python字典包含了以下内置函数：
序号
	
函数及描述
	
1 
	
cmp(dict1, dict2)
比较两个字典元素。 
	
2 
	
len(dict)
计算字典元素个数，即键的总数。 
	
3 
	
str(dict)
输出字典可打印的字符串表示。 
	
4 
	
type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。 
Python字典包含了以下内置方法：
序号
	
函数及描述
	
1 
	
dict.clear()
删除字典内所有元素 
	
2 
	
dict.copy()
返回一个字典的浅复制 
	
3 
	
dict.fromkeys(seq[, val]))
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 
	
4 
	
dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值 
	
5 
	
dict.has_key(key)
如果键在字典dict里返回true，否则返回false 
	
6 
	
dict.items()
以列表返回可遍历的(键, 值) 元组数组 
	
7 
	
dict.keys()
以列表返回一个字典所有的键 
	
8 
	
dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default 
	
9 
	
dict.update(dict2)
把字典dict2的键/值对更新到dict里 
	
10 
	
dict.values()
以列表返回字典中的所有值 
	
11 
	
pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 
	
12 
	
popitem()
随机返回并删除字典中的一对键和值。 
字典值可以是任意数值类型：
>>> dict1 = {"a":[1,2]}      # 值为列表
>>> print dict1["a"][1]
2
>>> dict2 = {"a":{"c":"d"}}   # 值为字典
>>> print dict2["a"]["c"]
d
>>> 


编写字典程序:
 1. 用户添加单词和定义
 2. 查找这些单词
 3.如果查不到，请让用户知道
 4. 循环
#coding:utf-8


# 字典创建  while开关 字典添加   字典寻找
dictionary = {}
flag = 'a'
pape = 'a'
off = 'a'
while flag == 'a' or 'c' :
    flag = raw_input("添加或查找单词 ?(a/c)")
    if flag == "a" :                             # 开启
        word = raw_input("输入单词(key):")
        defintion = raw_input("输入定义值(value):")
        dictionary[str(word)] = str(defintion)  # 添加字典
        print "添加成功!"
        pape = raw_input("您是否要查找字典?(a/0)")   #read
        if pape == 'a':
            print dictionary
        else :
            continue
    elif flag == 'c':
        check_word = raw_input("要查找的单词:")  # 检索
        for key in sorted(dictionary.keys()):            # yes
            if str(check_word) == key:
                print "该单词存在! " ,key, dictionary[key]
                break
            else:                                       # no
                off = 'b'
        if off == 'b':
            print "抱歉，该值不存在！"
    else:                               # 停止
        print "error type"
        break
测试输入：
添加或查找单词 ?(a/c)a
输入单词(key):runoob
输入定义值(value):www.runoob.com
添加成功!
您是否要查找字典?(a/0)0
添加或查找单词 ?(a/c)c 
要查找的单词:runoob
该单词存在!  runoob www.runoob.com
添加或查找单词 ?(a/c)
   modabiliba
  782***968
   yyulei
  1

Python 中的字典相当于 C++ 或者 Java 等高级编程语言中的容器 Map，每一项都是由 Key 和 Value 键值对构成的，当我们去访问时，根据关键字就能找到对应的值。
另外就是字典和列表、元组在构建上有所不同。列表是方括号 []，元组是圆括号 ()，字典是花括号 {}。

users = {
    'A':{
    'first':'yu',
    'last':'lei',
    'location':'hs',
    },
    'B':{
    'first':'liu',
    'last':'wei',
    'location':'hs',    
    },
}
# username,userinfo 相当于 key,value
for username,userinfo in users.items():
    print("username:"+username)
    print("userinfo"+str(userinfo))
    fullname=userinfo['first']+" "+userinfo['last']
    print("fullname:"+fullname)
    print("location:"+userinfo['location'])
  102***
schedule a task

class sched.scheduler(timefunc, delayfunc)
The scheduler class defines a generic interface to scheduling events. It needs two functions to actually deal with the “outside world” — timefunc should be callable without arguments, and return a number (the “time”, in any units whatsoever). The delayfunc function should be callable with one argument, compatible with the output of timefunc, and should delay that many time units. delayfunc will also be called with the argument 0 after each event is run to allow other threads an opportunity to run in multi-threaded applications.

Example:

>>> import sched, time
>>> s = sched.scheduler(time.time, time.sleep)
>>> def print_time(): print "From print_time", time.time()
...
>>> def print_some_times():
...     print time.time()
...     s.enter(5, 1, print_time, ())
...     s.enter(10, 1, print_time, ())
...     s.run()
...     print time.time()
...
>>> print_some_times()
930343690.257
From print_time 930343695.274
From print_time 930343700.273
930343700.276

In multi-threaded environments, the scheduler class has limitations with respect to thread-safety, inability to insert a new task before the one currently pending in a running scheduler, and holding up the main thread until the event queue is empty. Instead, the preferred approach is to use the threading.Timer class instead.

>>> import time
>>> from threading import Timer
>>> def print_time():
...     print "From print_time", time.time()
...
>>> def print_some_times():
...     print time.time()
...     Timer(5, print_time, ()).start()
...     Timer(10, print_time, ()).start()
...     time.sleep(11)  # sleep while time-delay events execute
...     print time.time()
...
>>> print_some_times()
930343690.257
From print_time 930343695.274
From print_time 930343700.273
930343701.301

---

Python 字符串操作（string替换、删除、截取、复制、连接、比较、查找、包含、大小写转换、分割等）

去空格及特殊符号

s.strip() .lstrip() .rstrip(',')   

复制字符串

#strcpy(sStr1,sStr)   
sStr= 'strcpy'   
sStr = sStr  
sStr= 'strcpy'   
print sStr 

连接字符串

#strcat(sStr1,sStr)   
sStr= 'strcat'   
sStr = 'append'   
sStr+= sStr   
print sStr 

查找字符

#strchr(sStr1,sStr)   
sStr1= 'strchr'   
sStr = 's'   
nPos = sStr1.index(sStr)   
print nPos   

比较字符串

#strcmp(sStr1,sStr)   
sStr1= 'strchr'   
sStr = 'strch'   
print cmp(sStr1,sStr) 

扫描字符串是否包含指定的字符

#strspn(sStr1,sStr)   
sStr1= '1345678'   
sStr = '456'   
#sStrand chars both in sStrand sStr   
print len(sStrand sStr)

字符串长度

#strlen(sStr1)   
sStr= 'strlen'   
print len(sStr1)

将字符串中的大小写转换

#strlwr(sStr1)   
sStr= 'JCstrlwr'   
sStr= sStr1.upper()   
#sStr= sStr1.lower()   
print sStr

追加指定长度的字符串

#strncat(sStr1,sStr,n)   
sStr1= '1345'   
sStr = 'abcdef'   
n = 3 
sStr += sStr[0:n]   
print sStr 

字符串指定长度比较

#strncmp(sStr1,sStr,n)   
sStr= '1345'   
sStr = '13bc'   
n = 3 
print cmp(sStr1[0:n],sStr[0:n]) 

复制指定长度的字符

#strncpy(sStr1,sStr,n)   
sStr1= ''   
sStr = '1345'   
n = 3 
sStr= sStr[0:n]   
print sStr

将字符串前n个字符替换为指定的字符

#strnset(sStr1,ch,n)   
sStr= '1345'   
ch = 'r'   
n = 3 
sStr= n * ch + sStr1[3:]   
print sStr  

扫描字符串

#strpbrk(sStr1,sStr)   
sStr= 'cekjgdklab'   
sStr = 'gka'   
nPos = -1 
for c in sStr1:   
     if c in sStr:   
         nPos = sStr1.index(c)   
         break   
print nPos

翻转字符串

#strrev(sStr1)   
sStr= 'abcdefg'   
sStr= sStr1[::-1]   
print sStr 

>>> a[1:5:2]  # 1-5位切片，步进为2，所以取出来是‘13’

查找字符串

#strstr(sStr1,sStr)   
sStr= 'abcdefg'   
sStr = 'cde'   
print sStr1.find(sStr)   

分割字符串

#strtok(sStr1,sStr)   
sStr= 'ab,cde,fgh,ijk'   
sStr = ','   
sStr= sStr1[sStr1.find(sStr) + 1:]   
print sStr  

或者

s = 'ab,cde,fgh,ijk'   
print(s.split(','))  

连接字符串

delimiter = ','   
mylist = ['Brazil', 'Russia', 'India', 'China']   
print delimiter.join(mylist)   
PHP 中 addslashes 的实现  
def addslashes(s):   
     d = {'"':'\\"', "'":"\\'", "\0":"\\\0", "\\":"\\\\"}   
    return ''.join(d.get(c, c) for c in s)   
s = "John 'Johny' Doe (a.k.a. \"Super Joe\")\\\0"   
print s   
print addslashes(s)

只显示字母与数字

def OnlyCharNum(s,oth=''):   
     s = s.lower();   
    fomart = 'abcdefghijklmnopqrstuvwxyz013456789'   
    for c in s:   
        if not c in fomart:   
             s = s.replace(c,'');   
     return s;   
print(OnlyStr("a000 aa-b")) 

---

import time
time.sleep(secs)

---

>>> n=input("Enter an non-negative integar:")
Enter an non-negative integar:123
>>> n
123
>>> isinstance(n, int)
True

---

iter() and next()

# define a list
my_list = [4, 7, 0, 3]
# get an iterator using iter()
my_iter = iter(my_list)
## iterate through it using next() 
#prints 4
print(next(my_iter))
#prints 7
print(next(my_iter))

## next(obj) is same as obj.__next__()
#prints 0
print(my_iter.__next__())




#prints 3
print(my_iter.__next__())




## This will raise error, no items left
next(my_iter)

---

异或常用于将所有的位反转 
0b1010 ^ 0b1111  #输出5，即0b0101

python中有一个zfill方法用来给字符串前面补0，非常有用

n = "123"


s = n.zfill(5)


assert s == "00123"

zfill()也可以给负数补0

n = "-123"


s = n.zfill(5)


assert s == "-0123"

对于纯数字，我们也可以通过格式化的方式来补0

n = 123


s = "%05d" % n

---

怎样初始化固定长度的字符串

>>> str = ''.zfill(96)
>>> str
‘000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000’

但是，Python中列表list中的值是可修改的，而元组和字符串的值是不可修改的。只能将字符串转换成列表后修改值，然后用join组成新字符串
string = 'abcdafg'
newstr = list(string)
newstr[4] = 'e'
print(string, ''.join(newstr), sep='\n')
---
怎样生成随机数
>>> from random import randint
>>> randint(0,9)
9

生成96位随机二进制串：
>>> from random import randint
>>> s=''.zfill(96)
>>> s
'000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
>>> ns=list(s)
>>> for i in range(0,96):
...     ns[i] = str(randint(0,9)%2)
...
>>> ns
['0', '0', '1', '0', '0', '0', '1', '1', '1', '0', '1', '1', '0', '0', '0', '0', '1', '0', '1', '0', '1', '1', '1', '1', '1', '0', '1', '0', '1', '0', '1', '0', '1', '1', '0', '0', '1', '0', '0', '1', '1', '1', '0', '0', '0', '0', '1', '0', '0', '0', '1', '0', '0', '1', '1', '1', '0', '0', '1', '1', '1', '1', '1', '0', '1', '1', '0', '0', '0', '1', '0', '1', '0', '1', '1', '1', '0', '0', '0', '1', '0', '1', '1', '0', '0', '0', '0', '0', '0', '1', '0', '1', '0', '1', '1', '1']
>>> s = ''.join(ns)
>>> s
'001000111011000010101111101010101100100111000010001001110011111011000101011100010110000001010111'
---
打开文件，从头到尾读完后，再执行read()就没有了, 让指针回到文件首，用 file.seek(0)
---
import math
math.pow( x, y )
pow(x,y) 等价于 x**y: 
4**2    # 结果为16
4**2.5  # 结果为32.0

pow(x,y,z) 等价于 x**y%z: 

4**2.5%3  # 结果为2.0

---

python 的路径 PATH 配置

$ echo $PATH
/usr/local/maven/apache-maven-3.6.3/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin::/usr/local/gradle-6.0/bin:/opt/local/bin

$ echo $PYTHONPATH
/Users/qianruzhou/Documents/code/cic/DoHlyzer-master:/usr/local/Cellar/python@3.9/3.9.1_6/Frameworks/Python.framework/Versions/3.9/lib/python39.zip:/usr/local/Cellar/python@3.9/3.9.1_6/Frameworks/Python.framework/Versions/3.9/lib/python3.9:/usr/local/Cellar/python@3.9/3.9.1_6/Frameworks/Python.framework/Versions/3.9/lib/python3.9/lib-dynload:/usr/local/Cellar/python@3.9/3.9.1_6/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages

---

I've found that trying to edit the PYTHONPATH within Python doesn't stick. When you open Python again, you're back to the same old list.

The persistent solution: edit .bashrc or .tcshrc with commands to change PYTHONPATH. (not sure what shell your terminal is using? Run 'echo $0' That's the number zero.)

For TCSH shells, edit .tcshrc and add a line like this:
setenv PYTHONPATH ${PYTHONPATH}:/Users/riedel/Code/Python/:/Users/riedel/Code/Python/Astrotools:/Users/riedel/Code/Python/Database:/Users/riedel/Code/Python/Miscellaneous

For BASH shells, edit ~/.bashrc and add something like these lines:
PYTHONPATH="${PYTHONPATH}:/Users/riedel/Code/Python/:/Users/riedel/Code/Python/Astrotools:/Users/riedel/Code/Python/Database:/Users/riedel/Code/Python/Miscellaneous"

export PYTHONPATH=/DIR/TO/YOUR/FILE

The changes will take effect in newly opened terminals.

According to what I've read, all you SHOULD need is to specify the base code folder (mine is /Users/riedel/Code/Python) and add init.py files in the subfolders below it. That doesn't seem to work for the BDNYC module that comes with the python database, hence this approach.