老男孩自动化运维开发第1天

目录导航：

　　1. 注释

　　　　1.1 单行注释

　　　　1.2 多行注释

　　2. 变量

　　　　2.1 变量的概念

　　　　2.2 变量的声明

　　　　2.3 变量的命名

　　3. 常量

　　4. 关于编码

　　5. 数值数据类型

　　　　5.1 int整型

　　　　5.2 float 浮点型小数

　　　　5.3 bool 布尔类型

　　　　5.4 complex 复数类型

　　6. 字符串类型

　　　　6.1 单引号 ''

　　　　6.2 双引号 ""

　　　　6.3 三引号 ''' """ 支持跨行

　　　　6.4 元字符串

　　　　6.5 字符串的格式化

　　7. 容器数据类型

　　　　7.1 list 列表

　　　　7.2 tuple 元组

　　　　7.3 str 字符串

　　　　7.4 set 集合

　　　　7.5 dict 字典

　　8. 自动类型转换

　　9. 强制类型转换

　　10. 变量的缓存机制

1. 注释

 1.1 单行注释

　　采用 # 开头，表示此行为注释行

1.2 多行注释

　　多行注释采用：连着的3个单引号'''或者连着的3个双引号"""

　　注释的注意点：
　　"""
　　注释的嵌套:
　　如果外面用了三个双引号,里面用三个单引号
　　如果外面用三个单引号,里面用三个双引号
　　"""

2. 变量

　　变量: 可以改变的量, 实际具体指的是内存的一块空间

2.1 变量的概念

rujia_305 = "王文"
rujia_305 = "李四"
print(rujia_305)

2.2 变量的声明

a = 1
b = 2
print(a)
print(b)

2.3 变量的命名

　　"""
　　变量的命名
　　字母数字下划线,首字符不能为数字
　　严格区分大小写,且不能使用关键字
　　变量命名有意义,且不能使用中文哦
　　"""

　　查看关建字：import 引入 keyword 模块 (kwlist 可以得到所有的关键字)

import keyword
res = keyword.kwlist
print(res)

3. 常量

　　常量: 不能改变的量 (用大写命名一个变量 约定俗成是常量,不要修改)

SHENFENZHENG = "210202200010106688"
print(SHENFENZHENG)

4. 关于编码

　　"""

　　utf-8 国际通过编码集(万国码 ,unicode编码集的升级 utf-8 可变长的unicode 编码集) 一个中文按照3个字节存储, 一个英文或者符号按照1个字节存储
　　gbk 国标编码集 1个中文按照2个字节存储, 一个英文或者数字符号按照1个字节存储

　　"""

5. 数值数据类型

　　数值数据类型包含4种：int、float、bool、complex

5.1 int 整型

　　定义：正整型、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) )

5.2  float 浮点型小数

# 表达方法一
floatvar = 3.56
print(floatvar)
print(type(floatvar))
print(id(floatvar))

# 表达方式二 (科学计数法)
floatvar = 6.36e-3
print(floatvar)
print(type(floatvar))
print(id(floatvar))

5.3 bool 布尔类型

　　要么是True 真的 要么是False 假的

boolvar = True
print(boolvar , type(boolvar) , id(boolvar))

5.4 complex 复数类型

　　定义：　　

　　"""
　　　　实数 + 虚数
　　　　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))

6. 字符串类型

　　定义：str 字符串类型 : 用引号引起来的就是字符串　　

　　"""
　　# 转义字符: + 字符
　　(1)把无意义的字符变得有意义
　　(2)把有意义的字符变得无意义

　　 => 换行
　　 => 换行
　　 => 把 后面的字符串直接拉到当前行行首
　　 => 缩进(水平制表符) 一般来讲显示的是4个空格的长度
　　"""

6.1 单引号 ''

strvar = '本来无一物,何处惹尘埃'
print(strvar)
print(type(strvar))

6.2 双引号 "" 

# 将无意义的字符变得有意义
strvar = "黑夜给了我黑色的眼睛,
但是我却用它翻白眼"
strvar = "黑夜给了我黑色的眼睛,
但是我却用它翻白眼"
strvar = "黑夜给了我黑色的眼睛
, 但是我却用它
翻白眼"
strvar = "黑夜给了我	黑色的眼睛,但是我却用它翻白眼"
# 将有意义的字符变得无意义
strvar = "黑夜给了我	黑色的"眼睛",但是我却用它翻白眼"
strvar = "黑夜给了我	黑色的'眼睛',但是我却用它翻白眼"
print(strvar,type(strvar))

6.3 三引号 '''  """ 支持跨行

strvar = """
飞流直下三千尺,
疑是银河落九天
"""

strvar = '''
飞流'直'下三千尺,
疑是"银"河落九天
'''
print(strvar , type(strvar))

6.4 元字符串 

　　 r"字符串" : 不转移字符,原型化输出字符串

strvar = r"D:周末五期
ote"
print(strvar,type(strvar))

6.5 字符串的格式化

　　"""
　　%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)

7. 容器数据类型

　　容器数据类型有：str、list、tuple、set、dict

7.1 list 列表

　　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)

7.2 tuple 元组

　　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

7.3 str 字符串

　　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

7.4 set 集合

　　set集合作用：做交叉并补操作，集合特点："""无序,自动去重"""

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

# 无序
setvar = {"刘德华","郭富城","张学友","王文"}
print(setvar , type(setvar))

# 自动去重
setvar = {"刘德华","郭富城","张学友","王文","王文","王文"}
print(setvar , type(setvar))

# 所谓的无序,既不能获取里面的元素,又不能修改里面的元素
# res = setvar[0]
# setvar[0] = 90

7.5 dict 字典

　　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

8. 自动类型转换

　　自动类型转换 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)

9. 强制类型转换

　　强制类型转换 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

10. 变量的缓存机制

　　"""
　　# -->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))