Python 함수 클래스 구문 설탕

Python 구문 설탕

, 개행 연결

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

while, else for 루프 외부

while 루프가 정상적으로 끝나면 실행됩니다(break 종료 없음). ) 또 다른.

num = [1,2,3,4]
mark = 0while mark < len(num):
    n = num[mark]    if n % 2 == 0:   
     print(n)        # break
    mark += 1else: 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 표현식 in iterable }

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

집합 파생

{iterable의 표현식에 대한 표현식 }

튜플에는 파생이 없습니다

튜플 파생입니다 수식이 변경되었습니다 목록 이해에서 괄호까지, 나중에 생성기 이해를 발견했습니다.

제너레이터 파생

>>> num = ( x for x in range(5) )>>> num
...:<generator object <genexpr> 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()
... <generator object my_range at 0x7f02ea0a2bf8>

装饰器

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

# 一个装饰器
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 "<stdin>", line 1, in 
  <module>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

hort_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 "<stdin>", line 3, in <module>
__main__.UppercaseException: AA

命令行参数

命令行参数

python文件：

import sys
print(sys.argv)

PPrint()友好输出

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

类

子类super()调用父类方法

举个栗子：

class Person():
    def __init__(self, name):
        self.name = nameclass 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

# 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)