Python-VBA函数之旅-len函数

目录

一、len函数的常见应用场景：

二、len函数使用注意事项：

三、如何用好len函数？

1、len函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

一、len函数的常见应用场景：

        len函数在Python中非常常用，它可以帮助我们获取各种数据类型的长度或大小，常见的应用场景有：

1、字符串处理：当你需要知道一个字符串的长度时，可以使用len()函数，这在验证用户输入、处理文本数据或进行字符串操作时非常有用。

2、列表和元组操作：当你需要知道一个字符串的长度时，可以使用len()函数，这在验证用户输入、处理文本数据或进行字符串操作时非常有用。

3、字典操作：字典是Python中存储键值对的数据结构，len()函数可以用于获取字典中的键值对数量，这在统计字典大小或进行迭代操作时非常有用。

4、集合操作：集合用于存储唯一的元素，使用len()函数可以方便地获取集合中元素的数量，这在检查集合大小、比较集合或进行集合运算时非常有用。

5、自定义对象：如果你创建了自定义对象，并希望len()函数能够返回该对象的某种属性或状态的“长度”，你可以在自定义类中实现`__len__()`方法。

6、文件和输入/输出：在处理文件或进行输入/输出操作时，len()函数可以用来获取读取或写入的数据长度，这对于监控数据传输、检查文件大小或进行数据处理时非常有用。

7、循环和迭代控制：在循环中，有时候需要根据序列的长度来控制循环的次数，len()函数在这里可以发挥重要作用。

8、动态分配空间：在某些需要动态分配空间的情况下，如创建特定长度的列表或数组时，len()可以用于预先知道需要多少空间。

9、调试和日志记录：在开发过程中，len()函数可以用于调试，帮助开发者了解数据的大小或结构；同时，它也可以用于日志记录，记录数据的大小变化。

10、性能分析和优化：在性能分析和优化过程中，了解数据结构的大小可以帮助你确定算法的效率，使用len()函数可以方便地获取数据的大小，从而进行性能分析和比较。

11、结合其他函数和方法使用：len()函数可以与Python中的其他函数和方法结合使用，以实现更复杂的操作。例如，你可以使用len()与条件语句、循环结构、列表推导式等结合，以完成各种任务。

        总之，len()函数在Python编程中的应用非常广泛，几乎在任何需要知道对象大小或长度的场景中都可以使用。

二、len函数使用注意事项：

        在Python中使用len()函数时，有一些注意事项需要牢记，以确保正确使用并避免潜在的问题。以下是一些关键的注意事项：

1、数据类型支持：len()函数只适用于那些定义了`__len__()`方法的对象，这通常包括序列类型(如字符串、列表、元组、字节和字节数组)和集合类型(如字典、集合和冻结集合)，如果你尝试对不支持长度计算的对象使用len()函数，将会引发TypeError异常。

2、返回值类型：len()函数始终返回一个整数，表示对象的长度或元素数量，如果对象没有长度(例如整数或浮点数)，则不能使用len()函数。

3、对象的实时状态：len()函数返回的是对象在调用时的长度或大小，如果对象在调用len()函数之后被修改(例如，列表的元素被添加或删除)，那么你需要再次调用len()函数来获取新的长度。

4、性能考虑：对于非常大的对象，使用len()函数可能会导致性能问题，因为它可能需要遍历整个对象来确定长度，在处理大数据集时，请考虑其他可能的性能优化方法。

5、空对象：对于空对象(如空字符串、空列表或空字典)，len()函数将返回0，这有助于在编写代码时检查对象是否为空。

6、自定义对象：如果你想对自定义对象使用len()函数，你需要在类中实现`__len__()`方法，这个方法应该返回一个整数，表示对象的“长度”或“大小”。

7、可变/不可变对象：对于可变对象(如列表)，len()返回的是当前状态下的长度，如果你之后修改了对象(例如添加或删除元素)，你需要再次调用len()函数来获取新的长度，对于不可变对象(如字符串或元组)，一旦创建，它们的长度就不会改变，所以len()函数的返回值也不会变。

        总之，只有遵循这些注意事项，你才能更有效地使用len()函数，并避免在Python编程中遇到常见的问题。

三、如何用好len函数？

        要用好Python中的len()函数，首先要明确它的作用：返回对象的长度或项目数。为了充分发挥len()函数的功能，可以遵循以下几个建议：

1、明确数据类型：在使用len()函数之前，确保你了解对象的数据类型，虽然len()函数可以用于多种数据类型，但不同的数据类型可能有不同的解释。例如，对于字符串，len()返回字符数；对于列表或元组，返回元素数量；对于字典，返回键值对的数量。

2、检查对象是否为空：使用len()函数可以快速检查一个对象是否为空，如果len()返回0，那么对象就是空的，这对于条件判断和循环控制非常有用。

3、在循环和迭代中使用：在编写循环或迭代时，可以使用len()函数来确定需要迭代的次数。例如，在遍历列表或字符串时，你可以使用len()来确定循环的次数。

4、避免不必要的计算：虽然len()函数通常很快，但如果你在一个循环中多次调用它来获取相同的长度，那么这可能会导致不必要的性能开销，在这种情况下，最好将长度存储在一个变量中，并在循环中使用这个变量。

5、自定义对象支持：如果你正在处理自定义对象，并希望len()函数能够返回对象的某种长度或大小，你可以在自定义类中实现`__len__()`方法，这样，当你对该对象调用len()函数时，Python会自动调用你定义的`__len__()`方法。

6、结合其他函数和方法使用：len()函数可以与Python中的其他函数和方法结合使用，以实现更复杂的操作。例如，你可以使用len()`与条件语句、循环结构、列表推导式等结合，以完成各种任务。

7、注意返回值类型：len()函数始终返回一个整数，确保你在使用返回值时考虑到这一点，避免将其与其他非整数类型混淆。

1、len函数：
1-1、Python：
  1. # 1.函数：len
  2. # 2.功能：用于获取可迭代对象的长度或元素个数
  3. # 3.语法：len(s)
  4. # 4.参数：s，要获取其长度或者元素个数的对象
  5. # 5.返回值：返回可迭代对象的长度或元素个数
  6. # 6.说明：
  7. # 7.示例：
  8. # 利用dir()函数获取函数的相关内置属性和方法
  9. print(dir(len))
  10. # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
  11. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
  12. # '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
  13. # '__str__', '__subclasshook__', '__text_signature__']
  14.  
  15. # 利用help()函数获取函数的文档信息
  16. help(len)
  17.  
  18. # 应用一：字符串处理
  19. # 示例1：获取字符串长度
  20. string1 = "Hello, World!"
  21. length = len(string1)
  22. print(f"The length of the string '{string1}' is {length}.")
  23. # The length of the string 'Hello, World!' is 13.
  24.  
  25. # 示例2：比较两个字符串的长度
  26. string2 = "Python"
  27. string3 = "Java"
  28. if len(string2) > len(string3):
  29.     print(f"'{string2}' is longer than '{string3}'.")
  30. elif len(string2) < len(string3):
  31.     print(f"'{string2}' is shorter than '{string3}'.")
  32. else:
  33.     print(f"'{string2}' and '{string3}' are the same length.")
  34. # 'Python' is longer than 'Java'.
  35.  
  36. # 示例3：处理字符串切片并获取长度
  37. string4 = "myelsaiswonderful"
  38. substring = string4[2:6]  # Slicing the string from index 2 to 5 (excluding 6)
  39. substring_length = len(substring)
  40. print(f"The substring '{substring}' of '{string4}' has a length of {substring_length}.")
  41. # The substring 'elsa' of 'myelsaiswonderful' has a length of 4.
  42.  
  43. # 示例4：统计字符串中某个字符的出现次数(通过转换为列表并计算长度)
  44. string5 = "mississippi"
  45. char_to_count = "i"
  46. count = len([char for char in string5 if char == char_to_count])
  47. print(f"The character '{char_to_count}' appears {count} times in '{string5}'.")
  48. # The character 'i' appears 4 times in 'mississippi'.
  49.  
  50. # 示例5：处理字符串中的空格并获取非空格字符的长度
  51. string6 = "Hello,   World!  "
  52. string6_without_spaces = ''.join(string6.split())  # Remove spaces
  53. length_without_spaces = len(string6_without_spaces)
  54. print(f"The length of '{string6}' without spaces is {length_without_spaces}.")
  55. # The length of 'Hello,   World!  ' without spaces is 12.
  56.  
  57. # 应用二：列表和元组操作
  58. # 示例1：获取列表长度
  59. my_list = [1, 2, 3, 4, 5]
  60. list_length = len(my_list)
  61. print(f"The length of the list {my_list} is {list_length}.")
  62. # The length of the list [1, 2, 3, 4, 5] is 5.
  63.  
  64. # 示例2：比较两个列表的长度
  65. list1 = [1, 2, 3]
  66. list2 = ['a', 'b', 'c', 'd']
  67. if len(list1) > len(list2):
  68.     print(f"List {list1} is longer than list {list2}.")
  69. elif len(list1) < len(list2):
  70.     print(f"List {list1} is shorter than list {list2}.")
  71. else:
  72.     print(f"Lists {list1} and {list2} are the same length.")
  73. # List [1, 2, 3] is shorter than list ['a', 'b', 'c', 'd'].
  74.  
  75. # 示例3：处理列表切片并获取长度
  76. fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
  77. sliced_fruits = fruits[1:4]  # Slicing the list from index 1 to 3 (excluding 4)
  78. sliced_length = len(sliced_fruits)
  79. print(f"The sliced list {sliced_fruits} has a length of {sliced_length}.")
  80. # The sliced list ['banana', 'cherry', 'date'] has a length of 3.
  81.  
  82. # 示例4：列表中添加元素并查看长度变化
  83. numbers = [1, 2, 3]
  84. print(f"Initial length of the list {numbers} is {len(numbers)}.")
  85. numbers.append(4)  # Add an element to the list
  86. print(f"After adding an element, the length of the list {numbers} is {len(numbers)}.")
  87. # Initial length of the list [1, 2, 3] is 3.
  88. # After adding an element, the length of the list [1, 2, 3, 4] is 4.
  89.  
  90. # 示例5：使用列表推导式并获取长度
  91. squares = [x**2 for x in range(5)]  # List comprehension to create a list of squares
  92. squares_length = len(squares)
  93. print(f"The list {squares} of squares has a length of {squares_length}.")
  94. # The list [0, 1, 4, 9, 16] of squares has a length of 5.
  95.  
  96. # 示例6：获取元组长度
  97. my_tuple = (10, 20, 30, 40, 50)
  98. tuple_length = len(my_tuple)
  99. print(f"The length of the tuple {my_tuple} is {tuple_length}.")
  100. # The length of the tuple (10, 20, 30, 40, 50) is 5.
  101.  
  102. # 示例7：比较元组与列表的长度
  103. my_tuple = ('a', 'b', 'c')
  104. my_list = ['x', 'y', 'z']
  105. if len(my_tuple) == len(my_list):
  106.     print(f"The tuple {my_tuple} and the list {my_list} are the same length.")
  107. else:
  108.     print(f"The tuple {my_tuple} and the list {my_list} are not the same length.")
  109. # The tuple ('a', 'b', 'c') and the list ['x', 'y', 'z'] are the same length.
  110.  
  111. # 应用三：字典操作
  112. # 示例1：获取字典的长度(键的数量)
  113. my_dict = {'a': 1, 'b': 2, 'c': 3}
  114. dict_length = len(my_dict)
  115. print(f"The length of the dictionary {my_dict} is {dict_length}.")
  116. # The length of the dictionary {'a': 1, 'b': 2, 'c': 3} is 3.
  117.  
  118. # 示例2：比较两个字典的长度
  119. dict1 = {'x': 10, 'y': 20}
  120. dict2 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  121. if len(dict1) > len(dict2):
  122.     print(f"Dictionary {dict1} has more keys than {dict2}.")
  123. elif len(dict1) < len(dict2):
  124.     print(f"Dictionary {dict1} has fewer keys than {dict2}.")
  125. else:
  126.     print(f"Dictionaries {dict1} and {dict2} have the same number of keys.")
  127. # Dictionary {'x': 10, 'y': 20} has fewer keys than {'a': 1, 'b': 2, 'c': 3, 'd': 4}.
  128.  
  129. # 示例3：添加键值对到字典并查看长度变化
  130. person = {'name': 'Myelsa', 'age': 18}
  131. print(f"Initial length of the dictionary {person} is {len(person)}.")
  132. person['city'] = 'New York'  # Add a key-value pair to the dictionary
  133. print(f"After adding a key-value pair, the length of the dictionary {person} is {len(person)}.")
  134. # Initial length of the dictionary {'name': 'Myelsa', 'age': 18} is 2.
  135. # After adding a key-value pair, the length of the dictionary {'name': 'Myelsa', 'age': 18, 'city': 'New York'} is 3.
  136.  
  137. # 示例4：移除字典中的键值对并查看长度变化
  138. person = {'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}
  139. print(f"Initial length of the dictionary {person} is {len(person)}.")
  140. del person['city']  # Remove a key-value pair from the dictionary
  141. print(f"After removing a key-value pair, the length of the dictionary {person} is {len(person)}.")
  142. # Initial length of the dictionary {'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'} is 3.
  143. # After removing a key-value pair, the length of the dictionary {'name': 'Myelsa', 'age': 18} is 2.
  144.  
  145. # 示例5：获取字典中值的数量(不考虑重复)
  146. my_dict = {'a': 1, 'b': 2, 'c': 1, 'd': 3}
  147. values_set = set(my_dict.values())  # Convert values to a set to remove duplicates
  148. values_count = len(values_set)
  149. print(f"The number of unique values in the dictionary {my_dict} is {values_count}.")
  150. # The number of unique values in the dictionary {'a': 1, 'b': 2, 'c': 1, 'd': 3} is 3.
  151.  
  152. # 示例6：比较两个字典是否有相同数量的键值对
  153. dict3 = {'e': 5, 'f': 6}
  154. dict4 = {'g': 7, 'h': 8, 'i': 9}
  155. if len(dict3) == len(dict4):
  156.     print(f"Dictionaries {dict3} and {dict4} have the same number of key-value pairs.")
  157. else:
  158.     print(f"Dictionaries {dict3} and {dict4} do not have the same number of key-value pairs.")
  159. # Dictionaries {'e': 5, 'f': 6} and {'g': 7, 'h': 8, 'i': 9} do not have the same number of key-value pairs.
  160.  
  161. # 应用四：集合操作
  162. # 示例1：获取集合的长度(元素数量)
  163. my_set = {1, 2, 3, 4, 5}
  164. set_length = len(my_set)
  165. print(f"The length of the set {my_set} is {set_length}.")
  166. # The length of the set {1, 2, 3, 4, 5} is 5.
  167.  
  168. # 示例2：比较两个集合的长度
  169. set1 = {1, 2, 3}
  170. set2 = {4, 5, 6, 7}
  171. if len(set1) > len(set2):
  172.     print(f"Set {set1} has more elements than {set2}.")
  173. elif len(set1) < len(set2):
  174.     print(f"Set {set1} has fewer elements than {set2}.")
  175. else:
  176.     print(f"Sets {set1} and {set2} have the same number of elements.")
  177. # Set {1, 2, 3} has fewer elements than {4, 5, 6, 7}.
  178.  
  179. # 示例3：添加元素到集合并查看长度变化
  180. my_set = {1, 2, 3}
  181. print(f"Initial length of the set {my_set} is {len(my_set)}.")
  182. my_set.add(4)  # Add an element to the set
  183. print(f"After adding an element, the length of the set {my_set} is {len(my_set)}.")
  184. # Initial length of the set {1, 2, 3} is 3.
  185. # After adding an element, the length of the set {1, 2, 3, 4} is 4.
  186.  
  187. # 示例4：移除集合中的元素并查看长度变化
  188. my_set = {1, 2, 3, 4}
  189. print(f"Initial length of the set {my_set} is {len(my_set)}.")
  190. my_set.remove(3)  # Remove an element from the set
  191. print(f"After removing an element, the length of the set {my_set} is {len(my_set)}.")
  192. # Initial length of the set {1, 2, 3, 4} is 4.
  193. # After removing an element, the length of the set {1, 2, 4} is 3.
  194.  
  195. # 示例5：计算两个集合的并集并获取长度
  196. set1 = {1, 2, 3}
  197. set2 = {3, 4, 5}
  198. union_set = set1.union(set2)  # Get the union of two sets
  199. union_length = len(union_set)
  200. print(f"The union of {set1} and {set2} is {union_set} and its length is {union_length}.")
  201. # The union of {1, 2, 3} and {3, 4, 5} is {1, 2, 3, 4, 5} and its length is 5.
  202.  
  203. # 示例6：计算两个集合的交集并获取长度
  204. set1 = {1, 2, 3}
  205. set2 = {3, 4, 5}
  206. intersection_set = set1.intersection(set2)  # Get the intersection of two sets
  207. intersection_length = len(intersection_set)
  208. print(f"The intersection of {set1} and {set2} is {intersection_set} and its length is {intersection_length}.")
  209. # The intersection of {1, 2, 3} and {3, 4, 5} is {3} and its length is 1.
  210.  
  211. # 应用五：自定义对象
  212. # 示例1：自定义一个字符串列表类，并实现__len__()方法
  213. class StringList:
  214.     def __init__(self, strings):
  215.         self.strings = strings
  216.     def __len__(self):
  217.         return len(self.strings)
  218.     def __str__(self):
  219.         return str(self.strings)
  220. # 创建一个StringList对象
  221. my_list = StringList(['apple', 'banana', 'cherry'])
  222. # 使用len()函数获取StringList对象的长度
  223. length = len(my_list)
  224. print(f"The length of the StringList {my_list} is {length}.")
  225. # The length of the StringList ['apple', 'banana', 'cherry'] is 3.
  226.  
  227. # 示例2：自定义一个学生类，每个学生有多个课程，计算学生选课数量
  228. class Student:
  229.     def __init__(self, name, courses):
  230.         self.name = name
  231.         self.courses = courses
  232.     def __len__(self):
  233.         return len(self.courses)
  234.     def __str__(self):
  235.         return f"{self.name} has {len(self.courses)} courses."
  236. # 创建一个Student对象
  237. student = Student("Myelsa", ["Math", "Science", "English"])
  238. # 使用len()函数获取Student对象的课程数量
  239. num_courses = len(student)
  240. print(f"The number of courses for {student} is {num_courses}.")
  241. # The number of courses for Myelsa has 3 courses. is 3.
  242.  
  243. # 示例3：自定义一个点集类，计算点集中点的数量
  244. class PointSet:
  245.     def __init__(self, points):
  246.         self.points = points
  247.     def __len__(self):
  248.         return len(self.points)
  249.     def __str__(self):
  250.         return str(self.points)
  251. # 创建一个PointSet对象
  252. point_set = PointSet([(1, 2), (3, 4), (5, 6)])
  253. # 使用len()函数获取PointSet对象的点数量
  254. num_points = len(point_set)
  255. print(f"The number of points in the PointSet {point_set} is {num_points}.")
  256. # The number of points in the PointSet [(1, 2), (3, 4), (5, 6)] is 3.
  257.  
  258. # 应用六：文件和输入/输出
  259. # 示例1：读取文件内容并计算其长度
  260. # 打开文件并读取所有内容
  261. with open('file.txt', 'r', encoding='utf-8') as file:
  262.     content = file.read()
  263. # 计算文件内容的长度
  264. content_length = len(content)
  265. print(f"The length of the file content is: {content_length} characters.")
  266. # The length of the file content is: 39 characters.
  267.  
  268. # 示例2：逐行读取文件并计算行数
  269. # 打开文件并逐行读取
  270. with open('file.txt', 'r', encoding='utf-8') as file:
  271.     lines = file.readlines()
  272. # 计算行数(即列表长度)
  273. num_lines = len(lines)
  274. print(f"The number of lines in the file is: {num_lines}.")
  275. # The number of lines in the file is: 6.
  276.  
  277. # 示例3：从用户输入读取字符串并计算其长度
  278. # 从用户获取输入
  279. user_input = input("Enter a string: ")
  280. # 计算输入字符串的长度
  281. input_length = len(user_input)
  282. print(f"The length of your input is: {input_length} characters.")
  283. # Enter a string: myelsa
  284. # The length of your input is: 6 characters.
  285.  
  286. # 示例4：将文件内容读入列表并计算列表中元素的数量
  287. # 打开文件并读取所有行，将每行转换为整数并添加到列表中
  288. with open('file.txt', 'r', encoding='utf-8') as file:
  289.     data_list = [int(line.strip()) for line in file]
  290. # 计算列表中元素的数量
  291. num_elements = len(data_list)
  292. print(f"The number of elements in the list is: {num_elements}.")
  293. # The number of elements in the list is: 6.
  294.  
  295. # 应用七：循环和迭代控制
  296. # 示例1：使用len()和for循环遍历列表
  297. my_list = [1, 2, 3, 4, 5]
  298. # 使用len()获取列表长度，并使用for循环遍历列表
  299. for i in range(len(my_list)):
  300.     print(my_list[i])
  301. # 1
  302. # 2
  303. # 3
  304. # 4
  305. # 5
  306.  
  307. # 示例2：使用len()和while循环遍历字符串
  308. my_string = "Hello, Python!"
  309. index = 0
  310. # 使用len()获取字符串长度，并使用while循环遍历字符串
  311. while index < len(my_string):
  312.     print(my_string[index])
  313.     index += 1
  314. # H
  315. # e
  316. # l
  317. # l
  318. # o
  319. # ,
  320. #
  321. # P
  322. # y
  323. # t
  324. # h
  325. # o
  326. # n
  327. # !
  328.  
  329. # 示例3：使用len()和列表推导式(迭代控制)
  330. my_list = [1, 2, 3, 4, 5]
  331. # 使用len()和列表推导式创建一个新列表，包含原列表中每个元素的平方
  332. squared_list = [x ** 2 for x in my_list if x < len(my_list)]
  333. print(squared_list)
  334. # [1, 4, 9, 16]
  335.  
  336. # 示例4：使用len()和enumerate()函数遍历列表同时获取索引和值
  337. my_list = ['apple', 'banana', 'cherry']
  338. # 使用enumerate()和len()来遍历列表，并打印索引和值
  339. for index, item in enumerate(my_list):
  340.     print(f"Index {index} has value {item}")
  341. # 也可以使用range()和len()来达到相同的效果
  342. for index in range(len(my_list)):
  343.     print(f"Index {index} has value {my_list[index]}")
  344. # Index 0 has value apple
  345. # Index 1 has value banana
  346. # Index 2 has value cherry
  347. # Index 0 has value apple
  348. # Index 1 has value banana
  349. # Index 2 has value cherry
  350.  
  351. # 示例5：使用len()控制循环次数以处理嵌套列表
  352. nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  353. # 使用len()来控制外部循环，遍历嵌套列表的每一个子列表
  354. for i in range(len(nested_list)):
  355.     # 使用len()来控制内部循环，遍历当前子列表的每一个元素
  356.     for j in range(len(nested_list[i])):
  357.         print(nested_list[i][j])
  358. # 1
  359. # 2
  360. # 3
  361. # 4
  362. # 5
  363. # 6
  364. # 7
  365. # 8
  366. # 9
  367.  
  368. # 应用八：动态分配空间
  369. # 示例1：根据输入字符串的长度动态创建列表
  370. input_string = input("Enter a string: ")
  371. # 使用len()获取输入字符串的长度，并创建一个相应长度的列表
  372. list_length = len(input_string)
  373. my_list = [None] * list_length
  374. # 现在可以根据需要填充列表
  375. for i in range(list_length):
  376.     my_list[i] = input_string[i]
  377. print(my_list)
  378. # Enter a string: myelsa
  379. # ['m', 'y', 'e', 'l', 's', 'a']
  380.  
  381. # 示例2：根据一组数字动态创建和填充字典
  382. numbers = input("Enter numbers separated by spaces: ").split()
  383. # 使用len()获取数字的数量，并创建一个空字典
  384. num_count = len(numbers)
  385. my_dict = {}
  386. # 根据数字的数量动态添加键值对到字典中
  387. for i in range(num_count):
  388.     my_dict[i] = int(numbers[i])
  389. print(my_dict)
  390. # Enter numbers separated by spaces: 16
  391. # {0: 16}
  392.  
  393. # 示例3：动态扩展列表以包含新元素
  394. my_list = [1, 2, 3]
  395. # 假设我们要添加一个新元素到列表末尾
  396. new_element = 4
  397. # 不需要直接使用len()来分配空间，Python列表会自动处理
  398. my_list.append(new_element)
  399. print(my_list)
  400. # [1, 2, 3, 4]
  401.  
  402. # 应用九：调试和日志记录
  403. # 示例1：使用print和len()进行基本调试
  404. my_list = [1, 2, 3, 4, 5]
  405. # 在调试时使用print和len()查看列表长度
  406. print(f"The length of my_list is: {len(my_list)}")
  407. # 对列表进行修改后，再次查看长度
  408. my_list.append(6)
  409. print(f"After appending an element, the length of my_list is: {len(my_list)}")
  410. # The length of my_list is: 5
  411. # After appending an element, the length of my_list is: 6
  412.  
  413. # 示例2：使用日志库(如logging)记录长度信息
  414. import logging
  415. # 配置日志记录器
  416. logging.basicConfig(level=logging.INFO)
  417. my_list = [1, 2, 3, 4, 5]
  418. # 使用logging库记录列表长度
  419. logging.info(f"The length of my_list is: {len(my_list)}")
  420. # 对列表进行修改，并记录修改后的长度
  421. my_list.append(6)
  422. logging.info(f"After appending an element, the length of my_list is: {len(my_list)}")
  423. # INFO:root:The length of my_list is: 5
  424. # INFO:root:After appending an element, the length of my_list is: 6
  425.  
  426. # 示例3：在复杂函数中使用len()进行调试
  427. import logging
  428. def process_data(data):
  429.     # 假设data是一个列表，我们对其进行一些处理
  430.     processed_data = [x * 2 for x in data]
  431.     # 使用logging记录处理前和处理后的数据长度
  432.     logging.debug(f"Original data length: {len(data)}")
  433.     logging.debug(f"Processed data length: {len(processed_data)}")
  434.     return processed_data
  435. # 示例数据
  436. data = [1, 2, 3]
  437. # 调用函数并记录日志
  438. processed_data = process_data(data)
  439. logging.info(f"Processed data: {processed_data}")
  440.  
  441. # 示例4：在异常处理中使用len()进行调试
  442. import logging
  443. def read_file_and_process(filename):
  444.     try:
  445.         with open(filename, 'r') as file:
  446.             lines = file.readlines()
  447.         # 使用len()检查是否读取到任何行
  448.         if len(lines) == 0:
  449.             raise ValueError("The file is empty.")
  450.     # 对读取到的行进行处理（此处仅为示例，未实际处理）
  451.     except FileNotFoundError:
  452.         logging.error(f"File {filename} not found.")
  453.     except ValueError as e:
  454.         logging.error(e)
  455.     except Exception as e:
  456.         logging.error(f"An error occurred: {e}")
  457.         logging.debug(f"Number of lines read: {len(lines) if 'lines' in locals() else 'N/A'}")
  458. # 调用函数，假设文件存在但为空
  459. read_file_and_process('file.txt')
  460.  
  461. # 应用十：性能分析和优化
  462. # 示例1：避免在循环中多次调用len()
  463. # 不推荐的做法：在循环中多次调用len()
  464. my_list = [1, 2, 3, 4, 5]
  465. for i in range(len(my_list)):
  466.     print(len(my_list))  # 这里的len()调用是不必要的，因为列表长度不会改变
  467.     print(my_list[i])
  468. # 推荐的做法：在循环外部调用len()，并存储结果
  469. list_length = len(my_list)
  470. for i in range(list_length):
  471.     print(list_length)  # 使用之前存储的长度
  472.     print(my_list[i])
  473.  
  474. # 示例2：使用生成器代替列表以节省内存
  475. # 使用列表推导式创建列表
  476. my_list = [x * x for x in range(1000000)]  # 这会立即创建一个大列表，占用大量内存
  477. print(len(my_list))  # 使用len()获取长度
  478. # 使用生成器表达式节省内存
  479. my_generator = (x * x for x in range(1000000))  # 生成器不会立即创建所有元素，而是按需生成
  480. print(sum(1 for _ in my_generator))  # 使用sum和生成器表达式计算元素数量，而不是len()
  481.  
  482. # 示例3：使用内置函数和库函数代替手动循环
  483. # 使用循环和len()计算列表中所有元素的和
  484. my_list = [1, 2, 3, 4, 5]
  485. sum_manual = 0
  486. for item in my_list:
  487.     sum_manual += item
  488. print(sum_manual)
  489. # 使用内置函数sum()代替循环，更高效
  490. sum_builtin = sum(my_list)
  491. print(sum_builtin)
  492. # 对于更复杂的操作，考虑使用NumPy等库，它们针对数组操作进行了优化
  493. import numpy as np
  494. my_array = np.array(my_list)
  495. sum_numpy = np.sum(my_array)
  496. print(sum_numpy)
  497.  
  498. # 示例4：性能分析使用time模块测量执行时间
  499. import time
  500. # 示例函数，使用len()
  501. def count_elements(data):
  502.     return len(data)
  503. # 创建一个大型数据集
  504. large_data = [x for x in range(1000000)]
  505. # 使用time模块测量函数执行时间
  506. start_time = time.time()
  507. count = count_elements(large_data)
  508. end_time = time.time()
  509. print(f"Number of elements: {count}")
  510. print(f"Execution time: {end_time - start_time} seconds")
  511. # Number of elements: 1000000
  512. # Execution time: 0.0 seconds
  513.  
  514. # 示例5：使用cProfile进行性能分析
  515. import cProfile
  516. # 示例函数，执行一些操作并返回长度
  517. def process_data(data):
  518.     processed_data = [x * x for x in data]
  519.     return len(processed_data)
  520. # 创建一个大型数据集
  521. large_data = [x for x in range(100000)]
  522. # 使用cProfile进行性能分析
  523. cProfile.run('process_data(large_data)')
  524.  
  525. # 应用十一：结合其他函数和方法使用
  526. # 示例1：验证列表长度是否符合预期
  527. def validate_list_length(lst, expected_length):
  528.     if len(lst) != expected_length:
  529.         raise ValueError(f"Expected list length {expected_length}, but got {len(lst)}")
  530.     return lst
  531. my_list = [1, 2, 3, 4]
  532. try:
  533.     validate_list_length(my_list, 5)
  534. except ValueError as e:
  535.     print(e)
  536. # Expected list length 5, but got 4
  537.  
  538. # 示例2：使用map()函数和len()计算列表中每个字符串的长度
  539. my_strings = ['hello', 'world', 'python']
  540. lengths = list(map(len, my_strings))
  541. print(lengths)
  542. # [5, 5, 6]
  543.  
  544. # 示例3：使用filter()函数和len()筛选长度大于特定值的字符串
  545. my_strings = ['a', 'apple', 'banana', 'c', 'cherry']
  546. long_strings = list(filter(lambda s: len(s) > 1, my_strings))
  547. print(long_strings)  # 输出: ['apple', 'banana', 'cherry']
  548. # ['apple', 'banana', 'cherry']
  549.  
  550. # 示例4：使用sorted()函数和len()按字符串长度排序
  551. my_strings = ['apple', 'cherry', 'banana', 'grape']
  552. sorted_by_length = sorted(my_strings, key=len)
  553. print(sorted_by_length)
  554. # ['apple', 'grape', 'cherry', 'banana']
  555.  
  556. # 示例5：使用reduce()函数和len()计算嵌套列表中所有字符串的总长度
  557. from functools import reduce
  558. nested_list = [['a', 'bc'], ['def', 'ghi'], ['jklmnop']]
  559. total_length = reduce(lambda acc, lst: acc + sum(map(len, lst)), nested_list, 0)
  560. print(total_length)
  561. # 16
  562.  
  563. # 示例6：在数据清洗过程中使用len()去除空字符串
  564. data = ['apple', '', 'banana', ' ', 'cherry']
  565. cleaned_data = [item for item in data if len(item.strip()) > 0]
  566. print(cleaned_data)
  567. # ['apple', 'banana', 'cherry']
1-2、VBA：
略，待后补。
2、推荐阅读：

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

Python算法之旅：Algorithm

Python函数之旅：Functions 

个人主页：https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421 

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

评论记录：

未查询到任何数据！