pyton注释、变量、数据类型、变量缓存、类型转换

# 变量的声明
# 方法 1
a = 1
b = 2
print(a)
print(b)
# 方法 2
c, d =3, 4
print(c, d)
# 变量的命名
# 字母数字下划线，首字符不能为数字
# 严格区分大小写，且不能用关键字
# 变量命名有意义，且不能用中文
# import 引入 keyword 模块名
import keyword
res = keyword.kwlist #kwlist 可以打印出所有的关键字
print(res)
# Number (int float bool complex)
# int 整型 (正整型 0 负整型)
intvar = 123
print(intvar)
# type 获取一个变量的类型 type(值)
na_1 = type (intvar)
print(na_1)
# id 获取该变量所指向的地址 id (值)
na_1 = id(intvar)
print(na_1)
# 打印二进制
intvar = 0b101
print(intvar)
print(type(intvar))
print(id(intvar))
# 打印八进制
intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))
# 打印十六进制
intvar = 0xff
print(intvar)
print(type(intvar))
print(id(intvar))
# (1)float 浮点型 小数
# 表达一
floatvar = 3.15
print(floatvar, type(floatvar))
# 表达二
floatvar = 5.35e-3 # e 小数点向左移动三位
print(floatvar, type(floatvar))
floatvar = 5.35e+3 # e 小数点向右移动三位
print(floatvar, type(floatvar))
# (2) bool 布尔类型
boolvar = True
boolvar = False
print(boolvar, type(boolvar))
# (3) complex 复数类型
# 复数: 实数加虚数
# j: 如果一个书的平方等于-1， 那么这个数就是j
# 科学家认为有，表达一个高精度的类型
# 方式 1
complexvar = 3 + 4j
print(complexvar, type(complexvar))
# 方式 2  complex(实数, 虚数)
complexvar = complex(-5, -2)
print(complexvar)
# 容器类型数据 (str list tuple dict set )
# str 字符串类型
# (1) 单引号
strvar = '爱杨奇超'
print(strvar, type(strvar))
# (2) 双引号
strvar = "爱\n杨奇超"
print(strvar, type(strvar))
# (3) 三引号 (支持跨行 无需对单双引号重新转义)
strvar = """本来无一物
何处惹尘埃"""
print(strvar)
str = '''本来"无"一'物'，
何处惹尘埃'''
print(strvar)
# 源字符串 r (原型化输出字符串，让转义字符失效)
strvar: str = r"爱\r杨奇超"
strvar = r"C:\Program Files\AntiCheatExpert\SGuard"
print(strvar)
# 字符串的格式化 %d--整形占位符 %s--浮点型占位符 %f--字符型占位符
strvar = "我是美女，有%2d豪车"%(3)
print(strvar)
strvar = "我是美女，有%.2f豪车"%(5.56) # %.1f 存在四舍五入
print(strvar)
strvar = "%s"%("超超")
print(strvar)
# 容器类型数据 list tuple
# 定义一个空列表
listvar = []
print(listvar, type(listvar))
# 正向索引 0 1 2 3 4
listvar = [13,2.14,True,6-2j,"我是帅哥"]
# 反向索引 -5 -4 -3 -2 -1
# 获取列表当中的值
res = listvar [4]
print(res)
res = listvar [-1]
print(res)
# 通用 => 想要获取列表最后一个元素值 需要通过len函数
# len 用来获取容器类型数据的元素个数(长度)
res = len (listvar)-1
print(res)
print(listvar[res])
print(listvar[len(listvar)-1])
# 修改列表当中的值
listvar [3] = "爱超超"
listvar [-4] = "比养生"
print(listvar)
# tuple 可获取 不可修改 有序
# 证明一个元组的根本特征是逗号，声明一个孔院组，可以直接使用(),(1)表明一个整型
tuplevar = (1,2,3,4)
print(tuplevar,type(tuplevar))
tuplevar = (1,)
print(tuplevar,type(tuplevar))
tuplevar =1,2,3
print(tuplevar,type(tuplevar))
# 正向索引 0 1 2
tuplevar = ("a","b",False)
# 逆向索引 -3 -2 -1
res = tuplevar[-1]
print(res)
# 元组不可修改 tuplevar [-1] = True
# str 字符串和元组几乎一模一样， 只不过每一个元素都是字符
# 可获取 不可修改 有序
#          0 123  45 6 7 8
strvar = " 瞅你一眼，浑身哆嗦"
#          -9-8-7-6-5-4-3-2-1
# (1) 获取字符串中的一字
res = strvar [2]
print(res)
# (2) 字符串无法修改
# strvar [-1] = "!"      error
# 容器类型数据
# set 集合 (用来做前交叉并补 集合操作的)

# (1) 定义一个集合 无序 自动去重
setvar = set() # 强制转换
print(setvar,type(setvar))
setvar = {"周杰伦","王宝强","李宇春"}
print(setvar)
setvar = {"刘德华","张学友","郭富城","王文","王宝强"}
print(setvar)
# dict 字典 由键值对数据组成,有序
# 定义一个空字典
dictvar = {}
print(dictvar,type(dictvar))
# "键": "值"
dictvar = {"top": "程咬金","middle": "妖姬","bottom": "崔丝塔娜","jungle": "七大大声","support": "德玛西亚"}
print(dictvar,type(dictvar))
# 获取字典当中的值 (通过键来获取)
res = dictvar['middle']
print(res)
# 通过字典的键来修改值
dictvar ['top'] = "赵信"
print(dictvar)
# 关于字典 在3.6版本之前 字典无序
#          3.6版本之后 字典有序(看起来有序，本质无需)
# 哈希算法: 哈希值 (算法底层)
#         将不可变的长度值计算成具有固定长度的唯一值
#         这个值可正可负 通过计算出来的键来获取值 形成一一映射的效果
#         字典进行存储的时候，并不是按照字面顺序依次存在内存中
#         而是通过哈希算法 随机散列的把键所对应的值存储在底层 所以字典无序 【为了求效率】
#         可以通过哈希算出的键获取散列的值
#         3.6之后，记录了字典的字面顺序，进行重新排序，所以看起来有序，实际上无序
# 可哈希数据(不可变的数据): Number (int float complex bool) str tuple
# 不可哈希数据(可变数据): list set dict (set 顺序可变的
# 可哈希数据
dictvar = {35: 1, 36: True,3.15:"111",False:"112233",3+2j:12,"大帅哥":78,(11,22,333):4}
print(dictvar)
# 字典的键 集合的值 都需要可哈希数据
# 获取4
print(dictvar[(11,22,333)])
dictvar [False] = 67
print(dictvar)
# 可哈希数据 (集合)
# setvar = {1,2,3,4,{5,6,7}}
# print(setvar)

# 同一文件的变量缓存机制
# 变量的缓存机制是为了节省内存空间，提高效率
# 1.对于整型而言，-5 ~ 正无穷 范围内的相同值 id一致
intvar1 = 99
intvar2 =99
print(id(intvar1),id(intvar2))
# 2.对于浮点数而言，非负数范围内的相同值 id一致
a1 = 3.15
a2 = 3.15
print(id(a1),id(a2))
# f1 = -3.14
# f2 = -3.14
# print(id(f1),id(f2))
# 3.对于布尔值而言，值相同的情况下 id一致
t1 = True
t2 = True
print(id(t1),id(t2))
# 4.复数的id标识都不相同(在 实数 + 虚数 这样的结构中)
c1 = 3-2j
c2 = 3-2j
print(id(c1),id(c2))
# 只有虚数的情况下，在值相同时，地址相同
c1 = 6j
c2 = 6j
print(id(c1),id(c2))

# 自动类型转换 (针对于Number类型) bool float int complex
# 当Number不同的数据类型进行运算的时候，默认向更高精度转化
# 精度从高到低顺序:
# bool --> int --> float --> complex
# True 默认转化是1
# Flase 默认转化是0
# bool + int
res = True + 89
print(res)
# bool + float
res =True + 55.78
print(res)
# bool + complex
res = False + 2-4j
print(res)
# int + float
res = 31 + 4.1
print(res)
# int + complex
res = 16 + 4-7j
print(res)
# float + complex
res = 8.12 + 3+5j
print(res)
### 强制类型转换 Number => (int float bool complex)
var1 = 13
var2 = 99.12
var3 = True
var4 = 3 + 1j
var5 = "1234"
var6 = "你好123"
#  把数据强转为整型 int （整型 浮点型 布尔类型 纯数字字符串）
res = int(var2) # 也可成intvar2
print(res)
res = int(var3)
print(res)
# 把数据强转为浮点型 float （整型 浮点型 布尔类型 纯数字字符串）
res = float(var1)
print(res)
res = float(var3)
print(res)
res = float(var5)
print(res)
# 把数据强转为复数 complex （整型 浮点型 布尔类型 纯数字字符串 复数）
print("-----------")
res = complex(var1) # 13 + 0j
res = complex(var2) # 99.12 + 0j
res = complex(var3) # 0j
res = complex(var4)
print(res)
res = complex(var5)
print(res)
# 把数据强转为布尔类型 bool （所有数据类型） 无论是Number还是容器类型数据都可以墙砖， 要么Flase要么True
res = bool(var6)
res = bool(var4)
print(res)
"""
布尔类型为假的十种情况: 
0,0.0,Flase,0j,""字符空,[]列表空,()空元素,set()空集合,{}空字典,None
None 是字典的一个关键字 表示空的 什么也没有 一般做初始
2：56
"""