python变量成为数组 python中变量由什么组成

变量与基本数据类型 
        1、变量
            变量的基本使用
            变量的三大组成部分
            变量名命名规范
            变量名命名风格
            变量值的三个特征
                id
                type
                值

            小整数池（了解）

            垃圾回收机制之引用计数

            常量

        2、基本数据类型
            数字类型：int、float
            字符串类型
            列表类型
            字典

一、变量介绍
 

1.什么是变量？

变量就是可以变化的量，量指的是事物的状态，比如人的年龄、性别，游戏角色的等级、金钱等等

2.为什么要有变量？

为了让计算机能够像人一样去记忆事物的某种状态，并且状态是可以发生变化的 详细地说： 程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程

3.如何用变量

变量基本使用

# 原则：先定义，后引用

# 定义-》存

var1 = '变量值'             

   # 引用-》取

print(var1)                                   

score = 1000
print(score)

4.变量有三大组成部分

 I：变量名是指向等号右侧值的内存地址的，用来访问等号右侧的值
II：赋值符号：将变量值的内存地址绑定给变量名
III：变量值：代表记录的事物的状态

5、变量名的命名的规则

原则：变量名的命名应该见名知意
5.1. 变量名只能是 字母、数字或下划线的任意组合
5.2. 变量名的第一个字符不能是数字
5.3. 关键字不能声明为变量名，常用关键字如下
 ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from','global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
age=18
userName='daYing'

ps：不要用拼音，不要用中文，在见名知意的前提下尽可能短
 

 6、变量名的命名风格

6.1 纯小写加下划线的方式(在python中，关于变量名的命名推荐使用这种方式)
age_of_kok = 73
 print(age_of_kok)
 6.2 驼峰体
AgeOfKok = 73
 print(AgeOfKok )

7、变量值三个重要的特征

# name='ssabr'
 # id：反映的是变量值的内存地址，内存地址不同id则不同
 # print(id(name))
 # type：不同类型的值用来表示记录不同的状态
 # print(type(name))
 # value：值本身
 # print(name)# 7.2 is与==
 # is：比较左右两个值身份id是否相等
 # ==：比较左右两个值他们的值是否相等
 '''
 id不同的情况下，值有可能相同，即两块不同的内存空间里可以存相同的值
 id相同的情况下，值一定相同，x is y成立，x == y也必然成立
 >>>
 >>> x='info：koko：18'
 >>> y='info：koko：18'
 >>> print(x,y)
  
 >>> print(id(x),id(y))
 4565819264 4566192176
 >>>
 >>>
 >>>
 >>> x == y
 True
 >>> x is y
 False
 '''# 了解：小整数池[-5,256]
 # 从python解释器启动那一刻开始，就会在内存中事先申请
 # 好一系列内存空间存放好常用的整数
 '''
 >>> m=10
 >>> n=10
 >>> id(m)
 4562619328
 >>> id(n)
 4562619328
 >>>
 >>> res=4+6
 >>> res
 10
 >>> id(res)
 4562619328
 ''''''
 >>> x=-5
 >>> y=-5
 >>> x is y
 True
 >>> x=-6
 >>> y=-6
 >>> x is y
 False
 ''''''
 >>> x='aaa'
 >>> y='aaa'
 >>>
 >>>
 >>> id(x)
 4566200880
 >>> id(y)
 4566200880
 ''''''
 x=-6
 y=-6
 print(id(x))
 print(id(y))
 print(x is y)
 '''

 str是不可变类型 first_name= "mike" print(id(first_name)) first_name = 'james' print(id(first_name))

 8、常量：

# 注意：python语法中没有常量的概念，但是在程序的开发过程中会涉及到常量的概念 AGE_OF_KOK = 23 # 小写字母全为大写代表常量，这只是一种约定、规范 AGE_OF_KOK = 44 print(AGE_OF_KOK)

二、内存管理：垃圾回收机制

python的垃圾回收采用的是引用计数机制为主和分代回收机制为辅的结合机制，当对象的引用计数变为0时，对象将被销毁，除了解释器默认创建的对象外。（默认对象的引用计数永远不会变成0）

所有的计数引用+1的情况：

一.对象被创建:

1.number1 = 52
　　这里52这个对象并没有在内存中新建，因为在Python启动解释器的时候会创建一个小整数池，-5~256之间的这些对象
会被自动创建加载到内存中等待调用；number1  = 52是为52 这个整数对象增加了一个引用。
执行代码：

number1 = 52
import sys 
sys.getrefcount(number1)

结果：52这个整数对象目前有5个引用。也可以直接通过sys.getrefcount(52)，得到这个值被引用的次数

2. class如果对象被创建后没有引用操作，此时的引用计数是0，MyName()本身不是一个引用。

print(sys.getrefcount(MyClass1()))

结果：1

说明：之所以结果为1，是因为sys.getrefcount(MyClass1())函数也算一个引用。

二.对象被引用

number1 = 92320
print(sys.getrefcount(number1))

number2 = number1
number3 = number2
print(sys.getrefcount(number3))

结果：4

说明：每一次赋值和使用都会增加数据操作的引用次数，要记住引用的是变量number1,number2,number3等指向的数据92320，而不是变量本身。

三.对象被作为参数，传入到一个函数中;

# 第一次引用1382048
number  = 1382048
#第二次引用1382048
number2 = number
# 第三次引用1382048
number3 = number2
# 增加了一个引用
print(sys.getrefcount(number2))  # 执行完毕后引用销毁，减少一个引用
# 增加了一个引用
print(sys.getrefcount(number3))

说明：以上代码，赋值操作为数据增加了3个引用，sys.getrefcount(b)也增加了一个引用；

为什么sys.getrefcount(number3)的结果还是4呢？这是因为当函数执行后，作为参数的引用会自动销毁，所以print(sys.getrefcount(number2))在执行完毕后引用就删除了。

四.对象作为一个元素，存储在容器中；

# 增加了一个引用
num1 = 2348942734
# 增加了一个引用
num2 = num1
list = [num1, num2]  # 增加了2个引用
print(sys.getrefcount(num2))

结果：5

python所有对象引用计数被减少1的情况：

一.对象的别名被赋予新的对象;

num1 = 535353  # 增加了一个引用
num2 = num1  # 增加了一个引用
print(sys.getrefcount(num1))
num2 = 3.1544832038920
# 减少了一个23345455整数的引用
print(sys.getrefcount(num1))

结果：3；2

二.对象的别名被显式销毁;

num3 = 12345455  # 增加了一个引用
num4 = num3        # 增加了一个引用
list = [num3 , num4]  # 增加了2个引用
del num3
print(sys.getrefcount(num4))

结果：4

说明：直接使用del关键字或者del()函数；

注意：上述代码手动销毁的是被赋值引用的num3，但是在列表里的num3不会被销毁。

三.一个对象离开它的作用域;

num5 = 3445455  # 增加了一个引用
num6 = num5    # 增加了一个引用
print(sys.getrefcount(num5))  # 执行完毕后引用销毁
print(sys.getrefcount(num6))

结果：3；3

 说明：num5作为参数传递到sys.getrefcount(num5)函数中，只在函数中起作用，一旦执行完毕就会销毁。

四.对象所在的容器被销毁，或从容器中删除对象；

# 增加了一个引用
num7 = 27565455
# 增加了一个引用
num8 = num7
list = [num7, num8]  # 增加了2个引用
del list
print(sys.getrefcount(num8))

结果：3

三、python基本数据类型

基本数据类型
         list
         tuple（不可变的列表）
         dict# 1、作用：按位置存放多个值
 # 2、定义
 # l=[1,1.2,'a'] # l=list([1,1.2,'a'])
 # print(type(l))# 3、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
 # res=list('hello')
 # print(res)
 #
 # res=list({'k1':111,'k2':222,'k3':3333})
 # print(res) # 4、内置方法
 # 优先掌握的操作：
 # 1、按索引存取值(正向存取+反向存取)：即可以取也可以改
 # l=[111,'egon','hello']
 # 正向取
 # print(l[0])
 # 反向取
 # print(l[-1])
 # 可以取也可以改：索引存在则修改对应的值
 # l[0]=222
 # print(l)# 无论是取值操作还是赋值操作：索引不存在则报错
 # l[3]=333 # 2、切片(顾头不顾尾，步长)
 l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
 # print(l[0:3])
 # print(l[0:5:2]) # 0 2 4# print(l[0:len(l)])
 # print(l[:])
 # new_l=l[:] # 切片等同于拷贝行为，而且相当于浅copy
 # print(id(l))
 # print(id(new_l))# l[-1][0]=1111111
 # print(l)
 # print(new_l)# print(l[::-1])
# msg1='hello:egon:<>:18[]==123'
 # msg2=msg1[:]
 # print(msg1,id(msg1))
 # print(msg2,id(msg2))
 # 3、长度
 # print(len([1, 2, 3]))
 # 4、成员运算in和not in
 # print('aaa' in ['aaa', 1, 2])
 # print(1 in ['aaa', 1, 2])
 # 5、往列表中添加值
 # 5.1 追加
 # l=[111,'egon','hello']
 # l.append(3333)
 # l.append(4444)
 # print(l)# 5.2、插入值
 # l=[111,'egon','hello']
 # l.insert(0,'alex')
 # print(l)# 5.3、extend添加值
 # new_l=[1,2,3]
 # l=[111,'egon','hello']
 # l.append(new_l)
 # print(l)# 代码实现
 # for item in new_l:
 #     l.append(item)
 # print(l)# extend实现了上述代码
 # l.extend(new_l)
 # l.extend('abc')
 # print(l) # 7、删除
 # 方式一：通用的删除方法，只是单纯的删除、没有返回值
 # l = [111, 'egon', 'hello']
 # del l[1]
 # x =del l[1] # 抛出异常，不支持赋值语法
 # print(l)# 方式二：l.pop()根据索引删除，会返回删除的值
 # l = [111, 'egon', 'hello']
 # l.pop() # 不指定索引默认删除最后一个
 # l.pop()
 # print(l)# res=l.pop(1)
 # print(l)# print(res)
# 方式三：l.remove()根据元素删除，返回None
 # l = [111, 'egon', [1,2,3],'hello']
 # l.remove([1,2,3])
 # print(l)
 # res=l.remove('egon')
 # print(res) # None # 8、循环
 # l=[1,'aaa','bbb']
 # for x in l:
 #     l.pop(1)
 #     print(x)# 需要掌握操作
 l = [1, 'aaa', 'bbb','aaa','aaa']
 # 1、l.count()
 # print(l.count('aaa'))# 2、l.index()
 # print(l.index('aaa'))
 # print(l.index('aaaaaaaaa')) # 找不到报错# 3、l.clear()
 # l.clear()
 # print(l)# 4、l.reverse():不是排序，就是将列表倒过来
 # l = [1, 'egon','alex','lxx']
 # l.reverse()
 # print(l)# 5、l.sort(): 列表内元素必须是同种类型才可以排序
 # l=[11,-3,9,2,3.1]
 # l.sort() # 默认从小到大排，称之为升序
 # l.sort(reverse=True) # 从大到小排，设置为降序
 # print(l)# l=[11,'a',12]
 # l.sort()# l=['c','e','a']
 # l.sort()
 # print(l)# 了解：字符串可以比大小，按照对应的位置的字符依次pk
 # 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
 # print('a'>'b')
 # print('abz'>'abcdefg')# 了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
 # l1=[1,'abc','zaa']
 # l2=[1,'abc','zb']
 #
 # print(l1 < l2) # 补充
 # 1、队列：FIFO,先进先出
 # l=[]
 # # 入队操作
 # l.append('first')
 # l.append('second')
 # l.append('third')
 #
 # print(l)
 # # 出队操作
 # print(l.pop(0))
 # print(l.pop(0))
 # print(l.pop(0))# 2、堆栈：LIFO,后进先出
 l=[]
 # 入栈操作
 l.append('first')
 l.append('second')
 l.append('third')print(l)
 # 出队操作
 print(l.pop())
 print(l.pop())
 print(l.pop())# 元组就是"一个不可变的列表"
 #1、作用：按照索引/位置存放多个值，只用于读不用于改#2、定义:（）内用逗号分隔开多个任意类型的元素
 # t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
 # print(t,type(t)) # x=(10) # 单独一个括号代表包含的意思
 # print(x,type(x))# t=(10,) # 如果元组中只有一个元素，必须加逗号
 # print(t,type(t))# t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
 # t[0]=11111# t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
 # print(id(t[0]),id(t[1]))
 # # t[0]=111111111 # 不能改
 # # t[1]=222222222 # 不能改
 #
 # t[1][0]=11111111111111111
 # # print(t)
 # print(id(t[0]),id(t[1])) #3、类型转换
 # print(tuple('hello'))
 # print(tuple([1,2,3]))
 # print(tuple({'a1':111,'a2':333}))#4、内置方法
 #优先掌握的操作：
 #1、按索引取值(正向取+反向取)：只能取
 # t=('aa','bbb','cc')
 # print(t[0])
 # print(t[-1])#2、切片(顾头不顾尾，步长)
 # t=('aa','bbb','cc','dd','eee')
 # print(t[0:3])
 # print(t[::-1])#3、长度
 # t=('aa','bbb','cc','dd','eee')
 # print(len(t))
 #4、成员运算in和not in
 # print('aa' in t)#5、循环
 # for x in t:
 #     print(x)#6、
 t=(2,3,111,111,111,111)
 # print(t.index(111))
 # print(t.index(1111111111))print(t.count(111))
#1、作用
#2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是
 #                                   key必须是不可变类型,且不能重复
 # 造字典的方式一：
 # d={'k1':111,(1,2,3):222} # d=dict(...)
 # print(d['k1'])
 # print(d[(1,2,3)])
 # print(type(d))# d={} # 默认定义出来的是空字典
 # print(d,type(d))# 造字典的方式二：
 # d=dict(x=1,y=2,z=3)
 # print(d,type(d)) #3、数据类型转换
 # info=[
 #     ['name','egon'],
 #     ('age',18),
 #     ['gender','male']
 # ]
 # # d={}
 # # for k,v in info: # k,v=['name','egon'],
 # #     d[k]=v
 # # print(d)
 #
 # 造字典的方式三：
 # res=dict(info) # 一行代码搞定上述for循环的工作
 # print(res) # 造字典的方式四:快速初始化一个字典
 # keys=['name','age','gender']
 # # d={}
 # # for k in keys:
 # #     d[k]=None
 # # print(d)
 # d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
 # print(d)#4、内置方法
 #优先掌握的操作：
 #1、按key存取值：可存可取
 # d={'k1':111}
 # 针对赋值操作：key存在，则修改
 # d['k1']=222
 # 针对赋值操作：key不存在，则创建新值
 # d['k2']=3333
 # print(d)#2、长度len
 # d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
 # print(d)
 # print(len(d)) #3、成员运算in和not in:根据key
 # d={'k1':111,'k2':2222}
 # print('k1' in d)
 # print(111 in d)#4、删除
 d={'k1':111,'k2':2222}
 # 4.1 通用删除
 # del d['k1']
 # print(d)# 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值
 # res=d.pop('k2')
 # print(d)
 # print(res)# 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)
 # res=d.popitem()
 # print(d)
 # print(res)#5、键keys()，值values()，键值对items()  =>在python3中得到的是老母鸡
 d={'k1':111,'k2':2222}
 '''
 在python2中
 >>> d={'k1':111,'k2':2222}
 >>> 
 >>> d.keys()#6、循环
 ['k2', 'k1']
 >>> d.values()
 [2222, 111]
 >>> d.items()
 [('k2', 2222), ('k1', 111)]
 >>> dict(d.items())
 {'k2': 2222, 'k1': 111}
 >>>
 '''  #6、for循环
 # for k in d.keys():
 #     print(k)
 #
 # for k in d:
 #     print(k)# for v in d.values():
 #     print(v)# for k,v in d.items():
 #     print(k,v) # print(list(d.keys()))
 # print(list(d.values()))
 # print(list(d.items())) #需要掌握的内置方法
 d={'k1':111}
 #1、d.clear()#2、d.update()
 # d.update({'k2':222,'k3':333,'k1':111111111111111})
 # print(d)#3、d.get() ：根据key取值，容错性好
 # print(d['k2'])  # key不存在则报错# print(d.get('k1')) # 111
 # print(d.get('k2')) # key不存在不报错，返回None#4、d.setdefault()
 # info={}
 # if 'name' in info:
 #     ... # 等同于pass
 # else:
 #     info['name']='egon'
 # print(info)# 4.1 如果key有则不添加,返回字典中key对应的值
 info={'name':'egon'}
 res=info.setdefault('name','egon')
 # print(info)print(res)
# 4.2 如果key没有则添加，返回字典中key对应的值
 info={}
 res=info.setdefault('name','egon')
 # print(info)
 print(res)