def run301_04():
"""
sequence ops
:return:
"""
a = [1, 2, 3]
b = ['a', 'b', 'c']
print('a=', a)
print('b=', b)
print('Constructive:')
print('concat(a,b): ', concat(a, b))
print('\nSearching:')
print('contains(a,1):', contains(a, 1))
print('contains(b,"d"):', contains(b, 'd'))
print('countOf(a,1):', countOf(a, 1))
print('countOf(b,"d"):', countOf(b, 'd'))
print('indexOf(a,1):', indexOf(a, 1))
# print('indexOf(a,5):', indexOf(a, 5)) # ValueError
print('\nAccess Items:')
print('getitem(b,1):', getitem(b, 1))
print('getitem(b,slice(1,3)):', getitem(b, slice(1, 3)))
print('setitem(b,1,"d"):', setitem(b, 1, 'd'))
print(b)
print('setitem(a,slice(1,3),[4,5]):', setitem(a, slice(1, 3), [4, 5]))
print(a)
print('\nDestructive:')
print('delitem(b,1)', delitem(b, 1))
print(b)
print('delitem(a,slice(1,3))', delitem(b, slice(1, 3)))
print(a)
def test_simple(self):
# create classes holding simple numeric types, and check
# various properties.
init = range(15, 25)
for fmt in formats:
alen = len(init)
int_array = ARRAY(fmt, alen)
ia = int_array(*init)
# length of instance ok?
assert len(ia) == alen
# slot values ok?
values = [ia[i] for i in range(len(init))]
assert values == init
# change the items
from operator import setitem
new_values = range(42, 42 + alen)
[setitem(ia, n, new_values[n]) for n in range(alen)]
values = [ia[i] for i in range(len(init))]
assert values == new_values
# are the items initialized to 0?
ia = int_array()
values = [ia[i] for i in range(len(init))]
assert values == [0] * len(init)
# Too many in itializers should be caught
with pytest.raises(IndexError):
int_array(*range(alen * 2))
CharArray = ARRAY(c_char, 3)
ca = CharArray("a", "b", "c")
# Should this work? It doesn't:
# CharArray("abc")
with pytest.raises(TypeError):
CharArray("abc")
assert ca[0] == "a"
assert ca[1] == "b"
assert ca[2] == "c"
assert ca[-3] == "a"
assert ca[-2] == "b"
assert ca[-1] == "c"
assert len(ca) == 3
# slicing is now supported, but not extended slicing (3-argument)!
from operator import getslice, delitem
with pytest.raises(TypeError):
getslice(ca, 0, 1, -1)
# cannot delete items
with pytest.raises(TypeError):
delitem(ca, 0)
def main():
a = [1, 2, 3]
b = ["a", "b", "c"]
print("a =", a)
print("b =", b)
print("\nConstructive:")
print(" concat(a, b)", operator.concat(a, b))
print("\nSearching:")
print(" contains(a, 1) :", operator.contains(a, 1))
print(" contains(b, 'd'):", operator.contains(b, "d"))
print(" countOf(a, 1) :", operator.countOf(a, 1))
print(" countOf(b, 'd') :", operator.countOf(b, "d"))
print(" indexOf(a, 1) :", operator.indexOf(a, 1))
print("\nAccess Items:")
print(" getitem(b, 1) :", operator.getitem(b, 1))
print(" getitem(b, slice(1, 3)) :",
operator.getitem(b, slice(1, 3)))
print(" setitem(b, 1, 'd') :", end=" ")
operator.setitem(b, 1, "d")
print(b)
print(" setitem(a, slice(1, 3), [4,5]):", end=" ")
operator.setitem(a, slice(1, 3), [4, 5])
print(a)
print("\nDestructive:")
print(" delitem(b, 1) :", end=" ")
operator.delitem(b, 1)
print(b)
print(" delitem(a, slice(1, 3)):", end=" ")
operator.delitem(a, slice(1, 3))
print(a)
def remove_index_operation(self, name):
if name in self._index_operations:
delitem(self._index_operations, name)
#delattr(self, name)
else:
raise AttributeError(
"No index operation with the name {}".format(name))
def test__delitem__(self):
from operator import delitem
del self.stuf['test1']
self.assertRaises(KeyError, lambda: delitem(self.stuf, 'test2'))
self.assertRaises(KeyError, lambda: delitem(self.stuf, 'test3'))
self.assertEqual(len(self.stuf), 2)
self.assertNotIn('test1', self.stuf)
self.assertIn('test2', self.stuf)
self.assertIn('test3', self.stuf)
def currMod_End(self, name, attrs):
log(1, "Fun "+name+"_End", attrs)
cm="\nvoid test_%s(void)\n{" %self.modName
cm+=self.elements['lvariable']
cm+="\n\n hdr(\"Testing of %s module started\");" %self.modName
cm+=self.elements['testCase']
cm+="\n hdr(\"Testing of %s module compleated\");" %self.modName
cm+="\n}\n"
self.elements[name]+=cm
operator.delitem(self.elements, 'lvariable')
operator.delitem(self.elements, 'testCase')
def test_operations(self):
repl_cfg = {'members': [{}, {}]}
repl = ReplicaSet(repl_cfg)
self.assertEqual(len(self.rs), 0)
operator.setitem(self.rs, 1, repl)
self.assertEqual(len(self.rs), 1)
self.assertEqual(operator.getitem(self.rs, 1).repl_id, repl.repl_id)
operator.delitem(self.rs, 1)
self.assertEqual(len(self.rs), 0)
self.assertRaises(KeyError, operator.getitem, self.rs, 1)
def test_operations(self):
repl_cfg = {'members': [{}, {}]}
repl = ReplicaSet(repl_cfg)
self.assertEqual(len(self.rs), 0)
operator.setitem(self.rs, 1, repl)
self.assertEqual(len(self.rs), 1)
self.assertEqual(operator.getitem(self.rs, 1).repl_id, repl.repl_id)
operator.delitem(self.rs, 1)
self.assertEqual(len(self.rs), 0)
self.assertRaises(KeyError, operator.getitem, self.rs, 1)
def test_operations(self):
config = {'shards': [{}, {}, {}]}
cluster = ShardedCluster(config)
self.assertEqual(len(self.sh), 0)
operator.setitem(self.sh, 1, cluster)
self.assertEqual(len(self.sh), 1)
self.assertEqual(operator.getitem(self.sh, 1)['id'], cluster.id)
operator.delitem(self.sh, 1)
self.assertEqual(len(self.sh), 0)
self.assertRaises(KeyError, operator.getitem, self.sh, 1)
cluster.cleanup()
def test_operations(self):
config = {'shards': [{}, {}, {}]}
cluster = ShardedCluster(config)
self.assertEqual(len(self.sh), 0)
operator.setitem(self.sh, 1, cluster)
self.assertEqual(len(self.sh), 1)
self.assertEqual(operator.getitem(self.sh, 1)['id'], cluster.id)
operator.delitem(self.sh, 1)
self.assertEqual(len(self.sh), 0)
self.assertRaises(KeyError, operator.getitem, self.sh, 1)
cluster.cleanup()
def test_operations(self):
config = {'members': [{}, {}, {}]}
shard = Shard(config)
self.assertEqual(len(self.sh), 0)
operator.setitem(self.sh, 1, shard)
self.assertEqual(len(self.sh), 1)
self.assertEqual(operator.getitem(self.sh, 1)['id'], shard.id)
operator.delitem(self.sh, 1)
self.assertEqual(len(self.sh), 0)
self.assertRaises(KeyError, operator.getitem, self.sh, 1)
shard.cleanup()
def test_delitem(self):
#operator = self.module
a = [4, 3, 2, 1]
self.assertRaises(TypeError, operator.delitem, a)
self.assertRaises(TypeError, operator.delitem, a, None)
self.assertTrue(operator.delitem(a, 1) is None)
self.assertTrue(a == [4, 2, 1])
def test_delitem(self):
#operator = self.module
a = [4, 3, 2, 1]
self.assertRaises(TypeError, operator.delitem, a)
self.assertRaises(TypeError, operator.delitem, a, None)
self.assertTrue(operator.delitem(a, 1) is None)
self.assertTrue(a == [4, 2, 1])
def patchdict(k, v):
if k in os.environ:
self._cleanups.append(lambda old=os.environ[k]: setitem(os.environ, k, old))
else:
self._cleanups.append(lambda: delitem(os.environ, k))
os.environ[k] = v
def update(self, __m: Mapping[Any, Any], **kwargs: Any) -> None:
changes, deletions, = get_diff(self, dict(__m))
self.diff.changes.update(changes)
[delitem(self.diff.changes, key) for key in deletions]
self.diff.deletions.update(deletions)
[self.diff.deletions.discard(key) for key in changes.keys()]
super(JSONVC, self).update(__m, **kwargs)
def __delitem__(self, key: Any) -> None:
if isinstance(key, ConstructSymbol):
del self._dict[key]
self._disconnect(key)
else:
self._consume_multiindex(key[:-1], lambda a: delitem(a, key[-1]))
def patchdict(k, v):
if k in os.environ:
self._cleanups.append(
lambda old=os.environ[k]: setitem(os.environ, k, old))
else:
self._cleanups.append(lambda: delitem(os.environ, k))
os.environ[k] = v
def test_operations(self):
server_id = self.servers.create('mongod', {}, autostart=False)
self.assertTrue(len(self.servers) == 1)
self.assertTrue(server_id in self.servers)
server_id2 = 'server-id2'
server2 = Server(os.path.join(os.environ.get('MONGOBIN', ''), 'mongod'), {})
server2.start(30)
server2_pid = server2.info()['procInfo']['pid']
self.servers[server_id2] = server2
self.assertTrue(self.servers[server_id2]['procInfo']['pid'] == server2_pid)
self.assertTrue(server_id2 in self.servers)
for h_id in self.servers:
self.assertTrue(h_id in (server_id, server_id2))
operator.delitem(self.servers, server_id2)
self.assertFalse(server_id2 in self.servers)
server2.stop()
server2.cleanup()
def test_operations(self):
host_id = self.hosts.create('mongod', {}, autostart=False)
self.assertTrue(len(self.hosts) == 1)
self.assertTrue(host_id in self.hosts)
host_id2 = 'host-id2'
host2 = Host(os.path.join(os.environ.get('MONGOBIN', ''), 'mongod'), {})
host2.start(30)
host2_pid = host2.info()['procInfo']['pid']
self.hosts[host_id2] = host2
self.assertTrue(self.hosts[host_id2]['procInfo']['pid'] == host2_pid)
self.assertTrue(host_id2 in self.hosts)
for h_id in self.hosts:
self.assertTrue(h_id in (host_id, host_id2))
operator.delitem(self.hosts, host_id2)
self.assertFalse(host_id2 in self.hosts)
host2.stop()
host2.cleanup()
def test_operations(self):
server_id = self.servers.create('mongod', {}, autostart=False)
self.assertTrue(len(self.servers) == 1)
self.assertTrue(server_id in self.servers)
server_id2 = 'server-id2'
server2 = Server(os.path.join(os.environ.get('MONGOBIN', ''), 'mongod'), {})
server2.start(30)
server2_pid = server2.info()['procInfo']['pid']
self.servers[server_id2] = server2
self.assertTrue(self.servers[server_id2]['procInfo']['pid'] == server2_pid)
self.assertTrue(server_id2 in self.servers)
for h_id in self.servers:
self.assertTrue(h_id in (server_id, server_id2))
operator.delitem(self.servers, server_id2)
self.assertFalse(server_id2 in self.servers)
server2.stop()
server2.cleanup()
def operator_sequence_operation():
"""
we do some sequence operation like following.
---CRUD---
container :: in, append, extend, clear, remove, __new__, __eq__
sized :: len, index
iterable :: set, get
"""
a = [1, 2, 3]
b = list('abc')
print('a =', a)
print('b =', b)
# concatenate
print('\nConstructive:')
print(' concat(a, b):', operator.concat(a, b))
# search
print('\nSearch:')
print(' contains(a, 1) :', operator.contains(a, 1))
print(' contains(b, "d"):', operator.contains(b, "d"))
print(' countOf(a, 1) :', operator.countOf(a, 1))
print(' countOf(b, "d") :', operator.countOf(b, "d"))
print(' indexOf(a, 1) :', operator.indexOf(a, 1))
# access items
print('\nAccess:')
print(' getitem(b, 1) :', operator.getitem(b, 1))
print(' getitem(b, slice(1, 3)) :',
operator.getitem(b, slice(1, 3)))
print(' setitem(b, 1, "d") :', end=' ')
operator.setitem(b, 1, "d")
print(b)
print(' setitem(a, slice(1, 3), [4, 5]) :', end=' ')
operator.setitem(a, slice(1, 3), [4, 5])
print(a)
# remove items
print('\nDestructive:')
print(' delitem(b, 1) :', end=' ')
operator.delitem(b, 1)
print(b)
print(' delitem(a, slice(1, 3)) :', end=' ')
operator.delitem(a, slice(1, 3))
print(a)
def test_reuse(min_items=2, max_items=1000):
items = KeypoolDict()
for i in xrange(0, MAX_ITER):
rand = random.randint(min_items, max_items)
keys = [items.setitem(i) for i in xrange(0, rand)]
# No keys are identical
assert_unique(keys)
# Delete all the items
[delitem(items, key) for key in items.keys()]
# The old keys are now reused
keys2 = [items.setitem(i) for i in xrange(0, rand)]
assert keys == keys2
assert_unique(keys)
[delitem(items, key) for key in items.keys()]
def CreateTree(dataSet, labels):
classList = [example[-1] for example in dataSet]
# 如果类别完全相同，这停止划分，退出
if classList.count(classList[0]) == len(classList):
return classList[0]
# 如果只有一个特征，则遍历该特征，返回出现次数最多的
if len(dataSet[0]) == 1:
return majorityCnt(classList)
# 构造根节点
bestFeat = chooseBestFeatureToSplit(dataSet)
bestFeatLabel = labels[bestFeat]
mytree = {bestFeatLabel: {}}
# 将最佳标签删除
operator.delitem(labels, bestFeat)
#operator.del(labels(bestFeat))
# 最佳标签的取值list
featValues = [example[bestFeat] for example in dataSet]
# 去除重复值
uniqueVals = set(featValues)
for value in uniqueVals:
subLabels = labels[:]
mytree[bestFeatLabel][value] = CreateTree(
splitDataSet(dataSet, bestFeat, value), subLabels)
return mytree
def codeMod_End(self, name, attrs):
log(1, "Fun "+name+"_End", attrs)
if self.elements['func']:
cm=self.elements['func']+"\n{\n"+self.elements['lvariable']+self.elements['testCase']+"\n}\n"
else:
cm=self.elements['lvariable']+self.elements['testCase']
self.elements[name]+=cm
operator.delitem(self.elements, 'lvariable')
operator.delitem(self.elements, 'func')
operator.delitem(self.elements, 'testCase')
def rpn_calc(source):
stack = []
operators = ['+', '-', '/', '*']
for item in source:
if item not in operators:
stack.append(item)
else:
if item == '+':
stack.append(operator.add(stack.pop(), stack.pop()))
if item == '-':
stack.append(operator.add(-stack.pop(), stack.pop()))
if item == '*':
stack.append(operator.mul(stack.pop(), stack.pop()))
if item == '/':
stack.append(operator.delitem(stack.pop(), stack.pop()))
return stack[0]
def io(self, fd, events, ref=True, priority=None):
# We rely on hard references here and explicit calls to
# close() on the returned object to correctly manage
# the watcher lifetimes.
io_watchers = self._io_watchers
try:
io_watcher = io_watchers[fd]
assert io_watcher._multiplex_watchers, ("IO Watcher %s unclosed but should be dead" % io_watcher)
except KeyError:
# Start the watcher with just the events that we're interested in.
# as multiplexers are added, the real event mask will be updated to keep in sync.
# If we watch for too much, we get spurious wakeups and busy loops.
io_watcher = self._watchers.io(self, fd, 0)
io_watchers[fd] = io_watcher
io_watcher._no_more_watchers = lambda: delitem(io_watchers, fd)
return io_watcher.multiplex(events)
class TestFrozendict:
@pytest.mark.parametrize('mutator', [
lambda d: operator.setitem(d, 'key', 'value'),
lambda d: operator.delitem(d, 'key'),
frozendict.clear,
frozendict.popitem,
lambda d: frozendict.pop(d, 'key', None),
lambda d: frozendict.setdefault(d, 'key', 'value'),
lambda d: frozendict.update(d, key='value'),
])
def test_immutability(self, mutator):
with pytest.raises(TypeError):
mutator(frozendict())
def test_copying(self):
value = frozendict(a=1)
copied = copy(value)
assert value == copied
assert value is not copied
def _perform_redeem(self, voucher, counter, random_tokens):
"""
Use the redeemer to redeem the given voucher and random tokens.
This will not persist the voucher or random tokens but it will persist
the result.
:return Deferred[bool]: A ``Deferred`` firing with ``True`` if and
only if redemption succeeds.
"""
if not isinstance(voucher.state, model_Pending):
raise ValueError(
"Cannot redeem voucher in state {} instead of Pending.".format(
voucher.state, ), )
# Ask the redeemer to do the real task of redemption.
self._log.info("Redeeming random tokens for a voucher ({voucher}).",
voucher=voucher)
d = bracket(
lambda: setitem(
self._active,
voucher.number,
model_Redeeming(
started=self.store.now(),
counter=voucher.state.counter,
),
),
lambda: delitem(self._active, voucher.number),
lambda: self.redeemer.redeemWithCounter(voucher, counter,
random_tokens),
)
d.addCallbacks(
partial(self._redeem_success, voucher.number, counter),
partial(self._redeem_failure, voucher.number),
)
d.addErrback(partial(self._final_redeem_error, voucher.number))
return d
Operation – ob[pos]
'''
import operator
li = [1, 2, 3, 4, 6]
print("The original list is :", end=" ")
for i1 in range(0, len(li)):
print(li[i1], end=" ")
print("\r")
# using setitem() to assign 3 at 4th position
operator.setitem(li, 3, 90)
print("The Modified list is :", end=" ")
for i in range(0, len(li)):
print(li[i], end=" ")
print("\r")
# printing modified list after delitem()
operator.delitem(li, 3)
print("The deleted list is :", end=" ")
for i in range(len(li)):
print(li[i], end=" ")
print("\r")
# using getitem() to access 4th element
print("To get the 3rd position value from list :", end=" ")
print(operator.getitem(li, 3))
#https://www.geeksforgeeks.org/operator-functions-python-set-2/
import operator
li = [1, 5, 6, 7, 8]
operator.delitem(li, slice(2, 4))
print("modified list :", end="")
for i in range(0, len(li)):
print(li[i], end="")
print(my_list[1])
print(operator.getitem(my_list,3)) #it require two elements
#if sequence is mutable then we can delete or set item
my_list[1] = 100
print(my_list)
del my_list[1]
print(my_list)
#now we use operator for set and delete the item
my_list = [1,2,3,4]
operator.setitem(my_list,1,100)
print(my_list)
operator.delitem(my_list,1)
print(my_list)
print("############################ itemgetter ##############################")
my_list = [1,2,3,4]
f = operator.itemgetter(1) #here we pass index
print(f(my_list))
f = operator.itemgetter(1,3)
print(f(my_list))
print("############################ attrgetter ##############################")
class MyClass:
def __init__(self):
self.a = 10
self.b = 20
self.c = 30
def py_delitem(obj, key):
""" call __delitem__ on obj"""
operator.delitem(obj, key)
return (obj,)
# 0
# 1
c = [1, 'a', None, 10.01, {'key':'value'}]
# 通过下标操作序列
print operator.getitem(c, 4)
print operator.getslice(c, 1, 4)
operator.setitem(c, 2, 9999)
print c
operator.setslice(c, 3,-1, [10,20,30,40,50])
print c
operator.delitem(c, 0)
print c
operator.delslice(c, 2, 7)
print c
# output
# {'key': 'value'}
# ['a', None, 10.01]
# [1, 'a', 9999, 10.01, {'key': 'value'}]
# [1, 'a', 9999, 10, 20, 30, 40, 50, {'key': 'value'}]
# ['a', 9999, 10, 20, 30, 40, 50, {'key': 'value'}]
# ['a', 9999, {'key': 'value'}]
"""
获取对象元素或属性方法：
1.创建一个回调函数，
def clearElements(self):
_f=lambda x: operator.delitem(self.elements, x)
list(list(map(_f, ['include', 'define', 'gvariable', 'codeMod', 'currMod'])))
def test_modify_tree(self):
tree = self.repo[TREE_SHA]
with pytest.raises(TypeError):
operator.setitem('c', tree['a'])
with pytest.raises(TypeError):
operator.delitem('c')
def test_delitem(self):
a = [4, 3, 2, 1]
self.failUnlessRaises(TypeError, operator.delitem, a)
self.failUnlessRaises(TypeError, operator.delitem, a, None)
self.failUnless(operator.delitem(a, 1) is None)
self.assert_(a == [4, 2, 1])
print('#' * 52 + ' We can do the same thing using:')
print(operator.getitem(my_list, 1))
print('#' * 52 +
' If the sequence is mutable, we can also set or remove items:')
my_list = [1, 2, 3, 4]
my_list[1] = 100
del my_list[3]
print(my_list)
my_list = [1, 2, 3, 4]
operator.setitem(my_list, 1, 100)
operator.delitem(my_list, 3)
print(my_list)
print(
'#' * 52 +
' We can also do the same thing using the **operator** modules **itemgetter** function.'
)
print('#' * 52 + ' The difference is that this returns a callable:')
f = operator.itemgetter(2)
print(f(my_list))
x = 'python'
print(f(x))
def remove_index_operation(self, name):
if name in self._index_operations:
delitem(self._index_operations, name)
delattr(self, name)
else:
raise AttributeError("No index operation with the name {}".format(name))
def test_modify_tree(self):
tree = self.repo[TREE_SHA]
with pytest.raises(TypeError): operator.setitem('c', tree['a'])
with pytest.raises(TypeError): operator.delitem('c')
import operator
def test_delitem(self):
self.assertEqual(0, len(self.container))
self.container['key'] = 'value'
self.assertEqual(1, len(self.container))
self.assertEqual(None, operator.delitem(self.container, 'key'))
self.assertEqual(0, len(self.container))
def test_delitem(self):
a = [4, 3, 2, 1]
self.failUnless(operator.delitem(a, 1) is None)
self.assert_(a == [4, 2, 1])
print("Mul operator:", reduce(operator.mul, [1, 2, 3, 4, 5]))
from operator import is_
print(is_('abc', "def"))
print('\n*** Attribute getters and setters ***')
l = [1, 2, 3, 4]
g = operator.getitem(l, 1)
print(g)
l[1] = 10
del l[3]
print(l)
l = [1, 2, 3, 4]
g = operator.setitem(l, 1, 10)
g = operator.delitem(l, 3)
print(l)
print('\n*** Item getter, think like a partial function ***')
f = operator.itemgetter(2)
print("\tf is a callable: ", type(f))
print("\tGet item(from list) ", f(l))
s = "Python"
print("\tGet item(from string)", f(s))
f = operator.itemgetter(-1, -2, 0)
print("\tGet item(from string)", f(s))
l = [1, 2, 3, 4, 5]
print("\tGet items(from list) ", f(l))
print('\n*** Attribute getter ***')
def testDeleteNonExistingItem(self):
storage = self.storage
# This used to raise a KeyError, but sometimes the underlying storage
# can get inconsistent, so it is nicer to accept it.
# See https://github.com/plone/plone.scale/issues/15
delitem(storage, 'foo')
def resource_factory(self, name, schema, resource_cls=None):
"""
Registers a new resource with a given schema. The schema must not have any unresolved references
(such as `{"$ref": "#"}` for self-references, or otherwise). A subclass of :class:`Resource`
may be provided to add specific functionality to the resulting :class:`Resource`.
:param str name:
:param dict schema:
:param Resource resource_cls: a subclass of :class:`Resource` or None
:return: The new :class:`Resource`.
"""
cls = type(str(upper_camel_case(name)), (resource_cls or Resource, collections.MutableMapping), {
'__doc__': schema.get('description', '')
})
cls._schema = schema
cls._client = self
cls._links = links = {}
for link_schema in schema['links']:
link = Link(self,
rel=link_schema['rel'],
href=link_schema['href'],
method=link_schema['method'],
schema=link_schema.get('schema', None),
target_schema=link_schema.get('targetSchema', None))
# Set Resource._self, etc. for the special methods as they are managed by the Resource class
if link.rel in ('self', 'instances', 'create', 'update', 'destroy'):
setattr(cls, '_{}'.format(link.rel), link)
links[link.rel] = link
if link.rel != 'update': # 'update' is a special case because of MutableMapping.update()
setattr(cls, snake_case(link.rel), link)
# TODO routes (instance & non-instance)
for property_name, property_schema in schema.get('properties', {}).items():
# skip $uri and $id as these are already implemented in Resource and overriding them causes unnecessary
# fetches.
if property_name.startswith('$'):
continue
if property_schema.get('readOnly', False):
# TODO better error message. Raises AttributeError("can't set attribute")
setattr(cls,
property_name,
property(fget=partial((lambda name, obj: getitem(obj, name)), property_name),
doc=property_schema.get('description', None)))
else:
setattr(cls,
property_name,
property(fget=partial((lambda name, obj: getitem(obj, name)), property_name),
fset=partial((lambda name, obj, value: setitem(obj, name, value)), property_name),
fdel=partial((lambda name, obj: delitem(obj, name)), property_name),
doc=property_schema.get('description', None)))
root = None
if 'instances' in links:
root = cls._instances.href
elif 'self' in links:
root = cls._self.href[:cls._self.href.rfind('/')]
else:
root = self._root_path + '/' + name.replace('_', '-')
self._resources[root] = cls
return cls
print operator.contains(l, 2)
print operator.contains(l, 30)
print operator.contains(s, "ll")
print operator.contains(s, "z")
print operator.contains(t, "a")
print operator.contains(t, 2)
print operator.contains(d, 3)
print operator.contains(d, 0)
print operator.countOf(l, 9)
print operator.countOf(l, 30)
print operator.countOf(s, "l")
print operator.countOf(t, "a")
operator.delitem(l, 9)
print l
operator.delitem(l, 0)
print l
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 9]
s = "hello world"
t = ("a", "b", "c")
d = {1:1, 2:2, 3:3, 4:4, 5:5}
print operator.getitem(l, 2)
print operator.getitem(s, 0)
print operator.getitem(t, 1)
print operator.getitem(d, 4)
def __delitem__(self, key):
return operator.delitem(self._dict, key)
def add_consumer(self, consumer):
self.consumers[consumer.tag] = consumer
# so the consumer gets garbage collected when it is cancelled
consumer.cancelled_future.add_done_callback(lambda fut: delitem(self.consumers, fut.result().tag))
def test_delitem(self):
a = [4, 3, 2, 1]
self.failUnlessRaises(TypeError, operator.delitem, a)
self.failUnlessRaises(TypeError, operator.delitem, a, None)
self.failUnless(operator.delitem(a, 1) is None)
self.assert_(a == [4, 2, 1])
def test_errors(self):
self.assertRaises(TypeError, lambda: self.g1a['attempting'])
self.assertRaises(IndexError, lambda: self.g1b[1])
self.assertRaises(TypeError, lambda: operator.delitem(self.g1c, 0) )
import operator
li = [1, 2, 3, 4, 5]
for i in range(0, len(li)):
print(li[i], end=" ")
print("\r")
print("after set iteam")
operator.setitem(li, 3, 2)
###obj,postion,value
for i in range(0, len(li)):
print(li[i], end=" ")
print("\r")
print("after delete")
operator.delitem(li, 2)
for i in range(0, len(li)):
print(li[i], end=" ")
print("\r")
print("get value")
print(operator.getitem(li, 1))
def __delitem__(self, *args):
return operator.delitem(self.value, *args)
class TestWebElementWrapper:
"""Generic tests for WebElementWrapper.
Note: For some methods, there's a dedicated test class with more involved
tests.
"""
@pytest.fixture
def elem(self):
return get_webelem()
def test_nullelem(self):
"""Test __init__ with a null element."""
with pytest.raises(webelem.IsNullError):
get_webelem(null=True)
def test_double_wrap(self, elem):
"""Test wrapping a WebElementWrapper."""
with pytest.raises(TypeError) as excinfo:
webelem.WebElementWrapper(elem)
assert str(excinfo.value) == "Trying to wrap a wrapper!"
@pytest.mark.parametrize(
'code',
[
str,
lambda e: e[None],
lambda e: operator.setitem(e, None, None),
lambda e: operator.delitem(e, None),
lambda e: None in e,
len,
lambda e: e.is_visible(None),
lambda e: e.rect_on_view(),
lambda e: e.is_writable(),
lambda e: e.is_content_editable(),
lambda e: e.is_editable(),
lambda e: e.is_text_input(),
lambda e: e.debug_text(),
list, # __iter__
])
def test_vanished(self, elem, code):
"""Make sure methods check if the element is vanished."""
elem._elem.isNull.return_value = True
with pytest.raises(webelem.IsNullError):
code(elem)
def test_str(self, elem):
assert str(elem) == 'text'
@pytest.mark.parametrize('is_null, expected', [
(False, "<qutebrowser.browser.webelem.WebElementWrapper "
"html='<fakeelem/>'>"),
(True, '<qutebrowser.browser.webelem.WebElementWrapper html=None>'),
])
def test_repr(self, elem, is_null, expected):
elem._elem.isNull.return_value = is_null
assert repr(elem) == expected
def test_getitem(self):
elem = get_webelem(attributes={'foo': 'bar'})
assert elem['foo'] == 'bar'
def test_getitem_keyerror(self, elem):
with pytest.raises(KeyError):
elem['foo'] # pylint: disable=pointless-statement
def test_setitem(self, elem):
elem['foo'] = 'bar'
assert elem._elem.attribute('foo') == 'bar'
def test_delitem(self):
elem = get_webelem(attributes={'foo': 'bar'})
del elem['foo']
assert not elem._elem.hasAttribute('foo')
def test_setitem_keyerror(self, elem):
with pytest.raises(KeyError):
del elem['foo']
def test_contains(self):
elem = get_webelem(attributes={'foo': 'bar'})
assert 'foo' in elem
assert 'bar' not in elem
@pytest.mark.parametrize('attributes, expected', [
({
'one': '1',
'two': '2'
}, {'one', 'two'}),
({}, set()),
])
def test_iter(self, attributes, expected):
elem = get_webelem(attributes=attributes)
assert set(elem) == expected
@pytest.mark.parametrize('attributes, length', [
({
'one': '1',
'two': '2'
}, 2),
({}, 0),
])
def test_len(self, attributes, length):
elem = get_webelem(attributes=attributes)
assert len(elem) == length
@pytest.mark.parametrize('attributes, writable', [
([], True),
(['disabled'], False),
(['readonly'], False),
(['disabled', 'readonly'], False),
])
def test_is_writable(self, attributes, writable):
elem = get_webelem(attributes=attributes)
assert elem.is_writable() == writable
@pytest.mark.parametrize('attributes, expected', [
({}, False),
({
'contenteditable': 'false'
}, False),
({
'contenteditable': 'inherit'
}, False),
({
'contenteditable': 'true'
}, True),
])
def test_is_content_editable(self, attributes, expected):
elem = get_webelem(attributes=attributes)
assert elem.is_content_editable() == expected
@pytest.mark.parametrize('tagname, attributes, expected', [
('input', {}, True),
('textarea', {}, True),
('select', {}, False),
('foo', {
'role': 'combobox'
}, True),
('foo', {
'role': 'textbox'
}, True),
('foo', {
'role': 'bar'
}, False),
('input', {
'role': 'bar'
}, True),
])
def test_is_text_input(self, tagname, attributes, expected):
elem = get_webelem(tagname=tagname, attributes=attributes)
assert elem.is_text_input() == expected
@pytest.mark.parametrize('xml, expected', [
('<fakeelem/>', '<fakeelem/>'),
('<foo>\n<bar/>\n</foo>', '<foo><bar/></foo>'),
('<foo>{}</foo>'.format('x' * 500), '<foo>{}…'.format('x' * 494)),
],
ids=['fakeelem', 'newlines', 'long'])
def test_debug_text(self, elem, xml, expected):
elem._elem.toOuterXml.return_value = xml
assert elem.debug_text() == expected
def testDeleteNonExistingItem(self):
storage = self.storage
# This used to raise a KeyError, but sometimes the underlying storage
# can get inconsistent, so it is nicer to accept it.
# See https://github.com/plone/plone.scale/issues/15
delitem(storage, 'foo')
class TestWebKitElement:
"""Generic tests for WebKitElement.
Note: For some methods, there's a dedicated test class with more involved
tests.
"""
@pytest.fixture
def elem(self):
return get_webelem()
def test_nullelem(self):
"""Test __init__ with a null element."""
with pytest.raises(webkitelem.IsNullError):
get_webelem(null=True)
def test_double_wrap(self, elem):
"""Test wrapping a WebKitElement."""
with pytest.raises(TypeError, match="Trying to wrap a wrapper!"):
webkitelem.WebKitElement(elem, tab=None)
@pytest.mark.parametrize('code', [
pytest.param(str, id='str'),
pytest.param(lambda e: e[None], id='getitem'),
pytest.param(lambda e: operator.setitem(e, None, None), id='setitem'),
pytest.param(lambda e: operator.delitem(e, None), id='delitem'),
pytest.param(lambda e: '' in e, id='contains'),
pytest.param(list, id='iter'),
pytest.param(len, id='len'),
pytest.param(lambda e: e.has_frame(), id='has_frame'),
pytest.param(lambda e: e.geometry(), id='geometry'),
pytest.param(lambda e: e.value(), id='value'),
pytest.param(lambda e: e.set_value('foo'), id='set_value'),
pytest.param(lambda e: e.insert_text('foo'), id='insert_text'),
pytest.param(lambda e: e.is_writable(), id='is_writable'),
pytest.param(lambda e: e.is_content_editable(),
id='is_content_editable'),
pytest.param(lambda e: e.is_editable(), id='is_editable'),
pytest.param(lambda e: e.is_text_input(), id='is_text_input'),
pytest.param(lambda e: e.remove_blank_target(),
id='remove_blank_target'),
pytest.param(lambda e: e.outer_xml(), id='outer_xml'),
pytest.param(lambda e: e.is_content_editable_prop(),
id='is_content_editable_prop'),
pytest.param(lambda e: e.tag_name(), id='tag_name'),
pytest.param(lambda e: e.rect_on_view(), id='rect_on_view'),
pytest.param(lambda e: e._is_visible(None), id='is_visible'),
])
def test_vanished(self, elem, code):
"""Make sure methods check if the element is vanished."""
elem._elem.isNull.return_value = True
elem._elem.tagName.return_value = 'span'
with pytest.raises(webkitelem.IsNullError):
code(elem)
def test_str(self, elem):
assert str(elem) == 'text'
wke_qualname = 'qutebrowser.browser.webkit.webkitelem.WebKitElement'
@pytest.mark.parametrize('is_null, xml, expected', [
(False, '<fakeelem/>', "<{} html='<fakeelem/>'>".format(wke_qualname)),
(False, '<foo>\n<bar/>\n</foo>',
"<{} html='<foo><bar/></foo>'>".format(wke_qualname)),
(False, '<foo>{}</foo>'.format('x' * 500),
"<{} html='<foo>{}…'>".format(wke_qualname, 'x' * 494)),
(True, None, '<{} html=None>'.format(wke_qualname)),
])
def test_repr(self, elem, is_null, xml, expected):
elem._elem.isNull.return_value = is_null
elem._elem.toOuterXml.return_value = xml
assert repr(elem) == expected
def test_getitem(self):
elem = get_webelem(attributes={'foo': 'bar'})
assert elem['foo'] == 'bar'
def test_getitem_keyerror(self, elem):
with pytest.raises(KeyError):
elem['foo']
def test_setitem(self, elem):
elem['foo'] = 'bar'
assert elem._elem.attribute('foo') == 'bar'
def test_delitem(self):
elem = get_webelem(attributes={'foo': 'bar'})
del elem['foo']
assert not elem._elem.hasAttribute('foo')
def test_setitem_keyerror(self, elem):
with pytest.raises(KeyError):
del elem['foo']
def test_contains(self):
elem = get_webelem(attributes={'foo': 'bar'})
assert 'foo' in elem
assert 'bar' not in elem
def test_not_eq(self):
one = get_webelem()
two = get_webelem()
assert one != two
def test_eq(self):
one = get_webelem()
two = webkitelem.WebKitElement(one._elem, tab=None)
assert one == two
def test_eq_other_type(self):
assert get_webelem() != object()
@pytest.mark.parametrize('attributes, expected', [
({
'one': '1',
'two': '2'
}, {'one', 'two'}),
({}, set()),
])
def test_iter(self, attributes, expected):
elem = get_webelem(attributes=attributes)
assert set(elem) == expected
@pytest.mark.parametrize('attributes, length', [
({
'one': '1',
'two': '2'
}, 2),
({}, 0),
])
def test_len(self, attributes, length):
elem = get_webelem(attributes=attributes)
assert len(elem) == length
@pytest.mark.parametrize('attributes, writable', [
([], True),
(['disabled'], False),
(['readonly'], False),
(['disabled', 'readonly'], False),
])
def test_is_writable(self, attributes, writable):
elem = get_webelem(attributes=attributes)
assert elem.is_writable() == writable
@pytest.mark.parametrize('attributes, expected', [
({}, False),
({
'contenteditable': 'false'
}, False),
({
'contenteditable': 'inherit'
}, False),
({
'contenteditable': 'true'
}, True),
])
def test_is_content_editable(self, attributes, expected):
elem = get_webelem(attributes=attributes)
assert elem.is_content_editable() == expected
@pytest.mark.parametrize('tagname, attributes, expected', [
('input', {}, True),
('textarea', {}, True),
('select', {}, False),
('foo', {
'role': 'combobox'
}, True),
('foo', {
'role': 'textbox'
}, True),
('foo', {
'role': 'bar'
}, False),
('input', {
'role': 'bar'
}, True),
])
def test_is_text_input(self, tagname, attributes, expected):
elem = get_webelem(tagname=tagname, attributes=attributes)
assert elem.is_text_input() == expected
@pytest.mark.parametrize('attribute, code', [
('geometry', lambda e: e.geometry()),
('toOuterXml', lambda e: e.outer_xml()),
])
def test_simple_getters(self, elem, attribute, code):
sentinel = object()
mock = getattr(elem._elem, attribute)
mock.return_value = sentinel
assert code(elem) is sentinel
@pytest.mark.parametrize('frame, expected', [(object(), True),
(None, False)])
def test_has_frame(self, elem, frame, expected):
elem._elem.webFrame.return_value = frame
assert elem.has_frame() == expected
def test_tag_name(self, elem):
elem._elem.tagName.return_value = 'SPAN'
assert elem.tag_name() == 'span'
def test_value(self, elem):
elem._elem.evaluateJavaScript.return_value = 'js'
assert elem.value() == 'js'
@pytest.mark.parametrize('editable, value, uses_js, arg', [
('false', 'foo', True, 'this.value="foo"'),
('false', "foo'bar", True, r'this.value="foo\'bar"'),
('true', 'foo', False, 'foo'),
])
def test_set_value(self, editable, value, uses_js, arg):
elem = get_webelem(attributes={'contenteditable': editable})
elem.set_value(value)
attr = 'evaluateJavaScript' if uses_js else 'setPlainText'
called_mock = getattr(elem._elem, attr)
called_mock.assert_called_with(arg)
#包含 同 in
print operator.sequenceIncludes([1,2,3],1)
print operator.sequenceIncludes("123","1")
#计数,计算某个值在序列中出现的次数
print operator.countOf([1,2,1,3,1],1)
#set序列可以去重
print operator.countOf(set([1,2,1,3,1]),1)
#变量的值 同__index__()
a = 12
print operator.index(a)
#删除字典中的某对数值 同del a[b]
a = {0:"zero",1:"one",2:"two"}
operator.delitem(a,0)
print a
#删除序列中的某片数值 同del a[b:c]
a = [1,2,3,4,5]
operator.delslice(a,0,1)
print a
#取得字典的值 同 a[b]
a = {0:"zero",1:"one",2:"two"}
print operator.getitem(a,0)
#取得序列的片段 同 a[b:c]
a = [1,2,3,4,5]
print operator.getslice(a,0,2)
print(" is_", op.is_("abc","abc"))
print(" is not ", "abc" is not "abcd")
print(" is_", op.is_not("abc","abcd"))
print(" in ", "a" in "abc")
print(" __contains__", "abc".__contains__('a'))
print(" contains", op.contains("abc",'a'))
print(" in ", "a" not in "abc")
print(" __contains__", not("abc".__contains__('a')))
print(" contains", op.not_(op.contains("abc",'a')))
print(" __getslice__ :", [0,1,2,3].__getslice__(0,2))
print(" getslice :", op.getslice([0,1,2,3],0,2))
l=[0,1,2,3]
print(" __setslice__ :", l.__setslice__(0,2,[99,99]),l)
print(" __delslice__ :", l.__delslice__(0,2),l)
l=[0,1,2,3]
print(" setslice :", op.setslice(l,0,2,[99,99]),l)
print(" delslice :", op.delslice(l,0,2),l)
print(" __getitem__ : ", [0,1,2,3].__getitem__(slice(0,2)))
print(" getitem : ", op.getitem([0,1,2,3],slice(0,2)))
l=[0,1,2,3]
print(" __setitem__ :", l.__setitem__(slice(0,2),[99,99]),l)
print(" __delitem__ :", l.__delitem__(slice(0,2)),l)
l=[0,1,2,3]
print(" setitem :", op.setitem(l,slice(0,2),[99,99]),l)
print(" delitem :", op.delitem(l,slice(0,2)),l)
def delitem(a, b):
return operator.delitem(a, b)
