精华内容
下载资源
问答
  • Python 变量类型

    千次阅读 2016-09-09 22:43:18
    这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。变量赋值...

    概述

    变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

    基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。

    因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。

    变量赋值

    Python 中的变量赋值不需要类型声明。

    每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。

    每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

    等号(=)用来给变量赋值。
    等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

    例如:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    size= 100 # 赋值整型变量
    salary= 1000.0 # 浮点型
    name = "xiaogongjiang" # 字符串
    
    print size
    print salary
    print name

    以上实例中,100,1000.0和”John”分别赋值给size,salary,name 变量。
    执行以上程序会输出如下结果:

    100
    1000.0
    John

    多个变量赋值

    Python允许你同时为多个变量赋值。例如:

    a = b = c = 1

    以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。

    也可以为多个对象指定多个变量。例如:

    a, b, c = 1, 2, "xiaogongjiang"

    以上实例,两个整型对象1和2的分配给变量a和b,字符串对象”xiaogongjiang”分配给变量c。


    标准数据类型

    在内存中存储的数据可以有多种类型。

    Python有五个标准的数据类型:

    • Numbers(数字)
    • String(字符串)
    • List(列表)
    • Tuple(元组)
    • Dictionary(字典)

    Python数字 Number

    数字数据类型用于存储数值。

    他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。

    当你指定一个值时,Number对象就会被创建:

    var1 = 1
    var2 = 10

    也可以使用del语句删除一些对象的引用。
    del语句的语法是:

    del var1[,var2[,var3[....,varN]]]]

    您可以通过使用del语句删除单个或多个对象的引用。例如:

    del var
    del var_a, var_b

    Python支持四种不同的数字类型:

    • int(有符号整型)
    • long(长整型[也可以代表八进制和十六进制])
    • float(浮点型)
    • complex(复数)

    看下栗子:

    这里写图片描述

    • 长整型也可以使用小写”L”,但是还是建议您使用大写”L”,避免与数字”1”混淆。Python使用”L”来显示长整型。
    • Python还支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示,
      复数的实部a和虚部b都是浮点型

    Python字符串 String

    字符串或串(String)是由数字、字母、下划线组成的一串字符。
    一般记为 :

    s="a1a2···an"(n>=0)

    它是编程语言中表示文本的数据类型。

    python的字串列表有2种取值顺序:

    • 从左到右索引默认0开始的,最大范围是字符串长度少1
    • 从右到左索引默认-1开始的,最大范围是字符串开头

    如果你的实要取得一段子串的话,可以用到变量[头下标:尾下标],就可以截取相应的字符串,其中下标是从0开始算起,可以是正数或负数,下标可以为空表示取到头或尾。

    比如:

    s = 'ilovepython'

    s[1:5]的结果是love。

    当使用以冒号分隔的字符串,python返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界。

    上面的结果包含了s[1]的值l,而取到的最大范围不包括上边界,就是s[5]的值p。

    加号(+)是字符串连接运算符,星号(*)是重复操作。

    如下实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    str = 'Hello World!'
    
    print str # 输出完整字符串
    print str[0] # 输出字符串中的第一个字符
    print str[2:5] # 输出字符串中第三个至第五个之间的字符串
    print str[2:] # 输出从第三个字符开始的字符串
    print str * 2 # 输出字符串两次
    print str + "TEST" # 输出连接的字符串

    以上实例输出结果:

    Hello World!
    H
    llo
    llo World!
    Hello World!Hello World!
    Hello World!TEST

    Python列表 List

    List(列表) 是 Python 中使用最频繁的数据类型。

    列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(所谓嵌套)。

    列表用[ ]标识。是python最通用的复合数据类型

    列表中的值得分割也可以用到变量[头下标:尾下标],就可以截取相应的列表,从左到右索引默认0开始的,从右到左索引默认-1开始,下标可以为空表示取到头或尾。

    加号(+)是列表连接运算符,星号(*)是重复操作。如下实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
    tinylist = [123, 'john']
    
    print list # 输出完整列表
    print list[0] # 输出列表的第一个元素
    print list[1:3] # 输出第二个至第三个的元素 
    print list[2:] # 输出从第三个开始至列表末尾的所有元素
    print tinylist * 2 # 输出列表两次
    print list + tinylist # 打印组合的列表

    以上实例输出结果:

    ['abcd', 786, 2.23, 'john', 70.2]
    abcd
    [786, 2.23]
    [2.23, 'john', 70.2]
    [123, 'john', 123, 'john']
    ['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

    Python元组 Tuple

    元组是另一个数据类型,类似于List(列表)。
    元组用”()”标识内部元素用逗号隔开

    但是元组不能二次赋值,相当于只读列表。

    栗子:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
    tinytuple = (123, 'john')
    
    
    print tuple # 输出完整元组
    print tuple[0] # 输出元组的第一个元素
    print tuple[1:3] # 输出第二个至第三个的元素 
    print tuple[2:] # 输出从第三个开始至列表末尾的所有元素
    print tinytuple * 2 # 输出元组两次
    print tuple + tinytuple # 打印组合的元组
    

    以上实例输出结果:

    ('abcd', 786, 2.23, 'john', 70.2)
    abcd
    (786, 2.23)
    (2.23, 'john', 70.2)
    (123, 'john', 123, 'john')
    ('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

    以下是元组无效的,因为元组是不允许更新的。而列表是允许更新的:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
    list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
    tuple[2] = 1000 # 元组中是非法应用
    list[2] = 1000 # 列表中是合法应用

    Python元字典 Dictionary

    字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。

    两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

    字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    dict = {}
    dict['one'] = "This is one"
    dict[2] = "This is two"
    
    tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
    
    
    print dict['one'] # 输出键为'one' 的值
    print dict[2] # 输出键为 2 的值
    print tinydict # 输出完整的字典
    print tinydict.keys() # 输出所有键
    print tinydict.values() # 输出所有值

    输出结果为:

    This is one This is two {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734, 'john']

    Python数据类型转换

    有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。

    以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。

    这里写图片描述

    展开全文
  • 在Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则: 1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,...

    1 JAVA语法基础

    1.1 标识符

    标识符可以简单的理解成一个名字。
    在Java中,我们需要给代码中的很多元素起名,包括类名、方法名、字段名、变量名等等。我们给对应元素起的名称就被称为标识符,一个正确的标识符需要遵循以下规则:

    1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,但不能包含 @、%、空格等其它特殊字符
    2. 不能以数字开头。如:123name 就是不合法
    3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
    4. 标识符的命名最好能反映出其作用,做到见名知意。
    5. 标识符不能是Java的关键字

    1.2 关键字

    在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
    这50个单词都是全小写,其中有两个保留字:const和goto。
    注意,关键字不能被用作标识符!
    在这里插入图片描述
    需要注意的是,除了上述的50个关键字以外,true,false,null也不可以被用作标识符~

    1.3.1 注释

    几乎所有编程语言都允许程序员在代码中输入注释
    因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
    注释的真正作用是: 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息, 提高代码的可读性,方便后期的维护与复用。
    Java的注释有3种:

    1. 单行注释: 注释单行内容.

    格式: 每行都以”//”开头.
    快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释

    2. 多行注释:注释多行内容,虽然叫多行注释,也可注释单行内容.

    格式: 以” /* ”开头, 以” * / ”结束.
    快捷方式: 可以输入” /* ”之后按回车添加注释

    3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.

    格式: 以” /** ”开头。 以” * / ”结尾
    快捷方式: 输入 “ /** ” 之后按回车添加注释

    1.3.2 练习:

    创建包: cn.tedu.basic
    创建类: CommentDemo.java

    package cn.tedu.basic;
    /**本类用于练习注释*/
    public class CommentDemo {
    	//我是一个单行注释
    	
    	/*
    	 * 我
    	 * 是
    	 * 一
    	 * 个
    	 * 多行注释
    	 */
    	
    	/**
    	 * 我是一个文档注释/DOC注释
    	 * 我也可以注释多行内容
    	 * 除此之外,我还可以添加一些作者/时间/版本...的信息
    	 */
    	public static void main(String[] args) {
    		System.out.println("我就是想测试下注释会不会执行~");
    	}
    }
    

    1.4 变量

    在JAVA中,我们需要记录一些数据
    但这些数据的值是不固定的,总在变,我们可以把这些数据理解为变量。
    我们通过三个元素来描述变量:变量类型 变量名以及变量值。
    定义变量的两种格式:
    格式一:声明变量时并且赋值:int age = 18;
    格式二:先声明变量:String tel ; 然后给变量赋值:tel = 119;

    注意:

    1. 变量名必须是一个有效的标识符
    2. 变量名不可以使用java关键字
    3. 变量名不能重复

    1.5 常量

    在程序运行过程中,值一直不会改变的量成为常量。(后续会进一步学习,略…)

    2 数据类型

    2.1 基本类型介绍(八种)

    变量要保存值,这个值是存在内存中的,所以就需要向内存申请存储空间
    java是一个强类型的语言
    为了方便内存管理系统根据变量类型更加合理的分配内存空间
    会把我们常见的数据,分成不同类型
    不同类型分配的内存大小是不同的,这个大小的单位就是字节Byte
    八大基本类型速查表
    拓展:常用的转换关系:
    位 bit,来自英文bit,音译为“比特”,表示二进制位。
    1 Byte = 8 Bits (1字节 = 8位)
    1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB

    2.2 练习: 输入个人信息

    创建包: cn.tedu.basic
    创建类: TestInfo.java
    需求: 在控制台打印: java架构师今年20岁,月薪100000.99,感慨java是世界上最好的语言

    package cn.tedu.basic;
    /**本类用于完成个人信息输出案例*/
    public class TestInfo {
    	//1.添加程序的入口函数main()
    	public static void main(String[] args) {
    		/**1.定义变量的规则:变量的类型  变量名  变量的值*/
    		/**2.String是字符串类型,用来保存多个字符*/
    		//2.定义变量
    		String name = "泡泡";//定义一个String变量用来保存姓名"江江"
    		int age = 16;//定义一个age变量用来保存年龄16
    		double salary = 100000.66;//定义一个变量salary用来保存工资
    		//3.我们可以通过打印语句查看变量的值
    		System.out.println(name);
    		System.out.println("java架构师"+name+",今年"+age+"岁,月薪"+salary+",感慨Java是世界上最好的语言!");
    	}
    }
    

    2.3 练习:查看基本类型的最大值与最小值

    创建包: cn.tedu.basic
    创建类: TestTypeScope.java

    package cn.tedu.basic;
    /**本类用于测试基本类型*/
    public class TestTypeScope {
    	//1.创建程序的入口函数
    	public static void main(String[] args) {
    		/**1.整形类型:byte short int long*/
    		/**2.Java给8大基本类型都提供了类型对应的“工具箱”*/
    		/**3.int类型的工具箱比较特殊,叫做:Integer*/
    		//2.定义对应类型的变量:格式:类型 名字 = 值 ;
    		byte byteMin = Byte.MIN_VALUE;
    		byte byteMax = Byte.MAX_VALUE;
    		System.out.println("byte类型的最小值为:" + byteMin);
    		System.out.println("byte类型的最大值为:" + byteMax);
    		
    		short shortMin = Short.MIN_VALUE;
    		short shortMax = Short.MAX_VALUE;
    		System.out.println("short类型的最小值为:" + shortMin);
    		System.out.println("short类型的最大值为:" + shortMax);
    		
    		int intMin = Integer.MIN_VALUE;
    		int intMax = Integer.MAX_VALUE;
    		System.out.println("int类型的最小值为:" + intMin);
    		System.out.println("int类型的最大值为:" + intMax);
    		
    		long longMin = Long.MIN_VALUE;
    		long longMax = Long.MAX_VALUE;
    		System.out.println("long类型的最小值为:" + longMin);
    		System.out.println("long类型的最大值为:" + longMax);
    		
    		/**4.浮点类型 :float double*/
    		float floatMin = Float.MIN_VALUE;
    		float floatMax = Float.MAX_VALUE;
    		System.out.println("float类型的最小值为:" + floatMin);
    		System.out.println("float类型的最大值为:" + floatMax);
    		
    		double doubleMin = Double.MIN_VALUE;
    		double doubleMax = Double.MAX_VALUE;
    		System.out.println("double类型的最小值为:"+ doubleMin);
    		System.out.println("double类型的最大值为:"+ doubleMax);
    		
    		/**5.boolean布尔类型只有两个值true与false
    		 * 虽然true和false不是关键字,但是也不可以用作标识符*/
    		boolean b1 = true;
    		boolean b2 = false;
    		
    		/**6.测试char 字符类型
    		 * 字符型的数据需要使用单引号 ' ' 来包裹
    		 * char类型可以存数字,但是会从ASCII码表查出这个数字对应的字符来打印
    		 * 128~65535这些数字,也可以保存,但是eclispe一般显示为?*/
    		char c1 = 'a';//字符型可以保存一个字母
    		char c2 = '中';//字符型还可以保存一个汉字
    		char c3 = '7';//字符型可以保存一个字符7
    		char c4 = 97;//字符型可以保存数字,但是会查ASCII,打印的是字符a
    		char c5 = 55;//字符型可以保存数字,但是会查ASCII,打印的是字符7
    		char c6 = 199;
    		System.out.println(c1);
    		System.out.println(c2);
    		System.out.println(c3);
    		System.out.println(c4);
    		System.out.println(c5);
    		System.out.println(c6);
    		
    	}
    
    
    
    }
    

    2.4 练习:求圆形的面积

    需求:求出指定半径圆的面积
    公式:圆的面积:π * r * r
    创建包: cn.tedu.basic
    创建类: TestCircleArea.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于求圆形的面积*/
    public class TestCircleArea {
    	//1.创建程序的入口函数main()
    	public static void main(String[] args) {
    		/**等号右边的值赋值给等号左边的变量来保存*/
    		//1.提示用户输入圆的半径:
    		System.out.println("请您输入要求的半径值:");
    		
    		/**变量的第二种定义方式:先定义,再赋值*/
    		//2.1定义一个变量用来保存圆的半径
    		//double r = 5.5;
    		double r ;
    		//2.2接收用户在键盘上输入的数据,并把这个数据交给r保存
    		//开启扫描(发出一个系统指令,准备接收控制台输入的数据)
    		//nextDouble()控制用户只能输入double类型的数据,否则报错
    		r = new Scanner(System.in).nextDouble();
    		
    		//根据半径值求出圆的面积
    		double circleArea = 3.14 * r * r;
    		//打印计算的结果
    		System.out.println("圆的面积是:"+circleArea);
    	}
    
    }
    

    2.5 练习:变量交换

    在这里插入图片描述
    需求: 接收用户输入的两个值:假设a=1,b=2,并将这两个变量的值进行互换
    创建包: cn.tedu.basic
    创建类: TestValueExchage.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于练习值交换案例*/
    public class TestValueExchange {
    	//1.创建程序的入口函数main
    	public static void main(String[] args) {
    		//2.提示并接受用户在控制台输入的两个整数
    		System.out.println("请输入要交换的第一个整数:");
    		int a = new Scanner(System.in).nextInt();
    		System.out.println("请输入要交换的第二个整数:");
    		int b = new Scanner(System.in).nextInt();
    		System.out.println("a的值:"+a);
    		System.out.println("b的值:"+b);
    		
    		//3.交换 a b 这两个变量保存的值
    		int t;//定义一个变量用来辅助值交换
    		t = a;//把a的值交给t来保存
    		a = b;//把b的值交给a来保存
    		b = t;//把t的值交给b来保存
    		
    		System.out.println("交换后,a的值:"+a);
    		System.out.println("交换后,b的值:"+b);
    		
    	}
    
    }
    

    2.6 引用类型

    除了基本类型以外的所有类型都是引用类型
    目前我们只遇到了String字符串类型,需要用双引号包裹
    引用类型是一个对象类型,值是什么呢?
    它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值。如:类,接口,数组,后面讲。。。
    (后续会进一步学习,略…)

    3 基本类型的字面值(5条)

    3.1 整数类型的字面值类型是int类型

    也就是说,我们只要写一个整数,就被认为是int类型

    int x = 99999;
    //byte y = 300;//错,300是int类型,byte存不下
    //int z = 999999999999;//错,虽然是int类型,但是超出范围
    long h = 999999999999L;//如果要定义long类型需要加后缀L
    

    3.2 浮点数类型的字面值类型是double类型

    也就是说,我们只要写一个小数,就被认为是double类型

    	double d = 3.14;
    	//float f = 3.14;//错,3.14认为自己是double类型
    	float f = 3.14F;//如果要定义float类型需要加后缀F
    	double d2 = 3D;//如果要定义的小数是整数,最好加D方便阅读
    

    3.3 byte,short,char三种比int小的整数可以用范围内的值直接赋值

    byte b1=127;//对,
    byte b2=128;//错,超出byte的范围
    char c1=97;//对,对应的是码表中的'a'
    char c2 =69999;//错,超出char的范围
    

    3.4 字面值后缀L D F

    long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
    float b = 3.0F;//3.0字面值是double类型,加后缀F会变成float类型
    double d = 3D;//3字面值是int类型,加后缀D,会变成double类型
    

    3.5 进制前缀

    0b - 标识这是2进制 ,如:0b0101
    0 - 标识这是8进制, 8进制是三位,如: 023
    0x - 标识这是16进制,如: 0x0001
    		//10进制,底数为10:10^2 10^1 10^0 =100+0+0=100
    		System.out.println(100);//默认10进制,打印100
    		//2进制,底数为2:2^2 2^1 2^0 =4+0+0=4
    		System.out.println(0b100);//2进制,打印4
    		//8进制,底数为8:8^2 8^1 8^0 =64+0+0=64
    		System.out.println(0100);//8进制,打印64
    		//16进制,底数为16:16^2 16^1 16^0 =256+0+0=256
    		System.out.println(0x100);//16进制,打印256
    

    4 基本类型的类型转换

    箭头开始的地方是小类型,箭头指向的地方是大类型
    我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数哦
    基本类型的类型转换

    4.1 小到大(隐式转换)

    byte m = 120;
    int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
    float f = 3.2f; double d = f; -->可以执行

    4.2 大到小(显式转换)

    容量大的类型转换为容量小的类型时必须使用强制类型转换。

    int x = 999;
    byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换
    1. 转换过程中可能导致溢出或损失精度
      例如:int i =128; byte b = (byte)i; //打印的结果是-128
      因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
    2. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入
      例如:float f = 32.7f; int a2 =(int) f; //打印的结果是32
    3. 不能对boolean类型进行类型转换。

    4.3 口诀:

    小到大,直接转 大到小,强制转 浮变整,小数没

    低 ------------------------------------> 高

    byte,short,char→ int→ long→float→double

    5 运算规则(5条)

    5.1 计算结果的数据类型,与最大数据类型一致

    System.out.println(3/2);//1,int/int,得到的结果类型还是int
    System.out.println(3/2d);//1.5,int/double。得到的结果是double

    5.2 byte,short,char三种比int小的整数,运算时会先自动转换成int

    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);
    //a+b会自动提升成int类型,右面得运算结果就是int大类型
    //给左面的byte小类型赋值,不可以,需要强转。

    5.3 整数运算溢出

    整数运算溢出

    整数运算,类似于一个钟表,转到最大时,再转会回到最小。
    计算:光速运行一年的长度是多少米?3亿m/s

    //溢出的现象:
    //因为做了大的整型数据的运算,会超出int取值范围。解决方法:把整数提升成long类型。
    System.out.println(300000000L * 60 * 60 * 24 * 365);

    5.4 浮点数运算不精确

    1-0.8 (这是一个现象,后续会学习解决方案)

    5.5 浮点数的特殊值

    Infinity 无穷大 3.14/0
    NaN not a number 0/0.0 或 0.0/0

    6 拓展 标识符命名风格

    1.【强制】标识符命名均不能以数字开头,而且下划线或美元符号开始,也不能以下划线或美元符号结束
    错误案例:1name / _ name / name_ / $ name / name $
    2.【强制】代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式。
    说明:正确的英文拼写和语法可以让阅读者易于理解,避免歧义。
    注意,即使纯拼音命名方式也要避免采用。
    正确案例:alibaba / taobao / youku / hangzhou 等国际通用的名称,可视同英文。
    错误案例:DaZheModule [打折模块] / getPingfenByName() [评分]
    3.【强制】类名使用 UpperCamelCase 风格,即第一个单词的首字母就要大写

    展开全文
  • TensorFlow创建变量

    千次阅读 2017-11-06 21:21:32
    一、使用tf.Variable函数创建变量 tf.Variable(initial_value=None,trainable=True,collections=None,validate_shape=True,caching_device=None,name=None,variable_def=None,dtype=None,expected_shape=None,...

    一、使用tf.Variable函数创建变量

    tf.Variable(initial_value=None,trainable=True,collections=None,validate_shape=True,caching_device=None,name=None,variable_def=None,dtype=None,expected_shape=None,import_scope=None)

    函数功能:创建一个新的变量,变量的值是initial_value,创建的变量会被添加到[GraphKeys.GLOBAL_VARIABLES]默认的计算图列表中,如果trainable被设置为True,这个变量还会被添加到GraphKeys.TRAINABLE_VARIABLES计算图的集合中。

    参数:

    initial_value:默认值是None,张量或者是一个python对象可以转成张量,这个initial_value是初始化变量的值。它必须有一个特殊的shape,除非validate_shape设置为False。

    trainable:默认的是True,变量还会被添加到GraphKeys.TRAINABLE_VARIABLES计算图集合中。

    collections:变量会被添加到这个集合中,默认的集合是[GraphKeys.GLOBAL_VARIABLES]。

    validate_shape:如果是False,允许这个变量被初始化一个不知道shape。默认的是True,这个initial_value的shape必须是知道的。

    name:变量的名字。

    dypte:变量的类型,小数的默认是float32,整数默认是int32。

        a = tf.Variable(initial_value=[1,2,3],name="a")
        init = tf.initialize_all_variables()
        sess = tf.Session()
        sess.run(init)
        print(a.eval(session=sess))
        #[1 2 3]
        print(a.dtype)
        #<dtype: 'int32_ref'>
    二、使用tf.get_variable函数创建变量

    tf.get_variable(name,shape=None,dtype=None,initializer=None,regularizer=None,trainable=True,collections=None,
    caching_device=None,partitioner=None,validate_shape=True,use_resource=None,custom_getter=None)

    函数功能:根据变量的名称来获取变量或者创建变量。

    参数:

    name:变量的名称(必选)。

    shape:变量的shape。

    dtype:变量的数据类型。

    initializer:变量的初始化值。

    1、根据变量的名称创建变量

        b = tf.get_variable(name="b", initializer=[1., 2., 3.])
        init = tf.initialize_all_variables()
        sess = tf.Session()
        sess.run(init)
        print(b.eval(session=sess))
        #[ 1.  2.  3.]
        print(b.dtype)
        #<dtype: 'float32_ref'>

    使用tf.get_variable创建变量的时候,如果不指定name,会报TypeError: get_variable() missing 1 required positional argument: 'name'

    2、根据变量的名称获取变量
        with tf.variable_scope("f"):
            #初始化一个变量名称为c的变量
            c = tf.get_variable(name="c",shape=[3],initializer=tf.constant_initializer([1,2,3]))
    
        with tf.variable_scope("f",reuse=True):
            d = tf.get_variable(name="c",shape=[3])
            sess = tf.Session()
            init = tf.initialize_all_variables()
            sess.run(init)
            print(d.eval(session=sess))
            #[ 1.  2.  3.]
            print(c.eval(session=sess))
            #[ 1.  2.  3.]
            print(d == c)
            #True
    在使用tf.get_variable()根据变量的名称来获取已经生成变量的时候,需要通过tf.variable_scope函数来生成一个上下文管理器,并明确指定在这个上下文管理器中。获取变量值的时候,需要将上下文管理器中的reuse设置为True,才能直接获取已经声明的变量,如果不设置reuse会报错。需要注意的是,如果变量名在上下文管理器中已经存在,在获取的时候,如果不将reuse设置为True则会报错。同理,如果上下文管理器中不存在变量名,在使用reuse=True获取变量值的时候,也会报错。
    三、tf.variable_scope的嵌套

        with tf.variable_scope("a"):#默认是False
            #查看上下文管理器中的reuse的值
            print(tf.get_variable_scope().reuse) #False
            with tf.variable_scope("b",reuse=True):
                print(tf.get_variable_scope().reuse) #True
                #如果reuse是默认的则保持和上一层的reuse值一样
                with tf.variable_scope("c"):
                    print(tf.get_variable_scope().reuse) #True
            print(tf.get_variable_scope().reuse) #False
    四、上下文管理器与变量名

        #没有上下文管理器
        a = tf.get_variable(name="a",shape=[2],initializer=tf.constant_initializer([1,2]))
        print(a.name) #a:0,a就是变量名
        #声明上下文管理器
        with tf.variable_scope("f"):
            b = tf.get_variable(name="b",shape=[2],initializer=tf.constant_initializer([1,2]))
            print(b.name) #f/b:0,f代表的是上下文管理器的名称,b代表的是变量的名称
            #嵌套上下文管理器
            with tf.variable_scope("g"):
                c = tf.get_variable(name="c",shape=[2],initializer=tf.constant_initializer([1,2]))
                print(c.name)#f/g/c:0
    通过上下文管理器和变量名来获取变量

        #通过带上下文管理器名称和变量名来获取变量
        with tf.variable_scope("",reuse=True):
            d = tf.get_variable(name="f/b")
            print(d == b)  #True
            e = tf.get_variable(name="f/g/c")
            print(e == c)  #True
    






    展开全文
  • php框架用的是SpeedPHP,这框架在使用数据model的时候,是通过...这样创建的$db由于类型无法确定,所以在IDE里面没有代码提示,有点不方便! spClass 返回的实际上是传进来的参数 'modelClassName' 类型的对象,也

    最近使用PhpStorm来写php代码,

    php框架用的是SpeedPHP,这框架在使用数据model的时候,是通过“spClass”这函数来创建的,

    如:$db = spClass('modelClassName');

    这样创建的$db由于类型无法确定,所以在IDE里面没有代码提示,有点不方便!

    spClass 返回的实际上是传进来的参数 'modelClassName' 类型的对象,也是spModel 的子类;

    好了,现在我的问题是,使用 $db 变量的一些方法,IDE没有提示很不方便。


    百度搜了下,这里http://bbs.csdn.net/topics/340026534 有位哥们也提问了类似需求,貌似回答没结果;

    我想到了一个笨方法,在这里发一下,给有需要的人参考下!


    如下:

    $db = spClass('yue_magazine');
    上面这样写,IDE是没有代码提示的

    $db = spClass('yue_magazine');
    //$db = 1==2 ? new spModel() : $db;
    $db = 1==2 ? new yue_magazine() : $db;

    改为上面这样,IDE就有提示了,有点欺骗IDE的感觉。。。

    请看一下下面的效果截图:


    (或许有更好的方法,欢迎大家留言)




    展开全文
  • python之变量类型

    千次阅读 2018-02-07 14:39:49
    这就意味着在创建变量时会在内存中开辟一个空间。 基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。 因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。 ...
  • Kotlin的变量和数据类型

    千次阅读 2017-12-28 10:23:08
    什么是变量和数据类型 为了方便新手阅读,在这里我们简单介绍下变量和基本数据类型的概念,老司机跳过即可。 首先我们先来搞清楚一件事就是我们编写的程序实际上都是在处理数据。不管是视频,图片,还是文字,...
  • JAVA 入坑教程 | 章节三 变量类型

    千次阅读 2017-02-17 11:11:33
    变量(静态变量)类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。 无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。 静态变量除了被声明为常量外很少使用。常量是指...
  • java的数据类型变量类型笔记总结

    千次阅读 2018-03-02 13:31:02
    这些变量在声明指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。 对象、数组都是引用数据类型。 所有引用类型的默认值都是null。 一个引用变量可以用来引用任何与之兼容的...
  • 有的时候我们的泛型中的数据类型是动态变化的. 所以有的时候.我们需要.根据Type参数动态创建.不同内部类型的泛型 例如:List t = new List(); 这里的 int 参数是需要根据情况动态变化的. 所以就出现了.var rType =...
  • c++之变量类型

    千次阅读 2018-02-08 15:29:58
    C++ 中每个变量都有指定类型类型决定了变量存储的大小和布局,该范围内的值都可以存储在内存中,运算符可应用于变量上。变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写...
  • 这就意味着在创建变量时会在内存中开辟一个空间。 基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。 因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。 Python...
  • python函数的参数和返回值进行指定类型和检查

    万次阅读 多人点赞 2019-07-16 22:34:21
    python一直以来都不是开发大工程的主流语言,不管是前端还是后端,主要的原因其实就是以下几点: ...但是,在python3.5之后,就新增了函数参数和返回值的类型指定和检查,以及在新建变量时也可以指定类型。 基...
  • Golang的变量常量及基本类型

    万次阅读 2016-02-01 19:04:53
    1,变量变量的声明: ...关键字var,而类型信息放在变量名之后,示例如下:1.1变量的声明var v1 int var v2 string var v3 [10]int // 数组 var v4 []int // 数组切片 var v5 struct { f int } var v6 *int // 指针 v
  • Python笔记(5) 变量类型

    万次阅读 多人点赞 2019-07-21 09:13:49
    标准数据类型:数字、字符串、列表、元组、集合、字典 变量的赋值、标准、转换
  • Python 变量

    千次阅读 热门讨论 2017-03-31 19:31:01
    这意味着,在创建变量时会在内存中开辟一个空间。 基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。因此,变量可以指定不同的数据类型,例如:整数、小数或字符串等。
  • Python3 教程 变量类型

    千次阅读 2020-07-09 09:59:29
    基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。 因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。
  • 变量

    千次阅读 2020-07-04 11:36:27
    //在创建一个变量的同时,立刻放入指定的数据值 public class Demo02Variable{ public static void main(String[] args){ //创建一个变量 //格式:数据类型 变量名称; int num1; //向变量当中存入一
  • java基本数据类型&java变量类型

    千次阅读 多人点赞 2015-12-05 11:01:50
    也就是说,当创建变量的时候,需要在内存中申请空间。 内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据。 因此,通过定义不同类型的变量,可以在内存中储存整数、小数或者字符。...
  • Java变量

    万次阅读 多人点赞 2019-09-29 00:06:53
    文章目录定义分类按被声明的位置划分成员变量局部变量成员变量和局部变量的区别使用原则按所属的数据类型划分基本数据类型变量引用数据类型变量定义格式注意事项 定义 在程序执行的过程中,在某个范围内其值可以...
  • python基础之变量定义和变量类型

    千次阅读 2019-03-17 20:29:58
    变量类型(不需要指定类型) 数字型 整型int 浮点型float 布尔型bool 复数型complex 非数字型 字符串、列表、元组、字典 type(name)可以查看name的数据类型 type(2**32) 数字型...
  • Python中的变量和数据类型

    千次阅读 2018-10-29 12:38:45
    目录 变量 全局变量和局部变量 数据类型 数字 ...变量是计算机内存中的一块区域,变量可以存储任何值(也称指向),而且值可以改变。...这就意味着在创建变量时会在内存中开辟一个空间。基于变...
  • shell变量类型

    万次阅读 2011-05-16 08:58:00
    13.10.2 命名惯例 变量必须以字母或下划线字符开头。其余的字符可以是字母、数字(0~9)或下划线字符。任何其他的字符都标志着变量名的终止。名字是大小写敏感的。给变量赋值,等号周围不能有任何空白...
  • Java实例变量和类变量

    万次阅读 多人点赞 2017-09-04 09:02:02
    Java程序的变量大体可分为成员变量和局部变量。其中局部变量可分为如下3类。 形参:在方法签名中定义的...代码块的局部变量:在代码块内定义的局部变量必须在代码块内其进行显式初始化,这种类型的局部变量从初始化
  •  C语言声明数组变量时,在什么情况下,可不指定数组大小  只有以下三种情况:  (1)数组是形式参数  (2)数组声明的同时进行了初始化  (3)数组的存储类型为extern
  • 结构体变量和结构体类型的定义

    万次阅读 多人点赞 2019-08-02 16:43:19
    结构体类型定义 定义方式1: Typedef struct LNode { int data; // 数据域 struct LNode *next; // 指针域 } *LinkList; 定义方式2: struct LNode { int data; // 数据域 struct LNode *next; // 指针域 }; ...
  • Scratch数据类型以及变量和列表

    千次阅读 2019-11-04 15:50:15
    数据类型 Scratch有3种数据类型: 数字类型 布尔类型 字符串类型 参数凹槽 某些积木中带有参数凹槽。参数凹槽有3种: 六边形: 布尔类型参数 矩形: 字符串类型参数 圆角矩形: 数字类型参数 然而,...
  • 1.如何给变量赋一个指定地址并赋值 答1:int *p; p=(int *)0x123456; *p=0x1234; 答2:(unsigned int *)(0x123456) = 0x1234; //数值强转地址 2.如何将变量定义到指定的地址 具体要看环境(还没搞懂) ①linux ...
  • plc 变量的数据类型

    千次阅读 2013-12-17 11:29:21
    标准数据类型 布尔型数据类型 布尔型变量可被赋予“TRUE”真或“FALSE”假。这个值为逻辑量,占用1 位存储...注意,当较长的数据类型转换为较短的数据类型时,会丢失高位信息 实型数据类型 REA
  • 如何分配变量指定的地址

    万次阅读 2015-11-04 15:10:56
    如何分配变量指定的地址 举例: unsigned char temp_A@0x00; //定义无符号变量temp_A,强制其地址为0x00 unsigned char temp_B@0x100; //定义无符号变量temp_B,强制其地址为0x100 @tiny unsigned char temp...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 880,059
精华内容 352,023
关键字:

创建变量时必须指定类型对吗