day04

1-复习

"""集合使用pop() 用于随机移除第一个元素"""
s1 = {"a", "b", "c", "d"}
print(s1)
ret = s1.pop()
print(ret)
# {'a', 'd', 'b', 'c'}
# a

2-复习-小数据池

a = 5
print(a, id(a))

 3-复习-小数据池

a = 5
print(a, id(a))

4-作业

students = [
    {"name": "A", "age": 16, "lve": ["A1", "B1", "C1"]},
    {"name": "B", "age": 17, "lve": ["A2", "B2", "C2"]},
    {"name": "C", "age": 18, "lve": ["A3", "B3", "C3"]},
]

# 第二个学生
stu = students[1]
print(stu)  # {'name': 'B', 'age': 17, 'lve': ['A2', 'B2', 'C2']}

# 第二个爱好
lve_list = stu["lve"]
lve = lve_list[1]
print(lve)  # B2

lve = students[1]["lve"][1]
print(lve)  # B2




address = {
    "110000": "北京市",
    "120000": "天津市",
    "130000": "河北省",
    "310000": "上海市",
    "320000": "江苏省",
}
# 小红的身份证号码
id_card = "130000202210011020"

# 提取小红身份证号码的地址码，并显示他的出生城市。(身份证号码前六位)
city = address[id_card[:6]]
print(city)         # 河北省

# 提取小红身份证号码的生日(身份证号码第七位到第十四位)
born = id_card[6:14]
print(born)         # 20221001

5-二维容器转字典

"""二维容器，也叫二级容器

二维列表、二级列表"""
list_data = [
    ["name", "xiaoli"],
    ["age", 15]
]
print(list_data[1][0])   # age

data = dict(list_data)
print(data)    # {'name': 'xiaoli', 'age': 15}


list_data = (
    ["name", "xiaoming"],
    ["age", 17]
)

data = dict(list_data)
print(data)  # {'name': 'xiaoming', 'age': 17}




list_data = [
    "ab",
    ["c", "d"]
]
data = dict(list_data)
print(data)     # {'a': 'b', 'c': 'd'}



list_data = (
    "ab",
    "cd"
)
data = dict(list_data)
print(data)     # {'a': 'b', 'c': 'd'}



list_data = ["c3", "c2", ("name", "xiaoming")]
dict_data = dict(list_data)
print(dict_data)    # {'c': '2', 'name': 'xiaoming'}    覆盖了

 6-运算符-算术运算符

a = 4
b = 7
c = a+b
print(c, type(c))   # 11 <class 'int'>


c = a * b
print(c)     # 28


"""除法 / 运算结果是浮点数"""
c = b / a
print(c)   # 1.75

c = 10 / 2
print(c)  # 5.0

b = 10 / 3
print(b) # 3.3333333333333335

"""整除 //"""
c = 10 // 2
print(c, type(c))  # 5 <class 'int'>

c = 10 // 3
print(c, type(c))  # 3 <class 'int'>



"""计算机中有存储上限，所有的浮点数运算，都是一种近似值的运算，得到结果都是近似值"""

"""因为计算中CPU采用的是二进制，所以实际上数值在计算机内部运算过程中，都会被先转换成二进制，才进行运算"""
ret = 7.1+0.8
print(ret)  # 7.8999999999999995

# 解决上面的隐患，所以一般要保留精度
print("%.2f" % ret)  # 7.90


"""求余 %"""
a = 10 % 3
print(a)  # 1

a = 10 % 5
print(a)  # 0


a = -10 % 4
print(a)  # 2

a = -10 % -4
print(a) # -2

a = 10 % 4
print(a)  # 2

a = 10 % -4
print(a) # -2


"""** 幂运算"""
print(3**2) # 9
print(3**3) # 27

"""水仙花数"""
print(1**1)
print(2**2)
print(3**3)
print(4**4)

7-运算符-赋值运算符

"""= 普通赋值"""
a = 10
print(a)  # 10


"""+= 加法赋值"""
age = 16
age = age + 1  # 此处，age代表的就是age+1，也就是代表16+1
print(age) # 17
# 注意：在代码中，有遇到=号的情况，先计算=号右边的。

age = 16
age += 1   # age = age + 1 的简写
print(age) # 17


"""-= 减法赋值"""
age = 16
age -= 5    # age = age - 5
print(age)  # 11

8-运算符-比较运算符

a = 4
b = 7

print(a != b)  # True   不等于 ！=
print(a < b)  # True


"""特殊情况，如果是字符串的比较，实际上是编码位置的比较，
实际上，计算机中最终运行的都是二进制，所以计算中本身是没有任何中文，或者字母的。
所以，我们锁看到的中文，字母，实际上别人提前把文字，字母录入到计算机中的一个文件里，我们要看到文字就从这个文件中提取出来的内容，
最后因为这个文件的内容中各个字符、文字、字母录入有先后，因此就有数值位置（编码位置），
因此，字符串的比较就成了编码位置的比较
计算机发展的过程中，最先录入计算机中的编码文件，是美国人录入的，叫ASCII码表，这个编码文件中主要记录了所有的大小写字母，数字，以及特殊符号
后面计算机传入了其他非英语国家，又出现了，
big5编码   繁体
gbk编码    简体
ja        日文
........
国际组织为了方便一台电脑能呈现多种不同的语言的文字，后面推出了 unicode编码，目前我们经常使用的编码就是unicode编码中的子集
utf-8
utf-8mb4
"""
print("a" > "b")  # False
print("c" > "b")  # True


"""类型不同不能比较，当然数值之间可以比较（整型，浮点型，布尔值）"""
# print("a" > 1) # 报错！TypeError: '>' not supported between instances of 'str' and 'int'


# == 只是比较两边的数值是否相等，并不能判断内存空间的地址是否相等
print(True == 1) # True

9-运算符-成员运算符

"""通过in判断指定成员是否在容器中存在"""

s = "hello"
print("e" in s)  # True
print('w' in s)  # False

"""字典通过in判断目标是否作为key存在于字典中"""
data = {
    "error": 1001,
    "errmsg": "类型有误！"
}
# data 是一个变量， "data" 是一个字符串，两者不是同一个东西
print("error" in data)    # True



"""列表，元组"""
data = ["小明", "小红"]
print("小明" in data)  # True



"""集合"""
data = {"小明", "小红"}
print("小红" in data)  # True



"""not in 判断是否不是容器的成员"""
data = {
    "data": {"id": 1, "title": "商品标题", "price": 13.6}
}

print("error" not in data)  # True

 10-运算符-身份运算符

var1 = 56
var2 = 56
res = var1 == var2  # (判断两个值是否相等)
print(res) # True
# 先计算等号=右边的代码，然后在计算左边的代码

res = var1 is var2  # (判断两个值的内存地址是否相等)
print(res) # True


"""有运算符参与，把多个数据组成一段代码的这种情况，我们一般称之为表达式，如下：
1+2
b is a
var1 == var2
当然，单个数据写在等号右边，有时候也可以认为是表达式，因为等号=本身也是运算符，如下：
a = [1,2,3]
a = 1
a = 100"""


"""is not 判断是否与目标不是在同一个内存地址"""
a = 100
print(type(a) is not int) # 判断a的类型是否不是整型 False
print(type(a) is not str) # 判断a的类型是否不是字符串类型 True

a = []
print(type(a) is not list) # 判断a是否不是列表 False

a = True
print(type(a) is not bool) # 判断a是否不是布尔型 False



"""
类型的关键字：
整型   int    浮点型 float  布尔型 bool   字符串 str

列表   list   元组 tuple    字典   dict   集合 set
"""
a = {}
print(type(a) is dict)  # True
print(type(a) is set)   # False

a = set()  # 空集合
print(type(a) is not set)  # False

 

11-运算符-逻辑运算符

"""逻辑运算符，主要用于实现多个条件的连续判断

and 与，逻辑与，有并且的意思
or  或，逻辑或，有或者的意思
not 非，逻辑非，有取反，反义，相反的意思

and 判断两个的结果是否都成立，是否都为真
如果两边都为真，则最终and运算的结果就是True
如果一边为False，则最终结果为False
"""
ret = True and True
print(ret)  # True

ret = False and True
print(ret)  # False

ret = False and False
print(ret)  # False

ret = True and False
print(ret)  # False

# 查看一个整数是否处于1~100的范围内？
num = 101
ret = num >= 1 and num <= 100
print(ret)    # False


"""or 判断两边只要有一方的结果为True，则or运算的最终结果就是True
只有两边的运算结果为False时，or运算的最终结果才是False
"""
ret = True or True
print(ret)  # True

ret = False or True
print(ret)  # True

ret = False or False
print(ret)  # False

ret = True or False
print(ret)  # True

# 判断一个密码长度是否不符合要求
# 密码长度要求必须在6-16之间

password = "123456"
length = len(password)   # 可以通过len()函数计算一个容器里面的成员的数量
print(length)  # 6

ret = length < 6 or length > 16
print(ret)   # False


"""
not 非，取反，反义，相反
not的使用，只能在后面写上数据或表达式
非真即假
非假即真
"""
ret = not True
print(ret) # False

ret = not False
print(ret)  # True


"""工作中有时候会把数据转换成布尔型，这时候，我们除了使用bool函数以外，还可以使用not"""
ret = bool(1)
print(ret) # True

ret = not not 1
print(ret)  # True

ret = not 1
print(ret)  # False



"""逻辑运算符的短路现象，主要是因为左边的运算结果已经可以让python清晰整个逻辑运算的最终结果了"""

"""
因为and要两边表达式结果都是True的时候，才是True，
如果左边是False，那么右边无论是True/False，都不会影响最终and的结果
False and False  => False
False and True   => False"""

False and print("hello")  # 逻辑短路

"""
因为or要两边表达式结果都是False的情况下，才是False
如果左边是True，那么右边无论是True/False，都不会响应最终or的结果
True or False  ==> True
True or True   ==> True"""

True or print(456)  # 逻辑短路


# 因为左边是True，所以最终and的运算结果还不确定，所以下面的print会执行
True and print(789)   # 789

False or print(123)   # 123



"""逻辑运算符的最终结果，因为存在短路现象，所以最终结果不一定就是布尔值的"""
print(2 and 1)  # 1
print(0 and 1)  # 0

print(0 or 1)  # 1
print(3 or 5)  # 3

 12-运算符-位运算

"""1bytes(1字节) = 8bit(8位)

1字节可以存储的有符号二进制的范围：  -127 ~ 127"""

print(bin(127))  # 0111 1111


"""按位与 &"""
a = 19
b = 25
print(bin(a))  # 0001 0011
print(bin(b))  # 0001 1001
"""
a --> 19  --> 0001 0011
b --> 25  --> 0001 1001
-----------------------
              0001 0001[二]  --> 17[十] 
              1 * 2**4 + 1   --> 17[十]
安位与 --> 从左往右，同位对比，同一个位置上下都是1，当前位置结果为1，否则为0
"""
print(a & b)  # 17


"""按位或 | """
a = 19
b = 25
print(bin(a))  # 0001 0011
print(bin(b))  # 0001 1001
"""
a --> 19  --> 0001 0011
b --> 25  --> 0001 1001
-----------------------
              0001 1011[二]  -->  27[十]
              1*2**4 + 1*2**3 + 1*2**1 = 16+8+2+1
"""
print(int(0b11011))  # 27
print(a | b)  # 27


"""
~ 按位取反
给补码取反
"""
a = 19
b = 25
print(bin(a))  # 0001 0011
print(bin(b))  # 0001 1001
"""

a --> 19  --> 0001 0011[补]  # 正数的补码和原码一样，再对补码转反码就是 按位取反
-----------------------
              1001 0011[补]+1
              1001 0100[反]
              --------

b --> 25  --> 0001 1001[补]
-----------------------
              1001 1001[补]+1
              1001 1010[反]
              [二]  --> [十]
"""
print(-0b10100)
print(~a)  # 12
print(-0b11010)
print(~b)  # -26


"""
^ 按位异或
从左往右，同位对比，同一个位置上下不一样，当前位置结果为1，否则为0
"""
# a = 19
# b = 25
# print(bin(a))  # 0001 0011
# print(bin(b))  # 0001 1001
"""
a --> 19  --> 0001 0011[原]
b --> 25  --> 0001 1001[原]
-----------------------
              0000 1010[二]
"""
print(0b1010)  # 10
print(a ^ b)  # 10




a = 5
print(a << 2)  # 20
"""
左移
0000 0101 ---> 5
0001 0100 ---> 20
"""

b = 4
print(b << 3)  # 32

"""
左移
0000 0100 ---> 4
0010 0000 ---> 32
"""

a = 20
print(0b10100)
print(a >> 2)  # 5
"""
右移
0001 0100  --> 20
000001 01  --> 5
"""

b = 87
print(bin(b))  # 0b1010111
print(b >> 3)  # 10
"""
右移
0101 0111  --> 87
0000 1010  --》10  
"""

"""
其他的语言中，浮点数取整
js代码中就有时候看到利用二进制取证
a = 3.14
console.log(a >> 0)
"""

 13-运算符的优先级

ret = 10 & 8 + 6 ** 2 + 1
ret = 10 & 8 + 36 + 1
ret = 10 & 45
print(bin(45))  # 0b101101
"""
0000 1010 ---> 10
0010 1101 ---> 45
-----------------
0000 1000 ---> 
"""
print(ret) # 8


ret = 6 * 3 + 2
print(ret) # 20


ret = 2 + 1 and 1 + 3
# ret = 3 and 4
print(ret)  # 4


# 再开发中都是使用小括号提升代码或者表达式的执行优先级的。
ret = (2 + (1 and 1)) + 3
print(ret) # 6