python高级2：其他知识点1_python中数字2的高级表现形式-CSDN博客

本文链接：https://blog.csdn.net/laststom/article/details/78708643

第二章其他的知识点

2.1. import导入模块
2.2. 循环导入
2.3. 作用域
2.4. ==、is
2.5. 深拷贝、浅拷贝
2.6. 进制、位运算
2.7. 私有化
2.8. 属性property

2.1. import导入模块

1. import 搜索路径

import sys
sys.path

路径搜索

从上面列出的目录里依次查找要导入的模块文件
' ' 表示当前路径

程序执行时导入模块路径

sys.path.append('/home/itcast/xxx')
sys.path.insert(0, '/home/itcast/xxx')    #可以确保先搜索这个路径

In [37]: sys.path.insert(0,"/home/python/xxxx")
In [38]: sys.path
Out[38]: 
['/home/python/xxxx',
'',
'/usr/bin',
'/usr/lib/python35.zip',
'/usr/lib/python3.5',
'/usr/lib/python3.5/plat-x86_64-linux-gnu',
'/usr/lib/python3.5/lib-dynload',
'/usr/local/lib/python3.5/dist-packages',
'/usr/lib/python3/dist-packages',
'/usr/lib/python3/dist-packages/IPython/extensions',
'/home/python/.ipython']

2. 重新导入模块

模块被导入后，import module不能重新导入模块，重新导入需用

测试模块内容
调用模块中的方法
修改测试模块
重新加载模块

2.2. 循环导入

1. 什么是循环导入

a.py

from b import b 

print '---------this is module a.py----------'
def a():
   print("hello, a")
   b() 

a()

b.py

from a import a

print '----------this is module b.py----------'
def b():
   print("hello, b")

def c():
   a() 
c()

运行python a.py

2. 怎样避免循环导入

程序设计上分层，降低耦合
导入语句放在后面需要导入时再导入，例如放在函数体内导入

2.3. 作用域

什么是命名空间

比如有一个学校，有10个班级，在7班和8班中都有一个叫“小王”的同学，如果在学校的广播中呼叫“小王”时，7班和8班中的这2个人就纳闷了，你是>喊谁呢！！！如果是“7班的小王”的话，那么就很明确了，那么此时的7班就是小王所在的范围，即命名空间

globals、locals

在之前学习变量的作用域时，经常会提到局部变量和全局变量，之所有称之为局部、全局，就是因为他们的自作用的区域不同，这就是作用域

locals
globals

LEGB 规则

Python 使用 LEGB 的顺序来查找一个符号对应的对象

locals -> enclosing function -> globals -> builtins

locals，当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量
enclosing，外部嵌套函数的命名空间（闭包中常见）

def fun1():
 a = 10
 def fun2():
     # a 位于外部嵌套函数的命名空间
     print(a)

globals，全局变量，函数定义所在模块的命名空间

a = 1
def fun():
 # 需要通过 global 指令来声明全局变量
 global a
 # 修改全局变量，而不是创建一个新的 local 变量
 a = 2

builtins，内建模块的命名空间。

 Python 在启动的时候会自动为我们载入很多内建的函数、类，
 比如 dict，list，type，print，这些都位于 __builtin__ 模块中，
 可以使用 dir(__builtin__) 来查看。
 这也是为什么我们在没有 import任何模块的情况下，
 就能使用这么多丰富的函数和功能了。

 在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后，
 且没有执行程序员所写的任何代码前，Python会首先加载该内建函数到内存。
 另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀，
 其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块
 比如：内建模块中有一个abs()函数，其功能求绝对值，如abs(-20)将返回20。

2.4. ==、is

==、is

总结

is 是比较两个引用是否指向了同一个对象（引用比较）。
== 是比较两个对象是否相等。

2.5. 深拷贝、浅拷贝

1. 浅拷贝

浅拷贝是对于一个对象的顶层拷贝
通俗的理解是：拷贝了引用，并没有拷贝内容

2. 深拷贝

深拷贝是对于一个对象所有层次的拷贝(递归)

进一步理解拷贝

In [23]: a = [11,22,33]

In [24]: b = [44,55,66]

In [25]: c = (a,b)

In [26]: e = copy.deepcopy(c)

In [27]: a.append(77)

In [28]: a
Out[28]: [11, 22, 33, 77]

In [29]: b
Out[29]: [44, 55, 66]

In [30]: c
Out[30]: ([11, 22, 33, 77], [44, 55, 66])

In [31]: e
Out[31]: ([11, 22, 33], [44, 55, 66])

In [32]: 

In [32]: 

In [32]: f = copy.copy(c)

In [33]: a.append(88)

In [34]: a
Out[34]: [11, 22, 33, 77, 88]

In [35]: b
Out[35]: [44, 55, 66]

In [36]: c
Out[36]: ([11, 22, 33, 77, 88], [44, 55, 66])

In [37]: e
Out[37]: ([11, 22, 33], [44, 55, 66])

In [38]: f
Out[38]: ([11, 22, 33, 77, 88], [44, 55, 66])

3. 拷贝的其他方式

浅拷贝对不可变类型和可变类型的copy不同

In [88]: a = [11,22,33]

In [89]: b = copy.copy(a)

In [90]: id(a)
Out[90]: 59275144

In [91]: id(b)
Out[91]: 59525600

In [92]: a.append(44)

In [93]: a
Out[93]: [11, 22, 33, 44]

In [94]: b
Out[94]: [11, 22, 33]

In [95]:

In [95]:

In [95]: a = (11,22,33)

In [96]: b = copy.copy(a)

In [97]: id(a)
Out[97]: 58890680

In [98]: id(b)
Out[98]: 58890680

分片表达式可以赋值一个序列

   a = "abc"

   b = a[:]

字典的copy方法可以拷贝一个字典

   d = dict(name="zhangsan", age=27)

   co = d.copy()

有些内置函数可以生成拷贝(list)

   a = list(range(10))

   b = list(a)

copy模块中的copy函数

   import copy

   a = (1,2,3)

   b = copy.copy(a)

2.6. 进制、位运算

1、什么是进制

1）理解个X进制的概念 :

每一位只允许出现 0~X-1 这几个数字,逢X进一,基是X, 每一位有一个权值大小是X的幂次。其表示的数值可以写成按位权展开的多项式之和。

十进制: 每一位只允许出现0~9这十个数字,逢十进1,基是十,每一位数字有一个权值大小是十的幂次。 >其表示的数值可以写成按位权展开的多项式之和。

二进制: 每一位只允许出现0~1这二个数字,逢二进1,基是二, 每一位数字有一个权值大小是二的幂次。 >其表示的数值可以写成按位权展开的多项式之和。

八进制:

十六进制

2）

假如用两个字节表示一个整数，如下：
   十进制数字1 的二进制表现形式: 0000 0000 0000 0001
   十进制数字2 的二进制表现形式: 0000 0000 0000 0010
如何表示二进制数的正负？

3）有符号数和无符号数的概念

规则：把二进制数中的最高位（最左边的那位）用作符号位
   对于有符号数，最高位被计算机系统规定为符号位(0为正,1为负)
   对于无符号数，最高位被计算机系统规定为数据位
按照这种说法，比如有符号数 +2 -2 的原码形式：
+2 = 0000 0000 0000 0010
-2 = 1000 0000 0000 0010
真值      机器数
+1 = 0000 0000 0000 0001

-1 = 1000 0000 0000 0001
-----------------------------------------

      1000 0000 0000 0010
-1+1 的结果？

-1+1 = 1000 0000 0000 0010 —-》 -2

不等于0，按理说-1+1等于0才对，为什么会是-2呢？

规则
数字在计算机中，是用二进制补码的形式来保存的，因此-1 +1需要按照补码进行相加才是正确的结果

2、原码、反码、补码

1）如何计算补码？
规则:
正数：原码 = 反码 = 补码
负数：反码 = 符号位不变，其他位取反
    补码 = 反码+1
1 的原码：0000 0000 0000 0001
-1的原码：1000 0000 0000 0001
-1的反码：1111 1111 1111 1110
-1的补码：1111 1111 1111 1111
重新计算 -1+1 结果
1111 1111 1111 1111

0000 0000 0000 0001
---------------------------

0000 0000 0000 0000
2）从补码转回原码

负数补码转换原码的规则:
原码 = 补码的符号位不变 -->数据位取反--> 尾+1
-1的补码:1111 1111 1111 1111
   取反:1000 0000 0000 0000
-1的原码:1000 0000 0000 0001
【了解】

可以把减法用加法来算，只需设计加法器就好了。运算的时候都是用补码去运算的。 2-1 = 2+(-1)=0000 0000 0000 0010 +1111 1111 1111 1111

【了解】

为何要使用原码, 反码和补码既然原码才是被人脑直接识别并用于计算表示方式, 为何还会有反码和补码呢? 首先, >因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对应加减，但是对于计算机，加减乘数已经是最>基础的运算, >要设计的尽量简单。计算机辨别”符号位”显然会让计算机的基础电路设计变得十分复杂！于是人们想出了将符号位也参与运>算的方法. >我们知道，根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, >这样计算机运算的设计就更简单了.于是人们开始探索将符号位参与运算, 并且只保留加法的方法

3. 进制间转换


#10进制转为2进制

>>> bin(10)
'0b1010'


#2进制转为10进制

>>> int("1001",2)
9



#10进制转为16进制

>>> hex(10)
'0xa'


#16进制到10进制

>>> int('ff', 16)
255

>>> int('0xab', 16)
171


#16进制到2进制

>>> bin(0xa)
'0b1010'
>>>


#10进制到8进制

>>> oct(8)
'010'



#2进制到16进制

>>> hex(0b1001)
'0x9'

4. 位运算

看如下示例:

如果有一个十进制数 5，其二进制为:0000 0101

把所有的数向左移动一位 其结果为: 0000 1010

想一想:二进制 0000 1010 十进制是多少呢？？？其答案为10，有没有发现是5的2倍呢！

再假设有一个十进制数 3， 其二进制 为:0000 0011

把所有的数向左移动一位 其结果为: 0000 0110

二进制0000 0110 的十进制为6，正好也是3的2倍

通过以上2个例子，能够看出，把一个数的各位整体向左移动一个位，就变成原来的2倍

那么在Python中，怎样实现向左移动呢？还有其他的吗？？？

<1>位运算的介绍

& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 按位左移
>> 按位右移

用途: 直接操作二进制,省内存,效率高

<2>位运算

1）<< 按位左移

各二进位全部左移n位,高位丢弃,低位补0

x << n 左移 x 的所有二进制位向左移动n位,移出位删掉,移进的位补零

【注意事项】

a. 左移1位相当于 乘以2
用途:快速计算一个数乘以2的n次方 (8<<3 等同于8*2^3)
b.左移可能会改变一个数的正负性

2)>> 右移

各二进位全部右移n位,保持符号位不变

x >> n x的所有二进制位向右移动n位,移出的位删掉,移进的位补符号位 右移不会改变一个数的符号

【注意事项】

右移1位相当于 除以2
x 右移 n 位就相当于除以2的n次方 用途:快速计算一个数除以2的n次方 (8>>3 等同于8/2^3)

3)& 按位与

全1才1否则0 :只有对应的两个二进位均为1时,结果位才为1,否则为0
用6和3这个例子。不要用9 和13的例子

4) | 按位或

有1就1 只要对应的二个二进位有一个为1时,结果位就为1,否则为0

5) ^ 按位异或

不同为1 当对应的二进位相异(不相同)时,结果为1,否则为0

6) ~ 取反

~9 = -10

【为什么9取反变成了-10的说明】：

9的原码 ==> 0000 1001 因为正数的原码=反码=补码，所以在 真正存储的时候就是0000 1001

接下来进行对9的补码进行取反操作

进行取反==> 1111 0110 这就是对9 进行了取反之后的补码

既然已经知道了补码，那么接下来只要转换为 咱们人能识别的码型就可以，因此按照规则 ，把这个1111 0110 这个补码 转换为原码即可

符号位不变，其它位取反==> 1000 1001

然后+1 ，得到原码 =======>1000 1010 这就是 -10

【扩展】

1)任何数和1进行&操作,得到这个数的最低位 数字&1 = 数字的二进制形式的最低位

2)位运算优先级

2.7. 私有化

xx: 公有变量
_x: 单前置下划线,私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问
__xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到)
__xx__:双前后下划线,用户名字空间的魔法对象或属性。例如:__init__ , __ 不要自己发明这样的名字
xx_:单后置下划线,用于避免与Python关键词的冲突

通过name mangling（名字重整(目的就是以防子类意外重写基类的方法或者属性)如：_Class__object）机制就可以访问private了。


#coding=utf-8


class Person(object):
   def __init__(self, name, age, taste):
       self.name = name
       self._age = age 
       self.__taste = taste

   def showperson(self):
       print(self.name)
       print(self._age)
       print(self.__taste)

   def dowork(self):
       self._work()
       self.__away()


   def _work(self):
       print('my _work')

   def __away(self):
       print('my __away')

class Student(Person):
   def construction(self, name, age, taste):
       self.name = name
       self._age = age 
       self.__taste = taste

   def showstudent(self):
       print(self.name)
       print(self._age)
       print(self.__taste)

   @staticmethod
   def testbug():
       _Bug.showbug()


#模块内可以访问，当from  cur_module import *时，不导入

class _Bug(object):
   @staticmethod
   def showbug():
       print("showbug")

s1 = Student('jack', 25, 'football')
s1.showperson()
print('*'*20)


#无法访问__taste,导致报错


#s1.showstudent() 

s1.construction('rose', 30, 'basketball')
s1.showperson()
print('*'*20)

s1.showstudent()
print('*'*20)

Student.testbug()

总结

父类中属性名为__名字的，子类不继承，子类不能访问
如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性
_名的变量、函数、类在使用from xxx import *时都不会被导入

2.8. 属性property

1. 私有属性添加getter和setter方法

class Money(object):
   def __init__(self):
       self.__money = 0

   def getMoney(self):
       return self.__money

   def setMoney(self, value):
       if isinstance(value, int):
           self.__money = value
       else:
           print("error:不是整型数字")

2. 使用property升级getter和setter方法

class Money(object):
   def __init__(self):
       self.__money = 0

   def getMoney(self):
       return self.__money

   def setMoney(self, value):
       if isinstance(value, int):
           self.__money = value
       else:
           print("error:不是整型数字")
   money = property(getMoney, setMoney)
运行结果:

In [1]: from get_set import Money

In [2]: 

In [2]: a = Money()

In [3]: 

In [3]: a.money
Out[3]: 0

In [4]: a.money = 100

In [5]: a.money
Out[5]: 100

In [6]: a.getMoney()
Out[6]: 100

3. 使用property取代getter和setter方法

@property成为属性函数，可以对属性赋值时做必要的检查，并保证代码的清晰短小，主要有2个作用

将方法转换为只读
重新实现一个属性的设置和读取方法,可做边界判定

class Money(object):
   def __init__(self):
       self.__money = 0

   @property
   def money(self):
       return self.__money

   @money.setter
   def money(self, value):
       if isinstance(value, int):
           self.__money = value
       else:
           print("error:不是整型数字")
运行结果

In [3]: a = Money()

In [4]: 

In [4]: 

In [4]: a.money
Out[4]: 0

In [5]: a.money = 100

In [6]: a.money
Out[6]: 100