Python筑基之旅-两个重要函数/列表/元组

目录

一、两个重要的函数

1、dir()函数

1-1、特殊方法和魔法方法

1-2、继承自基类的属性和方法

1-3、其他可访问的属性

2、help()函数

2-1、函数的基本信息

2-2、函数的参数列表

2-3、函数的文档字符串(docstring)

2-4、返回值

2-5、其他相关信息

二、列表

1、列表的定义

2、列表的语法

3、获取列表的属性和方法

4、获取列表的帮助信息

5、列表的用法

5-1、创建列表

5-1-1、创建一个空列表

5-1-2、创建一个包含元素的列表

5-1-3、创建一个包含不同类型元素的列表

5-2、访问列表元素

5-3、修改列表元素

5-4、列表用法

5-4-1、append()方法

5-4-2、insert()方法

5-4-3、remove()方法

5-4-4、pop()方法

5-4-5、index()方法

5-4-6、sort()方法

5-4-7、sorted()函数

5-4-8、count()方法

5-4-9、extend()方法

5-4-10、clear()方法

5-4-11、使用del语句

5-4-12、reverse()方法

5-4-13、reversed()函数

5-5、列表推导式

三、元组

1、元组的定义

2、元组的语法

3、获取元组的属性和方法

4、获取元组的帮助信息

5、元组的用法

5-1、创建元组

5-1-1、创建一个空元组

5-1-2、创建一个包含1个元素的元组

5-1-3、创建一个包含多个元素的元组

5-1-4、创建一个包含不同类型元素的元组

5-2、访问元组中的元素

5-3、元组的不可变性 

5-4、元组用法

5-4-1、count()方法

5-4-2、index()方法

5-4-3、元组作为字典的键

5-4-4、元组解包

5-4-5、元组在循环中的使用

5-5、元组推导式(非官方术语) 

四、推荐阅读

1、Python-VBA函数之旅-list()函数

2、Python-VBA函数之旅-tuple()函数

3、Python算法之旅

4、Python函数之旅

5、个人主页-神奇夜光杯-CSDN

一、两个重要的函数

1、dir()函数

        dir()函数在Python中用于返回一个对象的所有属性和方法的列表，当你对一个函数使用dir()时，它会返回该函数对象的所有可访问属性和方法的名字列表。

具体来说，dir()函数获取的内容包括：

1-1、特殊方法和魔法方法

        如 __call__、__code__、__defaults__、__doc__、__globals__、__name__等，这些方法和属性是函数对象的一部分，提供了对函数元数据的访问。

1-2、继承自基类的属性和方法

        如果函数是某个类(如内建的函数类型)的实例，那么dir()也会包括从该类继承的属性和方法。

1-3、其他可访问的属性

        这可能包括任何在函数定义之外动态添加到函数对象上的属性。

        注意，dir()返回的列表并不保证顺序，且可能包含一些不是为了一般用途而设计的内部属性。

2、help()函数

        help()函数在Python中用于显示模块、类、方法、函数、关键字、变量等的帮助信息，当你使用 help()函数并传入一个函数作为参数时，它会显示该函数的文档字符串(如果有的话)，以及该函数的基本信息(如参数列表、返回值等)。

        具体来说，help()函数获取的内容包括：

2-1、函数的基本信息

        这包括函数的名称、所属的模块(如果有的话)以及它是否是内置的。

2-2、函数的参数列表

        如果函数有参数，help()函数会列出它们，对于每个参数，它通常会显示参数的名称和类型(如果函数定义中有类型注解的话)。

2-3、函数的文档字符串(docstring)

        如果函数有文档字符串，help()函数会显示它，文档字符串是函数定义中的第一个未赋值的字符串字面量，它应该用于解释函数的目的、参数、返回值等。

2-4、返回值

        如果函数有返回值，并且文档字符串中明确提到了返回值的类型或描述，help()函数会显示这些信息。但请注意，不是所有的函数都会在文档字符串中明确说明返回值。

2-5、其他相关信息

        如果函数有额外的元数据或特性(例如，它是否是装饰器、是否是类方法或静态方法等)，help()函数可能会显示这些信息。

        总之，使用help()函数是获取Python中函数和其他对象帮助信息的常用方法，在编写代码或学习新库时，它可以帮助你更好地理解函数的用法和行为。

二、列表

1、列表的定义

        在Python中，列表(List)是一种基本的数据类型，用于存储有序的元素集合，这些元素可以是任何类型，包括整数、浮点数、字符串、元组、列表、字典等，甚至可以是不同类型的元素混合在一起。

2、列表的语法

        列表使用方括号[]来定义，元素之间用逗号(,)分隔。如lst=[3, 5, 6, 8, 10, 11, 24]

3、获取列表的属性和方法

        用dir()函数获取list所有属性和方法的列表

  1. print(dir(list))
  2. # ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__',
  3. # '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__',
  4. # '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
  5. # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__',
  6. # '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

4、获取列表的帮助信息

        用help()函数获取list的帮助信息

  1. help(list)
  2. # Help on class list in module builtins:
  3. # 
  4. # class list(object)
  5. #  |  list(iterable=(), /)
  6. #  |  
  7. #  |  Built-in mutable sequence.
  8. #  |  
  9. #  |  If no argument is given, the constructor creates a new empty list.
  10. #  |  The argument must be an iterable if specified.
  11. #  |  
  12. #  |  Methods defined here:
  13. #  |  
  14. #  |  __add__(self, value, /)
  15. #  |      Return self+value.
  16. #  |  
  17. #  |  __contains__(self, key, /)
  18. #  |      Return key in self.
  19. #  |  
  20. #  |  __delitem__(self, key, /)
  21. #  |      Delete self[key].
  22. #  |  
  23. #  |  __eq__(self, value, /)
  24. #  |      Return self==value.
  25. #  |  
  26. #  |  __ge__(self, value, /)
  27. #  |      Return self>=value.
  28. #  |  
  29. #  |  __getattribute__(self, name, /)
  30. #  |      Return getattr(self, name).
  31. #  |  
  32. #  |  __getitem__(...)
  33. #  |      x.__getitem__(y) <==> x[y]
  34. #  |  
  35. #  |  __gt__(self, value, /)
  36. #  |      Return self>value.
  37. #  |  
  38. #  |  __iadd__(self, value, /)
  39. #  |      Implement self+=value.
  40. #  |  
  41. #  |  __imul__(self, value, /)
  42. #  |      Implement self*=value.
  43. #  |  
  44. #  |  __init__(self, /, *args, **kwargs)
  45. #  |      Initialize self.  See help(type(self)) for accurate signature.
  46. #  |  
  47. #  |  __iter__(self, /)
  48. #  |      Implement iter(self).
  49. #  |  
  50. #  |  __le__(self, value, /)
  51. #  |      Return self<=value.
  52. #  |  
  53. #  |  __len__(self, /)
  54. #  |      Return len(self).
  55. #  |  
  56. #  |  __lt__(self, value, /)
  57. #  |      Return self
  58. #  |  
  59. #  |  __mul__(self, value, /)
  60. #  |      Return self*value.
  61. #  |  
  62. #  |  __ne__(self, value, /)
  63. #  |      Return self!=value.
  64. #  |  
  65. #  |  __repr__(self, /)
  66. #  |      Return repr(self).
  67. #  |  
  68. #  |  __reversed__(self, /)
  69. #  |      Return a reverse iterator over the list.
  70. #  |  
  71. #  |  __rmul__(self, value, /)
  72. #  |      Return value*self.
  73. #  |  
  74. #  |  __setitem__(self, key, value, /)
  75. #  |      Set self[key] to value.
  76. #  |  
  77. #  |  __sizeof__(self, /)
  78. #  |      Return the size of the list in memory, in bytes.
  79. #  |  
  80. #  |  append(self, object, /)
  81. #  |      Append object to the end of the list.
  82. #  |  
  83. #  |  clear(self, /)
  84. #  |      Remove all items from list.
  85. #  |  
  86. #  |  copy(self, /)
  87. #  |      Return a shallow copy of the list.
  88. #  |  
  89. #  |  count(self, value, /)
  90. #  |      Return number of occurrences of value.
  91. #  |  
  92. #  |  extend(self, iterable, /)
  93. #  |      Extend list by appending elements from the iterable.
  94. #  |  
  95. #  |  index(self, value, start=0, stop=9223372036854775807, /)
  96. #  |      Return first index of value.
  97. #  |      
  98. #  |      Raises ValueError if the value is not present.
  99. #  |  
  100. #  |  insert(self, index, object, /)
  101. #  |      Insert object before index.
  102. #  |  
  103. #  |  pop(self, index=-1, /)
  104. #  |      Remove and return item at index (default last).
  105. #  |      
  106. #  |      Raises IndexError if list is empty or index is out of range.
  107. #  |  
  108. #  |  remove(self, value, /)
  109. #  |      Remove first occurrence of value.
  110. #  |      
  111. #  |      Raises ValueError if the value is not present.
  112. #  |  
  113. #  |  reverse(self, /)
  114. #  |      Reverse *IN PLACE*.
  115. #  |  
  116. #  |  sort(self, /, *, key=None, reverse=False)
  117. #  |      Sort the list in ascending order and return None.
  118. #  |      
  119. #  |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
  120. #  |      order of two equal elements is maintained).
  121. #  |      
  122. #  |      If a key function is given, apply it once to each list item and sort them,
  123. #  |      ascending or descending, according to their function values.
  124. #  |      
  125. #  |      The reverse flag can be set to sort in descending order.
  126. #  |  
  127. #  |  ----------------------------------------------------------------------
  128. #  |  Class methods defined here:
  129. #  |  
  130. #  |  __class_getitem__(...) from builtins.type
  131. #  |      See PEP 585
  132. #  |  
  133. #  |  ----------------------------------------------------------------------
  134. #  |  Static methods defined here:
  135. #  |  
  136. #  |  __new__(*args, **kwargs) from builtins.type
  137. #  |      Create and return a new object.  See help(type) for accurate signature.
  138. #  |  
  139. #  |  ----------------------------------------------------------------------
  140. #  |  Data and other attributes defined here:
  141. #  |  
  142. #  |  __hash__ = None

5、列表的用法

5-1、创建列表
5-1-1、创建一个空列表
  1. # 创建一个空列表
  2. my_list = []
  3. print(my_list) # 输出：[]
5-1-2、创建一个包含元素的列表
  1. # 创建一个包含元素的列表
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. print(my_list)  # 输出: [3, 5, 6, 8, 10, 11, 24]
5-1-3、创建一个包含不同类型元素的列表
  1. # 创建一个包含不同类型元素的列表
  2. mixed_list = [3, 'Myelsa', 'three',  3.0, True, [5, 6]]
  3. print(mixed_list)  # 输出: [3, 'Myelsa', 'three', 3.0, True, [5, 6]]
5-2、访问列表元素
  1. # 访问列表中的元素
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. print(my_list[0])  # 输出: 3 (访问第一个元素)
  4. print(my_list[-1])  # 输出: 24 (访问最后一个元素)
  5. print(my_list[-3:-1]) # 输出：[10, 11]  (切片操作，访问索引-3到-2的元素，不包括索引-1)
  6. print(my_list[2:4])  # 输出: [6, 8] (切片操作，访问索引2到3的元素，不包括索引4)
  7. print(my_list[:]) # 输出：[3, 5, 6, 8, 10, 11, 24] (获取列表全部元素)
5-3、修改列表元素
  1. # 修改列表中的元素
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. my_list[2] = 100  # 将索引为2的元素修改为100，默认索引从0开始
  4. print(my_list)  # 输出: [3, 5, 100, 8, 10, 11, 24]
5-4、列表用法
5-4-1、append()方法
  1. # append() 方法：在列表末尾添加元素
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. my_list.append(7)
  4. print(my_list)  # 输出: [3, 5, 6, 8, 10, 11, 24, 7]
5-4-2、insert()方法
  1. # insert()方法：在指定索引处插入元素，列表默认索引从0开始
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. my_list.insert(1, 'a')
  4. print(my_list)  # 输出: [3, 'a', 5, 6, 8, 10, 11, 24]
5-4-3、remove()方法
  1. # remove()方法：移除列表中第一个匹配的元素
  2. my_list = [3, 5, 6, 8, 11, 10, 11, 24]
  3. my_list.remove(11)
  4. print(my_list)  # 输出: [3, 5, 6, 8, 10, 11, 24]
5-4-4、pop()方法
  1. # pop()方法：移除并返回列表中的最后一个元素，或者指定索引的元素
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. last_element = my_list.pop()
  4. print(last_element)  # 输出: 24
  5. print(my_list)  # 输出: [3, 5, 6, 8, 10, 11]
5-4-5、index()方法
  1. # index()方法：返回指定元素在列表中的索引
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. index_of_three = my_list.index(3)
  4. print(index_of_three)  # 输出: 0
5-4-6、sort()方法
  1. # sort()方法：对列表进行排序(原地排序)
  2. my_list = [3, 5, 10, 8, 6, 11, 24]
  3. my_list.sort()
  4. print(my_list) # 输出：[3, 5, 6, 8, 10, 11, 24]
5-4-7、sorted()函数
  1. # sorted()函数：返回一个新的已排序的列表(不改变原列表)
  2. my_list = [3, 5, 10, 8, 6, 11, 24]
  3. sorted_list = sorted(my_list)
  4. print(sorted_list)  # 输出: [3, 5, 6, 8, 10, 11, 24]
  5. print(my_list) # 输出：[3, 5, 10, 8, 6, 11, 24]
5-4-8、count()方法
  1. # count()方法：返回指定元素在列表中出现的次数
  2. my_list = [3, 5, 6, 8, 10, 11, 10, 24]
  3. count_of_ones = my_list.count(10)
  4. print(count_of_ones)  # 输出: 2
5-4-9、extend()方法
  1. # extend()方法：将另一个列表的所有元素添加到当前列表的末尾
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. another_list = [7, 2, 9]
  4. my_list.extend(another_list)
  5. print(my_list)  # 输出: [3, 5, 6, 8, 10, 11, 24, 7, 2, 9]
5-4-10、clear()方法
  1. # clear()方法：清空列表
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. my_list.clear()
  4. print(my_list)  # 输出: []
5-4-11、使用del语句
  1. # 使用del语句：删除指定索引对应元素
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. del my_list[1]  # 删除索引为1的元素
  4. print(my_list)  # 输出: [3, 6, 8, 10, 11, 24]
5-4-12、reverse()方法
  1. # reverse()方法：直接反转原列表
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. print("原始列表：", my_list) # 输出：原始列表： [3, 5, 6, 8, 10, 11, 24]
  4. my_list.reverse()
  5. print("反转后的列表：", my_list) # 输出：反转后的列表： [24, 11, 10, 8, 6, 5, 3]
5-4-13、reversed()函数
  1. # reversed()方法：返回一个反转的迭代器，而不是一个列表，且不影响原列表
  2. my_list = [3, 5, 6, 8, 10, 11, 24]
  3. reversed_my_list = list(reversed( my_list)) # 注意，这里要用list()函数转化为列表形式
  4. print("原始列表：", my_list) # 输出：原始列表： [3, 5, 6, 8, 10, 11, 24]
  5. print("反转后的列表：", reversed_my_list) # 输出：反转后的列表： [24, 11, 10, 8, 6, 5, 3]
5-5、列表推导式
  1. # 使用列表推导式创建列表
  2. squares = [x**2 for x in range(1, 6)]
  3. print(squares)  # 输出: [1, 4, 9, 16, 25]

三、元组

1、元组的定义

        在Python中，元组(tuple)是一种不可变(immutable)的序列类型，用于存储一系列按序排列的元素。与列表（list）类似，元组也是有序的，并且可以包含不同类型的元素，但是，与列表不同的是，元组一旦创建就不能被修改(即不能添加、删除或修改元素)。

2、元组的语法

        元组使用圆括号()进行定义，即使元组中只有一个元素，也需要在这个元素后面加上逗号 , 以区分该元素和圆括号内的其他内容(比如函数调用或数学表达式)。

3、获取元组的属性和方法

        用dir()函数获取tuple所有属性和方法的列表

  1. print(dir(tuple))
  2. # ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
  3. # '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__',
  4. # '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', 
  5. # '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

4、获取元组的帮助信息

        用help()函数获取tuple的帮助信息

  1. help(tuple)
  2. # Help on class tuple in module builtins:
  3. # 
  4. # class tuple(object)
  5. #  |  tuple(iterable=(), /)
  6. #  |  
  7. #  |  Built-in immutable sequence.
  8. #  |  
  9. #  |  If no argument is given, the constructor returns an empty tuple.
  10. #  |  If iterable is specified the tuple is initialized from iterable's items.
  11. #  |  
  12. #  |  If the argument is a tuple, the return value is the same object.
  13. #  |  
  14. #  |  Built-in subclasses:
  15. #  |      asyncgen_hooks
  16. #  |      UnraisableHookArgs
  17. #  |  
  18. #  |  Methods defined here:
  19. #  |  
  20. #  |  __add__(self, value, /)
  21. #  |      Return self+value.
  22. #  |  
  23. #  |  __contains__(self, key, /)
  24. #  |      Return key in self.
  25. #  |  
  26. #  |  __eq__(self, value, /)
  27. #  |      Return self==value.
  28. #  |  
  29. #  |  __ge__(self, value, /)
  30. #  |      Return self>=value.
  31. #  |  
  32. #  |  __getattribute__(self, name, /)
  33. #  |      Return getattr(self, name).
  34. #  |  
  35. #  |  __getitem__(self, key, /)
  36. #  |      Return self[key].
  37. #  |  
  38. #  |  __getnewargs__(self, /)
  39. #  |  
  40. #  |  __gt__(self, value, /)
  41. #  |      Return self>value.
  42. #  |  
  43. #  |  __hash__(self, /)
  44. #  |      Return hash(self).
  45. #  |  
  46. #  |  __iter__(self, /)
  47. #  |      Implement iter(self).
  48. #  |  
  49. #  |  __le__(self, value, /)
  50. #  |      Return self<=value.
  51. #  |  
  52. #  |  __len__(self, /)
  53. #  |      Return len(self).
  54. #  |  
  55. #  |  __lt__(self, value, /)
  56. #  |      Return self
  57. #  |  
  58. #  |  __mul__(self, value, /)
  59. #  |      Return self*value.
  60. #  |  
  61. #  |  __ne__(self, value, /)
  62. #  |      Return self!=value.
  63. #  |  
  64. #  |  __repr__(self, /)
  65. #  |      Return repr(self).
  66. #  |  
  67. #  |  __rmul__(self, value, /)
  68. #  |      Return value*self.
  69. #  |  
  70. #  |  count(self, value, /)
  71. #  |      Return number of occurrences of value.
  72. #  |  
  73. #  |  index(self, value, start=0, stop=9223372036854775807, /)
  74. #  |      Return first index of value.
  75. #  |      
  76. #  |      Raises ValueError if the value is not present.
  77. #  |  
  78. #  |  ----------------------------------------------------------------------
  79. #  |  Class methods defined here:
  80. #  |  
  81. #  |  __class_getitem__(...) from builtins.type
  82. #  |      See PEP 585
  83. #  |  
  84. #  |  ----------------------------------------------------------------------
  85. #  |  Static methods defined here:
  86. #  |  
  87. #  |  __new__(*args, **kwargs) from builtins.type
  88. #  |      Create and return a new object.  See help(type) for accurate signature.

5、元组的用法

5-1、创建元组
5-1-1、创建一个空元组
  1. # 创建空元组
  2. my_tuple = ()
  3. print(my_tuple) # 输出：()
5-1-2、创建一个包含1个元素的元组
  1. # 只有一个元素的元组需要一个逗号
  2. single_element_tuple = (5,)
  3. print(single_element_tuple) # 输出：(5,)
5-1-3、创建一个包含多个元素的元组
  1. # 使用圆括号创建元组
  2. my_tuple = (3, 5, 6, 8, 10, 11, 24)
  3. print(my_tuple) # 输出：(3, 5, 6, 8, 10, 11, 24)
  4.  
  5. # 也可以不使用圆括号，仅通过逗号分隔元素来创建元组
  6. another_tuple = 3, 5, 6, 8, 10, 11, 24
  7. print(another_tuple) # 输出：(3, 5, 6, 8, 10, 11, 24)
5-1-4、创建一个包含不同类型元素的元组
  1. # 元组可以包含不同类型的元素
  2. mixed_tuple = (1, 'two', 3.0, [4, 5])
  3. print(mixed_tuple) # 输出：(1, 'two', 3.0, [4, 5])
5-2、访问元组中的元素
  1. # 访问元组中的元素
  2. my_tuple = (3, 5, 6, 8, 10, 11, 24)
  3. print(my_tuple [0])  # 输出: 3 (访问第一个元素)
  4. print(my_tuple [-1])  # 输出: 24 (访问最后一个元素)
  5. print(my_tuple [-3:-1]) # 输出：(10, 11)  (切片操作，访问索引-3到-2的元素，不包括索引-1)
  6. print(my_tuple [2:4])  # 输出: (6, 8) (切片操作，访问索引2到3的元素，不包括索引4)
  7. print(my_tuple [:]) # 输出：(3, 5, 6, 8, 10, 11, 24) (获取元组全部元素)
5-3、元组的不可变性 
  1. my_tuple = (3, 5, 6, 8, 10, 11, 24)
  2. # 尝试修改元组中的元素会导致错误
  3. try:
  4.     my_tuple[0] = 10
  5. except TypeError as e:
  6.     print(e)  # 输出: 'tuple' object does not support item assignment
5-4、元组用法
5-4-1、count()方法
  1. # count()方法：计算元组中某个元素的出现次数
  2. my_tuple = (3, 5, 6, 8, 10, 11, 10, 24)
  3. print(my_tuple.count(10))  # 输出: 2
5-4-2、index()方法
  1. # index()方法：找到元组中某个元素的索引
  2. my_tuple = (3, 5, 6, 8, 10, 11, 10, 24)
  3. print(my_tuple.index(6))  # 输出: 2 (索引默认从0开始)
5-4-3、元组作为字典的键
  1. my_dict = {(3, 6): 'Bruce', (10, 8): 'Jimmy', (10, 24):'Myelsa', (5, 11):'Lucy'}
  2. print(my_dict[(10, 24)])  # 输出: Myelsa
5-4-4、元组解包
  1. my_tuple = (3, 5, 6, 8, 10, 11, 10, 24)
  2. a, b, c, d, e, f, g, h = my_tuple
  3. print(a, b, c, d, e, f, g, h)  # 输出: 3 5 6 8 10 11 10 24
5-4-5、元组在循环中的使用
  1. colors = ['red', 'green', 'blue']  
  2. numbers = (1, 2, 3)  
  3. for color, number in zip(colors, numbers):  
  4.     print(f"Color: {color}, Number: {number}")
  5. # 输出：
  6. # Color: red, Number: 1
  7. # Color: green, Number: 2
  8. # Color: blue, Number: 3
5-5、元组推导式(非官方术语) 
  1. # 使用元组推导式创建列表
  2. squares = tuple((x**2 for x in range(1, 6)))
  3. print(squares)  # 输出: (1, 4, 9, 16, 25)

四、推荐阅读

1、Python-VBA函数之旅-list()函数

2、Python-VBA函数之旅-tuple()函数

3、Python算法之旅

4、Python函数之旅

5、个人主页-神奇夜光杯-CSDN

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61321 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/139009046"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！