编码

文件编码，why # coding=utf-8会起效

我们经常看到python文件开头会用声明python文件的编码，例如 # -*- coding: latin-1 -*-或 # coding: latin-1。这主要是因为python文件默认是ASCII编码，所有就有个老哥儿想办法用文件开头声明的方法来解决该文件的编码问题，具体可以参考：https://www.python.org/dev/peps/pep-0263/。
所以，看起来是个注释，但其实这是个有意义的注释。

字符串前加u

字符串前加u表示是一个Unicode编码的字符串，在python3中，字符串的存储方式都是按照Unicode字符来存储的，所以带不带u是一样的。

  1. Python 3.7.3 (default, Sep  5 2019, 17:14:41)
  2. >>> a = '我爱你'
  3. >>> a
  4. '我爱你'
  5. >>> ua = u'我爱你'
  6. >>> ua
  7. '我爱你'
  8. >>> print(len(a) == len(ua))
  9. True
  10. >>> print(a == ua)
  11. True
  13. # 下面可以看到，utf-8中一个汉字为3个16进制字符，gbk一个汉字为2个。
  14. # 同时，encode实现了字符串到字节的编码
  15. >>> a_utf8 = a.encode('utf-8')
  16. >>> a_gbk = a.encode('gbk')
  17. >>> print(type(a_utf8))
  18. <class 'bytes'>
  19. >>> print(type(a_gbk))
  20. <class 'bytes'>
  21. >>> print(len(a_utf8))
  22. 9
  23. >>> print(len(a_gbk))
  24. 6
  25. >>> a_utf8
  26. b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'
  27. >>> a_gbk
  28. b'\xce\xd2\xb0\xae\xc4\xe3'

字符串前加b

表示字符串是bytes类型。

  1. # bytes不能编码非ASCII码
  2. >>> a=b'我爱你'
  3.   File "<stdin>", line 1
  4. SyntaxError: bytes can only contain ASCII literal characters.
  6. >>> a_bytes = b'Hello World'
  7. >>> a_str = 'Hello World'
  8. >>> a_bytes
  9. b'Hello World'
  10. >>> type(a_bytes)
  11. <class 'bytes'>
  13. >>> a_str
  14. 'Hello World'
  15. >>> type(a_str)
  16. <class 'str'>
  18. >>> len(a_bytes)
  19. 11
  20. >>> len(a_str)
  21. 11
  23. >>> a_bytes == a_str
  24. False
  25. # str <-> bytes 通过encode,decode
  26. >>> a_bytes.decode('utf-8') == a_str
  27. True

字符串前加r

字符串前面加r，表示字符串内的内容按照字符串解释，一些转义符之类的就无效了。

  1. >>> a = r'\n\n'
  2. >>> print(a)
  3. \n\n
  5. >>> a = '\n\n'  # 表示打印两个换行
  6. >>> print(a)
  10. >>>

类型转换

string <-> bytes

  1. # string to bytes
  2. >>> s = "abc"
  3. >>> s.encode()
  4. b'abc'
  6. # bytes to string
  7. >>> b = s.encode()
  8. >>> b.decode()
  9. 'abc'
  11. # bytes类型的unicode（中文）输出
  12. # 中文是：今天天气真不错
  13. >>> s = '\\u4eca\\u5929\\u5929\\u6c14\\u4e0d\\u9519' 
  14. >>> s.encode()
  15. b'\\u4eca\\u5929\\u5929\\u6c14\\u4e0d\\u9519'
  16. >>> s.encode().decode('unicode_escape')
  17. '今天天气不错'

json <-> string

  1. import json
  2. a = [{"span":"5"}, {"class":"PERSON"}]
  3. b = json.dumps(a)
  5. >>> type(b)
  6. <type 'str'>

迭代器 generator

generator的使用场景：list大家都很熟悉，但是当list特别大时，我们肯定不希望占用太多的内存，此时，就可以用generator，他定义了一个产生数据的方法，在需要数据时，再生成数据。下面结合代码进行讲解。

  1. # a是一个generator
  2. # 如果使用[]代替()，这里就是生成了一个List
  3. >>> a = (x for x in range(10))
  4. >>> a
  5. <generator object <genexpr> at 0x7f9e38b72200>
  7. # 使用next()可以取下一个值，一般这种用法较少
  8. >>> next(a) 
  9. 0
  10. # 注意，generator是一次性的，上面取完了0，因此这里从1开始了
  11. # 同时，这里表明list()可以一次性取完generator
  12. >>> list(a)
  13. [1, 2, 3, 4, 5, 6, 7, 8, 9]
  15. >>> a = (x for x in range(10))
  16. >>> a
  17. <generator object <genexpr> at 0x7f9e38b722b0>
  18. >>> tuple(a)
  19. (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
  20. # 当generator全部被取出以后，会抛异常
  21. # 可以用这个异常来判断generator数据已经取完
  22. >>> next(a)
  23. Traceback (most recent call last):
  24.   File "<stdin>", line 1, in <module>
  25. StopIteration
  27. >>> a = (x for x in range(10))
  28. # 这是最常使用generator的方法
  29. >>> for i in a:
  30. ...   print(i)
  31. ...
  32. 0
  33. 1
  34. 2
  35. 3
  36. 4
  37. 5
  38. 6
  39. 7
  40. 8
  41. 9
  43. # 以斐波那契数列为例
  44. # generator，在每次调用next()的时候执行，遇到yield语句返回。
  45. # 再次执行的时候，从上次返回的yield语句处继续执行，执行到下一个yield返回
  46. def fib(max):
  47.     n, a, b = 0, 0, 1
  48.     while n < max:
  49.       print("before b, b={}".format(b))
  50.       yield b  # 当函数里有yield，这个函数就是一个generator
  51.       print("a={}, b={}, n={}".format(a, b, n))
  52.       a, b = b, a+b
  53.       n += 1
  54.     return
  56. a = fib(10)
  57. print(a)  # <generator object fib at 0x7fd476acbb48>
  58. next(a)   # before b, b=1
  59. next(a)   # a=0, b=1, n=0  before b, b=1
  60. next(a)   # a=1, b=1, n=1  before b, b=2

打印日志 logging

  • 为啥不用print?

首先，print不够灵活，比如你在开发的时候写了print，但是正式环境想删掉，要么手动删掉，要么每个都加一句开发还是正式环境的判断。
其次，某些情况下，print是没地方显示的，只能通过logging打日志。
但是吧，logging本身也有BUG，所以print也是个不错的选择，对于第一个不够灵活的问题，你完全可以自定义一个函数，在里面设置一个flag判断环境，然后决定是否print，所以取舍都在自己了。
先来看一段代码：

  1. import logging
  2. # logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(message)s')
  3. logger = logging.getLogger(__name__)
  5. logger.info('Start...')
  6. logger.debug('I want to say: %s', "hello word")
  7. logger.warning('Finish..')
  9. -- 默认输出
  10. Finish..
  12. -- 设置为DEBUG级别
  13. -- logging.basicConfig(level=logging.DEBUG) 
  14. INFO:__main__:Start...
  15. DEBUG:__main__:I want to say: hello word
  16. WARNING:__main__:Finish..
  18. -- basicConfig 加入format
  19. -- logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(message)s')
  20. 2021-01-25 17:29:08,766 - Start...
  21. 2021-01-25 17:29:08,766 - I want to say: hello word
  22. 2021-01-25 17:29:08,767 - Finish..

首先，logging是Python自带的模块，不用额外安装。
其次，logging总共有

  • DEBUG
  • INFO
  • WARNING
  • ERROR
  • CRITICAL
  • NOSET

6个日志级别，默认是WARNING，所以使用logging.debug()就可以实现在开发时打印日志，在正式环境，将日志级别设置到DBDUG以上，就不会输出debug日志。
上面通过logging.baseConfig对日志进行了设置，常用的还有其他参数，如：

  • level：调整日志级别
  • filename：输出日志的路径
  • filemode：覆盖还是追加

  • format：输出的格式

    logging的4大部分


更详细的介绍：https://www.cnblogs.com/deeper/p/7404190.html