Python Study

Introduction

When

Python is a widely used high-level programming language for general-purpose programming, created by Guido van Rossum and first released in 1991.
Python第一版发布于1991年，由Guido van Rossum编写。

What

An interpreted language, Python has a design philosophy which emphasizes code readability (notably using whitespace indentation to delimit code blocks rather than curly brackets or keywords), and a syntax which allows programmers to express concepts in fewer lines of code than possible in languages such as C++ or Java.[22][23] The language provides constructs intended to enable writing clear programs on both a small and large scale.
首先我们要知道Python跟Lua一样，是解释型语言(不需要编译，通过解析执行，有自己的解析器)。Python设计理念强调可读性(通过缩进而非{}来表示代码块)。

Python features a dynamic type system and automatic memory management and supports multiple programming paradigms, including object-oriented, imperative, functional programming, and procedural styles.
Python是动态类型语言，同时有自己的内存管理机制，支持多种编程范式(待深入学习了解)。

Why

了解了Python When & What。那么我们Why什么要选择学习使用Python了？
Python is powerful… and fast; plays well with others; runs everywhere; is friendly & easy to learn; is Open.
supports multiple programming paradigms. It has a large and comprehensive standard library.[25]
把上面可以归纳如下:

1. Run everywhere(跨平台)
2. Friendly & easy to learn(学习更友好更容易(对于无编程经验的人更加友好，语法更nature))
3. Supports multiple programming paradigms(支持多种编程范式)
4. Large and comprehensive standard library(丰富的标准库和Package)

Note:
这里提一句Python里很有名的一句话:
“Life is short, you need python.”

IDE & Editor

学习任何一门编程语言，好的IDE或者Editor都能帮助我们更加快速的学习。
因为初学Python且Python是解析执行，这里暂时不考虑过于强大的IDE。
IDE详情选择可以参考Python IDE
这里通过使用Sublime Text 3以及其Python相关的扩展插件作为学习Python的Editor。
Sublime Text 3 Python相关插件设置详情

Python Version Choosen

Python有一个比较重要版本分割线2.x & 3.x。
详情参见Python2orPython3
这里就不深入去了解2.x和3.x之间的区别了。
简单的理解就是3.x提供了更多更全的功能支持，同时有更多的丰富的库支持。如果作为初学者，并不需要维护老版本(2.x)的工具代码时，完全可以从3.x学起。

Useful Package

Pip

Python有丰富的标准库。而其中最重要也是新手第一时间就应该安装的就是Pip。
Pip对于Python就好比Package Control好比Sublime Text 3。
Pip(Python Package Index)是一个Python Package集中管理安装的扩展包。
Pip安装详情参考官方文档
Pip安装成功后我们就可以通过Pip去查看或安装丰富的Python Package了。
Package Install:

Show Intalled Packages:

安装之后的Package可以在安装目录查看到:

更多关于Pip使用查看官方文档

argparse

详细的介绍会在后面Tip的Command Line Args篇章

Tutorial(基础篇)

Introduction

Keywords and Identifier

Identifier(标识.e.g funcname, variable ……)定义规则:

1. Keywords不能用做变量声明(这应该是任何语言都通用的规范了吧)
2. 变量名不能以数字开头
3. 变量名不能用特殊符号(e.g. !, @, #, $, %)
   简单了解下Python的关键词：
   

Note:
Python is a case-sensitive language. This means, Variable and variable are not the same. Always name identifiers that make sense.
Python是大小写敏感的，大小写不同的变量名是不同变量。

Statements & Comments

Instructions that a Python interpreter can execute are called statements.
Python可解析执行的语句叫做Statements。
多行Statements可以通过\或者[]或者{}或者()链接或封装：

1
2
3
4
5

a = 1 + 2 + \
    3 + 4 + \
    5 + 6

b = (1 + 2 + 3 + 4)

Python设计理念强调可读性(通过缩进而非{}来表示代码块)：
同时Python注释是通过# or ‘’’ or “””:

1
2
3
4
5
6
7
8

for i in range(5):
    if i >= 5:
        print("{0} >= 5".format(i))
        break
else:
    # No break happends in for loop
    # Then execute this block
    print("No number is equal or greater than 5!")

Docstring(Docstring is short for documentation string):
可以看出Docstring是一段文档描述(好比在C#里通过///编写描述信息一样)。Python在书写格式上要求比较严，虽然不会导致报错，但会算作不是规范的写法，这也就是我们为什么会去安装Sublime Text 3 flake8这样的linter插件了。

1
2
3
4
5
6

def addition(par1, par2):
    """This funtion is used to get result of (a + b)."""
    return par1 + par2

print(addition(1, 2))
print(addition.__doc__)

可以看到我们定义了一个加法函数，并编写了docstring。
通过func_name.__doc__我们可以得到那段描述

Python I/O and Import

Python里的输入输出交互(好比C++里的cin,cout)是通过input和print。
因为需要交互所以需要在可执行Python代码的terminal里执行python脚本:

因为Python的import是指import Module，我们需要知道Python里Module的定义，
Modules refer to a file containing Python statements and definitions.
Modules在Python里是指一个文件所包含的所有定义和声明(以文件为单位划分，文件名即为import的名字)。

在import Module还有一个重要的点就是，我们需要知道Python查找所有*.py的搜索路径(跟环境变量有点像):

1

print("sys.path:{0}".format(sys.path))

我们可以指定只导入特定定义(e.g. from math import pi)

Note:
Python的Module和C#的namespace概念不一样，前者是以文件为单位，后者是以命名空间划分(支持在多个文件里定义在同一命名空间下)

Python Operators

运算符跟大多数编程差不多，这里只讲几个比较特殊的:
Logical Operators:

1
2
3
4

x = True
y = False
print(x and y)
print(x or y)

或许跟Python提倡简洁明了有关，可以直接采用and or not之类的逻辑运算符

Identity operators：

1
2
3
4
5
6
7
8
9

x1 = 1
y1 = 1
print("x1 is y1 = ", x1 is y1)
y1 = 2
print("After y1 = 2. x1 is y1 = ", x1 is y1)

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print("list1 is list2 = ", list1 is list2)

Note:
is and is not are used to check if two values (or variables) are located on the same part of the memory.
List可以理解成分配了不同的内存去存储实际成员值所以是不同identity，上面x1 = 1和y1 = 1是located on the same part of the memory就需要理解后续会讲到的[Namespaces概念](http://tonytang1990.github.io/2017/06/12/Python-Study/#Object & Class)

Membership operators:

1
2
3

list3 = [1, 'T', 'H']
print('T' in list3)
print(1 not in list3)

Note:
in & not in are used to test whether a value or variable is found in a sequence (string, list, tuple, set and dictionary).
in & not in 主要是用于判断特定变量或者值是否存在于特定sequence里。

Flow Control

if,elif,else,while,for这里主要记录一些Python相对于C++,C#,Java这些语言里的一些区别。

Python里是以:结束条件语句，以缩进表示层级。
while和for有一点比较特殊，支持else语句(没有break语句执行时)。

1
2
3
4
5
6
7
8

for i in range(5):
    if i >= 5:
        print("{0} >= 5".format(i))
        break
else:
    # No break happends in for loop
    # Then execute this block
    print("No number is equal or greater than 5!")

Function

Python的Function定义关键词是def，格式如下：

1
2
3

def func_name(paras):
    """Docstring"""
    Statements

Python支持显示传递参数，也支持默认参数和不限数量参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# User-defined functions
def my_python_function(para1, dp1="dp1", dp2="dp2"):
    """My Python Function Docstring."""
    # Build-in functions
    print("my_python_function(para1:{0} dp1:{1} dp2:{2})".format(para1, dp1, dp2))

my_python_function("Tony")

# Keyword para call
my_python_function(dp1="ndp1", para1="Tang")


# Parameters without length limited
def arbitrary_para_function(*paras):
    """ Python function without length of parameter limitation."""
    for para in paras:
        print(para)

arbitrary_para_function("para1", "para2", "para3")

Python也支持匿名函数(Lambda Function),只是不像C++，C#使用(x)=>表示而是lambda x:

1
2

sqrfunc = lambda x: x * 2
print(sqrfunc(2))

Modules

C,C++里有#include。C#有using。Java有import。Python里有Modules。
但Python里的Modules更像C,C++是针对文件为单位。
使用的时候通过import filename即可(也支持指定别名 as newname)

1
2
3

def my_first_python_func():
    """MyFirstPython.py's function."""
    print("my_first_python_func() called")

1
2
3

import MyFirstPython as MFP

MFP.my_first_python_func()

知道了Python是以文件为单位导入的，那么我们也需要知道Python导入文件时的搜索路径(通过打印sys.path即可)

Note:
Python也支持只导入指定文件里的指定对象
e.g.

1

from math import pi

Package

C++，C#里有namespace。Java有package。Python里有Package(相当于Java里package和C#里namespace概念，负责抽象对应Directory到指定Package里)
Steps:

1. 创建文件夹(文件夹名作为Package Name)
2. 文件夹目录下创建一个__init__.py文件(默认可以不写任何内容)
3. 通过import PackageName.Module引入特定文件
   e.g.

1

import MyPackage.MyFirstPython

Note:
Package是针对Directory而言，Module是针对file而言

Datatypes

Variable变量赋值在Python里简单明了:

1
2
3

p1 = 1
p2, p3, p4 = 2, 3, "Tony"
print(p1, p2, p3, p4)

判断数据类型Python是通过type()这个类似C#GetType()。
判断是否是某个类型实例Python是通过isinstance()，类似于Python里的is关键词。

1
2
3
4
5
6
7
8
9
10
11

class MyClass:
    """My first class."""

    name

myclassinstance = MyClass()
myclassinstance.name = "Tony"
mystring = "Tony"
print(myclassinstance, " is typeof ", type(myclassinstance))
print("myclassinstance is typeof MyClass:", isinstance(myclassinstance, MyClass))
print(mystring, " is typeof ", type(mystring))

可以看出在Python是弱语言类型，声明变量是无需显示指定变量类型。
同时通过type和isinstance可以判断实例对象类型。

Note:
这里的Data Type是指实例对象的类型，Python是弱类型语言。

Basic Data Types

Python支持大部分基本数据类型，e.g. int, float等。
有一点比较特殊的是Python支持complex numbers(复数)：x + yj(x为实部，yj为虚部)

1
2

cn = 2 + 3j
print("cn = {0}".format(cn))

同时表示不同进制的Number只需添加不同前缀即可：

List

List is an ordered sequence of items. It is one of the most used datatype in Python and is very flexible. All the items in a list do not need to be of the same type.
Python的List好比数组，但是更灵活，可存储不同类型的对象。

1
2
3

pythonList = [1, "a", 3.0, True]
for member in pythonList:
    print(member, " is typof ", type(member))

更多的List处理参见List.Method和其他Build-in Functions(比如len(),sorted()等)

Note：
List是通过[]定义。

Tuple

Tuple is an ordered sequence of items same as list.The only difference is that tuples are immutable. Tuples once created cannot be modified.
Tuple和List的唯一区别就是创建后不可再被改变，但如果内嵌可变的(e.g. List)那么List的数据是可以被改变的。Tuple是通过()定义内容。

1
2
3
4
5
6

my_tuple = (1, "string", [1, "th"])
my_tuple[2][0] = 2
for tuplemember in my_tuple:
    print(tuplemember)
del my_tuple
# my_tuple -- Error: name 'my_tuple' is not defined

从上面可以看出del关键词可以删除变量的引用。

Note：
Tuple是通过()定义。
Tuple相比List更适合用于存储固定的不同数据类型的数据。
Everything is object in Python.(这一点跟Java，C#一样)

Strings

1
2
3
4

mypythonstring = "我的名字是TonyTang"
print(mypythonstring)
print(mypythonstring[0])
mypythonstring[0] = '你'

Note:
String is sequence of Unicode characters. Strings are immutable
Python里是采用Unicode编码存储字符串。Strings可以通过[]访问，但是不可被改变的。
We cannot delete or remove characters from a string. But deleting the string entirely is possible using the keyword del.因为string是immutable的，所以我们不能通过del删除string里面的个别character，但是我们可以删除对string的整个引用。

Set

Set is an unordered collection of unique items. Set is defined by values separated by comma inside braces { }. Items in a set are not ordered.
Set也是一系列数据的集合类型，但是是无序的。

1
2
3

mySet1 = {1, "a", 2, "b", 1}
for member in mySet1:
    print("member in mySet1:{0}".format(member))

可以看出因为Set是无序的，连循环遍历出来的结果也是不确定的。所以针对Set，[]访问就是无意义也是不被允许的。

Every element is unique (no duplicates) and must be immutable (which cannot be changed).
Set还有一点特性就是成员是唯一且不可变的同时支持类似于集合与或等操作:

1
2
3
4
5
6

mySet2 = {"a", 2, "b"}
for member in (mySet1 & mySet2):
    print("member in (mySet1 & mySet2):{0}".format(member))

for member in (mySet1 - mySet2):
    print("member in (mySet1 - mySet2):{0}".format(member))

Note：
Set是通过{}定义。
更多操作参考Set.API

Dictionary

Dictionary is an unordered collection of key-value pairs.
Python里的Dictionary跟C#里的Dictionary差不多，代表无序的Key-Value主键值对。

1
2
3

myDictionary = {1: "Tony", "Tang": 2}
print(myDictionary[1])
print(myDictionary["Tang"])

可以看出Python里Dictionary的键值对定义时通过:分割，然后通过[]去方案对应Key得到Value值。

Note：
Dictionary是通过{}定义。
更多操作参考Dictionary.API

Conversion between data types

基础数据类型转换通过int,float,complex显示转换即可：

1
2
3
4
5

myint = int(2.5)
print(myint)
mylist = list('hello')
for member in mylist:
    print(member)

Files

File Operation

首先看看最新官方文档给出的API说明:
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

1
2
3
4
5
6
7
8
9
10
11
12
13

# try: finally: Make sure f close successfully
# specify encoding='utf-8' is used to avoid platform dependent problems
try:
    f = open("./FilesFolder/TonyTangFile.txt", mode='r', encoding='utf-8')
    for line in f:
        print(line)
finally:
    f.close()

# Another way to make sure file close successfully
with open("./FilesFolder/TonyTangFile.txt", mode='w', encoding='utf-8') as f:
    # Do file operation here
    f.write("Flow my heart!\nI have a dream!")

从上面可以看到，open的几个关键参数，mode决定了可读还是可写等模式，encoding决定编码格式是为了确保不同平台脚本的一致性。

Directory

Python提供了os module支持很多文件夹目录操作的API

1
2
3
4
5
6
7
8
9
10
11
12
13

import os

print(os.getcwd())
print(os.listdir())
os.chdir("./FilesFolder")
print(os.getcwd())
if os.path.exists("MyNewFilesFolder") == False:
    os.mkdir("MyNewFilesFolder")
print(os.listdir())
if os.path.exists("MyRenameFilesFolder") == True:
    os.removedirs("MyRenameFilesFolder")
os.rename('MyNewFilesFolder', 'MyRenameFilesFolder')
print(os.listdir())

从上面可以看出Python的API都很简洁明了，跟bat，shell很像，具体使用过程中主要还是按需求差文档写自己的自动化即可。

Exception

Python Exception
Exception Handling
User-defined Exception

Object & Class

Name

Name (also called identifier) is simply a name given to objects.

1
2
3
4
5
6
7
8
9
10
11

a = 2
print('id(2) = ', id(2))
print('id(a) = ', id(a))

a = a + 1
print('id(a) = ', id(a))
print('id(3) = ', id(3))

b = 2
print('id(2) = ', id(2))
print('id(b) = ', id(b))

id()适用于打印object地址，从上面的输出可以看到只要Name指向Object的值是一致的，那么他们所指向的地址就是一致的。详情参考下图:

This is efficient as Python doesn’t have to create a new duplicate object. This dynamic nature of name binding makes Python powerful; a name could refer to any type of object.

Note:
Everything in Python is an object.

1

import this

上面这段代码很有意思，会在控制台打印出Python的编程哲学:

Namepsace & Scope

namespace is a collection of names.(前面讲解了什么是Name，接下来要理解的Namespace就好比一系列Name的集合)
我们平时用到的Build-in Functions就属于Build-in Namespace里。
让我们结合下图看看Python里Namespace的层级：

讲完Namespace，Python里还有一点跟Namespace密切相关的Scope:
Scope is the portion of the program from where a namespace can be accessed directly without any prefix.(Namespace在Python就好比C++,C#里的namespace。Scope就好比C++,C#里变量的有效区域。)

现阶段主要分为3中Scope:

1. Scope of the current function which has local names(当前function scope)
2. Scope of the module which has global names(全局scope)
3. Outermost scope which has build-in names(最外层Build-in scope)

接下来透过实例学习理解Python里的Scope:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def outer_function():
    """Outer Function."""
    a = 20

    def inner_function():
        """Inner Function."""
        global a
        a = 30
        print("a = ", a)

    inner_function()
    print("a = ", a)

a = 10
outer_function()
print("a = ", a)

可以看出在Function内的定义因为在不同的Scope不会覆盖Global Scope的a定义。当我们显示指定Function Scope里的a为global的a时，我们可以在Function Scope内引用到Global的a。

Class

接触过面向对象编程的人应该对Class都不陌生，他是我们抽象对象定义的关键类型。
在面向对象编程语言的Python里Class也起着同样的作用，只不过定义的方式有所区别，详情如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class MyFirstClass(object):
    """docstring for MyClass"""

    def __init__(self, arg):
        """Class Constructor."""
        super(MyFirstClass, self).__init__()
        self.name = arg

    def sayhi(self):
        """Class Member Function."""
        print("Hello World!")

    def printname(self):
        """Print name member."""
        print("self.name = ", self.name)

# 这里因为我是定义在MyFirstPython.py文件里的，所以导入的是MyFirstPython
import MyFirstPython
mfp = MyFirstPython.MyFirstClass("Tony")
mfp.sayhi()
mfp.printname()
print(mfp.name)
mfp.age = 10
print(mfp.age)
del mfp.name
# mfp.printname() AttributeError: 'MyFirstClass' object has no attribute 'name'
del mfp
# mfp.sayhi() NameError: name 'mfp' is not defined

从上面可以看出Python里Class的定义格式如下:

1
2
3
4
5
6
7
8
9

def classname(父类):
    """Docstring Class description."""
    def __init__(self,arg):
        """Docstring Constructor description."""
        # constructor's body

    def functionname(arg):
        """DocString Member Function description."""
        # body

__init__就好比C++里的构造函数。
Python里的继承写法:classname()括号里面跟的是父类，在子类可以通过super去访问父类。
值得一提的是Docstring，每一个类或者方法都有Docstring，我们可以通过classname.__doc__的方式去访问。
同时我们看到Python里还可以在运行时动态定义成员变量(e.g. mfp.age)
Python里不是通过new关键词去实例化类对象，但del关键词就好比C++里和new配对的delete，但这里的delete不仅是针对new出来的实例化对象进行回收，还能针对特定实例化成员进行删除。(当我们del mfp实例对象时，我们只是把mfp的对于Object的引用从corresponding namespace里移除而非真的销毁内存里Object。真正的销毁是发生在没有人在绑定到该Object时。)

This automatic destruction of unreferenced objects in Python is also called garbage collection.(真正的销毁就好比C++里的GC对内存进行释放)

Note:
Python is an object oriented programming language.

Inheritance

Like C++, a class can be derived from more than one base classes in Python. This is called multiple inheritance.

关于继承这里就不多讲了，大家参考文档介绍。

Operator Overloading

Operator Overloading翻译过来应该是运算符重载。

在了解Operator Overloading之前，让我们来了解下Python Class里的一些特殊方法。

这里的特殊方法学过lua的同学应该会感到很亲切:

1. new – New一个Class的实例对象时会被调用
2. init – Class的构造函数(父类构造函数需要手动调用，默认不递归调用)
3. del – Class实例对象销毁时调用(类似C#析构函数)
4. class – 访问类的静态变量的时候(实例对象可以直接通过self访问)
5. str – str()，format()以及print()函数触发Class获取字符串表达方法
6. lt – <运算符操作时调用
7. le – ==运算法操作时调用
8. hash – hash()方法计算Class实例对象Hash值时
9. getattr – 访问Class成员不能存在时调用(类似Lua的__index元方法)
10. setattr – 设置Class成员值时调用(类似Lua的__newindex元方法)
11. ……

更多特殊方法参考:Special method names

从上面可以看出Python和Lua有很多相似的地方。

接下来让我们看看实战效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# MyFirstPython.py
# File Name: 		MyFirstPython.py
# Description: 		This file is used to study python
# Author:  			TangHuan
# Create Date:  	2017/6/5

import shutil

class MyFirstClass(object):
	"""docstring for MyClass"""
	# class Static Member
	age = 10
	
	# 构造函数
	def __init__(self, name):
		"""Class Constructor."""
		super().__init__()
		print("MyFirstClass:__init__({})".format(name))
		self.name = name

	# str()，format()以及print()函数触发
	def __str__(self):
		return "MyFirstClass name:{} age:{}".format(self.name, self.age)

	# 获取不存在成员时触发
	def __getattr__(self, name):
		print("MyFirstClass:__getattr__({}) not exist!".format(name))

	# 设置成员值时触发
	def __setattr__(self, name, value):
		super().__setattr__(name, value)
		print("MyFirstClass:__setattr__({}, {})!".format(name, value))

	# 加号运算符重载
	def __add__(self, other):
		newName = self.name + other.name
		return MyFirstClass(newName)
	
	def sayhi(self):
		"""Class Member Function."""
		print("MyFirstClass:sayhi() Hello World!")

	def printname(self):
		"""Print name member."""
		print("MyFirstClass:printname() self.name = ", self.name)


def my_first_python_func():
	"""MyFirstPython.py's function."""
	print("my_first_python_func() called")

1
2
3
4
5
6
7
8
9
10
11
12
13

# Class e.g.
mfp = MyFirstPython.MyFirstClass("Tony")
print(mfp.__class__.age)
mfp.sayhi()
mfp.printname()
print(mfp.name)
print(mfp.noneexitname)
mfp.age = 10
print(mfp.age)
print(mfp)
mfp2 = MyFirstPython.MyFirstClass("Tang")
tempMfp = mfp + mfp2
print(tempMfp)

通过上面的学习用例，可以看到我们通过自定义__init__,str,getattr,setattr,__add__等特殊方法实现了类构造，类成员自定义访问设置，类+运算符重载，类print()等方法自定义输出等效果。看到这里，不得不说Python特殊方法和Lua的元方法概念很像。

Iterator

Iterator in Python is simply an object that can be iterated upon. An object which will return data, one element at a time.

这里的Iterator和C#里的迭代器应该是一个概念。实现迭代器需要实现两个特殊方法(iter__和__next)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# File Name: 		IteratorStudy.py
# Description: 		This file is used to study python iterator
# Author:  			TangHuan
# Create Date:  	2021/5/25

# 迭代器类
class IteratorClass(object):
	"""Class to implement an iterator"""

	# 构造函数
	def __init__(self, max):
		super().__init__()
		self.max = max

	# 返回迭代器
	def __iter__(self):
		print("IteratorClass:__iter__()")
		self.n = 0
		return self

	# 迭代器MoveNext
	def __next__(self):
		print("IteratorClass:__next__()")
		if self.n <= self.max:
			value = self.n
			self.n += 1
			return value
		else:
			raise StopIteration

iteratorClassInstance = IteratorClass(5)
for iter in iteratorClassInstance:
	print(iter)

Generator

Python generators are a simple way of creating iterators. Simply speaking, a generator is a function that returns an object (iterator) which we can iterate over (one value at a time).

It is fairly simple to create a generator in Python. It is as easy as defining a normal function, but with a yield statement instead of a return statement.

看介绍Generators的概念和C#的携程差不多。

Generator和普通方法的区别:

1. Generator function contains one or more yield statements.
2. When called, it returns an object (iterator) but does not start execution immediately.
3. Methods like __iter__() and __next__() are implemented automatically. So we can iterate through the items using next().
4. Once the function yields, the function is paused and the control is transferred to the caller.
5. Local variables and their states are remembered between successive calls.
6. Finally, when the function terminates, StopIteration is raised automatically on further calls.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Generator
GeneratorVariable = 0
def GeneratorFunction():
	global GeneratorVariable
	print("GeneratorFunction() {}".format(GeneratorVariable))
	yield GeneratorVariable
	GeneratorVariable += 1
	print("GeneratorFunction() {}".format(GeneratorVariable))
	yield GeneratorVariable
	GeneratorVariable += 1
	print("GeneratorFunction() {}".format(GeneratorVariable))
	yield GeneratorVariable
	
GeneratorFunc = GeneratorFunction()
print("GeneratorFunction Start")
for generator in GeneratorFunc:
	print(generator)

可以看到Generator在Python里还能直接通过for循环的形式便利这一点和C#的携程还不太一样。

通过Generator我们可以简化自定义Iterator的写法，无需自定义__iter__和__next__方法，通过自定义的Generator方法即可实现迭代效果。Generator更多好处参考:Generator

Closure

Closure指类似传统语言里的闭包，但在Python里有几个较大的区别：

1. 闭包访问外围变量时，默认是只读的，需要通过nonlocal关键字来标识闭包内部可写。
2. 闭包必须是嵌套函数定义
3. 嵌套函数必须访问外部成员
4. 外围函数必须返回嵌套函数自身

Python里用闭包的好处：

Closures can avoid the use of global values and provides some form of data hiding. It can also provide an object oriented solution to the problem.

Decorators

A decorator takes in a function, adds some functionality and returns it.

看介绍Decorator像是设计模式里的修饰器概念，能够做到给现有功能添加额外功能的作用。

看介绍利用万物皆object的概念(类似Lua里第一类值)的概念，实现封装函数调用实现扩展函数功能。

还有更多更复杂的使用方式，详情参考:Decorators

Note:

1. everything in Python (Yes! Even classes), are [objects].

Property

Property类似于C#里的属性概念。Python通过关键字@property实现属性的快速定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# File Name: 		PropertyStudy.py
# Description: 		This file is used to study python property
# Author:  			TangHuan
# Create Date:  	2021/5/25

# 属性类
class PropertyClass(object):
	"""Class to implement an property"""

	# 构造函数
	def __init__(self, propertyvalue):
		super().__init__()
		print("PropertyClass.__init__()")
		self.Property = propertyvalue

	@property
	def Property(self):
		print("Getting Property Value : {}".format(self._Property))
		return self._Property

	@Property.setter
	def Property(self, value):
		print("Setting Property Value : {}".format(value))
		self._Property = value

propertyClassInstance = PropertyClass(5)
print(propertyClassInstance.Property)
propertyClassInstance.Property = 10
print(propertyClassInstance.Property)

更多学习参考:[Property][https://www.programiz.com/python-programming/property]

RegEx

Date and Time

Process

multiprocessing is a package that supports spawning processes using an API similar to the threading module.

threading module constructs higher-level threading interfaces on top of the lower level _thread module.

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several older modules and functions：os.system os.spawn*

从介绍可以看出，multiprocessing包是用于支持多进程类似多线程功能的模块。

threading是多线程的一个上层抽象模块。

multiprocessing是多进程的一个上层抽象模块(相比threading，不受限于**Global Interpreter Lock(多线程锁，限定同时只有一个Thread执行)**可以真正利用多核来跑多进程功能。

subprocess模块是封装的更好的一个创建使用子进程的模块，同时提供了和子进程处理交互相关的接口。

这里我们重点学习process相关即multiprocessing和subprocess相关概念和使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

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

"""
	File Name: 		MultiProcessStudy.py
	Description: 		This file is used to study python subprocess
	Author:  			TangHuan
	Create Date:  	2021/8
"""

import os
import subprocess
import time
import random
from multiprocessing import Pool

def process_task(subProcessName):
	print("subProcessName:{0} Process pid:{1}".format(subProcessName, os.getpid()))
	start = time.time()
	time.sleep(random.random())
	end = time.time()
	print("SubProcess:{0} Process pid:{1} runs:{2} seconds!".format(subProcessName, os.getpid(), end - start))

if __name__=='__main__':
	print("MultiProcessStudy")
	# 打印主进程id
	print("Current Process pid:{0}".format(os.getpid()))

	# 创建4个多进程(子进程)的进程池
	p = Pool(4)
	for i in range(5):
		p.apply_async(process_task, args=("SubProcess{0}".format(i),))
	print("Waiting for all subprocesses done.")
	# 停止提交更多的任务到p里
	p.close()
	# 等待p里的所有子线程任务完成
	p.join()
	print("All subprocesses done.")

	# SubProcess的方式开启子进程1
	subProcess1 = subprocess.Popen(['python', 'SubProcess1.py'])
	print("start SubProcess1")
	# SubProcess的方式开启子进程2
	subProcess2 = subprocess.Popen(['python', 'SubProcess2.py'])
	print("start SubProcess2")
	# 等待子进程1完成
	subProcess1.wait()
	print("SubProcess1 complete")
	# 等待子进程2完成
	subProcess2.wait()
	print("SubProcess2 complete")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# File Name: 		SubProcess1.py
# Description: 		This file is used to study python subprocess
# Author:  			TangHuan
# Create Date:  	2021/8/7

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

import os
import time

print("SubProcess1-1")

print("SubProcess1 parent pid:{0}".format(os.getppid()))
print("SubProcess1 pid:{0}".format(os.getpid()))
time.sleep(1)
print("SubProcess1-2")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# File Name: 		SubProcess2.py
# Description: 		This file is used to study python subprocess
# Author:  			TangHuan
# Create Date:  	2021/8/7

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

import os
import time

print("SubProcess2-1")

print("SubProcess2 parent pid:{0}".format(os.getppid()))
print("SubProcess2 pid:{0}".format(os.getpid()))
time.sleep(1)
print("SubProcess2-2")

从上面的测试代码可以看出，我们通过mutilprocessing模块提供的Pool(用于控制一组子进程的创建使用)成功创建了4个多进程池开启5个多进程任务(其中有一个任务需要等待一个可用的进程才能执行)。

通过SubProcess模块，我们实现了开启多个进程执行不同Python脚本的功能，从而实现多进程执行多Python脚本任务的需求。

更多更细节的学习参考:

多进程

Note：

1. multiprocessing和subprocess是提供了多进程而非多线程
2. Unix/Linux操作系统多进程是采用fork()实现真正的进程复制，而Windows不支持fork()函数，Windows上多进程是通过在子进程里创建新的Python解析器来实现的(来源:On Windows, there is no such system call. Python needs to perform the quite heavy task of creating a fresh Python interpreter session in the child, and re-create (step by step) the state of the parent.)，所以我们执行多进程时要通过命令行而非Sumblime等软件。

待续……

Tips

encode and decode

字符编码问题，无论是shell，python都是需要考虑的，不然会出现乱码的情况。

encode(编码)和decode(解码)是需要一一对应的，不然同一个二进制数据，通过不同的编码和解码会得出不一样的结果。

首先我们来看看Python官网对于Encode和Decode的介绍:
Strings are stored internally as sequences of code points in range 0x0–0x10FFFF. (See PEP 393 for more details about the implementation.) Once a string object is used outside of CPU and memory, endianness and how these arrays are stored as bytes become an issue. As with other codecs, serialising a string into a sequence of bytes is known as encoding, and recreating the string from the sequence of bytes is known as decoding.

从上面可以看出，我们的string最终都是以字节码形式存储起来的。我们指定如何编码字符串到字节码的方法叫做编码。我们制定如何解析字节码到字符串的方法叫做解码。

关于字符编码的详细学习，这里参考以前转载的一片文章来加深理解:
关于字符编码，你所需要知道的（ASCII,Unicode,Utf-8,GB2312…）

不难看出，编码和解码方式要是不一致，最终字节码数据解析出来就会出现不正确(比如乱码)的情况。

这里需要提一下Python 3.X里有提供codecs的Package专门负责处理encode，decode问题。
codecs深入了解链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#!/usr/bin/python
# -*- coding: utf-8 -*-
# 指定文件包含非anscii字符

import sys
import codecs

# 打印系统默认编码
print(sys.getdefaultencoding())

# 如果默认编码不是utf-8，强制设置成utf8去支持文本内非anscii字符
# 下面这段代码针对Python 2.X
# Phtyon 3.X默认就是utf-8编码不需要自己设定utf-8编码
#reload(sys)
#sys.setdefaultencoding('utf-8')

s="English-中文"
print(s)

s2=codecs.encode(s,"gb2312")
print(codecs.decode(s2,"gb2312"))
#解码格式与编码格式gb2312不一致，报错，无法解析
#print(codecs.decode(s2,"utf-8"))

# 需要指定和文件一样的编码格式才能正确解析文件里的内容
# 读取解码格式与inputfile.txt保存的编码格式utf-8不一致报错
#f = open('inputfile.txt','r',encoding='gb2312')
f = open('inputfile.txt','r',encoding='utf-8')
content = f.read()
print(content)

可以看到当我们把通过gb2312编码的字符串通过对应的gb2312解析时能正确显示，但用utf-8去解析时就出现了问题。同理文件读取指定的解码格式与文件自身的编码格式不一致也会出现无法读取的情况。

结论：
编码和解码格式要一一对应才能正确解析显示。
String is sequence of Unicode characters. Strings are immutable. We cannot delete or remove characters from a string. But deleting the string entirely is possible using the keyword del.
Python里是采用Unicode编码存储字符串。Strings可以通过[]访问，但是不可被改变的。
因为string是immutable的，所以我们不能通过del删除string里面的个别character，但是我们可以删除对string的整个引用。

main

'__main__' is the name of the scope in which top-level code executes. A module’s name is set equal to '__main__' when read from standard input, a script, or from an interactive prompt. A module can discover whether or not it is running in the main scope by checking its own __name__, which allows a common idiom for conditionally executing code in a module when it is run as a script or with python -m but not when it is imported:

从上面的介绍可以看出__main__表示是否是从最上层执行(比如直接执行脚本，命令行执行脚本)代码的名字。

如何判定是否是从最上层执行当前python脚本了？

从上面的介绍可以看出，__name__变量标识了当前python脚本是通过什么方式执行的。

1
2
3
4
5
6
7

# File Name: 		MainName.py
# Description: 		This file is used to study __name__ and __main__ using
# Author:  			TangHuan
# Create Date:  	2021/5/22

print("MainName.py")
print(__name__)

比如上面这段代码，在通过脚本直接执行时，我们会看到打印输出:

如果我们通过以下代码导入MainName.py会看到打印输出:

1

import MyPackage.MainName

在命令行执行脚本和直接执行脚本同理。

可以看出当我们通过非import方式导入脚本时，__name__的值为__main__这个特殊的值，我们可以通过判定这个值来判定当前python脚本的执行方式，因此我们经常会看到以下代码:

1
2

if __name__ == "__main__":
	print("DoSomething()")

这样就能做到只有通过非import方式执行当前python脚本时才执行某些东西。

Command Line Args

os.argv

很多时候作为脚本语言Python，我们写的Python脚本更多是用于自动化流程(比如打包签包等)，而调用此Python脚本的方式大多为命令行调用。这里就引出了如何通过命令行将我们所需的参数传递进我们Python脚本的问题。

Python自带了一个os.argv的参数用于获取命令行传入参数数据。

1
2

for arg in sys.argv:
	print(arg)

如果我们通过命令执行以下脚本传入参数:

1

***.py param1 param2 param3

我们会看到以下输出:

可以看到第0个参数表示当前python脚本执行的文件路径。

但上面这种方式，虽然能获得命令行传入的参数，但对于参数的格式以及参数的要求对于用的人来说都还是不透明且未做任何安全检查也未给与任何提示信息的，这样会导致Python脚本内部还需要自行做这些参数检查。这里就要引出接下来要提到的模块功能:argparse

Note:

1. 如果以-c的参数触发python，os.argv的第一个参数是-c,详情参考:-c

argparse

The argparse module makes it easy to write user-friendly command-line interfaces. The program defines what arguments it requires, and argparse will figure out how to parse those out of sys.argv. The argparse module also automatically generates help and usage messages and issues errors when users give the program invalid arguments.

argparse是Python里帮助我们引导输入参数和快速解析参数的模块。

接下来我们直接上学习Demo，简单学习了解下如何使用argparse帮助我们快速引导输入参数和快速解析参数:
argparsestudy.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#!/usr/bin/python
# -*- coding: utf-8 -*-
# 指定文件包含非anscii字符

import os
import argparse
import sys

# argparse解析参数输入，需要先定义一个ArgumentParser对象
# description - -h的时候显示在最前面的信息
parser = argparse.ArgumentParser(description='Study argparse module.')

# add_argument - 定义如何解析一个参数
# 第一个参数代表参数名
# type - 指定参数数据类型
# help - -h时解释该参数的用意
# dest - 表示该参数最终在parser.parse_args()返回对象里的名字
# default - 表示该参数的默认值
# required - 表示该参数是不是必须填的参数
parser.add_argument('--APKName', type=str,
                    help='APK名字', dest='APKName',
                    required=True)

parser.add_argument('--ClientChId', type=str,
                    help='新的ClientChId值', dest='New_Clientchid',
                    default='com.default.com')

parser.add_argument('--LEBIAN_VERCODE', type=int,
                     help='新的LEBIAN_VERCODE值', dest='New_Lebian_Vercode',
                     default='0')

parser.add_argument('--TemplateValue', type=str,
                    help='替换AndroidManifest.xml里quicksdk_packName字段为新的*', dest='NewTemplateValue',
                    default='com.defaulttemplatevalue.com')

parser.add_argument('--ResourcePath', type=str,
                    help='放入新资源到指定包内目录', dest='NewResourcePath',
                    default='./default.aba')

# 解析输入的参数
args = parser.parse_args()

# 打印参数的详细信息，通过访问parser.parse_args()的对象去访问
print(args)
print("APKName : {0}".format(args.APKName))
print("New_Clientchid : {0}".format(args.New_Clientchid))
print("New_Lebian_Vercode : {0}".format(args.New_Lebian_Vercode))
print("NewTemplateValue : {0}".format(args.NewTemplateValue))
print("NewResourcePath : {0}".format(args.NewResourcePath))

命令行输入:
Python .\argparsestudy.py -h
会看到每个参数的详细信息

真正使用时因为–APKName是必传参数，所以按下面方式调用即可:
Python .\argparsestudy.py –APKName com.tonytang.com

可以看到我们通过argparse模块轻松的完成参数输入引导以及参数解析的任务。

更多详细学习参考:
argparse — Parser for command-line options, arguments and sub-commands

Path

关于Path模块，这里需要先了解一下跟语言无关的一个基础知识。

路径中斜杠/和反斜杠\的区别

从博客介绍中可以看出，斜杠和反斜杠主要是Windows路径和Unix路径里区分，大部分情况(无论是浏览器还是html url都是反斜杠)。

这里就引出了在自动化流程里涉及路径时，我们需要兼容Windows，Mac，Android或者IOS时候路径问题需要处理。而Path模块正是能够处理这一问题的现有模块功能。

os.path

这里只是简单示范几个常规API用法，详情参考:os.path

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import os
import sys

FilePath = sys.argv[0]
print("FilePath = {}".format(FilePath))

# 获取当前工作目录
WorkingFolder = os.getcwd()
print("WorkingFolder = {}".format(WorkingFolder))

# 文件所在文件夹名
FileFolderName = os.path.dirname(FilePath)
print("FileFolderName = {}".format(FileFolderName))

if os.path.isdir(WorkingFolder):
	print("{} is directory!".format(WorkingFolder))
else:
	print("{} is not directory!".format(WorkingFolder))

pathlib

This module offers classes representing filesystem paths with semantics appropriate for different operating systems. Path classes are divided between pure paths, which provide purely computational operations without I/O, and concrete paths, which inherit from pure paths but also provide I/O operations.

上面提到了两种概念PurePath和Concrete Paths，前者只是提供路径概念(比如区分Windows还是Unix文件系统以及路径相关操作)不和文件系统挂钩。后者就是Pathlib提供的OOP文件路径系统抽象，提供了一系列的文件操作接口(Pathlib相当于进阶版的Path抽象模块)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import os
import sys
from pathlib import Path

FilePath = sys.argv[0]
print("FilePath = {}".format(FilePath))

# 获取当前工作目录
WorkingFolder = os.getcwd()
print("WorkingFolder = {}".format(WorkingFolder))

# 文件所在文件夹名
FileFolderName = os.path.dirname(FilePath)
print("FileFolderName = {}".format(FileFolderName))

if os.path.isdir(WorkingFolder):
	print("{} is directory!".format(WorkingFolder))
else:
	print("{} is not directory!".format(WorkingFolder))

# 这一步可以自动转化成对应平台的路径格式(最后需要str的时候需要转化成str)
PathWorkingFolder = Path(WorkingFolder)
print("PathWorkingFolder = {}".format(PathWorkingFolder))

WorkingFolderJoinPath = PathWorkingFolder.joinpath("joinpath")
print("WorkingFolderJoinPath = {}".format(WorkingFolderJoinPath))

if PathWorkingFolder.exists():
	print("{} exists!".format(PathWorkingFolder))

这里用Pathlib除了他提供了更多的文件路径操作外，还有就是它继承了PurePath跨平台文件路径处理的特性，让我们可以在处理文件路径时无需关心平台。

Bat and Shell

Bat和Shell在Unity自动化&IOS自动化签包文章中已经了解过了，这里主要是介绍如何在python里和bat，shell交互(比如我们想获取环境变量里的数据，执行shell命令等)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import os

androidhome = os.getenv("ANDROID_HOME")
if androidhome == None:
	print("未配置ANDROID_HOME环境变量路径，请先配置ANDROID_HOME环境变量")
else:
	print("ANDROID_HOME = {}".format(androidhome))

WorkingFolder = os.getcwd()
print("WorkingFolder = {}".format(WorkingFolder))

CmdCommand = "echo Hello World"
print("CmdCommand = {}".format(CmdCommand))
# 执行CDM命令
os.system(CmdCommand)

# 确保不自动关闭
input("请按任意键继续...")

注释和用法都很详细了，这里就不多介绍了。

Python GUI

GUI(Graphic User Interface)可视化用户界面。
Python实现GUI有很多选择，这里参考一位博主的分享：
Python 的图形界面（GUI）编程？

学习需要从需求出发，这里本人主要是想用Python写点简单的GUI来满足可视化即可，所以对GUI要求不高，本人不是以Python为主，只是用Python写点周边小工具，所以这里本人考虑的是学习了解Python自带的TKinter。

如果对GUI要求比较高，有比较常用Python，根据上面那位博主的建议来看，PyQT是个不错的选择。

TKinter

官方介绍：
Tkinter is Python’s de-facto standard GUI (Graphical User Interface) package. It is a thin object-oriented layer on top of Tcl/Tk.

接下来将根据Tkinter 8.5 reference: a GUI for Python去学习了解TKinter的概念以及使用。

待续……

Reference

Conception Part

Python
Guido van Rossum

Tkinter

Encode and Decode in Python

Tutorial Part

Python Tutorial
Python Package Index

Tkinter 8.5 reference: a GUI for Python

codecs

argparse

Python教程

Other Part

Python2orPython3
Python 的图形界面（GUI）编程？

Unity自动化打包

本章节主要是为了学习Unity自动化打包相关知识以及运用。
本文大部分属于本人学习理解的东西，如有不对欢迎指出，学习交流，共同进步。

本章节的流程如下：

1. 了解什么是打包以及打包过程中的一些相关概念
2. 了解什么是自动化以及帮助我们快速完成一键打包的工具
3. 自动化打包工具或编程语言的选取
4. Unity自动化打包过程中的相关工具
5. 实战集成运用到Unity构建一键打包
6. 更多学习程序发布以及相关概念

在了解相关自动化工具之前，我们需要先简单了解下什么是版本控制。在我们的日常开发工作中必不可少。

版本控制

版本控制相关概念学习

打包

平时做游戏开发，在完成整个游戏功能开发后，需要通过打包上真机测试。
把所有游戏资源代码打包成安装包的过程称为打包。

多平台

在多平台的处理上，Unity已经帮我们做了很大一部分工作了。让我们大部分时间只需关心游戏核心开发(Unity部分API在不同平台有差异)，在打包这一块只需打选择对应平台即可。

但Unity自带的打包，终究只包含最基本的打包流程，当我们有特殊需求时，我们需要通过Unity以及相关工具完成支持我们自定义的打包流程。

自动化

在了解什么是自动化之前，让我们看看打包的基本流程。
在打包过程中，打包往往包含4个步骤。

1. Preprocess(打包准备步骤)
   这一步主要是为正式打包编译做准备，比如做一些平台相关设置，资源打包处理，文件复制等
2. Build(打包编译步骤)
   这一步是程序代码和资源正式打包成安装包的步骤，主要是通过指定打包参数执行打包。
   Unity在打包到Android和IOS平台时有差异。Android是直接就打包出APK，而IOS要先打包成XCode工程，然后在通过编译XCode工程打包出Ipa安装包。
3. Postprocess(打包结束后期处理步骤)
   这一步是打包完成后负责后续的自动化操作以及善后工作，比如在打包IOS时打包出XCode工程后，可以在这一步进行XCode工程的自动化处理部分(比如动态添加info.plist文件信息，动态插入代码等)
4. Deploy(安装步骤)
   这一步主要是打包好的安装包安装到真机的步骤

如果没有自动化，我们需要一步一步人工手动去完成上面的步骤。
而自动化就是只需人工设置打包最基本的参数信息，然后通过一步就自动化完成上述步骤的过程。

Jenkins

Introduction
Jenkins是一个用Java编写的开源的持续集成工具。Jenkins提供了软件开发的持续集成服务。它运行在Servlet容器中（例如Apache Tomcat）。它支持软件配置管理（SCM）工具（包括AccuRev SCM、CVS、Subversion、Git、Perforce、Clearcase和RTC），可以执行基于Apache Ant和Apache Maven的项目，以及任意的Shell脚本和Windows批处理命令。Jenkins的主要开发者是川口耕介。

本人使用目的：
做Unity游戏打包机，持续集成自动化打包流程，做到一键打包。

Deployment

1. Download Jeakins
2. Open up a terminal in the download directory and run java -jar jenkins.war
3. Browse to http://localhost:8080 and follow the instructions to complete the installation.(安装插件)

Jenkins实战

自由风格构建系统

主要是采用特定的构建系统去构建自动化。(比如java通过ant||Maven，windows通过bat||python等)

如果不想采用Pipeline编写自动化流程，也可以通过直接编写调用Windows Bat或者Python等命令触发自动化流程。

Unity3d Plugin不支持Pipeline，所以为了使用Unity3d Plugins,这里采用自由风格构建系统来搭建Unity3D的自动化打包。

1. Create Free Style(创建自由风格项目)
   新建 -> 构建一个自由风格的软件项目
   
2. 设置参数构造(用于自定义参数添加)
   
3. 设置代码来源
   
4. 设置构建命令(bat || python || unity3d……)
   
5. 设置构建完毕后的一些行为(比如邮件通知)
   

Note:
想要改变默认的workspace路径的话。
设置->使用自定义的工作空间(只针对当前设置的自由风格项目有效)

Pipeline

What

Jenkins Pipeline is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins. Pipeline provides an extensible set of tools for modeling simple-to-complex delivery pipelines “as code”.(这里的Pipeline是一套插件，用于支持持续自动化集成编写。好比脚本文件定义一系列的自动化流程，但并不等价于脚本。)

那么Pipeline是用什么语言编写了？
Jenkins是基于Java的，Pipeline的编写是基于Groovy。
Groovy是Java平台上设计的面向对象编程语言。这门动态语言拥有类似Python、Ruby和Smalltalk中的一些特性，可以作为Java平台的脚本语言使用。

Why

为什么需要Pipeline？

1. Code – 可管理可编辑可视化的自动化流程脚本
2. Durable – 可持续化开发
3. Pausable – 可以自动也可以停止等待输入
4. Versatile – 支持复杂的持续交付需求
5. Extensible – “The Pipeline plugin supports custom extensions to its DSL [5: Domain-Specific
   Language] and multiple options for integration with other plugins.”

How

接下来让我们看看如何创建一个Pipeline。

1. 下载Pipeline插件
   
2. New Item – 新建Pipeline(选择Pipeline类型)
   
3. Configure Pipeline
   • 配置Pipeline的名字
     
   • 设置Jenkins Pipeline Code的来源
     • 网页版编写
       
     • SVN下含Jenksfile文件
       
       这里不深入讨论Jenkins的各种设置，详情查看官方文档Jenkins User Handbook

Note:
Pipeline supports two syntaxes, Declarative and Scripted Pipeline

Jenkinsfile

除了直接在网页上编写Pipeline自动化流程。我们也可以指定Jenkinsfile文件作为编写Pipeline的地方。

为什么需要Jenkinsfile？
主要还是为了放入版本管理，方便所有人可视化看到自动化流程代码。

e.g.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#!groovy
pipeline {
    //agent指定jenkins从哪里以及如何执行pipeline
    //any表示从any available agent处执行
    agent any
    
    //看定义在那一层，就只针对那一层起作用(pipeline一层针对pipeline。stage一层针对特定stage)
    //也可以修改已定义的环境变量值
    environment {
        UNITY_PROJECT_PATH = 'E:\\TonyTang\\Work\\Projects\\TGame_code'
    }

    //自定义参数
    //可以通过pipeline代码编写，也可以直接在web UI界面上添加
    parameters{
        string(name: 'Platform', defaultValue: 'Android', description: 'Which plaftform is using?')
        booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: 'Is debug version?')
    }

    stages {
        stage('postprocess'){
            //when表示执行条件判断
            //决定stage是否应该执行
            when{
                expression
                {
                    return params.DEBUG_BUILD
                }
            }
            steps{
                //params是访问pipeline里定义的所有parameters入口
                echo "Current platform is ${params.Platform}"
                echo 'postprocess'
                echo UNITY_PROJECT_PATH
                //env是jenkins定义的全局的环境变量
                //http://localhost:8080/job/TonyTangPipeline/pipeline-syntax/globals
                echo env.WORKSPACE
            }
        }
        stage('build') {
            steps {
                //Windows调用bat
                //Mac Linux采用sh
                bat 'TonyTangPipeline'
            }
        }
        stage('deploy'){
            steps{
                echo 'deploy'
                //支持调用python
                bat 'python FirstPython.py'
            }
        }
    }

    //post表示Pipeline执行完之后执行，做一些clean up操作
    post {
        //根据pipeline的结果做特定操作
        always{
            echo 'Always!'
        }
        success {
            echo 'Success!'
        }
        failure{
            echo 'Failed!'
        }
    }
}

// Script Pipeline(Optional)
//在pipeline执行完成之后执行
//支持大部分Groovy
//Script Pipeline的参数定义需要在properties里
properties([parameters([string(defaultValue: 'Android', description: 'Which platform is using?', name: 'Platform')])])

node {
    //定义字符串
    def Date = '2017//4//26'
    stage('postprocess') {
        //要使用${}访问string，需要用""
        echo "Date = ${Date}"
        echo "Current platform is ${params.Platform}"
        echo 'postprocess....'
    }
    stage('build') {
        echo 'build....'
    }
    stage('deploy') {
        echo 'deploy....'
    }
}

Note:

1. 指定使用版本管理后，Jenkinsfile必须放到版本管理里才能找到。
2. Jenkinsfile必需放到前面设置的本机相对路径下才能找到。

Problems

1. 构建参数一旦通过代码指定添加后，代码删除了依然存在
2. No valid crumb was included in the request

Solutions:

1. 通过Pipeline -> Setting的UI界面手动删除参数
2. 在系统管理 –> Configure Global Security
   取消“防止跨站点请求伪造（Prevent Cross Site Request Forgery exploits）”的勾选。

Tools

Pipeline Tools

Snippet Generator

这是一个很有用帮助快速编写Pipeline的工具,他可以帮助我们把我们熟悉的自动化脚本转换成Pipeline格式的语句，也可以快速生成一些特定功能的脚本(比如邮件功能等)。(Jenkins提供)

Pipiline全局环境变量

Email Plugin

利用现有的SMTP(腾讯，网易等)服务进行搭建邮件提醒，详情参见如下：
Jenkins——应用篇——插件使用——Mailer Plugin
Jenkins自带Email配置如下:
Manage Jenkins -> Configure System -> E-mail Notification

Jenkins自带的Mailer提供的功能很有限，为了提供更多更广的功能，这里我们需要用到Jenkins Email Extension Plugin
Jenkins进阶系列之——01使用email-ext替换Jenkins的默认邮件通知
Email Extension Plugin配置详情参见如下：
Manage Jenkins -> Configure System -> Extended E-mail Notification

针对workspace自定义邮件内容配置如下：

最终收到Email提醒:

Unity3D Plugin

管理插件->Unity3d Plugin
Unity本身是支持从命令行启动U3D，执行Editor特定方法的。
但Unity3D Plugin是一个针对Jenkins集成Unity命令行的插件，可以帮助我们直接在Jenkins上编写U3D命令，对于Jenkins更加友好。
好处如下:

1. Log file redirection(Log重定位到Jenkins界面)
2. Distributed builds(分布式编译)

Unity3D Plugin实战配置

1. Configure Unity Installation Path
   System Setting -> Global Tool Configuration
   
2. 编写Unity下可通过命令行调用的代码

1
2
3
4
5
6
7
8
9
10
11
12

using UnityEngine;
using System.Collections;
using UnityEditor;

public class UnityBuild {

    [MenuItem("Custom/UnityBuild/OneKeyBuild")]
    static void OneKeyBuild()
    {
        Debug.Log("OneKeyBuild() Called!");   
    }
}

3. 配置Unity命令行运行启动以及参数
   
   
   从上面可以看出我们成功的配置了Jenkins以及对于Unity打包方法的调用(在这一步我们可以做很多我们自己对于Unity打包的流程设置，资源打包或者其他的预处理等)
4. 编写完整的打包设置以及相关预处理代码
   待续…….
   接下来是为了在IOS进行Jenkins自动化打包而设置的步骤
5. 在IOS搭配SmartSVN拉VisualSVN上的文件(Windows上用TortoiseSVN作为SVN客户端即可)
6. 在IOS上配置Jenkins(和Windows上类似，需要下载Java支持Jenkins运行)
   这里讲几个配置搭建Mac OSX的Jenkins时遇到的坑：
   1. 配置Unity插件Unity安装路径问题
      Windows上是到Editor上一层即可。IOS是到Unity.app这一层(Unity.app(e.g. /Applications/Unity/Unity.app/)在命令行里可以往里访问)
   2. 指定IOS Subversion URL(e.g. https://192.168.1.3/svn/***)时显示无法访问或者不正确的credential(这里是因为默认的Mac SVN版本过低需要更新Mac OSX自带的SVN)
   3. 更新Mac OSX自带SVN时在添加新装的SVN到环境变量里后依然显示是老版的SVN
      在~/目录下touch .bash_profile(创建.bash_profile)
      然后添加环境变量路径export PATH=”/opt/subversion/bin;$PATH”
      使其环境变量路径设置生效source .bash_profile
      查看当前SVN版本svn –version
      如果上一步依然显示是旧版SVN且当前系统是10.11
      那么我们就需要删除Mac OSX上原本的SVN以实现更新SVN的目的
      查看旧版SVN路径which svn
      删除旧版SVN(sudo -s rm -rf /svnpath/svn*)(此时如果出现No Permission to remove，那么恭喜，你是用的10.11系统。10.11推出了SIP(System Integrity Protection)机制去防止root用户对于部分文件的操作权限限制用于防止病毒破坏或修改重要文件)
      为了能够删除旧版SVN，这里我们需要进到Recover Mode去临时关闭SIP(重启电脑一直按住cmd+R，然后在terminal里执行csrutil disable，关闭成功后就可以重启电脑去删除旧版svn了)
      然后将新版SVN链接到旧版SVN执行路径(sudo -s ln -s /opt/subversion/bin/svn* /svnpath)
      最后到Recover Mode里恢复SIP(csrutil enable)
   4. 打包IOS时报错：_RegisterApplication(), FAILED TO establish the default connection to the WindowServer, _CGSDefaultConnection() is NULL.
      这是因为Jenkins默认安装时是以Jenkins作为用户和组。开机自启动时也是以Jenkins用户和组来运行的。而Unity我是默认安装在我自己的用户apple和admin组下。所以在Jenkins需要启动Unity时应该是没有权限调用 Unity Editor 的命令行。所以我们要做的就是确保Unity和Jenkins运行在同一个User和Group下。
      以下采用把Jenkins改到apple和wheel下运行以支持Unity的命令行运行。
      详情参见macOS 安装配置 Jenkins 持续集成 Unity 项目指南
   5. 指定Custom Workspace(自定义到桌面特定目录后每次都报Failed to mkdir，这个跟第四个问题是同一个问题，默认Jenkins用户权限问题)

Note:
很多文件是Unity自动生成的(比如Library目录)，我们无需加入版本管理(SVN只要不加入版本管理即可)

Note:
Unity3d Plugin不支持在Pipeline里添加。
同时Unity3d Plugin只在3.4.2 to 5.0.1的版本下测试过。(经本人测试在Unity5.4.0f3的版本也能正常使用)

Jenkins从零搭建

这里的从零搭建，在借助Jenkins插件的基础上，尽量采用Pipeline编写为主，插件UI为辅的方式来实现一整套完整的Jenkins自动化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#!groovy
pipeline {
    //agent指定jenkins从哪里以及如何执行pipeline
    //any表示从any available agent处执行
    agent any
    
    //看定义在那一层，就只针对那一层起作用(pipeline一层针对pipeline。stage一层针对特定stage)
    //也可以修改已定义的环境变量值
    environment {
        UNITY_PROJECT_PATH = 'E:\\TonyTang\\Work\\Projects\\MyGitHubProjects\\GitStudy2'
        GIT_URL = 'git@github.com:TonyTang1990/GitStudy.git'
        GIT_AUTH = '7d947f92-1e9c-44ba-9a80-9744f92f2ff6'
    }

    //自定义参数
    //可以通过pipeline代码编写，也可以直接在web UI界面上添加
    parameters{
        string(name: 'Platform', defaultValue: 'Android', description: 'Which plaftform is using?')
        booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: 'Is debug version?')
    }

    stages {
        stage('postprocess'){
            //when表示执行条件判断
            //决定stage是否应该执行
            when{
                expression
                {
                    return params.DEBUG_BUILD
                }
            }
            steps{
                //params是访问pipeline里定义的所有parameters入口
                echo "Current platform is ${params.Platform}"
                echo 'postprocess'
                echo "${env.UNITY_PROJECT_PATH}"
                echo "${env.GIT_URL}"
                echo "${env.GIT_AUTH}"
                //env是jenkins定义的全局的环境变量
                //http://localhost:8080/job/TonyTangPipeline/pipeline-syntax/globals
                echo env.WORKSPACE
            }
        }
        stage('Git') {
            steps {
                echo 'Git operation'
                checkout([$class: 'GitSCM', 
                        userRemoteConfigs: [[url: "${env.GIT_URL}", credentialsId: "${env.GIT_AUTH}"]],
                        extensions: [[$class: 'CleanBeforeCheckout', $class: 'GitLFSPull']]
                        ])
            }
        }
        stage('build') {
            steps {
                //Windows调用bat
                //Mac Linux采用sh
                bat 'BatAutomation'
            }
        }
        stage('deploy'){
            steps{
                echo 'deploy'
                //支持调用python
                bat 'python PythonAutomation.py'
            }
        }
    }

    //post表示Pipeline执行完之后执行，做一些clean up操作
    post {
        //根据pipeline的结果做特定操作
        always{
            echo 'Always!'
        }
        success {
            echo 'Success!'
        }
        failure{
            echo 'Failed!'
        }
    }
}

// Script Pipeline(Optional)
//在pipeline执行完成之后执行
//支持大部分Groovy
//Script Pipeline的参数定义需要在properties里
properties([parameters([string(defaultValue: 'Android', description: 'Which platform is using?', name: 'Platform')])])

node {
    //定义字符串
    def Date = '2017//4//26'
    stage('postprocess') {
        //要使用${}访问string，需要用""
        echo "Date = ${Date}"
        echo "Current platform is ${params.Platform}"
        echo 'postprocess....'
    }
    stage('build') {
        echo 'build....'
    }
    stage('deploy') {
        echo 'deploy....'
    }
}

脚本语言

为了快速编写一些自动化任务，我们往往需要用到脚本语言。

bat

批处理文件（英语：Batch file），又称批次档，在DOS、OS/2、微软视窗系统中，是一种用来当成脚本语言运作程序的文件。它本身是文本文件，其中包含了一系列让具备命令行界面的解释器读取并运行的指令。它相当于是类Unix系统下的Shell script。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

:: 关闭命令输出打印
@echo off
:: UTF8
chcp 65001
:: 清除命令行界面内容
CLS
:: 输出打印信息
echo Tony Tang bat study
:: 设置打印传入参数
set par1=%1
set par2=%2
echo %par1%
echo %par2%
:: 输出打印当前目录路径
echo %cd%
:: 切换到上一层路径
cd ..
:: 输出打印当前目录路径
echo %cd%
:: 切换到BatStudy目录
cd BatStudy
:: 输出打印当前目录路径
echo %cd%
:: 打印帮助信息
::HELP
:: 自定义变量(定义变量时=号两边不能有空格)
set batvariable=tonytang
:: 打印自定义变量
echo %batvariable%
:: 自定义数字变量
set number=3
:: 打印自定义数字变量
echo number = %number%
:: 条件语句
if %number%==2 (echo %number%==2) else (echo %number%!=2)
:: 检查文件是否存在
set filename=batcontent.txt
echo filename=%filename%
if EXIST ./%filename% (echo %filename% exits) else (echo %filename% not exist)
:: 普通循环语句
for %%i in (1 2 3) do echo %%i
:: 当前目录文件循环遍历语句
for %%f in (*) do @echo %%f
:: 启用变量执行时解析
SetLocal EnableDelayedExpansion
for %%i in (1 2 3) do (
	set numberVariable=%%i
	echo !numberVariable!
	set numberVariable=!numberVariable!+!numberVariable!
	echo !numberVariable!
)
:: 暂停等待输入
pause
:: 退出命令界面 0代表正常退出
EXIT 0

这里只列举一些常用基础的，详细Windows Batch学习参考:
Batch file – Programming tutorial
Batch Script Tutorial

Shell

Windows上的bat，power shell
Linux上的shell
好处：
简单快速的编写一些系统相关的任务(比如文件复制等)
缺点：
有平台差异

在正式学习Shell之前，让我们依然从What，How，Why，When这四个问题着手：
What?
Unix shell，一种壳层与命令行界面，是UNIX操作系统下传统的用户和计算机的交互界面。第一个用户直接输入命令来执行各种各样的任务。

第一个Unix shell是由肯·汤普逊，仿效Multic上的shell所实现出来，称为sh。

后续出了其他的Shell:

1. Bourne-Again shell - bash
2. Debian Almquist shell - dash
3. Korn shell - ksh
4. Z shell - zsh

上面的几个Shell都可以看作是后续发展功能越来越强大的Shell解析器，至于具体分别包含些什么功能就不在本文讨论的范围内了。这里我们主要以bash和shell作为解析器来学习编写shell脚本。

How?
Shell脚本（英语：Shell script），又称Shell命令稿、程序化脚本，是一种计算机程序与文本文件，内容由一连串的shell命令组成，经由Unix Shell直译其内容后运作。被当成是一种脚本语言来设计，其运作方式与解释型语言相当，由Unix shell扮演命令行解释器的角色，在读取shell脚本之后，依序运行其中的shell命令，之后输出结果。利用shell脚本可以进行系统管理，文件操作等。

可以看出Shell脚本是被当做脚本语言来解释执行，通过调用系统内核的一些工具来实现特定功能任务的。

Why?
Shell并不适合编写复杂的程序任务，因为他只提供了一些比较基础的工具，并且不具备面向对象编程等高级语言的特性。
既然如此那我们为何还要坚持使用Shell了？为何不直接选择Python，Ruby，Perl这些相对高级一点的解释性语言了？
理论上是可以的，但Shell属于原生就具备提供的工具，可以很快捷的编写出一些看似简单但却方便的工具脚本。即使Python可以实现，但针对特定的功能可能没有Shell来的那么快捷方便，根据需求选择合适的脚本语言也是很重要的。后续我会结合Python夸平台的特性，使用Python结合Shell编写一些自动化相关的工具。

Note:
Shell跟操作系统紧密相关，原本并非跨系统平台的，但通过移植很多shell具备了跨系统平台的能力(Windows上通过Cygwin与MinGW可以模拟执行Unix Shell)。

When?
那么什么时候适合用Shell了？从前面三个问题不难看出，Shell只适合用于一些不复杂的功能任务里，无论是语言特性还是跨平台都没有Python那些高级语言支持的好。如果需要实现复杂的且跨平台，需要高级语言特性(面向对象等)时，不应该考虑Shell而是Python，Perl，Ruby这些。

Note:
这里所说的shell和Window的batch并不是同一个东西。

bash

• 指定解析器

1
2

#!/bin/bash
# Proper header for a Bash script

**#!**是two-byte的magic number
表示这个文本是executable shell script，后面紧跟的/bin/bash表示shell解析器是用的bash

• 输出打印
  学程序，最初开始的地方肯定是Hello World。
  在bash里打印输出是通过echo指令。

1
2
3

#!/bin/bash
# Proper header for a Bash script
echo "Hello World"

• 特殊符号

1. 井号(#) – 注释符号

1

# Proper header for a Bash script(这一行#号开头表示注释)

2. ; – 命令分隔符(允许同一行多个指令)

1
2

#! /bin.bash
echo "Hello"; echo "World"

![CommandSeparator](/img/Bash/CommandSeparator.png)

3. ;; – 跳出case语句

1
2
3
4
5
6

#! /bin/bash
variable="TonyTang"
case "$variable" in
    TonyTang) echo "TonyTang1";;
    TonyTang) echo "TonyTang2";;
esac

![TerminateCommand](/img/Bash/TerminateCommand.png)

4. .
   • 表示文件是隐藏的

1
2
3
4

#! /bin/bash
touch .hidden-file
ls -l
ls -al

![HidenProfileCommand](/img/Bash/HidenProfileCommand.png)
- 表示当前目录

1
2
3

pwd
cd .
pwd

![CurrentDirectoryCommand](/img/Bash/CurrentDirectoryCommand.png)
- 正则里面表示匹配单个字母

5. “” - 字符串(保留大部分特殊符号)
6. ‘’ - 字符串(保留所有特殊符号)
7. ,
8. \ - 反斜杠，忽略特殊符号

1
2

#! /bin/bash
echo "\"Hello World"\"

![Backslash](/img/Bash/Backslash.png)

9. / - 文件路径分隔符
10. : - 相当于内置true

1
2
3
4
5
6

while :
do
    echo "Number 1"
    echo "Number 2"
    echo "Number 3"
done

![ColonOperator](/img/Bash/ColonOperator.png)

11. ! - 取反
12. 星号(*) - 通配符或者乘法
13. ? - 三目运算符或者表示测试条件
14. $
    • $ 变量取值符号
    • $? 退出状态码
    • $$ 进程号

1
2
3
4
5

#! /bin/bash
var1=100
echo "var1 = $var1"
echo $?
echo $$

![VariableSubstitution](/img/Bash/VariableSubstitution.png)

15. &> >& >> < <>

    • &> 重定向输出到指定文件

    • <> 文件读取

1
2
3
4
5

#! /bin/bash
ls -l
echo "Hello World" >HelloWorldFile.txt
ls -l
cat HelloWorldFile.txt

![RedirectionCommand](/img/Bash/RedirectionCommand.png)

16. ~ ~+ - home目录和当前目录

1
2
3
4

echo ~
echo $HOME
echo ~+
echo $PWD

![FolderCommands](/img/Bash/FolderCommands.png)

17. ` - 命令执行符号(可以用于快速执行命令并将结果复制)

1
2

Date=`date +%Y%m%d%H%M%S`
echo $Date

![CommandsSubstitution](/img/Bash/CommandsSubstitution.png)

• Shell小知识

1. $0 - $9
   $0表示Shell文件名
   $1-$9表示Shell的第一个到第九个参数

2. ls -l
   查看文件详细信息(比如读写权限等)
   
   具体如何理解最前面的权限信息，参考第六章、Linux 的文件权限与目录配置

3. chmod
   修改文件权限

4. cd
   切换目录

5. pwd or ~+
   当前所在目录

6. echo
   输出信息

7. exit
   退出shell

8. $?
   前一段shell的返回输出值

9. $ or ${}
   去变量值

10. 
    多行shell支持

11. $SHELL
    从当前Shell执行结束的地方打开一个新的terminal窗口(能保持之前所有的输出信息都在)

待续……

Python(严格意义上不算脚本语言)

好处：

1. 跨平台
2. 解释性语言，开发方便快速
3. 库丰富
   待续……

IOS自动化打包

IOS打包准备

1. Apple Account(发布到IOS设备上需要)
   任何账号都可以发布到自己的设备测试，但是如果要使用GC or In-App Purchases或者发布到App Store的话需要注册Apple Developer Program。

2. Xcode(up-to-date version)
   因为Xcode是Mac上的软件，所以这里需要Mac电脑或者是黑苹果。(开发所需的SDK，IDE套装都在这)

3. Adding your Apple ID to Xcode
   Open Xcode -> Xcode -> Preferences -> Account ->

4. 在开发之前，Mac需要获得IOS Certificartes(用于对Mac开发授权，程序签名等)
   登陆Apple Developer Program -> Certificates ,identifiers & Profiles -> Certificate Signing Request
   Create CSR(Certificate Signing Request):

   1. Folder -> Utilities Folder -> Keychain Access
   2. Keychain Access -> Certificate Assistant -> Request a Certificate from a Certificate Authority -> 填完内容存储到本地
      CSR里包含了public key和private key。
      当CSR创建以后，需要使用CSR去请求一个Certificate:
   3. 上传CSR
   4. 下载Certificate
   5. 运行安装Certificate
      安装Certificate后public和private key pair就生成了(在Keychain Access下可以查看)而我们的应用程序签名是使用私钥来签名用公钥来进行验证, 而苹果生成的Certificate 只包含了公钥,当你用自己的私钥签名后,苹果会用公钥来进行验证,确保是你自己对程序签名而不是别人冒充的
      通过导出共享公钥和私钥，可以实现共同开发(Mac开发授权，程序签名等)。

5. 设置App ID(相当于Android包名，用于识别App)
   App ID包含以下组成部分：

   1. Prefix – 作为Team ID
   2. Suffix – 作为Build ID的搜索字符串(可指定通配符)
   3. AppServices – 指定包含的Service(比如Game Center， IAP， iCloud等服务)，只有指定了这些，使用包含了此APP ID的Provision Profile才能使用特定服务

6. 添加设备列表(只有被添加了的设备列表才能用于安装和测试程序)
   需要通过Itunes查看UDID，然后添加到设备列表。

7. 用上述我们创建的Certificate, Apple ID, Devices List等生成我们的Provision Profile(Unity Cloud Build的时候需要指定)
   不同的Provision Profile有不同的用处，比如iPhone Developer证书用于测试设备上运行，iPhone Distribution证书用于提交应用到App Store。
   让我们来理解一些相关概念，下文引用至IOS开发 证书总结
   Identifier:
   顾名思义App ID（application id, not apple id）, 对于你的一个或者一组app他们的唯一标识, 这个App ID跟你Xcode中的Targets —–> General—–> Identity中的Bundle Identifier是匹配的,(其余的那些推送服务啊什么的都是配置在APP ID下面的) 如下图:

   Provisioning Profile
   一个Provisioning Profile包含了上述所有内容 Certificate && App ID && Device, 这个Provisioning Profile文件会在打包时嵌入到.ipa的包里,如下图:

   所以一台设备上运行应用程序的过程如下(以Developer Provisioning Profile为例):
   1 检查app 的 bunld ID 是否 matches Provisioning Profile 的 App ID
   2 检查 app 的 entitements 是否 matches Provisioning Profile 的 entitements
   3 用Certificate来验证签名签名
   4 检查此设备的UDID是否存在于 Provisioning Profiles中 （仅在 非发布证书中）

   如何创建?
   在 Provisioning Profiles 中点加号,然后依次选择App ID, Certificate, Devices(development),再指定名称,最后下载, 双击则安装到Xcode中

   Xcode中的配置
   Project && Target 的 build settings 中搜索Code sign…
   然后分别选好对应的证书,如果选择列表中没有刚才创建的证书可以双击直接复制名字上去

   关于推送服务
   基于上面的操作，如果需要推送服务我们还需要申请一个推送证书
   依次进入 Certificates —>Production —>Apple Push Notification service SSL (Production)
   然后选择需要推送服务的App ID
   再选择前面创建的.cerSigningRequest文件
   最后点击generated生成推送证书
   IOS开发流程大致如下：
   

XUPorter or Unity API(PBXFroject)

PBXFroject是Unity 5.X版本加进来的。因为5.X以前没有关于XCode自动化修改的相关接口，所以以前的版本用的都是XUPoter这个第三方插件工具来实现自动化修改info.plist文件，自动添加library之类的功能。

本人只使用过XUPoter还没详细使用PBXProject，但XUPoter的作者在Unity 5.X开始已经不在更新支持了，因为有了PBXProject，所以可以这样说，Unity 5.X版本开始可以直接使用Unity 5.X不需要再使用XUPoter了。

XUPoter

这里直接给出作者工具链接，就不详细讲解如何集成使用了，具体参考官方作者网站。
onevcat/XUPorter

PBXProject

对IOS的打包后的XCode工程做后处理，我们需要在代码里实现IPostProcessBuild接口的OnPostProcessBuild方法。

XcodePostProcess.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

using UnityEngine;
using System;
using System.Collections.Generic;
UnityEditor.iOS.Xcode

public static class XCodePostProcess : IPostprocessBuild

    public void OnPostprocessBuild(BuildTarget target, string path)
    {
        Debug.Log("XCodePostProcess.OnPostprocessBuild for target " + target + " at path " + path);

        //通过PBXProject访问并修改XCode工程相关的设置
        string projpath = path + "/Unity-iPhone.xcodeproj/project.pbxproj";
        PBXProject proj = new PBXProject();

        //读取XCode项目的数据
        proj.ReadFromString(File.ReadAllText(projPath));

        //获取XCode项目的Unity Target名字
        string nativetargetname = PBXProject.GetUnityTargetName();

        //获取XCode项目的Unity Target的GUID
        string nativeTarget = proj.TargetGuidByName(nativetargetname);

        //获取XCode项目的Test Target名字
        string testTarget = proj.TargetGuidByName(PBXProject.GetUnityTestTargetName());

        //设置需要设定的target列表
        string[] buildTargets = new string[] { nativeTarget, testTarget };

        //BitCode是用于提交AppStore后优化数据用的，IOS上是optional，但watchOS和tvOS是必须的。动态设置BitCode值
        proj.SetBuildProperty(buildTargets, "ENABLE_BITCODE", "NO");

        //动态修改UnityAppController.mm文件的arc编译参数
        ArcOnFileByProjectPath(proj, nativetargetname, "Classes/UnityAppController.mm", false);

        //自动化删除ReleaseForProfiling和ReleaseForRunning两个Configuration
        proj.RemoveBuildConfig("ReleaseForProfiling");
        proj.RemoveBuildConfig("ReleaseForRunning");

        //整个XCode项目数据写回去
        File.WriteAllText(projPath, proj.WriteToString());
    }

    /// <summary>
    /// 开启或关闭指定target的指定文件的arc(Automatic Reference Counting)
    /// </summary>
    /// <param name="proj"></param>
    /// <param name="targetname"></param>
    /// <param name="filepath"></param>
    /// <param name="isenablearc"></param>
    private void ArcOnFileByProjectPath(PBXProject proj, string targetname, string filepath, bool isenablearc)
    {
        string targetguid = proj.TargetGuidByName(targetname);
        var fileguid = proj.FindFileGuidByProjectPath(filepath);
        Debug.Log("targetguid = " + targetguid);
        Debug.Log("fileguid = " + fileguid);
        var compileflaglist = new List<string>();
        if(isenablearc)
        {
            compileflaglist.Add("-fobjc-arc");
        }
        else
        {
            compileflaglist.Add("-fno-objc-arc");
        }
        proj.SetCompileFlagsForFile(targetguid, fileguid, compileflaglist);
    }
}

这里就不一一截Mac对应的图了，示例代码对XCode的各种参数设置都进行了修改，注释也很清楚了，具体详细的使用，请参考官网API解释。

IOS自动化签包

Xcodebuild是XCode上编译Xcode工程的工具。

所以接下来我们主要是要学习的是使用Xcodebuild去编写自动化签包的工具。

学习XCode Project项目里的一些相关概念。
一下概念来源iOS系统提供开发环境下命令行编译工具：xcodebuild:

1. Workspace：简单来说，Workspace就是一个容器，在该容器中可以存放多个你创建的Xcode Project， 以及其他的项目中需要使用到的文件。
   使用Workspace的好处有：
   • 扩展项目的可视域，即可以在多个项目之间跳转，重构，一个项目可以使用另一个项目的输出。Workspace会负责各个Project之间提供各种相互依赖的关系;
   • 多个项目之间共享Build目录。
2. Project：指一个项目，该项目会负责管理生成一个或者多个软件产品的全部文件和配置，一个Project可以包含多个Target。
3. Target：一个Target是指在一个Project中构建的一个产品，它包含了构建该产品的所有文件，以及如何构建该产品的配置。
4. Scheme：一个定义好构建过程的Target成为一个Scheme。可在Scheme中定义的Target的构建过程有：Build/Run/Test/Profile/Analyze/Archive
5. BuildSetting：配置产品的Build设置，比方说，使用哪个Architectures？使用哪个版本的SDK？。在Xcode Project中，有Project级别的Build Setting，也有Target级别的Build Setting。Build一个产品时一定是针对某个Target的，因此，XCode中总是优先选择Target的Build Setting，如果Target没有配置，则会使用Project的Build Setting。

了解了XCode Project中的一些概念，让我们看看Xcodebuild到底是什么样的工具了？
xcodebuild is a command-line tool that allows you to perform build, query, analyze, test, and archive operations on your Xcode projects and workspaces from the command line. It operates on one or more targets contained in your project, or a scheme contained in your project or workspace.

如果想查看xcodebuild的详细说明，我们可以通过命令行输入:man xcodebuild查看即可:

首先以XcodeProject为例，我们来看看上面的概念在实际操作过程中对应的东西:

从上面可以看出，我们的Demo Xcode Project是没有workspace的，只有一个叫做Unity-iPhone.xcodeproj的Xcode工程文件，而这个文件对应的就是我们前面提到的Project的概念。

如果我们想查看Xcode Project里面的相关schemes或者target信息，我们可以通过命令行切换到Xcode Project目录下然后输入xcodebuild -list -project *.xcodeproj命令来查看:

从上面的信息我们可以看到，我们的Unity-iPhone.xcodeproj项目里有两个Targets分别为:Unity-iPhone和Unity-iPhone Tests以及一个Schemes:Unity-iPhone。这些都分别对应了我们前面最初所了解的相关Xcode Project的概念。

如果想要查看Xcode Project的详细Build Setting设置信息，我们可以通过输入xcodebuild -showBuildSettings来查看：

-showBuildSettings有不少东西，很多概念需要对比着Xcode工程里的设置来看，这里暂时不深究每一个代表什么意思。

了解了Workspace,Project,Target,Scheme,BuildSetting等等概念以及如何通过xcodebuild工具查看Xcode工程相关信息后，接下来我们看一下xcodebuild是如何编译打包导出IPA的。

这里参考网上，我发现Xcode9以后有两种方式来实现自动化打包。

1. Automatic
2. Manual

这里我先以Manual的形式来学习打包，后续再学习了解Automatic的形式打包。

首先我们来看看官方对xcodebuild工具的介绍:
xcodebuild is a command-line tool that allows you to perform build, query, analyze, test, and archive operations on your Xcode projects and workspaces from the command line.
可以看出xcodebuild正式苹果官方给出的通过命令行触发打包编译导出一系列操作的工具。

具体想知道xcodebuild的详细使用介绍，可以在shell里输入man xcodebuild查看即可：

Manual:
手动打包之前，我们要用到下面几个比较重要的xcodebuild命令参数:

1. clean – Remove build products and intermediate files from the build root(SYMROOT)(清楚通过build触发编译的所有中间文件)
2. build – Build the target in the build root(SYMROOT). This is the default action, and is used if no action is given.(build指定target)
3. archive – Archive a scheme from the build root(SYMROOT). This requires specifying a scheme.(打包指定scheme)
4. exportArchive – Specifies that an archive should be exported. Requires -archivePath, -exportPath, and -exportOptionsPlist. Cannot be passed along with an action.(指定Archive文件导出IPA)

下面以工作中完整的命令行编译打包导出IPA为例来讲解学习(敏感信息中文代替):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

#! /bin/bash
# 检查并创建文件夹
CheckAndCreateFolder()
{
    echo "CheckOrCreateFolder parameter1 : $1"
    if [ -d $1 ]
    then 
        echo "$1 exits!"
    else
        echo "$1 not exits!"
        mkdir -p $1
    fi
}

currentfolder=~+
homefolderpath=~
xcodeexportoptionfolderpath="${homefolderpath}/Desktop/XcodeAutoSign/"
currentdatetime=`date +%Y%m%d%H%M%S`

#签包相关信息(默认大陆Appstore)
# 包名
bundleid="对应包名"
# 大陆
areas="dalu"
#证书类型
provisionprofiletype="AppStore"
# 证书名字
codesignidentity="对应证书名字"
# 描述文件名字
provisioningprofile="对应描述文件名字"
# Deployment最低版本指定
deploymenttarget="对应最低IOS支持版本"
# 打包导出配置文件
# 最终签名相关信息都是以配置文件为准
exportoptionsplist="对应签名配置文件"

echo "--------------------"
echo "1. 大陆Appstore"
echo "2. 大陆AdHoc"
echo "3. 台湾Appstore"
echo "4. 台湾AdHoc"
echo "--------------------"
echo "输入打包类型数字id(默认不输入是大陆AppStore):"
read countrynumber
# 默认大陆
echo "countrynumber = ${countrynumber:=1}"

echo "输入工程文件夹全路径:"
read xcodeprojectfolderpath
xcodeprojectfullpath="${xcodeprojectfolderpath}/Unity-iPhone.xcodeproj"
echo "xcodeprojectfullpath : ${xcodeprojectfullpath}"

# 检查工程Xcode项目文件是否存在
if [ -d ${xcodeprojectfullpath} ]
then
    echo "Xcode项目文件存在!"
else
    echo "Xcode项目:${xcodeprojectfullpath}文件不存在!签包IPA失败!" > ErrorLog.txt
    exit 0
fi

if [ $countrynumber -eq 1 ]
then    
    #大陆Appstore
    echo "大陆AppStore"
    areas="dalu"
    provisionprofiletype="AppStore"
    bundleid="对应包名"
    codesignidentity="对应证书名字"
    provisioningprofile="对应描述文件名"
    deploymenttarget="对应最低IOS支持版本"
    exportoptionsplist="对应签名配置文件"
elif [ $countrynumber -eq 2 ]
then
    #大陆Ad Hoc
    echo "大陆AdHoc"
    areas="dalu"
    provisionprofiletype="AdHoc"
    bundleid="对应包名"
    codesignidentity="对应证书名字"
    provisioningprofile="对应描述文件名"
    deploymenttarget="对应最低IOS支持版本"
    exportoptionsplist="对应签名配置文件"
elif [ $countrynumber -eq 3 ]
then
    #台湾Appstore
    echo "台湾Appstore"
    areas="taiwan"
    provisionprofiletype="AppStore"
    bundleid="对应包名"
    codesignidentity="对应证书名字"
    provisioningprofile="对应描述文件名"
    deploymenttarget="对应最低IOS支持版本"
    exportoptionsplist="对应签名配置文件"
elif [ $countrynumber -eq 4 ]
then
    #台湾AdHoc
    echo "台湾AdHoc"
    areas="taiwan"
    provisionprofiletype="AdHoc"
    bundleid="对应包名"
    codesignidentity="对应证书名字"
    provisioningprofile="对应描述文件名"
    deploymenttarget="对应最低IOS支持版本"
    exportoptionsplist="对应签名配置文件"
else
    echo "请输入1或者2或者3或者4!签包失败!" > ErrorLog.txt
    exit 0
fi

# IPA文件名
ipadname="${areas}_${provisionprofiletype}_$currentdatetime"
# IPA输出目录全路径
ipaexportpath="/Users/Shared/build-ios/${areas}/${provisionprofiletype}/${currentdatetime}"
# Archive文件名
archivefilename="${xcodeprojectfolderpath}/${areas}_archive.xcarchive"

# 切换到对应工程目录下
cd $xcodeprojectfolderpath
echo "切换到对应工程目录后当前目录:"
echo ~+

# 检查输出目录是否存在，不存在则创建一个
CheckAndCreateFolder $ipaexportpath

#检查导出配置文件是否路径正确且存在
echo "导出配置文件路径:"
echo "${xcodeexportoptionfolderpath}/${exportoptionsplist}"
if [ -f ${xcodeexportoptionfolderpath}/${exportoptionsplist} ]
then
    echo "导出配置文件存在!"
else
    echo "导出配置文件不存在!签包IPA失败!" > ErrorLog.txt
    exit 0
fi

# 判定符合条件的Archive文件是否存在，
# 存在则直接Export，
# 不存在则完全重新签包
if [ ! -d ${archivefilename} ]
then
    echo "${archivefilename}文件不存在!"
    #clean下工程
    echo "开始清理工程"
    xcodebuild  clean \
                -project Unity-iPhone.xcodeproj \
                -configuration Release -alltargets \
                PRODUCT_BUNDLE_IDENTIFIER="$bundleid"

    #开始编译
    echo "开始编译打包"
    xcodebuild -project Unity-iPhone.xcodeproj \
                -scheme Unity-iPhone \
                -configuration Release \
                PRODUCT_BUNDLE_IDENTIFIER="$bundleid" \
                CODE_SIGN_STYLE="Manual" \
                CODE_SIGN_IDENTITY="$codesignidentity" \
                PROVISIONING_PROFILE="$provisioningprofile" \
                IPHONEOS_DEPLOYMENT_TARGET="$deploymenttarget" \
                -archivePath "${archivefilename}" \
                archive
else
    echo "${archivefilename}文件存在!"
fi
            
#开始打包Archive
echo "开始导出IPA"
xcodebuild -exportArchive \
           -archivePath "${archivefilename}" \
           -exportOptionsPlist "${xcodeexportoptionfolderpath}/${exportoptionsplist}" \
           -exportPath "${ipaexportpath}"

#修改最终输出的ipa文件名
mv -f "${ipaexportpath}/Unity-iPhone.ipa" "${ipaexportpath}/${ipadname}.ipa"

echo "xcodeprojectfolderpath : $xcodeprojectfolderpath"
echo "homefolderpath : $homefolderpath"
echo "ipaexportpath : $ipaexportpath"
echo "bundleid : $bundleid"
echo "codesignidentity : $codesignidentity"
echo "provisioningprofile : $provisioningprofile"
echo "deploymenttarget : $deploymenttarget"
echo "exportoptionsplist : $exportoptionsplist"
echo "xcodeexportoptionfolderpath : $xcodeexportoptionfolderpath"
echo "currentdatetime : $currentdatetime"
echo "ipadname : $ipadname"
echo "archivefilename : $archivefilename"

echo "签包结束."
$SHELL

这里针对上面的自动化签包脚本，我们需要理解几个关键概念：

1. 包名 – 我们平时说的包名，Unity里平台设置那里设置的包名
   Xcode里显示参考下图：
   
2. 证书名字 – IOS开发打包需要的证书文件(比如:Development,Distribution证书)
   因为Apple Developer Account最近刚到期，无法截后台账号的图，这里只放一张Keychain里面显示已经安装在本地的Certificate图:
   
   证书名字通过右键对应Certificate后选择Get Info可查看:
   
3. 描述文件 – 是指后台指定了Certificate,Apple Id, Device List等信息的描述文件
   
   如果想详细查看里面的信息，可以通过下面这个命令:

1

security cmd -D -i *.mobileprovision

这里面就包含了很多信息，这里我们暂时需要通过这个找到描述文件的名字:

4. IOS最低版本支持 – 这个是对应Xcode里设置Deployment Target的那个参数，表示打包支持的最低IOS版本
   
5. 签名配置文件 – 关于导出IPA时的签名信息以及相关参数等的配置文件
   
   让我们看下里面的详细信息:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>method</key>
    <string>app-store</string>
    <key>provisioningProfiles</key>
    <dict>
        <key>对应包名</key>
        <string>对应描述文件名</string>
    </dict>
    <key>signingCertificate</key>
    <string>***</string>
    <key>signingStyle</key>
    <string>manual</string>
    <key>stripSwiftSymbols</key>
    <true/>
    <key>teamID</key>
    <string>***</string>
    <key>uploadSymbols</key>
    <false/>
</dict>
</plist>

可以看到签名配置文件里面指定了导出类型(app-store or development等)，证书名以及包名，描述文件信息等信息。
那么这个配置文件哪里来的了？
手动Archive后，我们会在*.ipa的同层文件目录下得到一个叫ExportOption.plist的文件，这个就是那个配置文件。

Note：
如果我们的程序开启了苹果相关的服务，比如Apple Wallet等，那这些服务会以参数的信息显示在上面的配置文件里，如果后台证书配置了使用特定服务，但该配置文件里没有，就会提示特定字段信息对不上或者遗漏而报错。

可以看出通过上面的自动化，我们可以命令行指定以下内容:

1. 包名
2. 证书
3. 描述文件
4. IOS最低支持版本号
5. 签名证书

接下来我们看看xcodebuild编译里是如何指定这些信息并成功导出IPA的:

1. 清理工程

1
2
3
4

xcodebuild  clean \                              # 指定了清理工程
            -project Unity-iPhone.xcodeproj \    # 指定清理哪一个project
            -configuration Release -alltargets \ # 指定清理Release下的所有targets
            PRODUCT_BUNDLE_IDENTIFIER="$bundleid"# 指定了包名(这一个可能不需要)

2. 编译打包

1
2
3
4
5
6
7
8
9
10

xcodebuild -project Unity-iPhone.xcodeproj \                # 指定打包哪个project
            -scheme Unity-iPhone \                          # 指定打包哪个scheme
            -configuration Release \                        # 指定编译Release
            PRODUCT_BUNDLE_IDENTIFIER="$bundleid" \         # 指定包名
            CODE_SIGN_STYLE="Manual" \                      # 指定手动签名
            CODE_SIGN_IDENTITY="$codesignidentity" \        # 指定证书
            PROVISIONING_PROFILE="$provisioningprofile" \   # 指定描述文件
            IPHONEOS_DEPLOYMENT_TARGET="$deploymenttarget" \# 指定IOS最低版本
            -archivePath "${archivefilename}" \             # 指定生成的Archive文件路径
            archive                                         # 指定编译打包

3. 导出IPA

1
2
3
4

xcodebuild -exportArchive \                                         # 指定导出IPA
           -archivePath "${archivefilename}" \                      # 指定Archive文件路径
           -exportOptionsPlist "${xcodeexportoptionfolderpath}/${exportoptionsplist}" \ # 指定签名配置文件路径
           -exportPath "${ipaexportpath}"                           # 指定IPA输出路径

上面的注释已经很详细了，这里就不在详细讲解了。
通过archive命令，我们得到了一个*.xcarchive的文件。

通过这个*.xcarchive文件，我们可以通过指定签名配置文件导出我们想要的IPA文件。

Automatic:
待续……

References

http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/001374027586935cf69c53637d8458c9aec27dd546a6cd6000)

Jenkins Part

Groovy
Uniy3d Plugin
Jenkins——应用篇——插件使用——Mailer Plugin
Jenkins进阶系列之——01使用email-ext替换Jenkins的默认邮件通知
macOS 安装配置 Jenkins 持续集成 Unity 项目指南
MAC EI Capitan上更新系统自带SVN版本(关闭SIP方能sudo rm)
About System Integrity Protection on your Mac
Email-ext plugin

Shell Part

Unix shell
Shell脚本
Advanced Bash-Scripting Guide

Xcodebuild Part

Xcode 9 最新 最准确 的自动化打包
iOS系统提供开发环境下命令行编译工具：xcodebuild
Building from the Command Line with Xcode FAQ
Build settings reference

Other Part

Editor

Editor Comparison

先如今有很多优秀的编辑器(有些近乎IDE的水准):

1. Sublime Text 3
2. Vim
3. Emacs
4. VS Code
5. Notepade++
   ……

每一种都各有各的优势，作为一个小白用户，连Sublime Text 3和VS Code都算不上使用熟悉，所以这里并不能做详细的比较。

Editor Chosen

How to choose editor?
在选择自己的IDE或则编辑器的时候，我很赞同一句话“没有最厉害最优秀的只有最适合。”
所以哪一种最好最适合取决于我们用它做什么。

What do I need?
作为一个前端程序员，大部分时间是在做手游或者PC端的开发，需要和Android，IOS，PC打交道。
在Windows上主要使用VS，Android Studio作为IDE。
在Mac上使用XCode作为IDE。
主要使用C++,C#,Java,Python,bat,Lua等编程语言。
但VS，Android Studio，XCode都属于比较大型的IDE，这里主要是需要一个轻量级的编辑器。
主要希望有下列功能：

1. 跨平台(跨Mac和Windows开发)
2. 语法高亮
3. 代码补充
4. 调试(option)
5. 快速切换，查询，跳转等方便快捷的快捷修改
6. 快速启动
7. 方便自定义(比如背景，快捷键设置等)
8. 扩展性强(方便添加支持更多功能)
   ……

Why choose Sublime Text 3?
这里就不一一说明Sublime Text 3的好处了，几乎上面我需要的都可以很方便的扩展支持，这也就是为什么选择Sublime Text 3的原因。

Sublime Text 3

Sublime Text 3官网

Install

Download Sublime Text 3

Useful Package

1. Package Control
   Sublime Text 3扩展性强就在于通过安装扩展包，可以得到很多有用的功能支持。
   而帮助快速安装和查找有用的Package，就不得不提Package Control，有了它我们可以快速的搜索和安装想要的Package。
   如何安装Package Control：
   Package Control Installation
   如果不知道有哪些Package，可以在下面官网查询：
   Package Control Package
2. Terminal
   偶尔会需要打开命令行窗口，这个插件可以帮助我们直接在Sublime里通过快捷键快速打开系统自带命令行
   Terminal
   Note:
   虽然Sublime Text 3也有Git相关的插件，但是考虑已经添加了快速打开命令行的插件，并且Git使用不会太频繁，所以不单独添加Git扩展。
3. Markdown
   Markdown是我们经常会去编写文档的一类格式，语法高亮，快速浏览效果是效率的关键。

   1. Markdown Edit
      Better syntax understanding and good color schemes.

   2. Markdown Preview
      ctrl+shift+p，然后输入Markdown Preview: Preview in Browser
      我们去Preference -> Key Binding里去改快速生成Markdown HTML的快捷键

最后得到我们Markdown的网页版：

4. SublimeCodeIntel
   SublimeCodeIntel 作为一个代码提示和补全插件，支持 JavaScript、Mason、XBL、XUL、RHTML、SCSS、Python、HTML、Ruby、Python3、XML、Sass、XSLT、Django、HTML5、Perl、CSS、Twig、Less、Smarty、Node.js、Tcl、TemplateToolkit 和 PHP 等所有语言，是 Sublime Text 自带代码提示功能基础上一个更好的扩展，自带代码提示功能只可提示系统代码，而SublimeCodeIntel则可以提示用户自定义代码。
   这里本人主要是为了配置Python
   因为官网提到Default Settings在更新时会被覆盖，如果要修改设置应该写在User里。
   Preferences -> Package Settings -> SublimeCodeIntel -> Setting User
   配置Python如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32