精华内容
下载资源
问答
  •   我们知道,python变量是有类型的,对于python变量的几种类型,我们在写python时是必须要有一定的概念的。知道类型就要知道变量类型怎么存储,可是为什么python变量不需要声明类型就可以直接赋值?变量如果有...

      我们知道,python的变量是有类型的,对于python变量的几种数据类型,我们在写python时是必须要有一定的概念的。知道数据类型就要知道变量数据类型怎么存储,可是为什么python的变量不需要声明数据类型就可以直接赋值?变量如果有数据类型,那变量不是可以为任意数据类型?那真正的数据类型如int在内存存储的字节大小应该为多少?等等诸如一系列的问题让我提起了的兴趣,经过网上不断查找学习后,在此将我所了解到的内容在此做个总结归纳。


    一、变量的数据类型

    1、什么是变量的数据类型

      我们先捋一捋什么是变量,变量从字面上理解就是可以变化的量,我们可以随时改变这个变量的值,使得我们可以调用同一个变量而获得不同的值,与之对应的是常量。那么对于一个可变的变量,它有可能表示是一个字符串,一个数字或者是一个小数,因为这些在计算机内存里存放的方式是不一样的,所以简单理解就是变量的数据类型不同就是对应的数据在计算机内存中存放方式的不同。这种方式表现在按多少字节存储,是否连续存储等。
      我们都知道,c是静态类型语言,一种在编译期间就确定数据类型的语言,也就是我们需要对变量先声明其数据类型后才能使用,并且在使用过程中一般不能赋值一些超过该数据类型数值,比如:int a = 1.2,当然大类型是可以转向小类型的,如:double a = 1 (double类型接收整形数值)。可以肯定的,大多数静态类型语言都这么干。
      当然,python语言也有数据类型。但python语言不同,它是一种动态类型语言,又是强类型语言。它们确定一个变量的数据类型是在你第一次给它赋值的时候,也就是说你赋值给变量什么数据类型的数值,变量就是什么数据类型的。所以,对比之下,c语言变量的数据类型是事先定义的,而python是后天接受的

    2、python五大标准数据类型

      在讲变量存储之前,这里先简单总结下python的五大标准数据类型,为了方便展示,我们采用type方法显示变量的数据类型。

    (1)Numbers(数字)
      数字数据类型用于存储数值。他们是不可改变的数据类型,可简单分为以下四种:(注意这里十六进制,八进制都属于int整形。)
    int(整型):

    var = 520
    print(type(var))     	 # <class 'int'>
    

    float(浮点型):

    var = 5.20
    print(type(var))     	 # 输出:<class 'float'>
    

    bool(布尔型):

    var = true
    print(type(var))         # 输出:<class 'bool'>
    

    complex(复数):

    var = complex(13,14)
    print(type(var))   	     # 输出:<class 'complex'>
    

    (2)String(字符串)
      字符串或串是由数字、字母、下划线组成的一串字符,用‘’,“”,“‘ ’”都可表示。三者的使用可参考这篇文章: python字符串的各种表达方式.
      如下方代码所示,获得的类型为str类型。另外也顺便提一个小知识点,要访问字符串可以正向访问也可以反向访问,即正向时,var[0] = ‘p’,var[1] = ‘i’,var[2] = ‘g’;而反向时,var[-1] = ‘g’,var[-2] = ‘i’,var[-3] = ‘p’。

    var = “pig”
    print(type(var))   	     # 输出:<class 'str'>
    print(var[0:3])          # 正向访问,输出:'pig'
    print(var[-1])           # 反向访问,输出:'g'
    

    (3)List(列表)
      列表是 Python 中使用最频繁的数据类型,用 [ ] 标识。列表可以完成大多数集合类的数据结构实现。它可以同时包含字符,数字,字符串甚至可以包含列表(即嵌套)。如下方代码所示,列表的处理方式和字符串类似。

    var = [ 'pig' , 1 , 2.2 ]
    print(type(var))   	     # 输出:<class 'list'>
    print(var[0])   	     # 获得第一个元素,输出:'pig'
    print(var+var)  		 # 打印组合的列表,输出:[ 'pig', 1 , 2.2,'pig', 1 , 2.2 ]
    

    (4)Tuple(元组)
      元组类似于 List(列表)。元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。

    var = ( 'pig', 1 , 2.2 )
    print(type(var))   	     # 输出:<class 'tuple'>
    print(var[0])   	     # 获得第一个元素,输出:'pig'
    print(var+var)  		 # 打印组合的元组,输出:( 'pig', 1 , 2.2,'pig', 1 , 2.2 )
    var[0] = 'dog'			 # 出错!不能被二次赋值
    

    (5)Dictionary(字典)
      字典的相对于列表来说,列表是有序的对象集合,而字典是无序的对象集合。两者之间的区别在于字典当中的元素是通过键来存取的,而不是通过偏移存取。字典用"{ }"标识,字典由索引key和它对应的值value组成。

    dic = {'name''张三''age'18}
    print(dic ['name'])       # 得到键为'name' 的值,输出:'张三'
    print(dic [age])          # 得到键为'age' 的值,输出:18
    print(dic)                # 得到完整的字典,输出:{'name':'张三','age':18}
    print(dic.keys())         # 得到所有键,输出:dict_keys:(['name','age'])
    print(dic.values())       # 输出所有值,输出:dict_values:(['张三',18])
    

    二、python变量的存储

    1、变量与储存地址的关系

      在高级语言中,变量是对内存及其地址的抽象。以c语言举例, 变量事先定义好一种数据类型,于是编译器为变量分配一个对应类型的地址空间和大小(如int 4字节,char 1字节),当该变量改变值时,改变的只是这块地址空间中保存的值,即在程序运行中,变量的地址就不能再发生改变了。这种存储方式称为值语义。如下代码用VS2015运行,由结果可知,test变量的值被存储在0x0020FDC8,当变量改变时,地址不变,地址中对应的值发生改变。

    #include<iostream>
    using namespace std;
    int main()
    {
    	int test = 1;
    	cout << &test << ":" << test << endl;
    	test = 2;
    	cout << &test << ":" << test << endl;
    	return 0;
    }
    

    运行结果:

    0020FDC8:1
    0020FDC8:2
    

      这里就存在一个问题,每次新建一个变量,编译器就会开辟一块对应数据类型大小的内存,然后给那块内存取个名字(变量名)。除非一块内存被释放,那么该变量才能释放,不然一个变量就只能固定地对应一个数据类型。
      对此,python做出了改变,它采用了与高级语言截然不同的方式。在python中,一切变量都是对象,变量的存储采用了引用语义的方式,存储的只是一个变量的值所在的内存地址,而不是这个变量的值本身。简单理解就是,python变量只是某个数据的引用(可以理解成C语言的指针),当python变量赋值时,解释器(因为python为解释性语言)先为数值开辟一块空间,而变量则指向这块空间,当变量改变值时,改变的并不是这块空间中保存的值,而是改变了变量的指向,使变量指向另一个地址空间。这种存储方式称为对象语义或指针语义。举个例子:

    str = 'girls are pig'
    print(id(str))
    str = 'boys are dog'
    print(id(str))
    

    运行结果:

    113811696
    113812464
    

      id()方法可以获得变量指向的地址,由运行结果所示,一开始变量指向了113811696这个地址,这个地址存放了‘girls are pig’这个字符串,当变量发生改变时,即该变量的指向改变了,指向地址113812464,该地址存放有‘boys are dog’这个字符串。这两个字符串都是一开始解释器先在内存开辟好的。
      所以,这也就解释了为什么python的变量被整形赋值就成了整形,被列表赋值就成了列表,变量可以为任意数据类型的,因为python的变量只是对编译器事先在内存存放好的数据的引用
      python采用这种方式,好处就体现在,对于解释器来说,变量就只是一个地址的引用,而这个引用是可以随时改变的,那么就可以做到一个变量用来指向各种各样的数据类型,只要每次记录变量与哪个数据类型连接就行了,效率不就提升了嘛~。而对于c语言的编译器来说,一个变量就只能与一个数据类型长相厮守,所以它望着记录了各种各样变量名与内存值对应的表格,一边编译,一边陷入了沉思…(这里注意一点牛角尖,变量名只是给解释器看的东西,在内存是不做存储的,真正存储的是变量名对应的内容,上面说的变量都是int a中a这个个体

    2、复杂数据类型的存储方式

      这里说的复杂数据类型主要是像列表,字典等这种可以改变内部数据的数据类型。以列表作为例子举例,代码如下所示:

    list1 = [1,2,3]
    print(list1)			#输出:[1,2,3]
    print(id(list1))		#输出:112607104(不同电脑分配给变量的地址不同)
    list1[0] = "hello"
    print(list1)			#输出:['hello',2,3]
    print(id(list1))		#输出:112607104
    list1.append(4)
    print(list1)			#输出:['hello',2,3,4]
    print(id(list1))		#输出:112607104
    list1 = ['hello',4]
    print(list1)			#输出:['hello',4]
    print(id(list1))		#输出:112925120
    

      由运行结果所示,无论对列表list1进行什么增删改查操作,都不会影响list1本身的存储,只是改变了存储的内容,但list1重新赋值时,地址则发生改变。这个为了更好地解释清楚一点,就拿出我自豪的画画天赋吧(手动狗头,咳咳),上图~。
    在这里插入图片描述
      先声明一点,一个变量存有某一个对象的地址即等于该变量指向了这个对象。上面解释了,list1变量存放的是某个数据类型的引用,换种说法就是存放某个对象的地址,这里就是存放一个列表的地址,即list1变量指向了列表。如图所示,第一步,list1变量指向列表1,该列表存放着三个可变元素list1[0],list1[1],list1[2],它们分别存放着不同对象(值)的地址。第二步,列表的第一个元素list1[0]发生改变,变成存放hello这个字符串对象的地址。第三步,列表新增了一个元素,该元素存放了新的整形对象4的地址。第四步,列表变量list1重新赋值,指向了新的列表2,列表2元素又指向了hello和4这两个对象。
      因此,前面三步,因为都是改变了列表元素的指向,变量本身的指向没有变化,即变量的地址也没有变化,但第四步,变量进行重新的赋值,即指向了新的列表,那么变量的地址变发生了变化。
      这里也有重要的一点是,列表2和列表1指向的对象hello和4是一致的,因为它们的对象是一样的,所以它们共用一个对象。从下面代码可以体现,输出的结果是一致的。

    list1 = ['hello',2,3,4]
    print(id(list1[0]))		#输出:112926064
    print(id(list1[3]))		#输出:8791404644096
    list2 = ['hello',4]
    print(id(list2[0]))		#输出:112926064
    print(id(list2[1]))		#输出:8791404644096
    

    3、变量的赋值——浅拷贝和深拷贝

    (1)变量赋值的安全隐患

      因为python的这种变量是一个对象的引用的机制,必然导致的结果是两个变量赋值时会产生相互牵连的现象。举个例子,list1赋值为[1,2,3],然后将其赋值给list2,改变list1时,我们可以发现list2也发生改变。代码如下。

    list1 = [1,2,3]
    list2 = list1
    print(list1)			#输出:[1,2,3]
    print(list2)			#输出:[1,2,3]
    print(id(list1))		#输出:112607104
    print(id(list2))		#输出:112607104
    list1[0] = 'hello'
    print(list1)			#输出:['hello',2,3]
    print(list2)			#输出:['hello',2,3]
    print(id(list1))		#输出:112607104
    print(id(list2))		#输出:112607104
    

      解释图如下,第一步,list1变量指向了列表1,经过赋值后,变量list2也指向了列表1,因此两者地址相同。第二步,变量list1改变第一个列表元素的值,使其指向‘hello’,这时我们访问list2内容时,因为list1和list2指向的列表一致,所以list2就变成改变后的值。
    在这里插入图片描述
      由此引出主题深拷贝和浅拷贝,所谓深拷贝呢,就是一个变量的内容赋值给另一个变量时,是把全部资源重新复制一份再赋值给新的变量,而浅拷贝则不然,它的赋值只是将资源的地址给新的变量,二者同时共享该资源。显然,上面的赋值运算例子就是一个浅拷贝。

    (2)浅拷贝

      为了更加深入了解二者,举一个稍微复杂一丢丢的例子,这里我们需要用到外部包,copy包,它的方法copy()就是一个浅拷贝,而deepcopy()就是一个深拷贝。先举例浅拷贝,这次采用嵌套列表并且使用copy方法来进行拷贝。对比输出结果可以看到对列表list1和list2进行操作时,两者没影响,但对peope这个列表操作时,则两个列表都有影响。

    import copy
    people = ['girl','boy']
    list1 = [1,2,people]
    list2 = copy.copy(list1)
    print(list1)				#输出:[1,2,['girl','boy']]
    print(list2)				#输出:[1,2,['girl','boy']]
    list1.append('hello')		
    list2.append('hi')			
    print(list1)				#输出:[1,2,['girl','boy'],'hello']
    print(list2)				#输出:[1,2,['girl','boy'],'hi']
    people[0] = 'pig'
    print(list1)				#输出:[1,2,['pig','boy'],'hello']
    print(list2)				#输出:[1,2,['pig','boy'],'hi']
    

      由下图可知,第一步,list1和list2分别指向列表1和列表2,其元素也指向对应的值,但个列表的第三个元素都指向了同个列表。第二步,list1产生新元素,指向‘hello’,list2产生新的元素,指向‘hi’。第三步,people这个列表的第一元素地址指向从‘girl’变成了‘pig’(狗头保命),因为是共用列表,所以list1和list2这两个变量都产生了变化。从中也可以分析得到,copy这个方法不像‘=’这种赋值运算,它拷贝了资源的第一层,但如果有该资源有第二层时,则变成共用资源,这也是比较容易被忽略的一点。
    在这里插入图片描述
    (3)深拷贝

      为了解决浅拷贝带来的安全隐患,有时我们需要采用深拷贝来拷贝我们的资源。即python的copy模块提供的另一个deepcopy方法。深拷贝会完全复制原变量相关的所有数据,在内存中生成一堆一模一样的资源,在这个过程中我们对这两个变量中的一个进行任意修改都不会影响其他变量。我们来测试一下。

    import copy
    people = ['girl','boy']
    list1 = [1,2,people]
    list2 = copy.deepcopy(list1)
    print(list1)				#输出:[1,2,['girl','boy']]
    print(list2)				#输出:[1,2,['girl','boy']]
    list1.append('hello')		
    list2.append('hi')			
    print(list1)				#输出:[1,2,['girl','boy'],'hello']
    print(list2)				#输出:[1,2,['girl','boy'],'hi']
    people[0] = 'pig'
    print(list1)				#输出:[1,2,['pig','boy'],'hello']
    print(list2)				#输出:[1,2,['girl','boy'],'hi']
    

      流程如下图所示,其步骤和浅拷贝的步骤一致,但不同的一点是,步骤三的people列表改变时,只有list1变量的people列表中‘girl’变成‘pig’,而list2变量没什么影响,二者完全独立。
    在这里插入图片描述

    三、python变量数据类型的大小

      本来探索到上面已经差不多要结束,鬼知道我脑子又冒出了个奇怪的想法,python的int类型到底要占有电脑的多少个字节呢。毕竟习惯了c语言,而python对变量神奇的设计总是散发着它独特的魅力。所以找啊找,找到一个可以显示数据大小的API函数getsizeof(),只要导入sys包即可。那么写个例子:

    import sys
    print(sys.getsizeof(0))        # 输出:24
    print(sys.getsizeof(1))        # 输出:28 
    print(sys.getsizeof(2))        # 输出:28
    print(sys.getsizeof(2**15))    # 输出:28
    print(sys.getsizeof(2**30))    # 输出:32
    print(sys.getsizeof(2**128))   # 输出:44
    

      看到输出结果,属实让人震惊,一个int型的数值,居然用高达24个字节来存储,而且在电脑存储大小居然是不限定的,是自增长的。喝口水压压惊后,让我想到c++的STL容器,可以使用栈顶指针,当检测到容量超出时,则删除旧内存而去开辟一块新的内存,确实可以实现这种效果。
      扯完犊子,那么这里首先先解决第一个问题,int类型这个变量什么时候内存会变大?我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图,简单来说就是int类型每多2^30(1073741824 )就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节,而比它小的是28个字节的原因,当然零除外。其他类型也可以在下面找到答案。
    在这里插入图片描述
      那么它的自增长问题呢,这个可能要去看python的源码才能解决,还好有大佬已经提前给我们铺了下路,这里我就没这个能力去了解太深入了,直接引用大佬的结论就可以了。具体可以参考这篇文章:点此处跳转。在64位python的解释器中,int类型的定义是通过一个结构体来定义的,简化后的结构体如下所示:

    struct PyLongObject {
      long ob_refcnt;                // 8 bytes
      struct _typeobject *ob_type;   // 8 bytes
      long ob_size;                  // 8 bytes
      unsigned int ob_digit[1];      // 4 bytes * abs(ob_size)
    };
    

      ob_refcnt引用计数8个字节,ob_type类型信息8个字节(指针),ob_size变长部分元素的个数8个字节。ob_digit变长的数据部分,字节数为4 * abs(ob_size),ob_size可以为0,所以ob_digit这部分可以占0字节,那么最少int就为8 + 8 + 8 = 24个字节,每次增量都是4(unsigned int)的倍数。
      对于32位的版本与64位又有所不同,定义如下,最少12个字节,增量为2个字节。

    struct PyLongObject {
      int ob_refcnt;                // 4 bytes
      struct _typeobject *ob_type;  // 4 bytes
      int ob_size;                  // 4 bytes
      unsigned short ob_digit[1];   // 2 bytes * abs(ob_size)
    };
    

      至于其他类型实际大小,也是一个类似的方案,这里也不探讨太多东西了,学无止境吧~

    总结

      这篇文章从变量的角度切入,首先谈谈什么是变量的类型,并且举例了python中常用的基本数据类型,接着讨论了变量在内存中的存储,说白了就一句话,变量就是某一个对象的引用,对象在内存爱怎么放怎么放与变量无关。最后讨论了int类型占有电脑的字节数。


    Tips:本人能力有限,如有错误之处麻烦指出。放弃不难,但坚持一定很酷!
    展开全文
  • 1. 整型 >>...查看变量的类型 >>> type(a) <class ‘int’> 2. 浮点型 >>>b = 1.2 >>> print(b) 1.2 >>> type(b) <class 'float'> ...

    1. 整型

    >>> a = 1
    >>> print(a)
    
    查看变量的类型
    >>> type(a)
    <class ‘int’>
    

    在这里插入图片描述

    2. 浮点型

    >>>b = 1.2
      >>> print(b)
    1.2
    
    >>> type(b)
    <class 'float'>
    

    在这里插入图片描述

    3. 字符串型

    >>> c = 'westos'
    >>> print(c)
    westos
    >>> c = "what's"
    >>> print(c)
    what's
    >>> c = 'what's'
      File "<stdin>", line 1
        c = 'what's'
                  ^
    SyntaxError: invalid syntax
    >>> c = 'what\'s'
    >>> print(c)
    what's
    

    在这里插入图片描述

    4. bool型(只有两个值:True False 非0即真)

    >>> a = 1
    >>> bool(a)
    True
    >>> bool(0)
    False
    >>> bool('')
    False
    >>> bool(' ')
    True
    >>> bool('redhat')
    True
    

    当“”中为空时,bool值为false,当“”中有空格或者其他字符时,bool值为true(非0即真)
    在这里插入图片描述

    5. 数据类型之间的转换

    >>> a = 1
    >>> type(a)
    <class 'int'>
    >>> float(a)
    1.0
    >>> type(a)
    <class 'int'>
    

    在这里插入图片描述

    >>> b = float(a)
    >>> b
    1.0
    >>> b = 2.0
    >>> int(b)
    2
    

    在这里插入图片描述

    >>> b = 123
    >>> str(b)
    '123'
    >>> c = '123'
    >>> int(c)
    123
    >>> a
    1
    >>> b
    123
    >>> c
    '123'
    

    在这里插入图片描述

    6. 在内存中删除一个变量

    >>> del a
    >>> a
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'a' is not defined
    >>> del b
    >>> b
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'b' is not defined
    

    在这里插入图片描述

    7. 变量和地址的关系

    (1) Python中采用基于值的内存管理方式,不同的值分配不同的内存空间
    当给变量赋值时,Python解释器为该值分配一个内存空间,而变量则指向该空间
    当变量的值被改变时,改变的不是该内存空间的内容,而是改变了变量的指向关系,使变量指向另一内存空间
    可以理解为:Python变量并不是某一固定内存单元的标识,而是对内存中存储的某个数据的引用,这个引用是动态改变的

    (2) Python具有自动内存管理功能,对于没有任何变量指向的值(垃圾数据),Python系统自动将其删除
    例如:x从指向12转向3.14后,数值12变成了没有变量引用的垃圾数据,Python会回收垃圾数据的内存单元,以便提供给别的数据使用
    这就是垃圾回收,也可以用del语句删除一些对象的引用
    在这里插入图片描述

    8.Python的id()函数可以返回对象的内存地址

    Python解释器会为每个出现的对象分配内存单元,即使他们的值相等,也会这样。
    例如:执行a=1.1,b=1.1,会先后为1.1这个float类型对象分配内存单元,然后将a和b分别指向这两个对象,所以a和b执行的不是同一对象。
    但是为了提高内存利用效率,对于一些简单的对象,如数值较小的整形int对象,Python采取重用对象内存的办法,不会两次为其分配内存单元
    而对于较大的数值,情况就跟前面的一样了。
    在这里插入图片描述

    展开全文
  • Python会自动将不再使用的对象/值(没有任何变量数据结构成员指向它的那种) 直接删除,这被称为垃圾回收。 即使是del语句也无法删除对象/值的本体,但del语句可以删除所有与该名称相关的引用,以及该名称本身。...

    问题描述:

    1. 经查阅资料,我发现只要还存在任何一个变量在引用某个值(无论是直接赋值引用,还是通过其他变量赋值间接引用),这个值本身就不会被删除。
    2. 也就是说想通过删除“赋值变量”来删除“被赋值的变量”是不可能的,不注意这一点的话,会遇到很多问题。
    3. 但Python会自动将不再使用的对象/值(没有任何变量或数据结构成员指向它的那种) 直接删除,这被称为垃圾回收。
    4. 即使是del语句也无法删除对象/值的本体,但del语句可以删除所有与该名称相关的引用,以及该名称本身。
    a1='第一个值+'
    a2='第二个值'
    b=a1+a2
    
    print('不修改a,可以正常打印b:'+b)
    # 该语句可正常打印
    
    a1=None
    print('将a1修改为none,依然可以正常打印b:'+b)
    # 该语句可正常打印
    
    del a1,a2
    print('将a1、a2直接删除,还是可以正常打印b:'+b)
    # 该语句可正常打印
    
    del b
    print('除非用del语句删除b这个名称本身及其所有的引用:'+b) 
    # del语句将变量b本身及其所有的引用都删除了,但并未删除赋值变量a1与a2所指向的值。
    
    
    

    展开全文
  • 一、python声明变量 变量的命名和使用 # 在Python中使用变量时,需要遵守一些规则和指南。 # 违反这些规则将引发错误,而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。 # 变量名...

    一、python声明变量

    变量的命名和使用
    # 在Python中使用变量时,需要遵守一些规则和指南。
    # 违反这些规则将引发错误,而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。
    # 变量名只能包含字母、数字和下划线。变量名 可以字母或下划线打头,但 不能以数字打头,例如,可将变量命名为message_1,但不能将其命名为1_message。
    # 变量名 不能包含空格,但 可使用下划线来分隔其中的单词。例如,变量名 greeting_message可行,但变量名 greeting message会引发错误。
    # 不要将Python关键字和函数名用作变量名,即不要使用Python保留用于特殊用途的单词,如print 。
    # 变量名应既简短又具有描述性。例如,name比n好,student_name比s_n好,name_length比length_of_persons_name好。
    # 慎用小写字母l和大写字母O,因为它们可能被人错看成数字1和0。
    # 要创建良好的变量名,需要经过一定的实践,在程序复杂而有趣时尤其如此。随着你编写的程序越来越多,并开始阅读别人编写的代码,将越来越善于创建有意义的变量名。
    # 注意  就目前而言,应使用小写的Python变量名。在变量名中使用大写字母虽然不会导致错误,但避免使用大写字母是个不错的主意。
     
    #声明变量
    message = "Hello Python world!" 
    
    #打印结果
    print(message)
    

      上边代码输出的结果为: Hello Python world! 

    二、python修改变量值

    下面来进一步扩展这个程序:修改以上代码,使其再打印一条消息。为此,在以上中添加一个空行,再添加下面两行代码:

    1 message = "Hello Python world!"
    2 print(message)
    3 message = "Hello Python Crash Course world!"
    4 print(message)

    现在如果运行这个程序,将看到两行输出:

    Hello Python world!
    Hello Python Crash Course world!
    以上代码将打印出两个结果,按照执行先后顺序,第一个print打印的是在他之前的变量值,如果这里不打印,在代码的最后只打印一次,那么它将始终打印最新记录的变量值,其他不打印
    因此上在python程序中可随时修改变量的值,而Python将始终记录变量的最新值
     

    三、python字符串类型

    字符串 就是一系列字符。在Python中,用引号括起的都是字符串,其中的引号可以是单引号,也可以是双引号,如下所示:

     "This is a string."   'This is also a string.' 

     

    这种灵活性让你能够在字符串中包含引号和撇号: 

    1 'I told my friend, "Python is my favorite language!"'
    2 "The language 'Python' is named after Monty Python, not the snake."
    3 "One of Python's strengths is its diverse and supportive community."

    3.1 使用方法修改字符串大小

    修改英文字符串的方法总共有三种: title() 方法,英文单词首字母全部大写      upper() 方法,英文单词全部大写    lower() 方法,全部小写

    1 name = "pthon or javascript"
    2 print(name.title())  
    3 print(name.upper())  
    4 print(name.lower()) 

    以上代码打印的结果分别为:

    1 Pthon Or Javascript
    2 PTHON OR JAVASCRIPT
    3 pthon or javascript

    四、python列表

    列表 由一系列按特定顺序排列的元素组成。

    你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表;

    也可以将任何东西加入列表中,其中的元素之间可以没有任何关系。

    鉴于列表通常包含多个元素,给列表指定一个表示复数的名称(如letters 、digits 或names )是个不错的主意。

    在Python中,用方括号([] )来表示列表,并用逗号来分隔其中的元素。

    names = ["liu de hua","li jian","zhou jie lun","xietingfeng"]

     

     4.1 访问列表元素

    列表类似于javascript中的数组概念,是一个有序集合,因此上要访问列表的任何一个元素只需要将该元素的位置或索引告诉python即可,如下:

    names = ["liu de hua","li jian","zhou jie lun","xietingfeng"]
    # 访问第一个列表值,记住:列表值一般从0开始,在很多编程语言中都是如此
    print(names[0])
    #获取的值是 liu de hua #我们用学习过的title()方法,让他显示更整齐好看,首字母全部大写 print(names[0].title()) #返回的值 Liu De Hua

    4.2  操作列表

      1. 使用append(),在列表末尾添加新的对象

    names = ["liu de hua","li jian","zhou jie lun","xietingfeng"]
    names.append("na ying")
    print(names)
    

      2、清空列表,clear()

    names = ["liu de hua","li jian","zhou jie lun","xietingfeng"]
    names.clear()
    print(names)
    

      3、列表拷贝 copy()

    names = ["liu de hua","li jian","zhou jie lun","xietingfeng"]
    name_2 = names.copy()
    print(name_2)
    

      4、计算元素出现的次数  count()

    names = ["aa","bb","cc","bb","dd","ee","bb"]
    li_name = names.count("bb")
    print(li_name)
    

      5、扩展原列表,参数:可迭代对象(和append的区别在于append只会追加要传入的对像,extend会用迭代方式循环添加传入对像的每个元素)

     

     

       6.根据值获取当前值索引位置(左边优先,找到后就不会找下一个元素了)

      7.在指定索引位置的前面插入元素  insert()

      8.使用 del 用酒删除值,pop()方法删除值,但仍可使用

      

      9、当不知道元素的位置,但知道元素的值,可使用remove()方法删除元素,并可继续使用该值

    转载于:https://www.cnblogs.com/xingfuggz/p/9667418.html

    展开全文
  • 基本数据类型2.1 字符串2.1.1 字符串拼接2.1.2 大小写转换方法2.1.3 删除空白方法2.2 整数2.3 浮点数2.4 字符串与数字的转换 1. 变量 1.1 变量规则 在Python中使用变量时,需要遵守一些规则和指南。违反这些规则将...
  • 本文主要内容: 1. 变量 1.1 变量规则 2. 基本数据类型 ...在Python中使用变量时,需要遵守一些规则和指南。违反这些规则将引发错误,而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。
  • 首先,最重要的,你需要知道,在Python中,变量保存的仅为值的引用,即变量是内存及其地址的抽象 在Python中,变量的存储采用了引用语义的方式,变量在内存之中所存储的仅仅为变量的值所在的内存地址,而非值本身...
  • 文章目录Python-python中常见的数据结构1. 列表1.1 列表常见的方法(函数)1.2 列表可看作堆栈(stack)1.3 列表可看作队列(queue)1.3 列表推导1.4 嵌套列表的使用1.5 del语句2. 元组3. 集合4. 字典4. 字典 Python-...
  • 初学编程的小伙伴都会对于深浅拷贝的用法有些疑问,今天我们就结合python变量存储...预备知识一——python变量及其存储  在详细的了解python中赋值、copy和deepcopy之前,我们还是要花一点时间来了解一
  • 数据存储 化思维导图的软件:mindjet 数据是存在内存里的,32位操作系统最多寻址4G内存,如果我们是8G的内存,相当于浪费内存,而64位的操作系统理论上寻址空间为无穷大,所以现在从32位升级到64位。内存是与CPU进行...
  • Python中使用变量时,需要遵守一些规则和指南。违反这些规则将引发错误,而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。 变量名只能包含 字母 、 数字 和 下划线 。变量名可以 字母 ...
  • Python变量类型 变量存储在内存中的值,这就意味着在创建变量时会在内存中开辟一个空间。 基于变量数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。 因此,变量可以指定不同的数据类型,...
  • python输入输出及变量

    千次阅读 2018-03-04 15:11:00
    2.变量及常量 3.python用户输入 4.Hello,World程序 一、python输出及注释 1.python输出 在python2和python3中的输出均依靠print来实现,不过区别是python2中print为语句而在python3中print为内置函数 ...
  • 变量 变量在程序中能储存计算结果或...Python 变量不需要声明,但变量在使用前必须赋值,赋值后该变量才被创建。Python变量是没有类型的,但变量所指向内存中的对象是有类型的。 示例: name = "Jack" 变量赋值...
  • 在本文中,您将学习各种Python数据结构及其实现方式。 A link to my GitHub repository to access the Jupyter notebook used for this demonstration: 指向我的GitHub存储库的链接,以访问用于此演示的Jupyter...
  • python 数字类型变量及其方法详解

    千次阅读 2016-06-03 15:25:32
    Python数字 数字数据类型用于存储数值。 他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。 当你指定一个值时,Number对象就会被创建: var1 = 1 var2 = 10 您也可以使用del语句删除...
  • 数据处理的过程中,一般都需要进行数据的清洗工作,如数据集是否存在重复、是否存在确实、数据是否具有完整性和一致性、数据中是否存在异常值等。当发现数据中存在如上可能的问题时,都需要有针对性地处理。 本文...
  • python的tuple数据及其操作

    千次阅读 2019-05-23 00:51:24
    元组被称为只读列表,数据可被查询,但不能被修改,类似于列表的切片操作,元组写在小括号里面()元素之前用逗号隔开 对于一些不想被修改的数据,可以用元组来保存。 # 创建元组 1)创建空元组 # 创建空元组...
  • 队列(Queue)的python实现及其应用一、什么是队列二、队列的python实现三、队列的应用 传土豆问题 一、什么是队列 与栈类似,队列本身十分简单,但可以用于解决诸多问题。 **队列是有序集合,添加操作发生在“尾部...
  • Python3对股票数据进行分析

    万次阅读 多人点赞 2019-04-19 10:40:17
    二、股票数据 三、股票数据分析 1、导入股票时间序列数据 2、绘制股票成交量的时间序列图 3、绘制股票收盘价和成交量的时间序列图 3、绘制K线图(蜡烛图) (1)K线图理论 (2)K线图绘制 4、股票指标相关性...
  • python数据类型经典练习题

    千次阅读 2018-09-09 12:54:58
    3. 升序输出所有的不同的数字及其每个数字重复的次数 代码如下: # _*_ coding:utf-8 _*_ import random check_list = [random.randint(20, 100) for i in range(1000)] result_dict = {} for num in ...
  • 关注相关说明文章内容:变量、基本数据类型及其转换作者博客:csdn.cxhit.com www.cxhit.com1. 变量1.1 变量规则在Python中使用变量时,需要遵守一些规则和指南。违反这些规则将引发错误,而指南旨在让你编写的代码...
  • python数据分析模块

    2021-07-22 16:39:09
    python可以做数据分析,主要包括numpy,scipy,pandas,matplotlib,scikit-learn等等诸多强大的模块,在结合上ipython交互工具 ,以及python强大的爬虫数据获取能力,字符串处理能力 NumPy(Numerical Python的简称...
  • Python之pandas:pandas的get_dummies函数简介(将分类变量转为哑变量)及其使用方法之详细攻略 目录 pandas的get_dummies函数简介 pandas.get_dummies()函数代码参数解释 pandas的get_dummies函数的其使用...
  • 索引和获取数据 应用函数到单元格、列、行 分组(Groupby) 汇总表 增减DataFrame的行列 预测离网率 本篇通过分析电信运营商的客户离网率来熟悉Pandas数据探索的常用方法,并构建一个预测客户离网率的简单模型...
  • Python分析泰坦尼克号数据

    千次阅读 2020-10-12 20:35:58
    泰坦尼克号数据分析 分析目的: 分析影响乘客生存的因素 #导入相应的库 import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline 导入数据 网上有很多...
  • Python修炼计划》第二天
  • Python变量理解起来其实很容易,变量是表示(或指向)特定值的名称。 变量可以存储很多不同类型的信息,我们称之为数据类型。 变量的概念基本上和初中代数方程变量是一致的,在计算机程序中,变量不仅可以是数.....
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等)请往我的资源... 000 愉快的开始 ...
  • python 变量的非数字型和集合

    千次阅读 2018-09-02 15:55:31
    python 变量中的非数字型有:str , tuple , dict , list 一、字符串(str) 1.字符串中元素的判定与更改 判断字符串里面的每个元素是否为什么类型 # 一旦有一个元素不满足,就返回False print '123'.isdigit() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,412
精华内容 8,564
关键字:

python删除变量及其数据

python 订阅