老男孩自动化运维开发第1天
目录导航：
采用 # 开头，表示此行为注释行
多行注释采用：连着的3个单引号'''或者连着的3个双引号"""
注释的注意点：
"""
注释的嵌套:
如果外面用了三个双引号,里面用三个单引号
如果外面用三个单引号,里面用三个双引号
"""
变量: 可以改变的量, 实际具体指的是内存的一块空间
rujia_305 = "王文"
rujia_305 = "李四"
print(rujia_305)
a = 1
b = 2
print(a)
print(b)
"""
变量的命名
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
变量命名有意义,且不能使用中文哦
"""
查看关建字：import 引入 keyword 模块 (kwlist 可以得到所有的关键字)
import keyword
res = keyword.kwlist
print(res)
常量: 不能改变的量 (用大写命名一个变量 约定俗成是常量,不要修改)
SHENFENZHENG = "210202200010106688"
print(SHENFENZHENG)
"""
utf-8 国际通过编码集(万国码 ,unicode编码集的升级 utf-8 可变长的unicode 编码集) 一个中文按照3个字节存储, 一个英文或者符号按照1个字节存储
gbk 国标编码集 1个中文按照2个字节存储, 一个英文或者数字符号按照1个字节存储
"""
数值数据类型包含4种：int、float、bool、complex
定义：正整型、0 、负整型
intvar = 13
print(intvar)
# type 获取变量的类型
res = type(intvar)
print(res)
# id 获取变量所指向值的地址
res = id(intvar)
print(res)
整型常用的有二进制、八进制、十六进制，如下：
# 二进制整型 0b
intvar = 0b101
res = type(intvar)
res2 = id(intvar)
print(intvar)
print( res )
print( res2 )
# 八进制整型 0o
intvar = 0o127
print( intvar )
print( type(intvar) )
print( id(intvar) )
# 十六进制整型 0x
intvar = 0xff
print( intvar )
print( type(intvar) )
print( id(intvar) )
# 表达方法一
floatvar = 3.56
print(floatvar)
print(type(floatvar))
print(id(floatvar))
# 表达方式二 (科学计数法)
floatvar = 6.36e-3
print(floatvar)
print(type(floatvar))
print(id(floatvar))
要么是True 真的 要么是False 假的
boolvar = True
print(boolvar , type(boolvar) , id(boolvar))
定义：
"""
实数 + 虚数
4+6j
4 就是实数
6j 就是虚数
如果有一个数,他的平方是-1,那么这个数就是j
科学家认为有,表达的是高精度类型
"""
# 表达方式一
complexvar = 4+3j
complexvar = -6j
print(complexvar , type(complexvar) , id(complexvar) )
# 表达方式二
"""
complex(实数,虚数)
"""
complexvar = complex(4,3)
print(complexvar , type(complexvar) ,id(complexvar))
定义：str 字符串类型 : 用引号引起来的就是字符串
"""
# 转义字符: \ + 字符
(1)把无意义的字符变得有意义
(2)把有意义的字符变得无意义
\n => 换行
\r\n => 换行
\r => 把\r后面的字符串直接拉到当前行行首
\t => 缩进(水平制表符) 一般来讲显示的是4个空格的长度
"""
strvar = '本来无一物,何处惹尘埃'
print(strvar)
print(type(strvar))
# 将无意义的字符变得有意义
strvar = "黑夜给了我黑色的眼睛,\n但是我却用它翻白眼"
strvar = "黑夜给了我黑色的眼睛,\r但是我却用它翻白眼"
strvar = "黑夜给了我黑色的眼睛\n, 但是我却用它\r翻白眼"
strvar = "黑夜给了我\t黑色的眼睛,但是我却用它翻白眼"
# 将有意义的字符变得无意义
strvar = "黑夜给了我\t黑色的\"眼睛\",但是我却用它翻白眼"
strvar = "黑夜给了我\t黑色的'眼睛',但是我却用它翻白眼"
print(strvar,type(strvar))
strvar = """
飞流直下三千尺,
疑是银河落九天
"""
strvar = '''
飞流'直'下三千尺,
疑是"银"河落九天
'''
print(strvar , type(strvar))
r"字符串" : 不转移字符,原型化输出字符串
strvar = r"D:\周末五期\note"
print(strvar,type(strvar))
"""
%d : 整型占位符
%f : 浮点型占位符
%s : 字符串占位符
# 语法:
"字符串" % (值1,值2, ... )
"""
# %d 整型占位符
strvar = "郑飞昨天晚上买了%d个风油精" % (100)
print(strvar)
# %2d 占两位 原字符默认居右
strvar = "郑飞昨天晚上买了%2d个风油精" % (3)
print(strvar)
# %-2d 占两位 原字符默认居左
strvar = "郑飞昨天晚上买了%-2d个风油精" % (3)
print(strvar)
# %f 浮点型占位符
strvar = "李辉今天发工资,一共发了%f元" % (9.9)
print(strvar)
# %.2f 小数点保留两位
strvar = "李辉今天发工资,一共发了%.2f元" % (9.9)
print(strvar)
# %s 字符串占位符
strvar = "%s" % ("吴旭峰很帅,你信么?")
print(strvar)
# 注意点:在不清楚用什么类型做占位的时候,统一用%s进行占位,默认会转化成字符串;
strvar = "%s 买了%s盒巧克力,花了%s元" % ("刘琦",90,9.9)
strvar = "%s 买了%d盒巧克力,花了%.3f元" % ("刘琦",90,9.9)
print(strvar)
容器数据类型有：str、list、tuple、set、dict
list列表特点："""可获取,可修改,有序"""
# 定义一个空列表
listvar = []
print(listvar , type(listvar))
# 定义一个列表
# 正向索引 0 1 2 3 4
listvar = [12,5.78,False,65+7j,"文哥真帅"]
# 逆向索引 -5 -4 -3 -2 -1
# 获取列表当中的元素
res = listvar[4]
res = listvar[-1]
print(res)
# 修改列表当中的元素
listvar[2] = True
print(listvar)
# 逆向索引下标,python特有 [可以瞬间得到列表中最后一个元素]
"""len 获取容器类型数据的元素个数 """
res = len(listvar)
print(res)
res = listvar[res-1] # res-1 =5-1 = 4
print(res)
# 简写
res = listvar[len(listvar) - 1]
print(res)
tuple元组特点："""可获取,不可修改,有序"""
# 定义一个空元组
tuplevar = ()
print(tuplevar,type(tuplevar))
# 逗号用来区分是否是元组的一个标识符
tuplevar = (5+6j,)
print(tuplevar,type(tuplevar))
#正向索引 0 1 2 3 4 5
tuplevar = (1,"a",2,False,3,"c" )
#逆向索引 -6 -5 -4 -3 -2 -1
print(tuplevar,type(tuplevar))
# (1) 获取元组当中的值
res = tuplevar[3]
res = tuplevar[-3]
print(res)
# (2) 是否可以修改元组当中的值
# tuplevar[0] = 100 error
str字符串特点："""可获取,不可修改,有序"""
# 正向索引 0 1 2 3 4 5 6 7 8
strvar = "我爱你,亲爱的祖国"
# 逆向索引 -9-8-7-6-5-4-3-2-1
res = strvar[1]
res = strvar[-8]
print(res)
# 是否可以修改?
# strvar[0] = "你" error
set集合作用：做交叉并补操作，集合特点："""无序,自动去重"""
# 定义一个空集合
setvar = set()
print(setvar,type(setvar))
# 无序
setvar = {"刘德华","郭富城","张学友","王文"}
print(setvar , type(setvar))
# 自动去重
setvar = {"刘德华","郭富城","张学友","王文","王文","王文"}
print(setvar , type(setvar))
# 所谓的无序,既不能获取里面的元素,又不能修改里面的元素
# res = setvar[0]
# setvar[0] = 90
dict字典特点："""键值对存储的数据,3.6之后,表面上有序,本质上无序"""
"""
语法: 键值之间用冒号隔开,键值对之间用逗号隔开
{键1:值1 , 键2:值2 ,键3:值3 .... }
"""
# 定义空字典
dictvar = {}
print(dictvar , type(dictvar))
# 定义一个字典
dictvar = {"top":"夏侯惇" , "middle":"甄姬" , "bottom":"后裔" , "jungle":"娜可露露" , "support" : "蔡文姬" }
print(dictvar , type(dictvar))
# 获取字典当中的元素
res = dictvar["top"]
print(res)
# 修改字典当中的元素
dictvar["bottom"] = "鲁班七号"
print(dictvar)
# ### 为什么无序?
"""
字典的键 和 集合的值 在底层用的是哈希算法;
哈希算法所呈现的数据 是一个散列
哈希算法可以帮助我们把数据均匀的分配在内存中,所有用哈希
哈希算法有要求: 这个数据必须可哈希
可哈希数据: Number(int bool float complex) str tuple
不可哈希数据: list set dict
"""
# 语法上允许,不推荐使用 ,命名字典键的时候,推荐用变量命名的字符串
dictvar = {"123":1 , 90:23 ,7.56:45,False:789,5-9j:"abc","你好":111,(1,2,3,4,5):890}
print(dictvar,type(dictvar))
res = dictvar[(1,2,3,4,5)]
print(res)
# 集合 (只要出现了不可哈希数据,就不行)
# setvar = {1,2,"c","abc",(1,2,3,[5,6,7])} error
自动类型转换 Number ( int float bool complex )
"""
精度类型从低->高
bool < int < float < complex
当两个不同的类型进行运算时,默认向高精度转换
"""
var1 = 3
var2 = 3.67
var3 = True
var4 = 7+2j
# bool + int
res = var3 + var1 # True + 3
print(res)
# bool + float
res = var3 + var2 # True + 3.67
print(res)
# bool + complex
res = var3 + var4 # True + 7+2j
print(res)
# int + float
res = var1 + var2 # 3 + 3.67
print(res)
# int + complex
res = var1 + var4 # 3 + 7+2j
print(res)
# float _ complex
res = var2 + var4 # 3.67 + 7+2j
print(res) # (10.67+2j)
强制类型转换 Number(int float bool complex)
var1 = 56
var2 = 7.87
var3 = False
var4 = 3-6j
var5 = "156"
var6 = "abcd"
# int 强制转换成int类型
res = int(var2) # 7
res = int(var3) # 0
res = int(True) # 1
# res = int(var4) error
res = int(var5) # 156
print(res,type(res))
# float 强制转换成float类型
res = float(var1) # 56.0
res = float(var3) # 0.0
res = float(var5) # 156.0
print(res)
# complex 强制转换成complex类型
res = complex(var1) # 56+0j
res = complex(var2) #(7.87+0j)
res = complex(var3) #0j
res = complex(var5) # (156+0j)
print(res)
# bool 强制转换成bool类型 只有True 和 False 两个结果
res = bool(None)
print(res)
# bool 类型为假的十种情况
# 0 0.0 0j False '' [] () set() {} None
"""
None 是系统的关键字,代表空的,什么也没有,一般用在初始化操作
"""
a = None
"""
# -->Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
"""
# 1.对于整型而言，-5~正无穷范围内的相同值 id一致
var1 = 90
var2 = 90
var1 = -90
var2 = -90
print(id(var1) , id(var2))
# 2.对于浮点数而言，非负数范围内的相同值 id一致
var1 = 5.78
var2 = 5.78
print(id(var1) , id(var2))
# 3.布尔值而言,值相同情况下，id一致
var1 = False
var2 = False
print(id(var1) , id(var2))
# 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
var1 = 4+3j
var2 = 4+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))
