Python 语法糖

\\，换行连接

s = \'\'
s += \'a\' + \\
     \'b\' + \\
     \'c\'
n = 1 + 2 + \\
3
# 6

while，for 循环外的 else

如果 while 循环正常结束（没有break退出）就会执行else。

num = [1,2,3,4]
mark = 0
while mark < len(num):
    n = num[mark]
    if n % 2 == 0:
        print(n)
        # break
    mark += 1
else: print(\"done\")

zip() 并行迭代

a = [1,2,3]
b = [\'one\',\'two\',\'three\']
list(zip(a,b))
# [(1, \'one\'), (2, \'two\'), (3, \'three\')]

列表推导式

x = [num for num in range(6)]
# [0, 1, 2, 3, 4, 5]
y = [num for num in range(6) if num % 2 == 0]
# [0, 2, 4]

# 多层嵌套
rows = range(1,4)
cols = range(1,3)
for i in rows:
    for j in cols:
        print(i,j)
# 同
rows = range(1,4)
cols = range(1,3)
x = [(i,j) for i in rows for j in cols]

字典推导式

{ key_exp : value_exp fro expression in iterable }

#查询每个字母出现的次数。
strs = \'Hello World\'
s = { k : strs.count(k) for k in set(strs) }

集合推导式

{expression for expression in iterable }

元组没有推导式

本以为元组推导式是列表推导式改成括号，后来发现那个 生成器推导式。

生成器推导式

>>> num = ( x for x in range(5) )
>>> num
...: at 0x7f50926758e0>

函数

函数关键字参数，默认参数值

def do(a=0,b,c)
    return (a,b,c)

do(a=1,b=3,c=2)

函数默认参数值在函数定义时已经计算出来，而不是在程序运行时。
列表字典等可变数据类型不可以作为默认参数值。

def buygy(arg, result=[]):
    result.append(arg)
    print(result)

changed：

def nobuygy(arg, result=None):
    if result == None:
        result = []
    result.append(arg)
    print(result)
# or
def nobuygy2(arg):
    result = []
    result.append(arg)
    print(result)

*args 收集位置参数

def do(*args):
    print(args)
do(1,2,3)
(1,2,3,\'d\')

**kwargs 收集关键字参数

def do(**kwargs):
  print(kwargs)
do(a=1,b=2,c=\'la\')
# {\'c\': \'la\', \'a\': 1, \'b\': 2}

lamba 匿名函数

a = lambda x: x*x
a(4)
# 16

生成器

生成器是用来创建Python序列的一个对象。可以用它迭代序列而不需要在内存中创建和存储整个序列。
通常，生成器是为迭代器产生数据的。

生成器函数函数和普通函数类似，返回值使用 yield 而不是 return 。

def my_range(first=0,last=10,step=1):
    number = first
    while number < last:
        yield number
        number += step

>>> my_range()
... 

装饰器

有时需要在不改变源代码的情况下修改已经存在的函数。
装饰器实质上是一个函数，它把函数作为参数输入到另一个函数。
举个栗子：

# 一个装饰器
def document_it(func):
    def new_function(*args, **kwargs):
        print(\"Runing function: \", func.__name__)
        print(\"Positional arguments: \", args)
        print(\"Keyword arguments: \", kwargs)
        result = func(*args, **kwargs)
        print(\"Result: \" ,result)
        return result
    return new_function

# 人工赋值
def add_ints(a, b):
    return a + b

cooler_add_ints = document_it(add_ints) #人工对装饰器赋值
cooler_add_ints(3,5)

# 函数器前加装饰器名字
@document_it
def add_ints(a, b):
    return a + b

可以使用多个装饰器，多个装饰由内向外向外顺序执行。

命名空间和作用域

a = 1234
def test():
    print(\"a = \",a) # True
####
a = 1234
def test():
    a = a -1    #False
    print(\"a = \",a)

可以使用全局变量 global a 。

a = 1234
def test():
    global a
    a = a -1    #True
    print(\"a = \",a)

Python 提供了两个获取命名空间内容的函数
local()
global()

_ 和 __

Python 保留用法。
举个栗子：

def amazing():
    \'\'\'This is the amazing.
    Hello
    world\'\'\'
    print(\"The function named: \", amazing.__name__)
    print(\"The function docstring is: \\n\", amazing.__doc__)

异常处理，try…except

只有错误发生时才执行的代码。
举个栗子：

>>> l = [1,2,3]
>>> index = 5
>>> l[index]
Traceback (most recent call last):
  File \"\", line 1, in 
IndexError: list index out of range

再试下：

>>> l = [1,2,3]
>>> index = 5
>>> try:
...     l[index]
... except:
...     print(\"Error: need a position between 0 and\", len(l)-1, \", But got\", index)
...
Error: need a position between 0 and 2 , But got 5

没有自定异常类型使用任何错误。

获取异常对象，except exceptiontype as name

short_list = [1,2,3]
while 1:
    value = input(\"Position [q to quit]? \")
    if value == \'q\':
        break
    try:
        position = int(value)
        print(short_list[position])
    except IndexError as err:
        print(\"Bad index: \", position)
    except Exception as other:
        print(\"Something else broke: \", other)

自定义异常

异常是一个类。类 Exception 的子类。

class UppercaseException(Exception):
    pass

words = [\'a\',\'b\',\'c\',\'AA\']
for i in words:
    if i.isupper():
        raise UppercaseException(i)
# error
Traceback (most recent call last):
  File \"\", line 3, in 
__main__.UppercaseException: AA

命令行参数

命令行参数

python文件：

import sys
print(sys.argv)

PPrint()友好输出

与print()用法相同，输出结果像是列表字典时会不同。

类

子类super()调用父类方法

举个栗子：

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

class email(Person):
    def __init__(self, name, email):
        super().__init__(name)
        self.email = email

a = email(\'me\', \'me@me.me\')
>>> a.name
... \'me\'
>>> a.email
... \'me@me.me\'

self.__name 保护私有特性

class Person():
    def __init__(self, name):
        self.__name = name
a = Person(\'me\')
>>> a.name
... AttributeError: \'Person\' object has no attribute \'__name\'

# 小技巧
a._Person__name

实例方法( instance method )

实例方法，以self作为第一个参数，当它被调用时，Python会把调用该方法的的对象作为self参数传入。

class A():
    count = 2
    def __init__(self): # 这就是一个实例方法
        A.count += 1

类方法 @classmethod

class A():
    count = 2
    def __init__(self):
        A.count += 1
    @classmethod
    def hello(h):
        print(\"hello\",h.count)

注意，使用h.count(类特征)，而不是self.count(对象特征)。

静态方法 @staticmethod

class A():
    @staticmethod
    def hello():
        print(\"hello, staticmethod\")
>>> A.hello()

创建即用，优雅不失风格。

特殊方法(sqecial method)

一个普通方法：

class word():
    def __init__(self, text):
        self.text = text
    def equals(self, word2): #注意
        return self.text.lower() == word2.text.lower()
a1 = word(\'aa\')
a2 = word(\'AA\')
a3 = word(\'33\')
a1.equals(a2)
# True

使用特殊方法：

class word():
    def __init__(self, text):
        self.text = text
    def __eq__(self, word2): #注意，使用__eq__
        return self.text.lower() == word2.text.lower()
a1 = word(\'aa\')
a2 = word(\'AA\')
a3 = word(\'33\')
a1 == a2
# True

其他还有：

*方法名*                        *使用*
__eq__(self, other)            self == other
__ne__(self, other)            self != other
__lt__(self, other)            self < other
__gt__(self, other)            self > other
__le__(self, other)            self <= other
__ge__(self, other)            self >= other

__add__(self, other)        self + other
__sub__(self, other)        self - other
__mul__(self, other)        self * other
__floordiv__(self, other)    self // other
__truediv__(self, other)        self / other
__mod__(self, other)        self % other
__pow__(self, other)        self ** other

__str__(self)                str(self)
__repr__(self)                repr(self)
__len__(self)                len(self)

文本字符串

\'%-10d | %-10f | %10s | %10x\' % ( 1, 1.2, \'ccc\', 0xf )
#
\'1          | 1.200000   |        ccc |         33\'

{} 和 .format

\'{} {} {}\'.format(11,22,33)
# 11 22 33
\'{2:2d} {0:-10d} {1:10d}\'.format(11,22,33)
# :后面是格式标识符
# 33 11 22

\'{a} {b} {c}\'.format(a=11,b=22,c=33)