在py里面变量是没有类型的 而对象是存放数据的 所以对象是有类型的

先创建一个对象 在创建一个变量 由变量引用这个对象 变量存放这指针 而对象是一块内存

共享引用

列表 存储形态不一样所以和整形浮点型 字符不一样

【】是列表

任务4、动态类型简介

　在python中，省去了变量声明的过程，在引用变量时，往往一个简单的赋值语句就同时完成了，声明变量类型，变量定义和关联的过程，那么python的变量到底是怎样完成定义的呢？

动态类型

　　python使用动态类型和他提供的多态性来提供python语言的简洁灵活的基础。在python中我们是不会声明所使用对象的确切类型的。所谓的python动态类型，就是在程序运行的过程中自动决定对象的类型。

对象、变量和引用

当我们在赋值一个变量时，在python中其实自动做了很多事情。

　　1.创建变量：当代码第一次赋值给一个变量时就创建了这个变量，在之后的赋值过程关联值，python在代码运行之前先检验变量名，可以当成是最初的赋值创建变量。

　　2.变量声明：python中类型只存在于对象中，而不是变量，变量是通用的，他只是在程序的某一段时间引用了某种类型的对象而已，比如定义a =1 ，a = 'a'，一开始定义了变量a为指向了整型的对象，然后变量又指向了字符串类型的变量，可见，变量是不固定的类型。

　　3.变量使用：变量出现在表达式中就会马上被对象所取代，无论对象是什么内类型，变量在使用前必须要先定义。

　　值得注意的是，变量必须在初始化名字之后才能更新他们，比如计数器初始化为0，然后才能增加他。

　　也就是说，当我们给变量赋值的时候，比如a=3，python执行三个不同操作去完成赋值。

　　1.创建一个对象代表3，

　　2.如果程序中没有变量a，则创建他。

　　3.将变量与对象3连接起来。

　　变量与对象是连接关系，它们存储在内存的不同位置，如果有列表嵌套这样大的对象，对象还连接到它包含的对象。这种从变量到对象的连接称为引用。

变量的引用以内存中的指针形式实现。一旦变量被使用，那么python自动跟变量的对象连接。具体来说：

　　1.变量是系统表的元素，他指向对象存放的地址空间。

　　2.对象是分配的一块内存，地址可被连接，有足够大空间代表对象的值，

　　3.引用的过程自动完成变量指向对象地址的过程，即从变量到对象的指针。

　　对象的垃圾回收

　　每个对象都有两个标准头部信息，一个是类型标志符，用于标记对象类型，另一个是引用计数器，用来决定是不是可回收对象。很显然，在python中只有对象才有类别区分，变量不过是引用了对象，变量并不具有类别区分，他只是在特定时间引用某个特定对象。

　　对于引用计数器的使用，则关联到python的垃圾回收机制，当当一个变量名赋予了一个新的对象，那么之前旧的对象占用的地址空间就会被回收。旧对象的空间自动放入内存空间池，等待后来的对象使用。

　　计数器在垃圾回收的过程中有事如何工作的呢？计数器记录的是当前指向对象的引用数目，如果在某时刻计数器设置为0，则表示未被引用，name这个对象的内存空间就会收回。

　　对象的垃圾回收有着很大的意义，这使得我们在python中任意使用对象而且不需要考虑释放空间，省去了C与C++中大量的基础代码。

在Python中先创建一个对象，然后再将变量指向所创建的对象。

对于每个对象，都有一个头部信息，在信息中就标记了这个对象的类型信息。每当一个变量名被赋予了一个新的对象，之前那个对象占用的空间就回被回收（如果此时这个对象没有被别的变量名或者对象所引用的话）。另外，在python中，每个对象都保有一个计数器，计数器中记录了这个对象被引用的次数，当这个计数器被置为0时，对象所占用的内存空间就会被释放，即当做垃圾回收。

共享引用：

在python中，变量总是一个指向对象的指针，而不是可以改变的内存区域标签。给一个变量赋予一个新的值，不是替换了原始的对象，而是让这个变量去引用一个新的对象，实际效果就是对变量重新赋值，这仅仅会影响到那个被重新赋值的变量。

另外，在这里说一下 “ == ”和“ is ”这个操作符

==，和C语言中的作用是一样的，测试两个被引用的对象的值是否一致；

is，检查两个对象的同一性，判断两个对象名是否指向同一地址空间，如果是则返回True。

Python的类型与运算-动态类型简介

变量、对象、引用、共享引用。

    变量：在Python里，不像别的一些语言，需要声明变量类型。因为在Python里变量没有类型。

    变量是存放指针的，因此变量没有类型。
    对象是存放数据的，所以对象有类型之说。

    对象回收：因为对象是独立于变量的，当不再使用的时候是得回收的。

    在Python里两个变量可以共享一个对象，这个叫做共享引用。

    == 表示测试两个值是否相等。

    is 表示两个值是否是同一对象。

    在Python里多个变量引用同一整数，字符串的时候，会引用同一对象。但是其他时候，在Python里给两个变量赋予同样值的对象，其对象不是共用的。

    需要了解一个对象被引用多少次，可以使用如下函数来查看：
    import sys
    sys.getrefcount(1)

is 判断值是否相等

变量没有类型，对象有类型

Python里变量没有类型

变量 ——引用 ——对象

import sys

sys.getrefcount（X）某变量被引用的次数

变量：一个系统表的元素，拥有指向对象的连接的空间

对象：分配的一块内存，有足够的空间去表示他们所代表的值

引用：自动形成的从变量到对象的指针

变量是存放指针的，因此变量没有类型

对象是存放数据的，所以对象有类型之说

因为对象是独立于变量的，当不再使用的时候是需要回收的

在python中两个变量可以共享一个对象，这个叫做共享引用 a=3  b=a  这个时候a跟b是共享对象3的

当a赋另一个值的时候，就会创建一个对象，a变量会引用新对象，而不是改变对象

==表示测试两个值是否相等

is表示两个值是否是同一对象

变量是没有类型的，赋值时可以取代，会回收

对象有指向类型的指针

‘’和“”一样

【】列表

list=[1,2,3]

list[0]=24,1变为24

list2=list[:]复制，不是共享

is表示是不是同一对象

a=1 b=1.0 a is b为false

浮点数a=3.14 b=3.14 a is b为true

但是a=‘one’b='one' 为true

import sys

sys.getrefcount(1)本身就引用一次

很少的都是3

Python中变量无类型

变量：一个系统表的元素，拥有指向对象的连接空间

对象：分配的一块内存，有足够的空间去表示他们所代表的值

引用：自动形成的从变量到对象的指针

对象的回收：因为对象是独立于变量的，当不再使用时回收。即a=3  再次赋值（a=3）时，对象3回收0.

共享引用：

当两个变量相互赋值（a=b）时，b的引用赋给了a,这时a与b共享了对象3.；当共享引用时，用了类似a+=2等等操作是会创造新的对象和引用。

列表的共享引用：                      List1=[1,2,3]                            List2=List1(共享引用)【改变List1的值会影响到List2的值】                          List2=List1[:]（复制列表）【改变List1的值不会影响到List3的值】

is 判断两个对象是否是同一个对象             == 判断两个对象是否相等

import sys                   syssys.getrfcount(元素)可查看元素被使用多少次（不会为零【因为自己也会引用到这个元素】）

==动态语言
静态语言:运行前先编译，运行过程中不能修改
动态语言:直接运行

==动态添加属性及方法
class Person(object):
    def __init__(self,newName,newAge):
        self.name=newName
        self.age=newAge

laowang=Person('laowang',100)
laowang.addr='bj'#对象动态添加属性

Person.num=100 #给类动态添加属性

def run(self):
    print('run')

laowang.run=run
laowang.run(laowang) #在类外部动态添加的方法，需要手动传参

优化：
import types
laowang.run=types.MethodType(run,p1)
laowang.run()

@staticmethod
def test():
    pass
Person.test=test#添加静态方法

@classmethod
def printNum(cls):
    pass
Person.printNum=printNum #添加类方法

==__slots__
由于python是动态语言，可以任意添加属性和方法
那么，有没有一种方法，让实体只能拥有我们定义好的属性呢？
class Person(object):
    __slots__=('name','age')
限制通过Person类创建的任意对象，只能拥有name、age属性
添加其他属性会报错

 python里第一次赋值给一个变量时，变量就被创建了。且在python里变量没有类型（变量是存放指针的，对象存放数据，所以变量没有类型而对象有类型之说）

对象的回收：对象独立于变量， 当不再使用时需要回收。

在python里两个变量可以共享一个对象（共享引用）

例如：a=3   b=a

列表的共享引用

list1=[1,2,3]

list2=list1  //将list1的指针赋值给list2

list[0]=24  //将list1中的第一个元素更改为24

复制列表

list1=[1,2,3]

list2=list1[:]  //复制list1中的引用对象，把对象引用到list2

a = 3：模型

创建一个int类型的对象 3 ；还创建一个变量 a；

a 引用 3 那个对象；a:存放的是引用对象的指针

自动回收机制

list[ x : y : z ] :

  x : 起始元素

  y : 终止元素

  z : 间隔

共享引用 ：

  list2 = list1    list1 and list2 表示同一个对象

相等 ：

  list2 = list1[ : ]     将 list1 复制给 list2

1、变量：在python中变量没有类型，当第一次赋值给一个变量的时候，变量就会自动创建。

    变量：一个系统表的元素，拥有指向对象的连接的空间。（存储的是对象的一个指针。）

    对象：分配的一块内存，有足够的空间去表示他们所代表的值。

    引用：自动形成的从变量到对象的指针。

    对象的回收：因为对象是独立于变量的，当不再使用的时候得回收。

a=3

a=’Three’    #回收整数3

a=[1,2,34]   #回收字符串’Three’

    第二次引用（赋值）后，当没有别得变量引用对象3的话，3就会被回收，以此类推。

使用函数来查看对象被引用的次数：

     import sys

     Sys.getrefcount(1) #结果比较大是因为在很多内部函数里会使用值为1的对象，而且，当使用这个函数的时候，这个函数就调用其本身，所以最终结果不可能为0.