python_day2-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_80367128/article/details/136167942

各位同学，大家好，今天是学习python的第二天

在第一天的学习中，了解到计算机和python的一些的基本知识
在第二天的学习中，将进一步的学习相关的概念和代码。

python的六大标准数据类型：

1.数据类型分类:
        ()Number   数字类型 (int float bool complex)
        (2)str   字符串类型
        (3)1ist   列表类型
        (4)tuple   元组类型
        (5)set   集合类型
        (6)dict   字典类型
2.Number数字类型分类:
        int :   整数类型   (正整数0负整数)
        float:   浮点数类型(1普通小数2科学计数法表示的小数例:a = 3e-5 #3e-05)
        boo1:   布尔值类型(真True 和假False)
        complex:   复数类型   (声明复数的2种方法)(复数用作于科学计算中,表示高精度的数据,科学                               家会使用)
3.容器类型分类:五个
        str   "nihao"
        list   [1,2,3]
        tuple (6，7，8)
        set   {'a' ,1,2}
        dict {'a':1,'b' :2}

Number(数字):

1.int:

intvar =100
intvar = 0b110 #二进制整形
intvar = 0o127 #八进制整形
intvar = oxff  #十六进制整形
print(intavar)

#type 获取值的类型
res = type(intvar)    
print(res)    
print(type(intvar)) ---<class 'int'>

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

2.float:

#表达方式1 
floatvar = 3.6
print(floatvar, type(floatvar))

#表达方式2:
科学计数法
floatvar = 5.7e5 #小数点右移5
floatvar = 5.7e-2 # 小数点左移5 
print(floatvar ， type(floatvar))

--<class 'float'>

3.bool

#bool布尔型(True 真的，False 假的) 
boolvar = True 
boolvar = False
print (boolvar，type(boolvar))

--<class 'bool'>

4.complex复数类型

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

#表达方式1:
complexvar =3 +4j complexvar = -3j
print (complexvar，type (complexvar))

#表达方法2:
#complex(实数,虚数)=> 复数
res = complex (3,4)
print(res , type (res))

str（字符串）：

可获取，不可修改，有序

#有引号的就是字符串,单引号,双引号,三引号
#转义字符\+字符
#(1)可以将无意义的字符变得有意义
#(2)可以将有意义的字符变得无意义
#\n : 换行\r\n : 换行    \t : 缩进(水平制表符)    \r : 将\r后面的字符串拉到了当前行的行首

#1.单引号的字符串
strvar = 'Cloud丶雲）
print(strvar，type(strvar) )

#2.双引号的字符串
strvar = "Cloud丶雲")
print(strvar;type(strvar) )

#3.三引号的字符串（可以支持换行效果）
strvar = '''
        Cloud"丶"
         '雲'
        '''
#4.元字符串 
r"字符串"原型化输出字符串
strvar = "D:\nython32_python\tay02" 
strvar = r"D:\nython32_python\tay02"
print(strvar)

# 5.字符串的格式化
gd 整型占位符 gf浮点型占位符8S字符串占位符语法形式:
"字符串" % (值1,值2)
# %d 整型占位符
#%2d 占两位(不够两位拿空格来补位)原字符串具右
#%-2d 占两位(不够两位拿空格来补位)原字符串具左
#%f 浮点型占位符
#%.2f 保留小数点后面两位小数(存在四舍五入的情况,默认保留六位小数)
#s字符串占位符

List（列表类型）：

#"特征:可获取,可修改,有序""

#1.定义一个空列表 
listvar = []
print( listvar ,type(listvar) )
#定义普通列表
listvar = [98,6.9,True,12-90j,"雲"]
#2.获取列表中的元素
#正向索引/逆向索引
listvar =  [98,6.9,True,12-90j,"雲"]    
res = listvar[2] 
res = listvar[-2]
print (res)

#len获取容器类型数据中元素个数
length = len(listvar) 
res = listvar[length-1] 
res = listvar[len(listvar)-1]
print (res)

# python逆向索引的特点，瞬间得到列表中最后一个元素
print(listvar[-1])
# 3.修改列表中的元素
listvar = [98,6.9,True,12-90j,"雲"] 
listvar[3] = "cloud" 
print(listvar)

Tuple(元组):

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

#定义一个元组
tuplevar = ("梦好心","王伟","安晓东","孙坚")
print(tuplevar;type(tuplevar) )
#获取元组中的元素    正向索引/逆向索引
tuplevar = ("梦好心","王伟","安晓东","孙坚")
print(tuplevar[2]) print (tuplevar[-1])
#修改元组中的元素:元组中的值不能修改

#注意点
#逗号才是区分是否是元组的标识符
tuplevar =(8.9,) 
tuplevar =8.1 print (tuplevar)
print (type(tuplevar))

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

set（集合）:

#set 集合类型(交差并补)
#"特点:无序,自动去重.

# 1.集合无序
setvar = {"巨石强森","史泰龙","施瓦辛格","王文"} 
print(setvar; type(setvar))
#获取集合中的元素不可以
#修改集合中的元素不可以

#2.集合自动去重
setvar = {"巨石强森","史泰龙","施瓦辛格","王文","史泰龙","史泰龙","史泰龙"}
print(setvar，type(setvar))

#3.定义一个空集合 
setvar = set()
print(setvar ;type(setvar))

dict（字典类型）:

#键值对存储的数据
#dictvar = {键1:值1，键2:值2，...}
3.6版本之前，完全无序
3.6版本之后，存储的时候，保留了字典定义的字面顺序，在获取内存中的数据时
            重新按照字面顺序做了排序，所以看起来有序，实际上存储时还是无序。

# 1.定义一个字典
dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove" }
print (dictvar，type(dictvar))

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

# 3.修改字典中的值
dictvar["top"] = "the xboy" 
print(dictvar)

# 4.定义空字典 dictvar = {}
print(dictvar，type(dictvar) )

字典的键和集合的值右数据类型上的要求：
(允许的类型范围）不可变的类型: Number(int float complex bool) str tuple
(不允许的类型) 可变的类型 : list set dict
哈希算法的提出是让数据尽量的均匀的在内存中分配，以减少哈希碰撞，提升存储分配的效率
哈希算法一定是无需的散列，所以集合和字典都是无序的
字典的键有要求，值没要求字典的值可以任意换掉，但是键不可以

在同一文件中，变量的缓存机制(python3.6)(了解即可)

无论是变量缓存机制还是小数据池的驻留机制，都是为了节省内存空间，提升代码效率

#1.对于整型而言，-5~正无穷范围内的相同值id一致
var1 = 5 
var2 = 5 
print(id(var1)，id(var2) )

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

#3.布尔值而言,值相同情况下，id一致 
var1 = True
var2 = True
print(id(var1)，id(var2) )
#4.复数在实数+虚数这样的结构中永不相同(只有虚数的情况例外) 
var1 = 4 +5j
var2 = 4 +5j
print(id(var1),id(var2))

#-->容器类型部分
#5.字符串 和空元组相同的情况下，地址相同
var1 = "雲"
var2 = "雲"
var1 = () 
var2 = ()
print(id(var1);id(var2))

# 6.列表，元组，字典，集合无论什么情况 id标识都不同[空元组例外]
var1 = (1,2) 
var2 = (1,2) 
var1 = [1,2,3] 
var2 = [1,2,3]
print(id(var1);id(var2))