【Python数据魔术】：揭秘类型奥秘，赋能代码创造

"""
1.举个例子，在python命令行模式下：为什么同样值a,b与c,d的结果却不一样呢？
"""
>>> a = 1000
>>> b = 1000
>>> a is b
False
>>> c = 10
>>> d = 10
>>> c is d
True

# 注意，因为python对小整数在内存中直接创建了一份，不会回收，所有创建的小整数变量直接从对象池中引用即可。
# 但是注意Python仅仅对比较小的整数对象进行缓存（范围为范围[-5, 256]）缓存起来，而并非是所有整数对象。
# 也就说只有在这个[-5,256]范围内创建的变量值使用is比较时候才会成立。

# 注意: python中创建两个内容一样的变量时（变量名不一样），
#       一般都会在内存中分配两个内存地址(id地址)分别给这两个变量。
#       即两个变量的内容虽然一样，但是变量的引用地址不一样。
#       所以两个变量使用==比较成立，但是使用 is比较不成立。

# 但是在python中有两个意外情况：
# 1.使用python命令行时对于小整数[-5,256]区间内的整数,python会创建小整数对象池，这些对象一旦创建，
#     就不会回收，所有新创建的在这个范围的整数都是直接引用他即可。
#     所以造成在[-5,256]区间内的整数不同变量只要值相同，引用地址也相同。
#     此范围外的整数同样遵循新建一个变量赋予一个地址。

# 2.python中虽然字符串对象也是不可变对象,但python有个intern机制，
#     简单说就是维护一个字典，这个字典维护已经创建字符串(key)和它的字符串对象的地址(value),
#     每次创建字符串对象都会和这个字典比较,没有就创建，重复了就用指针进行引用就可以了。
#     相当于python对于字符串也是采用了对象池原理。
#     (但是注意：如果字符串（含有空格），不可修改，没开启intern机制，不共用对象。
#     比如"a b"和"a b",这种情况使用is不成立的形式 只有在命令行中可以。
#     使用pycharm同样是True，因为做了优化)
    

# 交互式模式（命令行模式）
>>> a ='abc'   #没有空格内容一样的两个变量，在命令行模式下is 结果True
>>> b = 'abc'
>>> a ==b
True
>>> a is b
True
>>> c ='a b '   #有空格内容一样的两个变量，在命令行模式下is 结果false
>>> d= 'a b '
>>> c ==d
True
>>> c is d
False

# pycharm自己实践

str1 = [1, 2, 3, '哈哈哈']

print(1 in str1)  # True
print(1 not in str1)  # False

a = 1

a += 1  # 展开形式：a = a + 1

print(a)  # 2

print(2 > 1)  # True

# 比较结果为布尔值（True， False）

a = 1
b = 1
c = 2

# and 两边为真则为真，其余情况为假
print(a > 0 and a < c)  # True
print(a > 1 and a < c)  # False

# or 两边为假则为假， 其余情况为真
print(a > 0 and a < b)  # False
print(a == 1 and a < c)  # True

# not: 取反
print(not c < a)  # True

# 优先级： not and or
a = 1
b = 1
c = 2

print(a > 1 and c < 3 or not a == 1) # False

# 字符前存在\，在特定情况下字符就不再表示本身的意思

# --- 交互界面 ---
>>> print('a\000c')
a c
>>> print('a\0c')
a c

统一码（Unicode），也叫万国码、单一码，由统一码联盟开发，是计算机科学领域里的一项业界标准，包括字符集、编码方案等。
统一码是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

s = "Hello, 你好"
b = s.encode(encoding="utf-8", errors="strict")
print(b)    # 输出： b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd'

b = b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd'
s = b.decode(encoding="utf-8", errors="strict")
print(s)    # 输出：Hello, 你好

dec = 255

# 十进制转二进制
bin_str = bin(dec)
print(bin_str)   # 输出 '0b11111111'

# 十进制转八进制
oct_str = oct(dec)
print(oct_str)   # 输出 '0o377'

# 十进制转十六进制
hex_str = hex(dec)
print(hex_str)   # 输出 '0xff'

# 字符串转整数（删除前缀 -- 通过切片处理）
int_val = int(bin_str[2:], 2)
print(int_val)   # 输出 255

int_val = int(oct_str[2:], 8)
print(int_val)   # 输出 255

int_val = int(hex_str[2:], 16)
print(int_val)   # 输出 255

# ord() 是 Python 内置函数之一，用于将ASCII字符转换为对应的 Unicode 码点。具体而言，ord() 接受一个字符串参数，表示要转换为码点的字符，然后返回该字符所对应的 Unicode 码点。
# 将字符转换为 Unicode 编码
print(ord('A'))    # 输出 65
print(ord('a'))    # 输出 97
print(ord('€'))   # 输出 8364

# chr() 是 Python 内置函数之一，用于将 Unicode 码点转换为对应的ASCII字符。具体而言，chr() 接受一个整数参数，表示 Unicode 码点（介于 0 到 0x10ffff 之间），并返回与该码点相对应的字符。
# 将 Unicode 编码转换为字符
print(chr(65))    # 输出 'A'
print(chr(97))    # 输出 'a'
print(chr(8364))  # 输出 '€'

l1 = [1234, 5678, 910]

l2 = ['a', l1]

l3 = l2.copy()

l1.append('帅')

>>> id(l1)
1750917116360
>>> id(l2)
1750917140744
>>> id(l2[1])
1750917116360
# 内层id地址相同

print(id(l2))  # 2429073232384
print(id(l2[1]))  # 2104199485056
print(id(l3))  # 2429073240128
print(id(l3[1]))  # 2104199485056

# 浅复制 外层不同，内层id相同

import copy
l1 = [1234, 5678, 910]

l2 = ['a', l1]

l4 = copy.deepcopy(l2)

l1.append('帅')

print(id(l1))  # 1633334532096
print(id(l2))  # 1633334532352
print(id(l4))  # 1633334448384
print(id(l2[1]))  # 1633334532096

print(id(l2[0]))  # 1633303890928
print(id(l4[0]))  # 1633303890928
print(id(l4[1]))  # 1633334532672

l2[0] = 1234
print(id(l4[0]))  # 外层地址不同
print(id(l2[0]))  

# 内外层都不同

# 当然还有 id，type这些常见方法

# isinstance(x, A_tuple) --- 判断 x 是否是 A_tuple类型；注意A_tuple也可以是元组包多个，案例如下：

print(isinstance('a', list)) # False

# isinstance(x, (A, B, ...))  相当于isinstance(x, A) or isinstance(x, B) or ...

a = b = c = [1, 2, 3, 4]

# 其id相同，引用的同一组数据
# 改变其中一组， 另外一组也会改变

a = [1, 2]
b, c = a
# a--1   b--2

# 注意： 常规解包， 多少个元素就需要多少变量去解


demo = [1, 2, 3, 4]
data, *lets = demo

# data -- 1   lets -- [2, 3, 4]

# 注意： 这里利用了不定长参数中的 * ， 不限接收数据多少

a = 1
b = 2

b, a = a, b
# a -- 2    b -- 1