Python面向對象-高級用法

来源:https://www.cnblogs.com/geoffreygao/archive/2023/03/29/17271010.html
-Advertisement-
Play Games

1.魔法函數 python中常見的內置類型 什麼是魔法函數? python的魔法函數總被雙下劃線包圍,它們可以給你的類增加特殊的方法。如果你的對象實現了這些方法中的一個,那麼這個方法就會在特殊情況下被調用,你可以定義想要 的行為,而這一切都是自動發生的。 魔法函數一覽 魔法函數舉例 1.1.__ge ...


1.魔法函數

python中常見的內置類型

img

什麼是魔法函數?

python的魔法函數總被雙下劃線包圍,它們可以給你的類增加特殊的方法。如果你的對象實現了這些方法中的一個,那麼這個方法就會在特殊情況下被調用,你可以定義想要

的行為,而這一切都是自動發生的。

魔法函數一覽

img

魔法函數舉例

1.1.__getitem__

把對象變成可迭代的對象

例子:

class Company(object):
    def __init__(self,employee_list):
        self.employee = employee_list
    #魔法函數,給類加可迭代類型
    def __getitem__(self, item):
        return self.employee[item]

company = Company(['11','22','33'])

#加了魔法函數“__getitem__”,類就成了可迭代的了
for em in company:
    print(em)    #11,22,33

如果不用魔法函數迴圈出每個員工的方法

class Company(object):
    def __init__(self,employee_list):
        self.employee = employee_list


company = Company(['11','22','33'])

for em in company.employee:
    print(em)

還可以切片和獲取長度

class Company(object):
    def __init__(self,employee_list):
        self.employee = employee_list
    #魔法函數
    def __getitem__(self, item):
        return self.employee[item]

company = Company(['11','22','33'])
#可以切片
company1 = company[:2]
#可以判斷len長度
print(len(company1))   #2

for em in company1:
    print(em)    #11,22

1.2.__len__

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list
    #
    # def __getitem__(self, item):
    #     return self.employee[item]

    def __len__(self):
        return len(self.employee)

company = Company(["11", "22", "33"])

#如果不加魔法函數,len(company)會報錯的
print(len(company))     #3

1.3. __repr____str__

1.安裝交互環境(jupyter)

pip install -i https://pypi.douban.com/simple ipython

pip install -i https://pypi.douban.com/simple notebook

#啟動
ipython notebook

2.__repr____str__的用法

img

img

2.深入類和對象

1.1.鴨子類型和多態

“當看到一隻鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子,那麼這隻鳥就可以被稱為鴨子。”

我們並不關心對象是什麼類型,到底是不是鴨子,只關心行為。

實例一:

# 鴨子類型和多態簡單實例

class Dog(object):
    def say(self):
        print('a dog')


class Cat(object):
    def say(self):
        print('a cat')

class Duck(object):
    def say(self):
        print('a duck')

animal_list = [Dog,Cat,Duck]

for animal in animal_list:
    animal().say()


#運行結果

a dog
a cat
a duck

實例二:

類只要實現了__getitem__方法,它就是可迭代的,並不關心對象的本身,只關心行為,然後就可以當做extend的參數。

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __getitem__(self, item):
        return self.employee[item]


company = Company(["11", "22", "33"])

a = ['derek1','derek2']

name_set = set()

name_set.add('tom1')
name_set.add(('tom2'))

#extend裡面的參數介紹
#def extend(self, iterable):  # real signature unknown; restored from __doc__
    #""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """


#extend裡面可以添加任何可迭代的參數,給類添加一個魔法函數__getitem__,類就變成可迭代的,所以可以extend進去
a.extend(company)
print(a)       #['derek1', 'derek2', '11', '22', '33']

a.extend(name_set)
print(a)       #['derek1', 'derek2', '11', '22', '33', 'tom2', 'tom1']

1.2.抽象基類(abc模塊)

抽象基類的作用類似於JAVA中的介面。在介面中定義各種方法,然後繼承介面的各種類進行具體方法的實現。抽象基類就是定義各種方法而不做具體實現的類,任何繼承自抽象基類的類必須實現這些方法,否則無法實例化

(1)判斷類時候有某種屬性

#判斷類是否有某種屬性

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __len__(self):
        return len(self.employee)

com = Company(["11", "22", "33"])

#hasattr判斷類有沒有某種屬性,方法也是類的屬性
print(hasattr(com,"__len__"))   #True

#雖然用hasattr可以判斷,但正確的方式是定義一個抽象基類

#我們在某些情況下希望判定某個對象的類型,可以用抽象基類
from collections.abc import Sized
print(isinstance(com,Sized))    #True
# print(len(com))
class Sized(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __len__(self):
        return 0

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            return _check_methods(C, "__len__")
        return NotImplemented

(2)abc模塊

簡單抽象基類實例

#模擬一個抽象基類

#寫一個抽象基類,它的子類必須要重寫抽象基類裡面的方法
import abc
#定義一個抽象基類
class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def get(self,key):
        pass

    @abc.abstractclassmethod
    def set(self,key,value):
        pass

#子類,必須有抽象基類裡面的方法,get和set
#假入不寫set方法會報錯

class RedisCache(CacheBase):
    def get(self,key):
        pass
    
    # def set(self,key,value):
    #     pass

redis_cache = RedisCache()
#模擬一個抽象基類

#寫一個抽象基類,它的子類必須要重寫抽象基類裡面的方法
import abc
#定義一個抽象基類
class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def get(self,key):
        pass

    @abc.abstractclassmethod
    def set(self,key,value):
        pass

#子類,必須有抽象基類裡面的方法,get和set
#假入不寫set方法會報錯

class RedisCache(CacheBase):
    def get(self,key):
        pass

    def set(self,key,value):
        pass

redis_cache = RedisCache()

img

(3)abc裡面所有的抽象基類

from collections.abc import *

所有的抽象基類

# Copyright 2007 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
"""

from abc import ABCMeta, abstractmethod
import sys

__all__ = ["Awaitable", "Coroutine",
           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
           "Sized", "Container", "Callable", "Collection",
           "Set", "MutableSet",
           "Mapping", "MutableMapping",
           "MappingView", "KeysView", "ItemsView", "ValuesView",
           "Sequence", "MutableSequence",
           "ByteString",
           ]

# This module has been renamed from collections.abc to _collections_abc to
# speed up interpreter startup. Some of the types such as MutableMapping are
# required early but collections module imports a lot of other modules.
# See issue #19218
__name__ = "collections.abc"

# Private list of types that we want to register with the various ABCs
# so that they will pass tests like:
#       it = iter(somebytearray)
#       assert isinstance(it, Iterable)
# Note:  in other implementations, these types might not be distinct
# and they may have their own implementation specific types that
# are not included on this list.
bytes_iterator = type(iter(b''))
bytearray_iterator = type(iter(bytearray()))
#callable_iterator = ???
dict_keyiterator = type(iter({}.keys()))
dict_valueiterator = type(iter({}.values()))
dict_itemiterator = type(iter({}.items()))
list_iterator = type(iter([]))
list_reverseiterator = type(iter(reversed([])))
range_iterator = type(iter(range(0)))
longrange_iterator = type(iter(range(1 << 1000)))
set_iterator = type(iter(set()))
str_iterator = type(iter(""))
tuple_iterator = type(iter(()))
zip_iterator = type(iter(zip()))
## views ##
dict_keys = type({}.keys())
dict_values = type({}.values())
dict_items = type({}.items())
## misc ##
mappingproxy = type(type.__dict__)
generator = type((lambda: (yield))())
## coroutine ##
async def _coro(): pass
_coro = _coro()
coroutine = type(_coro)
_coro.close()  # Prevent ResourceWarning
del _coro
## asynchronous generator ##
async def _ag(): yield
_ag = _ag()
async_generator = type(_ag)
del _ag


### ONE-TRICK PONIES ###

def _check_methods(C, *methods):
    mro = C.__mro__
    for method in methods:
        for B in mro:
            if method in B.__dict__:
                if B.__dict__[method] is None:
                    return NotImplemented
                break
        else:
            return NotImplemented
    return True

class Hashable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __hash__(self):
        return 0

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Hashable:
            return _check_methods(C, "__hash__")
        return NotImplemented


class Awaitable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __await__(self):
        yield

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Awaitable:
            return _check_methods(C, "__await__")
        return NotImplemented


class Coroutine(Awaitable):

    __slots__ = ()

    @abstractmethod
    def send(self, value):
        """Send a value into the coroutine.
        Return next yielded value or raise StopIteration.
        """
        raise StopIteration

    @abstractmethod
    def throw(self, typ, val=None, tb=None):
        """Raise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

    def close(self):
        """Raise GeneratorExit inside coroutine.
        """
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError("coroutine ignored GeneratorExit")

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Coroutine:
            return _check_methods(C, '__await__', 'send', 'throw', 'close')
        return NotImplemented


Coroutine.register(coroutine)


class AsyncIterable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __aiter__(self):
        return AsyncIterator()

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncIterable:
            return _check_methods(C, "__aiter__")
        return NotImplemented


class AsyncIterator(AsyncIterable):

    __slots__ = ()

    @abstractmethod
    async def __anext__(self):
        """Return the next item or raise StopAsyncIteration when exhausted."""
        raise StopAsyncIteration

    def __aiter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncIterator:
            return _check_methods(C, "__anext__", "__aiter__")
        return NotImplemented


class AsyncGenerator(AsyncIterator):

    __slots__ = ()

    async def __anext__(self):
        """Return the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        """
        return await self.asend(None)

    @abstractmethod
    async def asend(self, value):
        """Send a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        """
        raise StopAsyncIteration

    @abstractmethod
    async def athrow(self, typ, val=None, tb=None):
        """Raise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

    async def aclose(self):
        """Raise GeneratorExit inside coroutine.
        """
        try:
            await self.athrow(GeneratorExit)
        except (GeneratorExit, StopAsyncIteration):
            pass
        else:
            raise RuntimeError("asynchronous generator ignored GeneratorExit")

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncGenerator:
            return _check_methods(C, '__aiter__', '__anext__',
                                  'asend', 'athrow', 'aclose')
        return NotImplemented


AsyncGenerator.register(async_generator)


class Iterable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __iter__(self):
        while False:
            yield None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterable:
            return _check_methods(C, "__iter__")
        return NotImplemented


class Iterator(Iterable):

    __slots__ = ()

    @abstractmethod
    def __next__(self):
        'Return the next item from the iterator. When exhausted, raise StopIteration'
        raise StopIteration

    def __iter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, '__iter__', '__next__')
        return NotImplemented

Iterator.register(bytes_iterator)
Iterator.register(bytearray_iterator)
#Iterator.register(callable_iterator)
Iterator.register(dict_keyiterator)
Iterator.register(dict_valueiterator)
Iterator.register(dict_itemiterator)
Iterator.register(list_iterator)
Iterator.register(list_reverseiterator)
Iterator.register(range_iterator)
Iterator.register(longrange_iterator)
Iterator.register(set_iterator)
Iterator.register(str_iterator)
Iterator.register(tuple_iterator)
Iterator.register(zip_iterator)


class Reversible(Iterable):

    __slots__ = ()

    @abstractmethod
    def __reversed__(self):
        while False:
            yield None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Reversible:
            return _check_methods(C, "__reversed__", "__iter__")
        return NotImplemented


class Generator(Iterator):

    __slots__ = ()

    def __next__(self):
        """Return the next item from the generator.
        When exhausted, raise StopIteration.
        """
        return self.send(None)

    @abstractmethod
    def send(self, value):
        """Send a value into the generator.
        Return next yielded value or raise StopIteration.
        """
        raise StopIteration

    @abstractmethod
    def throw(self, typ, val=None, tb=None):
        """Raise an exception in the generator.
        Return next yielded value or raise StopIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

    def close(self):
        """Raise GeneratorExit inside generator.
        """
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError("generator ignored GeneratorExit")

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Generator:
            return _check_methods(C, '__iter__', '__next__',
                                  'send', 'throw', 'close')
        return NotImplemented

Generator.register(generator)


class Sized(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __len__(self):
        return 0

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            return _check_methods(C, "__len__")
        return NotImplemented


class Container(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __contains__(self, x):
        return False

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Container:
            return _check_methods(C, "__contains__")
        return NotImplemented

class Collection(Sized, Iterable, Container):

    __slots__ = ()

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Collection:
            return _check_methods(C,  "__len__", "__iter__", "__contains__")
        return NotImplemented

class Callable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __call__(self, *args, **kwds):
        return False

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Callable:
            return _check_methods(C, "__call__")
        return NotImplemented


### SETS ###


class Set(Collection):

    """A set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__ and __len__.

    To override the comparisons (presumably for speed, as the
    semantics are fixed), redefine __le__ and __ge__,
    then the other operations will automatically follow suit.
    """

    __slots__ = ()

    def __le__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) > len(other):
            return False
        for elem in self:
            if elem not in other:
                return False
        return True

    def __lt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) < len(other) and self.__le__(other)

    def __gt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) > len(other) and self.__ge__(other)

    def __ge__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) < len(other):
            return False
        for elem in other:
            if elem not in self:
                return False
        return True

    def __eq__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) == len(other) and self.__le__(other)

    @classmethod
    def _from_iterable(cls, it):
        '''Construct an instance of the class from any iterable input.

        Must override this method if the class constructor signature
        does not accept an iterable for an input.
        '''
        return cls(it)

    def __and__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        return self._from_iterable(value for value in other if value in self)

    __rand__ = __and__

    def isdisjoint(self, other):
        'Return True if two sets have a null intersection.'
        for value in other:
            if value in self:
                return False
        return True

    def __or__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        chain = (e for s in (self, other) for e in s)
        return self._from_iterable(chain)

    __ror__ = __or__

    def __sub__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return self._from_iterable(value for value in self
                                   if value not in other)

    def __rsub__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return self._from_iterable(value for value in other
                                   if value not in self)

    def __xor__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return (self - other) | (other - self)

    __rxor__ = __xor__

    def _hash(self):
        """Compute the hash value of a set.

        Note that we don't define __hash__: not all sets are hashable.
        But if you define a hashable set type, its __hash__ should
        call this function.

        This must be compatible __eq__.

        All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        """
        MAX = sys.maxsize
        MASK = 2 * MAX + 1
        n = len(self)
        h = 1927868237 * (n + 1)
        h &= MASK
        for x in self:
            hx = hash(x)
            h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167
            h &= MASK
        h = h * 69069 + 907133923
        h &= MASK
        if h > MAX:
            h -= MASK + 1
        if h == -1:
            h = 590923713
        return h

Set.register(frozenset)


class MutableSet(Set):
    """A mutable set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__, __len__,
    add(), and discard().

    To override the comparisons (presumably for speed, as the
    semantics are fixed), all you have to do is redefine __le__ and
    then the other operations will automatically follow suit.
    """

    __slots__ = ()

    @abstractmethod
    def add(self, value):
        """Add an element."""
        raise NotImplementedError

    @abstractmethod
    def discard(self, value):
        """Remove an element.  Do not raise an exception if absent."""
        raise NotImplementedError

    def remove(self, value):
        """Remove an element. If not a member, raise a KeyError."""
        if value not in self:
            raise KeyError(value)
        self.discard(value)

    def pop(self):
        """Return the popped value.  Raise KeyError if empty."""
        it = iter(self)
        try:
            value = next(it)
        except StopIteration:
            raise KeyError
        self.discard(value)
        return value

    def clear(self):
        """This is slow (creates N new iterators!) but effective."""
        try:
            while True:
                self.pop()
        except KeyError:
            pass

    def __ior__(self, it):
        for value in it:
            self.add(value)
        return self

    def __iand__(self, it):
        for value in (self - it):
            self.discard(value)
        return self

    def __ixor__(self, it):
        if it is self:
            self.clear()
        else:
            if not isinstance(it, Set):
                it = self._from_iterable(it)
            for value in it:
                if value in self:
                    self.discard(value)
                else:
                    self.add(value)
        return self

    def __isub__(self, it):
        if it is self:
            self.clear()
        else:
            for value in it:
                self.discard(value)
        return self

MutableSet.register(set)


### MAPPINGS ###


class Mapping(Collection):

    __slots__ = ()

    """A Mapping is a generic container for associating key/value
    pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __iter__, and __len__.

    """

    @abstractmethod
    def __getitem__(self, key):
        raise KeyError

    def get(self, key, default=None):
        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'
        try:
            return self[key]
        except KeyError:
            return default

    def __contains__(self, key):
        try:
            self[key]
        except KeyError:
            return False
        else:
            return True

    def keys(self):
        "D.keys() -> a set-like object providing a view on D's keys"
        return KeysView(self)

    def items(self):
        "D.items() -> a set-like object providing a view on D's items"
        return ItemsView(self)

    def values(self):
        "D.values() -> an object providing a view on D's values"
        return ValuesView(self)

    def __eq__(self, other):
        if not isinstance(other, Mapping):
            return NotImplemented
        return dict(self.items()) == dict(other.items())

    __reversed__ = None

Mapping.register(mappingproxy)


class MappingView(Sized):

    __slots__ = '_mapping',

    def __init__(self, mapping):
        self._mapping = mapping

    def __len__(self):
        return len(self._mapping)

    def __repr__(self):
        return '{0.__class__.__name__}({0._mapping!r})'.format(self)


class KeysView(MappingView, Set):

    __slots__ = ()

    @classmethod
    def _from_iterable(self, it):
        return set(it)

    def __contains__(self, key):
        return key in self._mapping

    def __iter__(self):
        yield from self._mapping

KeysView.register(dict_keys)


class ItemsView(MappingView, Set):

    __slots__ = ()

    @classmethod
    def _from_iterable(self, it):
        return set(it)

    def __contains__(self, item):
        key, value = item
        try:
            v = self._mapping[key]
        except KeyError:
            return False
        else:
            return v is value or v == value

    def __iter__(self):
        for key in self._mapping:
            yield (key, self._mapping[key])

ItemsView.register(dict_items)


class ValuesView(MappingView):

    __slots__ = ()

    def __contains__(self, value):
        for key in self._mapping:
            v = self._mapping[key]
            if v is value or v == value:
                return True
        return False

    def __iter__(self):
        for key in self._mapping:
            yield self._mapping[key]

ValuesView.register(dict_values)


class MutableMapping(Mapping):

    __slots__ = ()

    """A MutableMapping is a generic container for associating
    key/value pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __setitem__, __delitem__,
    __iter__, and __len__.

    """

    @abstractmethod
    def __setitem__(self, key, value):
        raise KeyError

    @abstractmethod
    def __delitem__(self, key):
        raise KeyError

    __marker = object()

    def pop(self, key, default=__marker):
        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        '''
        try:
            value = self[key]
        except KeyError:
            if default is self.__marker:
                raise
            return default
        else:
            del self[key]
            return value

    def popitem(self):
        '''D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        '''
        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError
        value = self[key]
        del self[key]
        return key, value

    def clear(self):
        'D.clear() -> None.  Remove all items from D.'
        try:
            while True:
                self.popitem()
        except KeyError:
            pass

    def update(*args, **kwds):
        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
            In either case, this is followed by: for k, v in F.items(): D[k] = v
        '''
        if not args:
            raise TypeError("descriptor 'update' of 'MutableMapping' object "
                            "needs an argument")
        self, *args = args
        if len(args) > 1:
            raise TypeError('update expected at most 1 arguments, got %d' %
                            len(args))
        if args:
            other = args[0]
            if isinstance(other, Mapping):
                for key in other:
                    self[key] = other[key]
            elif hasattr(other, "keys"):
                for key in other.keys():
                    self[key] = other[key]
            else:
                for key, value in other:
                    self[key] = value
        for key, value in kwds.items():
            self[key] = value

    def setdefault(self, key, default=None):
        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
        try:
            return self[key]
        except KeyError:
            self[key] = default
        return default

MutableMapping.register(dict)


### SEQUENCES ###


class Sequence(Reversible, Collection):

    """All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    """

    __slots__ = ()

    @abstractmethod
    def __getitem__(self, index):
        raise IndexError

    def __iter__(self):
        i = 0
        try:
            while True:
                v = self[i]
                yield v
                i += 1
        except IndexError:
            return

    def __contains__(self, value):
        for v in self:
            if v is value or v == value:
                return True
        return False

    def __reversed__(self):
        for i in reversed(range(len(self))):
            yield self[i]

    def index(self, value, start=0, stop=None):
        '''S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.
        '''
        if start is not None and start < 0:
            start = max(len(self) + start, 0)
        if stop is not None and stop < 0:
            stop += len(self)

        i = start
        while stop is None or i < stop:
            try:
                v = self[i]
                if v is value or v == value:
                    return i
            except IndexError:
                break
            i += 1
        raise ValueError

    def count(self, value):
        'S.count(value) -> integer -- return number of occurrences of value'
        return sum(1 for v in self if v is value or v == value)

Sequence.register(tuple)
Sequence.register(str)
Sequence.register(range)
Sequence.register(memoryview)


class ByteString(Sequence):

    """This unifies bytes and bytearray.

    XXX Should add all their methods.
    """

    __slots__ = ()

ByteString.register(bytes)
ByteString.register(bytearray)


class MutableSequence(Sequence):

    __slots__ = ()

    """All the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().

    """

    @abstractmethod
    def __setitem__(self, index, value):
        raise IndexError

    @abstractmethod
    def __delitem__(self, index):
        raise IndexError

    @abstractmethod
    def insert(self, index, value):
        'S.insert(index, value) -- insert value before index'
        raise IndexError

    def append(self, value):
        'S.append(value) -- append value to the end of the sequence'
        self.insert(len(self), value)

    def clear(self):
        'S.clear() -> None -- remove all items from S'
        try:
            while True:
                self.pop()
        except IndexError:
            pass

    def reverse(self):
        'S.reverse() -- reverse *IN PLACE*'
        n = len(self)
        for i in range(n//2):
            self[i], self[n-i-1] = self[n-i-1], self[i]

    def extend(self, values):
        'S.extend(iterable) -- extend sequence by appending elements from the iterable'
        for v in values:
            self.append(v)

    def pop(self, index=-1):
        '''S.pop([index]) -> item -- remove and return item at index (default last).
           Raise IndexError if list is empty or index is out of range.
        '''
        v = self[index]
        del self[index]
        return v

    def remove(self, value):
        '''S.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        '''
        del self[self.index(value)]

    def __iadd__(self, values):
        self.extend(values)
        return self

MutableSequence.register(list)
MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString

img

1.3.使用isinstance而不是type

(1)語法

isinstance(object, classinfo)

其中,object 是變數,classinfo 是類型即 (tuple,dict,int,float,list,bool等) 和 class類

若參數 object 是 classinfo 類的實例,或者 object 是 classinfo 類的子類的一個實例, 返回 True。
若 object 不是一個給定類型的的對象, 則返回結果總是False。

若 classinfo 不是一種數據類型或者由數據類型構成的元組,將引發一個 TypeError 異常。

(2)isinstance簡單用法

>>> isinstance(1,int)
True
>>> 
>>> isinstance('1',str)
True
>>> 
>>> isinstance(1,list)
False

(3)type()與isinstance()的區別:

  • 共同點兩者都可以判斷對象類型
  • 不同點對於一個 class 類的子類對象類型判斷,type就不行了,而 isinstance 可以。
class A:
    pass

class B(A):
    pass

b = B()

#判斷b是不是B的類型
print(isinstance(b,B))        #True
# b是不是A的類型呢,也是的
#因為B繼承A,isinstance內部會去檢查繼承鏈
print(isinstance(b,A))        #True

print(type(b) is B)           #True
#b指向了B()對象,雖然A是B的父類,但是A是另外一個對象,它們的id是不相等的
print(type(b) is A)           #False

1.4.類變數和實例變數

python的類變數和實例變數,顧名思義,類變數是指跟類的變數,而實例變數,指跟類的具體實例相關聯的變數

class A:
    #類變數
    bb = 11
    def __init__(self,x,y):
        #實例變數
        self.x = x
        self.y = y

a = A(2,3)
A.bb = 111111
print(a.x,a.y,a.bb)    # 2 3 111111
print(A.bb)            # 111111

a.bb = 2222     #實際上會在實例對象a裡面新建一個屬性bb
print(a.bb)          # 2222
print(A.bb)          # 111111

1.5.類和實例屬性的查找順序

img

class D:
    pass

class C(D):
    pass

class B(D):
    pass

class A(B,C):
    pass

#順序:A,B,C,D
#__mro__,類的屬性查找順序
print(A.__mro__)      #(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

img

class D:
    pass

class E:
    pass

class C(E):
    pass

class B(D):
    pass

class A(B,C):
    pass

#順序:A,B,D,C,E
#__mro__,類的屬性查找順序
print(A.__mro__)      

#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)

1.6.類方法,靜態方法,和實例方法

實例:

class Date():
    #構造函數
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    #實例方法
    def tomorrow(self):
        self.day += 1

    # 靜態方法不用寫self
    @staticmethod
    def parse_from_string(date_str):
        year, month, day = tuple(date_str.split("-"))
        # 靜態方法不好的地方是採用硬編碼,如果用類方法的話就不會了
        return Date(int(year), int(month), int(day))

    #類方法
    @classmethod
    def from_string(cls, date_str):
        year, month, day = tuple(date_str.split("-"))
        # cls:傳進來的類,而不是像靜態方法把類寫死了
        return cls(int(year), int(month), int(day))

    def __str__(self):
        return '%s/%s/%s'%(self.year,self.month,self.day)

if __name__ == "__main__":
    new_day = Date(2018,5,9)
    #實例方法
    new_day.tomorrow()
    print(new_day)       #2018/5/10

    #靜態方法
    date_str = '2018-05-09'
    new_day = Date.parse_from_string(date_str)
    print(new_day)       #2018/5/9

    # 類方法
    date_str = '2018-05-09'
    new_day = Date.from_string(date_str)
    print(new_day)  # 2018/5/9

1.7.python對象的自省機制

在電腦編程中,自省是指一種能力:檢查某些事物以確定它是什麼、它知道什麼以及它能做什麼。自省向程式員提供了極大的靈活性和控制力。

class Person:
    '''人類'''
    name = "user"


class Student(Person):
    def __init__(self,school_name):
        self.school_name = school_name

if __name__ == "__main__":

    user = Student('仙劍')
    #通過 __dict__ 查詢有哪些屬性
    print(user.__dict__)        #{'school_name': '仙劍'}

    print(Person.__dict__)      #{'__module__': '__main__', '__doc__': '人類', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}

    print(Person.__doc__)       #人類

    #可以添加屬性
    user.__dict__['school_addr'] = '北京'
    print(user.school_addr)     #北京


    #dir也可以查看屬性,比__dict__功能更強大
    print(dir(user))
#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'school_addr', 'school_name']

1.8.super函數

super執行的順序

class A:
    def __init__(self):
        print('A')

class B(A):
    def __init__(self):
        print('B')
        super().__init__()


class C(A):
    def __init__(self):
        print('C')
        super().__init__()


class D(B,C):
    def __init__(self):
        print('D')
        super(D, self).__init__()

if __name__ == '__main__':
    print(D.__mro__)          #(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
    d = D()
    
    
#執行結果
D
B
C
A

1.9.with語句(上下文管理器)

#上下文管理器
class Sample:
    def __enter__(self):
        print('enter')
        #獲取資源
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        #釋放資源
        print('exit')

    def do_something(self):
        print('doing something')

#會自動執行enter和exit方法
with Sample() as sample:
    sample.do_something()


# 運行結果
enter
doing something
exit

3.python元類編程

1.1.propety動態屬性

在面向對象編程中,我們一般把名詞性的東西映射成屬性,動詞性的東西映射成方法。在python中他們對應的分別是屬性self.xxx和類方法。但有時我們需要的屬性需要根據其他屬性動態的計算,此時如果直接使用屬性方法處理,會導致數據不同步。下麵介紹@property方法來動態創建類屬性。

from datetime import datetime,date

class User:
    def __init__(self,name,birthday):
        self.name = name
        self.birthday = birthday
        self._age = 0

    @property
    def age(self):
        return datetime.now().year - self.birthday.year

    @age.setter
    def age(self,value):
        self._age = value

if __name__ == '__main__':
    user = User("derek",date(year=1994,month=11,day=11))
    user.age = 23
    print(user._age)   # 23
    print(user.age)    # 24 ,動態計算出來的

1.2.__getattr__和__getattribute__的區別

object.__getattr__(self, name)
找不到attribute的時候,會調用getattr,返回一個值或AttributeError異常。

object.__getattribute__(self, name)
無條件被調用,通過實例訪問屬性。如果class中定義了__getattr__(),則__getattr__()不會被調用(除非顯示調用或引發AttributeError異常)

(1)調用一個不存在的屬性

class User:
    def __init__(self,info={}):
        self.info = info

    # def __getattr__(self, item):
    #     return self.info[item]

if __name__ == '__main__':
    user = User(info={"name":"derek","age":24})
    print(user.name)

會報錯

img

(2)加了__getattr__之後就可以調用了

class User:
    def __init__(self,info={}):
        self.info = info

    #__getattr__是在查找不到屬性的時候調用
    def __getattr__(self, item):
        return self.info[item]

if __name__ == '__main__':
    user = User(info={"name":"derek","age":24})
    print(user.name)    #derek

(3)__getattribute__

class User:
    def __init__(self,info={}):
        self.info = info

    #__getattr__是在查找不到屬性的時候調用
    def __getattr__(self, item):
        return self.info[item]

    #__getattribute不管屬性存不存在,都訪問這個
    def __getattribute__(self, item):
        return "zhang_derek"


if __name__ == '__main__':
    user = User(info={"name":"derek","age":24})
    #不管屬性存不存在,都走__getattribute__
    print(user.name)    #zhang_derek     #即使屬性存在也走__getattribute__
    print(user.test)     #zhang_derek    #不存在的屬性也能列印
    print(user.company)   #zhang_derek   #不存在的屬性也能列印

1.3.屬性描述符

驗證賦值的時候是不是int類型

#屬性描述符

import numbers

#只要一個類實現了下麵三種魔法函數中的一種,這個類就是屬性描述符
class IntField:
    def __get__(self, instance, owner):
        return self.value
    def __set__(self, instance, value):
        if not isinstance(value,numbers.Integral):
            raise ValueError("必須為int")
        self.value = value
    def __delete__(self, instance):
        pass

class User:
    age = IntField()

if __name__ == '__main__':
    user = User()
    user.age = 24
    print(user.age)

如果user.age=24,值是int,可以正常列印

如果user.age='test',傳一個字元串,則會報錯

img

1.4.__new____init__的區別

(1)__new__方法如果不返回對象,不會執行init方法

class User:
    def __new__(cls, *args, **kwargs):
        print("in new")

    def __init__(self,name):
        print("in init")
        self.name = name

# new是用用來控制對象的生成過程,在對象生成之前
# init是用來完善對象的
# 如果new方法不返回對象,則不會調用init函數
if __name__ == '__main__':
    user = User("derek")

運行結果:沒有調用init方法

img

(2)返回對象就會執行init方法

class User:
    def __new__(cls, *args, **kwargs):
        print("in new")         #in new
        print(cls)              #cls是當前class對象    <class '__main__.User'>
        print(type(cls))        #<class 'type'>
        return super().__new__(cls)   #必須返回class對象,才會調用__init__方法

    def __init__(self,name):
        print("in init")        #in init
        print(self)             #self是class的實例對象      <__main__.User object at 0x00000000021B8780>
        print(type(self))       #<class '__main__.User'>
        self.name = name

# new是用用來控制對象的生成過程,在對象生成之前
# init是用來完善對象的
# 如果new方法不返回對象,則不會調用init函數
if __name__ == '__main__':
    user = User(name="derek")

#總結
# __new__ 用來創建實例,在返回的實例上執行__init__,如果不返回實例那麼__init__將不會執行
# __init__ 用來初始化實例,設置屬性什麼的

1.5.自定義元類

(1)前戲:通過傳入不同的字元串動態的創建不同的類

def create_class(name):
    if name == 'user':
        class User:
            def __str__(self):
                return "user"
        return User

    elif name == "company":
        class Company:
            def __str__(self):
                return "company"
        return Company

if __name__ == '__main__':
    Myclass = create_class("user")
    my_obj = Myclass()
    print(my_obj)    #user
    print(type(my_obj))     #<class '__main__.create_class.<locals>.User'>

(2)用type創建

雖然上面的方法能夠創建,但很麻煩,下麵是type創建類的一個簡單實例

# 一個簡單type創建類的例子
#type(object_or_name, bases, dict)
#type裡面有三個參數,第一個類名,第二個基類名,第三個是屬性
User = type("User",(),{"name":"derek"})

my_obj = User()
print(my_obj.name)    #derek

(3)不但可以定義屬性,還可以定義方法

def say(self):     #必須加self
    return "i am derek"

User = type("User",(),{"name":"derek","say":say})

my_obj = User()
print(my_obj.name)     #derek
print(my_obj.say())    #i am derek

(4)讓type創建的類繼承一個基類

def say(self):     #必須加self
    return "i am derek"

class BaseClass:
    def answer(self):
        return "i am baseclass"

#type裡面有三個參數,第一個類名,第二個基類名,第三個是屬性
User = type("User",(BaseClass,),{"name":"derek","say":say})

if __name__ == '__main__':

    my_obj = User()
    print(my_obj.name)          # derek
    print(my_obj.say())         # i am derek
    print(my_obj.answer())      # i am baseclass

1.6.什麼是元類?

元類就是創建類的類,比如上面的type

在實際編碼中,我們一般不直接用type去創建類,而是用元類的寫法,自定義一個元類metaclass去創建

# 把User類創建的過程委托給元類去做,這樣代碼的分離性比較好

class MetaClass(type):
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls,*args, **kwargs)

class User(metaclass=MetaClass):
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return "test"

if __name__ == '__main__':
    #python中類的實例化過程,會首先尋找metaclass,通過metaclass去創建User類
    my_obj = User(name="derek")
    print(my_obj)    #test

4.自定義序列類

1.1.序列類型的分類

img

1.2.序列的+和+=,extend和append的區別

from collections import abc

a = [1,2,]
c = a + [3,4]
print(c)         #[1, 2, 3, 4]

#如果 + 元祖則會報錯, not tuple
# c = a + (3,4)     #TypeError: can only concatenate list (not "tuple") to list

# + 是新生產一個list, += 是就地加,不會新生成list
#用+= 則可以是元祖,後面只要是可迭代的就行
#其原理是python內部抽象基類MutableSequence裡面有個魔法函數__iadd__來實現的
a += (3,4)       #[1, 2, 3, 4]
print(a)

a.extend((5,6))
print(a)        #[1, 2, 3, 4, 5, 6]

a.append((7,8))
print(a)        #[1, 2, 3, 4, 5, 6, (7, 8)]

#可以看到extend和append結果並不一樣,append是把裡面當一個值傳進去,extend是迭代的傳進去

1.3.實現可切片的對象

(1)切片的用法

#模式[start:end:step]
"""
    其中,第一個數字start表示切片開始位置,預設為0;
    第二個數字end表示切片截止(但不包含)位置(預設為列表長度);
    第三個數字step表示切片的步長(預設為1)。
    當start為0時可以省略,當end為列表長度時可以省略,
    當step為1時可以省略,並且省略步長時可以同時省略最後一個冒號。
    另外,當step為負整數時,表示反向切片,這時start應該比end的值要大才行。
"""
aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
#切片返回的是一個新元素,不會改變原有的list

print (aList[::])  # 返回包含原列表中所有元素的新列表            [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print (aList[::-1])  # 返回包含原列表中所有元素的逆序列表        [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
print (aList[::2])  # 隔一個取一個,獲取偶數位置的元素           [3, 5, 7, 11, 15]
print (aList[1::2])  # 隔一個取一個,獲取奇數位置的元素          [4, 6, 9, 13, 17]
print (aList[3:6])  # 指定切片的開始和結束位置                   [6, 7, 9]
print(aList[0:100])  # 切片結束位置大於列表長度時,從列表尾部截斷      [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print(aList[100:])  # 切片開始位置大於列表長度時,返回空列表           []

# aList[len(aList):] = [9]  # 在列表尾部增加元素
# aList[:0] = [1, 2]  # 在列表頭部插入元素
# aList[3:3] = [4]  # 在列表中間位置插入元素
# aList[:3] = [1, 2]  # 替換列表元素,等號兩邊的列表長度相等
# aList[3:] = [4, 5, 6]  # 等號兩邊的列表長度也可以不相等
# aList[::2] = [0] * 3  # 隔一個修改一個
# print (aList)
# aList[::2] = ['a', 'b', 'c']  # 隔一個修改一個
# aList[::2] = [1,2]  # 左側切片不連續,等號兩邊列表長度必須相等  #會報錯
# aList[:3] = []  # 刪除列表中前3個元素


#刪除
# del aList[:3]  # 切片元素連續
# del aList[::2]  # 切片元素不連續,隔一個刪一個

(2)實現對象支持切片操作

from collections import abc
#Sequence協議

import numbers
class Group:
    #支持切片操作
    def __init__(self, group_name, company_name, staffs):
        self.group_name = group_name
        self.company_name = company_name
        self.staffs = staffs

    def __reversed__(self):
        self.staffs.reverse()

    def __getitem__(self, item):
        #當前的類
        cls = type(self)
        #判斷類是不是可切片的對象
        if isinstance(item, slice):
            return cls(group_name=self.group_name, company_name=self.company_name, staffs=self.staffs[item])
        elif isinstance(item, numbers.Integral):
            return cls(group_name=self.group_name, company_name=self.company_name, staffs=[self.staffs[item]])

    def __len__(self):
        return len(self.staffs)

    def __iter__(self):
        return iter(self.staffs)

    def __contains__(self, item):
        if item in self.staffs:
            return True
        else:
            return False

staffs = ["derek1", "derek2", "derek3", "derek4"]
group = Group(company_name="alibaba", group_name="user", staffs=staffs)

#現在對象就成可切片的對象了

#__getitem__
for user in group:
    print(user)

#運行結果
# derek1
# derek2
# derek3
# derek4

#__contains__
if 'derek1' in group:
    print('yes')

1.4.列表生成式,字典推導式

# odd_list = []
# for i in range(21):
#     if i%2 == 1:
#         odd_list.append(i)
# print(odd_list)      #[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]


#列表生成式
#1.取出1-20之間的基數
odd_list = [i for i in range(21) if i %2 == 1]
print(odd_list)     #[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

#2.取出1-20之間的基數的平方
def hadle_item(item):
    return item * item

odd_list = [hadle_item(i) for i in range(21) if i %2 == 1]
print(odd_list)     #[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]

利用字典推導式把字典的key和value做轉換:{key:value}變成{value:key}的形式

# 字典推導式的用法
my_dict = {'derek1':11,'derek2':22,'derek3':33}
reversed_dict = {value:key for key,value in my_dict.items()}
print(reversed_dict)    #{11: 'derek1', 22: 'derek2', 33: 'derek3'}

https://www.cnblogs.com/derek1184405959/p/8579428.html


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Array --JavaScript內置對象 描述 可以用一個變數存儲多種數據類型的Array對象,Array不是關聯數組,不能使用字元串作為索引訪問數組元素,需要使用非負整數的下標訪問數組中的元素。 和對象的某些特征很相似,例如:屬性訪問器一半相似,衍生出的使用 .call() 或者 .apply ...
  • 享元模式(Flyweight Pattern):是一種用於優化對象創建和管理的設計模式。它旨在減少記憶體消耗和提高性能,通過共用具有相同狀態的對象來實現這一目標。 具體來說,享元模式涉及兩個主要的對象:享元工廠和具有共用狀態的享元對象。享元工廠負責創建和管理共用對象,以確保每個對象只被創建一次。享元對 ...
  • 上一篇文章我們介紹了 Vue2模版編譯原理,這一章我們的目標是弄清楚模版 template和響應式數據是如何渲染成最終的DOM。數據更新驅動視圖變化這部分後期會單獨講解 我們先看一下模版和響應式數據是如何渲染成最終DOM 的流程 Vue初始化 new Vue發生了什麼 Vue入口構造函數 funct ...
  • 定義 觀察者模式屬於行為型模式,它定義了對象間的一種一對多的依賴關係,當一個對象的狀態發生改變時,所有依賴於它的對象都將得到通知,並自動更新。 一種一對多的關係中一稱為被觀察者也叫目標對象Subject而多則稱為觀察者對象Observer 觀察者模式中通常有兩個模型,一個觀察者(observer)和 ...
  • UML 類圖 1 類圖的結構 用動物園的類圖結構來舉例,先抽象化動物類如圖所示: 一個類圖包括類名、屬性和行為,類名不用解釋,在介紹屬性和行為前,先瞭解一下訪問許可權: ‘ - ’ private:只有類內部的成員才能訪問 ‘ + ’ public:類內部和類外部都能訪問 ‘ # ’ protecte ...
  • XSS攻擊是什麼? XSS攻擊是指攻擊者利用網站中的漏洞,向頁面中註入惡意腳本,從而獲取用戶的信息或者控制用戶的電腦。 舉一個通俗的例子,早期使用JSP頁面渲染頁面的項目,如果將用戶名改成nick<alert>1</alert>,則當用戶打開頁面時,就會彈出一個警告框,而這個警告框可以被惡意腳本所 ...
  • 使用 VLD 記憶體泄漏檢測工具輔助開發時整理的學習筆記。本篇介紹 VLD 配置文件中配置項 SkipHeapFreeLeaks 的使用方法。 ...
  • 文章目錄 限流基本概念 QPS和連接數控制 傳輸速率 黑白名單 分散式環境 限流方案常用演算法 令牌桶演算法 漏桶演算法 滑動視窗 常用的限流方案 Nginx限流 中間件限流 限流組件 合法性驗證限流 Guava限流 網關層限流 從架構維度考慮限流設計 具體的實現限流的手段: Tomcat限流 限流基本概 ...
一周排行
    -Advertisement-
    Play Games
  • 下麵是一個標準的IDistributedCache用例: public class SomeService(IDistributedCache cache) { public async Task<SomeInformation> GetSomeInformationAsync (string na ...
  • 這個庫提供了在啟動期間實例化已註冊的單例,而不是在首次使用它時實例化。 單例通常在首次使用時創建,這可能會導致響應傳入請求的延遲高於平時。在註冊時創建實例有助於防止第一次Request請求的SLA 以往我們要在註冊的時候實例單例可能會這樣寫: //註冊: services.AddSingleton< ...
  • 最近公司的很多項目都要改單點登錄了,不過大部分都還沒敲定,目前立刻要做的就只有一個比較老的項目 先改一個試試手,主要目標就是最短最快實現功能 首先因為要保留原登錄方式,所以頁面上的改動就是在原來登錄頁面下加一個SSO登錄入口 用超鏈接寫的入口,頁面改造後如下圖: 其中超鏈接的 href="Staff ...
  • Like運算符很好用,特別是它所提供的其中*、?這兩種通配符,在Windows文件系統和各類項目中運用非常廣泛。 但Like運算符僅在VB中支持,在C#中,如何實現呢? 以下是關於LikeString的四種實現方式,其中第四種為Regex正則表達式實現,且在.NET Standard 2.0及以上平... ...
  • 一:背景 1. 講故事 前些天有位朋友找到我,說他們的程式記憶體會偶發性暴漲,自己分析了下是非托管記憶體問題,讓我幫忙看下怎麼回事?哈哈,看到這個dump我還是非常有興趣的,居然還有這種游戲幣自助機類型的程式,下次去大玩家看看他們出幣的機器後端是不是C#寫的?由於dump是linux上的程式,剛好win ...
  • 前言 大家好,我是老馬。很高興遇到你。 我們為 java 開發者實現了 java 版本的 nginx https://github.com/houbb/nginx4j 如果你想知道 servlet 如何處理的,可以參考我的另一個項目: 手寫從零實現簡易版 tomcat minicat 手寫 ngin ...
  • 上一次的介紹,主要圍繞如何統一去捕獲異常,以及為每一種異常添加自己的Mapper實現,並且我們知道,當在ExceptionMapper中返回非200的Response,不支持application/json的響應類型,而是寫死的text/plain類型。 Filter為二方包異常手動捕獲 參考:ht ...
  • 大家好,我是R哥。 今天分享一個爽飛了的面試輔導 case: 這個杭州兄弟空窗期 1 個月+,面試了 6 家公司 0 Offer,不知道問題出在哪,難道是杭州的 IT 崩盤了麽? 報名面試輔導後,經過一個多月的輔導打磨,現在成功入職某上市公司,漲薪 30%+,955 工作制,不咋加班,還不捲。 其他 ...
  • 引入依賴 <!--Freemarker wls--> <dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.30</version> </dependency> ...
  • 你應如何運行程式 互動式命令模式 開始一個互動式會話 一般是在操作系統命令行下輸入python,且不帶任何參數 系統路徑 如果沒有設置系統的PATH環境變數來包括Python的安裝路徑,可能需要機器上Python可執行文件的完整路徑來代替python 運行的位置:代碼位置 不要輸入的內容:提示符和註 ...