1、對數值進行取整

#使用內建的round(value,ndigits)函式來取整,ndigits指定保留的位數，在取整時會取值在偶數上，如1.25取一位會取整1.2,1.26會取整1.3
In [1]: round(1.23,1)
Out[1]: 1.2

In [2]: round(1.25,1)
Out[2]: 1.2

In [3]: round(1.26,1)
Out[3]: 1.3

In [4]: round(1.2645,3)
Out[4]: 1.264
#如果引數ndigits為負數的話會相應的取整到十位、白位和千位
In [1]: a = 1234567

In [
 
2]: round(a,-1)
Out[2]: 1234570

In [3]: round(a,-3)
Out[3]: 1235000

#通過格式化操作取小數精度
In [4]: x = 1.23456

In [5]: format(x,'0.2f')
Out[5]: '1.23'

In [6]: 'value is {:0.3f}'.format(x)
Out[6]: 'value is 1.235'

2、執行精確的小數計算

#在數學計算中由於CPU的浮點運算單元特性導致會引入微小的誤差
In [11]: a = 4.2

In [12]: b = 2.1

In [
 
13]: a + b
Out[13]: 6.300000000000001

In [14]: (a + b) == 6.3
Out[14]: False

#可以通過Decimal模組來將數字以字串的形式來指定，但它支援所有常見的數學操作
In [27]: from decimal import Decimal

In [28]: a = Decimal('4.2')

In [29]: b = Decimal('2.1')

In [30]: a + b
Out[30]: Decimal('6.3')

In [31]: print(a + b)
6.3

In [32]: print
 
(type(a + b))
<class 'decimal.Decimal'>

In [33]: (a + b) == Decimal('6.3')
Out[33]: True
#decimal模組的主要功能是允許控制計算過程中的各個方面，包括數字位數的四捨五入，可以通過建立本地的上下文環境來修改其設定
In [34]: from decimal import localcontext

In [35]: a = Decimal('1.3')

In [36]: b = Decimal('1.7')

In [37]: a / b
Out[37]: Decimal('0.7647058823529411764705882353')

In [38]: with localcontext() as ctx:
    ...:     ctx.prec = 3  #指定精確位數
    ...:     print(a / b)
    ...:     
0.765

In [39]: with localcontext() as ctx:
    ...:     ctx.prec = 30
    ...:     print(a / b)
    ...:     
0.764705882352941176470588235294

#如果在數字進行運算時可以使用math.fsum()精確誤差
In [41]: nums = [1.23,10,1,-10,-1.23]

In [42]: sum(nums)
Out[42]: 1.0000000000000004

In [44]: import math
In [46]: math.fsum(nums)
Out[46]: 1.0

3、對數值做格式化輸出

In [47]: x = 1234.56789
#格式化時精確2位小數
In [48]: format(x,'0.2f')
Out[48]: '1234.57'
#右對齊寬度20精確小數3位格式化
In [49]: 'value is{:>20.3f}'.format(x)
Out[49]: 'value is            1234.568'
#左對齊寬度20精確小數位3位格式化
In [50]: 'value is{:<20.3f}'.format(x)
Out[50]: 'value is1234.568            '
#劇中對齊20寬度精確3位小數位格式化
In [51]: 'value is{:^20.3f}'.format(x)
Out[51]: 'value is      1234.568      '
#指定逗號為千位分隔符
In [52]: 'value is{:^20,.1f}'.format(x)
Out[52]: 'value is      1,234.6       '
#使用科學計演算法輸出
In [53]: 'value is{:^20,.4e}'.format(x)
Out[53]: 'value is     1.2346e+03     '

In [54]: 'value is{:^20,.4E}'.format(x)
Out[54]: 'value is     1.2346E+03     '

4、同二進位制、八進位制和十六進位制數打交道

In [55]: num = 12345
#轉換為二進位制
In [56]: bin(num)
Out[56]: '0b11000000111001'
#轉換為八進位制
In [57]: oct(num)
Out[57]: '0o30071'
#轉換為十六進位制
In [58]: hex(num)
Out[58]: '0x3039'

#通過format()函式也可以轉換，它會省去前面的標識0b\0o\0x
In [59]: format(num,'b')
Out[59]: '11000000111001'

In [60]: format(num,'o')
Out[60]: '30071'

In [61]: format(num,'x')
Out[61]: '3039'

#處理負數
In [62]: x = -1234

In [63]: format(x,'b')
Out[63]: '-10011010010'

In [64]: format(x,'o')
Out[64]: '-2322'

In [65]: format(x,'x')
Out[65]: '-4d2'
#通過字串迴轉只需要通過int函式轉換為數字並指定進位制即可
In [66]: int('-4d2',16)
Out[66]: -1234

In [67]: int('-2322',8)
Out[67]: -1234

In [68]: int('-10011010010',2)
Out[68]: -1234

#在python中指定八進位制的語法是在新增字首0o，如修改檔案許可權時，不加上字首將會報錯
In [1]: import os

In [2]: os.chmod('test.py',0777)
  File "<ipython-input-2-ddababe9874c>", line 1
    os.chmod('test.py',0777)
                          ^
SyntaxError: invalid token

#指定資料為八進位制
In [3]: os.chmod('test.py',0o0777)

5、從位元組串中打包和解包大整數

In [4]: x = 23**23

In [5]: x
Out[5]: 20880467999847912034355032910567
#將大整數轉換為位元組串，使用int.to_bytes()方法，指定位元組數和位元組序即可
In [8]: x.to_bytes(16,'big')
Out[8]: b'\x00\x00\x01\x07\x8cnO}uE\x0b\x1f\xb3\xecj\xe7'

#將位元組轉換為整數，使用int.from_bytes()方法，指定位元組序即可
In [9]: data = b'\x00\x00\x01\x07\x8cnO}uE\x0b\x1f\xb3\xecj\xe7'

In [10]: len(data)
Out[10]: 16

In [11]: int.from_bytes(data,'big')
Out[11]: 20880467999847912034355032910567
#指定從小到大的位元組序
In [12]: int.from_bytes(data,'little')
Out[12]: 307606851333435471716003534337847918592

#如果指定的位元組數位數不夠將會報錯，可以使用int.bit_length()方法來確定需要多少位的值才能儲存這個值
In [13]: xx = 523 ** 23
In [14]: xx
Out[14]: 335381300113661875107536852714019056160355655333978849017944067

In [15]: xx.to_bytes(16,'little')
---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
<ipython-input-15-2f3e88637b10> in <module>()
----> 1 xx.to_bytes(16,'little')

OverflowError: int too big to convert

In [17]: xx.bit_length()
Out[17]: 208

In [18]: x.to_bytes(208,'little')
Out[18]: b'\xe7j\xec\xb3\x1f\x0bEu}On\x8c\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00...'

6、複數運算

#建立複數
In [19]: a = complex(2,4)
In [20]: b = 3 - 5j
In [22]: a,b
Out[22]: ((2+4j), (3-5j))
#取實屬部分
In [23]: a.real
Out[23]: 2.0
#取虛數部分
In [24]: a.imag
Out[24]: 4.0
#取共取值
In [25]: a.conjugate()
Out[25]: (2-4j)
#複數運算操作
In [26]: a + b
Out[26]: (5-1j)

In [27]: a - b
Out[27]: (-1+9j)

In [28]: a * b
Out[28]: (26+2j)

In [29]: a / b
Out[29]: (-0.4117647058823529+0.6470588235294118j)

In [30]: abs(a)
Out[30]: 4.47213595499958
#複數的函式操作正弦、餘弦和平方根，可以使用cmath模組
In [31]: import cmath
#正弦
In [32]: cmath.sin(a)
Out[32]: (24.83130584894638-11.356612711218173j)
#餘弦
In [33]: cmath.cos(a)
Out[33]: (-11.36423470640106-24.814651485634183j)
#平方根
In [34]: cmath.exp(a)
Out[34]: (-4.829809383269385-5.5920560936409816j)

#使用numpy模組直接建立複數陣列，並對他們執行操作
In [1]: import numpy as np

In [2]: a = np.array([2+3j,4+5j,6-7j,8+9j])

In [3]: a
Out[3]: array([2.+3.j, 4.+5.j, 6.-7.j, 8.+9.j])

In [4]: a + 2
Out[4]: array([ 4.+3.j,  6.+5.j,  8.-7.j, 10.+9.j])

In [5]: np.sin(a)
Out[5]: 
array([   9.15449915  -4.16890696j,  -56.16227422 -48.50245524j,
       -153.20827755-526.47684926j, 4008.42651446-589.49948373j])

7、處理無窮大和NaN

#無窮大、負無窮大和NaN可以通過float()函式來建立
In [6]: a = float('inf')
In [7]: b = float('-inf')
In [8]: c = float('nan')
In [9]: a,b,c
Out[9]: (inf, -inf, nan)

#通過math.isinf()和math.isnan()函式來檢測是否出現這些值
In [11]: import math

In [12]: math.isinf(a)
Out[12]: True

In [13]: math.isnan(c)
Out[13]: True

In [14]: math.isinf(b)
Out[14]: True
#無窮大在數學計算中應用
In [15]: a + 100
Out[15]: inf

In [16]: a * 100000
Out[16]: inf

In [17]: 10 / a
Out[17]: 0.0
#特定的操作會產生NaN結果
In [18]: a/a
Out[18]: nan

In [19]: a + b
Out[19]: nan

In [20]: c + 2345
Out[20]: nan

In [21]: c / 2222222
Out[21]: nan

In [23]: c * 33323333333
Out[23]: nan

In [24]: math.sqrt(c)
Out[24]: nan
#NaN在做比較時從不會判定為相等
In [25]: x = float('nan')

In [26]: y = float('nan')

In [27]: x == y
Out[27]: False

In [28]: x is y
Out[28]: False
#唯一能檢測是否為NaN的辦法只有math.isnan()方法
In [29]: math.isnan(x)
Out[29]: True

8、分數的計算

#fractions模組可以用來處理涉及分數的數學計算
In [1]: from fractions import Fraction

In [2]: a = Fraction(3,4)

In [3]: b = Fraction(4,8)

In [4]: print(a+b)
5/4

In [5]: print(a-b)
1/4

In [6]: print(a*b)
3/8

In [7]: c = a * b

In [8]: c
Out[8]: Fraction(3, 8)
#顯示分數
In [9]: c.numerator
Out[9]: 3
#顯示母數
In [10]: c.denominator
Out[10]: 8
#將分數轉換為浮點數
In [11]: float(c)
Out[11]: 0.375
#限制分母
In [12]: print(c.limit_denominator(4))
1/3
#將浮點數轉換為分數
In [13]: x = 3.75

In [14]: y = Fraction(*x.as_integer_ratio())

In [15]: y
Out[15]: Fraction(15, 4)

In [16]: print(y)
15/4

9、處理大型陣列的計算

#大型陣列的計算可以使用numpy庫來運算
In [17]: import numpy as np

In [18]: ax = np.array([1,2,3,4])

In [19]: ay = np.array([5,6,7,8])

In [20]: ax * 3
Out[20]: array([ 3,  6,  9, 12])

In [21]: ax / 2
Out[21]: array([0.5, 1. , 1.5, 2. ])

In [22]: ax - ay
Out[22]: array([-4, -4, -4, -4])

In [23]: ax + ay
Out[23]: array([ 6,  8, 10, 12])

In [24]: ax * ay
Out[24]: array([ 5, 12, 21, 32])
#多計算組合
In [25]: def f(x):
    ...:     return 2 * x + 10
    ...: 
    ...: 
In [26]: f(ax)
Out[26]: array([12, 14, 16, 18])

In [27]: f(ay)
Out[27]: array([20, 22, 24, 26])
#計算陣列的平方根
In [28]: np.sqrt(ax)
Out[28]: array([1.        , 1.41421356, 1.73205081, 2.        ])
#餘弦數
In [29]: np.cos(ax)
Out[29]: array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])
#正弦數
In [30]: np.sin(ax)
Out[30]: array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 ])

#通過numpy建立二維浮點陣列
In [31]: grid = np.zeros(shape=(1000,1000),dtype=float)
In [32]: grid
Out[32]: 
array([[0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]])
#陣列計算
In [33]: grid += 11

In [34]: grid
Out[34]: 
array([[11., 11., 11., ..., 11., 11., 11.],
       [11., 11., 11., ..., 11., 11., 11.],
       [11., 11., 11., ..., 11., 11., 11.],
       ...,
       [11., 11., 11., ..., 11., 11., 11.],
       [11., 11., 11., ..., 11., 11., 11.],
       [11., 11., 11., ..., 11., 11., 11.]])
#陣列正弦
In [35]: np.sin(grid)
Out[35]: 
array([[-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021],
       [-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021],
       [-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021],
       ...,
       [-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021],
       [-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021],
       [-0.99999021, -0.99999021, -0.99999021, ..., -0.99999021,
        -0.99999021, -0.99999021]])
#numpy擴充套件了python列表的索引功能
In [36]: a = np.array([[1,2,3],[4,5,6],[7,8,9]])

In [37]: a
Out[37]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
#索引第一層
In [38]: a[1]
Out[38]: array([4, 5, 6])

In [39]: a[0]
Out[39]: array([1, 2, 3])

In [40]: a[:]
Out[40]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
# 索引第二層
In [41]: a[:,1]
Out[41]: array([2, 5, 8])

In [42]: a[1:3,1:3]
Out[42]: 
array([[5, 6],
       [8, 9]])

In [43]: a[0:3,0:3]
Out[43]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

In [44]: a[0:3,1:3]
Out[44]: 
array([[2, 3],
       [5, 6],
       [8, 9]])
#對索引進行運算操作
In [45]: a[0:3,1:3] += 10

In [46]: a
Out[46]: 
array([[ 1, 12, 13],
       [ 4, 15, 16],
       [ 7, 18, 19]])

In [47]: a + 10
Out[47]: 
array([[11, 22, 23],
       [14, 25, 26],
       [17, 28, 29]])

In [48]: a
Out[48]: 
array([[ 1, 12, 13],
       [ 4, 15, 16],
       [ 7, 18, 19]])
#對陣列中小於10以外的值運算加10
In [49]: np.where(a < 10 ,a ,a+10)
Out[49]: 
array([[ 1, 22, 23],
       [ 4, 25, 26],
       [ 7, 28, 29]])
#numpy是使用最為龐大和複雜的模組之一，官方站點：http://www.numpy.org

10、矩陣和線性代數的計算

#numpy庫中的matrix物件可以用來處理線性代數
In [50]: import numpy as np

In [51]: m = np.matrix([[1,2,3],[4,5,6],[7,8,9]])

In [52]: m
Out[52]: 
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])

In [53]: m.T
Out[53]: 
matrix([[1, 4, 7],
        [2, 5, 8],
        [3, 6, 9]])
In [55]: v = np.matrix([[22],[33],[44]])

In [56]: v
Out[56]: 
matrix([[22],
        [33],
        [44]])

In [57]: m * v
Out[57]: 
matrix([[220],
        [517],
        [814]])
In [58]: from numpy import linalg

In [59]: linalg.det(m)
Out[59]: 0.0

In [60]: linalg.eigvals(m)
Out[60]: array([ 1.61168440e+01, -1.11684397e+00, -1.30367773e-15])

11、隨機選擇

#random模組中的choice()提供隨機選擇元素
In [62]: import random

In [63]: values = [1,2,3,4,5,6,7,8,9]

In [64]: random.choice(values)
Out[64]: 4

In [65]: random.choice(values)
Out[65]: 2

In [66]: random.choice(values)
Out[66]: 6
#隨機選出多個元素可以使用random.samle()
In [68]: random.sample(values,2)
Out[68]: [4, 8]

In [69]: random.sample(values,3)
Out[69]: [3, 8, 9]

In [70]: random.sample(values,5)
Out[70]: [1, 7, 4, 3, 5]
#原地打亂元素順序可以使用random.shuffle()
In [71]: values
Out[71]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [72]: random.shuffle(values)

In [73]: values
Out[73]: [8, 7, 2, 5, 9, 3, 1, 6, 4]

#生成隨機數可以使用random.randint()
In [74]: random.randint(1,1000)
Out[74]: 534

In [75]: random.randint(1,1000)
Out[75]: 675

In [76]: random.randint(1,1000)
Out[76]: 969
#產生0到1之間的浮點隨機數可以使用random.random()
In [77]: random.random()
Out[77]: 0.4467371549631729

In [78]: random.random()
Out[78]: 0.870836619476411

In [79]: random.random()
Out[79]: 0.7285090986539235
#如果要得到由N個隨機位元位表示的整數，可以使用random.getrandbits()
In [81]: random.getrandbits(50)
Out[81]: 898644577661596

In [82]: random.getrandbits(50)
Out[82]: 825711475826498

In [83]: random.getrandbits(50)
Out[83]: 877330983329038

12、時間換算

#利用datetime模組來完成不同時間單位間的換算，timedelta例項完成時間間隔換算
In [103]: from datetime import datetime,timedelta
#當前時間加2天后的時間
In [104]: datetime.now() + timedelta(days=2)
Out[104]: datetime.datetime(2018, 11, 17, 14, 0, 16, 257925)
#當前時間加5小時後的時間
In [105]: datetime.now() + timedelta(hours=5)
Out[105]: datetime.datetime(2018, 11, 15, 19, 0, 49, 178027)
#當前時間加30秒後的時間
In [106]: datetime.now() + timedelta(seconds=30)
Out[106]: datetime.datetime(2018, 11, 15, 14, 2, 26, 290114)
#建立一個小時例項
In [109]: x = timedelta(hours=2)
#建立一個60秒的時間例項
In [110]: y = timedelta(seconds=60)

In [111]: c = x + y

In [112]: c.days
Out[112]: 0
#換算成秒
In [113]: c
Out[113]: datetime.timedelta(seconds=7260)
#換算成時間
In [114]: c.seconds / 3600
Out[114]: 2.0166666666666666
In [117]: c.total_seconds()
Out[117]: 7260.0

In [118]: c.total_seconds() / 3600
Out[118]: 2.0166666666666666

#建立時間例項
In [119]: a = datetime(2018,10,10)
#輸出10天后的時間
In [120]: print(a + timedelta(days=10))
2018-10-20 00:00:00
#建立時間例項
In [121]: b = datetime(2017,5,8)

In [122]: d = a - b
#兩個時間的時間差
In [123]: d
Out[123]: datetime.timedelta(days=520)

In [124]: d.days
Out[124]: 520
#時間差的秒數
In [125]: d.total_seconds()
Out[125]: 44928000.0

13、計算上週5的日期

from datetime import datetime,timedelta

weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

def get_previous_byday(dayname,start_date=None):
    if start_date is None:
        start_date = datetime.today()  #獲取當前時間

    day_num = start_date.weekday() #獲取時間的星期
    day_num_target = weekdays.index(dayname) #獲取查詢星期
    days_ago = (7 + day_num - day_num_target) % 7  #獲取日期差的天數
    if days_ago == 0:
        days_ago = 7
    target_date = start_date - timedelta(days=days_ago) #計算時間差
    return target_date


print('現在時間：',datetime.today())
print(get_previous_byday('Monday'))
print(get_previous_byday('Tuesday',datetime(2018,10,23)))
print(get_previous_byday('Saturday',datetime(2018,8,8)))
print(get_previous_byday('Friday'))

#
現在時間： 2018-11-15 15:41:03.775963
2018-11-12 15:41:03.775963
2018-10-16 00:00:00
2018-08-04 00:00:00
2018-11-09 15:41:03.775963

14、找出當月的日期範圍

from datetime import datetime,date,timedelta
import calendar

def get_month_range(start_date=None):
    if start_date is None:
        start_date = date.today().replace(day=1)
    else:
        start_date = start_date.replace(day=1) #替換輸入時間的日期為1得到開始時間
    _,days_in_month = calendar.monthrange(start_date.year,start_date.month) #calendar.monthrange()函式返回當月的第一個工作日和當月的天數
    end_date = start_date + timedelta(days=days_in_month) #起始時間加當月天數獲得截至時間
    a_day = timedelta(days=1)  #定義一天時間物件
    while start_date < end_date:
        print(start_date)
        start_date += a_day


get_month_range()
get_month_range(date(2018,10,23))

#
2018-10-01
2018-10-02
2018-10-03
2018-10-04
2018-10-05
2018-10-06
2018-10-07
2018-10-08
......

from datetime import datetime,timedelta

def date_range(start,stop,step):
    while start < stop:
        yield start
        start += step

for i in date_range(datetime(2018,10,15),datetime(2018,11,10),timedelta(hours=24)):
    print(i)

#
2018-10-15 00:00:00
2018-10-16 00:00:00
2018-10-17 00:00:00
2018-10-18 00:00:00
2018-10-19 00:00:00
2018-10-20 00:00:00
2018-10-21 00:00:00
2018-10-22 00:00:00
......

15、將字串轉換為日期

In [10]: from datetime import datetime

In [11]: date = '2018-11-16'
#將字串轉換為日期
In [12]: datetime.strptime(date,'%Y-%m-%d')
Out[12]: datetime.datetime(2018, 11, 16, 0, 0)
#獲取當前日期
In [13]: datetime.now()
Out[13]: datetime.datetime(2018, 11, 16, 10, 56, 7, 487189)

In [14]: z = datetime.now()
#將日期格式化為閱讀的日期形式
In [15]: datetime.strftime(z,'%A %B %d, %Y')
Out[15]: 'Friday November 16, 2018'
#使用自編寫函式來處理字串轉日期要比datetime.strptime()快很多
In [16]: def parse_ymd(s):
    ...:     year_s,mon_s,day_s = s.split('-')
    ...:     return datetime(int(year_s),int(mon_s),int(day_s))
    ...: 
    ...: 

In [17]: parse_ymd('2018-11-16')
Out[17]: datetime.datetime(2018, 11, 16, 0, 0)

16、處理涉及到時區的日期問題

In [24]: from datetime import datetime,time,date

In [25]: import pytz
#檢視中國時區
In [26]: pytz.country_timezones('cn')
Out[26]: ['Asia/Shanghai', 'Asia/Urumqi']
#建立中國時區物件
In [28]: tz = pytz.timezone('Asia/Shanghai')
#建立時間物件時指定時區
In [29]: datetime.now(tz)
Out[29]: datetime.datetime(2018, 11, 16, 13, 32, 59, 744669, tzinfo=<DstTzInfo 'Asia/Shanghai' CST+8:00:00 STD>)
#指定時區建立日期物件
In [30]: datetime(2018,11,16,tzinfo=tz)
Out[30]: datetime.datetime(2018, 11, 16, 0, 0, tzinfo=<DstTzInfo 'Asia/Shanghai' LMT+8:06:00 STD>)
#指定時區建立時間物件
In [31]: time(13,33,00,tzinfo=tz)
Out[31]: datetime.time(13, 33, tzinfo=<DstTzInfo 'Asia/Shanghai' LMT+8:06:00 STD>)
#本地化時間物件
In [33]: tz.localize(datetime.now())
Out[33]: datetime.datetime(2018, 11, 16, 13, 41, 28, 395602, tzinfo=<DstTzInfo 'Asia/Shanghai' CST+8:00:00 STD>)
#建立本地化時間物件
In [34]: loc_d = tz.localize(datetime.now())
#通過本地化時間物件轉化為其他時區時間
In [35]: loc_d.astimezone(pytz.timezone('America/New_York'))
Out[35]: datetime.datetime(2018, 11, 16, 0, 42, 43, 666067, tzinfo=<DstTzInfo 'America/New_York' EST-1 day, 19:00:00 STD>)
#轉換為UTC時間物件
In [36]: loc_d.astimezone(pytz.utc)
Out[36]: datetime.datetime(2018, 11, 16, 5, 42, 43, 666067, tzinfo=<UTC>)

In [37]: loc_d
Out[37]: datetime.datetime(2018, 11, 16, 13, 42, 43, 666067, tzinfo=<DstTzInfo 'Asia/Shanghai' CST+8:00:00 STD>)

In [38]: utc_d = loc_d.astimezone(pytz.utc)

In [39]: print(utc_d)
2018-11-16 05:42:43.666067+00:00
#將UTC時間轉換為合適的時區
In [40]: later_utc = utc_d + timedelta(minutes=30)

In [41]: print(later_utc.astimezone(tz))
2018-11-16 14:12:43.666067+08:00