python就业班1_

综下所述：有两个知识点：

（1）sys.path

import sys
sys.path 
这个打印出来导入的模块，搜索的路径，需要要添加的话，
sys.path.append('../')的形式添加。

(2)reload(test)

import 后，程序运行过程中更改，函数并不会更改，如果要刷新函数
from imp import *
reload(test)
才会重新加载test.py函数。

（3）循环导入
a.py b.py
a 与 b 相互以调用，这样就会出现循环导入的问题。
在设计的初始阶段，应该避免这种调用方法。
（4）== 与 is
== 判断，值 是否相等
is 判断是否是同一个东西
c=a ,是引用传递，
id(a) 查看a对象的内存地址。
（5）深拷贝、浅拷贝

浅拷贝
	a=[11,22,33]
	b=a
深拷贝
	import copy
	a=[11,22,33]
	c=copy.deepcopy(a)
	copy.copy()
		 可变类型：copy第一层(列表【】)
		 不可变类型：不copy (元组())
	copy.deepcopy()
		可变类型和不可变类型，都copy
		如果有引用，继续copy.

（6）进制、位运算

（7）原码、反码、补码

（8）位运算，&

左移*2   5<<1   10
右移/2	10>>1	5
按位与	&		全1才1，否则0 ，逐位进行与运算。
按位或	|		全0才0，否则1	
按位异或	^	    相同为1，不同为0 
取反		~		取相反	

（9）property

方式一：
	class Test(object):
		def __init__(self):
			self.__num=100
		def getNum(self):
			return self.__num
		def setNum(self,newValue):
			self.__num=newValue
		num=property(getNum,setNum)
	t=Test()
	print(t.num)
	t.num=200
	print(t.num)
  方式二：装饰器
	class Test(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:
				return "error value type".
	t=Test()
	print(t.money)
	t.money=200
	print(t.money)

1.知识点

导入
循环导入
作用域
== is
深copy,浅 copy
禁制，位运算
私有化
其他的知识点

2.import导入模块

import xxx
=>ImportError :No module named 'xxx'

import sys
sys.path
=>打印出列表。显示，导入包时，搜索的路径。
sys.path
['',
'/usr/lib/python35.zip',
...]
这是一个列表，列表支持append .

sys.path.append('/home') .添加home路径到sys.path的查询路径上。

import .导入之后的模块，如果运行Python后就会一直用之前import 的内容，这个时候，如果程序发生了变化，import 的内容，
不会发生变化。

(2)重新加载：
如果在程序运行的过程中，要重新加载程序：
from imp import *
reload(test)

3.循环导入
a.py
b.py
a要导入b，b还要导入a的情况。

一大半的错误，都是自己刚开始的时候，没有注意到错误引起的。
b.py
def b():
	print("------b-----")
a.py
from b import b
def a():
	print("-------a---")
	b()
a()
然后运行调用，python a.py
就会输出了，之前一直报错，EOLError ,for why ,because i forget the "" of b function .

4. == 与 is
   a=[11,22,33]
   b=[11,22,33]
   a==b
   True
   a is b
   False
   c=a
   c is a
   True
   id(a) 140664155920392
   id(b) 140664155926664
   id(c) 140664155920392

   c=a ,传递的是a的内存的引用。实际指向同一个东西。
   如果这个时候，a的内容更改，会重新创建列表。
   这时候 c is a False .即c 和 a 将不再是同1个东西。

   a=100
   b=100
   a ==b True
   a is b True .
   a=10000
   b=10000
   a=b True
   a is b False
   在python 中，如果值在-126-127之间，则is 的时候是相同的，除此之外是不相同的。
   5.深拷贝、浅拷贝

   浅拷贝：引用地址的传递，没有开辟新内存创建。
   a=[11,22,33]
   b=a
   a is b
   True
   深拷贝：将对象的内存内容重新创建，如果有引用，引用的对象也重新创建。
   import copy
   a=[11,22,33]
   c=copy.deepcopy(a)
   这个是深copy,id(a)!=id(b)
   a=[11,22,33,44],此时，b也会更改为[11,22,33,44]
   c不会更改
   深拷贝：（copy.deepcopy()--如果里面有引用，就接着copy）
   a=[11,22,33]
   b=[44,55,66]
   c=[a,b]
   d=c
   e=copy.deepcopy(c)

    a.append(44)
    d
    [[11,22,33,44],[44,55,66]]
    e
    [[11,22,33],[44,55,66]]
    元组，和列表，都会发生copy变化。
   

   深拷贝：(copy.copy()--仅copy第一层。是可变类型，copy一层， 不可变类型，不copy)
   a=[1,2,3]
   b=[4,5,6]
   c=[a,b]
   e=copy.copy(c)
   a.append(4)
   c
   [[1,2,3,4],[4,5,6]]
   e
   [[1,2,3,4],[4,5,6]]
   如果是列表【】，第一层是copy 的。
   如果是元组（），第一层不copy .
   元组特点：（不可变类型）copy可以判断是否是可变类型。
   6.进制、位运算

   进制

    十进制、二进制、八进制、十六进制
   

   转换

7.原码、反码、补码

1个字节有8位
1B=8bit

0000	0000	0000	0001
第一个0 用来表示符号。（0为正，1为负）

+2
0000	0000	0000	0010
-2
1000	0000	0000	0010

+1 与 -1 相加
0000	0000	0000	0001
1000	0000	0000	0001
=》
1000	0000	0000	0010
结果是-2 .是错误的。

规则：
正数： 原码  =  反码  = 补码
负数： 反码  = 符号位不变.其他取反
	  补码  =  反码 + 1
      原码  = 补码的符号为不变--》数据位取反+1
补码相加

溢出：
CPU小模块，加法比较快。减法慢。

十进制转二进制：bin(18)	0b10010
十进制转八进制：oct(18)	0o22
十进制转十六进制：hex(18) 0x12

十六进制转十进制：int('0x12',16)
八进制转换十进制：int('0o22',8)

8.位运算

对数值，进行bit位运算。

乘法运算：
	转换成二进制，往左移动。每移动一次，乘以2。而且效率很高。
问：如何快速对两个值，进行相乘？
	左移和右移动，速度很快，效率很高。

5<<1	10
5<<3	40
10>>1	5

位移运算符：>> ,<< 
<<,>> 位运算作用：快速进行乘法和除法。
2*3	
	2<<1 +2

运算，都是对补码，进行运算。
~9  ==-10 
9的原码：0000	1001
9的补码：0000	1001	
对补码取反：1111	0110
转成原码：1000	1010
就是 -10 .		

9.私有化

__init__() 无法访问，私有化。
python中 ”__“代表私有化。

如果子类，继承了原来的类，那么子类，不能访问原来的类的私有化的属性。
（1）
__属性	私有属性
__方法	私有方法
	私有属性，私有方法，类外面，不能用
	子类，不能继承的。子类不能直接调用。
（2）
属性
方法
	公有变量
（3）
__属性__
__方法__
	系统提供的方法，自己不要写这样的符号
（4）
_属性
_方法
	模块内可用，模块外不能用。私有化属性和方法。
	from somemodule import * .
	禁止导入，类内部和子类可以用。
    名字重整
	__xx__ 系统的方法
	_x: 类内部可访问方法。

10.property

class Test(object):
	def __init__(self):
		self.__num=100
	def getNum(self):
		return self.__num
	def setNum(self,newNum):
		self.__num=newNum
t=Test()
print(t.num)
t.num=200
print(t.num)

property的作用，相当于对方法进行了封装，开发者对属性设置数据的时候更加方便。
（1）property用法一：
	class Test(object):
		def __init__(self):
			self.__num=100	
		def getNum(self):
			return self.__num	
		def setNum(self,newNum):
			self.__num=value
		num=property(getNum,setNum)
	t=Test()
	print(t.num)
	t.mum=200
	print(t.num)
(2)property用法二
 	class Test(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:not int type")