python进阶篇
Posted levelstrcpy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python进阶篇相关的知识，希望对你有一定的参考价值。
python进阶篇
import 导入模块
sys.path:获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到。
? import sys
? sys.path.append("")
重新导入模块
? reload(模块)
==、is
a = [11,22,33]
b = [11,22,33]
>>>a == b
True
>>>a is b
False
>>>a = c
>>>a is c
True
数字在一定范围内a is b，True,其他范围False
深拷贝和浅拷贝
? a = [11,22,33]
? b =a
? >>>id(a)==id(b)
? True
? 没有复制数据，只是把指向的位置复制给它就是浅拷贝
? import copy
? c = copy.deepcopy(a)
? id(a)和id(c)不同，深拷贝
? a = [11,22,33]
? b = [44,55,66]
? c = [a,b]
? d = copy.deepcopy(c)
? e = copy.copy(c)
? a.append(44)
? >>>c[0]
? [11,22,33,44]
? >>>d[0]
? [11,22,33]
? >>>e[0]
? [11,22,33,44]
copy.copy()列表后，id 也不同，但是会持续拷贝
改为元组后，copy.copy()，id相同,元组不可变类型，直接浅拷贝
copy.copy()根据可变不可变类型，功能不同
十进制，二进制，八进制，十六进制之间的转换
私有化
xx：公有变量
_x:from somemodule import * 禁止导入，类对象和子类可以访问
__xx:双前置下划线，避免与子类中的属性命名冲突，无法在外部直接访问
___xx___:双前后下划线，对象或属性
xx_:单后置下划线，用于避免与python关键字的冲突
###### 1.私有属性添加getter和setter方法
?
```python
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方法
?
```python
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)```
注意:
t.num到底是调用getNum()还是setNum(),要根据实际场景来判断；
如果是给t.num赋值，那么一定是调用setNum()
如果是获取t.num的值，那么就一定调用getNum()
property的作用：相当于把方法进行了封装，开发者在对属性设置数据的时候更方便
?
```python
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:不是整型数字")```
?
#### 迭代器
1.可迭代对象
直接作用于for循环的数据类型有以下几种：
一种是集合数据类型，如list,tuple,dict,set,str等；
一种是generator,包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象:lterable。
##### 2.判断是否可以迭代
可以使用isinstance()判断一个对象是否是lterable:
```python
from collections import Iterableisinstance("abc",Iterable) >>>True```
?
##### 3.迭代器
可以被next()函数调用并不断返回下一值的对象成为迭代器：Iterator
? from collections import Iterator
? isinstance([],Iterator)
? >>>False
? isinstance((x for x in range(10)),Iterator)
? >>>True
##### 4.iter()函数
生成器都是Iterator对象，但list、dict、str虽然是Iterable,却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
? isinstance(iter([]),Iterator)
? >>>True
#### 闭包
```python
#在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包def test(number): print("----1------") def test_in(number2): print("------2----") print(number-number2) print("-----3-----") return test_in ret = test(100) ret(1) \>>>----1------ -----3----- ------2---- 99 def test(a,b): def test_in(x): print(a*x+b) return test_in line1 = test(1,1) line1(0) line2 = test(10,4) line2(0) line1(0)```
?
#### 装饰器
? def w1(func):
? def inner():
? print("----正在验证权限------")
? func()
? return inner
? def f1():
? print("----f1-----")
? def f2():
? print("----f2-----")
? innerFunc = w1(f1)
? innerFunc()
f1 赋值地址，f1()调用函数
? def w1(func):
? def inner():
? print("----正在验证权限------")
? func()
? return inner
? def f1():
? print("----f1-----")
? def f2():
? print("----f2-----")
? f1 = w1(f1)
? f1()
@w1等价于w1(f1)
def w1(func):
? def inner():
? print("----正在验证权限------")
? func()
? return inner
? @w1
? def f1():
? print("----f1-----")
? @w1
? def f2():
? print("----f2-----")
? f1()
? f2()
###### 多个装饰器
? def makeBold(fn):
? def wrapped():
? print("----1------")
? return "" + fn() + ""
? return wrapped
? def makeItalic(fn):
? def wrapped():
? print("----2------")
? return "" + fn() +""
? return wrapped
? @makeBold#只要python解释器执行到了这个代码，那么就会自动进行装饰，而不是等到调用才装饰的
? @makeItalic
? def test3():
? print("--------3-----")
? return "hello world-3"
? ret = test3()
? print(ret)
? >>>----1------
? ----2------
? --------3-----
? hello world-3
从上往下执行，从下往上装饰
? def w1(func):
? print("----正在装饰1-----")
? def inner():
? print("------正在验证权限1-----")
? def w2(func):
? print("---- 正在装饰2-----")
? def inner():
? print("----正在验证权限2----")
? func()
? return inner()
? @w1
? @w2
? def f1():
? print("----f1----")
? f1() #在调用f1之前，已经进行装饰了
? >>>---- 正在装饰2-----
? ----正在装饰1-----
? ------正在验证权限1-----
? ----正在验证权限2----
? ----f1----
###### 装饰器对有参数，无参数函数进行装饰
```python
def func(functionName):print("----func---1---") def fun_in(*args,**kwargs):#定义不定长参数 print("---func_in---1---") functionName（*args,**kwargs) print("---func_in---2---") print("---func---2---") return func_in @func def test1(a,b,c): print("----test-a=%d,b=%d,c=%d---"%(a,b,c)) @func def test2(a,b,c,d): print("----test-a=%d,b=%d,c=%d,d=%d---"%(a,b,c,d)) test1(11,22,33) test2(44,55,66,77) \>>>----func---1--- ---func---2--- ---func---1--- ---func---2--- ---func_in---1--- ----test-a=11,b=22,c=33--- ---func_in---2--- ---func_in---1--- ----test-a=44,b=55,c=66,d=77--- ---func_in---2---```
###### 装饰器对带有返回值的参数进行装饰
```python
def func(functionName):print("---func---1---") def func_in(): print("---func_in---1---") ret = functionName()#保存返回来的haha print("---func_in---2---") return ret #把haha返回到调用处 print("---func---2---") @func def test(): print("----test----") return "haha" ret = test() print("test return value is %s"%ret)带有参数的装饰器
def func_arg(arg): def func(functionName): def func_in(): print("---记录日志-arg=%s--"%arg) if arg =="heihei": functionName() functionName() else: functionName() return func_in() return func @func_arg("heihei")#带有参数的装饰器，能够起到在运行时，有不同的功能 def test(): print("--test--") @func_arg("haha") def test2(): print("--test2--") test() test2()```
?
#### 作用域
###### LEGB规则
locals -> enclosing function -> globals -> builtings
locals:当前所在命名空间
enclosing function:外部嵌套函数的命名空间（闭包中常见）
globals:全局变量
builtings：内嵌
##### 动态添加属性和方法
添加属性 类/实例.属性 = XX
添加方法 不能按上面方法，
? import types.MethodType
? 绑定的对象.函数名() = types.MethodType(函数名,绑定的对象)
###### __slots__
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量来限制class实例能添加的属性：
```python
class Person(object):
slots = ("name","age")P = Person()
P.name = "老王"
P.age = 20
#添加其他属性会报错
```##### 生成器
一边循环一边计算
###### 创建生成器方法
1.把列表生成式的[]改成(),通过next函数获取生成器的下一个返回值
python def creatNum(): print("-----start-----") a,b = 0,1 for i in range(5): print("----1----") yield b #程序停下来，把yield后面的值返回 print("----2----") a,b = b,a+b print("----3----") print("----stop----") \>>>a = creatNum() \>>>a <generator object creatNum at 0x7f42d27de7d8> \>>>next(a) -----start----- ----1---- 1 \>>>next(a)#等价于a.__next__() ----2---- ----3---- ----1---- 1python def test(): i = 0 while i<5: temp = yield i print(temp) i+=1 \>>>t = test() \>>>t.__next__() [out] 0 \>>>t.__next__() None [out] 1 \>>>t.__next__() None [out] 2 \>>>t.send("haha") haha [out] 3##### 类当作装饰器
定义一个__call__方法，类就可以直接调用
class Test(object):
def __init__(self,func):
print("---初始化---")
print("func name is %s"%func.__name__)
self.__func = func
def __call__(self):
print("---装饰器中的功能---")
self.__func()
@Test
def test():#当用Test来装作装饰器对test函数进行装饰的时候，首先会创建一个Test的实例对象,func指向test(),func.__name__函数名
print("---test---")
test()元类
类也是一个对象
使用type创建类
python = type(类名，由父类名称组成的元组(针对继承的情况可以为空)，包含属性的字典) Person = type("Person",(),{"num":0}) p1 = Person() \>>>p1.num 0 def printNum(self): print("---num-%d---"%self.num) \>>>Test3 = type（"Test3",(),{"printNum":printnum}） t1 = Test3() t1.num = 100 t1.printNum() ---num-100---
__metaclass__属性
def upper_attr(future_class_name,future_class_parents,future_class_attr):
#遍历属性字典，把不是__开头的属性名字变为大写
newAttr = {}
for name,value in future_class_attr.items():
if not name.startswith("__"):
newAttr[name.upper()] = value
#调用type来创建一个类
return type(future_class_name,future_class_parents,newAttr)
class Foo(object,metaclass = upper_attr):
#设置Foo类的元类为upper_attr
bar = "bip"
print(hasattr(Foo,‘bar‘))
print(hasattr(Foo,‘BAR‘))
f = Foo()
print(f.BAR)垃圾回收
1.小整数对象池
[-5,257)这些整数对象是提前建立好的，不会被垃圾回收。在一个python程序中，所有位于这个范围内的整数使用的都是同一个对象
2.大整数对象池
3.intern机制
- 小整数共用对象，常驻内存
- 单个字符共用对象，常驻内存
- 单个单词，不可修改，默认开启intern机制，共用对象，引用计数为0，则销毁
Garbage collection（GC垃圾回收)
python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的 策略
引用计数机制的优点：
- 简单
- 实用性：一旦没有引用，内存就直接释放了。处理回收内存的时间分摊到了平时
缺点：
维护引用计数消耗资源
循环引用
python list1 = [] list2 = [] list1.append(list2) list2.append(list1)
相互引用，list1与list2的引用计数也仍然为1，所占用的内存永远无法被回收。
链表引用计数，分代收集
1.引用计数+1的情况
- 对象被创建，例如a=23
- 对象被引用，例如b =a
- 对象被作为参数，传入到一个函数中，例如func(a)
- 对象作为一个元素，存储在容器中，例如list1=[a,a]
2.引用计数-1的情况
- 对象的别名被显式销毁，例如del a
- 对象的别名被赋予新的对象，例如a=24
- 一个对象离开他的作用域，例如func函数执行完毕时，func函数中的局部变量（全局变量不会）
- 对象所在的容器被销毁，或从容器中删除对象
3.查看一个对象的引用计数
python import sys a = "hello world" sys.getrefcount(a) \>>>2
python import gc#gc默认运行 gc.disable()#关闭gc gc.collect()#手动调用collect
##### 内建属性
| 常用专有属性 | 说明 | 触法方式 |
|---|---|---|
| __init__ | 构造初始化函数 | 创建实例后，赋值时使用，在__new__后 |
| __new__ | 生成实例所需属性 | 创建实例时 |
| __class__ | 实例所在的类 | 实例.__class__ |
| __str__ | 实例字符串表示，可读性 | print(类属性)，如没实现，使用repr结果 |
| __repr__ | 实例字符串表示，准确性 | 类实例 回车 或者print(repr(类实例)) |
| __del__ | 析构 | del删除实例 |
| __dict__ | 实例自定义属性 | vars(实例.__dict__) |
| __doc__ | 类文档，子类不能继承 | help(类或实例) |
| __getattribute__ | 属性访问拦截器 | 访问实例属性时 |
| __base__ | 类的所有父类构成元素 | 类名.__bases__ |
#### 内建函数
###### map函数
map(function,sequence[,sequence,...]) -> list
- function：是一个函数
- sequence:是一个或多个序列，取决于function需要几个参数
- 返回值是一个list
```python
#函数需要一个参数
map(lambda x:x*x,[1,2,3])
# 结果为:[1,4,9]
#函数需要两个参数
map(lambda x, y: x+y,[1,2,3],[4,5,6])
#结果为：[5,7,9]
def f1(x, y):
return (x,y)
l1 =[0,1,2,3,4,5,6]
l2 =[‘Sun‘,‘M‘,‘T‘,‘W‘,‘T‘,‘F‘,‘S‘]
l3 =map(f1,l1,l2)
print(list(l3))
#结果为：[(0,‘Sun‘),(1,‘M‘),(2,‘T‘),(3,‘W‘),(4,‘T‘),(5,‘F‘),(6,‘S‘)]
```
##### filter函数
对指定对象执行过滤
filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为Ture的元素。
返回值的类型和参数sequence的类型相同
python filter(lambda x: x%2,[1,2,3,4]) [1,3] filter(None,"she") ‘she‘
##### reduce函数
reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。第一次调用function时，如果提供initial参数,会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function.注意function函数不能为None。
```python
reduce(lambda x, y: x+y,[1,2,3,4])
10
reduce(lambda x,y:x+y,[1,2,3,4],5)
15
reduce(lambda x, y:x+y,[‘aa‘,‘bb‘,‘cc‘],‘dd‘)
‘ddaabbcc‘
python3里面reduce函数要先引入:from functools import reduce
```
##### sorted函数
```python
a = [55,22,77,99]
a.sort()
>>>a
[22,55,77,99]
a.sort(reverse=Ture)
>>>a
[99,77,55,22]
sorted([1,5,4,2])
>>>[1,2,4,5]
sorted([1,5,4,2],reverse=1)
>>>[5,4,2,1]
```
#### 集合set
```python
a=[11,55,44,22,11,11]
b = set(a)
>>>b
{11,55,44,22}
>>>a=list(b)
>>>a
[11,55,44,22]
a = "abcdef"
b = set(a)
>>>b
{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘}
A="bdfhuy"
B = set(A)
>>>B
{‘b‘,‘d‘,‘f‘,‘h‘,‘u‘,‘y‘}
>>>b&B
{‘b‘,‘d‘,‘f‘}
>>>b|B
{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f,‘h‘,‘u‘,‘y‘}
>>>b-B
{‘a‘,‘c‘,‘e‘}
>>>b^B
{‘a‘,‘c‘,‘e‘,‘h‘,‘u‘,‘y‘}
```
##### functools
###### partial函数
```python
import functools
def showarg(*args,**kw):
print(arg)
print(kw)
p1=functools.partial(showarg,1,2,3)
p1()
p1(4,5,6)
p1(a=‘python‘,b=‘itcast‘)
>>>(1,2,3)
{}
(1,2,3,4,5,6)
{}
(1,2,3)
{‘a‘:‘python‘,‘b‘:‘itcast‘}
```
###### wraps函数
使用装饰器时，被装饰后的函数其实已经是另外一个函数（函数名等函数属性会发生改变，functools包中提供了叫warps的装饰器来消除这样的副作用。
import functools
def note(func):
"note function"
@functools.wraps(func)
def wrapper():
"wrapper function"
print(‘note something‘)
return func()
return wrapper
@note
def test():
"test function"
print(‘I am test‘)
test()
print(test.__doc__)模块
hashlib加密算法
import hashlib
m = hashlib.md5()#创建hash对象，md5
print m
m.update(‘itcast‘)#更新哈希对象以字符串参数
print(m.hexdigest())#返回十六进制数字字符串以上是关于python进阶篇的主要内容，如果未能解决你的问题，请参考以下文章