def __init__(self,arg): super(mama, self).__init__() Hello._init__(self,"",0,0) if arg == "OK": self.name = "Sarah" self.age = 20 self.size = 0 # Hello.__init__(self,self.name,self.age,self.size) mama.set(self,self.name,self.age,self.size) mama.get(self)
def Greetings():
clk1 = Signal(0)
clk2 = Signal(0)
clkdriver_1 = ClkDriver(clk1) # positional and default association
clkdriver_2 = ClkDriver(clk=clk2, period=19) # named association
hello_1 = Hello(clk=clk1) # named and default association
hello_2 = Hello(to="MyHDL", clk=clk2) # named association
return clkdriver_1, clkdriver_2, hello_1, hello_2
class guo(object):
"""docstring for guo"""
def __init__(self):
super(guo, self).__init__()
h = Hello()
h._init__("Rama", 20, 10.5)
h.speak()
mm = mama("OK")
def say(self, query, *args):
hello = Hello()
name = query.get('name')
if name is None:
return hello.say()
return hello.say(', '.join(name))
def greeting(self, query, *args):
hello = Hello()
return hello.say(args[0])
#!/usr/bin/env python
import sys
sys.path.append("../../library")
from Hello import Hello
Hello().onModuleLoad()
print "Simple python test of onModuleLoad succeeded."
#!/usr/bin/env python3
#coding:utf-8
#动态语言与静态语言最大区别：函数类的定义是编译时定义，而是运行时创建
#当导入一个模块时，解释器会依次执行该模块的语句，然后动态创建出一个hello的class对象
from Hello import Hello
h = Hello()
h.hello() #Hello, world.
h.hello('boy') #Hello, boy.
#type()函数查看一个类型或变量类型
print(type(h)) #<class 'Hello.Hello'>
print(type(Hello)) #<class 'type'>
#class是动态创建的，创建class的方法就是使用type()函数
#type()函数即可返回一个对象的类型，又可以创建出新的类型
def fn(self, name='wori'): #先定义函数
print('Hello, %s.' % name)
Hello = type('Hello', (object, ), dict(hello=fn)) #创建Hello class
h = Hello()
h.hello() #Hello, wori.
h.hello('woca') #Hello, woca.
print(type(h)) #<class '__main__.Hello'>
print(type(Hello)) #<class 'type'>
'''
创建出一个class对象，type()函数需要依次传入3个参数
def test_split(self):
obj = Hello().platform()
print(obj)
self.assertEqual(platform.platform(),obj)
#print('hello Peter')
from Hello import Hello
Name=input('What Names do you want to say hello to?')
Names=Name.split(",")
print(Names)
Test=Hello(Names,Greetings='Hi').say_hi()
def get(self): Hello._init__(self,self.name,self.age,self.size) mama.speak(self)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- __author__ = 'WZG' from Hello import Hello h = Hello() print(type(Hello), type(h), h.hello())
def say(self, query, *args):
hello = Hello()
name = query.get('name');
if name is None:
return hello.say()
return hello.say(', '.join(name))
def greeting(self, query, *args):
hello = Hello()
return hello.say(args[0])
from Hello import Hello
h = Hello()
h.hello()
#Hello, world
h1 = Hello()
h1.hello('Nancy')
#Hello, Nancy.
print(type(Hello))
#<class 'type'>
#type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type
print(type(h1))
#<class 'Hello.Hello'>
#h1是一个实例，它的类型就是class Hello
#type()函数既可以返回一个对象的类型，又可以创建出新的类型
def fn(self, name='world'): # 先定义函数
print('Hello, %s.' % name)
Hello1 = type('Hello', (object, ), dict(hello=fn))
#依次传入三个参数：
#1.class的名称；
#2.继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
#3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
print(type(Hello1))
#<class 'type'>
def main():
ho.Hello()
Hello()
class Teste(object):
_f = Node()
_h = Hello()
def __init__(self):
def make_hello_packet(self, dest_port):
epoch_time = int(time.time())
return Hello(
str(self.udp_ip) + ":" + str(self.port), self.udp_ip, self.port,
"udp", self.bidirectional_neighbors, epoch_time,
self.last_receive_time[dest_port])
