Python 函数类语法糖

ralap 发布于2019-07-25 10:43 / 626人阅读

摘要：语法糖，换行连接，循环外的如果循环正常结束没有退出就会执行。生成器函数函数和普通函数类似，返回值使用而不是。装饰器有时需要在不改变源代码的情况下修改已经存在的函数。提供了两个获取命名空间内容的函数和保留用法。

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: 
", 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)

超融合服务器私有云 python 语法糖语法糖 python 类函数 python类函数

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/38121.html

Python装饰器的另类用法

摘要：今天我们一起探讨一下装饰器的另类用法。语法回顾开始之前我们再将装饰器的语法回顾一下。例子本身只是演示了装饰器的一种用法，但不是推荐你就这样使用装饰器。类装饰器在以前，还不支持类装饰器。之前有比较系统介绍过Python的装饰器（请查阅《详解Python装饰器》），本文算是一个补充。今天我们一起探讨一下装饰器的另类用法。语法回顾开始之前我们再将Python装饰器的语法回顾一下。 @d...

hqman 2019-07-31 10:52 评论0 收藏0
【Python】一文弄懂python装饰器（附源码例子）

摘要：装饰器的使用符合了面向对象编程的开放封闭原则。三简单的装饰器基于上面的函数执行时间的需求，我们就手写一个简单的装饰器进行实现。函数体就是要实现装饰器的内容。类装饰器的实现是调用了类里面的函数。类装饰器的写法比我们装饰器函数的写法更加简单。目录前言一、什么是装饰器二、为什么要用装饰器 ...

liuchengxu 2021-09-04 16:40 评论0 收藏0
简单理解Python装饰器

摘要：下面我们一起抛去无关概念，简单地理解下的装饰器。用函数实现装饰器装饰器要求入参是函数对象，返回值是函数对象，嵌套函数完全能胜任。为了对调用方透明，装饰器返回的对象要伪装成被装饰的函数。来源：http://www.lightxue.com/under... Python有大量强大又贴心的特性，如果要列个最受欢迎排行榜，那么装饰器绝对会在其中。刚接触装饰器，会...

Meils 2019-07-30 14:42 评论0 收藏0
Python “黑魔法” 之 Meta Classes

摘要：幸而，提供了造物主的接口这便是，或者称为元类。接下来我们将通过一个栗子感受的黑魔法，不过在此之前，我们要先了解一个语法糖。此外，在一些小型的库中，也有元类的身影。首发于我的博客转载请注明出处接触过 Django 的同学都应该十分熟悉它的 ORM 系统。对于 python 新手而言，这是一项几乎可以被称作黑科技的特性：只要你在models.py中随便定义一个Model的子类，Dj...

LeoHsiun 2019-07-24 18:26 评论0 收藏0
Python技术点

摘要：内置函数实现对可迭代对象进行进一步处理。文件文件的打开权限打开文件，文件不存在报异常写入文件，文件不存在则创建。文件不存在则创建。追加文件，具有读写权限。 Python基础类型： 1.Tuple元组，内容不可改变，但是允许元素内部存在list等类型的元素，并且允许改变列表的值，所谓内容不可变指的是在内存中指向的地址是不变的。 temp=(1,2,[3,4]) temp[-1]....

Lionad-Morotar 2019-07-25 11:33 评论0 收藏0