可变对象和不可变对象

https://zhuanlan.zhihu.com/p/34395671

dict与dir()区别

https://blog.csdn.net/lis_12/article/details/53521554

  1. if seq原理
  2. print(8/2) # 4.0
  3. ls.append和ls.extend区别
  4. 闭包和装饰器

https://segmentfault.com/a/1190000004461404

  1. Nonlocal和global：nonlocal查找本地变量和全局变量之间的变量，其会优先寻找层级关系与闭包作用域最近的外部变量
  2. (注：在python函数中可以直接引用外部变量，但不能改写外部变量，只能使用global,nonlocal)
  3. Python代码规范遵循PEP8，检查代码是否规范可用的工具有：pylint,Flake8,Autopep8,Coverage,Yapf,cProfile
  4. all方法：

init中是否有all方法：

  • 如果导入的模块中定义了all属性的话，那么只有在all内指定的属性、方法或者类才可以被导入，如果没有定义的话，只会导入所有的公有属性、方法和类。
    1. from common.init import func
    ```python from .init import func all=[‘func’]

test.py再导包

from common import func from common.init import func # 两种兼容

  2. - 类中的属性或者方法如果本身是有下划线前缀的话，例如“_name”，直接from module import *的话是不会被导入的，但是如果在"__all__"中写明的话，是会被导入的。
  3. ```python
  4. __all__ = [
  5.     "_func",
  6.     "_module",
  7. ]
  9. class _module():
  10.     def _func1():
  11.         print("func1")
  13. def _func():
  14.     print("func")
  16. # test_property.py
  17. from module import *
  18. _func()
  19. m = _module()

总结：

  • from <module> import * 默认行为会从给定空间导出所有符号(下划线开头的除外)
  • __all__只会影响from <module> import * 这种导入方式，

而from <module> import <member>的导入方式并不受影响

  • __all__可以用于隐藏属性，也可以让下划线开头的方法、类、变量显示

练习：

  1. __all__ = ['A']
  2. class A:
  3.     def __init__(self):
  4.         self.name = "a" 
  5. class B:
  6.     def __init__(self):
  7.         self.name = "b"
  1. # 代码段1
  2. from test import A,B
  3. a = A()
  4. print(a.name) # a
  5. b = B()
  6. print(b.name) # b
  8. # 代码段2
  9. from test import *
  10. a = A()
  11. print(a.name) # a
  12. b = B()
  13. print(b.name) # name 'B' is not defined
  1. @setter 和@property

@property定义只读属性，@setter定义可读可写属性，@deleter定义可读可写可删除属性

  1. 异常捕获

try…except…finally

  1. 二次探测再散列

https://www.jianshu.com/p/98466542ef5b?utm_campaign=maleskine

  1. 前置双下划线：__var
  • 双下划线前缀会让Python解释器重写属性名称，以避免子类中的命名冲突。这也称为名称改写（name mangling），即解释器会更改变量的名称，以便在稍后扩展这个类时避免命名冲突。 ```python class Test: def init(self):
    1.   self.foo = 11
    2.   self._bar = 23
    3.   self.__baz = 23 # '_Test__baz' 名字被换了

t=Test() dir(t) [‘Testbaz’, ‘class‘, ‘delattr‘, ‘dict‘, ‘dir‘, ‘doc‘, ‘eq‘, ‘format‘, ‘ge‘, ‘getattribute‘, ‘gt‘, ‘hash‘, ‘init‘, ‘le‘, ‘lt‘, ‘module‘, ‘ne‘, ‘new‘, ‘reduce‘, ‘reduceex‘, ‘repr‘, ‘setattr‘, ‘sizeof‘, ‘str‘, ‘subclasshook‘, ‘weakref‘, ‘_bar’, ‘foo’] print(Test._Test__baz) # 23

  1. <a name="g93QH"></a>
  2. # pytest框架
  3. [https://blog.csdn.net/lovedingd/article/details/98952868](https://blog.csdn.net/lovedingd/article/details/98952868)
  4. ```python
  5. import pytest
  7. def add(a, b):
  8.     """
  9.     :param a:
  10.     :param b:
  11.     :return:
  13.     Error:
  14.         TypeError:if a is not a integer
  15.     """
  16.     if not isinstance(a, int):
  17.         raise TypeError("a is not int!")
  18.     return a+b
  20. def test_add():
  21.     assert add(1,2)==3
  23. def test_add2():
  24.     with pytest.raises(TypeError):
  25.         add('1','2')

python的无重载机制

python没有重载机制。因为重载主要解决的问题的就是除了参数类型和参数个数不同之外，功能完全相同。

  1. 参数类型不同的问题。python的参数可以传入任意数据类型
  2. 参数个数不同的问题。python可以使用args和*args

    python值传递和引用传递

  • 值传递：传递的是值，也就是在函数里修改该值，值本身不变。不可变参数是值传递
  • 引用传递：传递的是地址，在函数中修改该值，值本身也会变。可变参数是引用传递
  • 如何将引用传递转为值传递？
    1. import copy
    2. num = [1, 2, 3]
    3. def add(x):
    4.   x[1] = x[1]+2
    5.   return x
    6. res = add(copy.deepcopy(num))
    7. print(res) # [1,4,3]
    8. print(num) # [1,2,3]

    python回调函数