《Python语言及其应用》读书笔记

《Python语言及其应用》读书笔记

摘录了前 11 章中自己没有记住或不常使用的知识点。

第 1 章 Python 初探

1. python2 与 python3 的一个明显区别就是 print 在 python3 是函数，调用的时候需要将参数放在圆括号内。
2. Python3 的字符串是 Unicode 字符序列，而非字节数组。这是从 Python2 到 Python3 最大的变化。

第 2 章 数据： 类型、值、变量和名称

1. Python 数据皆是对象。

   • Python 不像其他语言一样，Java 中整数，浮点数变量名指向的地址存储的就是变量的值。Python 全部包装成了对象，对象里至少有四个值，id，类型，值，引用计数。
   • Python 是强类型语言（强类型语言定义：一旦某一个变量被定义类型，如果不经强制转换，那么它永远就是该数据类型），可以改变变量的值，但是不能改变它的类型。
   • Python 是动态类型语言。（动态类型语言指的是运行时检查数据类型。而静态类型语言是编译时检查数据类型。C，Java是静态类型语言）
   • is 与==：is 比较的是对象的 id， 两个对象 id 一样，结果为True， 而 == 比较的是对象中的值，调用的是 __eq__方法，值一样为 True
   • Python 内部会缓存 [-5, 256]范围内的值，他们 id 是相同的。Python 内部也会缓存建立的常规字符串（不含空格等特殊字符），默认缓存20位长度的字符串。

2. 变量，在程序中为了引用内存中的值而为其取的名称。

3. 复制

   • 如果该对象是不可变的，则其值无法被修改。

   x = 5 # x 指向值为 5 的整数对象
   print(x) # 5
   y = x # y 指向同一个值为 5 的整数对象，该对象引用计数加一
   print(y) # 5
   x = 29 # x 指向新的值为 29 的整数对象，y 还指向值为 5 的整数对象
   print(x) # 29
   print(y) # 5
   

   • 如果该对象是可变的，则可以通过任意名称修改该对象

   a = [2, 4, 6]
   b = a
   print(a) # [2, 4, 6]
   print(b) # [2, 4, 6]
   a[0] = 99
   print(a) # [99, 4, 6]
   print(b) # [99, 4, 6]
   

4. Python 中数据类型

   名称	类型	可变？
   布尔值	bool	否
   整数	int	否
   浮点数	float	否
   复数	complex	否
   文本字符串	str	否
   列表	list	是
   元组	tuple	否
   字节序列	bytes	否
   字节数组	bytearray	是
   集合	set	是
   冻结集合	frozenset	否
   字典	dict	是

5. bytes 和 bytearray

   • bytes 是不可变的
   • bytearray 是可变的

   字符串与 bytes 相互转换

   # 字符串前加个 b，就变成了 bytes 类型，拥有字符串所有的方法
   bt = b'hello word'
   print(type(bt)) # <class 'bytes'>
   

   这样生成的 bytes 类型字符串，只支持 ASCII 码字符串，含有中文的字符串，需要使用 encode 方法。string.encode(encoding='utf-8', errors='strict')。errors 指出错时的处理方式，默认 strict，直接抛出错误。可以选择ignore 忽略错误。

   str_data = 'you only live once'
   byte_data = str_data.encode('utf-8')
   print(byte_data) # b'you only live once' 变成了 bytes 类型
   

   将 bytes 转换为字符串，使用 decode。 bytes.decode(encoding='utf-8', errors='strict')

   str_data = '学为好人'
   bytes_data = str_data.encode('utf8')
   print(bytes_data) # b'\xe5\xad\xa6\xe4\xb8\xba\xe5\xa5\xbd\xe4\xba\xba'
   
   origin_str = bytes_data.decode('utf-8')
   print(origin_str) # 学为好人
   

第 3 章 数字

1. Python 函数 bool()能够将任意的 Python 数据类型转换为布尔值。非零的数被视为 True，值为 0 的数被视为 False。

2. 整数，在 Python 3.6 以上，可以使用下划线_作为数位分隔符，如：million = 1_000_000

3. 整数运算符

   运算符	描述
   +	加法
   -	减法
   *	乘法
   /	浮点数除法
   //	整数除法
   %	求模（余数）
   **	求幂

4. 使用divmod()可以一次得到商和余数

   print(divmod(9, 5)) # (1, 4)
   

5. Python 中不同进制数

   • 0b 或 0B 表示二进制
   • 0o 或 0O 表示八进制
   • 0x 或 0X 表示十六进制

6. 将十进制整数转换成任意基数形式的字符串

   • bin(num)将十进制数 num 转换为二进制数字符串
   • oct(num)将十进制数 num 转换为八进制数字符串
   • hex(num)将十进制数 num 转换为十六进制数字符串

7. chr(num)将十进制整数 num 转换为与其对等的单字符字符串

   print(chr(65)) # 'A'
   

8. ord(char) 将单字符字符串 char 转换为对应的整数

   print(ord('A')) # 65
   

9. 如果需要将其他 Python 数据类型转换为整型， 可以使用int()函数

   print(int(True))  # 1
   print(int(False)) # 0
   # 将浮点数转换为整数，直接去掉小数点后的，不会进行四舍五入
   print(int(98.6))  # 98
   # 将只包含整数的字符串转化为整数
   print(int('99'))  # 99
   print(int('-23')) # -23
   # 如果字符串描述的是非十进制数，可以加入基数，将其转换为十进制数
   print(int('10', 2))  # 二进制'10', 转换为十进制 2
   print(int('10', 8))  # 八进制 '10', 转换为十进制 8
   print(int('10', 16)) # 十六进制 '10', 转换为十进制 16
   # 注意，将不像整数的东西转化为整数，会报错
   print(int('99 x')) # 报错
   # int() 无法处理包含小数点或指数的字符串
   print(int('98.6')) # 报错
   

10. 在 Python 3 中没有 long 类型，int 类型可以是任意大小，甚至超过 64 位。

11. 可以使用float()函数将其他类型转换为浮点型。float()函数支持的类型有：浮点数，整数，布尔值，字符串（整数字符串与浮点数字符串都可以）

第 4 章 if 语句

1. Python 推荐一行长度不超过 80， 如果一行太长，可以使用字符 \ ，将它放在行尾，Python 就会认为后续内容仍在同一行。

2. Python 的比较运算符

   ==  # 等于
   !=  # 不等于
   <   # 小于
   <=  # 小于等于
   >   # 大于
   >=  # 大于等于
   

3. 如果需要同时进行多个比较，可以使用逻辑运算符and、or和not来决定最终的结果。

4. True 是什么？除了以下列出的，其余所有的情况均为True

   """
   布尔值 False
   空 None
   整数 0
   浮点数 0.0
   空串 '', "", """"""
   空列表 []
   空元组 ()
   空字典 {}
   空集 set()
   """
   

5. 海象运算符， Python 3.8 引入 name := expression，能让代码更 Pythonic。

   # 书中的例子，不用海象运算符
   tweet_limit = 280
   tweet_string = 'Blah' * 50
   diff = tweet_limit - len(tweet_string)
   if diff >= 0:
   	print('A fitting tweet')
   else:
       print("Went over by", abs(diff))
   
   # 使用海象运算符
   tweet_limit = 280
   tweet_string = 'Blah' * 50
   if (diff := tweet_limit - len(tweet_string) >= 0:  # 注意这里，赋值运算在一行，后面也可以使用 diff 这个变量
   	print('A fitting tweet')
   else:
       print("Went over by", abs(diff))
   # for 和 while 条件判断中也可以使用海象运算符
   

第 5 章 字符串

1. 字符串是 Python 序列的第一个例子。字符串是不可变的，无法就地修改字符串。

2. 可以使用str()函数从其他数据类型创建字符串。

3. 字符串是不可变的，无法直接向其中插入字符或修改特定位置的字符

   name = 'Henny'
   name[0] = 'p' # 报错
   

4. 字符串切片中，比字符串起始位置还靠前的偏移被视为 0，超出结束位置的偏移被视为 -1。

5. 可以使用内建的字符串函数 split()根据某些分隔符，将字符串分割为子串列表。

6. join()会分解字符串列表并将其合并成单个字符串。

7. replace()可以进行简单的子串替换，需要指定旧的子串、新的子串以及要替换的旧子串的实例数。但是不会修改原来的字符串。

   setup = 'a duck goes into a bar...'
   setup.replace('duck', 'marmoset') # 'a marmoset goes into a bar...'
   print(setup) # 'a duck goes into a bar...'
   

8. strip()会删除字符串两侧的空白字符，lstrip()会删除左侧，rstrip()会删除右侧。函数默认删除空白字符（'', \t, \n）也可以指定需要删除的任意字符。

   blurt = "What the ...!!?"
   blurt.strip('.!?') # 'What the' 
   

9. Python 有两种办法（find()和index()）用于查找子串的偏移，每种方法均有两个版本（从字符串开头查找或从结尾开始查找{ rfind()和rindex()}）。如果能找到子串，这两个函数的结果相同，如果找不到，find()函数返回 -1， index()函数产生异常。

10. 大小写转换

    setup = "a duck goes into a bar"
    # 第一个单词首字母大写
    setup.capitalize() # 'A duck goes into a bar'
    # 所有单词首字母大写
    setup.title() # 'A Duck Goes Into A Bar'
    # 所有字母大写
    setup.upper() # 'A DUCK GOES INTO A BAR'
    # 所有字母小写
    setup.lower() # 'a duck goes into a bar'
    # 交换字母大小写
    setup.swapcase() # 'A DUCK GOES INTO A BAR'
    # 注意，以上都没有修改原始字符串，只是将结果作为新字符串返回，setup 的值不变
    

11. 字符串格式化

    • 旧式样： %

      旧式字符串格式化采用的形式为 format_string % data，格式化字符串内是插值序列。

      单个数据项可以直接跟在 % 后，多个数据项必须写成元组的形式。

    • 新式样： {} 和 format()

      新式样格式化的形式为 format_string.format(data)

    • 最新式样： f 字符串（个人最习惯）Python 3.6 引进

      thing = 'wereduck'
      palce = 'werepond'
      print(f'The {
               thing} is in the {
               place}') # 'The wereduck is in the werepond'
      # 从 Python 3.8 开始，如果想打印变量名和值，可以直接把 = 放在 f 字符串的 {} 内的名称之后
      print(f'{
               thing =}, {
               place =}) # "thing = 'wereduck', place = 'werepond'"
      

第 6 章 while 循环和 for 循环

1. 如果 while 循环正常结束（没有执行 break），那么就会执行可选的else语句。for 循环也有这个else。

   numbers = [1, 3, 5]
   position = 0
   while position < len(numbers):
   	number = number[position]
   	if number % 2 == 0:
   		print('Found even number', number)
   		break
   	position += 1
   else:  # 未运行 break
   	print('No even number found')
   
   # result 'No even number found'
   

第 7 章 元组和列表

1. 使用 + 可以拼接元组。

   ('Groucho',) + ('Chico', 'Harpo') # ('Groucho', 'Chico', 'Harpo')
   

2. 和字符串一样，元组是不可变的。

3. Python 的 list()函数可以将其他可迭代数据（元组，字符串，集合和字典）转换为列表。

4. insert(index, value)函数可以在 index 位置插入值为 value 的元素。

5. 使用 del 可以根据索引删除列表项， del alist[1]。

6. 可以使用remove()函数按值删除列表项，如果相同值有多个，则只会删除第一个。

7. 使用pop()同时从列表中获取列表项并删除。如果调用时指定了索引，就会返回索引处的列表项；如果不指定索引，则默认为-1。

8. clear()函数可以清空列表。

9. index()函数可以按值查找列表项的索引，如果要查找的值在列表中不止一个，只会返回第一个值对应的索引。如果列表终不存在该列表项，会报错。

10. count()可以统计某个值出现的次数。

11. 使用sort()或sorted()函数对列表排序

    • 列表方法sort()会对列表本身就地排序

    • 普通函数sorted()会返回经过排序后的列表副本

    • 如果列表项是数值，默认升序排列，如果是字符串，则按字母表顺序排列

      marxes = ['Groucho', 'Chico', 'Harpo']
      sorted_marxes = sorted(marxes)
      # sorted_marxes 是一个新列表，原列表 marxes 不变
      # 调用列表方法sort，会改变列表 
      marxes.sort()
      

    • 通过设置 reverse = True可以设置为降序排列

12. 如果将列表赋值给多个变量，那么在一处修改列表也会影响到另一处

    a = [1, 2, 3]
    b = a
    a[0] = 'surprise'
    print(a) # ['surprise', 2, 3]
    print(b) # ['surprise', 2, 3]
    

13. 复制列表，有三种方法复制出一个独立的，全新的列表

    • 列表的copy()方法

    • list()转换函数

    • 列表切片[:]

      a = [1, 2, 3]
      b = a.copy()
      c = list(a)
      d = a[:]
      # b,c,d都是 a 的副本，它们是全新对象，具有各自的值，与 a 引用的原始列表对象没有任何关系
      # 修改 a
      a[0] = 'change'
      print(a) # ['change', 2, 3]
      print(b) # [1, 2, 3]
      print(c) # [1, 2, 3]
      print(d) # [1, 2, 3]
      

    如果列表中元素都是不可变值，以上三种方法复制效果很好。如果将 a 最后一个元素改为可变的呢？

    a = [1, 2, [8, 9]]
    b = a.copy() # [1, 2, [8, 9]]
    c = list(a)  # [1, 2, [8, 9]]
    d = a[:]     # [1, 2, [8, 9]]
    # 修改 a 列表中子列表的元素
    a[2][1] = 10
    print(a) # [1, 2, [8, 10]]
    print(b) # [1, 2, [8, 10]]
    print(c) # [1, 2, [8, 10]]
    print(d) # [1, 2, [8, 10]]
    # b,c,d跟着改变了，以上三种复制方法太浅了，是浅复制，如果需要改变a，bcd不变，需要深复制
    import copy
    a = [1, 2, [8, 9]]
    b = copy.deepcopy(a)
    # 修改 a 列表
    a[2][1] = 10
    print(a) # [1, 2, [8, 10]]
    print(b) # [1, 2, [8, 9]]
    # deepcopy() 可以处理深嵌套列表，字典以及其他对象
    

14. 列表的比较：可以使用==, <等比较运算符直接比较列表。这些运算符会遍历两个列表，比较同位置上的元素。如果列表 a 比列表 b 短，且所有元素都相等，则 a 小于 b。

15. zip()函数可以并行迭代多个序列，当最短的序列被处理完毕后，zip()就会停止。

16. 列表推导式的简单形式 [expression for item in iterable]

17. 列表推导式可以包含条件表达式 [expression for item in iterable if condition]

18. 列表推导式中也可以有不止一个 for 子句 ，如[(row, col) for row in rows for col in cols]

19. 可变类型（列表，字典和集合）具有推导式，没有元组推导式，(expression for item in iterable)是一个生成器推导式。

第 8 章 字典和集合

1. 字典的键大多是字符串，但也可以是任何 Python 的不可变类型：布尔值，整数，浮点数，元组，字符串等

2. 可以使用dict()创建字典

   acme_customer = dict(first='wile', middle='E', last='Coyote')
   

   也可以使用dict()将双值序列转换为字典。

   lol = [['a', 'b'], ['c', 'd'], ['e', 'f']]
   print(dict(lol)) # {'a': 'b', 'c': 'd', 'e':'f'}
   

3. 字典的键必须是唯一的。

4. 获取字典值的方法

   some_pythons = {
        
       'Graham': 'Chapman',
       'John': 'Cleese',
       'Eric': 'Idle',
       'Terry': 'Gilliam',
       'Michael': 'Palin',
       'Terry': 'Jones'
   }
   # 方法一：[key]
   print(some_pythons['John']) # Cleese
   # 方法二：get(key)
   print(some_pythons.get('John')) # Cleese
   # 该方法可以设置可选值，如果键不存在，返回可选值, 如果不设置可选值，得到的是None
   print(some_pythons.get('Groucho', 'Not a Python')) # Not a Python
   

5. 方法keys()获取一个字典所有的键。在 Python 3 中，会返回一个键的可迭代视图 dict_keys。

6. 方法 values()获取一个字典所有的值，返回的类型是 dict_values 。

7. {**a, **b}合并字典，从 Python 3.5 开始，出现的合并字典的新方法，使用 **

   first = {
        'a': 'agony', 'b': 'bliss'}
   second = {
        'b': 'bagels', 'c': 'candy'}
   {
        **a,