day2. 六大基本数据类型简介

一、基本数据类型

 Number   数字类型 (int  float  bool  complex)
 str        字符串类型
 list        列表类型
 tuple    元组类型
 set        集合类型
 dict        字典类型 

二、Number类型

1、int整形

Number类型

2、float浮点型

# (1) float 浮点型 小数
# 表达方式1
floatvar = 4.88
print(floatvar)
print( type(floatvar) )

# 表达方式2 科学计数法
floatvar = 6.7e4
print(floatvar)
print( type(floatvar) )

浮点型

3、bool布尔型

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

布尔型

4、complex复数

"""
complex  实数 + 虚数
3+4j
3:  实数
4j: 虚数
j: 如果有一个数,他的平方等于-1,那么这个数就是j,表达的是高精度的类型;(科学家认为有)
"""
# 表达方式一
complexvar = 56-3j
complexvar = -3j
print( complexvar )
print( type(complexvar) )

# 表达方式二
# 语法  : complex(实数,虚数)
complexvar = complex(56,-3)
print( complexvar )
print( type(complexvar) )

复数

三、字符串类型

1、定义

 用引号引起来的就是字符串

2、转义字符  \

 转义字符: \ + 某个字符
     (1) 将有意义的字符变得无意义
     (2) 将无意义的字符变得有意义

 \n,\r\n:  换行
 \t: tab缩进
 \r: 将后面的字符直接拉到当前行行首

3、单双三引号引起来的字符串

# (1) 单引号引起来的字符串
strvar = 'kxq'
print(strvar)
print(type(strvar))

# (2) 双引号引起来的字符串
# 将无意义的字符变得有意义
strvar = "将无意义的\n字符变得有意义"
strvar = "将无意义的\r\n字符变得有意义"
strvar = "将无意义的\t字符变得有意义"
strvar = "将无意义的\n字符\r变得有意义"

# 将有意义的字符变得无意义
strvar = "将无意义的\"字符\"变得有意义"
print(strvar)
print(type(strvar))

# (3) 三引号引起来的字符串 ''' """ (支持跨行)
strvar = """
fdsfad
dagdfs
"""
print(strvar)
print(type(strvar))

引起来的字符串

4、元字符

# 元字符 r"字符串" 不转义字符,原型化输出字符串
strvar = r"E:\python31期\day2"
print(strvar)
print(type(strvar))

5、格式化字符串

"""
语法: "字符串%s%s%s" %(值1,值2,值3)
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
"""

# %d 整型占位符
strvar = "%d" % (5)
print(strvar)

# %2d 占两位 原字符串默认居右 只有小于两位采用空格补
strvar = "%2d" % (5)
print(strvar)

# %-2d 占两位 原字符串默认居左
strvar = "%-2d发发发" % (5)
print(strvar)

# %f 浮点型占位符
strvar = "%f" % (1.1)
print(strvar)

# %.2f 小数点保留2位
strvar = "%2f" % (1.1)
print(strvar)

# %f 存在四舍五入的情况
strvar = "%2f" % (1.5863423)
print(strvar)

# %s 字符串占位符
strvar = "%s" % ("fdassssdfas")
print(strvar)

# 无论%d %f 都可以用 %s 占位符进行取代

格式化

容器类型数据 (str list tuple dict)

四、list列表

1、列表的特点

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

2、定义列表

# 定义一个空列表
listvar = []
print(listvar, type(listvar))

3、获取列表值

# 正向下标索引 从0 开始

listvar = [100, 19.123, True, 3+4j, "kxq"]

# 逆向下标索引 -5 -4     -4    -2     -1
print(listvar, type(listvar))

# 1.获取列表当中的值
res = listvar[2]
res = listvar[-3]
print(res)

# 获取列表当中最后一个元素
# python 特有
print(listvar[-1])

"""
len 获取容器类型数据的长度(元素的总个数)
"""
res = len(listvar)
print(res)

res = listvar[res - 1]
print(res)

# 简写
print(listvar[len(listvar) - 1])

取值

4、修改列表中的元素

listvar[-3] = False
print(listvar)

修改

五、元组tuple

1、元组的特点

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

2、定义元组

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

3、获取元组值

# 正向下标索引 从0 开始
tuplevar =     ("top","jack","jj","GG")

# 1.获取元组当中的元素
res = tuplevar[1]
res = tuplevar[-1]
print(res)

# tuplevar[0] = "aaa" 错 不能修改元组中的值

# 3.判定元组的类型
"""逗号才是区分是否是元组的标识符"""
tuplevar = (123,)
tuplevar = 123,
print(tuplevar, type(tuplevar))

取值

对于str字符串

 特征: 可获取,不可修改,有序

获取某一字符

#          0 1 2 3 4 5 6 7 8
strvar = "发生财的方式,银行"
#         -9    -6    -3  -1

# 1.可以通过下标获取字符串当中的元素
res = strvar[1]
res = strvar[-8]
print(res)
strvar[-2] = "很" #错, 不能修改字符串中的元素

六、set集合

1、作用及特点

 作用:集合之间的交差并补
 特点: 无序,自动去重

2、集合的定义

# 定义一个集合
setvar = {"top","jack","jj","GG"}
print(setvar, type(setvar))

# 定义一个空集合
# setvar = {} 错 类型是字典了
setvar = set()
print(setvar, type(setvar))

3、集合无序

 获取集合中的元素可以么? 不可以!
 res = setvar[3] 错误
 修改集合中的元素可以么? 不可以!
 setvar[0] = "" 错误

4、自动去重

# 自动去重
setvar = {"top","jack","jj","GG","GG","GG","GG"}
print(setvar)

七、字典

1、特点

 特点: 键值对存储的数据,表面上有序,实际上无序
 语法: { 键1:值1 , 键2:值2 ..... }

2、字典的定义

# 1.定义一个空字典
dictvar = {}
print(dictvar , type(dictvar))

# 2.定义一个字典
dictvar = {"name":"kxq","age":"","passwd":""}
print(dictvar , type(dictvar))

3、获取/修改字典值

# 获取字典中的值
res = dictvar["name"]
print(res)

# 修改字典当中的值
dictvar["passwd"] = ""
print(dictvar)

4、字典的键 和 集合中的值 对数据类型有要求

 字典的键 和 集合中的值 数据类型的要求必须是如下几种:
 如下类型可以: 不可变数据(可哈希的数据类型)
 Number(int , float , bool ,complex), str, tuple

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

 但凡提到哈希算法(hash),都是典型的无序特征
 目的: 为了更加均匀的把数据分配到内存里,底层用的算法类似于取模.

 python3.6版本之后,对字典做了优化,存储数据的时候用哈希算法
 但是在拿出数据的时候,重新按照定义字典时的顺序进行重新排序
 所以看起来有序,实际上无序

要求