快速上手 Python

## 通过 Homebrew 安装 python
$ brew install python3

## 查看 Python 的版本
$ python3 --version
Python 3.6.5 :: Anaconda custom (64-bit)

## 运行 *.py 的 Python 脚本文件
$ cat ~/scripts/first_script.py         # 显示 first_script.py 文件里的内容
print('Congratulations on running this script!!')

$ python3 ~/scripts/first_script.py     # 用 python3 运行 first_script.py 文件
Congratulations on running this script!!

## 直接输入命令 python ，不带任何文件和参数，会进入 interactive interpreter（交互式解释器），可进行各种 Python 的语法测试
$ python3
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>exit()
$

a = [1, 2, 3]
b = a        # b 和 a 指向同一个列表对象，而不是把 a 的内容复制给 b
b.append(4)  # 修改 b 的内容，a 也会一起改变
print(a)     # 输出 [1, 2, 3, 4]

# 如果函数参数有默认值，这个值又是可变对象时，容易出错
def foo(data=[]):
  data.append(1)
  return data

print(foo())  # [1]
print(foo())  # [1, 1] - 意外结果

## codes by chpwang - 2018-05-17 04:57:56

"""
任务3:
xxxxxx
"""

## 变量定义
x = 2 * 3

## 赋值
x = 12

## 变量定义还可以解析结构
l1 = [9, 8]
[u, v] = l1

print(u)  # 9
print(v)  # 8

## 匿名函数 x => x * x
lambda x: x * x

## 函数调用
(lambda x: x * x)(3)

## 函数定义
square1 = lambda x: x*x

def square2(x): return x*x

## 这里「缩进」很重要，python 靠缩进来判断函数体
## 如果函数体语句多，注意缩进要对齐，不能有的缩进 2 格，有的只缩进 1 格
## 「缩进」是一种危险的糟糕设计，容易出错，比如有时 return 缩进错了，可能就跑到外部去了
## 缩进设计似乎只是为了少写一些括号
def square3(x):
  return x*x


result1 = 10
result2 = 10

## square4 中的 result 是局部变量，不改变外面的 result
def square4(x):
  result1 = x*x
  return result

## 加了 global 关键词后，square5 中的 result 就是全局变量了
## 调用 square5 会改变外面的 result
def square5(x):
  global result
  result = x*x
  return result

print(square4(4))  # 16
print(result1)     # 10
print(square5(4))  # 16
print(result1)     # 16


## 函数也可以什么都不做，但要写一个 pass ，不能什么都不写
def do_nothing(x):
  pass

>>> def minus(x, y): return x - y
...
>>> minus(9, 6)
3
>>> minus(y=9, x=6)  # python 的函数调用可以指定参数的值，这样可以无视参数的调用顺序
-3                   # 好处是如果参数比较多，把各参数名和值写上，代码阅读起来就很直观 - 这是个好设计

def fib(n):
  if n == 0:
    return 0
  elif n == 1:
    return 1
  else:
    return fib(n-1) + fib(n-2)


if season == 'spring':
    print('plant the garden!')
elif season == 'summer':
    print('water the garden!')
else:
    print('unrecognized season')


## 三元操作符（Ternary Operator）写法
x = true_value if condition else false_value

## lambda 中的 if - 无法在 lambda 匿名函数中使用 print 打印，或者 raise 报错
lambda x: True if x % 2 == 0 else False

## Python 中的循环一般不用下标
>>> a = [2, 3, 4, 6]
>>> for x in a:
...  print(x)
...
2
3
4
6

## 可以使用这种模式匹配来直接取出 key 和 value 而不用后续访问下标 - 这是好设计
>>> for [k, v] in [["dog", 1], ["cat", 2], ["fish", 3]]:
...     print(f"{k}: {v}")
...
dog: 1
cat: 2
fish: 3

## 模式匹配（pattern match）还可以用于赋值，比如交换变量的数据
>>> [x, y] = [3, 4]
>>> x
3
>>> y
4
>>> [x, y] = [y, x]
>>> x
4
>>> y
3

## 和 range(start, stop, step) 函数结合使用
>>> for i in range(0, 2, 1):
...     print(i)
...
0
1

## 这里说明一下这个 range
## 可以认为 range(5) 的效果就相当于生成了一个 [0, 1, 2, 3, 4] 这样的 list
## 然后我们就可以 for i in range(5)
## 虽然效果上是一样的，但实际上 range 不会真的生成一个 list
## range 多用于循环，如果真生成一个 list ，就会影响计算性能并占用空间
## 比如这样一来 range(1000000) 就很吃计算资源了
## range 实际上生成的是一种 lazy list（惰性列表）
## 惰性列表的意思是，它不会真的给你放到内存里面去
## range(5) 会返回一个 range 对象，按需计算元素的值，内存高效（memory efficient）

## python 中的 for 循环都要用 for x in ... 这种形式，如果 x 是是数字，就要用这个 range
## 有人认为这样的 for 循环表达能力有限，不能表达复杂的逻辑，range 只能表达简单的数字
## 比如无法写出类似 for(var i=0, j=array.length; i < j; i++, j--) 的代码
## 但其实这是 python 的一个好设计。当表达不了的时候，就不应该使用 for 循环，而要改用 while 循环
## 上述复杂的 for 循环需要思考到底是先判断 i < j 还是先计算 i++ 和 j--，不利于代码阅读理解

## 用 reversed 配合 range 倒数
## 写成 for i in range(4, -1, -1) 虽然是同样的效果，但阅读理解上不直观
>>> for i in reversed(range(0, 5)):
...     print(i)
...
4
3
2
1
0

# 和 zip() 函数结合使用
>>> alist = ['a1', 'a2', 'a3']
>>> blist = ['b1', 'b2', 'b3']
>>> for a, b in zip(alist, blist):
...     print(a, b)
...
a1 b1
a2 b2
a3 b3

## upack 一个 list 也是常用的循环 - 若觉得下行的说明不清楚就开终端试一试
## 此例第 1 次循环取出第一个元素 [1, 3]，然后把第一项和第二项分别赋值给 a 和 b
>>> for a, b in [[1,3],[2,4]]:
...     print(a)
...     print(b)
...
1
3
2
4

## 使用 * （星号 star）和 zip 来操作 list
## 下划线符号：_ 在 Python 中代表占位符，相当于吃掉这两个位置的输出 - 下面的代码原本会输出 3 个结果，但只想要其中最后一个结果，所以使用下划线来抛弃前两个结果 
>>> _, _, rewards = zip(*[((6, 10, False), 1, 0), ((17, 10, True), 1, 0), ((21, 10, True), 0, 1.0)])
>>> rewards
(0, 0, 1.0)

## while 循环
>>> while i < 6:
...   print(i)
...   if i==3:
...     break
...   i += 1
...
1
2
3

## Map 没有定义 __init__ ，但还是程序还是会给它一个默认的 __init__
class Map:
  def print_data(self):
    print("'Map' object has no attribute 'data'") 


class Table:
  def __init__(self):
    self.data = []

  def add(self, key, value):
    self.data.insert(0, [key, value])

  def lookup(self, key):
    for [k, v] in self.data:
      if k == key:
        return v
    return None


class Hash:
  def __init__(self):
    self.data = {}

  def add(self, key, value):
    self.data[key] = value

  def lookup(self, key):
    return self.data[key]

## 普通输出 - 使用 {} 占位，.format() 填充占位符
>>> print("{} ~ {}% dog wins.".format(3, 9))
3 ~ 9% dog wins.

## 保留 5 位小数
>>> print("{} - {:.5f}".format(3,9.0/3.5))
3 - 2.57143

## 保留 1 位小数
>>> print("{} - {:.1f}".format(3,9.0/3.5))
3 - 2.6

name = "Alice"
age = 30
height = 1.75

print(f"My name is {name}, I am {age} years old.")    # 使用 f-string 插入变量值
# My name is Alice, I am 30 years old.

print(f"Next year, I will be {age + 1} years old.")   # 可以在 f-string 中进行简单的表达式计算
# Next year, I will be 31 years old.

print(f"My height is {height:.2f} meters.")           # 使用 f-string 格式化浮点数
# My height is 1.75 meters.

## test.py
num = 30
x = eval("num + 29")
print(x)

$ python test.py
59

## demo.py
import useful_functions as uf

scores = [88, 92, 79, 93, 85]
mean = uf.mean(scores)

print("Demo Mean:", mean)
print("__name__ value:", __name__)
print("uf.__name__ value:", uf.__name__)

## useful_functions.py

def mean(num_list):
    return sum(num_list) / len(num_list)

def main():
    n_list = [34, 44, 23, 46, 12, 24]
    print("Useful Functions' Mean:", mean(n_list))

# 检测当前脚本（即 useful_functions.py）是否做为主模块被运行
# 当前脚本若是被其他脚本的 import 语句导入，则下面的 if main 块代码不运行
if __name__ == '__main__':
    main()

$ ls
demo.py             useful_functions.py
$ python demo.py
Demo Mean: 87.4
__name__ value: __main__
uf.__name__ value: useful_functions

import math
from decimal import Decimal, getcontext

## 设置 Decimal 数据类型的小数点后保留的位数
getcontext().prec = 19
## 用来辅助判断一个数是否为零（小于此值则为零）
TOLERANCE = 1e-10

class Vector(object):
  
  ## 设置报错信息
  ALL_ELEMENT_MUST_BE_NUM_MSG = "Element must be number!"

  ## 实例（instance）的创建
  def __init__(self, coordinates):
    try:
      if not coordinates:
          raise ValueError
      self.coordinates = tuple([Decimal(x) for x in coordinates])
      self.dimension = len(coordinates)

    except ValueError:
      raise ValueError('The coordinates must be nonempty')

    except TypeError:
      raise TypeError('The coordinates must be an iterable')

  ## print 输出内容
  def __str__(self):
    return 'Vector: {}'.format(self.coordinates)

  ## 定义相等
  def __eq__(self, v):
    return self.coordinates == v.coordinates

  def __len__(self):
    return len(self.planes)

  ## __getitem__ 这个函数使得对于 v = Vector([5, 3, -2]) ，可使用索引方式 v[1] 得到数字 3
  def __getitem__(self, i):
    return self.coordinates[i]

  ## __setitem__ 这个函数使得对于 v = Vector([5, 3, -2]) ，可使用索引方式 v[1] = 9 将 v[1] 的值设置为 9
  def __setitem__(self, i, x):
    try:
      assert x.dimension == self.dimension  # 如果设置的 x 不是数字，则报错
      self.coordinates[i] = x

    except AssertionError:
      raise Exception(self.ALL_ELEMENT_MUST_BE_NUM_MSG)

  ## 计算向量的加法
  def plus(self, v):
    new_coordinates = [x+y for x,y in zip(self.coordinates, v.coordinates)]
    return Vector(new_coordinates)

  ## 计算向量的减法
  def minus(self, v):
    return self.plus(v.times_scalar(-1))

  ## 计算向量的数乘
  def times_scalar(self, c):
    new_coordinates = [x*c for x in self.coordinates]
    return Vector(new_coordinates)

  ## 计算向量与另一向量的点积（内积）
  def dot_product_with(self, v):
    new_coordinates = [x*y for x,y in zip(self.coordinates, v.coordinates)]
    return sum(new_coordinates)

  ## 计算向量的模
  def magnitude(self):
    return Decimal(math.sqrt(self.dot_product_with(self)))

  ## 计算向量标准化后的向量（同方向上的单位向量）
  def normalization(self):
    try:
      mag = self.magnitude()
      return self.times_scalar(Decimal(1)/mag)
    except ZeroDivisionError:
      #print("You can't normalize Zero Vector!")
      raise Exception("You can't normalize Zero Vector!")

  ## 计算向量与另一向量的夹角
  def angle_with(self, v, in_degrees=False):
    try:

      mag_1 = self.magnitude()
      mag_2 = v.magnitude()
      if in_degrees:
        return math.degrees(math.acos(self.dot_product_with(v)/(mag_1*mag_2)))
      else:
        return math.acos(self.dot_product_with(v)/(mag_1*mag_2))

    except ZeroDivisionError:
      #print("At least one of the vector is Zero Vector! No angle defined.")
      raise Exception("One of the vector is Zero Vector! No angle defined.")

  ## 私有函数（private function）和变量，以两个下划线开头来命名
  def __is_zero_vector(self):
    return self.magnitude() < TOLERANCE
  
  def is_parallel_to(self, v):
    if v.__is_zero_vector() or self.__is_zero_vector():
      return True
    else:
      s_m = self.normalization()
      v_m = v.normalization()
      return s_m.minus(v_m).__is_zero_vector() or s_m.plus(v_m).__is_zero_vector() 

  def is_orthogonal_to(self, v):
    return abs(self.dot_product_with(v)) < TOLERANCE

  ## 向量的分解 - 计算向量水平方向的分量
  def component_parallel_to(self, base_vactor):
    u_b = base_vactor.normalization()
    mag = self.dot_product_with(u_b)
    return u_b.times_scalar(mag)

  ## 向量的分解 - 计算向量竖直方向的分量
  def component_orthogonal_to(self, base_vactor):
    c_p = self.component_parallel_to(base_vactor)
    return self.minus(c_p)

  ## 计算向量与另一向量的叉乘
  def cross_product_with(self, v):
    if self.dimension != 3 or v.dimension != 3:
      raise Exception("Both cross product vectors must be three dimensional")
    
    if self.is_parallel_to(v):
      return Vector([0 for i in range(self.dimension)])
    else:
      x = self.coordinates[1]*v.coordinates[2] - self.coordinates[2]*v.coordinates[1]
      y = self.coordinates[2]*v.coordinates[0] - self.coordinates[0]*v.coordinates[2]
      z = self.coordinates[0]*v.coordinates[1] - self.coordinates[1]*v.coordinates[0]
      return Vector([x, y, z])
  
  ## 计算向量与另一向量的所围成的四边形的面积
  def area_of_parallelogram_spanned_with(self, v):
    new_self = self
    new_v = v
    if self.dimension == 2:
      new_self = Vector(self.coordinates + (0,))
    if v.dimension == 2:
      new_v = Vector(v.coordinates + (0,))

    return new_self.cross_product_with(new_v).magnitude()
  
  ## 计算向量与另一向量的所围成的三角形的面积
  def area_of_triangle_spanned_with(self, v):
    return self.area_of_parallelogram_spanned_with(v) / Decimal(2)