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方法

  ​

  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方法

  ​

  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的作用：相当于把方法进行了封装，开发者在对属性设置数据的时候更方便

     ​

     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:

     	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

     闭包

     	#在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
     
     	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----

     装饰器对有参数，无参数函数进行装饰

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

     装饰器对带有返回值的参数进行装饰

     	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实例能添加的属性：

     >>>class Person(object):
         __slots__ = ("name","age")
     
     >>>P = Person()
     >>>P.name = "老王"
     >>>P.age = 20
      #添加其他属性会报错
     

     生成器

     一边循环一边计算

     创建生成器方法

     1.把列表生成式的[]改成(),通过next函数获取生成器的下一个返回值

     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
     

     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创建类

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采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的 策略

引用计数机制的优点：

• 简单
• 实用性：一旦没有引用，内存就直接释放了。处理回收内存的时间分摊到了平时

缺点：

• 维护引用计数消耗资源

• 循环引用

  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.查看一个对象的引用计数

  import sys
  a = "hello world"
  sys.getrefcount(a)
  \>>>2
  

  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

  #函数需要一个参数
  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的类型相同

  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。

  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函数

  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

  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函数

  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())#返回十六进制数字字符串