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)

```

注意:

  1. t.num到底是调用getNum()还是setNum(),要根据实际场景来判断;

  2. 如果是给t.num赋值,那么一定是调用setNum()

  3. 如果是获取t.num的值,那么就一定调用getNum()

  4. 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 Iterable

    isinstance("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---- 1

    python 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进阶篇的主要内容,如果未能解决你的问题,请参考以下文章

Python进阶第十篇模块(上)

[资料分享]Python视频教程(基础篇进阶篇项目篇)

python 基础篇 12 装饰器进阶

Python面试重点(进阶篇)

Python 进阶篇

Python之路第十七篇Django进阶篇