• 30个Python操作小技巧

    1、列表推导

    列表的元素可以在一行中进行方便的循环。

    1. numbers = [1, 2, 3, 4, 5, 6, 7, 8]
    2. even_numbers = [number for number in numbers if number % 2 == 0]
    3. print(even_numbers)

    输出：

     [1,3,5,7]

    同时，也可以用在字典上。

    1. dictionary = {'first_num': 1, 'second_num': 2,
    2.               'third_num': 3, 'fourth_num': 4}
    3. oddvalues = {key: value for (key, value) in dictionary.items() if value % 2 != 0}
    4. print(oddvalues)Output: {'first_num': 1, 'third_num': 3}

    2、枚举函数

    枚举是一个有用的函数，用于迭代对象，如列表、字典或文件。该函数生成一个元组，其中包括通过对象迭代获得的值以及循环计数器（从0的起始位置）。当您希望根据索引编写代码时，循环计数器很方便。

    1. sentence = 'Just do It'
    2. length = len(sentence)
    3. for index, element in enumerate(sentence):
    4.     print('{}: {}'.format(index, element))
    5.      if index == 0:
    6.         print('The first element!')
    7.     elif index == length - 1:
    8.         print('The last element!')

    3、通过函数返回多个值

    在设计函数时，我们经常希望返回多个值。这里我们将介绍两种典型的方法：

    方法一

    最简单的方式就是返回一个tuple。

    get_student 函数，它根据员工的ID号以元组形式返回员工的名字和姓氏。

    1. # returning a tuple.
    2. def get_student(id_num):
    3.     if id_num == 0:
    4.         return 'Taha', 'Nate'
    5.     elif id_num == 1:
    6.         return 'Jakub', 'Abdal'
    7.     else:
    8.         raise Exception('No Student with this id: {}'.format(id_num))
    9.  
    1. Student = get_student(0)
    2. print('first_name: {}, last_name: {}'.format(Student[0], Student[1]))

    方法二、

    返回一个字典类型。因为字典是键、值对，我们可以命名返回的值，这比元组更直观。

    1. # returning a dictionary
    2. def get_data(id_num):
    3.     if id_num == 0:
    4.         return {'first_name': 'Muhammad', 'last_name': 'Taha', 'title': 'Data Scientist', 'department': 'A', 'date_joined': '20200807'}
    5.     elif id_num == 1:
    6.         return {'first_name': 'Ryan', 'last_name': 'Gosling', 'title': 'Data Engineer', 'department': 'B', 'date_joined': '20200809'}
    7.     else:
    8.         raise Exception('No employee with this id: {}'.format(id_num))
    1. employee = get_data(0)
    2. print('first_name: {},nlast_name: {},ntitle: {},ndepartment: {},ndate_joined: {}'.format(
    3.     employee['first_name'], employee['last_name'], employee['title'], employee['department'], employee['date_joined']))

    4、像数学一样比较多个数字

    如果你有一个值，并希望将其与其他两个值进行比较，则可以使用以下基本数学表达式：1

    你也许经常使用的是这种

    1

    在python中，你可以这么使用

    1. x = 5
    2. print(130)

    5、将字符串转换为字符串列表：

    当你输入 "[[1, 2, 3],[4, 5, 6]]" 时，你想转换为列表，你可以这么做。

    1. import ast
    2. def string_to_list(string):
    3.     return ast.literal_eval(string)
    4. string = "[[1, 2, 3],[4, 5, 6]]"
    5. my_list = string_to_list(string)
    6. print(my_list)

    6、对于Else方法

    Python 中 esle 特殊的用法。

    1. number_List = [1, 3, 8, 9,1]
    2.  
    3. for number in number_List:
    4.     if number % 2 == 0:
    5.         print(number)
    6.         break
    7.     else:
    8.         print("No even numbers!!")

    7、在列表中查找n个最大或n个最小的元素

    使用 heapq 模块在列表中查找n个最大或n个最小的元素。

    1. import heapq
    2. numbers = [80, 25, 68, 77, 95, 88, 30, 55, 40, 50]
    3. print(heapq.nlargest(5, numbers))
    4. print(heapq.nsmallest(5, numbers))

    8、在不循环的情况下重复整个字符串

    1. value = "Taha"
    2. print(value * 5)  
    3. print("-" * 21)

    9、从列表中查找元素的索引

    1. cities= ['Vienna', 'Amsterdam', 'Paris', 'Berlin']
    2. print(cities.index('Berlin'))

    10、在同一行中打印多个元素？

    1. print("Analytics", end="")
    2. print("Vidhya")
    3. print("Analytics", end=" ")
    4. print("Vidhya")
    5. print('Data', 'science', 'blogathon', '12', sep=', ')

    输出

    1. AnalyticsVidhya
    2. Analytics Vidhya
    3. Data, science, blogathon, 12

    11、把大数字分开以便于阅读

    有时，当你试图打印一个大数字时，传递整数真的很混乱，而且很难阅读。然后可以使用下划线，使其易于阅读。

    1. print(5_000_000_000_000)
    2.  
    3. print(7_543_291_635)

    输出：

    1. 5000000000000
    2. 7543291635

    12、反转列表的切片

    切片列表时，需要传递最小、最大和步长。要以相反的顺序进行切片，只需传递负步长。让我们来看一个例子：

    1. sentence = "Data science blogathon"
    2. print(sentence[21:0:-1])
    3.  
    4.

    输出

    nohtagolb ecneics ata

    13、 “is” 和 “==” 的区别。

    如果要检查两个变量是否指向同一个对象，则需要使用“is”

    但是，如果要检查两个变量是否相同，则需要使用“==”。

    1. list1 = [7, 9, 4]
    2. list2 = [7, 9, 4]
    3. print(list1 == list2) 
    4. print(list1 is list2)
    5. list3 = list1
    6. print(list3 is list1)

    输出

    1. True
    2. False
    3. True

    14、在一行代码中合并两个词典。

    1. first_dct = {"London": 1, "Paris": 2}
    2. second_dct = {"Tokyo": 3, "Seol": 4}
    3. merged = {**first_dct, **second_dct}
    4. print(merged)

    输出

    {‘London’: 1, ‘Paris’: 2, ‘Tokyo’: 3, ‘Seol’: 4}

    15、识别字符串是否以特定字母开头

    1. sentence = "Analytics Vidhya"
    2. print(sentence.startswith("b"))
    3. print(sentence.startswith("A"))

    16、获得字符的Unicode

    1. print(ord("T"))
    2. print(ord("A")) 
    3. print(ord("h")) 
    4. print(ord("a"))

    17、获取字典的键值对

    1. cities = {'London': 1, 'Paris': 2, 'Tokyo': 3, 'Seol': 4}
    2. for key, value in cities.items():
    3.     print(f"Key: {key} and Value: {value}")

    18、在列表的特定位置添加值

    1. cities = ["London", "Vienna", "Rome"]
    2. cities.append("Seoul")
    3. print("After append:", cities)
    4. cities.insert(0, "Berlin")
    5. print("After insert:", cities)

    输出：

    [‘London’, ‘Vienna’, ‘Rome’, ‘Seoul’] After insert: [‘Berlin’, ‘London’, ‘Vienna’, ‘Rome’, ‘Seoul’]

    19、Filter() 函数

    它通过在其中传递的特定函数过滤特定迭代器，并且返回一个迭代器。

    1. mixed_number = [8, 15, 25, 30,34,67,90,5,12]
    2. filtered_value = filter(lambda x: x > 20, mixed_number)
    3. print(f"Before filter: {mixed_number}") 
    4. print(f"After filter: {list(filtered_value)}")

    输出:

    1. Before filter: [8, 15, 25, 30, 34, 67, 90, 5, 12]
    2. After filter: [25, 30, 34, 67, 90]

    20、创建一个没有参数个数限制的函数

    1. def multiplication(*arguments):
    2.     mul = 1
    3.     for i in arguments:
    4.         mul = mul * i
    5.     return mul
    6. print(multiplication(3, 4, 5))
    7. print(multiplication(5, 8, 10, 3))
    8. print(multiplication(8, 6, 15, 20, 5))

    输出：

    1. 60
    2. 1200
    3. 72000

    21、一次迭代两个或多个列表

    1. capital = ['Vienna', 'Paris', 'Seoul',"Rome"]
    2. countries = ['Austria', 'France', 'South Korea',"Italy"]
    3. for cap, country in zip(capital, countries):
    4.     print(f"{cap} is the capital of {country}")

    22、检查对象使用的内存大小

    1. import sys
    2. mul = 5*6
    3. print(sys.getsizeof(mul))

    23、 Map() 函数

    map() 函数用于将特定函数应用于给定迭代器。

    1. values_list = [8, 10, 6, 50]
    2. quotient = map(lambda x: x/2, values_list)
    3. print(f"Before division: {values_list}")
    4. print(f"After division: {list(quotient)}")

    24、计算 item 在列表中出现的次数

    可以在 list 上调用 count 函数。

    1. cities= ["Amsterdam", "Berlin", "New York", "Seoul", "Tokyo", "Paris", "Paris","Vienna","Paris"]
    2. print("Paris appears", cities.count("Paris"), "times in the list")

    25、在元组或列表中查找元素的索引

    1. cities_tuple = ("Berlin", "Paris", 5, "Vienna", 10)
    2. print(cities_tuple.index("Paris")) 
    3. cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]
    4. print(cities_list.index("Amsterdam"))

    26、2个 set 进行 join 操作

    1. set1 = {'Vienna', 'Paris', 'Seoul'}
    2. set2 = {"Tokyo", "Rome",'Amsterdam'}
    3. print(set1.union(set2))

    27、根据频率对列表的值进行排序

    1. from collections import Counter
    2. count = Counter([7, 6, 5, 6, 8, 6, 6, 6])
    3. print(count)
    4. print("Sort values according their frequency:", count.most_common())

    输出：

    1. Counter({6: 5, 7: 1, 5: 1, 8: 1})
    2. Sort values according their frequency: [(6, 5), (7, 1), (5, 1), (8, 1)]

    28、从列表中删除重复值

    1. cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam","Paris","Amsterdam","Paris"]
    2. cities_list = set(cities_list)
    3. print("After removing the duplicate values from the list:",list(cities_list))

    29、找出两个列表之间的差异

    1. cities_list1 = ['Vienna', 'Paris', 'Seoul',"Amsterdam", "Berlin", "London"]
    2. cities_list2 = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]
    3. cities_set1 = set(cities_list1)
    4. cities_set2 = set(cities_list2)
    5. difference = list(cities_set1.symmetric_difference(cities_set2))
    6. print(difference)

    30、将两个不同的列表转换为一个字典

    1. number = [1, 2, 3]
    2. cities = ['Vienna', 'Paris', 'Seoul']
    3. result = dict(zip(number, cities))
    4. print(result)
  • 相关阅读:
    （二十九）加油站：面向对象重难点深入讲解【重点是元类】
    html实现点击按钮时下方展开一句话
    WPF 入门教程数据绑定（一)
    算法——字符串（1）
    使用Xposed对软件进行破解
    鸿鹄工程项目管理系统 Spring Cloud+Spring Boot+Mybatis+Vue+ElementUI+前后端分离构建工程项目管理系统
    LTE ATTACH流程、PDN流程、PGW地址分配介绍
    初赛错题集
    KMP算法
    Vulnhub系列靶机-Hackadmeic.RTB1
  • 原文地址：https://blog.csdn.net/m0_60001307/article/details/125976021