python就业班1_

最新推荐文章于 2023-04-07 10:40:39 发布

weixin_30908941

最新推荐文章于 2023-04-07 10:40:39 发布

阅读量191

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/sujingnuli/p/10122664.html

版权

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

（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 .

== 与 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")

转载于:https://www.cnblogs.com/sujingnuli/p/10122664.html

weixin_30908941

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python就业班1_

综下所述：有两个知识点：（1）sys.pathimport syssys.path 这个打印出来导入的模块，搜索的路径，需要要添加的话，sys.path.append('../')的形式添加。(2)reload(test)import 后，程序运行过程中更改，函数并不会更改，如果要刷新函数from imp import *reload(test)才会重新加载test.py函数。...
复制链接

扫一扫