01Python变量的数据类型 Jil

为何变量值要区分类型呢?

''' 
   变量值是用来记录事物状态的，而事物的
状态是各种各样的，所以对应着就应该用不同
类型的值去记录这些状态
'''

一、 变量的使用：

#1、变量基本使用
# 原则：先定义，后引用
name = 'egon'  # 定义-》存
print(name)  # 引用-》取

age = 18
print(age)

# 2、内存管理：垃圾回收机制
# 垃圾：当一个变量值被绑定的变量名的个数为0时，该变量值无法被访问到，称之为垃圾
# 引用计数增加
x = 10  # 10的引用计数为1
y = x  # 10的引用计数为2
z = x  # 10的引用计数为3

# 引用计数减少
del x  # 解除变量名x与值10的绑定关系，10的引用计数变为2
print(y)
del y  # 10的引用计数变为1
print(z)
z = 12345  # # 10的引用计数变为0
print(z)

# 4、变量名的命名风格
# 4.1 纯小写加下划线的方式(在python中，关于变量名的命名推荐使用这种方式)
age_of_alex = 73
# print(age_of_alex)
# 4.2 驼峰体
AgeOfAlex = 73
# print(AgeOfAlex)


# 5、变量值三个重要的特征
name='egon'
# id：反映的是变量值的内存地址，内存地址不同id则不同
print(id(name))
# type：不同类型的值用来表示记录不同的状态
print(type(name))
# value：值本身
print(name)

 二、变量的类型

1、字符串类型

#作用：记录描述性质的状态
#定义：在''、""、''''''、""""""中包含一串字符

#单行字符串''、""
　　msg = "hello world"
　　name = 'jil'
#多行字符串''''''、""""""
　　msg_n = """aaa
　　bbb
　　ccc
　　"""
#外层用单引号，内层就用双引号
　　info = 'my name is "jil"'

其他使用：
# 字符串的嵌套，注意：外层用单引号，内存应该用双引号，反之亦然
# print("my name is 'egon'")
# print('my name is \'egon\'')

# 字符串之间可以相加，但仅限于str与str之间进行，
# 代表字符串的拼接，了解即可，不推荐使用，因为str之间的
# 相加效率极低
# print('my name is '+'egon')
# print('='*20)
# print('hello world')
# print('='*20)

2、整型

# 作用：年龄、号码
# 定义方式：
　　age = 18
　　age ="d"
　　print(age)

小整数池概念：

#小整数池（python内置）：
#从python解释器启动那一刻开始，就会在内存中事先申请一系列内存空间存放好常用的整数
#Python 对小整数的定义是 [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收
'''
>>> x = 15      
>>> y = 15      
>>> z = 15      
>>> id(x)
140713836857440
>>> id(y)
140713836857440
>>> id(z)
140713836857440
'''
#字符串的复用机制（python内置）：
#intern机制处理空格。一个单词的复用机会大，所以创建一次，有空格创建多次，但是字符串长度大于20，就不是创建一次了。
'''
>>> a = "abc"
>>> b = "abc"
>>> id(a)
2286173418736
>>> id(b)
2286173418736
>>>
'''
# id不同的情况下，值有可能相同，即两块不同的内存空间里可以存相同的值
# 若有空格，则使用新的内存空间
# 若超过小整数池范围，则使用新的内存空间
'''

3、浮点型

# 作用：记录身高、薪资、体重
# 定义方式：
　　salary = 3.1
　　height = 1.75

数字类型的其他使用：

level = 1
level=level + 1
print(level)
print(10 *3)

print(10 + 3.3) # int与float之间可以相加
age = 19
print(age > 18)

4、列表（存多个值，索引对应值，索引代表的是位置）

#作用：按照顺序存放多个值，并且可以按照顺序取出指定位置的值
# 定义：在[]内，用逗号分隔开多个任意类型的值
　　l = ['AAA', 10, 11.2, ['bbb', 'ccc']]

列表的取值方式：

#索引从0开始
　　print(l[0]) #相当于print(['AAA', 10, 11.2, ['bbb', 'ccc']][0])
#反向取：
　　print(l[-1])
#嵌套取值
　　print(l[3][1])

列表类型应用案例：

#记录班级人员的姓名
　　school_name =["李三","张大牛","李亮"]
　　print(school_name[1])

5、字典类型（存多个值，key对应值，通常情况下key对值具有描述性功能，key通常是字符串类型）

#定义：{}，逗号分隔开多个key：value的元素
　　dic = {'xxx':111, 'yyy':222}
　　print(dic['xxx'])
　　print(dic['yyy'])

字典类型应用案例：

info = {"name":'jil',
        'age':18,
        "sex":"male",
        "salary":1.75}
print(info['name'])

 字典类型的错误使用及避免措施：

#此处要注意，key应唯一，若重复，将保留后一个,前一个被覆盖。
# 若字典取值，使用中括号方式，括号中的key不存在，则报错
　　dic1 = {'name':"jil", "name":"fishball"}
　　print(dic1)
　　print(dic1["name"])

# 若字典取值，使用中括号方式，括号中的key不存在，则报错。
# 若不想报错，则使用dic.get(key)函数，若不存在会返回NONE
　　#print(dic1["p"])　　　　　#结果：报错
　　print(dic.get("sex"))　　 #结果：NONE
#不过.get()函数只用于取值，并不能用于运算、赋值

6、布尔类型

# 6.1 作用
# 用来记录真假这两种状态


# 6.2 定义
is_ok = True
is_ok = False
print(type(is_ok))

x=1
y=0

#除了0，None,空 为False，其他状态均为True

三、不可变与可变数据类型

1、可变不可变类型

可变类型：值改变，id不变，证明改的是原值，证明原值是可以被改变的
         （有整型int、浮点型float、字符串型string和元组tuple）

不可变类型：值改变，id也变了，证明是产生新的值，压根没有改变原值，证明原值是不可以被修改的
           （有列表list和字典dict）
python中，只要是赋值，就会产生新的内存空间与变量名绑定。

2、代码验证

# 2.1 int是不可变类型
x=10
print(id(x))            #140720528082880
x=11                    # 产生新值
print(id(x))            #140720528082912

"""
>>> x = 777
>>> print(id(x))
2717233150800
>>> x = 777
>>> print(id(x))
2717233150928
>>> x = 777
>>> print(id(x))
2717233150864
>>> x = 777
>>> print(id(x))
2717233150800
>>> x = 777
>>> print(id(x))
2717233150928
>>> x = 777
>>> print(id(x))
2717233150864

每次赋值都会有一个新的内存地址绑定给变量x
不过python自带的优化会将重复使用的值标记，沿用之前的路径，这是一种内存优化机制，涉及底层。
"""

# 2.2 float是不可变类型
x=3.1
print(id(x))            #1411254741008
x=3.2
print(id(x))            #1411225256944

# 2.3 str是不可变类型
x="abc"
print(id(x))            #1411254415024
x='gggg'
print(id(x))            #1411254640752

# 小结：int、float、str都被设计成了不可分割的整体，不能够被改变
# python中，只要是赋值，就会产生新的内存空间与变量名绑定。

# 2.4 list是可变类型
l=['aaa','bbb','ccc']
print(id(l))            #1411225025408
l=['aaa','bbb','ccc']   # python中，只要是赋值，就会产生新的内存空间与变量名绑定
print(id(l))            #1411254651136

l[0]='AAA'              # 修改间接引用的值，不会改变原列表类型的id
print(l)                #['AAA', 'bbb', 'ccc']
print(id(l))            #1411254651136
l.append("ddd")         # 增加列表元素，也不会改变原列表类型的id
print(l)                #['AAA', 'bbb', 'ccc', 'ddd']
print(id(l))            #1411254651136


# 2.5 dict是可变类型
dic={'k1':111,'k2':222}
print(id(dic))          #1411254589824
dic={'k1':111,'k2':222} # python中，只要是赋值，就会产生新的内存空间与变量名绑定。
print(id(dic))          #1411254590208
dic['k1']=3333333333    # 修改间接引用的值，不会改变原容器类型的id
# print(dic)
print(id(dic))          #1411254590208
dic["k3"] = 333         #增加字典元素也不会改变原字典类型的id
print(dic)              #{'k1': 3333333333, 'k2': 222, 'k3': 333}
print(id(dic))          #1411254590208


#2.6 bool不可变

'''
 关于字典补充：
 定义：{}内用逗号分隔开多key:value,
           其中value可以是任意类型
           但是key必须是不可变类型
'''
# dic={[1,2,3]:33333333}    错误！