在 Python 中创建一个类及其对象
class Employee:
salary = 10000
name = "John Doe"
emp1 = Employee()
print(emp1.salary)
print(emp1.name)
Output:
10000
John Doe
在 Python 中创建一个空类
class Employee:
pass
e1 = Employee()
print(e1)
e1.name = "John Doe"
print(e1.name)
Output:
John Doe
在 Python 中使用 Type 创建类
e1 = type('Employee', (), {})()
print(e1)
e1.name = "John Doe"
print(e1.name)
Output:
John Doe
在 Python 中创建和调用类的方法
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
使用 init() 方法为数据属性赋值
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
在 Python 中更新对象属性
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
在 Python 中删除对象属性和对象
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:
在 Python 中检查和比较对象的类型
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
在Python中将对象的所有属性复制到另一个对象
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
在 Python 中迭代对象属性
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']
在 Python 中打印对象的所有属性
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
在python中在运行时创建类的数据属性
class Employee:
pass
emp1 = Employee()
setattr(emp1, 'Salary', 12000)
emp2 = Employee()
setattr(emp2, 'Age', 25)
print(emp1.Salary)
print(emp2.Age)
Output:
12000
25
在函数中将对象的实例作为参数传递
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]
在 Python 中创建和使用自定义 Self 参数
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
使用self参数来维护对象的状态
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
在 Python 中创建和使用静态类变量
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
在 Python 中的一个函数上使用多个装饰器
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
在 Python 中的方法中同时访问 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
从装饰器访问实例方法的类
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
使用给定的装饰器获取 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']
装饰一个 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
将类字段作为参数传递给类方法上的装饰器
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...
在 Python 中创建多个传入参数列表的类变量
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
Python 中的 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
使用可选参数构建装饰器
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 !
在 Python 中将参数传递给装饰器
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
@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
类和函数的装饰器
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
Python 中带参数和返回值的装饰器
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
Python 使用参数 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
Python 装饰器获取类名
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
简单装饰器示例
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
在 Python 中使用 print() 打印类的实例
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
在 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
获取在 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': , 'walk': }
带参数和不带参数的 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
Python 中带有 self 参数的类方法装饰器
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
在 Python 中的另一个类中使用隐藏的装饰器
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:
`python
Normal:
Start magic
Normal call
End magic
Original: https://blog.csdn.net/linmeiyun/article/details/126917501
Author: linmeiyun
Title: 再再肝3天,整理了70个Python面向对象编程案例,怎能不收藏?
原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/758211/
转载文章受原作者版权保护。转载请注明原作者出处!