Python高级
比较
is
print(a is b) # 比较的是地址 id(a) == id(b) True
==
print(a == b) # 比较的是内容 100 == 100 True
可变类型：列表 集合set 字典
不可变类型
元组 (不可变的，但是如果两个元组中的内容虽然相同，但是是两个不同的地址)
字符串（不可变，也是共享的一块地址，字符串在"字符串驻留区"保存）
数值（不可变，但是是共享的是一块地址，在"整型池"保存）
整型： 整型常量池
拷贝
浅拷贝
copy.copy()
list1 = ["小花", 20, ["红楼梦", "多拉A梦", "火影"]]
list2 = copy.copy(list1) # 新建一块内存保存内容
1.产生新的地址保存内容
2.两种类型数据：
1.字符串 数值 只要内容改变则地址改变
2.列表 内容改变地址是不变的
使用切片[:]操作
list3 = [2, 3, 5, 6, ["a", "b", "c"], 5, 3]
list4 = list3[2:]
print(id(list3))
print(id(list4))
print([id(e) for e in list3])
print([id(e) for e in list4])
使用工厂函数（如list/dir/set）
list6 = [1, 3, 6, 3, 6]
list5 = set(list6)
print(list5)
print(list6)
print([id(e) for e in list5])
print([id(e) for e in list6])
深拷贝
copy.deepcopy()
特点
1. 字符串和数值 同浅拷贝类似
2. 可变类型：list 会新建一份
3. 如果是元组执行深拷贝，如果是纯原子类型（数值，字符串），则不能执行深拷贝
t1=(1,2,3,4)
t2=copy.deepcopy(t1)
id(t1) == id(t2)
但是如果里面出现非原子类型则可以执行深拷贝
扩展
字典 的自带方法copy() 就是一个浅拷贝
d1 = {"name": "小花", "age": 20, "books": ["猪猪侠", "火影", "蜡笔小新"]}
d2 = d1.copy()
print(d1)
print(d2)
print(d1 is d2)
list1 = d1.get("books")
list2 = d2.get("books")
print(id(list1))
print(id(list2))
作用
1.减少内存的使用
2.以后在做一些数据的清除，修改的时候，会对原数据进行复制，以防止数据修改之后，想恢复造成丢失
应用范围
浅拷贝： 切片：列表 字符串 元组
深拷贝：列表 字典 元组 字符串
进制
计算
二进制
二进制：
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*2^0+1*2^1+0*2^2+1*2^3=
8 4 2 1 ---> 11
1字节 = 8个二进制位
八进制
八进制：
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*8^0+1*8^1+0*8^2+1*8^3=
512 64 8 1 521
十六进制
十六进制：0~9 A~F
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*16^0+1*16^1+0*16^2+1*16^3=
256*16 256 16 1 4096+16+1
十进制 ----》二进制：
23 ---》
2 | 23 1
——————
2 | 11 1
——————
2 |5 1
——————
2| 2 0
——————
1
10111 ---》 16 +4+2+1 ---》23
十进制 ----》八进制
8 |23 7
——————
2
27 ---》2*8+7*1=23
代码
八进制 ----》十进制
int("0oxxx",8)
print(int("0o27", 8))
二进制 ---》十进制
int("0bxxxx",2)
print(int("0b10111", 2))
十六进制 ----十进制
int("0xa8",16)
print(int("0xa8", 16))
十进制 ---》二进制
bin 二进制
binary 二进制
print(bin(10))
十进制 ----》 八进制
oct()
print(oct(100))
十进制 ----》 十六进制
hex()
print(hex(100))
原码
1 0000 0001 原码
5 0000 0101 原码
反码
对原码取反
0---》1 1---》0
1 反码： 1111 1110
5 反码： 1111 1010
补码
原码的反码+1
补码就是负数的表述形式
1 ---》 反码： 1111 1110 ---》补码： 1111 1111
2 ---》 反码： 1111 1101 ---》补码： 1111 1110
十进制： 正数 1 负数 -1
机器中认为 最前面一位符号位 0 正 1 负数
0 000 0001 ---》1
1 000 0001 ---》-1 ？？？ -1+1 =？
位运算
0000 1010
左移：10<<2 数值<<位数 ---> 数值*2^位数
右移：10>>2 数值>>位数 ---> 数值/2^位数 取商
作用域
1. 块级作用域：（python没有）
if 5 > 3:
name = "tom"
print(name)
print(name) --->tom
python 没有块的概念
2. 局部作用域：
函数：
def func():
name="tom"
print(name)
print(name)
locals()
查看局部作用域中的变量有哪些？locals() 结果就是一个字典
3.全局作用域：
模块中的，查看：globals()
print(globals()) # 在模块中定义的全局变量，函数，类 ---》 全局的
扩展
类
类没有作用域
class Test:
# 类属性
n = 5
list1 = [Test.n * i for i in range(10)]
print(Test.n)
只能用类名调用
命名空间
就是一个字典，名称到值得映射关系。
作用域
是针对变量，是指声明的变量在程序中的适用范围
命名空间定义了某个作用域内变量名和值之间的绑定关系，作用域定义了命名空间中的变量名在多大的空间内可以访问
命名空间： 是可以看得到的。globals() locals()
私有化
_xx: 声明在模块中，在from 模块 import * 无法访问，import 模块---》不受影响
在类中不受影响的
受保护的类属性
__xxx: 在类或者模块中都是属于私有的，模块导入无法访问，类的时候，类体外侧和继承都无法访问
私有的类属性
xxx: 认为就是公有的
xx_: 避免跟关键字冲突而存在的一种命名方式
property
class Card:
def __init__(self, money, phone):
self.__money = money # 初始化
self.__phone = phone
def set_phone(self, phone):
if len(phone) == 11:
self.__phone = phone
print("手机号码修改成功！")
else:
print("手机号码修改失败！")
def get_phone(self):
return self.__phone
def set_money(self, money):
if money % 100 == 0:
self.__money += money
print("存钱成功！")
else:
print("存钱失败！")
def get_money(self):
return self.__money
money = property(get_money, set_money)
phone = property(get_phone, set_phone)
card = Card(100,"15010185644")
print(card.money)
card.money = 10000
print(card.money)
print(card.phone)
card.phone="123456"
# card.set_money(250)
#
# print(card.get_money())
私有化： 通过__xxx 将属性或者方法私有化
往往通过setter和getter方式访问私有属性
1. set_xxx 和 get_xxx
2. 在类中添加：属性对象 = property(get_xxx,set_xxx)
类对象.属性对象 ----》相当于取值 get
类对象.属性对象=100 ----》赋值 set
3. 使用装饰器：
A. 先装饰get方法使用：@property
@property
def xxx(self):
return self.__xxx
B. 使用@xxx.setter装饰set方法
@xxx.setter
def xxx(self,xxx):
赋值
C. 类对象.属性对象 ----》相当于取值 get
类对象.属性对象=100 ----》赋值 set
属性对象就是，B步骤中的xxxx
比较
is
print(a is b) # 比较的是地址 id(a) == id(b) True
==
print(a == b) # 比较的是内容 100 == 100 True
可变类型：列表 集合set 字典
不可变类型
元组 (不可变的，但是如果两个元组中的内容虽然相同，但是是两个不同的地址)
字符串（不可变，也是共享的一块地址，字符串在"字符串驻留区"保存）
数值（不可变，但是是共享的是一块地址，在"整型池"保存）
整型： 整型常量池
拷贝
浅拷贝
copy.copy()
list1 = ["小花", 20, ["红楼梦", "多拉A梦", "火影"]]
list2 = copy.copy(list1) # 新建一块内存保存内容
1.产生新的地址保存内容
2.两种类型数据：
1.字符串 数值 只要内容改变则地址改变
2.列表 内容改变地址是不变的
使用切片[:]操作
list3 = [2, 3, 5, 6, ["a", "b", "c"], 5, 3]
list4 = list3[2:]
print(id(list3))
print(id(list4))
print([id(e) for e in list3])
print([id(e) for e in list4])
使用工厂函数（如list/dir/set）
list6 = [1, 3, 6, 3, 6]
list5 = set(list6)
print(list5)
print(list6)
print([id(e) for e in list5])
print([id(e) for e in list6])
深拷贝
copy.deepcopy()
特点
1. 字符串和数值 同浅拷贝类似
2. 可变类型：list 会新建一份
3. 如果是元组执行深拷贝，如果是纯原子类型（数值，字符串），则不能执行深拷贝
t1=(1,2,3,4)
t2=copy.deepcopy(t1)
id(t1) == id(t2)
但是如果里面出现非原子类型则可以执行深拷贝
扩展
字典 的自带方法copy() 就是一个浅拷贝
d1 = {"name": "小花", "age": 20, "books": ["猪猪侠", "火影", "蜡笔小新"]}
d2 = d1.copy()
print(d1)
print(d2)
print(d1 is d2)
list1 = d1.get("books")
list2 = d2.get("books")
print(id(list1))
print(id(list2))
作用
1.减少内存的使用
2.以后在做一些数据的清除，修改的时候，会对原数据进行复制，以防止数据修改之后，想恢复造成丢失
应用范围
浅拷贝： 切片：列表 字符串 元组
深拷贝：列表 字典 元组 字符串
进制
计算
二进制
二进制：
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*2^0+1*2^1+0*2^2+1*2^3=
8 4 2 1 ---> 11
1字节 = 8个二进制位
八进制
八进制：
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*8^0+1*8^1+0*8^2+1*8^3=
512 64 8 1 521
十六进制
十六进制：0~9 A~F
第四位 第三位 第二位 第一位 十进制
1 0 1 1 1*16^0+1*16^1+0*16^2+1*16^3=
256*16 256 16 1 4096+16+1
十进制 ----》二进制：
23 ---》
2 | 23 1
——————
2 | 11 1
——————
2 |5 1
——————
2| 2 0
——————
1
10111 ---》 16 +4+2+1 ---》23
十进制 ----》八进制
8 |23 7
——————
2
27 ---》2*8+7*1=23
代码
八进制 ----》十进制
int("0oxxx",8)
print(int("0o27", 8))
二进制 ---》十进制
int("0bxxxx",2)
print(int("0b10111", 2))
十六进制 ----十进制
int("0xa8",16)
print(int("0xa8", 16))
十进制 ---》二进制
bin 二进制
binary 二进制
print(bin(10))
十进制 ----》 八进制
oct()
print(oct(100))
十进制 ----》 十六进制
hex()
print(hex(100))
原码
1 0000 0001 原码
5 0000 0101 原码
反码
对原码取反
0---》1 1---》0
1 反码： 1111 1110
5 反码： 1111 1010
补码
原码的反码+1
补码就是负数的表述形式
1 ---》 反码： 1111 1110 ---》补码： 1111 1111
2 ---》 反码： 1111 1101 ---》补码： 1111 1110
十进制： 正数 1 负数 -1
机器中认为 最前面一位符号位 0 正 1 负数
0 000 0001 ---》1
1 000 0001 ---》-1 ？？？ -1+1 =？
位运算
0000 1010
左移：10<<2 数值<<位数 ---> 数值*2^位数
右移：10>>2 数值>>位数 ---> 数值/2^位数 取商
作用域
1. 块级作用域：（python没有）
if 5 > 3:
name = "tom"
print(name)
print(name) --->tom
python 没有块的概念
2. 局部作用域：
函数：
def func():
name="tom"
print(name)
print(name)
locals()
查看局部作用域中的变量有哪些？locals() 结果就是一个字典
3.全局作用域：
模块中的，查看：globals()
print(globals()) # 在模块中定义的全局变量，函数，类 ---》 全局的
扩展
类
类没有作用域
class Test:
# 类属性
n = 5
list1 = [Test.n * i for i in range(10)]
print(Test.n)
只能用类名调用
命名空间
就是一个字典，名称到值得映射关系。
作用域
是针对变量，是指声明的变量在程序中的适用范围
命名空间定义了某个作用域内变量名和值之间的绑定关系，作用域定义了命名空间中的变量名在多大的空间内可以访问
命名空间： 是可以看得到的。globals() locals()
私有化
_xx: 声明在模块中，在from 模块 import * 无法访问，import 模块---》不受影响
在类中不受影响的
受保护的类属性
__xxx: 在类或者模块中都是属于私有的，模块导入无法访问，类的时候，类体外侧和继承都无法访问
私有的类属性
xxx: 认为就是公有的
xx_: 避免跟关键字冲突而存在的一种命名方式
property
class Card:
def __init__(self, money, phone):
self.__money = money # 初始化
self.__phone = phone
def set_phone(self, phone):
if len(phone) == 11:
self.__phone = phone
print("手机号码修改成功！")
else:
print("手机号码修改失败！")
def get_phone(self):
return self.__phone
def set_money(self, money):
if money % 100 == 0:
self.__money += money
print("存钱成功！")
else:
print("存钱失败！")
def get_money(self):
return self.__money
money = property(get_money, set_money)
phone = property(get_phone, set_phone)
card = Card(100,"15010185644")
print(card.money)
card.money = 10000
print(card.money)
print(card.phone)
card.phone="123456"
# card.set_money(250)
#
# print(card.get_money())
私有化： 通过__xxx 将属性或者方法私有化
往往通过setter和getter方式访问私有属性
1. set_xxx 和 get_xxx
2. 在类中添加：属性对象 = property(get_xxx,set_xxx)
类对象.属性对象 ----》相当于取值 get
类对象.属性对象=100 ----》赋值 set
3. 使用装饰器：
A. 先装饰get方法使用：@property
@property
def xxx(self):
return self.__xxx
B. 使用@xxx.setter装饰set方法
@xxx.setter
def xxx(self,xxx):
赋值
C. 类对象.属性对象 ----》相当于取值 get
类对象.属性对象=100 ----》赋值 set
属性对象就是，B步骤中的xxxx