精华内容
下载资源
问答
  • android json解析及简单例子

    万次阅读 多人点赞 2011-11-23 11:10:14
    JSON的定义: 一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行数据交换...

    JSON的定义:

           一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式,同时也具备类似于C语言体系的行为。 – Json.org

    JSON Vs XML

    1.JSON和XML的数据可读性基本相同

    2.JSON和XML同样拥有丰富的解析手段

    3.JSON相对于XML来讲,数据的体积小

    4.JSON与JavaScript的交互更加方便

    5.JSON对数据的描述性比XML较差

    6.JSON的速度要远远快于XML

    android2.3提供的json解析类 

    android的json解析部分都在包org.json下,主要有以下几个类: 

    JSONObject:可以看作是一个json对象,这是系统中有关JSON定义的基本单元,其包含一对儿(Key/Value)数值。它对外部(External:   应用toString()方法输出的数值)调用的响应体现为一个标准的字符串(例如:{"JSON": "Hello, World"},最外被大括号包裹,其中的KeyValue被冒号":"分隔)。其对于内部(Internal)行为的操作格式略微,例如:初始化一个JSONObject实例,引用内部的put()方法添加数值:new JSONObject().put("JSON", "Hello, World!"),在KeyValue之间是以逗号","分隔。Value的类型包括:BooleanJSONArrayJSONObjectNumberString或者默认值JSONObject.NULL object 。

    JSONStringer:json文本构建类 ,根据官方的解释,这个类可以帮助快速和便捷的创建JSON text。其最大的优点在于可以减少由于 格式的错误导致程序异常,引用这个类可以自动严格按照JSON语法规则(syntax rules)创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。。其最大的优点在于可以减少由于格式的错误导致程序异常,引用这个类可以自动严格按照JSON语法规则(syntax rules)创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。

    JSONArray它代表一组有序的数值。将其转换为String输出(toString)所表现的形式是用方括号包裹,数值以逗号”,”分隔(例如:     [value1,value2,value3],大家可以亲自利用简短的代码更加直观的了解其格式)。这个类的内部同样具有查询行为,     get()和opt()两种方法都可以通过index索引返回指定的数值,put()方法用来添加或者替换数值。同样这个类的value类型可以包括:Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL object。

    JSONTokener:json解析类 
    JSONException:json中用到的异常 

    JSONObject, JSONArray来构建json文本 
    代码  收藏代码
    1. // 假设现在要创建这样一个json文本  
    2. //  {  
    3. //      "phone" : ["12345678", "87654321"], // 数组  
    4. //      "name" : "yuanzhifei89", // 字符串  
    5. //      "age" : 100, // 数值  
    6. //      "address" : { "country" : "china", "province" : "jiangsu" }, // 对象  
    7. //      "married" : false // 布尔值  
    8. //  }  
    9.   
    10. try {  
    11.     // 首先最外层是{},是创建一个对象  
    12.     JSONObject person = new JSONObject();  
    13.     // 第一个键phone的值是数组,所以需要创建数组对象  
    14.     JSONArray phone = new JSONArray();  
    15.     phone.put("12345678").put("87654321");  
    16.     person.put("phone", phone);  
    17.   
    18.     person.put("name""yuanzhifei89");  
    19.     person.put("age"100);  
    20.     // 键address的值是对象,所以又要创建一个对象  
    21.     JSONObject address = new JSONObject();  
    22.     address.put("country""china");  
    23.     address.put("province""jiangsu");  
    24.     person.put("address", address);    
    25.     person.put("married"false);  
    26. catch (JSONException ex) {  
    27.     // 键为null或使用json不支持的数字格式(NaN, infinities)  
    28.     throw new RuntimeException(ex);  
    29. }  

    getType和optType api的使用 
    getType可以将要获取的键的值转换为指定的类型,如果无法转换或没有值则抛出JSONException 
    optType也是将要获取的键的值转换为指定的类型,无法转换或没有值时返回用户提供或这默认提供的值 
    代码  收藏代码
    1. try {  
    2.     // 所有使用的对象都是用上面创建的对象  
    3.     // 将第一个电话号码转换为数值和将名字转换为数值  
    4.     phone.getLong(0);  
    5.     person.getLong("name"); // 会抛异常,因为名字无法转换为long        
    6.     phone.optLong(0); // 代码内置的默认值  
    7.     phone.optLong(01000); // 用户提供的默认值  
    8.     person.optLong("name");  
    9.     person.optLong("name"1000); // 不像上面那样抛异常,而是返回1000  
    10. catch (JSONException ex) {  
    11.     // 异常处理代码  
    12. }  

    除了上面的两个类,还可以使用JSONStringer来构建json文本 
    Java代码  收藏代码
    1. try {  
    2.     JSONStringer jsonText = new JSONStringer();  
    3.     // 首先是{,对象开始。object和endObject必须配对使用  
    4.     jsonText.object();  
    5.       
    6.     jsonText.key("phone");  
    7.     // 键phone的值是数组。array和endArray必须配对使用  
    8.     jsonText.array();  
    9.     jsonText.value("12345678").value("87654321");  
    10.     jsonText.endArray();  
    11.       
    12.     jsonText.key("name");  
    13.     jsonText.value("yuanzhifei89");  
    14.     jsonText.key("age");  
    15.     jsonText.value(100);  
    16.       
    17.     jsonText.key("address");  
    18.     // 键address的值是对象  
    19.     jsonText.object();  
    20.     jsonText.key("country");  
    21.     jsonText.value("china");  
    22.     jsonText.key("province");  
    23.     jsonText.value("jiangsu");  
    24.     jsonText.endObject();  
    25.       
    26.     jsonText.key("married");  
    27.     jsonText.value(false);  
    28.       
    29.     // },对象结束  
    30.     jsonText.endObject();  
    31. catch (JSONException ex) {  
    32.     throw new RuntimeException(ex);  
    33. }  

    json文本解析类JSONTokener 
    按照RFC4627规范将json文本解析为相应的对象。 

    对于将json文本解析为对象,只需要用到该类的两个api: 
    构造函数 
    public Object nextValue(); 
    代码  收藏代码
    1. //  {  
    2. //      "phone" : ["12345678", "87654321"], // 数组  
    3. //      "name" : "yuanzhifei89", // 字符串  
    4. //      "age" : 100, // 数值  
    5. //      "address" : { "country" : "china", "province" : "jiangsu" }, // 对象  
    6. //      "married" : false // 布尔值  
    7. //  }  
    8.   
    9. private static final String JSON =   
    10. "{" +  
    11.     "   \"phone\" : [\"12345678\", \"87654321\"]," +  
    12.     "   \"name\" : \"yuanzhifei89\"," +  
    13.     "   \"age\" : 100," +  
    14.     "   \"address\" : { \"country\" : \"china\", \"province\" : \"jiangsu\" }," +  
    15.     "   \"married\" : false," +  
    16. "}";  
    17.   
    18. try {  
    19.     JSONTokener jsonParser = new JSONTokener(JSON);  
    20.     // 此时还未读取任何json文本,直接读取就是一个JSONObject对象。  
    21.     // 如果此时的读取位置在"name" : 了,那么nextValue就是"yuanzhifei89"(String)  
    22.     JSONObject person = (JSONObject) jsonParser.nextValue();  
    23.     // 接下来的就是JSON对象的操作了  
    24.     person.getJSONArray("phone");  
    25.     person.getString("name");  
    26.     person.getInt("age");  
    27.     person.getJSONObject("address");  
    28.     person.getBoolean("married");  
    29. catch (JSONException ex) {  
    30.     // 异常处理代码  
    31. }  

    其它的api基本就是用来查看json文本中的文本的 

    代码  收藏代码
    1. try {  
    2.     JSONTokener jsonParser = new JSONTokener(JSON);  
    3.     // 继续向下读8个json文本中的字符。此时刚开始,即在{处  
    4.     jsonParser.next(8); //{    "phone。tab算一个字符  
    5.       
    6.     // 继续向下读1个json文本中的字符  
    7.     jsonParser.next(); //"  
    8.       
    9.     // 继续向下读取一个json文本中的字符。该字符不是空白、同时也不是注视中的字符  
    10.     jsonParser.nextClean(); //:  
    11.       
    12.     // 返回当前的读取位置到第一次遇到'a'之间的字符串(不包括a)。  
    13.     jsonParser.nextString('a'); //  ["12345678", "87654321"],    "n(前面有两个空格)  
    14.       
    15.     // 返回当前读取位置到第一次遇到字符串中(如"0089")任意字符之间的字符串,同时该字符是trimmed的。(此处就是第一次遇到了89)  
    16.     jsonParser.nextTo("0089"); //me" : "yuanzhifei  
    17.       
    18.     // 读取位置撤销一个  
    19.     jsonParser.back();  
    20.     jsonParser.next(); //i  
    21.       
    22.     // 读取位置前进到指定字符串处(包括字符串)  
    23.     jsonParser.skipPast("address");  
    24.     jsonParser.next(8); //" : { "c  
    25.       
    26.     // 读取位置前进到执行字符处(不包括字符)  
    27.     jsonParser.skipTo('m');  
    28.     jsonParser.next(8); //married"  
    29. catch (JSONException ex) {  
    30.     // 异常处理代码  
    31. }  

          以下是一个标准的JSON请求实现过程:

    HttpPost request = new HttpPost(url);  
    // 先封装一个 JSON 对象  
    JSONObject param = new JSONObject();  
    param.put("name", "rarnu");  
    param.put("password", "123456");  
    // 绑定到请求 Entry  
    StringEntity se = new StringEntity(param.toString());   
    request.setEntity(se);  
    // 发送请求  
    HttpResponse httpResponse = new DefaultHttpClient().execute(request);  
    // 得到应答的字符串,这也是一个 JSON 格式保存的数据  
    String retSrc = EntityUtils.toString(httpResponse.getEntity());  
    // 生成 JSON 对象  
    JSONObject result = new JSONObject( retSrc);  
    String token = result.get("token"); 

            下面这个是自己修改别人的小例子,主要是加一些注释和讲解,这个例子主要是使用android进行json解析。
    单数据{'singer':{'id':01,'name':'tom','gender':'男'}} 
    多个数据{"singers":[ 
            {'id':02,'name':'tom','gender':'男'}, 
             {'id':03,'name':'jerry,'gender':'男'}, 
    {'id':04,'name':'jim,'gender':'男'}, 
    {'id':05,'name':'lily,'gender':'女'}]}                                                                            
            下面的类主要是解析单个数据parseJson()和多个数据的方法parseJsonMulti():
    public class JsonActivity extends Activity { 
    	/** Called when the activity is first created. */ 
    	private TextView tvJson; 
    	private Button btnJson; 
    	private Button btnJsonMulti; 
    	@Override 
    	public void onCreate(Bundle savedInstanceState) { 
    		super.onCreate(savedInstanceState); 
    		setContentView(R.layout.main); 
    		tvJson = (TextView) this.findViewById(R.id.tvJson); 
    		btnJson = (Button) this.findViewById(R.id.btnJson); 
    		btnJsonMulti = (Button) this.findViewById(R.id.btnJsonMulti); 
    		btnJson.setOnClickListener(new View.OnClickListener() { 
    			@Override 
    			public void onClick(View v) { 
    				// url 
    				// String strUrl = "http://10.158.166.110:8080/AndroidServer/JsonServlet"; 
    				String strUrl = ServerPageUtil.getStrUrl(UrlsOfServer.JSON_SINGER); 
    				//获得返回的Json字符串 
    				String strResult = connServerForResult(strUrl); 
    				//解析Json字符串 
    				parseJson(strResult); 
    			} 
    		}); 
    		btnJsonMulti.setOnClickListener(new View.OnClickListener() { 
    			@Override 
    			public void onClick(View v) { 
    				String strUrl = ServerPageUtil.getStrUrl(UrlsOfServer.JSON_SINGERS); 
    				String strResult = connServerForResult(strUrl); 
    				//获得多个Singer 
    				parseJsonMulti(strResult); 
    			} 
    		}); 
    	} 
    	private String connServerForResult(String strUrl) { 
    		// HttpGet对象 
    		HttpGet httpRequest = new HttpGet(strUrl); 
    		String strResult = ""; 
    		try { 
    			// HttpClient对象 
    			HttpClient httpClient = new DefaultHttpClient(); 
    			// 获得HttpResponse对象 
    			HttpResponse httpResponse = httpClient.execute(httpRequest); 
    			if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) { 
    				// 取得返回的数据 
    				strResult = EntityUtils.toString(httpResponse.getEntity()); 
    			} 
    		} catch (ClientProtocolException e) { 
    			tvJson.setText("protocol error"); 
    			e.printStackTrace(); 
    		} catch (IOException e) { 
    			tvJson.setText("IO error"); 
    			e.printStackTrace(); 
    		} 
    		return strResult; 
    	} 
    	// 普通Json数据解析 
    	private void parseJson(String strResult) { 
    		try { 
    			JSONObject jsonObj = new JSONObject(strResult).getJSONObject("singer"); 
    			int id = jsonObj.getInt("id"); 
    			String name = jsonObj.getString("name"); 
    			String gender = jsonObj.getString("gender"); 
    			tvJson.setText("ID号"+id + ", 姓名:" + name + ",性别:" + gender); 
    		} catch (JSONException e) { 
    			System.out.println("Json parse error"); 
    			e.printStackTrace(); 
    		} 
    	} 
        //解析多个数据的Json
    	private void parseJsonMulti(String strResult) { 
    		try { 
    			JSONArray jsonObjs = new JSONObject(strResult).getJSONArray("singers"); 
    			String s = ""; 
    			for(int i = 0; i < jsonObjs.length() ; i++){ 
    				JSONObject jsonObj = jsonObjs.getJSONObject(i); 
    				int id = jsonObj.getInt("id"); 
    				String name = jsonObj.getString("name"); 
    				String gender = jsonObj.getString("gender"); 
    				s +=  "ID号"+id + ", 姓名:" + name + ",性别:" + gender+ "\n" ; 
    			} 
    			tvJson.setText(s); 
    		} catch (JSONException e) { 
    			System.out.println("Jsons parse error !"); 
    			e.printStackTrace(); 
    		} 
    	} 
    } 
    展开全文
  • 依据XML定义报文格式解析数据

    千次阅读 2017-07-20 09:25:30
    1、将报文格式定义在xml中 2、通过格式xml来解析数据 当前体会到此设计的优势: (1)报文格式可在xml中配置。报文格式调整不涉及程序调整。 (2)程序可读性强。实现: 一、自定义xml文件 二、读取XML...

    需求:
    报文(数据集)中含有多个字段,要解析为多个含有意义的字段。
    设计:
    1、将报文格式定义在xml中
    2、通过格式xml来解析数据
    当前体会到此设计的优势:
    1、报文格式可在xml中配置。报文格式调整不涉及程序调整。
    2、程序可读性强。

    实现:
    一、自定义xml文件
    1、节点标签
    2、子节点标签
    3、数据标签
    4、描述标签
    5、起始下标
    6、长度标签
    example.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <infos>
    <!-- 数据截取模板定义 -->
    <info>     
       <dataName>data1</dataName>  
       <desc>数据1</desc>   
       <startIndex>6</startIndex>
       <length>10</length>  
    </info>
    <infos>

    二、读取XML文件解析
    1、读取xml,获取Document。

     public static Document getDocument(Class<?> cls, String fileName) throws Exception{
        InputStream in = null;        
         try{
            //把要解析的XML文档转化为输入流,方便DOM解析器解析
            in = cls.getClassLoader().getResourceAsStream(fileName);
            //得到DOM解析器的工厂实例
            //从DOM工厂获得DOM解析器   
            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();   
            return builder.parse(in);
        }finally{
            if(in != null){
                in.close();
            }
        }
        return null;
    }
    补充:
    (1)导入包org.w3c.dom.Document
       a. dom,为文档对象模型 (DOM) 提供接口,该模型是 Java API for XML Processing 的组件 API。
       具体详见:http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/org/w3c/dom/package-summary.html。
       b. Document 接口表示整个HTML、XML。
       具体详见:http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/org/w3c/dom/Document.html。
       另:
       a. javax.swing.text 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。类相关说明详见:http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/javax/swing/text/package-use.html#javax.swing.text
       b. javax.swing.text.Document 作为swing文本组建模型的文本容器。
     (2)得到XML文档的根节点 
         Element rootNode = document.getDocumentElement();
     (3)从根节点获取子节点
         NodeList nodes = rootNode.getChildNodes();
     (4)DOM Document Object Model,也即文档对象模型。
         对xml文件进阶操作,用Java W3C DOM 进行XML操作的例子,可详见:
         http://blog.csdn.net/cds27/article/details/2139110。
     (5)从xml设置到Map
         注意:应在类中静态块中,进行初始化。
    
    static{          
                   setSubTemplateToMap();
               }
    
         private static final String SUBTEMPLATEFILENAME = "example.xml";
         private static Map subTemplateMap = new HashMap<String, List<Map<String,String>>>();
         public static void setSubTemplateToMap(){
            try {
                Document document = XmlDocumentUtils.getDocument(SUBTEMPLATEFILENAME );
                NodeList nodeList = document.getElementsByTagName("info");
                List<Map<String,String>> list = new ArrayList<Map<String,String>>();
                for ( int i = 0; i < nodeList.getLength(); i++){
                     Map<String,String> result = new HashMap<String, String>();
                     String dataName = document.getElementsByTagName("dataName").item(i).getFirstChild().getNodeValue();
                     String startIndex = document.getElementsByTagName("startIndex").item(i).getFirstChild().getNodeValue();
                     String length = document.getElementsByTagName("length").item(i).getFirstChild().getNodeValue();
                     if(StringUtils.empty(dataName)){
                         throw new Exception("第["+i+"]个"+"dataName"+"标签的内容不能为空");
                     }
                     if ( StringUtils.empty(startIndex)){
                         throw new Exception("第["+i+"]个"+"startIndex"+"标签的内容不能为空");
                     }
                     if ( StringUtils.empty(length)){
                         throw new Exception("第["+i+"]个"+"length"+"标签的内容不能为空");
                     }
                     result.put("dataName", dataName);
                     result.put("startIndex", startIndex);
                     result.put("length", length);
                     list.add(result);
                }
                subTemplateMap.put(SUBTEMPLATEFILENAME.substring(0,SUBTEMPLATEFILENAME.lastIndexOf(".")), list);
            } catch ( Throwable e ) {
                e.printStackTrace();
            }
        } 
    
        /*解析数据*/
         public static boolean getStrByTemplateMap(String data,String templateName,Map<String,String> result){
            boolean bool = false;
            List<Map<String,String>> list = subTemplateMap.get(templateName);//获取数据匹配模板
            if(list != null && list.size()>0){
                for(Map<String,String> map : list){
                    try{
                            String dataName = map.get("dataName");
                            int startIndex = Integer.parseInt(map.get("startIndex"));
                            int length = Integer.parseInt(map.get("length"));
                            String subData = data.substring(startIndex,startIndex+length).trim();
                            result.put(dataName, subData);
                    }catch(Throwable e){
                        //logger.error("通过模板解析数据异常",e);
                        if(!bool){
                            bool = true;
                        }
                    }
                }
            }
            return bool;
        }
    补充:
    a. NodeList getElementsByTagName(String tagName) Document成员方法
       按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList。
    b. int getLength() NodeList类成员方法 获取NodeList的长度,即Node数目。
    c. Node item(int index) NodeList类成员方法 返回集合中第index个项。
       NodeList详见:http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/org/w3c/dom/NodeList.html。
    d. Node getFirstChild() 此节点的第一个子节点。
    e. String getNodeValue()此节点的值。
    
    注意:
    a. xml文件要能读取到,可放置在同一目录下。
    b. 若无日志操作的,可注释掉logger部分。
    c. 引用的工具类StringUtils,可将其替换为 字符串判NULL或判空字符串。
    
    展开全文
  • 各种python 函数参数定义解析

    万次阅读 2014-04-18 17:25:22
    函数参数在调用过程中是如何解析的。首先说一下在python 中的函数调用过程是分四种方式的,这里且先说五种,第五种已经在以前的文章中说过了。 1.参数枚举的函数定义: >>> def Fun(a,b,c): return (a,b,c) >>> ...
    python 中的函数参数是赋值式的传递的,函数的使用中要注意两个方面:1.函数参数的定义过程,2.函数参数在调用过程中是如何解析的。首先说一下在python 中的函数调用过程是分四种方式的,这里且先说五种,第五种已经在以前的文章中说过了

    1.参数枚举的函数定义:

    >>> def Fun(a,b,c):
    	return (a,b,c)
    
    >>> Fun(1,2,3)
    (1, 2, 3)
    >>> Fun(1,2) # 枚举参数个数不对应
    
    Traceback (most recent call last):
      File "<pyshell#61>", line 1, in <module>
        Fun(1,2)
    TypeError: Fun() takes exactly 3 arguments (2 given)
    >>> 

    >>> def Fun(a,b,c):
    	print (a,b,c)
    
    	
    >>> Fun(a=22,b=33,c=44)
    (22, 33, 44)
    >>> Fun(22,33,44)<span style="white-space:pre">	</span># 不指定赋值对象,就是按照顺序匹配
    (22, 33, 44)
    >>> Fun(22,33,c=44)  <span style="white-space:pre">	</span># 可以指定参数的赋值对象,也可以不指定,
    (22, 33, 44)
    >>> Fun(b=22,a=33,c=44) # 参数顺序可以不对应
    (33, 22, 44)
    >>> 

    这是最常见的定义方式,一个函数可以枚举定义任意多的参数,每个参数之间使用逗号隔开,用这种方式定义的函数在调用的时候实参的个数和形参的个数必须相等,并且顺序是一一对应的,如果出现参数数量不对或者参数类型不对应就会报错。


    2.带默认参数的函数定义(在以前专门写过这里面需要注意的):

    >>> def Fun(a,b,c=33):
    	print (a,b,c)
    
    	
    >>> Fun(11,22) # 可以不写默认参数
    (11, 22, 33)
    >>> Fun(1)     # 就是至少实参的个数和非默认参数的个数相同
    
    Traceback (most recent call last):
      File "<pyshell#66>", line 1, in <module>
        Fun(1)
    TypeError: Fun() takes at least 2 arguments (1 given)
    >>> Fun(1,2,3) <span style="white-space:pre">	</span># 可以覆盖默认参数
    (1, 2, 3)
    这种方式就可以在调用的时候不填写默认参数了,但是要注意含有默认值的函数在定义的时候就已经把他的默认参数初始化了,这个在以前的文章也谈过

    3.不确定参数个数的函数定义:

    >>> def Fun(*a): 
    	if 0 == len(a):
    		print 'None'
    	else:
    		print a
    
    		
    >>> Fun(1,2,3)
    (1, 2, 3)              # tuple 类型
    >>> Fun(a=1,b=2,c=33)  # 不能在按照字典的方式赋值
    
    Traceback (most recent call last):
      File "<pyshell#93>", line 1, in <module>
        Fun(a=1,b=2,c=33)
    TypeError: Fun() got an unexpected keyword argument 'a'
    >>> Fun() # 可以是0参数
    None
    这种带*号的说明参数的个数是不确定的,在调用的时候想传多少个 参数都行[0,n],呵呵,爽吧,但是他传入的参数都会放在一个
    tuple中,如果有返回值的接受的时候也是用tuple行了,对于函数内部不确定的数量赋值时直接就循环迭代赋值就Ok了。

    4.不确定个数的字典参数定义:
    在定义的形参处加两个*,就是在函数内部处理函数的时候都是用字典的形式保存,当然调用的时候要用key=value的形式

    >>> def Fun(**a):
    	if 0 == len(a):
    		print 'None'
    	else:
    		print a
    
    		
    >>> Fun(1,2,3,4) # 字典赋值,这样就不行了
    
    Traceback (most recent call last):
      File "<pyshell#83>", line 1, in <module>
        Fun(1,2,3,4)
    TypeError: Fun() takes exactly 0 arguments (4 given)
    >>> Fun(a=1,b=2,c=3) <span style="white-space:pre">		</span># 必须key=value的赋值
    {'a': 1, 'c': 3, 'b': 2}  <span style="white-space:pre">	</span># dict 类型
    >>> Fun(aa=3,b=333,d=44)
    {'aa': 3, 'b': 333, 'd': 44}


    最后一个关于函数参数赋值优先级的例子:

    >>> def Fun(a,b,c=22,*d,**e):
    	print a,b,c,d,e
    
    	
    >>> Fun(1)
    
    Traceback (most recent call last):
      File "<pyshell#98>", line 1, in <module>
        Fun(1)
    TypeError: Fun() takes at least 2 arguments (1 given)
    >>> Fun(1,2)
    1 2 22 () {}
    >>> Fun(1,2,3)
    1 2 3 () {}
    >>> Fun(1,2,3,4,5)  # 默认顺序匹配把多余的参数匹配给tuple
    1 2 3 (4, 5) {}
    >>> Fun(1,2,3,4,5,aa=33,bb=33)   # 把字典赋值匹配给dict
    1 2 3 (4, 5) {'aa': 33, 'bb': 33}
    >>> Fun(a=3,c=4,b=2b)
    SyntaxError: invalid syntax
    >>> Fun(a=3,c=4,b=22)        <span style="white-space:pre">	</span> # 在字典赋值和枚举匹配赋值的时候优先考虑匹配赋值
    3 22 4 () {}
    >>> Fun(b=22,a=22,e=(1,2,3))
    22 22 22 () {'e': (1, 2, 3)}
    >>> Fun(b=22,c=77,2,3,4,5,6,)    # 没有给a 赋值,多一个逗号
    SyntaxError: non-keyword arg after keyword arg
    >>> Fun(b=22,c=77,2,3,4,5,6,k=44)  
    SyntaxError: non-keyword arg after keyword arg
    >>> Fun(b=22,c=77,a=44,2,3,4,5,6,)
    >>> Fun(1,2,3,(22,3334,34))   # 直接使用tuple的实参传递<br style="font-family: 'Microsoft YaHei';font-size:14px;" /><span style="font-family: 'Microsoft YaHei';font-size:14px;">1 2 3 ((22, 3334, 34),) {}</span><br style="font-family: 'Microsoft YaHei';font-size:14px;" />
    

    可以看出这里函数参数的赋值方式是有所差别的,按照 1 ,2,3,4的优先级依次降低,也就是先为枚举形参赋值,再为默认参数赋值,然后多出来的就都组装在在tuple中传过去,给带*的参数,最后把key=value的形式组装成字典的形式传进去,给**的参数

    5.修饰器的函数调用方式(不是函数的定义方式,只是一种函数调用约定):

    @Fun
    具体的这种函数调用方式看以前的那篇文章吧:


    人个论坛:http://itpark.sinaapp.com/

    展开全文
  • 目录 ...本文仅通过最简单的例子,展示如何定义使用以及解析注解。 实例 定义 Tag.java 定义一个标签注解。可以在类、方法、字段上使用。 @Retention(RetentionPolicy.RUNTIME) @T...

    目录

    注解的定义

    通过注解,有时候可以使我们的代码编写变得十分强大。

    本文仅通过最简单的例子,展示如何定义使用以及解析注解。

    实例

    定义

    • Tag.java

    定义一个标签注解。可以在类、方法、字段上使用。

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD, ElementType.LOCAL_VARIABLE})
    public @interface Tag {
    
        /**
         * tag 标签
         *
         * @return tag
         */
        String value();
    
    }

    使用

    public class DefineMethod {
    
        @Tag("calc")
        public void calcMethod() {
        }
    
        @Tag("print")
        public void printMethod() {
        }
    
    }

    解析

    public class DefineMethod {
    
        //...
    
        /**
         * 解析我们定义的标签
         * 1. 可以根据属性的不同,进行我们希望的事情处理
         */
        public static void showTags() {
            Method[] methods = DefineMethod.class.getDeclaredMethods();
            for(Method method : methods) {
                Tag tag = method.getAnnotation(Tag.class);
                if(tag != null) {
                    System.out.println(tag.value());
                }
            }
        }
    
        public static void main(String[] args) {
            DefineMethod.showTags();
        }
    
    }
    • 运行结果
    print
    calc

    备注

    我们可以根据注解,做更多其他的事情。

    在实际开发中,可以和 spring 结合,发挥出更大的威力。

    下一篇,将进一步学习 spring 与注解的结合。

    代码地址

    annotation 定义与解析

    系列导航

    系列导航

    展开全文
  • Poco的网络模块在Poco::Net名字空间下定义 下面是字典例子解析 #include "Poco/Net/StreamSocket.h" //流式套接字 #include "Poco/Net/SocketStream.h" //套接字流 #include "Poco/Net/SocketAddress.h" //...
  • 在《Gin源码解析例子——路由》一文中,我们已经初识中间件。本文将继续探讨这个技术。(转载请指明出于breaksoftware的csdn博客)  Gin的中间件,本质是一个匿名回调函数。这和绑定到一个路径的处理函数本质...
  • C++隐藏的概念(例子解析

    千次阅读 热门讨论 2018-06-01 18:33:09
    在继承机制,派生类的类域被嵌套在基类的类域中。派生类的名字解析过程如下: 1、首先在派生类类域中查找该名字。 2、如果第一步中没有成功查找到该名字,即在派生类的类域中无法对该名字进行解析,则编译器在...
  • 详细解析如何运行hadoop自带例子

    千次阅读 2018-05-07 19:10:38
    本文,简单介绍,如何运行hadoop自带的mapreduce的那些例子。本文针对的hadoop版本,是2.6.5版本,自带的例子包名为:hadoop-mapreduce-examples-2.6.5.jar;位于/share/hadoop/mapreduce目录。简单来说,如果想...
  • //下面程序取自 Poco 库的Net模块例子----HTTPServer 下面开始解析代码 #include "Poco/Net/HTTPServer.h" //继承自TCPServer 实现了一个完整的HTTP多线程服务器 #include "Poco/...
  • SqlServer触发器的格式+小例子解析

    千次阅读 2018-04-21 16:31:41
    触发器基本语法格式:create trigger tri_name on table for insert/update/deleted asSQL code触发器基本语法解析:create trigger tri_name //(tri_name:自定义触发器的名称)on table ...
  • 01 — 二项分布如果实验满足以下两种条件: 在每次试验中只有两种可能的结果,而且两种结果发生与否互相对立;...例子解析例如,一堆苹果有好的,有坏的,从中取10次,定义随机变量:从中取得好苹果的个数
  • 8583详细解析,还有例子

    千次阅读 2012-07-02 23:40:02
    描述:定义在收单单位中定义一个服务端的标识码,在同一个服务终端标识码应唯一。 终端为“00001111” 【收卡商户定义码:位图位置42】 31 30 32 32 35 30 31 35 33 31 3131 31 31 31 第42域,定长,...
  • 使用Expat XML解析器的例子

    千次阅读 2012-08-06 17:57:22
    2011-05-30 19:32:32| 分类: 默认分类 |字号 订阅 工作原理:  1 . Initialize the XML parser with the xml_...通过xml_parser_create()函数安装XML解析器;  2. Create functions to use with the different e
  • 抽象代数——群的基本定义和一些例子

    万次阅读 多人点赞 2015-08-28 14:26:33
    群论的基本概念点较多,且各概念点之间关系纵横交错,学习起来颇有本科时初学线性代数时的感觉,觉得有必要整理一下,先梳理一下群的基本定义例子。 首先作几点说明: 1、群(group)、环(ring)、域(field)是抽象...
  • Android 解析后台返回为Json数据的简单例子!!!

    万次阅读 多人点赞 2012-04-16 17:42:15
    大家好,今天给大家分享Android解析Json的例子,我这里自己安装了Tomcat,让自己电脑充当服务器,最重要的是,返回结果自己可以随便修改。首先看Json的定义,以及它和XML的比较:JSON的定义:一种轻量级的数据...
  • Java自定义注解及解析

    千次阅读 2018-03-28 16:36:52
    定义注解 注解处理器运行时解析注解 编译时解析注解自动生成.class代码 总结 注解 注解为我们在代码中添加信息提供一种形式化的方法,使我们可以在源码、编译时、运行时非常方便的使用...
  • 模板模式(template model)解析例子

    千次阅读 2011-12-04 23:07:25
    模板方法模式(Template Method):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。该模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 使用场景: 1、一次性实现一个算法的不变...
  • 用SAX解析xml文件的例子

    万次阅读 2006-12-01 15:18:00
    1. Xml技术简介Xml文件有两种约束类型,包括文档类型定义(DTD)和Xml 模式(Schema)。... xml模式在无序的情况使用起来比xml DTD更方便;C. xml模式支持名字空间,可以在不同的文件中定义相同
  • 二维码生成原理及解析代码

    万次阅读 多人点赞 2017-12-18 22:35:06
    二维码生成原理及解析代码 自从大街小巷的小商小贩都开始布满了腾讯爸爸和阿里爸爸的二维码之后,我才感觉到我大天朝共享支付的优越性。最近毕业论文写的差不多了,在入职之前多学一些东西也是好的。这里秉着好奇心...
  • Newtonsoft.Json解析数组的小例子

    万次阅读 2014-04-30 10:02:58
    http://www.cnblogs.com/usharei/category/373071.html 有四篇很好的文章,建议学习,但是现在的各种服务的json数据都是复杂类型的,本文只是补充一个复杂数据(数组)的小例子 上面提到的第四篇文章最后...
  • 本文介绍了camunda 对BPMN流程定义文件的解析实现。 该类库的JS框架采用的dojo (了解dojo与jquery的区别:http://blog.csdn.net/dojotoolkit/article/details/7682978) 这个类库有四个文件 Bpmn.js提供...
  • 要了解第二人生里使用expat XML解析器之前,先来仔细地分析一下怎么样使用expat库的小例子,看看具体调用了那些接口函数,是否会很复杂的呢?‘它的例子程序如下:#001 /*****************************************...
  • json解析及解析原理

    万次阅读 2012-11-13 17:43:25
    JSON的定义:  一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行数据...
  • Android Json生成及解析实例

    万次阅读 2013-12-21 16:10:13
    JSON的定义:  一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持),从而可以在不同平台间进行...
  • C/C++宏定义的可变参数详细解析

    千次阅读 2017-05-01 18:19:54
    在1999年版本的ISO C 标准中,宏可以象函数一样,定义时可以带有可变参数。宏的语法和函数的语法类似。编写代码的过程中,经常会输出一些调试信息到屏幕上,一般会调用printf这类的函数。但是当调试解决之后,我们...
  • Java解析Excel实例解析

    万次阅读 2017-03-09 10:32:55
    Java解析Excel实例解析
  •  当我们对SpringMVC控制的资源发起请求时,这些请求都会被SpringMVC的DispatcherServlet处理,接着Spring会分析看哪一个HandlerMapping定义的所有请求映射中存在对该请求的最合理的映射。然后通过该HandlerMapping...
  • C/C++宏定义的可变参数详细解析(转)

    千次阅读 2017-11-03 18:56:42
    这和上面举的那个ISO C定义的宏例子是完全一样的,但是这么写可读性更强并且更容易进行描述。 GNU CPP还有两种更复杂的宏扩展,支持上面两种格式的定义格式。 在标准C里,你不能省略可变参数,但是你却可以给它传递...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,150
精华内容 151,260
关键字:

下定义的例子及解析