name = "xiangxiao" √
name= "xiangxiao" ×

list = [1, 2, 3] √
list = [1,2, 3]  ×

# 注意name，age后面，紧跟了参数
def get_name_and_age(name="xiao", age=10)    √
    pass

def get_name_and_age(name = "xiao", age = 10) ×
    pass

# Java是通过驼峰来增加可读性的
# Python推荐用下划线来增加可读性
def my_function():  √
# is better than
def myFunction():   △

class Girl(object): 
    name = "HuangYinQi"
    _age = 30
    __password = "woshixiaoxiannv"

    def get_name():
        return name

    def get_birth_year():
        return 2018 - _get_age()

    def _get_age():
        return _age

    def __get_password():
        return __password

print Girl.__password
AttributeError: class Girl has no attribute '__password'
print Girl._Girl__password
woshixiaoxiannv

if name in my_dict: √

if my_dict.haskey("name"):  △

>>> "ild" in "Children" # True

my_num = ''.join(("1", "2", "3"))  √
# is faster than
my_num = "1" + "2" + "3"           △

"My name is {}, I am {} years old".format("xiangxiao", 18)
# Or
"My name is {0}, I am {1} years old".format("xiangxiao", 18)
# Or
"My name is {name}, I am {age} years old".format(name="xiangxiao", age=18)

# is better Than

"My name is %s, I am %d years old" % ("XiangXiao", 18)  △

还可以通过在花括号内添加【:格式符】指定格式：
print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))
print("{:*^20s}".format("Sammy"))

lst = [1, 2, 3]
lst == lst[:]  # True
lst is lst[:]  # False， Python重新分配了空间给列表的切片

class Negator(object):
    def __eq__(self,other):
        return not other

thing = Negator()
print thing == None    # True
print thing is None    # False

print "" is None # False
print not ""     # True
print not None   # True

if value:   # 当value不为空且不为""、[]等看起来空的值时

if not value: # 当value位空或不为""、[]等看起来空的值时

try:
    # block 1
except [异常类型 as e]:
    # block 2, 发生异常时， 执行此处
[else]:
    # block 3, 当block 1被顺利执行完没有捕捉到异常, 执行此处
[finally]:
    # block 4, 当1——>2或1——>3执行完，必定执行此处哪怕在1,2,3中有raise，sys.exit等中断操作

for number in number_list:
而不是
for i in range(0, len(number_list)):
    number = number_list[i]

if x is not None
而不是
if not x.equals(None)

num = [1, -2, 3, -4, 5]
new_list = [x**2 for x in num if x > 0]

def get_name_and_age():
    return self.name, self.age

# Python支持函数返回不止一个返回值，通过把几个值包装为一个tuple实现
# 当使用这个函数却只用到其中一个值时，可以用_代表废弃的那个

_, her_age = get_name_and_age()

def query_ecs_endpoint(self):
    return self.host, self.port

query_image_detail_url = 'https://{0}:{1}/v2/images'.format(*query_ecs_endpoint())

def get_server_info(self):
    return {"tenant_id": self.project_id, "server_id": self.ecs_id}

query_ecs_detail_url = 'https://{}:{}/v2.1/{tenant_id}/servers/{server_id}'.format(*query_ecs_endpoint, **get_server_info())

def sum(*values, **options):
    s = 0
    for i in values:
        s = s + i
    if options.get("neg") is True:
        s = -s
    return s

s = sum(1,2,3, neg=True)  # -6
s = sum(1,2,3, neg=False) # 6
s = sum(1,2,3)            # 6

for server_id in server_id_list: # 很帅很Pythonic但是如果我要序号信息怎么办？即一般循环中的i参数

for (i, server_id) in enumerate(server_id_list):
    logging.info("开始处理第{}台服务器：{}".format(i, server_id)
# output:
    开始处理第0台服务器:471a-451b....
    开始处理第1台服务器:1asz-9952....

for (i, server_id) in enumerate(server_id_list, 1):

# 正着数：
  0    1    2    3
["a", "b", "c", "d"]
 -4    -3   -2   -1
# 倒着数

# 翻转列表
a = ["a", "b", "c", "d"]
b = a[::-1] # 省略start和end就表示从-1到-4, step=-1, 所以从-1开始减到-4, b = ["d", "c", "b", "a"]

# 偶序数值
b = a[::2]
# b = ["a", "c"]

a[-1] # 取最后一个值
a[-2:] # 取最后俩
a[:-3] # 去掉最后仨
a[:3] + a[4:] # 去掉第四个
等等

# test.py
def foo():
    print "I am your father"

if __name__ == "__main__":
    foo()

# 通过python 脚本名执行
~> python test.py
~> I am your father

# my_module.py
class bar():
    def say_hi():
        print "{}'s name is {}".format(__file__, __name__）

if __name__ == "__main__":
    b = bar()
    b.say_hi()


# 在test.py中引用my_module中的类
from my_module import bar

def foo():
    print "{}'s name is {}".format(__file__, __name__）

if __name__ == "__main__":
    foo()
    test_b = bar()
    test_b.say_hi()

~> python test.py
~> test.py's name is __main__
   my_module.py's name is my_module

import <package> [as xxx]
import <module>  [as xxx]
from <package> import <module or subpackage or object> [as xxx]
from <module> import <object> [as xxx]

import sys
print sys.path

# output:
[
    "",
    "C:\\Python36\\Scripts\\ipython.exe",
    "c:\\python36\\python36.zip",
    "c:\\python36\\DLLs",
    "c:\\python36\\lib",
    "c:\\python36",
    "c:\\python36\\lib\\site-packages",
    "c:\\python36\\lib\\site-packages\\openpyxl-2.5.2-py3.6.egg",
    "c:\\python36\\lib\\site-packages\\pip-8.1.2-py3.6.egg",
    "c:\\python36\\lib\\site-packages\\IPython\\extensions",
    "C:\\Users\\x00442516\\.ipython"
]

# 绝对引入，视角是从根目录来看的，即test/
import other
import packA.a2
import packA.subA.sa1

# 显式相对引入，视角是从当前module来看的，即a1.py
import other
from . import a2
from .subA import sa1

# 隐式相对引入，就是没有.视角是从当前module来看的, 即a1.py。 【该方式Python3将不可使用】
import other
import a2
import subA.sa1

                         encode
    字符串       ---------------------->     字节串
unicode string  <-----code points----->   UTF-8 string
（unicode类型）  <----------------------   （str类型）
                         decode

>>> s = Unicode("你")
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 0:
ordinal not in range(128)

>>> u"你abc".encode("utf-8")
>>> '\xe4\xbd\xa0abc'  # "你"用三个字节来表示，"abc"小于128，原封不动

>>> u"你abc".encode("ascii")
UnicodeEncodeError: 'ascii' codec can't encode character u'\uf4u0' in
position 0: ordinal not in range(128)

>>> "你", type("你")
>>> ('\xe4\xbd\xa0', str)
>>> "你".decode("utf8"), type("你".decode("utf8"))
>>> (u'\u4f60', unicode) 

# 假设读取的文件是utf8编码的
with open("myfile.txt", "rb") as f:
    text = f.read().decode("utf8")

# 写
with open("output.txt", "rb") as f:
    f.write(text.encode("utf8"))

content = '{"名字":　"小明"}' # str类型, 如果是unicode的话就不用考虑解码问题了
mydict = json.loads(content, encoding="latin-1")  # 如不指定encoding，将使用utf-8解码

mydict[u"年龄"] = 18 # 注意用unicode来暂存字符串
return json.dumps(mydict, ensure_ascii=False)

                         encode
    字符串       ---------------------->     字节串
unicode string  <-----code points----->    二进制string
  （str类型）    <----------------------   （bytes类型）
                         decode

class Test(object):
    s_var = 0
    def __init__(self):
        self.name = "Mike"

    @staticmethod
    def s_func():
        print "hello"

    @classmethod
    def c_func(cls):
        return cls.s_var

    @classmethod
    def wrong_c_func():
        pass

>>> Test.c_func()
>>> 0
>>> Test.wrong_c_func()
>>> TypeError: wrong_c_func() takes no arguments (1 given) # 默认传进来的参数，Test

  "display": [
{
  "label": "地域",
  "type": "string",
  "value": "diyu1-ss(zm_vdc_project)"
},
{
  "label": "名称",
  "type": "string",
  "value": "ecs-1bfd"
},
{
  "label": "可用分区",
  "type": "string",
  "value": "kvm.type2"
},
{
  "label": "规格",
  "type": "string",
  "value": "sp002"
},
{
  "label": "镜像",
  "type": "string",
  "value": "cirros_kvm"
}


labels = [u"地域", u"名称", u"可用分区", u"规格", u"镜像"]
values = [u"diyu1-ss(zm_vdc_project)", "ecs-1bfd", "kvm.type2", "sp002", "cirros_kvm"]

display = [{
    "label": l,
    "type": "string",
    "value": v
} for l, v in zip(labels, values)]

def quicksort(array):
    if len(array) < 2:
        return array
    else:
        pivot = array[0]
        less = [i for i in array[1:] if i <= pivot]
        greater = [i for i in array[1:] if i >pivot]
        return quicksort(less) + [pivot] + quicksort(greater)

def q_sort(l):
    return l if len(l) < 2 else q_sort([el for el in l[1:] if el <= l[0]]) + [l[0]] + q_sort([el for el in l[1:] if el <= l[0]])

# java    
List<Integer> oldList = ...

List<String> newList = new ArrayList<String>(oldList.size()) 

for (Integer myInt : oldList) { 
    newList.add(String.valueOf(myInt)); 
}

# Python
new_list = map(str, old_list)

# 不谋而合的guava
import com.google.common.collect.Lists;
import com.google.common.base.Functions

List<Integer> integers = Arrays.asList(1, 2, 3, 4);
List<String> strings = Lists.transform(integers, Functions.toStringFunction());

# lambda
# 按value的大小顺序打印key
for key, value in sorted(my_dict.items(), key=lambda x: x[1]):
    print key

a_set = {1， 2， 3}
a_iterator = iter(a_set) # type(a_iterator) = iterator

class Series(object):
    def __init__(self, low, high):
        self.current = low
        self.high = high

    def __iter__(self): # 在Python2中这个函数叫iter
        return self

    def __next__(self): # 在Python2中这个函数叫next
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

n_list = Series(1,10)    
print(list(n_list))

 class Player():

    def __init__(self, name):
        self.name = name

    def __contains__(self, substring):
        if substring in self.name:
            return True
        else:
            return False

obj1 = Player("Sam")
print ('am' in obj1)    ----> True
print ('ami' in obj1)   ----> False

def series_generator(low, high):
    while low <= high:
       yield low # break, 这里就是
       low += 1

n_list = []
for num in series_generator(1,10):
    n_list.append(num)

print(n_list)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

import sys

l_10 = [x for x in range(10)]
g_10 = series_generator(0, 9)
print sys.getsizeof(l_10), sys.getsizeof(g_10) # 100, 40

l_100000 = [x for x in range(100000)]
g_100000 = series_generator(0, 99999)
sys.getsizeof(l_100000), sys.getsizeof(g_100000) # 412236, 40

(x for x in range(10) if x % 2 == 0) # 返回生成器
[x for x in range(10) if x % 2 == 0] # 返回