python进阶篇

标签：实用   star   私有化   不定长参数   迭代器   策略   不同   类型   闭包   

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

##### 内建属性

#### 内建函数

###### 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进阶篇

标签：实用   star   私有化   不定长参数   迭代器   策略   不同   类型   闭包   

原文地址：https://www.cnblogs.com/levelstrcpy/p/8996676.html