python初识（一）

变量的概念
rujia_305 = "王文"
rujia_305 = "李四"
print(rujia_305)

# (1) 单个变量的定义
a = 1
b = 2
print(a)
print(b)

# (2) 多个变量的定义
a,b = 3,4
print(a , b)

# (3) 相同变量定义
a = b = 5
print( a , b )

_abc123 = 3
abc = 10
ABC = 20
print(abc)


# 查看系统所有的关键字
# 引入 模块
import keyword
# res => result
res = keyword.kwlist
print(res)
"""
[‘False‘, ‘None‘, ‘True‘, ‘and‘, ‘as‘, ‘assert‘, ‘break‘, ‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘, ‘except‘, ‘finally‘, 
‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘, ‘lambda‘, ‘nonlocal‘, ‘not‘, ‘or‘, ‘pass‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, 
‘with‘, ‘yield‘]
"""

# 变量名字要有意义
my_car = "宝马"
abc = "宝马"


"""
在python中,用中文命名变量没有语法错误,但是严禁使用

utf-8 国际标准字符编码(万国码) 一个中文占用3个字节,数字或者符号占用一个字节
gbk   国标编码 一个中文占用2个字节,数字,字母,符号占用一个字节

(1) 防止乱码
(2) 占用的空间更小
"""


中文 = "兔子各个"
print(中文)
word = "兔子各个"

# 变量的交换
a = 10
a = 15
print(a)

# 通用写法
tmp = a
a = b
b = tmp
print(a , b)

# python特有写法
a = 20
b = 30
a,b = b,a
print(a,b)

# ### Number

# int => 整型 (正整数 0 负整数)
intvar = 1000
print(intvar)

# type 获取类型
res = type(intvar)
print(res)

# id   获取地址
res = id(intvar)
print(res)
内存地址的命名相当于内存地址号

 # 二进制整型

intvar = 0b101
print(intvar)
res = type(intvar)
res = id(intvar)
print(res)

# 八进制整型
intvar = 0o127
print(intvar)

# 十六进制整型
intvar = 0xff
print(intvar)

# float 浮点型(小数)
# 表达方式一  
floatvar = 3.14
print(floatvar)
res = type(floatvar)
print(res)

# 表达方式二 (科学计数法)
floatvar = 3.98e3  # 3.98乘以10的3次方（小数点向右移动3位） 结果：3980
floatvar = 3.98e-3  # 3.98乘以10的-3次方（小数点向左移动3位）  结果：0.00398
print(floatvar)
res = type(floatvar)
print(res)

# bool 布尔型 (True真的 False假的) 注意：T和F是大写，小写则报错
boolvar = True
print(boolvar)
res = type(boolvar)
print(res)

# complex 复数
"""
复数 : 实数 + 虚数
例如 : 3 + 5j
实数 : 3
虚数 : 5j
j   : 如果有一个数,他的平方等于-1,那么这个数就是j,科学家认为有,表达的是高精度的类型，j是Python内部定义好的，记住就好。
"""

# 表达方式一
complexvar = 2-90j
complexvar = -90j

print(complexvar,"<=====>")
res = type(complexvar)
print(res)

# 表达方式二
"""
complexvar = complex(实数,虚数)
"""
complexvar = complex(3,-90)
print(complexvar  ,  type(complexvar) )

# 字符串 str : 用引号引起来的就是字符串
"""

# 转义字符:通过\进行转换
    (1) 把无意义的字符变得有意义
    (2) 把有意义的字符变得无意义
    
\n   : 换行
\r\n : 换行
\t   : 缩进(水平制表符)Python标准一个缩进是4个空格
\r   : 把\r后面的字符串直接拉到当前行行首
\    : 折行
"""

# (1) 单引号引起来的字符串
strvar = ‘今天天气不错‘
print(strvar , type(strvar))

# (2) 双引号引起来的字符串# 注意：Python中的单双引号是没有区别的

strvar = "大江东去浪涛尽,千古风流人物" print(strvar,type(strvar))

# 把无意义的字符变得有意义
strvar = "大江东去浪涛尽,\n千古风流\r\n人物"
strvar = "大江东去浪涛尽,\t千古风流人物"
strvar = "大江东去浪涛尽,\r千古风流人物"
strvar = "大江东去\n浪涛尽,\r千古风流人物"
print(strvar)

　　输出：

　　大江东去
　　千古风流人物

# 把有意义的字符变得无意义
strvar = "大江东去浪涛尽,千古‘风流‘人物"
strvar = ‘大江东去浪涛尽,千古"风流"人物‘
strvar = "大江东去浪涛尽,千古\"风流\"人物"
print(strvar)

# \的折行功能，一行代码过长阅读性差

strvar = "大江东去浪涛尽,\
千古‘风流‘人物"
print(strvar)
输出：

大江东去浪涛尽,千古‘风流‘人物

# (3) 三引号引起来的字符串 (支持跨行)
strvar = ‘‘‘
本来无‘一‘物,
何处惹"尘"埃
‘‘‘
print(strvar , type(strvar))


# (4) 元字符串 r + "字符串"  => 表示不转义字符,原型化输出字符串，用在导入路径上
strvar = r"E:\python29\day3\no\ppp.py"
print(strvar)

# (5) 字符串的格式化
"""
"字符串" % (值1,值2,值3 ... )
%d => 整型占位符
%f => 浮点型占位符
%s => 字符串占位符
"""

# %d 整型占位符
strvar = "john同学今年%d岁" % (5)
print(strvar)

# %2d 占用2位空间,默认居右
strvar = "john同学今年%2d岁" % (5)
print(strvar)

# %-2d 占用2位空间,默认居左
strvar = "john同学今年%-2d岁" % (5)
print(strvar)


# %f 浮点型占位符(默认保留6位小数)
strvar = "程序员过家家这个同学今天开工资了,发了%f元" % (9.18) 
print(strvar)

# %.1f 小数点后边保留1位小数 (存在四舍五入的情况)
strvar = "程序员过家家这个同学今天开工资了,发了%.1f元" % (9.18) 
print(strvar)

# %s 字符串占位符
strvar = "%s" % ("这个同学真帅")
print(strvar)

# 综合案例
strvar = "%s今天开工资了,一共%.2f元,买了%d个布加迪威龙" % ("李",19.378,3)
print(strvar)

strvar = "%s今天开工资了,一共%s元,买了%s个布加迪威龙" % ("李",19.378,3)
print(strvar)

"""
特点: 可获取,不可修改,有序
"""
#         0123
strvar = "abcd"
#        -4-3-2-1
# 获取a元素
res = strvar[0]
print(res)

# 可以修改字符串当中的元素么? 不行
# strvar[0] = "z" error

"""
特点: 可获取,可修改,有序
"""

# 定义一个空列表
listvar = []
print(listvar, type(listvar))

# (1) 定义一个普通的列表
# 正向索引下标   0   1    2     3     4
listvar  =    [1,3.14,False,3+4j,"你好帅哥"]
# 逆向索引下标  -5   -4   -3    -2    -1

# (2) 获取列表当中的元素
res = listvar[3]
# python特点,用下标-1
res = listvar[-1]

# 获取列表中最后一个元素(通用写法)
# len 获取容器类型数据的总长度(元素总个数)
res = len(listvar)
max_len = res - 1
print(max_len) # 4

val = listvar[max_len]
print(val)

# (3) 修改列表当中的元素
listvar[-4] = "太帅了"
print(listvar)

"""
特点: 可获取,不可修改,有序
"""

# 1.定义一个普通的元组
# 正向下标  0    1    2   3
tuplevar = ("a",True,9.1,123)
# 逆向下表 -4    -3   -2  -1

# 获取元组当中的数据
res = tuplevar[2]
print(res)

# 2.是否可以修改元组当中的数据? 不可以
# tuplevar[0] = "bbb"
# print(tuplevar)

# 3.元组的注意点:
# (1) 定义一个空元组
tuplevar = ()
# (2) 逗号是区分是否是元组的标识符
tuplevar = (True,)
tuplevar = True,1
print(tuplevar, type(tuplevar))

# ### 集合set (作用:交差并补)
"""
特点: 无序,自动去重
"""

# 定义一个集合
setvar = {"刘德华","郭富城","张学友","王文"}
print(setvar , type(setvar) )

# 1.集合无序
# 获取集合中的元素? 不可以
# res = setvar[0]
# print(res) error
# 修改集合中的元素? 不可以
# setvar[0] = "abc" error

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

# 3.定义一个空集合
setvar = {} # 空字典
setvar = set()
print(setvar , type(setvar))

# ### 字典dict
"""
特点:键值对存储的数据,表面上有序,实际上无序
语法: dictvar = {键1:值1,键2:值2,键3:值3 ... }
"""
# 1.定义一个字典
dictvar = {"top":"夏侯淳","middle":"安其拉","bottom":"程咬金","jungle":"李白","support":"蔡文姬"}
print(dictvar , type(dictvar))

# 2.获取字典当中值
res = dictvar["middle"]
print(res)

# 3.修改字典当中的值
dictvar["bottom"] = "后裔"
print(dictvar)

# ### Number 的自动类型转换 (bool int float complex)
"""
默认按照精度从低到高进行转换
bool -> int -> float -> complex
自动类型转换规则: 将低精度向高精度自动转换
"""
# bool + int 
res = True + 100
print(res,type(res))


# bool + float
res = False + 3.56 # False => 0.0
print(res,type(res))

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

# int + float
res = 100 + 6.8 # 100 => 100.0
print(res)

# int + complex
res = 100 + 6-7j #100 = > 100+0j
print(res)

# float + complex # 9.5 => 9.5+0j
res = 9.5 + 3+4j
print(res)

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

var1 = 4
var2 = 6.89
var3 = 4-2j
var4 = False
var5 = "666888"
var6 = "123abc"

# 强制转换成int
res = int(var2) # 6
# res = int(var3) # error
res = int(var4) # True => 1 False => 0
res = int(var5) # 666888
# res = int(var6) # error
print(res , type(res) )


# 强制转换成float
res = float(var1) # 4.0
res = float(var4) # False => 0.0 True => 1.0
res = float(var5) # 666888.0
print(res , type(res))

# 强制转换成complex
res = complex(var1) # 4 + 0j
res = complex(var2) # 6.89 + 0j
res = complex(var4) # True => 1 + 0j False => 0j
res = complex(var5) # 666888 + 0j
# res = complex(var6) # error
print(res) 

# 强制转换成bool (True False)
res = bool(None)
print(res)

# ***** bool类型为假的十种情况
"""
0 , 0.0 , 0j , False , ‘‘,[],(),set(),{} ,None

None : 关键字,代表空的,什么也没有,一般用来做初始化操作
a = None
"""

"""
int() bool() float() complex() 都可以为当前变量初始化一个默认值
"""
res = complex()
print(res)

# ### 容器数据的强制类型转换 (list tuple set dict str)

var1 = "abc"
var2 = [1,2,3,4]
var3 = ("a","b")
var4 = {"a1","a2","a3"}
var5 = {"a100":1,"b100":2}
var6 = 90

# 强制转换成字符串 => str
"""
强制转换成字符串:就是单纯的在当前数据类型的两边套上引号;
"""
res = str(var2)
res = str(var3)
res = str(var6)
print(res , type(res) )

# repr 原型化输出字符串,可以显示引号
print(repr(res),type(res))


# 强制转换成列表 => list
"""
如果是字符串,把里面的字符作为列表的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上[]
"""
res = list(var1)
res = list(var3)
res = list(var4)
res = list(var5)
print(res , type(res))

# 强制转换成元组 => tuple
"""
如果是字符串,把里面的字符作为元组的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上()
"""
res = tuple(var1)
res = tuple(var2)
res = tuple(var5)
print(res , type(res))


# 强制转换成集合 => set
"""
如果是字符串,把里面的字符作为集合的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上{}
"""
res = set(var1)
res = set(var2)
res = set(var5)
print(res)

# 二级容器

# 二级列表
lst = [1,2,3,4,5,[6,7,8,9,10]]

# 二级元组
tup = (3,4,5,(6,7,8))

# 二级集合
setvar = {"a","b","c",("d","e","f")}

# 二级字典
dic = {"a":1,"b":2,"c":{"f":10,"e":15}}
res = dic["c"]["e"]
print(res)


# 四级容器
# 获取14这个元素?
container = [1,2,3,4,5,(6,7,8,{"a":1,"b":2,"c":[11,12,13,14]})]

# (6, 7, 8, {‘a‘: 1, ‘b‘: 2, ‘c‘: [11, 12, 13, 14]})
res = container[-1]
print(res)

# {‘a‘: 1, ‘b‘: 2, ‘c‘: [11, 12, 13, 14]}
res2 = res[-1]
print(res2)

# [11, 12, 13, 14]
res3 = res2["c"]
print(res3)

# 14
res4 = res3[-1]
print(res4)

# 简写
res = container[-1][-1]["c"][-1]
print(res)


# 等长的二级容器
"""
(1) 里面的元素都是容器
(2) 并且容器里面的元素个数都相同
"""

lst = [ (1,2,3,4) , {"a","b","c","d"} ]
lst = ([1,3,5],(7,8,9))

# ### 强制转换成字典
"""
要求: 等长的二级容器,并且里面的元素个数是2个
"""

# (1) 外面是列表,里面是等长的容器,元素个数是2个
lst = [ ["a",1] , ("b",2) , ("c",3) ]

dic = dict(lst)
print(dic , type(dic))

# (2) 外面是元组,里面是等长的容器,元素个数是2个
tup = ( ["c",1] ,("d",2) )
dic = dict(tup)
print(dic , type(dic))


# (3) 外面是集合,里面是等长的容器,元素个数是2个
setvar = {("a",10),("b",15)}
dic = dict(setvar)
print(dic, type(dic))

# (4)  例外情况,语法上正确,不推荐使用
# 情况一
"""字符串形式长度只能是2个,不能表达一个较大数据,不推荐使用"""
lst = ["a1","b2"]  #"c33" error
dic = dict(lst)
print(dic)

# 情况二
"""集合无序,本意是b作为字典的键,2作为字典的值,由于无序没有达到原来的本意,不推荐使用"""
lst = [ (‘a‘,1) , {"b",2} ]
print(dict(lst))


# 快速去掉列表当中的重复数据
lst = [11,11,"a","a","a","c","c","c","dd","dd"]
# 强制转换成集合 (去重)
setvar = set(lst)
print(setvar)
# 强转转换成列表,恢复成原来的数据类型
listvar = list(setvar)
print(listvar)

"""
str() list() tuple() set() dict() 可以为当前的数据类型创建一个默认值
"""
res = dict()
print(res)

"""
对集合的值 和 字典的键 有数据类型上的要求
可哈希的数据类型：
　　Number(int , bool , float ,complex) ,str , tuple
不可哈希的数据类型
　　list set dict

3.6版本之前都是 字典和集合都是无序的
3.6版本之后对字典做了优化,存储数据的时候用了哈希算法，但是拿出数据的时候,重新按照定义的顺序做了排序,所以看起来有序,实际上无序

　　记住：哈希算法是典型的无序的特征.

***推荐大家使用变量命名的字符串作为字典的键***
"""

# 字典的键要求可哈希
dictvar = {3:"a",False:"b",4.56:"c",4+9j:"d","中文":"ff",(1,2,3):"zz"}
print(dictvar)

# 获取元素 zz
res = dictvar[(1,2,3)]
print(res)

# 集合的值要求可哈希
setvar = {1,3.5,False,9+90j,"abc",(1,2,3)}
print(setvar , type(setvar))

# 算数运算符:  + - * / // % **
var1 = 10
var2 = 5

# +
res = var1 + var2
print(res)

# -
res = var1 - var2
print(res)

# *
res = var1 * var2
print(res)

# / (结果永远是小数)
res = var1 / var2 
print(res)

# // 地板除 10 除以 5 10被除数,5是除数,得到值是商 (默认得到的是整数)
res = var1 // var2
print(res)

# 被除数或除数是一个小数,结果就是小数
res = 10 // 5.0
res = 14 // 8
print(res)

# % 取余
res = 17 % 3  # 2
res = 11 % 7  # 4
res = -11 % 7 # 3  =>   -4 + 7 = 3 
res = 11 % -7 # -3 =>    4 + (-7) = -3
res = -11 % -7# -4 =>   -4

# res = 81 % 5  # 1
res = -81 % 5   # 4
res = 81 % -5   # -4
res = -81 % -5  # -1
print(res)

# ** 幂运算
res = 2 ** 50
print(res)

# 比较运算符:  > < >= <= == !=   结果只有两种 (True 真的 False 假的) 
res = 5 > 6
res = 6 < 1000
res = 90 <= 90
print(res)

# ==  等于
"""一个等号是赋值操作,两个等号在做比较操作"""
res = 100 == 100
print(res)

# !=  不等于
res = 100 != 100
print(res)

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

# = 
var1 = 10
var2 = 20
var1 = var2
print(var1,var2)

# +=
var1 = 10
var2 = 20
# var1 = var1 + var2
var1 += var2
# var1 = var1 + 1  
var1 += 1
print(var1)


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

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

# 成员运算符:  in 和 not in (针对于容器型数据)
# 针对于字符串
"""要求字符串是一个连续的片段"""
strvar = "好看的皮囊千篇一律,有趣的灵魂200多斤"
res = "皮" in strvar
res = "千篇一律" in strvar
res = "灵多" in strvar
print(res)

# 针对于 list tuple set
listvar = ["john","大江东去","繁星","dosir"]
res = "大江东去" in listvar

tuplevar = ("john","大江东去","繁星","dosir")
res = "dosir" not in tuplevar

setvar = {"john","大江东去","繁星","dosir"}
res = "john1234" not in setvar
print(res)

# 针对于字典 dict
"""针对于字典中的键来进行判定"""
dictvar = {"fx":"聪明","xx":"美丽","stone":"风流倜傥","fei":"睿智"}
res = "美丽" in dictvar
res = "xx" in dictvar
res = "abc" not in dictvar
print(res)

# 身份运算符:  is 和 is not (检测两个数据在内存当中是否是同一个值)  

# 整型 -5 ~ 正无穷
var1 = 100
var2 = 100
res = var1 is var2
print(res)

# 浮点型 非负数范围内
var1 = -9.13
var2 = -9.13
res = var1 is var2
print(res)

# 容器类型数据,除了空元组和相同的字符串,剩下所有的容器类型数据id地址都不相同
var1 = ()
var2 = ()
var1 = [1,2]
var2 = [1,2]
res = var1 is not var2
print(res)

# 逻辑运算符:  and or not
# and 逻辑与
"""全真则真,一假则假"""
res = True and True   # True
res = True and False  # False
res = False and True  # False
res = False and False # False
print(res)

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

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

# 逻辑短路
print("<=============>")
"""
短路: 后面代码不执行
(1)True or print("我就是我,不一样的烟火") [在单个表达式或者多个表达式中,可以直接判断短路]
(2)False and print("烟花一样的灿烂,是我逝去的青春") [只能在单个表达式当中判断是否短路]

# 不发生短路
True and print("仙女一样的姑娘，是我渴望已久的愿望")
"""

res = 5 or 6
res = 5 and 6
res = not 5

# 逻辑优先级
"""从高到低排列: () > not > and > or"""
res = 5 or 6 and 7 # 5 or 7 => 5
res = 0 and 6 or 7 # 0 or 7 => 7
res = not 5 or 6 and 7 # False or 6 and 7  => False or 7 => 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1>2 and 3<4 or 5>6 and 7<8 and 100>99
"""
False and True or False and True and True
False or False and True
False or False
False
"""
print(res,"<===标注===>")

res = False and False # 返回的是第一个False
res = False or False  # 返回的是第二个False
res = False and "闻哥,你为什么这么帅气,我已经爱上了你"
res = False or "闻哥,你为什么这么帅气,我已经爱上了你"
res = "闻哥哥,我爱你爱的受不了了" or True
res = "闻哥哥,我爱你爱的受不了了" and True
print(res)

"""
额外解答:
    res = 100 or 200
    res = 0 or 200
    res = ‘‘ or 200
    print(res)

    例子:False or ? = 多少呢?
    False or True => True
    False or False => False
    False or 200 => 200
"""

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

# 按位与 &
var1 = 19
var2 = 15
res = var1 & var2
print(res)
"""
先把19转换成二进制
10011
在把15转换成二进制
01111
结果
00011
把结果在转换成十进制 => 3
"""

# 按位或 |
var1 = 19
var2 = 15
res = var1 | var2
print(res)
"""
10011
01111
11111
11111 => 十进制31
"""

# 按位异或 ^ (两个值不一样,返回真1,两个值一样,返回假0)
var1 = 19
var2 = 15
res = var1 ^ var2
print(res)
"""
10011
01111
11100
"""


# << 左移 (做乘法 乘以2的n次幂)
res = 5 << 1
print(res)
"""
000101
向左边移动一位
001010
向左边移动二位
010100  => 20

000 0
001 1
010 2
011 3
100 4
101 5
110 6
111 => 7
"""

# >> 右移 (做除法 除以2的n次幂)
res = 20 >> 2
print(res)
"""
10100
向右边移动一位
01010  => 10
向右边移动二位
00101  => 5
"""


# ~ 按位非  -(n+1)
res = ~3
res = ~(-17)
res = ~0
print(res) 
# ~19 => -20
# ~18 => -19
# ~17 => -18

# ~(-19) => 18
# ~(-18) => 17
# ~(-17) => 16


# ### 运算符总结:
"""
优先级最高的符号是 ** 幂运算
优先级最低的符号是 = 赋值运算符

整体来说: 一元运算符 > 二元运算符 优先级
一元运算符 : 同一时间,只操作一个数字的就是一元 ( ~ , - )
二元运算符 : 同一时间,只操作两个数字的就是二元 ( + - * / ..)

逻辑运算符: () > not > and > or
位运算符  : (<< >>) > & > ^ > |
算数运算符: 先算乘除,再算加减

算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符做收尾,等所有运算结束之后,赋值给等号左侧;

算位比身成逻
赋值运算做收尾
"""

res = 5+5 << 6 // 3 is 40 and False
"""
10 << 2 is 40 and False
40 is 40 and False
True and False
False
"""
print(res) # False

# 通过() 提升运算的优先级
res = (5 + 5) << (6 // 3) is 40 and False

# ### 同一文件中,数据的缓存机制 [python3.6]
# -->Number 部分
# 1.对于整型而言，-5~正无穷范围内的相同值 id一致
var1 = 100
var2 = 100
print(id(var1) , id(var2))
输出：496856384 496856384

var1 = -100
var2 = -100
print(id(var1) ,id(var2))
输出：31312816 31312848

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


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


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

# -->容器类型部分
# 5.字符串 和 空元组 相同的情况下，地址相同
var1 = "我"
var2 = "我"
print(id(var1) , id(var2))
var1 = ()
var2 = ()
print(id(var1),id(var2))

# 6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
var1 = [1,2,3]
var2 = [1,2,3]
print(id(var1) , id(var2))
输出：37564552 37564616

var1 = (1,2,3)
var2 = (1,2,3)
print(id(var1),id(var2))

# 从 sys模块 引入 intern 函数 让a，b两个变量指向同一个值
from sys import intern
a = intern(‘大帅锅&*^^1234‘*10)
b = intern(‘大帅锅&*^^1234‘*10)
print(a is b)
print(id(a),id(b))
输出：
True
6105752 6105752