day02-Python运维开发基础

 

1. Number 数据类型

 

 

2. 容器数据类型-字符串

 

 

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

# %d   整型占位符
strvar = "邹永玲发型非常憔悴,因为昨天晚上买了%d个充气娃娃" % (3)
print(strvar)
# %2d  占用两位,原字符居右
strvar = "邹永玲发型非常憔悴,因为昨天晚上买了%2d个充气娃娃" % (3)
print(strvar)
# %-2d 占用两位,原字符居左
strvar = "邹永玲发型非常憔悴,因为昨天晚上买了%-2d个充气娃娃" % (3)
print(strvar)


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

# %s 字符串占位符
strvar = "%s" % ("易烊千玺")
print(strvar)

# 在不确定类型的情况下,统一用%s,这里会强制转化成字符串类型;
strvar = "小李买了%s个特斯拉,花了%s元" % (5,9.9)
# %f 存在四舍五入的情况
strvar = "小李买了%d个特斯拉,花了%.1f元" % (5,9.198)
print(strvar)

 

3. 列表、元组、字符串

 

 

 

 

# ### 容器类型数据 list 列表
"""可获取,可修改,有序"""
# 定义一个空列表 
listvar = []
print(listvar)
print( type(listvar) )

# 正向索引  0   1    2     3    4
listvar =  [89,7.56,False,8-9j,"王文"]
# 逆向索引  -5  -4   -3    -2   -1

# (1)获取列表中的值
res = listvar[4]
# 逆向索引可以迅速得到列表当中最后一个元素(python特有)
res = listvar[-1]
print(res)

# 其他语言如何得到列表中最后一个元素? (通用写法)
"""
len 可以获取容器类型数据的长度(元素个数)
"""
res = len(listvar)
print(res) #5
res2 = listvar[res-1]
print(res2)

# (2)修改列表中的值
listvar[1] = "王启军"
print(listvar)

# ### 容器类型数据 tuple 元组
"""可获取,不可修改,有序"""
"""
用逗号,来区分是否是元组,逗号是元组这个数据类型的标识
如果定义一个空元组,可以直接使用().只能是空元组;
"""

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

# 它不是元组
tuplevar = (5-9j)
# 它是元组
tuplevar = (5-9j,)
tuplevar = 1,2,3,4,5
tuplevar = (1,2,3,4,5) # 推荐写法
print(tuplevar , type(tuplevar) )

# (1) 获取元组中的值
# 正向        0      1          2       3
tuplevar = ("王文","王天赐","王天佑","王思聪")
# 逆向       -4     -3        -2       -1

res = tuplevar[2]
res = tuplevar[-1]
print(res)

# (2) 元组不能够修改其中的值
# tuplevar[0] = "周杰伦"  error
# print(tuplevar)


# ### 字符串 str
"""可获取,不可修改,有序"""
# 正向    0  1 2 3 4 5 6
strvar = "我却用它翻白眼"
# 逆向   -7 -6-5-4-3-2-1

# (1) 获取字符串当中的元素
res = strvar[5]
res = strvar[-2]
print(res)

# (2) 是否可以修改字符串当中的元素值?
# strvar[0] = "你" error
# print(strvar)

 

 4. 集合与字典特点

 

 

# ### set 集合类型 作用:做交叉并补操作
"""无序,自动去重"""
setvar = {"周杰伦","李宇春","王文"}
print(setvar)
print(type(setvar))

# 定义一个空集合
print("<=============>")
# setvar = {} 是空字典
setvar = set()
print(setvar)
print(type(setvar))
print("<=============>")

# 集合既不可以获取,有不能够修改
# 是否可以获取集合当中的值? 不可以!
# setvar[0]

# 是否可以修改集合当中的值? 不可以
# setvar[0] = 90

# 集合可以自动去重
setvar = {"周杰伦","林志颖","伍佰","王文","王文"}
print(setvar)

# ### dict 字典类型 
"""由键值对存储的数据,本质上无序,看起来有序"""

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

# 定义一个普通字典
"""
键和值用冒号隔开, 键值对之间用逗号隔开
{ 键1:值1  ,  键2:值2 , 键3:值3 ....  }


    3.6版本之前都是 字典和集合都是无序的
    3.6版本之后,把字典的字面顺序记录下来，当从内存拿数据的时候，
    根据字面顺序重新排序，所以看起来像有序,但本质上无序
"""
dictvar = { "top":"亚瑟" , "middle":"妲己" ,"bottom":"奥巴马","jungle":"荆轲" ,"support":"大乔" }
print(dictvar)
print(type(dictvar))

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

# (2)修改字典当中的值
dictvar["support"] = "蔡文姬"
print(dictvar)



# ### 集合的值 字典的键 需要是可哈希数据

# 哈希算法: 可以均匀的把数据分散在内存当中进行存储的算法;
# 哈希算法要求数据必须可哈希:
"""
可哈希数据:(不可变)
    Number(int float bool complex) str tuple
不可哈希数据:(可变)
    list set dict
"""

# 字典
dictvar = {1:1 , 5.88:"abc" , False: 111 , 7-9j:90,"123456":"aaa" , (1,2,3):"bbb"}
# dictvar = {{"a":1}:43} error 必须可哈希
# print(dictvar)
print(dictvar[(1,2,3)])

# 集合 
setvar = { 1,6.7,False,4-90j,"abc",(1,2,3) }
print(setvar)

 

 5. Number 类型转换与内存缓存机制

 

 

# ### 自动类型转换 Number (int float bool complex)
"""
自动类型转换 : 默认向更高精度转换
默认精度从低到高:
    bool < int < float < complex
"""

# bool + int
res = True + 5
print(res)

# bool + float
res = False + 5.67
print(res)

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

# int + float
res = 5 + 3.14
print(res)

# int + complex
res = 3 + 90-80j
print(res)

# float + complex
res = 5.8 + 89-4j
print(res)

# ### 强制类型转换 Number ( int float bool complex)

var1 = 89
var2 = 5.87
var3 = True
var4 = 4+5j
var5 = "135"

# 1.int 强制转换成整型
res = int(var2)
res = int(var3)
# res = int(var4) error
res = int(var5)
print(res , type(res))


# 2.float 强制转换成浮点型
res = float(var1)
res = float(var3)
res = float(var5)
print(res , type(res))

# 3.complex 强制转换成复数
res = complex(var1) # 89 +0j
res = complex(var2) # 5.87 +0j
res = complex(var3) # 1 + 0j
res = complex(var5) # 135 + 0j
print(res , type(res))


# 4.bool 强制转换成布尔型 True 真的 False 假的
res = bool(None)
print(res)

# 布尔类型为假的十种情况
# 0 0.0 0j False '' () [] set() {} None

# None 是python中的关键字,代表空的,什么也没有,一般用于变量的初始化操作
var = None

"""
# 括号里面不加任何值,可以转换出一个当前数据类型的值
int() float() bool() complex()
"""
var =complex()
print(var)

# ### 内存缓存机制:
"""
# -->Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
"""

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

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

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

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


# -->容器类型部分
"""
5.字符串 和 空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
"""
var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
var1 = [1,2,3]
var2 = [1,2,3]
print( id(var1) ,id(var2) )

 

 

 

 

11