python容器数据类型和变量的缓存机制

一 .容器类型(str list tuple set dict)

1.1str(字符串)

转义字符: +字符

1.把有意义的字符变得无意义

2.把无意义的字符变得有意义


 ,
 换行

strvar = "怀才就像怀孕,
时间长了才能让人看出来"

	 缩进

strvar = "怀才就	像	怀孕,时间长了才能让人看出来"


 把
后面的字符串拉到当前行行首

strvar = "怀才就像怀孕,
时间长了才能让人看出来"
# 元字符串 不产生转义,原形化输出字符串

pathvar = r"D:python33视频课件 otepad++"
print(pathvar)

格式化字符串

%d 整型占位符

%s 字符串占位符

%f 浮点型占位符

语法 : "" % (参数1,参数2,参数3)

1.2 list (列表类型)

**********特征:可获取,可获取,可修改**********

# 1.定义空列表
listvar = []
print(listvar , type(listvar))

# 定义普通列表
listvar = [19,6.89,"你好",5-90j]

# 2.获取列表中的元素
# 正向索引 0   1     2      3
listvar = [19,6.89,"你好",5-90j]
# 逆向索引 -4  -3    -2     -1
res = listvar[2] 
res = listvar[-2]  
print(res)

# 3.获取列表中最后一个元素
# 通过逆向索引下标
res = listvar[-1]
print(res)

# 通过len来获取长度
# len 可以获取容器中的元素个数(长度)
res = len(listvar)
print(res)
length = res - 1 # 4 - 1 = 3
res = listvar[length]
# 获取最后一个元素的索引下标 4 - 1
res = listvar[     len(listvar) - 1     ]
print(res)

# 4.修改列表中的元素
listvar = [19,6.89,"你好",5-90j]
listvar[1] = "哈哈哈"
print(listvar)

1.3 tuple (元组类型)

***************特点:可获取,不可修改,有序***************

# 1.定义一个空元组
tuplevar = ()
print(tuplevar , type(tuplevar))

# 定义一个普通元组
# 正向索引    0       1        2         3       4
tuplevar = ("李琦","朱培峰","方金顺","黄昌建","刘文博")
# 逆向索引    -5     -4        -3        -2     -1

# 2.获取元组当中数据
res = tuplevar[3]
print(res)

# 3.修改元组当中的数据? 不可以
# tuplevar[0] = "123" error

# 4.注意点
"""区分是否是元组,由逗号这个标识符来决定"""
tuplevar = ("你好",)
tuplevar = (345,)
tuplevar = (345+5j,)
tuplevar = 1,2
tuplevar = 5,
tuplevar = () # 什么元素都不写,可以表达空元组的概念;
print(tuplevar , type(tuplevar))

1.4 集合(set) 交叉并补

**********************特点:无序,自动去重**********************

# 1.定义一个集合
setvar = {"周杰伦","易烊千玺","王源","王俊凯"}
print(setvar , type(setvar) )

# 2.集合特征: 无序
# 是否可获取集合中的元素? 不行
# print(setvar[0]) error

# 是否可修改集合中的元素? 不行
# setvar[0] = "周润发"

# 3.集合特征: 自动去重
setvar = {"周杰伦","易烊千玺","王源","王俊凯","王文","王文","王文"}
print(setvar)

# 4.注意:定义一个空集合
setvar = set()
print(setvar , type(setvar))

1.5 字典类型 dict

特点
"""
    字典里的数据以键值对的方式进行存储,表面上有序,实际上无序;
    在python3.6版本之后,底层做了优化,存储时,记录了字典的定义顺序
    在获取字典时,把无序存储的数据拿出来,按照定义字典的字面顺序重新排序;
    语法: {键1:值1,键2:值2 , .... }
"""

# 1.定义一个字典
dictvar = {"haq":"胡安庆","llz":"刘灵镇","wsf":"王生福","xhr":"熊海瑞"}
print(dictvar , type(dictvar))

# 2.获取字典中的元素
res = dictvar["llz"]
res = dictvar["xhr"]
print(res)

# 3.修改字典中的元素
dictvar["xhr"] = "小黄人"
print(dictvar)

# 4.注意点
res = {}
print(res, type(res)) # dict

集合和字典注意点:

集合的值和字典的键有数据类型上的要求

允许的数据类型 (可哈希的数据类型,不可变的数局类型): Number(int float bool complex) str tuple

不允许的数据类型(不可哈希的数据类型,可变的数据类型): list,set dict

字典的键和集合的值在底层内存存储时,使用了哈希算法
哈希算法的要求是该数据类型为不可变得数据类型才能够存储
哈希算法特点: 无序的散列;

为什么要提出哈希算法?
为了把数据均匀的存储在内存之后,减少哈希碰撞
让数据更快的存储在内存中.

二 . 变量的缓存机制

首先 --> Number 部分

1.对于整型而言,-5~正无穷范围内的相同值id一致
2.对于浮点数而言,非负数范围内的相同值id一致
3.对于布尔值而言,值相同情况下,id一致
4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况列外)

-->容器类型部分

1) 字符串和空元祖相同的情况下,地址相同

2) 列表,元组,字典,集合无论什么情况 id标识都不同(空元组列外)