python 六大标准数据类型

Posted 2022-06-13 crownyp

Number(int float bool complex)

#int整型(正整数0 负整数)
intvar = 256
print(intvar)

#type获取一个值的类型
res = type(intvar)
print(res)

#二进制整型
intvar = 0b011
print(type(intvar))
print(id(intvar))

#八进制
intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))

#十六进制整型
intvar = 0xff
print(intvar)
print(type(intvar))
print(id(intvar))

int整数和bool等Number内型

#int 整型(正整数0 负整数)
intvar = 256
print(intvar)

#type 获取一个值的类型
res = type(intvar)
print(res)

#id 获取一个值的地址
res = id(intvar)
print(res)

#二进制整数
print('-------二进制---------')
intvar = 0b1010
print(intvar)
print(type(intvar))
print(id(intvar))

#八进制整型
print('-------八进制-------')
intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))

#十六进制整型
print('-------十六进制-------')
intvar = 0xFF
print(intvar)
print(type(intvar))
print(id(intvar))

#(1)float 浮点数 小数
print('---float浮点数小数----')
print('表达方式一')
floatvar = 3.89
print(type(floatvar))
print(id(floatvar))

print('----表达方式二 科学计数法----')
floatvar = 5.6e3
print(floatvar)
print(type(floatvar),id(floatvar))

#(2) bool 布尔型 True 真的 False 假的 只有两个值
boolvar = True
boolvar = False
print(boolvar,type(boolvar))

#(3)complex 复数
'''
complex 复数 实数 + 虚数  4 + 3j
4是实数 3j是虚数
如果有一个数,他的平方等于-1, 那么这个数就是j
表达一个高精度的类型,科学家认为有.
'''

#表达方式一
complexvar = 3-2j
print(complexvar,type(complexvar))

#表达方式二
#complex(实数,虚数)
complexvar = complex(3,-2)
print(complexvar,type(complexvar))

#只有虚数,没有偶实数
complexvar = 4j
print(complexvar,type(complexvar))

list列表str字符串tuple元组类型

# list 列表
'''可获取,可修改,有序'''
#定义空列表
listvar = []
print(listvar,type(listvar))

#正向索引   0  1    2     3      4
listvar = [89,5.78,True,8+3j,"马新建"]
#逆向索引  -5   -4   -3  -2    -1
print(listvar,type(listvar))

#1.获取列表里面的值
res = listvar[1]
print(res)

#获取最后一个值(python特有) res => result
res = listvar[-1]
print(res)

#在其它语言中,不存在逆向索引,比如php(通用写法)
"""
len 获取容器类型数据的长度,元素的总个数
"""
listvar = [89,5.78,True,8+3j,"马新建"]
#先获取总长度,然后减去1,就是最后一个元素的索引下标;
res = len(listvar)
print(res)# 5 5-1 = 4

#获取马新建
res = listvar[res - 1] #listvar[4]
print(res)

#2.修改列表里面的值
listvar[3] = "王青"
print(listvar)

# ###tuple 元组
"""可获取,不可修改,有序"""
tuplevar = ()
print(tuplevar,type(tuplevar))

#逗号是元组的标志性符号,如果想要表达空元组,可以用();
tuplevar = (1,) #不加逗号是整型
print(tuplevar,type(tuplevar))

#可以获取元组当中的值
#              0      1        2        3
tuplevar = ("刘潭","朱红霞","麦杰康","张哲浩")
#             -4     -3       -2       -1
print(tuplevar,type(tuplevar))
print(tuplevar[-1])

#可以修改元组中的值? 错误 不能修改
#tuplevar[0] = "轴承钢"  error

# ###str字符串
"""可获取,不可修改,有序"""

#可以获取
#
strvar = "黑夜给我了黑色的眼睛,但是我却用它翻白眼"
#
res = strvar[1]
print(res)
res = strvar[-2]
print(res)

#可以修改? 不可以
#strvar[0] = "白" #error

set集合和dict字典

#  ###set 集合类型 作用:用做交差并补操作;
"""无序,自动去重"""
#小团体
setvar = "易烊千玺","王源","蔡徐坤","王文"
print(setvar)

#是否可以获取集合中的值? 不可以
#print(setvar[0]) error

#是否可以设置集合中的值? 不可以
#setvar[0] = 1 error

#是否可以自动去重
setvar = "易烊千玺","王源","蔡徐坤","王文","王源","王源"
print(setvar)

#如何定义一个空集合?
setvar =  #这样定义是空字典
print(setvar)

#定义一个空集合
setvar = set()
print(setvar,type(setvar))

#  ### dict 字典类型
"""由键值对进行数据存储"""
"""
语法:
dictvar = "键1":"值1","键2":"值2"
由键值对存储数据,
左边是键,右边是只,键值之间用冒号隔开.
键值对之间用逗号,隔开

    3.6版本之前都是 字典和集合都是无序的
    3.6版本之后都是 字典和集合看似有序其实无序,
    根据字母顺序重新排序,所以看起来像有序,但本质上无序
"""
dictvar = "top":"程咬金","middle":"妲己","bottom":"后裔","jungle":"李白","support":"蔡文姬"
print(dictvar,type(dictvar))

#获取字典当中的值:
res = dictvar
print(res)

#修改字典中的值
dictvar['bottom'] = "小短腿"
print(dictvar)

#  ###字典当中的键和集合当中的值 底层都是通过哈希算法 算出来的
"但凡使用了哈希算法,那么这个数据就是散列无序,因为要把数字均匀的分布存储在内存当中,减少哈希碰撞"
"""
可哈希数据:
可哈希数据(不可变的数据):Number(int float bool complex) str tuple
不可哈希的数据(可变的数据): list set dict
"""
#如下定义字典的语法是允许的,大是不要使用,定义字典的键,一般按照变量命名的方式定义一个字符串
dictvar = 1:1,3.89:2,False:89,3+5j:"aaa","你好":123,(1,2,3):999000
print(dictvar)

#集合的值也必须可哈希(不可变数据)
'''但凡是不可哈希的数据都不能作为集合的值'''
#setvar = 1,9,"abc",(1,2,3),[1,2,3] error
#setvar = 1,9,"abc",(1,2,3,[1,2,3]) error
print(setvar)

字符串数据类型

#字符串
""" 用引号引起来的就是字符串 '' "" ''' '''"""
"""
#转义字符: \ + 某个字符
将有意义的字符变得无意义
将无意义的字符边得有意义

\n ,\r\n 换行
\t 缩进 水平制表符
\r 将\r后面的字符直接拉到当前行首
"""

#(1)单引号字符串
strvar = '今天教室里很热'
print(strvar,type(strvar))

#(2)双引号字符串
strvar = '小楼昨夜\n又东风'
strvar = '故国不堪回首\r\n明月中'
strvar = '故国不堪回首\t明月中'
strvar = '故国不堪回首\r明月中'
strvar = '故国不堪\n回首\r明月中'
#将有意义的双引号变得无意义,如果外面是双引号,里面就单引号,于注释嵌套一样
stavar = '故国不堪"回首"\'明\'月中'
print(strvar)

#(3)三引号字符串(支持跨行操作)
strvar = """
本来无一物,
何处惹尘埃.
"""

strvar = '''
床前明月光,
一时地下爽.
'''
print(strvar,type(strvar))

#(4)元字符串 r"字符串" 不转义字符,原型化输出字符串
strvar = r"C:\Users\35756\Desktop\day2\assets"
print(strvar)

#(5)格式化字符串
"""
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
"字符串"% (赋值1,赋值2,......)
"""
#%d 整型占位符
strvar = "xxx昨天晚上买了%d个娃娃"
print(strvar)

# %2d 占2位 原字符默认具右
strvar = "陈雄风买了%2d个金油" % (3)
print(strvar)

#$-3d 占3位 原字符默认具左
strvar = "陈雄风买了%-3d个金油" % (4)
print(strvar)

#%f 浮点型占位符 默认小数点保留6位
stavar = "xxx今天开工资,一共发了%f元"% (9.9)
print(strvar)
# %.2f 小数点保留2位
strvar = "xxx今天开工资,一共发了%.2f元"% (9.9)
print(strvar)

# %f 是存在四舍五入的情况
strvar = "xxx今天开工资,一共发了%.1f元"% (9.891)
print(strvar)

#%s 字符串占位符
strvar = "%s" % ("陈翔 和 刘翔只差一个字")
print(strvar)

#综合案例
strvar = "%s 看好了一辆车,布加迪威龙,买了%d辆,一共花了%.2f元,心情%s"% ("卢艳伟",2,20.32,"感觉买了个假车")
print(strvar)

#字符串的格式化存在类型转换(在于清楚类型的时候,直接%s)
strvar = "%s 看好了一辆车,布加迪威龙,买了%s辆,一共花了%s元,心情%s"% ("卢艳伟",2,20.32,"感觉买了个假车")
print(strvar)

自动类型转换

# ###自动类型转换 Number (int float bool complex)
"""
精度从第到高  顺序 bool < int <float <complex
自动类型转换,默认从第到高,依次转化
"""

#1.bool + int阿
"""
bool True => 1
bool Fasle => 0
"""
res = True + 20
print(res) #21

#2.bool + float
res = False + 5.7
print(res)

#3.bool + complex
res = True + 3+2j
print(res)

#4. int + float
res = 30 + 40.78
print(res)

#5.int + complex
res = 2 + 90-100j
print(res)

#6 float + complex
res = 3.67 + 4+78j
print(res)

变量的缓存机制

#  ### 变量的缓存机制(同一个文件内存,只对python3.6版本之前负责;)
# -->Number 部分
"""
1.对于整型而言,-5~正无穷范围内的相同值id一致
2.对于浮点数而言,非负数范围内的相同值id 一致
3.布尔值而言,值相同情况,id 一致
4.复数在实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
"""
#1.对于整型而言,-5~正无穷范围内的相同值id一致
var1 = -257
var2 = -257
print(id(var1),id(var2))

#2.对于浮点数而言,非负数范围内的相同值id一致
var1 = 5.78
var2 = 5.78
var1 = -5.78
var2 = -5.78
print(id(var1),id(var2))

#3.布尔值而言,值相同情况下,id一致
var1 = True
var2 = True
print(id(var1),id(var2))

#4.复数在,实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
var1 = 4 + 3j
var2 = 4 + 3j
print(id(var1),id(var2))
var1 = 7j
var2 = 7j
print(id(var1),id(var2))
var1 = 4
var2 = 4
print(id(var1),id(var2))

#容器类型部分
#5 字符串和空元组 相同的情况下,地址相同
var1 = "我"
var2 = "我"
var1 = ()
var2 = ()
print(id(var1),id(var2))
print(type(var1),type(var2))

#6.列表,元组,字典,集合无论什么情况id标识都不同(空元组例外)
var1 = "a":1,"b":2
var2 = "a":1,"b":2
var1 = 
var2 = 
print(id(var1),id(var2))