當(dāng)前位置：首頁 > 公眾號(hào)精選 > AI科技大本營

整理了?70?個(gè)?Python?面向?qū)ο缶幊贪咐?，怎能不收藏?/h1>
時(shí)間：2021-11-29 14:53:08
關(guān)鍵字： 面向?qū)ο缶幊?/a>   
手機(jī)看文章

掃描二維碼
隨時(shí)隨地手機(jī)看文章

[導(dǎo)讀]作者|周蘿卜來源|蘿卜大雜燴Python作為一門面向?qū)ο缶幊陶Z言，常用的面向?qū)ο笾R(shí)怎么能不清楚呢，今天就來分享一波文章很長，高低要忍一下，如果忍不了，那就收藏吧，總會(huì)用到的在Python中創(chuàng)建一個(gè)類及其對(duì)象在Python中創(chuàng)建一個(gè)空類在Python中使用Type創(chuàng)建類在Pyth...


作者 | 周蘿卜


來源 | 蘿卜大雜燴


Python 作為一門面向?qū)ο缶幊?/a>語言，常用的面向?qū)ο笾R(shí)怎么能不清楚呢，今天就來分享一波
文章很長，高低要忍一下，如果忍不了，那就收藏吧，總會(huì)用到的
  • 在 Python 中創(chuàng)建一個(gè)類及其對(duì)象


  • 在 Python 中創(chuàng)建一個(gè)空類


  • 在 Python 中使用 Type 創(chuàng)建類


  • 在 Python 中創(chuàng)建和調(diào)用類的方法


  • 使用 __init__() 方法為數(shù)據(jù)屬性賦值


  • 在 Python 中更新對(duì)象屬性


  • 在 Python 中刪除對(duì)象屬性和對(duì)象


  • 在 Python 中檢查和比較對(duì)象的類型


  • 在Python中將對(duì)象的所有屬性復(fù)制到另一個(gè)對(duì)象


  • 在 Python 中迭代對(duì)象屬性


  • 在 Python 中打印對(duì)象的所有屬性


  • 在python中在運(yùn)行時(shí)創(chuàng)建類的數(shù)據(jù)屬性


  • 在函數(shù)中將對(duì)象的實(shí)例作為參數(shù)傳遞


  • 在 Python 中創(chuàng)建和使用自定義 Self 參數(shù)


  • 使用self參數(shù)來維護(hù)對(duì)象的狀態(tài)


  • 在 Python 中創(chuàng)建和使用靜態(tài)類變量


  • 在 Python 中的一個(gè)函數(shù)上使用多個(gè)裝飾器


  • 在 Python 中的方法中同時(shí)訪問 cls 和 self


  • 從裝飾器訪問實(shí)例方法的類


  • 使用給定的裝飾器獲取 Python 類的所有方法


  • 裝飾一個(gè) class


  • 將類字段作為參數(shù)傳遞給類方法上的裝飾器


  • 在 Python 中創(chuàng)建多個(gè)傳入?yún)?shù)列表的類變量


  • Python 中的 wraps 裝飾器


  • 使用可選參數(shù)構(gòu)建裝飾器


  • 在 Python 中將參數(shù)傳遞給裝飾器


  • @property 裝飾器


  • 類和函數(shù)的裝飾器


  • Python 中帶參數(shù)和返回值的裝飾器


  • Python 使用參數(shù) wraps 裝飾器


  • Python 裝飾器獲取類名


  • 簡單裝飾器示例


  • 在 Python 中使用 print() 打印類的實(shí)例


  • 在 Python 中的類中將裝飾器定義為方法


  • 獲取在 Python 中修飾的給定類的所有方法


  • 帶參數(shù)和不帶參數(shù)的 Python 裝飾器


  • Python 中帶有 self 參數(shù)的類方法裝飾器


  • 在 Python 中的另一個(gè)類中使用隱藏的裝飾器


  • 裝飾器內(nèi)部的 self 對(duì)象


  • 在 Python 中將多個(gè)裝飾器應(yīng)用于單個(gè)函數(shù)


  • Python 裝飾器獲取類實(shí)例


  • __init__ 和 __call__ 有什么區(qū)別


  • 在 Python 中使用 __new__ 和 __init__


  • Python 中的迭代重載方法


  • 在 Python 中使用迭代器反轉(zhuǎn)字符串


  • Python 中 __reversed__ 魔術(shù)方法


  • Python 中的 __getitem__ 和 __setitem__


  • 在 Python 中使用 __getattr__ 和 __setattr__ 進(jìn)行屬性賦值


  • 什么是 __del__ 方法以及如何調(diào)用它


  • 創(chuàng)建類的私有成員


  • 一個(gè) Python 封裝的例子


  • 一個(gè) Python 組合的例子


  • 一個(gè)Python聚合的例子


  • Python 中的單級(jí)、多級(jí)和多級(jí)繼承


  • 在 Python 中獲取一個(gè)類的父類


  • Python 中的多態(tài)性


  • 訪問 Child 類中的私有成員


  • Python 中的抽象類


  • 創(chuàng)建一個(gè)抽象類來覆蓋 Python 中的默認(rèn)構(gòu)造函數(shù)


  • 使一個(gè)抽象類繼承另一個(gè)抽象類


  • Python 中的 super 是做什么的


  • super() 如何在多重繼承中與 __init__() 方法一起工作


  • 將 super 與類方法一起使用


  • mro 是做什么的


  • Python 中的元類是什么


  • 元類的具體案例


  • 在 Python 中使用元類的單例類


  • @staticmethod 和 @classmethod 有什么區(qū)別


  • Python 中的裝飾器是什么


  • 制作函數(shù)裝飾器鏈


1在 Python 中創(chuàng)建一個(gè)類及其對(duì)象

class Employee:
salary = 10000
name = "John Doe"


emp1 = Employee()
print(emp1.salary)
print(emp1.name)
Output:10000
John Doe

2在 Python 中創(chuàng)建一個(gè)空類

class Employee:
pass


e1 = Employee()
print(e1)

e1.name = "John Doe"
print(e1.name)
Output:<__main__.Employee object at 0x0000000002DA51D0>
John Doe

3在 Python 中使用 Type 創(chuàng)建類

e1 = type('Employee', (), {})()
print(e1)

e1.name = "John Doe"
print(e1.name)
Output:<__main__.Employee object at 0x0000000002DCC780>
John Doe

4在 Python 中創(chuàng)建和調(diào)用類的方法

class Employee:
salary = 10000
name = "John Doe"

def tax(self):
print(self.salary * 0.10)


emp1 = Employee()
print(emp1.salary)
print(emp1.name)
emp1.tax()
Output:10000
John Doe
1000.0

5使用 init() 方法為數(shù)據(jù)屬性賦值

class Employee:
def __init__(self, salary, name):
self.salary = salary
self.name = name


emp1 = Employee(10000, "John Doe")
print(emp1.salary)
print(emp1.name)
Output:10000
John Doe

6在 Python 中更新對(duì)象屬性

class Employee:
def __init__(self, salary, name):
self.salary = salary
self.name = name


emp1 = Employee(10000, "John Doe")
print(emp1.salary)

emp1.salary = 20000
print(emp1.salary)
Output:10000
20000

7在 Python 中刪除對(duì)象屬性和對(duì)象

class Employee:
def __init__(self, salary, name):
self.salary = salary
self.name = name


emp1 = Employee(10000, "John Doe")

del emp1.salary # Delete object property
del emp1 # Delete object
Output:哈哈

8在 Python 中檢查和比較對(duì)象的類型

class Test(object):
pass


print(type(Test))

obj1 = Test()
print(type(obj1))

obj2 = Test()
print(type(obj1) is type(obj2))
Output:< class 'type' >
< class '__main__.Test' >
True

9在Python中將對(duì)象的所有屬性復(fù)制到另一個(gè)對(duì)象

class MyClass(object):
def __init__(self):
super(MyClass, self).__init__()
self.foo = 1
self.bar = 2


obj1 = MyClass()
obj2 = MyClass()

obj1.foo = 25
obj2.__dict__.update(obj1.__dict__)

print(obj1.foo)
print(obj2.foo)
Output:25
25

10在 Python 中迭代對(duì)象屬性

class A():
m = 1
n = 2

def __int__(self, x=1, y=2, z=3):
self.x = x
self._y = y
self.__z__ = z

def xyz(self):
print(x, y, z)


obj = A()
print(dir(obj))
print([a for a in dir(obj) if not a.startswith('__')])
Output:['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__int__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'm', 'n', 'xyz']
['m', 'n', 'xyz']

11在 Python 中打印對(duì)象的所有屬性

class Animal(object):
def __init__(self):
self.eyes = 2
self.name = 'Dog'
self.color= 'Spotted'
self.legs= 4
self.age  = 10
self.kids = 0


animal = Animal()
animal.tail = 1

temp = vars(animal)
for item in temp:
print(item, ':', temp[item])
Output:kids : 0
eyes : 2
name : Dog
color : Spotted
tail : 1
legs : 4
age : 10

12在python中在運(yùn)行時(shí)創(chuàng)建類的數(shù)據(jù)屬性

class Employee:
pass


emp1 = Employee()
setattr(emp1, 'Salary', 12000)

emp2 = Employee()
setattr(emp2, 'Age', 25)

print(emp1.Salary)
print(emp2.Age)
Output:12000
25

13在函數(shù)中將對(duì)象的實(shí)例作為參數(shù)傳遞

class Vehicle:
def __init__(self):
self.trucks = []

def add_truck(self, truck):
self.trucks.append(truck)


class Truck:
def __init__(self, color):
self.color = color

def __repr__(self):
return "{}".format(self.color)


def main():
v = Vehicle()
for t in 'Red Blue Black'.split():
t = Truck(t)
v.add_truck(t)
print(v.trucks)


if __name__ == "__main__":
main()
Output:[Red, Blue, Black]

14在 Python 中創(chuàng)建和使用自定義 Self 參數(shù)

class Employee:
def __init__(person, salary, name):
person.salary = salary
person.name = name

def print_details(emp):
print(str(emp.salary) ' : ' emp.name)


emp1 = Employee(10000, 'John Doe')
emp1.print_details()
Output:10000 : John Doe

15使用self參數(shù)來維護(hù)對(duì)象的狀態(tài)

class State(object):
def __init__(self):
self.field = 5.0

def add(self, x):
self.field  = x

def mul(self, x):
self.field *= x

def div(self, x):
self.field /= x

def sub(self, x):
self.field -= x


s = State()
print(s.field)

s.add(2) # Self is implicitly passed.
print(s.field)

s.mul(2) # Self is implicitly passed.
print(s.field)

s.div(2) # Self is implicitly passed.
print(s.field)

s.sub(2) # Self is implicitly passed.
print(s.field)
Output:5.0
7.0
14.0
7.0
5.0

16在 Python 中創(chuàng)建和使用靜態(tài)類變量

class Employee:
age = 25


print(Employee.age)

e = Employee()
print(e.age)

e.age = 30
print(Employee.age) # 25
print(e.age) # 30
Output:25
25
25
30

17在 Python 中的一個(gè)函數(shù)上使用多個(gè)裝飾器

def my_decorator(func):
def wrapper():
print("Step - 1")
func()
print("Step - 3")
return wrapper


def repeat(func):
def wrapper():
func()
func()
func()
return wrapper


@my_decorator
@repeat
def start_steps():
print("Step - 2")


start_steps()
Output:Step - 1
Step - 2
Step - 2
Step - 2
Step - 3

18在 Python 中的方法中同時(shí)訪問 cls 和 self

class MyClass:
__var2 = 'var2'
var3 = 'var3'

def __init__(self):
self.__var1 = 'var1'

def normal_method(self):
print(self.__var1)

@classmethod
def class_method(cls):
print(cls.__var2)

def my_method(self):
print(self.__var1)
print(self.__var2)
print(self.__class__.__var2)


if __name__ == '__main__':
print(MyClass.__dict__['var3'])


clzz = MyClass()
clzz.my_method()
Output:var3
var1
var2
var2

19從裝飾器訪問實(shí)例方法的類

class Decorator(object):
def __init__(self, decoratee_enclosing_class):
self.decoratee_enclosing_class = decoratee_enclosing_class

def __call__(self, original_func):
def new_function(*args, **kwargs):
print('decorating function in ', self.decoratee_enclosing_class)
original_func(*args, **kwargs)
return new_function


class Bar(object):
@Decorator('Bar')
def foo(self):
print('in foo')


class Baz(object):
@Decorator('Baz')
def foo(self):
print('in foo')


print('before instantiating Bar()')
b = Bar()
print('calling b.foo()')
b.foo()
Output:before instantiating Bar()
calling b.foo()
decorating function in Bar
in foo

20使用給定的裝飾器獲取 Python 類的所有方法


import inspect


def deco(func):
return func


def deco2():
def wrapper(func):
pass
return wrapper


class Test(object):
@deco
def method(self):
pass

@deco2()
def method2(self):
pass


def methodsWithDecorator(cls, decoratorName):
sourcelines = inspect.getsourcelines(cls)[0]
for i, line in enumerate(sourcelines):
line = line.strip()
if line.split('(')[0].strip() == '@' decoratorName: # leaving a bit out
nextLine = sourcelines[i 1]
name = nextLine.split('def')[1].split('(')[0].strip()
yield(name)


print(list(methodsWithDecorator(Test, 'deco')))
print(list(methodsWithDecorator(Test, 'deco2')))
Output:['method']
['method2']

21裝飾一個(gè) class

from functools import wraps


def dec(msg='default'):
def decorator(klass):
old_foo = klass.foo

@wraps(klass.foo)
def decorated_foo(self, *args, **kwargs):
print('@decorator pre %s' % msg)
old_foo(self, *args, **kwargs)
print('@decorator post %s' % msg)
klass.foo = decorated_foo
return klass
return decorator


@dec('foo decorator')
class Foo(object):
def foo(self, *args, **kwargs):
print('foo.foo()')


@dec('subfoo decorator')
class SubFoo(Foo):
def foo(self, *args, **kwargs):
print('subfoo.foo() pre')
super(SubFoo, self).foo(*args, **kwargs)
print('subfoo.foo() post')


@dec('subsubfoo decorator')
class SubSubFoo(SubFoo):
def foo(self, *args, **kwargs):
print('subsubfoo.foo() pre')
super(SubSubFoo, self).foo(*args, **kwargs)
print('subsubfoo.foo() post')


SubSubFoo().foo()
Output:@decorator pre subsubfoo decorator
subsubfoo.foo() pre
@decorator pre subfoo decorator
subfoo.foo() pre
@decorator pre foo decorator
foo.foo()
@decorator post foo decorator
subfoo.foo() post
@decorator post subfoo decorator
subsubfoo.foo() post
@decorator post subsubfoo decorator

22將類字段作為參數(shù)傳遞給類方法上的裝飾器

import functools

# imagine this is at some different place and cannot be changed


def check_authorization(some_attr, url):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"Welcome Message: '{url}'...")
return func(*args, **kwargs)
return wrapper
return decorator

# another dummy function to make the example work


def do_work():
print("work is done...")


def custom_check_authorization(some_attr):
def decorator(func):
# assuming this will be used only on this particular class
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
# get url
url = self.url
# decorate function with original decorator, pass url
return check_authorization(some_attr, url)(func)(self, *args, **kwargs)
return wrapper
return decorator


class Client(object):
def __init__(self, url):
self.url = url

@custom_check_authorization("some_attr")
def get(self):
do_work()


# create object
client = Client('Hello World')

# call decorated function
client.get()
Output:Welcome Message: 'Hello World'...
work is done...

23在 Python 中創(chuàng)建多個(gè)傳入?yún)?shù)列表的類變量

class Employee(object):
def __init__(self, **kwargs):
for key in kwargs:
setattr(self, key, kwargs[key])


emp = Employee(age=25, name="John Doe")
print(emp.age)
print(emp.name)
Output:25
John Doe

24Python 中的 wraps 裝飾器

from functools import wraps


def decorator_func_with_args(arg1, arg2):
def decorator(f):
@wraps(f)
def wrapper(*args, **kwargs):
print("Before orginal function with decorator args:", arg1, arg2)
result = f(*args, **kwargs)
print("Ran after the orginal function")
return result
return wrapper
return decorator


@decorator_func_with_args("test1", "test2")
def hello(name):
"""A function which prints a greeting to the name provided.
"""
print('Hello ', name)
return 25


print("Starting script..")
x = hello('John')
print("The value of x is:", x)
print("The wrapped functions docstring is:", hello.__doc__)
print("The wrapped functions name is:", hello.__name__)
Output:Starting script..
Before orginal function with decorator args: test1 test2
Hello John
Ran after the orginal function
The value of x is: 25
The wrapped functions docstring is: A function which prints a greeting to the name provided.

The wrapped functions name is: hello

25使用可選參數(shù)構(gòu)建裝飾器

def d(arg):
if callable(arg): # Assumes optional argument isn't.
def newfn():
print('my default message')
return arg()
return newfn
else:
def d2(fn):
def newfn():
print(arg)
return fn()
return newfn
return d2


@d('This is working')
def hello():
print('hello world !')


@d  # No explicit arguments will result in default message.
def hello2():
print('hello2 world !')


@d('Applying it twice')
@d('Would also work')
def hello3():
print('hello3 world !')


hello()
hello2()
hello3()
Output:This is working
hello world !
my default message
hello2 world !
Applying it twice
Would also work
hello3 world !

26在 Python 中將參數(shù)傳遞給裝飾器

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2, decorator_arg3):
def decorator(func):
def wrapper(function_arg1, function_arg2, function_arg3):
print("The wrapper can access all the variables\n"
"\t- from the decorator maker: {0} {1} {2}\n"
"\t- from the function call: {3} {4} {5}\n"
"and pass them to the decorated function"
.format(decorator_arg1, decorator_arg2, decorator_arg3,
function_arg1, function_arg2, function_arg3))
return func(function_arg1, function_arg2, function_arg3)

return wrapper

return decorator


@decorator_maker_with_arguments("canada", "us", "brazil")
def decorated_function_with_arguments(function_arg1, function_arg2, function_arg3):
print("This is the decorated function and it only knows about its arguments: {0}"
" {1}" " {2}".format(function_arg1, function_arg2, function_arg3))


decorated_function_with_arguments("france", "germany", "uk")
Output:The wrapper can access all the variables
- from the decorator maker: canada us brazil
- from the function call: france germany uk
and pass them to the decorated function
This is the decorated function and it only knows about its arguments: france germany uk

27@property 裝飾器


class Currency:
def __init__(self, dollars, cents):
self.total_cents = dollars * 100 cents

@property
def dollars(self):
return self.total_cents // 100

@dollars.setter
def dollars(self, new_dollars):
self.total_cents = 100 * new_dollars   self.cents

@property
def cents(self):
return self.total_cents % 100

@cents.setter
def cents(self, new_cents):
self.total_cents = 100 * self.dollars   new_cents


currency = Currency(10, 20)
print(currency.dollars, currency.cents, currency.total_cents)

currency.dollars  = 5
print(currency.dollars, currency.cents, currency.total_cents)

currency.cents  = 15
print(currency.dollars, currency.cents, currency.total_cents)
Output:10 20 1020
15 20 1520
15 35 1535

28類和函數(shù)的裝飾器

from functools import wraps


def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('sth to log: %s : %s' % (func.__name__, args))
return func(*args, **kwargs)
return wrapper


class Class_test(object):
@decorator
def sum_func(self, a, b):
print('class sum: %s' % (a   b))
return a   b


print(Class_test.sum_func(1, 5, 16))
Output:sth to log: sum_func : (1, 5, 16)
class sum: 21
21

29Python 中帶參數(shù)和返回值的裝飾器

def calculation(func):
def wrapper(*args, **kwargs):

print("Inside the calculation function")

num_sum = func(*args, **kwargs)
print("Before return from calculation function")

return num_sum

return wrapper


@calculation
def addition(a, b):
print("Inside the addition function")
return a   b


print("Sum =", addition(5, 10))
Output:Inside the calculation function
Inside the addition function
Before return from calculation function
Sum = 15

30Python 使用參數(shù) wraps 裝飾器

from functools import wraps


def decorator_func_with_args(arg1, arg2):
def decorator(f):
@wraps(f)
def wrapper(*args, **kwargs):
print("Before orginal function with decorator args:", arg1, arg2)
result = f(*args, **kwargs)
print("Ran after the orginal function")
return result
return wrapper
return decorator


@decorator_func_with_args("test1", "test2")
def hello(name):
"""A function which prints a greeting to the name provided.
"""
print('Hello ', name)
return 25


print("Starting script..")
x = hello('John')
print("The value of x is:", x)
print("The wrapped functions docstring is:", hello.__doc__)
print("The wrapped functions name is:", hello.__name__)
Output:Starting script..
Before orginal function with decorator args: test1 test2
Hello John
Ran after the orginal function
The value of x is: 25
The wrapped functions docstring is: A function which prints a greeting to the name provided.

The wrapped functions name is: hello

31Python 裝飾器獲取類名

def print_name(*args):
def _print_name(fn):
def wrapper(*args, **kwargs):
print('{}.{}'.format(fn.__module__, fn.__qualname__))
return fn(*args, **kwargs)
return wrapper
return _print_name


class A():
@print_name()
def a():
print('Hi from A.a')


@print_name()
def b():
print('Hi from b')


A.a()
b()
Output:__main__.A.a
Hi from A.a
__main__.b
Hi from b

32簡單裝飾器示例

def my_decorator(func):
def wrapper():
print("Step - 1")
func()
print("Step - 3")
return wrapper


@my_decorator
def start_steps():
print("Step - 2")


start_steps()
Output:Step - 1
Step - 2
Step - 3

33在 Python 中使用 print() 打印類的實(shí)例

class Element:
def __init__(self, name, city, population):
self.name = name
self.city = city
self.population = population

def __str__(self):
return str(self.__class__) '\n' '\n'.join(('{} = {}'.format(item, self.__dict__[item]) for item in self.__dict__))


elem = Element('canada', 'tokyo', 321345)
print(elem)
Output:name = canada
city = tokyo
population = 321345

34在 Python 中的類中將裝飾器定義為方法

class myclass:
def __init__(self):
self.cnt = 0

def counter(self, function):
"""
this method counts the number of runtime of a function
"""
def wrapper(**args):
function(self, **args)
self.cnt  = 1
print('Counter inside wrapper: ', self.cnt)
return wrapper


global counter_object
counter_object = myclass()


@counter_object.counter
def somefunc(self):
print("Somefunc called")


somefunc()
print(counter_object.cnt)

somefunc()
print(counter_object.cnt)

somefunc()
print(counter_object.cnt)
Output:Somefunc called
Counter inside wrapper: 1
1
Somefunc called
Counter inside wrapper: 2
2
Somefunc called
Counter inside wrapper: 3
3

35獲取在 Python 中修飾的給定類的所有方法

class awesome(object):
def __init__(self, method):
self._method = method

def __call__(self, obj, *args, **kwargs):
return self._method(obj, *args, **kwargs)

@classmethod
def methods(cls, subject):
def g():
for name in dir(subject):
method = getattr(subject, name)
if isinstance(method, awesome):
yield name, method
return {name: method for name, method in g()}


class Robot(object):
@awesome
def think(self):
return 0

@awesome
def walk(self):
return 0

def irritate(self, other):
return 0


print(awesome.methods(Robot))
Output:{'think': <__main__.awesome object at 0x00000213C052AAC0>, 'walk': <__main__.awesome object at 0x00000213C0E33FA0>}

36帶參數(shù)和不帶參數(shù)的 Python 裝飾器

def someDecorator(arg=None):
def decorator(func):
def wrapper(*a, **ka):
if not callable(arg):
print(arg)
return func(*a, **ka)
else:
return 'xxxxx'
return wrapper

if callable(arg):
return decorator(arg) # return 'wrapper'
else:
return decorator # ... or 'decorator'


@someDecorator(arg=1)
def my_func():
print('my_func')


@someDecorator
def my_func1():
print('my_func1')


if __name__ == "__main__":
my_func()
my_func1()
Output:1
my_func

37Python 中帶有 self 參數(shù)的類方法裝飾器

def check_authorization(f):
def wrapper(*args):
print('Inside wrapper function argement passed :', args[0].url)
return f(*args)
return wrapper


class Client(object):
def __init__(self, url):
self.url = url

@check_authorization
def get(self):
print('Inside get function argement passed :', self.url)


Client('Canada').get()
Output:Inside wrapper function argement passed : Canada
Inside get function argement passed : Canada

38在 Python 中的另一個(gè)類中使用隱藏的裝飾器

class TestA(object):
def _decorator(foo):
def magic(self):
print("Start magic")
foo(self)
print("End magic")
return magic

@_decorator
def bar(self):
print("Normal call")

_decorator = staticmethod(_decorator)


class TestB(TestA):
@TestA._decorator
def bar(self):
print("Override bar in")
super(TestB, self).bar()
print("Override bar out")


print("Normal:")
test = TestA()
test.bar()
print('-' * 10)

print("Inherited:")
b = TestB()
b.bar()
Output:Normal:
Start magic
Normal call
End magic
----------
Inherited:
Start magic
Override bar in
Start magic
Normal call
End magic
Override bar out
End magic

39裝飾器內(nèi)部的 self 對(duì)象

import random


def only_registered_users(func):
def wrapper(handler):
print('Checking if user is logged in')
if random.randint(0, 1):
print('User is logged in. Calling the original function.')
func(handler)
else:
print('User is NOT logged in. Redirecting...')
return wrapper


class MyHandler(object):

@only_registered_users
def get(self):
print('Get function called')


m = MyHandler()
m.get()
Output:Checking if user is logged in
User is logged in. Calling the original function.
Get function called

40在 Python 中將多個(gè)裝飾器應(yīng)用于單個(gè)函數(shù)

def multiplication(func):
def wrapper(*args, **kwargs):
num_sum = func(*args, **kwargs)
print("Inside the multiplication function", num_sum)
return num_sum * num_sum

return wrapper


def addition(func):
def wrapper(*args, **kwargs):
num_sum = func(*args, **kwargs)
print("Inside the addition function", num_sum)
return num_sum   num_sum

return wrapper


@addition
@multiplication
def calculation(a):
print("Inside the calculation function", a)
return a


print("Sum =", calculation(5))
Output:Inside the calculation function 5
Inside the multiplication function 5
Inside the addition function 25
Sum = 50

41Python 裝飾器獲取類實(shí)例

class MySerial():
def __init__(self):
pass # I have to have an __init__

def write(self, *args):
print(args[0])
pass # write to buffer

def read(self):
pass # read to buffer

@staticmethod
def decorator(func):
def func_wrap(cls, *args, **kwargs):
cls.ser.write(func(cls, *args, **kwargs))
return cls.ser.read()
return func_wrap


class App():
def __init__(self):
self.ser = MySerial()

@MySerial.decorator
def myfunc(self):
self = 100
return ['canada', 'australia']


App().myfunc()
Output:['canada', 'australia']

42init 和 call 有什么區(qū)別

class Counter:
def __init__(self):
self._weights = []
for i in range(0, 2):
self._weights.append(1)
print(str(self._weights[-2]) " No. from __init__")

def __call__(self, t):
self._weights = [self._weights[-1], self._weights[-1]
self._weights[-1]]
print(str(self._weights[-1]) " No. from __call__")


num_count = Counter()
for i in range(0, 4):
num_count(i)
Output:1 No. from __init__
2 No. from __call__
4 No. from __call__
8 No. from __call__
16 No. from __call__

43在 Python 中使用 new 和 init

class Shape:
def __new__(cls, sides, *args, **kwargs):
if sides == 3:
return Triangle(*args, **kwargs)
else:
return Square(*args, **kwargs)


class Triangle:
def __init__(self, base, height):
self.base = base
self.height = height

def area(self):
return (self.base * self.height) / 2


class Square:
def __init__(self, length):
self.length = length

def area(self):
return self.length*self.length


a = Shape(sides=3, base=2, height=12)
b = Shape(sides=4, length=2)

print(str(a.__class__))
print(a.area())

print(str(b.__class__))
print(b.area())
Output:class '__main__.Triangle'
12.0
class '__main__.Square'
4

44Python 中的迭代重載方法

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

def __iter__(self):
return self

def __next__(self):
if self.current > self.high:
raise StopIteration
else:
self.current  = 1
return self.current - 1


for num in Counter(5, 15):
print(num)
Output:5
6
..
..
15

45在 Python 中使用迭代器反轉(zhuǎn)字符串

class Reverse:
def __init__(self, data):
self.data = data
self.index = len(data)

def __iter__(self):
return self

def __next__(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]


test = Reverse('Python')
for char in test:
print(char)
Output:n
o
h
t
y
P

46Python 中 reversed 魔術(shù)方法

class Count:
def __init__(self, start, end):
self.start = start
self.end = end
self.current = None

def __iter__(self):
self.current = self.start
while self.current < self.end:
yield self.current
self.current  = 1

def __next__(self):
if self.current is None:
self.current = self.start
if self.current > self.end:
raise StopIteration
else:
self.current  = 1
return self.current-1

def __reversed__(self):
self.current = self.end
while self.current >= self.start:
yield self.current
self.current -= 1


obj1 = Count(0, 5)
for i in obj1:
print(i)

obj2 = reversed(obj1)
for i in obj2:
print(i)
Output:0
1
2
....
2
1
0

47Python 中的 getitem 和 setitem

class Counter(object):
def __init__(self, floors):
self._floors = [None]*floors

def __setitem__(self, floor_number, data):
self._floors[floor_number] = data

def __getitem__(self, floor_number):
return self._floors[floor_number]


index = Counter(4)
index[0] = 'ABCD'
index[1] = 'EFGH'
index[2] = 'IJKL'
index[3] = 'MNOP'

print(index[2])
Output:IJKL

48在 Python 中使用 getattr 和 setattr 進(jìn)行屬性賦值

class Employee(object):
def __init__(self, data):
super().__setattr__('data', dict())
self.data = data

def __getattr__(self, name):
if name in self.data:
return self.data[name]
else:
return 0

def __setattr__(self, key, value):
if key in self.data:
self.data[key] = value
else:
super().__setattr__(key, value)


emp = Employee({'age': 23, 'name': 'John'})
print(emp.age)
print(emp.name)
print(emp.data)
print(emp.salary)

emp.salary = 50000
print(emp.salary)
Output:23
John
{'age': 23, 'name': 'John'}
0
50000

49什么是 del 方法以及如何調(diào)用它

class Employee():
def __init__(self, name='John Doe'):
print('Hello ' name)
self.name = name

def developer(self):
print(self.name)

def __del__(self):
print('Good Bye ' self.name)


emp = Employee('Mark')
print(emp)

emp = 'Rocky'
print(emp)
Output:Hello Mark
<__main__.Employee object at 0x00000000012498D0>
Good Bye Mark
Rocky

50創(chuàng)建類的私有成員

class Test(object):
__private_var = 100
public_var = 200

def __private_func(self):
print('Private Function')

def public_func(self):
print('Public Function')
print(self.public_var)

def call_private(self):
self.__private_func()
print(self.__private_var)


t = Test()
print(t.call_private())
print(t.public_func())
Output:Private Function
100
None
Public Function
200
None

51一個(gè) Python 封裝的例子

class Encapsulation:
__name = None

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

def get_name(self):
return self.__name


pobj = Encapsulation('Rocky')
print(pobj.get_name())
Output:Rocky

52一個(gè) Python 組合的例子

class Salary:
def __init__(self, pay):
self.pay = pay

def get_total(self):
return (self.pay*12)


class Employee:
def __init__(self, pay, bonus):
self.pay = pay
self.bonus = bonus
self.obj_salary = Salary(self.pay)

def annual_salary(self):
return "Total: " str(self.obj_salary.get_total()   self.bonus)


obj_emp = Employee(600, 500)
print(obj_emp.annual_salary())
Output:Total: 7700

53一個(gè)Python聚合的例子

class Salary:
def __init__(self, pay):
self.pay = pay

def get_total(self):
return (self.pay*12)


class Employee:
def __init__(self, pay, bonus):
self.pay = pay
self.bonus = bonus

def annual_salary(self):
return "Total: " str(self.pay.get_total()   self.bonus)


obj_sal = Salary(600)
obj_emp = Employee(obj_sal, 500)
print(obj_emp.annual_salary())
Output:Total: 7700

54Python 中的單級(jí)、多級(jí)和多級(jí)繼承

# Single inheritence
class Apple:
manufacturer = 'Apple Inc'
contact_website = 'www.apple.com/contact'
name = 'Apple'

def contact_details(self):
print('Contact us at ', self.contact_website)


class MacBook(Apple):
def __init__(self):
self.year_of_manufacture = 2018

def manufacture_details(self):
print('This MacBook was manufactured in {0}, by {1}.'
.format(self.year_of_manufacture, self.manufacturer))


macbook = MacBook()
macbook.manufacture_details()


# Multiple inheritence
class OperatingSystem:
multitasking = True
name = 'Mac OS'


class MacTower(OperatingSystem, Apple):
def __init__(self):
if self.multitasking is True:
print('Multitasking system')
# if there are two superclasses with the sae attribute name
# the attribute of the first inherited superclass will be called
# the order of inhertence matters
print('Name: {}'.format(self.name))


mactower = MacTower()


# Multilevel inheritence
class MusicalInstrument:
num_of_major_keys = 12


class StringInstrument(MusicalInstrument):
type_of_wood = 'Tonewood'


class Guitar(StringInstrument):
def __init__(self):
self.num_of_strings = 6
print('The guitar consists of {0} strings,'
'it is made of {1} and can play {2} keys.'
.format(self.num_of_strings,
self.type_of_wood, self.num_of_major_keys))


guitar = Guitar()
Output:This MacBook was manufactured in 2018, by Apple Inc.
Multitasking system
Name: Mac OS
The guitar consists of 6 strings, it is made of Tonewood and can play 12 keys.

55在 Python 中獲取一個(gè)類的父類

class A(object):
pass


class B(object):
pass


class C(A, B):
pass


print(C.__bases__)
Output:(< class '__main__.A' >, < class '__main__.B' >)

56Python 中的多態(tài)性

# Creating a shape Class
class Shape:
width = 0
height = 0

# Creating area method
def area(self):
print("Parent class Area ... ")


# Creating a Rectangle Class
class Rectangle(Shape):

def __init__(self, w, h):
self.width = w
self.height = h

# Overridding area method
def area(self):
print("Area of the Rectangle is : ", self.width*self.height)


# Creating a Triangle Class
class Triangle(Shape):

def __init__(self, w, h):
self.width = w
self.height = h

# Overridding area method
def area(self):
print("Area of the Triangle is : ", (self.width*self.height)/2)


rectangle = Rectangle(10, 20)
triangle = Triangle(2, 10)

rectangle.area()
triangle.area()
Output:Area of the Rectangle is : 200
Area of the Triangle is : 10.0

57訪問 Child 類中的私有成員

class Human():

# Private var
__privateVar = "this is __private variable"

# Constructor method
def __init__(self):
self.className = "Human class constructor"
self.__privateVar = "this is redefined __private variable"

# Public method
def showName(self, name):
self.name = name
return self.__privateVar " " name

# Private method
def __privateMethod(self):
return "Private method"

# Public method that returns a private variable
def showPrivate(self):
return self.__privateMethod()

def showProtecded(self):
return self._protectedMethod()


class Male(Human):
def showClassName(self):
return "Male"

def showPrivate(self):
return self.__privateMethod()

def showProtected(self):
return self._protectedMethod()


class Female(Human):
def showClassName(self):
return "Female"

def showPrivate(self):
return self.__privateMethod()


human = Human()
print(human.className)
print(human.showName("Vasya"))
print(human.showPrivate())

male = Male()
print(male.className)
print(male.showClassName())

female = Female()
print(female.className)
print(female.showClassName())
Output:Human class constructor
this is redefined __private variable Vasya
Private method
Human class constructor
Male
Human class constructor
Female

58Python 中的抽象類

from abc import ABC, abstractmethod


class AbstractClass(ABC):
def __init__(self, value):
self.value = value
super().__init__()

@abstractmethod
def eat(self):
pass


class Parents(AbstractClass):
def eat(self):
return "Eat solid food " str(self.value) " times each day."


class Babies(AbstractClass):
def eat(self):
return "Milk only " str(self.value) " times or more each day."


food = 3
adult = Parents(food)
print('Adult')
print(adult.eat())

infant = Babies(food)
print('Infants')
print(infant.eat())
Output:Adult
Eat solid food 3 times each day.
Infants
Milk only 3 times or more each day.

59創(chuàng)建一個(gè)抽象類來覆蓋 Python 中的默認(rèn)構(gòu)造函數(shù)

from abc import ABCMeta, abstractmethod


class AbstractClass(object, metaclass=ABCMeta):
@abstractmethod
def __init__(self, n):
self.n = n


class Employee(AbstractClass):
def __init__(self, salary, name):
self.salary = salary
self.name = name


emp1 = Employee(10000, "John Doe")
print(emp1.salary)
print(emp1.name)
Output:10000
John Doe

60使一個(gè)抽象類繼承另一個(gè)抽象類

from abc import ABC, abstractmethod


class A(ABC):
def __init__(self, username):
self.username = username
super().__init__()

@abstractmethod
def name(self):
pass


class B(A):
@abstractmethod
def age(self):
pass


class C(B):
def name(self):
print(self.username)

def age(self):
return


c = C('Test1234')
c.name()
Output:Test1234

61Python 中的 super 是做什么的

class A(object):
def __init__(self, profession):
print(profession)


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


b = B()
Output:John Doe
Developer

62super() 如何在多重繼承中與 init() 方法一起工作

class F:
def __init__(self):
print('F%s' % super().__init__)
super().__init__()


class G:
def __init__(self):
print('G%s' % super().__init__)
super().__init__()


class H:
def __init__(self):
print('H%s' % super().__init__)
super().__init__()


class E(G, H):
def __init__(self):
print('E%s' % super().__init__)
super().__init__()


class D(E, F):
def __init__(self):
print('D%s' % super().__init__)
super().__init__()


class C(E, G):
def __init__(self):
print('C%s' % super().__init__)
super().__init__()


class B(C, H):
def __init__(self):
print('B%s' % super().__init__)
super().__init__()


class A(D, B, E):
def __init__(self):
print('A%s' % super().__init__)
super().__init__()


a = A()
print(a)
Output:A bound method D.__init__ of __main__.A object at 0x000000000369CFD0
D bound method B.__init__ of __main__.A object at 0x000000000369CFD0
B bound method C.__init__ of __main__.A object at 0x000000000369CFD0
C bound method E.__init__ of __main__.A object at 0x000000000369CFD0
E bound method G.__init__ of __main__.A object at 0x000000000369CFD0
G bound method H.__init__ of __main__.A object at 0x000000000369CFD0
H bound method F.__init__ of __main__.A object at 0x000000000369CFD0
F method-wrapper '__init__' of A object at 0x000000000369CFD0
__main__.A object at 0x000000000369CFD0

63將 super 與類方法一起使用

class A(object):
@classmethod
def name(self, employee):
print('Employee Name: ', employee)


class B(A):
@classmethod
def name(self, employee):
super(B, self).name(employee)


B.name('John Doe')
Output:Employee Name: John Doe

64mro 是做什么的

class A(object):
def dothis(self):
print('From A class')


class B1(A):
def dothis(self):
print('From B1 class')
pass


class B2(object):
def dothis(self):
print('From B2 class')
pass


class B3(A):
def dothis(self):
print('From B3 class')


# Diamond inheritance
class D1(B1, B3):
pass


class D2(B1, B2):
pass


d1_instance = D1()
d1_instance.dothis()
print(D1.__mro__)

d2_instance = D2()
d2_instance.dothis()
print(D2.__mro__)
Output:From B1 class
(class '__main__.D1', class '__main__.B1', )
From B1 class
(class '__main__.D2', class '__main__.B1', , class '__main__.B2', class 'object')

65Python 中的元類是什么

def _addMethod(fldName, clsName, verb, methodMaker, dict):
compiledName = _getCompiledName(fldName, clsName)
methodName = _getMethodName(fldName, verb)
dict[methodName] = methodMaker(compiledName)


def _getCompiledName(fldName, clsName):
if fldName[:2] == "__" and fldName[-2:] != "__":
return "_%s%s" % (clsName, fldName)
else:
return fldName


def _getMethodName(fldName, verb):
s = fldName.lstrip("_")
return verb   s.capitalize()


def _makeGetter(compiledName):
return lambda self: self.__dict__[compiledName]


def _makeSetter(compiledName):
return lambda self, value: setattr(self, compiledName, value)


class Accessors(type):
def __new__(cls, clsName, bases, dict):
for fldName in dict.get("_READ", [])   dict.get("_READ_WRITE", []):
_addMethod(fldName, clsName, "get", _makeGetter, dict)
for fldName in dict.get("_WRITE", [])   dict.get("_READ_WRITE", []):
_addMethod(fldName, clsName, "set", _makeSetter, dict)
return type.__new__(cls, clsName, bases, dict)


class Employee(object, metaclass=Accessors):
_READ_WRITE = ['name', 'salary', 'title', 'bonus']

def __init__(self, name, salary, title, bonus=0):
self.name = name
self.salary = salary
self.title = title
self.bonus = bonus


b = Employee('John Doe', 25000, 'Developer', 5000)
print('Name:', b.getName())
print('Salary:', b.getSalary())
print('Title:', b.getTitle())
print('Bonus:', b.getBonus())
Output:Name: John Doe
Salary: 25000
Title: Developer
Bonus: 5000

66元類的具體案例

class UpperAttrNameMetaClass(type):
def __new__(cls, clsname, bases, attrdict, *args, **kwargs):
print('1. Create a new type, from '
' UpperAttrNameMetaClass.__new__')
new_attrs = dict()
for attr, value in attrdict.items():
if not callable(value) and not str(attr).startswith('__'):
new_attrs[attr.upper()] = value
else:
new_attrs[attr] = value

cls_obj = super().__new__(cls, clsname, bases, new_attrs,
*args, **kwargs)
return cls_obj

def __init__(self, clsname, bases, attrdict):
self.test = 'test'
super().__init__(clsname, bases, attrdict)
print('2. Initialize new type, increase test attribute,'
'from UpperAttrNameMetaClass.__init__')

def __call__(self, *args, **kwargs):
print('3. Instantiate the new class,'
' from UpperAttrNameMetaClass.__call__')
new_obj = self.__new__(self, *args, **kwargs)
new_obj.__init__(*args, **kwargs)
return new_obj


class ObjectNoInitMetaClass(type):
def __call__(cls, *args, **kwargs):
if len(args):
raise TypeError('Must use keyword argument '
' for key function')
new_obj = cls.__new__(cls)
for k, v in kwargs.items():
setattr(new_obj, k.upper(), v)
return new_obj


class Pig(object, metaclass=UpperAttrNameMetaClass):
size = 'Big'

def __new__(cls, *args, **kwargs):
print('4. Call __new__ in the __call__ of the metaclass,'
' from Pig.__new__')
obj = object.__new__(cls)
return obj

def __init__(self):
print('5. After the new object is instantiated in '
'the __call__ of the metaclass,the object is promoted,'
' from Pig.__init__')
self.name = 'Mark'

def talk(self):
print(self.name)


Pig().talk()
print(Pig.__dict__)
print(Pig.SIZE)


class AnyOne(metaclass=ObjectNoInitMetaClass):
pass


foo = AnyOne(name='John', age=28)
print(foo.NAME, foo.AGE)
print(foo.__dict__)
Output:1. Create a new type, from UpperAttrNameMetaClass.__new__
2. Initialize new type, increase test attribute,from UpperAttrNameMetaClass.__init__
3. Instantiate the new class, from UpperAttrNameMetaClass.__call__
4. Call __new__ in the __call__ of the metaclass, from Pig.__new__
5. After the new object is instantiated in the __call__ of the metaclass,the object is promoted, from Pig.__init__
Mark
{'__doc__': None, 'test': 'test', '__weakref__': , 'SIZE': 'Big', '__init__': , '__dict__': , '__module__': '__main__', '__new__': , 'talk': }
Big
John 28
{'AGE': 28, 'NAME': 'John'}

67在 Python 中使用元類的單例類

class SingleInstanceMetaClass(type):
def __init__(self, name, bases, dic):
self.__single_instance = None
super().__init__(name, bases, dic)

def __call__(cls, *args, **kwargs):
if cls.__single_instance:
return cls.__single_instance
single_obj = cls.__new__(cls)
single_obj.__init__(*args, **kwargs)
cls.__single_instance = single_obj
return single_obj


class Setting(metaclass=SingleInstanceMetaClass):
def __init__(self):
self.db = 'MySQL'
self.port = 3306


bar1 = Setting()
bar2 = Setting()

print(bar1 is bar2)
print(bar1.db, bar1.port)
bar1.db = 'ORACLE'
print(bar2.db, bar2.port)
Output:True
MySQL 3306
ORACLE 3306

68@staticmethod 和 @classmethod 有什么區(qū)別

class Employee:
@classmethod
def classmthd(*args):
return args

@staticmethod
def staticmthd(*args):
return args


print(Employee.classmthd())
print(Employee.classmthd('test'))

print(Employee.staticmthd())
print(Employee.staticmthd('test'))
Output:(class '__main__.Employee',)
(class '__main__.Employee', 'test')
()
('test',)

69Python 中的裝飾器是什么

def message(param1, param2):
def wrapper(wrapped):
class WrappedClass(wrapped):
def __init__(self):
self.param1 = param1
self.param2 = param2
super(WrappedClass, self).__init__()

def get_message(self):
return "message %s %s" % (self.param1, self.param2)

return WrappedClass
return wrapper


@message("param1", "param2")
class Pizza(object):
def __init__(self):
pass


pizza_with_message = Pizza()
print(pizza_with_message.get_message())
Output:message param1 param2

70制作函數(shù)裝飾器鏈

def benchmark(func):
"""
A decorator that prints the time a function takes
to execute.
"""
import time

def wrapper(*args, **kwargs):
t = time.clock()
res = func(*args, **kwargs)
print("{0} {1}".format(func.__name__, time.clock()-t))
return res
return wrapper


def logging(func):
"""
A decorator that logs the activity of the script.
(it actually just prints it, but it could be logging!)
"""
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
print("{0} {1} {2}".format(func.__name__, args, kwargs))
return res
return wrapper


def counter(func):
"""
A decorator that counts and prints the number of times a
function has been executed
"""
def wrapper(*args, **kwargs):
wrapper.count = wrapper.count 1
res = func(*args, **kwargs)
print("{0} has been used: {1}x".format(func.__name__, wrapper.count))
return res
wrapper.count = 0
return wrapper


@counter
@benchmark
@logging
def letter_range(start, stop, step=1):
start = ord(start.lower())
stop = ord(stop.lower())
for str_lst in range(start, stop, step):
yield chr(str_lst)


print(list(letter_range("a", "f")))
print('\n')
print(list(letter_range("m", "z", 2)))
Output:letter_range ('a', 'f') {}
wrapper 0.0009437184107374183
wrapper has been used: 1x
['a', 'b', 'c', 'd', 'e']


letter_range ('m', 'z', 2) {}
wrapper 3.131164480070134e-05
wrapper has been used: 2x
['m', 'o', 'q', 's', 'u', 'w', 'y']




本站聲明： 本文章由作者或相關(guān)機(jī)構(gòu)授權(quán)發(fā)布，目的在于傳遞更多信息，并不代表本站贊同其觀點(diǎn)，本站亦不保證或承諾內(nèi)容真實(shí)性等。需要轉(zhuǎn)載請(qǐng)聯(lián)系該專欄作者，如若文章內(nèi)容侵犯您的權(quán)益，請(qǐng)及時(shí)聯(lián)系本站刪除。
換一批
延伸閱讀

電感是導(dǎo)線內(nèi)通過交流電流時(shí)，在導(dǎo)線的內(nèi)部及其周圍產(chǎn)生交變磁通，導(dǎo)線的磁通量與生產(chǎn)此磁通的電流之比。電感器也叫電感線圈，是利用電磁感應(yīng)原理制成的，由導(dǎo)線在絕緣管上單層或多層繞制而成的，導(dǎo)線彼此互相絕緣，而絕緣管可以是空心的...

關(guān)鍵字： 電感 磁通量 電感器

根據(jù)交通運(yùn)輸部水運(yùn)科學(xué)研究院提出的智慧港口的概念，智慧港口是利用新一代信息技術(shù)，將港口相關(guān)業(yè)務(wù)和管理創(chuàng)新深度融合，使港口更加集約、高效、便捷、安全、綠色，創(chuàng)新港口發(fā)展模式，實(shí)現(xiàn)港口科學(xué)可持續(xù)發(fā)展。

關(guān)鍵字： 智慧港口 信息技術(shù) 業(yè)務(wù)

近年來，世界主要汽車大國紛紛加強(qiáng)新能源汽車戰(zhàn)略謀劃、強(qiáng)化政策支持、完善產(chǎn)業(yè)布局，新能源汽車已成為全球汽車產(chǎn)業(yè)轉(zhuǎn)型發(fā)展的主要方向和促進(jìn)世界經(jīng)濟(jì)持續(xù)增長的重要引擎。2021年，全國新能源汽車實(shí)現(xiàn)產(chǎn)量354.5萬輛，銷量352...

關(guān)鍵字： 新能源 汽車 引擎

2007-2021年，全球針狀焦行業(yè)專利申請(qǐng)人數(shù)量及專利申請(qǐng)量總體呈現(xiàn)增長態(tài)勢(shì)。雖然2021年全球針狀焦行業(yè)專利申請(qǐng)人數(shù)量及專利申請(qǐng)量有所下降，但是這兩大指標(biāo)數(shù)量仍較多。整體來看，全球針狀焦技術(shù)處于成長期。

關(guān)鍵字： 針狀焦行業(yè) 專利申請(qǐng)人 增長態(tài)勢(shì)

按企業(yè)主營業(yè)務(wù)類型分，我國智能家居行業(yè)競爭派系可分為傳統(tǒng)家電企業(yè)、互聯(lián)網(wǎng)企業(yè)以及其他企業(yè)三派。傳統(tǒng)家電企業(yè)代表有海爾智家、美的集團(tuán)、格力電器等，具有供應(yīng)鏈和銷售渠道，制造能力和品牌優(yōu)勢(shì)突出;互聯(lián)網(wǎng)企業(yè)代表有小米集團(tuán)、百度...

關(guān)鍵字： 智能家居 互聯(lián)網(wǎng)企業(yè) 供應(yīng)鏈

軍工電子是集紅外技術(shù)、激光技術(shù)、半導(dǎo)體及嵌入式技術(shù)與虛擬仿真技術(shù)為一體的綜合性軍工技術(shù)體系，是國防信息化建設(shè)的基石。軍工電子行業(yè)包含在軍工行業(yè)內(nèi)，專注于軍工行業(yè)電子產(chǎn)品布局。根據(jù)其軍工產(chǎn)品的不同可分為衛(wèi)星導(dǎo)航、通信指揮、...

關(guān)鍵字： 軍工電子 嵌入式技術(shù) 信息化建設(shè)

我國汽車零配件行業(yè)細(xì)分種類眾多，從汽車零配件主要產(chǎn)品來看，發(fā)動(dòng)機(jī)系統(tǒng)行業(yè)內(nèi)有濰柴動(dòng)力、華域汽車等主要從業(yè)企業(yè);在車身零部件領(lǐng)域內(nèi)，福耀玻璃、中策橡膠具有一定的規(guī)模優(yōu)勢(shì);行駛系統(tǒng)領(lǐng)域內(nèi)有中策橡膠提供的輪胎以及華為等企業(yè)提供...

關(guān)鍵字： 汽車零配件 發(fā)動(dòng)機(jī) 行駛系統(tǒng)

茶飲料是指以茶葉或茶葉的水提取液、濃縮液、茶粉(包括速溶茶粉、研磨茶粉)或直接以茶的鮮葉為原料添加或不添加食品原輔料和(或)食品添加劑，經(jīng)加工制成的液體飲料。根據(jù)國家標(biāo)準(zhǔn)《茶飲料(GB/T 21733-2008)》的規(guī)定...

關(guān)鍵字： 茶飲料 茶葉的水 食品添加劑

全球液壓行業(yè)專利技術(shù)在21世紀(jì)初得到初步發(fā)展，這一時(shí)期液壓專利申請(qǐng)人數(shù)量和申請(qǐng)量處于較低水平。2011-2012年，液壓行業(yè)專利技術(shù)的發(fā)展總體處于成長期，2012年以后中全球液壓行業(yè)專利技術(shù)申請(qǐng)量或申請(qǐng)人數(shù)量整體處于波動(dòng)...

關(guān)鍵字： 液壓行業(yè) 專利授權(quán) 技術(shù)類型

從上市企業(yè)的總市值情況來看，2022年7月28日，中芯國際、紫光國微和韋爾股份總市值遙遙領(lǐng)先，中芯國際總市值達(dá)到3238.21億元，紫光國微總市值達(dá)到1358.77億元，韋爾股份總市值達(dá)到1277.07億元;其次是兆易創(chuàng)...

關(guān)鍵字： 上市企業(yè) 集成電路 行業(yè)

AI科技大本營

113 篇文章

關(guān)注

發(fā)布文章

編輯精選

技術(shù)子站

關(guān)閉