Python笔记_03_强制类型转换_运算符_变量储存的缓存机制

最新推荐文章于 2024-02-29 18:36:25 发布

豆浆多放点糖

最新推荐文章于 2024-02-29 18:36:25 发布

阅读量211

点赞数

分类专栏： python笔记

本文链接：https://blog.csdn.net/wangjunwen1017/article/details/89572132

版权

python笔记专栏收录该内容

83 篇文章 3 订阅

订阅专栏

文章目录

强制类型转换

Number 部分

var1 = 5
var2 = 4.85
var3 = True
var3_2 = False
var4 = 3+9j
var5 = "888777"
var6 = "sdf424s+"

int : 整型浮点型布尔类型纯数字字符串

res = int(var2)
res = int(var3)  # True => 1
res = int(var3_2)# False => 0
res = int(var5)
# res = int(var6) error 
print(res)

float: 整型浮点型布尔类型纯数字字符串

res = float(var1)
res = float(var3)
res = float(False)
# res = float(var4) error
res = float(var5)
print(res)

complex: 整型浮点型布尔类型纯数字字符串 (复数)

res = complex(var1)
res = complex(var2)
res = complex(var3)
res = complex(False)
res = complex(var5)
print(res)

bool: ( 容器类型数据 / Number类型数据都可以 )
```
res = bool(var1)
res = bool(var2)
res = bool(var6)
res = bool(None)
print(res)
```
布尔类型为假的十种情况:
0 0.0 0j False '' () [] set() {} None

容器类型部分

var1 = "今天好晴朗"
var2 = [1, 2, 3, 4]
var3 = ("黄将用", "黄熊大", "刘五星")
var4 = {"朱思华", "黄广雄", "正路"}
var5 = {'ffq' : "身材魁梧,瞳孔有力", "hyz" : "斯斯文文,斯文败类"}
var6 = 3 + 6j

str: ( 容器类型数据 / Number类型数据都可以 )
规律:基于原有类型,在外面套一层引号


res = str(var2)
res = str(var3)
res = str(var5)
res = str(var6)
print(res, type(res))
print(repr(res))  # 打印出字符串类型的那个引号 <原型化输出>

list: 字符串列表元组集合字典
规律:
如果是字符串,把字符串当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上,套一个[]标识符即可转化
```
res = list(var1)
res = list(var3)
res = list(var5)  # 把字典强转成列表时,只获取键,忽略值
# list(var6) error  
print(res, type(res))
```
tuple: 字符串列表元组集合字典
规律:
如果是字符串,把字符串当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上,套一个()标识符即可转化
```
res = tuple(var1)
res = tuple(var2)
res = tuple(var5) # 把字典强转成元组时,只获取键,忽略值
res = tuple(var4)
print(res)
```

set: 字符串列表元组集合字典 (注意:相同的值,只会保留一份)
规律:
如果是字符串,把字符串当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上,套一个{}即可转化集合

res = set(var1)
res = set(var5) # 把字典强转成集合时,只获取键,忽略值
print(res)


# 去掉列表当中的重复元素
listvar = ["周杰伦","周润发","周星驰","王文","王文"]
res = set(listvar)
print(res)
res = list(res)
print(res)
# 简写
res = list(set(listvar))
print(res)

dict: 使用二级列表或二级元组 (二级集合语法上不错,但是无序,不建议使用)

# (1) 外面是列表,里面是列表 或 元组 或 字符串
'''字符串元素的个数只能是2层,有它的局限性,不推荐使用'''
'''[["a", [1, 2, 3, 4]]   ]'''
listvar = [['a' ,1], ('b' ,2), "c3"] #c33
res = dict(listvar)
print(res, type(res))

# 特殊注意:
res = dict(   [   ["a", [1, 2, 3, 4]]  , ("b", [5, 6, 6, 7]) ]   )
print(res,"<===>")
'''
#会产生意想不到的结果,不推荐使用
listvar = [{'c',1},{'d',2}] 
res = dict(listvar)
print(res,type(res))
'''
# (2) 外面是元组,里面是列表 或 元组 或 字符串
'''字符串元素的个数只能是2个,有它的局限性,不推荐使用'''
tupvar = (["c" ,3], ("d", 33), "f2")
res = dict(tupvar)
print(res,type(res))


# (3) 外面是集合,里面是元组 或 字符串
setvar = {('a', 1),('b', 2)}
res = dict(setvar)
print(res,type(res))

总结:
关于容器类型数据的强转一共如下：
str() list() set() tupel() dict() 都可以转换成对应的数据类型
关于Number数据类型的强转一共如下:
int() bool() float() complex() 都可以转换成对应的数据类型
多级容器数据:该类型是容器数据,并且里面的元素还是容器类型数据

二级列表

listvar = [1,2,3,4,5,[6,7,8,9]]  
res = listvar[-1][3]
print(listvar)
print(res)

二级元组
```
tuplevar = (1,2,3,4,5,(6,7,8,9)) 
```

二级集合 (只能在里面放元组作为集合里面的容器数据)

setvar = {1,2,3,(4,5,6)}
setvar = {1,2,3,(4,5,6,{'a':1,"b":2})} #error 必须是可hash不可变得数据
setvar = {1,2,3,[4,5,6]} #error
print(setvar)

二级字典

dictvar = {"a":{"c":3},"b":2}
res = dictvar["a"]
print(res)
print(res['c'])
# 简写
print(dictvar["a"]["c"])

四级容器

content = [1,2,3,4,(4,6,{'a':{4,5,6,78},"b":2},7),5]
print(content[4])
print(content[4][2])
# 获取集合
print(content[4][2]["a"])

等长的二级容器

首先容器是2个,代表二级容器
每一个容器元素个数都是一样的叫做等长
```
listvar = [(1,2,3,4),(5,6,7,8)]
tupvar = ([1,2],[3,4],[5,6])
```

python运算符

算数运算符: + - * / // % **

var1 = 5
var2 = 8

# +
res = var1+var2
print(res)

# -
res = var1 -var2
print(res)

# *
res = var1 * var2
print(res)

# / (除法,结果一定是小数)
var1 = 8
var2 = 2
res = var1 /var2
print(res)

# // 地板除(整除)
var1 = 8
var2 = 2
res = var1 // var2
print(res)

# 如果相除的两个含有小数,那么就在结果上加上.0
var1 = 8.0
var2 = 2
res = var1 // var2
print(res)

# % 取余
print("<============>")
var1 = 7 
var2 = 4
res = var1 % var2
print(res)

print("<============>")
var1 = -7 
var2 = 4
res = var1 % var2
print(res) # 1
# -3+4 = 1

print("<============>")
var1 = 7 
var2 = -4
res = var1 % var2
print(res) # -1
# 3-4 = -1

#  **(幂运算)
var1 = 3 
res = var1 ** 3
print(res)

比较运算符: > < >= <= == !=

最终只返回2个结果,要么是True 要么是False

# >
var1 = 10
var2 = 20
res = var1 > var2
print(res)

# <
var1 = 10
var2 = 20
res = var1 < var2
print(res)

# >=
var1 = 20
var2 = 20
res = var1 >= var2
print(res)

# <=
var1 = 20
var2 = 20
res = var1 <= var2
print(res)

# == 等于
var1 = 14
var2 = 13
res = var1 == var2
print(res)

'''
是2个等号 , 不是1个等号,1个等号是在做变量的赋值,2个是比较是否相同
if var1 == var2:
	print(123)
'''

# != 不等于
var1 = 14
var2 = 13
res = var1 != var2
print(res)

赋值运算符: = += -= *= /= //= %= **=

# = 将右边的值赋值给左侧
var1 = 19
var2 = 18
var2 = var1
print(var2)


var1 = 19
var2 = 20

# +=
var1 += var2
# var1 = var1 + var2 var1 = 19 + 20 = 39
print(var1)



# -=
var1 -= var2
# var1 = var1 - var2
print(var1)



# *=
var1 *= var2
# var1 = var1 * var2
print(var1)



# /=
var1 /= var2
# var1 = var1 /var2
print(var1)


# //=
var1 //= var2
# var1 = var1 // var2
print(var1)



# %=
var1 %= var2
# var1 = var1 % var2
print(var1)



# **=
var1 **= var2
# var1  =  var1 ** var2
print(var1)

成员运算符: in 和 not in

(针对于容器型数据) 如果是字符串,必须是一个连续的片段才能判断成功

# str
strvar = "英雄爱江山,更爱美人"
res = "爱江山" in strvar
print(res)
res = "英" in strvar
print(res)
res = "雄江" in strvar
print(res)

# list tuple set
listvar = [1, 2, 3, 4, 5, 6]
res = 3 in listvar
res = 4 not in listvar
print(res)

tupvar = 23, 343, 343, 343, 343
res = 999 not in tupvar
print(res)

setvar = {(1, 2, 3), (4, 5, 6)}
res = (1, 2, 3) in setvar
print(res)

# dict (in not in 判断的是字典的键)
dicvar = {"hxd": "大", "hgx": "小"}
res = "大" not in dicvar
res = "hxd" in dicvar
res = "aaa" not in dicvar
print(res)

身份运算符: is 和 is not

(检测两个数据在内存当中是否是同一个值)

var1 = 6
var2 = 6
print(id(var1),id(var2))

var1 = "好"
var2 = "不好"

# is 用来判断2个变量的地址是否一致
res = var1 is var2
print(res)

res = var1 is not var2
print(res)

# var1 == var2 与 var1 is var2 区别
'''
一个是在比较两个值是否相同
一个是在比较两个值地址是否相同
'''

逻辑运算符: and or not

# and 逻辑与
'''全真则真,一假则假'''
res = True and True
res = True and False
res = False and True
res = False and False
print(res)

# or  逻辑或
'''全假则假,一真则真'''
res = True or True
res = True or False
res = False or False
res = False or True
print(res)

# not 逻辑非 
'''真变假 假变真'''
res = not False
res = not True
print(res)

逻辑短路 (后面的代码就不走了)

# 两种情况
res = False and 布尔值
res = True or 布尔值
'''
# print 默认返回一个None 而None的布尔值是假
# res = False and print(1)
res = True and print(2)
res = True or print(3)
res = False or print(4)
print(res)

逻辑运算符优先级
() > not > and > or

# (5+6)*3
res = 5 or 6 and 7
# 5 or 7 => 5
res = (5 or 6) and 7
# 5 and 7 => 7
res = not (5 or 6) and 7 
# |  (5 or 6) => 5 | not 5 => False | False and 7 => False
res = 5>6 or 7<8 and 9>10 or 11<12
''' 
False or True and False or True 
False or  False or True
False or True => True
'''
print(res)

有一种情况不用考虑and和or优先级问题,
就是or短路比如 True or … => 结果一定为True

位运算符: & | ~ ^ << >>

var1 = 19
var2 = 15
# & 按位与

res = var1 & var2
print(res)

'''
000...10011
000...01111
000...00011
'''

# | 按位或
res = var1 | var2
'''
000...10011
000...01111
000...11111
'''
print(res)


# ^ 按位异或
res = var1 ^ var2
'''
000...10011
000...01111
000...11100
'''
print(res)

# << 左移  (左移  相当于乘以2的几次幂 n << m 相当于n乘2的m次幂)
res = 5 << 1
res = 5 << 3
print(res)
'''
000...101
000..1010
'''

# >> 右移 (右移  相当于除以2的几次幂 n >> m 相当于n除2的m次幂)
res = 5 >> 1  # 5 // 2的1次幂 => 2
res = 5 >> 2  # 5 // 2的2次幂 => 1
res = 5 >> 3  # 5 // 2的3次幂 => 0
print(res)
'''
000...101
000....10  =>2
000....01  =>1
'''

# ~ 按位非 (按位非 操作的二进制的补码, 对二进制的每一位进行取反,包括符号位)   
# 公式:-(n+1)
res = ~19
print(res)
'''
000...10011  (补码)
111...01100  (按位非)

# 给补码求原码
111...01100

100...10011  (反码)
100...10100  (原码 = 反码+1)
十进制 => -20
'''
res = ~(-19)
print(res)
'''
1000...10011  (原码)
1111...01100  (反码)
1111...01101  (补码)

# 现在进行按位非
0000...10010
因为高位都是0是正数
原码 = 反码 = 补码
0000...10010  (原码)
十进制 => 18
'''

运算符的优先级

() 括号优先级最高
** 优先级其次
= 优先级最低
一元运算符:同一时间只操作一个数字的 (- , ~)
二元运算符:同一时间能操作二个数字的 (+ , -…)
~19+5
一般来说,一元运算符大于二元运算符的优先级
+ - * / => * / 大于 + -
() not and or => not > and > or
如果都是二元运算符:
算术运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符作为最后等号右边的值算好后进行赋值.

变量存储的缓存机制（同一文件或模块）

在同一文件(模块)里,变量存储的缓存机制（为了节省空间） (仅对python3.x版本负责了解)

Number 部分

对于整型而言，-5~正无穷范围内的相同值 id一致

var1 = 18
var2 = 18
var1 = -99
var2 = -99
var1 = -6
var2 = -6
print(id(var1))
print(id(var2))

对于浮点数而言，非负数范围内的相同值 id一致

var1 = 3.15
var2 = 3.15
var1 = -5.88
var2 = -5.88
print(id(var1),id(var2))

布尔值而言,值相同情况下，id一致

var1 = False
var2 = False
print(id(var1),id(var2))

复数的id标识都不相同(在实数+虚数这样的结构中)

var1 = 5+3j
var2 = 5+3j
'''只有虚数的情况下 例外'''
var1 = 8j
var2 = 8j
print(id(var1),id(var2))

容器类型部分

字符串而言，字符串值相同情况下，id一致

var1 = "你"
var2 = "你"
print(id(var1),id(var2))

列表，元组，字典，集合无论什么情况 id标识都不同(但空元组的id标识一样)

# 空元祖
var1 = ()
var2 = ()
print(id(var1),id(var2))

# 剩下所有的容器类型数据地址都不一样
var1 = (1,2,3)
var2 = (1,2,3)
var2 = []
var1 = []
var1={'a':1}
var2 = {"a":1}
print(id(var1),id(var2))

部分数据驻留小数据池中（不同文件或模块里）

小数据池只针对：int ,string,bool,以及空元祖(),None关键字 有效

对于整型来说：

python提前在内存中创建了 -5 ~ 256 范围的整数,驻留在了内存的一块区域.
如果是不同文件(模块)的两个变量,并在此范围具有了相同的值,
那么id一致.

对于字符串来说:

字符串的长度为0或者1，默认驻留小数据池
字符串的长度>1,且只含有大小写字母，数字，下划线时，默认驻留小数据池
用乘法得到的字符串，分两种情况。
1)乘数为1时:
无论什么字符串 * 1 , 都默认驻留小数据池
2)乘数大于1时:
乘数大于1，仅包含数字，字母，下划线时会被缓存，但字符串长度不能大于20

指定驻留

from sys import intern
a = intern('大帅锅&*^^1234'*10)
b = intern('大帅锅&*^^1234'*10)
print(a is b)
#可以指定任意字符串加入到小数据池中,无论声明多少个变量,只要此值相同,都指向同一个地址空间

在这里插入图片描述
无论是缓存机制还是小数据池的驻留机制,都是为了节省内存空间,提升代码效率

豆浆多放点糖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录