python 技巧

最新推荐文章于 2023-12-15 12:00:00 发布
最新推荐文章于 2023-12-15 12:00:00 发布
阅读量353 收藏 1
点赞数
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HXChuangxiaochuan/article/details/79259701
版权

之前我们这样操作：

 
 
  1. i = 0
  2. for item in iterable:
  3.     print i, item
  4.     i += 1

现在我们这样操作：

 
 
  1. for i, item in enumerate(iterable):
  2.     print i, item

enumerate函数还可以接收第二个参数。就像下面这样：

 
 
  1. >>> list(enumerate('abc')) 
  2. [(0, 'a'), (1, 'b'), (2, 'c')] 
  3.  
  4. >>> list(enumerate('abc', 1)) 
  5. [(1, 'a'), (2, 'b'), (3, 'c')]

你也许知道如何进行列表解析，但是可能不知道字典/集合解析。它们简单易用且高效。就像下面这个例子：

 
 
  1. my_dict = {i: i * i for i in xrange(100)} 
  2. my_set = {i * 15 for i in xrange(100)}
  3.  
  4. # There is only a difference of ':' in both
  6.  
  7. # 两者的区别在于字典推导中有冒号
 
 
  1. from __future__ import division 
  2. result = 1/2
  3. # print(result)
  5. # 0.5

我们都知道eval函数，但是我们知道literal_eval函数么？也许很多人都不知道吧。可以用这种操作：

 
 
  1. import ast 
  2. my_list = ast.literal_eval(expr)

来代替以下这种操作：

 
 
  1. expr = "[1, 2, 3]"
  2. my_list = eval(expr)

我相信对于大多数人来说这种形式是第一次看见，但是实际上这个在Python中已经存在很长时间了。

你可以用以下方法快速逆序排列数列：

 
 
  1. >>> a = [1,2,3,4]
  2. >>> a[::-1]
  3. [4, 3, 2, 1]
  4.  
  5. # This creates a new reversed list. 
  7. # If you want to reverse a list in place you can do:
  9.  
  10. a.reverse()

这总方式也同样适用于字符串的逆序：

 
 
  1. >>> foo = "yasoob"
  2. >>> foo[::-1]
  3. 'boosay'

三元运算是if-else 语句的快捷操作，也被称为条件运算。这里有几个例子可以供你参考，它们可以让你的代码更加紧凑，更加美观。

 
 
  1. [on_true] if [expression] else [on_false]
  2. x, y = 50, 25
  3. small = x if x < y else y

标准库中的copy模块提供了两个方法来实现拷贝.一个方法是copy,它返回和参数包含内容一样的对象.

 
 
  1. import copy
  2. new_list = copy.copy(existing_list)

有些时候,你希望对象中的属性也被复制,可以使用deepcopy方法:

 
 
  1. import copy
  2. new_list_of_dicts = copy.deepcopy(existing_list_of_dicts)
  4. copy(x)
  5. Shallow copy operation on arbitrary Python objects.
  6.  
  7. deepcopy(x, memo=None, _nil=[])
  8. Deep copy operation on arbitrary Python objects.
   
   
  1. 首先是C#中字符串的==和equal方法。
  3. “==” :
  4. 对于内置值类型而言， == 判断两个内存值是否相等。
  5. 对于用户自定义的值类型而言(Struct)， == 需要重载，否则不能使用。
  6. 对于引用类型而言，默认是同一引用才返回true，但是系统重载了很多引用类型的 == （比如下文提到的string），所以c#中引用类型的比较并不建议使用 ==。
  8. “equals” :
  9. 对于值类型而言， 内存相等才返回true。
  10. 对于引用类型而言，指向同一个引用才算相等。
  11. 但是比较特殊的是字符串String,是一个特殊的引用型类型，在C#语言中，重载了string的equals()方法，使string对象用起来就像是值类型一样。
  13. python中的 ==
  15. python中的对象包含三要素:id, type, value
  16. id 用来标识唯一一个对象，type标识对象的类型，value用来设置对象的值。
  17. is 判断是否是一个对象，使用id来判断的。
  18. == 是判断a对象的值是否是b对象的值，默认调用它的__eq__方法。

今天阅读代码，发现一个不错的函数命名方式:

 
 
  1. def request(_argv):

就是把所有的参数前面都加上_下划线，这样你在函数体中，一眼就可以看出那些是局部变量，那些是作为参数传入的，类似把全局变量前面加上g。

  • pydoc： 模块可以根据源代码中的docstrings为任何可导入模块生成格式良好的文档。
  • doctest模块：该模块可以从源代码或独立文件的例子中抽取出测试用例。
  • unittest模块：该模块是一个全功能的自动化测试框架，该框架提供了对测试准备(test fixtures), 预定义测试集(predefined test suite)以及测试发现(test discovery)的支持。
  • trace：模块可以监控Python执行程序的方式，同时生成一个报表来显示程序的每一行执行的次数。这些信息可以用来发现未被自动化测试集所覆盖的程序执行路径，也可以用来研究程序调用图，进而发现模块之间的依赖关系。编写并执行测试可以发现绝大多数程序中的问题，Python使得debug工作变得更加简单，这是因为在大部分情况下，Python都能够将未被处理的错误打印到控制台中，我们称这些错误信息为traceback。如果程序不是在文本控制台中运行的，traceback也能够将错误信息输出到日志文件或是消息对话框中。当标准的traceback无法提供足够的信息时，可以使用cgitb 模块来查看各级栈和源代码上下文中的详细信息，比如局部变量。cgitb模块还能够将这些跟踪信息以HTML的形式输出，用来报告web应用中的错误。
  • pdb：该模块可以显示出程序在错误产生时的执行路径，同时可以动态地调整对象和代码进行调试。
  • profile, timeit: 开发者可以使用profile以及timit模块来测试程序的速度，找出程序中到底是哪里很慢，进而对这部分代码独立出来进行调优的工作。
  • compileall: Python程序是通过解释器执行的，解释器的输入是原有程序的字节码编译版本。这个字节码编译版本可以在程序执行时动态地生成，也可以在程序打包的时候就生成。compileall模块可以处理程序打包的事宜，它暴露出了打包相关的接口，该接口能够被安装程序和打包工具用来生成包含模块字节码的文件。同时，在开发环境中，compileall模块也可以用来验证源文件是否包含了语法错误。
  • YAPF：Google开源的Python代码格式化工具。
  • iPDB: iPDB是一个极好的工具，我已经用它查出了很多匪夷所思的bug。pip install ipdb 安装该工具，然后在你的代码中import ipdb; ipdb.set_trace()，然后你会在你的程序运行时，获得一个很好的交互式提示。它每次执行程序的一行并且检查变量。
  • pycallgraph: 在一些场合，我使用pycallgraph来追踪性能问题。它可以创建函数调用时间和次数的图表。
  • objgraph: objgraph对于查找内存泄露非常有用。

pycallgraph.jpg

collections.OrderedDict类：

 
 
  1. def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
  2.     if key not in self:
  3.         root = self.__root
  4.         last = root[0]
  5.         last[1] = root[0] = self.__map[key] = [last, root, key]
  6.     return dict_setitem(self, key, value)

注意最后一个参数：dict_setitem=dict.setitem。如果你仔细想就会感觉有道理。将值关联到键上，你只需要给__setitem__传递三个参数：要设置的键，与键关联的值，传递给内建dict类的__setitem__类方法。等会，好吧，也许最后一个参数没什么意义。 最后一个参数其实是将一个函数绑定到局部作用域中的一个函数上。具体是通过将dict.__setitem__赋值为参数的默认值。这里还有另一个例子：

 
 
  1. def not_list_or_dict(value):
  2.   return not (isinstance(value, dict) or isinstance(value, list))
  3.  
  4. def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list):
  5.   return not (_isinstance(value, _dict) or _isinstance(value, _list))

这里我们做同样的事情，把本来将会在内建命名空间中的对象绑定到局部作用域中去。因此，python将会使用LOCAL_FAST而不是LOAD_GLOBAL（全局查找）。那么这到底有多快呢？我们做个简单的测试：

 
 
  1. $ python -m timeit -s 'def not_list_or_dict(value): return not (isinstance(value, dict) or isinstance(value, list))' 'not_list_or_dict(50)'
  2. 1000000 loops, best of 3: 0.48 usec per loop
  3. $ python -m timeit -s 'def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list): return not (_isinstance(value, _dict) or _isinstance(value, _list))' 'not_list_or_dict(50)'
  4. 1000000 loops, best of 3: 0.423 usec per loop

换句话说，大概有11.9%的提升 [2]。比我在文章开始处承诺的5%还多！

Python世界最棒的地方之一，就是大量的第三方程序包。同样，管理这些包也非常容易。按照惯例，会在 requirements.txt 文件中列出项目所需要的包。每个包占一行，通常还包含版本号。

 
 
  1. pelican==3.3
  2. Markdown
  3. pelican-extended-sitemap==1.0.0
 
 
  1. Python 2.7.9 (default, Dec 19 2014, 06:05:48)
  2. [GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.56)] on darwin
  3. Type "help", "copyright", "credits" or "license" for more information.
  4. >>> def generate_new_list_with(my_list=[], element=None):
  5. ...     my_list.append(element)
  6. ...     return my_list
  7. ...
  8. >>> list_1 = generate_new_list_with(element=1)
  9. >>> list_1
  10. [1]
  11. >>> list_2 = generate_new_list_with(element=2)
  12. >>> list_2
  13. [1, 2]
  14. >>>

可见代码运行结果并不和我们预期的一样。list_2在函数的第二次调用时并没有得到一个新的list并填入2，而是在第一次调用结果的基础上append了一个2。为什么会发生这样在其他编程语言中简直就是设计bug一样的问题呢？ 
可见如果参数默认值是在函数编译compile阶段就已经被确定。之后所有的函数调用时，如果参数不显示的给予赋值，那么所谓的参数默认值不过是一个指向那个在compile阶段就已经存在的对象的指针。如果调用函数时，没有显示指定传入参数值得话。那么所有这种情况下的该参数都会作为编译时创建的那个对象的一种别名存在。如果参数的默认值是一个不可变(Imuttable)数值，那么在函数体内如果修改了该参数，那么参数就会重新指向另一个新的不可变值。而如果参数默认值是和本文最开始的举例一样，是一个可变对象(Muttable)，那么情况就比较糟糕了。所有函数体内对于该参数的修改，实际上都是对compile阶段就已经确定的那个对象的修改。

1、在解释器中：在这种情况下，“_”代表交互式解释器会话中上一条执行的语句的结果。这种用法首先被标准CPython解释器采用，然后其他类型的解释器也先后采用。

 
 
  1. >>> _ Traceback (most recent call last): 
  2. File "<stdin>", line 1, in <module> 
  3. NameError: name '_' is not defined 
  4. >>> 42
  5. >>> _ 
  6. 42
  7. >>> 'alright!' if _ else ':('
  8. 'alright!'
  9. >>> _ 
  10. 'alright!'

2、作为一个名称：这与上面一点稍微有些联系，此时“”作为临时性的名称使用。这样，当其他人阅读你的代码时将会知道，你分配了一个特定的名称，但是并不会在后面再次用到该名称。例如，下面的例子中，你可能对循环计数中的实际值并不感兴趣，此时就可以使用“”。

 
 
  1. n = 42
  2. for _ in range(n): 
  3.     do_something()

3、国际化：也许你也曾看到”_“会被作为一个函数来使用。这种情况下，它通常用于实现国际化和本地化字符串之间翻译查找的函数名称，这似乎源自并遵循相应的C约定。例如，在Django文档“转换”章节中，你将能看到如下代码：

 
 
  1. from django.utils.translation import ugettext as _ 
  2. from django.http import HttpResponse 
  3. def my_view(request): 
  4.     output = _("Welcome to my site.") 
  5.     return HttpResponse(output)

可以发现，场景二和场景三中的使用方法可能会相互冲突，所以我们需要避免在使用“”作为国际化查找转换功能的代码块中同时使用“”作为临时名称。

程序员使用名称前的单下划线，用于指定该名称属性为“私有”。这有点类似于惯例，为了使其他人（或你自己）使用这些代码时将会知道以“_”开头的名称只供内部使用。正如Python文档中所述：

以下划线 __ 为前缀的名称（如_pam）应该被视为API中非公开的部分（不管是函数、方法还是数据成员）。此时，应该将它们看作是一种实现细节，在修改它们时无需对外部通知。

正如上面所说，这确实类似一种惯例，因为它对解释器来说确实有一定的意义，如果你写了代码 : from <模块/包名> import * ，那么以 _ 开头的名称都不会被导入，除非模块或包中的 __all__ 列表显式地包含了它们。了解更多请查看 Importing * in Python

名称（具体为一个方法名）前双下划线 _ 的用法并不是一种惯例，对解释器来说它有特定的意义。Python中的这种用法是为了避免与子类定义的名称冲突。Python文档指出，__spam 这种形式（至少两个前导下划线，最多一个后续下划线）的任何标识符将会被 正如所预料的，“_internal_use”并未改变，而“__method_name”却被变成了“_ClassName__method_name”。此时，如果你创建A的一个子类B，那么你将不能轻易地覆写A中的方法“__method_name”。spam 这种形式原文取代，在这里 classname 是去掉前导下划线的当前类名。例如下面的例子：

 
 
  1. >>> class A(object): 
  2. ... def _internal_use(self): 
  3. ... pass
  4. ... def __method_name(self): 
  5. ... pass
  6. ... 
  7. >>> dir(A()) 
  8. ['_A__method_name', ..., '_internal_use']

正如所预料的，“_internal_use”并未改变，而“__method_name”却被变成了“_ClassName__method_name”。此时，如果你创建A的一个子类B，那么你将不能轻易地覆写A中的方法“__method_name”。

这种用法表示Python中特殊的方法名。其实，这只是一种惯例，对Python系统来说，这将确保不会与用户自定义的名称冲突。通常，你将会覆写这些方法，并在里面实现你所需要的功能，以便Python调用它们。例如，当定义一个类时，你经常会覆写“init”方法。

虽然你也可以编写自己的特殊方法名，但不要这样做。

 
 
  1. def foo(x, y):
  2.     print x, y
  4. alist = [1, 2]
  5. adict = {'x': 1, 'y': 2}
  7. foo(*alist)  # 1, 2
  9. foo(**adict)  # 1, 2
 
 
  1. >>> x = 3
  2. >>> 1 < x < 5
  3. True
  4. >>> 4 > x >=3
  5. True
 
 
  1. >>> def foo(x=[]):
  2. ...     x.append(1)
  3. ...     print x
  4. ...
  5. >>> foo()
  6. [1]
  7. >>> foo()
  8. [1, 1]

更安全的做法是：

 
 
  1. >>> def foo(x=None):
  2. ...     if x is None:
  3. ...         x = []
  4. ...     x.append(1)
  5. ...     print x
  6. ...
  7. >>> foo()
  8. [1]
  9. >>> foo()
  10. [1]
  11. >>>
 
 
  1. >>> print "Hello %(name)s !" % {'name': 'James'}
  2. Hello James !
  3. >>> print "I am years %(age)i years old" % {'age': 18}
  4. I am years 18 years old

更新些的格式化:

 
 
  1. >>> print "Hello {name} !".format(name="James")
  2. Hello James !

可以用步长 -1 来反转链表：

 
 
  1. >>> a = [1, 2, 3, 4, 5]
  2. >>> a[::2]
  3. [1, 3, 5]
  4. >>> a[::-1]
  5. [5, 4, 3, 2, 1]
  6. >>>
 
 
  1. [(i, j) for i in range(3) for j in range(i)]
  2. [(1, 0), (2, 0), (2, 1)]

列表推导构造permutation：
可以用 itertools.permutations 来实现。

 
 
  1. In[47]: a = 'abcd'
  3. In[48]: [i+j+k for i in a for j in a.replace(i,'') for k in a.replace(i,'').replace(j,'')]
  4. Out[48]: 
  5. ['abc',
  6.  'abd',
  7.  'acb',
  8.  'acd',
  9.  'adb',
  10.  'adc',
  11.  'bac',
  12.  'bad',
  13.  'bca',
  14.  'bcd',
  15.  'bda',
  16.  'bdc',
  17.  'cab',
  18.  'cad',
  19.  'cba',
  20.  'cbd',
  21.  'cda',
  22.  'cdb',
  23.  'dab',
  24.  'dac',
  25.  'dba',
  26.  'dbc',
  27.  'dca',
  28.  'dcb']

注意打开的模式: “w+” 而不能 “w” , 当然 “a” 是可以的

 
 
  1. >>> print >> open("somefile", "w+"), "Hello World"
 
 
  1. >>> a, b, *rest = range(10)
  2. >>> a
  3. 0
  4. >>> b
  5. 1
  6. >>> rest
  7. [2, 3, 4, 5, 6, 7, 8, 9]
  8. >>>
  10. >>> first, second, *rest, last = range(10)
  11. >>> first
  12. 0
  13. >>> second
  14. 1
  15. >>> last
  16. 9
  17. >>> rest
  18. [2, 3, 4, 5, 6, 7, 8]

其实第三个参数是来求模的: pow(x, y, z) == (x ** y) % z，注意，内置的 pow 和 math.pow 并不是一个函数，后者只接受2个参数。

 
 
  1. >>> pow(4, 2, 2)
  2. 0
  3. >>> pow(4, 2, 3)
  4. 1

enumerate 很赞，可以给我们索引和序列值的对, 但是它还有第二个参数，这个参数用来: 指明索引的起始值。

 
 
  1. >>> lst = ["a", "b", "c"]
  2. >>> list(enumerate(lst, 1))
  3. [(1, 'a'), (2, 'b'), (3, 'c')]

在Python 2.7 之后可以这么声明一个集合。

 
 
  1. >>> {1,2,3}
  2. set([1, 2, 3])
 
 
  1. >>> a = [1, 2, 3, 4, 5, 6, 7]
  2. >>> a[1:4] = []
  3. >>> a
  4. [1, 5, 6, 7]

当然用 del a[1:4] 也是可以的，去除偶数项(偶数索引的):

 
 
  1. >>> a = [0, 1, 2, 3, 4, 5, 6, 7]
  2. >>> del a[::2]
  3. >>> a
  4. [1, 3, 5, 7]

这个真的鲜为人知, 我们可以用 isinstance(x, (float, int)) 来判断 x 是不是数，也就是那个元组里面是 或 的关系，只要是其中一个的实例就返回 True。

 
 
  1. >>> isinstance(1, (float, int))
  2. True
  3. >>> isinstance(1.3, (float, int))
  4. True
  5. >>> isinstance("1.3", (float, int))
  6. False

虽然Python让许多编程任务变得容易，但它可能并不总能为紧急的任务提供最佳性能。你可以为紧急的任务使用C、C++或机器语言编写的外部包，这样可以提高应用程序的性能。这些包都是不能跨平台的，这意味着你需要根据你正在使用的平台，寻找合适的包。简而言之，这个方案放弃了一些应用程序的可移植性，以换取只有在特定主机上直接编程才能获得的程序性能。这里有一些你应该考虑加入到你的“性能兵工厂”的包：

  • Cython
  • PyInlne
  • PyPy
  • Pyrex

这些包以不同的方式提高性能。例如，Pyrex能够扩展Python所能做的事情，例如使用C的数据类型来让内存任务更加有效或直接。PyInIne让你在Python应用程序中直接使用C代码。程序中的内联代码单独编译，但它在利用C语言所能提供的效率的同时，也让所有的代码都在同一个地方。

有很多老的Python排序代码，它们在你创建一个自定义的排序时花费你的时间，但在运行时确实能加速执行排序过程。元素排序的最好方法是尽可能使用键（key）和默认的sort()排序方法。例如，考虑下面的代码：

 
 
  1. import operator
  2. somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
  3. somelist.sort(key=operator.itemgetter(0))
  4. somelist
  5. #Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
  7. somelist.sort(key=operator.itemgetter(1))
  8. somelist
  9. #Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]
  11. somelist.sort(key=operator.itemgetter(2))
  12. somelist

每一个实例中，根据你选择的作为key参数部分的索引，数组进行了排序。类似于利用数字进行排序，这种方法同样适用于利用字符串排序。

每种编程语言都会强调需要优化循环。当使用Python的时候，你可以依靠大量的技巧使得循环运行得更快。然而，开发者经常漏掉的一个方法是：避免在一个循环中使用点操作。例如，考虑下面的代码：

 
 
  1. lowerlist = ['this', 'is', 'lowercase']
  2. upper = str.upper
  3. upperlist = []
  4. append = upperlist.append
  5. for word in lowerlist:
  6.     append(upper(word))
  7.     print(upperlist)
  8.     #Output = ['THIS', 'IS', 'LOWERCASE']

每一次你调用方法str.upper，Python都会求该方法的值。然而，如果你用一个变量代替求得的值，值就变成了已知的，Python就可以更快地执行任务。优化循环的关键，是要减少Python在循环内部执行的工作量，因为Python原生的解释器在那种情况下，真的会减缓执行的速度。

（注意：优化循环的方法有很多，这只是其中的一个。例如，许多程序员都会说，列表推导是在循环中提高执行速度的最好方式。这里的关键是，优化循环是程序取得更高的执行速度的更好方式之一。）

如果每次你创建一个应用程序都是用相同的编码方法，几乎肯定会导致一些你的应用程序比它能够达到的运行效率慢的情况。作为分析过程的一部分，你可以尝试一些实验。例如，在一个字典中管理一些元素，你可以采用安全的方法确定元素是否已经存在并更新，或者你可以直接添加元素，然后作为异常处理该元素不存在情况。考虑第一个编码的例子：

 
 
  1. n = 16
  2. myDict = {}
  3. for i in range(0, n):
  4.     char = 'abcd'[i%4]
  5.     if char not in myDict:
  6.         myDict[char] = 0
  7.         myDict[char] += 1
  8.         print(myDict)

这段代码通常会在myDict开始为空时运行得更快。然而，当mydict通常被数据填充（或者至少大部分被充填）时，另一种方法效果更好。

 
 
  1. n = 16
  2. myDict = {}
  3. for i in range(0, n):
  4.     char = 'abcd'[i%4]
  5.     try:
  6.         myDict[char] += 1
  7.     except KeyError:
  8.         myDict[char] = 1
  9.     print(myDict)

两种情况下具有相同的输出：{‘d’: 4, ‘c’: 4, ‘b’: 4, ‘a’: 4}。唯一的不同是这个输出是如何得到的。跳出固定的思维模式，创造新的编码技巧，能够帮助你利用你的应用程序获得更快的结果。

一个列表推导式包含以下几个部分：

  • 一个输入序列
  • 一个表示输入序列成员的变量
  • 一个可选的断言表达式
  • 一个将输入序列中满足断言表达式的成员变换成输出列表成员的输出表达式
 
 
  1. num = [1, 4, -5, 10, -7, 2, 3, -1]
  2. filtered_and_squared = []
  3.  
  4. for number in num:
  5.     if number > 0:
  6.         filtered_and_squared.append(number ** 2)
  7. print filtered_and_squared
  8.  
  9. # [1, 16, 100, 4, 9]

而如果使用filter、lambda和map函数，则能够将代码大大简化：

 
 
  1. num = [1, 4, -5, 10, -7, 2, 3, -1]
  2. filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num))
  3. print filtered_and_squared
  4.  
  5. # [1, 16, 100, 4, 9]
  8. ## 更简化的一种写法    
  10. num = [1, 4, -5, 10, -7, 2, 3, -1]
  11. filtered_and_squared = [ x**2 for x in num if x > 0]
  12. print filtered_and_squared
  13.  
  14. # [1, 16, 100, 4, 9]

comprehension.jpg

列表推导也可能会有一些负面效应，那就是整个列表必须一次性加载于内存之中，这对上面举的例子而言不是问题，甚至扩大若干倍之后也都不是问题。但是总会达到极限，内存总会被用完。

针对上面的问题，生成器(Generator)能够很好的解决。生成器表达式不会一次将整个列表加载到内存之中，而是生成一个生成器对象(Generator objector)，所以一次只加载一个列表元素。

生成器表达式同列表推导式有着几乎相同的语法结构，区别在于生成器表达式是被圆括号包围，而不是方括号：

 
 
  1. num = [1, 4, -5, 10, -7, 2, 3, -1]
  2. filtered_and_squared = ( x**2 for x in num if x > 0 )
  3. print filtered_and_squared
  4.  
  5. # <generator object <genexpr> at 0x00583E18>
  7.  
  8. for item in filtered_and_squared:
  9.     print item
  10.  
  11. # 1, 16, 100 4,9

这比列表推导效率稍微提高一些，让我们再一次改造一下代码：

 
 
  1. num = [1, 4, -5, 10, -7, 2, 3, -1]
  2.  
  3. def square_generator(optional_parameter):
  4.     return (x ** 2 for x in num if x > optional_parameter)
  5.  
  6. print square_generator(0)
  7. # <generator object <genexpr> at 0x004E6418>
  9.  
  10. # Option I
  12. for k in square_generator(0):
  13.     print k
  14. # 1, 16, 100, 4, 9
  16.  
  17. # Option II
  19. g = list(square_generator(0))
  20. print g
  21. # [1, 16, 100, 4, 9]

除非特殊的原因，应该经常在代码中使用生成器表达式。但除非是面对非常大的列表，否则是不会看出明显区别的。 再来看一个通过两阶列表推导式遍历目录的例子：

 
 
  1. import os
  2. def tree(top):
  3.     for path, names, fnames in os.walk(top):
  4.         for fname in fnames:
  5.             yield os.path.join(path, fname)
  6.  
  7. for name in tree('C:\Users\XXX\Downloads\Test'):
  8.     print name

装饰器为我们提供了一个增加已有函数或类的功能的有效方法。听起来是不是很像Java中的面向切面编程(Aspect-Oriented Programming)概念？两者都很简单，并且装饰器有着更为强大的功能。举个例子，假定你希望在一个函数的入口和退出点做一些特别的操作(比如一些安全、追踪以及锁定等操作)就可以使用装饰器。

装饰器是一个包装了另一个函数的特殊函数：主函数被调用，并且其返回值将会被传给装饰器，接下来装饰器将返回一个包装了主函数的替代函数，程序的其他部分看到的将是这个包装函数。

 
 
  1. import time
  2. from functools import wraps
  3.  
  4. def timethis(func):
  5.     '''
  6.     Decorator that reports the execution time.
  7.     '''
  8.     @wraps(func)
  9.     def wrapper(*args, **kwargs):
  10.         start = time.time()
  11.         result = func(*args, **kwargs)
  12.         end = time.time()
  13.         print(func.__name__, end-start)
  14.         return result
  15.     return wrapper
  16.  
  17. @timethis
  18. def countdown(n):
  19.     while n > 0:
  20.         n -= 1
  21.  
  22. countdown(100000)
  23.  
  24. # ('countdown', 0.006999969482421875)

contextlib模块包含了与上下文管理器和with声明相关的工具。通常如果你想写一个上下文管理器，则你需要定义一个类包含__enter__方法以及__exit__方法，例如：

 
 
  1. import time
  2. class demo:
  3.     def __init__(self, label):
  4.         self.label = label
  5.  
  6.     def __enter__(self):
  7.         self.start = time.time()
  8.  
  9.     def __exit__(self, exc_ty, exc_val, exc_tb):
  10.         end = time.time()
  11.         print('{}: {}'.format(self.label, end - self.start))

完整的例子在此：

 
 
  1. import time
  2.  
  3. class demo:
  4.     def __init__(self, label):
  5.         self.label = label
  6.  
  7.     def __enter__(self):
  8.         self.start = time.time()
  9.  
  10.     def __exit__(self, exc_ty, exc_val, exc_tb):
  11.         end = time.time()
  12.         print('{}: {}'.format(self.label, end - self.start))
  13.  
  14. with demo('counting'):
  15.     n = 10000000
  16.     while n > 0:
  17.         n -= 1
  18.  
  19. # counting: 1.36000013351

上下文管理器被with声明所激活，这个API涉及到两个方法。

  1. __enter__方法，当执行流进入with代码块时，__enter__方法将执行。并且它将返回一个可供上下文使用的对象。
  2. 当执行流离开with代码块时，__exit__方法被调用，它将清理被使用的资源。

利用@contextmanager装饰器改写上面那个例子：

 
 
  1. from contextlib import contextmanager
  2. import time
  3.  
  4. @contextmanager
  5. def demo(label):
  6.     start = time.time()
  7.     try:
  8.         yield
  9.     finally:
  10.         end = time.time()
  11.         print('{}: {}'.format(label, end - start))
  12.  
  13. with demo('counting'):
  14.     n = 10000000
  15.     while n > 0:
  16.         n -= 1
  17.  
  18. # counting: 1.32399988174

看上面这个例子，函数中yield之前的所有代码都类似于上下文管理器中__enter__方法的内容。而yield之后的所有代码都如__exit__方法的内容。如果执行过程中发生了异常，则会在yield语句触发。

描述器决定了对象属性是如何被访问的。描述器的作用是定制当你想引用一个属性时所发生的操作。

构建描述器的方法是至少定义以下三个方法中的一个。需要注意，下文中的instance是包含被访问属性的对象实例，而owner则是被描述器修辞的类。

get(self, instance, owner) – 这个方法是当属性被通过(value = obj.attr)的方式获取时调用，这个方法的返回值将被赋给请求此属性值的代码部分。 set(self, instance, value) – 这个方法是当希望设置属性的值(obj.attr = ‘value’)时被调用，该方法不会返回任何值。 delete(self, instance) – 当从一个对象中删除一个属性时(del obj.attr)，调用此方法。 译者注：对于instance和owner的理解，考虑以下代码：

 
 
  1. class Celsius(object):
  2.     def __init__(self, value=0.0):
  3.         self.value = float(value)
  4.     def __get__(self, instance, owner):
  5.         return self.value
  6.     def __set__(self, instance, value):
  7.         self.value = float(value)
  8.  
  9. class Temperature(object):
  10.     celsius = Celsius()
  11.  
  12. temp=Temperature()
  13. temp.celsius #calls Celsius.__get__
 
 
  1. >>> a = [1, 2, 3]
  2. >>> b = ['a', 'b', 'c']
  3. >>> z = zip(a, b)
  4. >>> z
  5. [(1, 'a'), (2, 'b'), (3, 'c')]
  6. >>> zip(*z)
  7. [(1, 2, 3), ('a', 'b', 'c')]
 
 
  1. >>> a = [1, 2, 3, 4, 5, 6]
  3. >>> # Using iterators
  5. >>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))
  6. >>> group_adjacent(a, 3)
  7. [(1, 2, 3), (4, 5, 6)]
  8. >>> group_adjacent(a, 2)
  9. [(1, 2), (3, 4), (5, 6)]
  10. >>> group_adjacent(a, 1)
  11. [(1,), (2,), (3,), (4,), (5,), (6,)]
  14. >>> # Using slices
  16. >>> from itertools import islice
  17. >>> group_adjacent = lambda a, k: zip(*(islice(a, i, None, k) for i in range(k)))
  18. >>> group_adjacent(a, 3)
  19. [(1, 2, 3), (4, 5, 6)]
  20. >>> group_adjacent(a, 2)
  21. [(1, 2), (3, 4), (5, 6)]
  22. >>> group_adjacent(a, 1)
  23. [(1,), (2,), (3,), (4,), (5,), (6,)]
 
 
  1. >>> from itertools import islice
  2. >>> def n_grams(a, n):
  3. ...     z = (islice(a, i, None) for i in range(n))
  4. ...     return zip(*z)
  5. ...
  6. >>> a = [1, 2, 3, 4, 5, 6]
  7. >>> n_grams(a, 3)
  8. [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]
  9. >>> n_grams(a, 2)
  10. [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
  11. >>> n_grams(a, 4)
  12. [(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]
 
 
  1. >>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  2. >>> m.items()
  3. [('a', 1), ('c', 3), ('b', 2), ('d', 4)]
  4. >>> zip(m.values(), m.keys())
  5. [(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]
  6. >>> mi = dict(zip(m.values(), m.keys()))
  7. >>> mi
  8. {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
 
 
  1. >>> a = [[1, 2], [3, 4], [5, 6]]
  2. >>> list(itertools.chain.from_iterable(a))
  3. [1, 2, 3, 4, 5, 6]
  5. >>> sum(a, [])
  6. [1, 2, 3, 4, 5, 6]
  8. >>> [x for l in a for x in l]
  9. [1, 2, 3, 4, 5, 6]
  11. >>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
  12. >>> [x for l1 in a for l2 in l1 for x in l2]
  13. [1, 2, 3, 4, 5, 6, 7, 8]
  15. >>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]
  16. >>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
  17. >>> flatten(a)
  18. [1, 2, 3, 4, 5, 6, 7, 8]
 
 
  1. >>> m = {x: x ** 2 for x in range(5)}
  2. >>> m
  3. {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
  5. >>> m = {x: 'A' + str(x) for x in range(10)}
  6. >>> m
  7. {0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

Python允许开发者指定一个默认值给函数参数，虽然这是该语言的一个特征，但当参数可变时，很容易导致混乱，例如，下面这段函数定义：

 
 
  1. >>> def foo(bar=[]):        # bar is optional and defaults to [] if not specified
  3. ...    bar.append("baz")    # but this line could be problematic, as we'll see...
  5. ...    return bar

在上面这段代码里，一旦重复调用foo()函数（没有指定一个bar参数），那么将一直返回’bar’，因为没有指定参数，那么foo()每次被调用的时候，都会赋予[]。下面来看看，这样做的结果：

 
 
  1. >>> foo()
  2. ["baz"]
  3. >>> foo()
  4. ["baz", "baz"]
  5. >>> foo()
  6. ["baz", "baz", "baz"]

解决方案：

 
 
  1. >>> def foo(bar=None):
  2. ...    if bar is None:      # or if not bar:
  4. ...        bar = []
  5. ...    bar.append("baz")
  6. ...    return bar
  7. ...
  8. >>> foo()
  9. ["baz"]
  10. >>> foo()
  11. ["baz"]
  12. >>> foo()
  13. ["baz"]

Python的作用域解析是基于LEGB规则，分别是Local、Enclosing、Global、Built-in。实际上，这种解析方法也有一些玄机，看下面这个例子：

 
 
  1. >>> x = 10
  2. >>> def foo():
  3. ...     x += 1
  4. ...     print x
  5. ...
  6. >>> foo()
  7. Traceback (most recent call last):
  8.   File "<stdin>", line 1, in <module>
  9.   File "<stdin>", line 2, in foo
  10. UnboundLocalError: local variable 'x' referenced before assignment

许多人会感动惊讶，当他们在工作的函数体里添加一个参数语句，会在先前工作的代码里报UnboundLocalError错误（ 点击这里查看更详细描述）。 在使用列表时，开发者是很容易犯这种错误的，看看下面这个例子：

 
 
  1. >>> lst = [1, 2, 3]
  2. >>> def foo1():
  3. ...     lst.append(5)   # This works ok...
  5. ...
  6. >>> foo1()
  7. >>> lst
  8. [1, 2, 3, 5]
  10. >>> lst = [1, 2, 3]
  11. >>> def foo2():
  12. ...     lst += [5]      # ... but this bombs!
  14. ...
  15. >>> foo2()
  16. Traceback (most recent call last):
  17.   File "<stdin>", line 1, in <module>
  18.   File "<stdin>", line 2, in foo
  19. UnboundLocalError: local variable 'lst' referenced before assignment

为什么foo2失败而foo1运行正常？ 答案与前面那个例子是一样的，但又有一些微妙之处。foo1没有赋值给lst，而foo2赋值了。lst += [5]实际上就是lst = lst + [5]，试图给lst赋值（因此，假设Python是在局部作用域里）。然而，我们正在寻找指定给lst的值是基于lst本身，其实尚未确定。

 
 
  1. >>> odd = lambda x : bool(x % 2)
  2. >>> numbers = [n for n in range(10)]
  3. >>> for i in range(len(numbers)):
  4. ...     if odd(numbers[i]):
  5. ...         del numbers[i]  # BAD: Deleting item from a list while iterating over it
  7. ...
  8. Traceback (most recent call last):
  9.       File "<stdin>", line 2, in <module>
  10. IndexError: list index out of range

在遍历的时候，对列表进行删除操作，这是很低级的错误。稍微有点经验的人都不会犯。 对上面的代码进行修改，正确地执行：

 
 
  1. >>> odd = lambda x : bool(x % 2)
  2. >>> numbers = [n for n in range(10)]
  3. >>> numbers[:] = [n for n in numbers if not odd(n)]  # ahh, the beauty of it all
  5. >>> numbers
  6. [0, 2, 4, 6, 8]

对于dict和list等数据结构的对象，直接赋值使用的是引用的方式。而有些情况下需要复制整个对象，这时可以使用copy包里的copy和deepcopy，这两个函数的不同之处在于后者是递归复制的。效率也不一样：（以下程序在ipython中运行）

timeit后面的-n表示运行的次数，后两行对应的是两个timeit的输出，下同。由此可见后者慢一个数量级。

 
 
  1. import copy
  2. a = range(100000)
  3. %timeit -n 10 copy.copy(a) # 运行10次 copy.copy(a)
  5. %timeit -n 10 copy.deepcopy(a)
  6. 10 loops, best of 3: 1.55 ms per loop
  7. 10 loops, best of 3: 151 ms per loop
 
 
  1. %timeit -n 100 a = (i for i in range(100000))
  2. %timeit -n 100 b = [i for i in range(100000)]
  3. 100 loops, best of 3: 1.54 ms per loop
  4. 100 loops, best of 3: 4.56 ms per loop

使用()得到的是一个generator对象，所需要的内存空间与列表的大小无关，所以效率会高一些。在具体应用上，比如set(i for i in range(100000))会比set([i for i in range(100000)])快。

但是对于需要循环遍历的情况：

 
 
  1. %timeit -n 10 for x in (i for i in range(100000)): pass
  2. %timeit -n 10 for x in [i for i in range(100000)]: pass
  3. 10 loops, best of 3: 6.51 ms per loop
  4. 10 loops, best of 3: 5.54 ms per loop

后者的效率反而更高，但是如果循环里有break,用generator的好处是显而易见的。yield也是用于创建generator：

 
 
  1. x, y, z = 1,2,3
  2. %timeit -n 1000000 if x < y < z:pass
  3. %timeit -n 1000000 if x < y and y < z:pass
  4. 1000000 loops, best of 3: 101 ns per loop
  5. 1000000 loops, best of 3: 121 ns per loop

x < y < z效率略高，而且可读性更好。

 
 
  1. def while_1():
  2.     n = 100000
  3.     while 1:
  4.         n -= 1
  5.         if n <= 0: break
  6. def while_true():
  7.     n = 100000
  8.     while True:
  9.         n -= 1
  10.         if n <= 0: break    
  12. m, n = 1000000, 1000000 
  13. %timeit -n 100 while_1()
  14. %timeit -n 100 while_true()
  15. 100 loops, best of 3: 3.69 ms per loop
  16. 100 loops, best of 3: 5.61 ms per loop

while 1 比 while true快很多，原因是在python2.x中，True是一个全局变量，而非关键字。

 
 
  1. %timeit -n 10000 c = pow(2,20)
  2. %timeit -n 10000 c = 2**20
  3. 10000 loops, best of 3: 284 ns per loop
  4. 10000 loops, best of 3: 16.9 ns per loop
 
 
  1. import cPickle
  2. import pickle
  3. a = range(10000)
  4. %timeit -n 100 x = cPickle.dumps(a)
  5. %timeit -n 100 x = pickle.dumps(a)
  6. 100 loops, best of 3: 1.58 ms per loop
  7. 100 loops, best of 3: 17 ms per loop

由c实现的包，速度快10倍以上！

下面比较了eval, cPickle, json方式三种对相应字符串反序列化的效率，可见json比cPickle快近3倍，比eval快20多倍。

 
 
  1. import json
  2. import cPickle
  3. a = range(10000)
  4. s1 = str(a)
  5. s2 = cPickle.dumps(a)
  6. s3 = json.dumps(a)
  7. %timeit -n 100 x = eval(s1)
  8. %timeit -n 100 x = cPickle.loads(s2)
  9. %timeit -n 100 x = json.loads(s3)
  10. 100 loops, best of 3: 16.8 ms per loop
  11. 100 loops, best of 3: 2.02 ms per loop
  12. 100 loops, best of 3: 798 µs per loop

这个问题比较难回答，我是看 怎么样才算是精通 Python 这个知乎问答，按照自己的看法整理了一些观点。不要问我是按什么标准整理的，我只能说，整理的这些点，第一，在我看来都说得不错；第二，我自己都会去按照这些点来看看自己离 “精通” python还有多远。

  • 熟悉语法以及原声数据结构
  • 熟悉基本实现中的性能特点，就是知道什么操作会慢
  • 会使用profile以及基于profile的性能分析工具
  • 会使用运行时编译和静态编译的工具。pypy，numba，cython，ctypes，original C/C++ extension
  • 熟悉你所在领域的拓展库，比如我，科学计算方面的库不要太多，numpy衍生出来的一大堆大堆
  • 了解基本的编译过程，基本的操作系统知识（只要你C、C++学的还行就可以了）
  • 要想精通python，写的代码首先得pythonic
  • 研读牛B的开源代码，在这过程中会遇到python的许多高阶用法
  • 理解装饰器，生成器，描述符，元类
  • 掌握list comprehension，
  • 多用内置函数：map，reduce，filter，iter，range，divmod，round，chr，enumerate，all，any，slice，zip+

python里有一个很奇妙的monkey patch，中文叫做猴子补丁，是指的是在运行时动态替换某些已加载的模块的实现。第一次了解这个概念是在使用gevent的时候，需要把python自带的socket，os等相关模块的实现改变成异步形式，但同时不改动python的源代码。

先参考 飘逸的python - 偏函数functools.partial

python-time.jpg

python -mSimpleHTTPServer

Clond2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python技巧
m0_72349101的博客
08-01 100
备注： 文中的“[Tab]”就是table(Tab)键 正文： 随机打印一个数： a=random.randint([范围的最小值],[范围的最大值]) print(a) 所有字母小写字母： a="……" print(a.lower()) print换行： print("……\n……") 打印指数： print([数字]**[数字]) 对号入座：（对号入座两个以上数(一个：(……))。） print("{}……{}".format('……','……'……)) 表格： im..
Python技巧
Room08304
04-04 249
1.重复元素判定 思路：数据结构中，集合具有数据不重复的属性，使用set()方法移除所有重复元素 def all_unique(list): return len(list) == len(set(list)) eg: x = [1,1,2,2,3,2,3,4,5,6] y = [1,2,3,4,5] all_unique(x) # False all_unique(y) # True 2...
一分钟学会python的__setitem__方法
Norsaa的博客
04-16 1万+
在python中__setitem__(self,value,key)方法时python魔法方法的一种，这个方法会让类按照一定的方法存储和key映射的value。该值可以使用另一种魔法方法__getitem__(self,key)来获取。 使用场景：当期望定义的类具备按照键存储值时，即类能够执行data['key']=value 目的：如果给类定义了__setitem__方法，则可以方便的给类...
python:__setitem__方法详解
热门推荐
LYY的学习和记录
08-11 2万+
__setitem__(self,key,value): 这个方法应该以与键相关联的方式存储值，以便之后能够使用__setitem__来获取。当然，这个对象可变时才需要实现这个方法。 class Tag: def __init__(self): self.change={'python':'This is python', '......
59个Python使用技巧，从此你的Python与众不同！
weixin_34174322的博客
07-20 776
今天给大家分享几个Python使用的小技巧，原文来自于Python 技巧总结,进行了细微的调整，感谢作者！1. 枚举 - enumerate 可以有参数哦之前我们这样操作：i = 0for item in iterable: print i, item i += 1现在我们这样操作：for i, item in enumerate(iterable):  print i, itemenumera...
python类__setitem__方法和__getitem__方法
qq_45711921的博客
04-27 1100
在 Python 中，类可以定义自己的索引方式，即可以通过中括号来访问类实例中的属性。Python 中的内置方法 __setitem__ 就是类定义索引的一种方式。它定义了在使用 [] 索引符号时，向类实例中设置值的方式
Python定制化容器操作：__setitem__方法
涛哥聊Python
12-15 1172
进一步探讨在自定义容器中的应用。row } , {value } ") else : raise ValueError("Invalid index format. Use (row, col).") # 使用矩阵容器 matrix_container = MatrixContainer(3 , 3) matrix_container [ 1 , 2 ] = 5 # 触发__setitem__方法row } , {
Python你需要知道的20个常用的Python技巧
07-23
【Python】你需要知道的20个常用的Python技巧【Python】你需要知道的20个常用的Python技巧【Python】你需要知道的20个常用的Python技巧【Python】你需要知道的20个常用的Python技巧【Python】你需要知道的20个常用的...
python-tips-tricks:Python技巧与窍门
04-17
Python技巧与窍门有关Python的一些技巧和窍门。有用的文件-BeautifulSoup库的概述，以便解析XML文件。 -概述Oletools库，以便检查VB代码 -Pyspark库概述-Sweetviz库概述帮助您找到所有缺少的值并显示它们-获取文件的...
13 个你可能未使用过的 Python 技巧！.docx
07-23
13 个你可能未使用过的 Python 技巧！.docx13 个你可能未使用过的 Python 技巧！.docx13 个你可能未使用过的 Python 技巧！.docx13 个你可能未使用过的 Python 技巧！.docx13 个你可能未使用过的 Python 技巧！.docx...
了解不常见但是实用的Python技巧
09-19
下面有一些相对不常见但非常有用的Python技巧，小编来和大家一起学习一下
pytricks::snake:Python技巧
03-07
"pytricks::snake:Python技巧"这个主题聚焦于Python中的实用小技巧，这些技巧被称为"snake tricks"，它们通常涉及语言特性、代码优化、调试以及模块化等方面。下面将详细探讨其中的一些关键知识点。 1. **Python的...
python--基础知识点--__getitem__、__setitem__、__delitem__
Chasing__Dreams的博客
07-01 800
一、普通使用 __getitem__()：如果类把某个属性定义为序列，可以使用__getitem__()输出序列属性中的某个元素。 __setitem__()：如果类把某个属性定义为序列，可以使用__getitem__()修改序列属性中的某个元素。 __delitem__()：如果类把某个属性定义为序列，可以使用__getitem__()删除序列属性中的某个元素。 1、类把某个属性定义为列表 class Test: def __init__(self, names): self.na
Python浅谈set和dict
杨同学的博客
11-12 301
python set 和 dict
Python教程：__setitem__和__getitem和__delitem__
Python热爱者的博客
02-25 200
Python教程：__setitem__和__getitem和__delitem__
Python----魔法函数__getitem__/__setitem__/__delitem__的用法
redrose2100的博客
06-22 1506
1、__getitem__魔法函数 对于字典比如a={“name”:“zhangsan”,“age”:20}，可以通过a[“name”]取值，之所以可以这么用，就是因为dict的类实现了__getitem__魔法函数，同样，在我们自定义的类中，如果我们也实现了这个魔法函数，那么自定义类的对象同样也可以像字典那样取值 如： class Student(): def __init__(self): self.attr={"name":"zhangsan","age":20}
Python学习：__setitem__,__getitem,__delitem__
错位的梦寐的博客
06-22 1339
__setitem__,__getitem,__delitem__ class Foo: def __init__(self,name): self.name=name def __getitem__(self, item): print(self.__dict__[item]) def __setitem__(self, key, va...
Python __setitem__()、__getitem__()、__delitem__() （十一）
魔法学徒de专栏
09-23 6478
__xxxitem__:使用 [''] 的方式操作属性时被调用 __setitem__:每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环 __getitem__:当访问不存在的属性时会调用该方法 __delitem__:当删除属性时调用该方法 class A(object): def __init__(self):
基于微信小程序的高校体育互动平台设计与实现
07-21
在当前移动互联网技术广泛渗透各行业的背景下，高校体育教育面临着新的发展机遇和挑战。本研究以满足学生多样化体育需求、促进高校体育信息化管理为目标，探索了利用微信小程序等现代技术的体育互动平台设计与实施。通过深入文献回顾和定性、定量研究方法，全面了解了高校学生的体育需求及现有技术解决方案。在微信小程序技术支持下，设计了功能全面、用户友好、安全性高的平台，并多次迭代优化。实际应用和评估显示，该平台为学生提供了信息发布、活动报名、成绩查询和互动交流等综合体育活动管理服务。数据分析表明，相较传统管理方式，平台显著提升了学生体育活动参与度，增强了锻炼意识，同时为教育工作者提供了高效便捷的管理工具。基于微信小程序的高校体育互动平台为体育教育带来新的研究方向和实践机遇，不仅满足学生需求，还为教育工作者提供了灵活、有效的管理工具。 建议高校体育部门深入合作，结合国家政策推广完善该平台，提供培训和技术支持，确保其广泛应用和推广。
机器学习Python实战-重庆理工大学编著 教学ppt
最新发布
07-21
机器学习Python实战-重庆理工大学编著 全6章教学ppt（500+页）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值