分享:Python好用的函数和实例-1.0

admin
admin
admin
140350
文章
117
评论
2024年12月19日23:18:54评论8 views字数 9059阅读30分11秒阅读模式

Python常用函数总结

  1.     print()函数：打印字符串

  2.     raw_input()函数：从用户键盘捕获字符

  3.     len()函数：计算字符长度

  4.     format(12.3654，‘6.2f’/‘0.3%’)函数：实现格式化输出

  5.     type()函数：查询对象的类型

  6.     int()函数、float()函数、str()函数等：类型的转化函数

  7.     id()函数：获取对象的内存地址

  8.     help()函数：Python的帮助函数

  9.     s.islower()函数：判断字符小写

  10.     s.sppace()函数：判断是否为空格

  11.     str.replace()函数：替换字符

  12.     import()函数：引进库

  13.     math.sin()函数：sin()函数

  14.     math.pow()函数：计算次方函数

  15.     3**4: 3的4次方

  16.     pow(3,4)函数：3的4次方

  17.     os.getcwd()函数：获取当前工作目录

  18.     listdir()函数：显示当前目录下的文件

  19.     socket.gethostbyname()函数：获得某主机的IP地址

  20.     urllib.urlopen(url).read():打开网络内容并存储

  21.     open().write()函数：写入文件

  22.     webbrowser.open_new_tab()函数：新建标签并使用浏览器打开指定的网页

  23.     def function_name(parameters):自定义函数

  24.     time.sleep()函数：停止一段时间

  25.     random.randint()函数：产生随机数

  26.     range()函数：返回一个列表，打印从1到100

  27.     file.read()函数：读取文件返回字符串

  28.     file.readlines()函数：读取文件返回列表

  29.     file.readline()函数：读取一行文件并返回字符串

  30.     ords()和chr(ASCII)函数：将字符串转化为ASCII或将ASCIIIS转化为字符串

  31.     find(s[,start,end])函数：从字符串中查找s

  32.     strip()、lstrip()、rstrip()函数：去除空格

  33.     split()函数：用什么来间隔字符串

  34.     isalnum()函数：判断是否为有效数字或字符

  35.     isalpha()函数：判断是否区全为字符

  36.     isdigit()函数：判断是否全为数字

  37.     lower()函数：将数据改成小写

  38.     upper()函数：将数据改成大写

  39.     startswith(s)函数：判断字符串是否以s开始的

  40.     endwith(s)函数：判断字符串是否以s结尾的

  41.     file.write()函数：写入函数

  42.     file.writeline()函数：写入文件

  43.     s.append()函数：在数据的尾部插入数据

  44.     s.insert(3,-1)函数：在3的位置之前插入数据-1

  45.     list()函数：将字符串转换成列表

  46.     index(value)函数：在数据中查找第一次value的位置

  47.     list.extend()函数：将数据的每一个提取出来加入list中

  48.     count()函数：统计数据中的某个元素的出现次数

  49.     list.remove(“s”)函数：将数据中第一次出现的s删掉

  50.     del list[2]函数：将数据的第2个元素删掉

  51.     pop()函数：去掉数据的指定位置的数据，有返回值

  52.     remove(“ha”)函数：去掉原数据中的“ha”元素

  53.     reverse()函数：列表的逆序

  54.     isinstance()函数：判断某个数据是否为某种类型

  55.     abs()函数：得到某数的绝对值

  56.     del x[2]函数：删除列表x中的索引为2的元素

  57.     file.sort()函数：对书数据排序

  58.     tuple()函数：创建一个元组

  59.     find()函数：查找 返回的是索引

  60.     join()函数：split的逆操作

  61.     { }：建立字典

  62.     . dict()函数：创建字典

  63.     clear()函数：清楚字典中的所有项

  64.     copy()函数：复制一个字典，会修改所有的字典

  65.     d.copy()函数：复制一个字典，只会修改当前字典

  66.     get()函数：查询字典中的元素

  67.     items()函数：将所有的字典返回一个列表

  68.     iteritems()函数：与items函数作用相同

  69.     popitem()函数：移除字典中的元素

  70.     update()函数：用一个字典项更新另一个字典项

  71.     pass：什么都不做

  72.     .exec：执行一段代码

  73.     eval：计算Python的表达式

  74.     ord()函数：返回单字符字符串的int值

  75.     zip(sep1，sep2)函数：创造英语并行迭代的新序列

  76.     def hello()：自定义函数

  77.     import()函数：加载扩展库

实例函数代码：
1.链式比较
x = 2y = 3z = 4if x < y < z:print("x is less than y and y is less than z")
2.链式赋值
total_regions = region_total_instances = total_instances = 0
3.三元运算符
x =11result= "Greater than 10" if x >10else "Less than or equal to 10"

4.使用args和kwargs传递多个位置参数或关键字参数给函数

defexample_function(*args, **kwargs):for arg in args:# 执行相关操作    for key, value in kwargs.items():        # 执行相关操作

5.使用enumerate函数同时获取索引和值

my_list = ['watermelon', 'apple', 'pear']for index, value inenumerate(my_list):print(f"Index: {index}, Value: {value}")

6.使用zip函数同时迭代多个可迭代对象

list1 = [1, 2, 3]list2 = ['a', 'b', 'c']for item1, item2 inzip(list1, list2):print(f"Item from list1: {item1}, Item from list2: {item2}")

7.使用itertools模块进行迭代器和循环的高级操作

import itertoolsfor item in itertools.chain([1, 2, 3], ['a', 'b', 'c']):print(item)

8.使用collections.Counter进行计数

from collections import Countermy_list = ['watermelon', 'apple', 'pear', 'orange', 'banana', 'apple']counter = Counter(my_list)print(counter)  # 输出为Counter({'apple': 2, 'banana': 1, 'orange': 1,'watermelon':1,'pear':1 })

9.使用any和all函数对可迭代对象中的元素进行逻辑判断

my_list = [True, False, True, True]print(any(my_list))  # 输出为Trueprint(all(my_list))  # 输出为False

10.使用sorted函数对可迭代对象进行排序

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]sorted_list = sorted(my_list)print(sorted_list)  # 输出为[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

11.使用set进行集合操作

set1 = {1, 2, 3, 4, 5}set2 = {3, 4, 5, 6, 7}print(set1.union(set2))  # 输出为{1, 2, 3, 4, 5, 6, 7}print(set1.intersection(set2))  # 输出为{3, 4, 5}

12.上下文管理器

classCustomContextManager:def__enter__(self):# 在代码块执行之前执行的操作        # 可以返回一个值，该值将被赋值给as子句中的变量    def __exit__(self, exc_type, exc_val, exc_tb):        # 在代码块执行之后执行的操作        # 可以处理异常，返回True表示异常被处理，False则会重新抛出异常# 使用自定义上下文管理器with CustomContextManager() as obj:    # 在这里执行一些操作

13.生成器表达式

# 使用生成器表达式计算1到10的平方和squared_sum =sum(x**2for x inrange(1, 11))print(squared_sum)

14.使用str.endswith()方法来检查字符串是否以元组中的任何一个字符串结尾

filename = "example.csv"if filename.endswith((".csv", ".xls", ".xlsx")):# 执行相关操作

同样的用法还有str.startswith()来检查字符串是否以元组中的任何一个字符串开头

15.else语句与for和while循环结合使用

for item in some_list:if condition:        # 执行相关操作breakelse:    # 如果循环自然结束，执行相关操作

16.静态类型检查

# 使用mypy进行静态类型检查def add_numbers(a: int, b: int) ->int:return a + bresult= add_numbers(5, 10)print(result)

17.反射，反射是一种机制，可以在运行时获取、检查和修改对象的属性和方法。Python提供了一些内置的函数和属性，可以用于实现反射操作

    dir()函数：返回对象的所有属性和方法的列表

classMyClass:def__init__(self):        self.name = "陆家嘴"        self.age = 28my_obj = MyClass()print(dir(my_obj))

    getattr()函数：获取对象的属性或方法

classMyClass:def__init__(self):        self.name = "陆家嘴"        self.age = 28my_obj = MyClass()name = getattr(my_obj, "name")print(name)

    setattr()函数：设置对象的属性或方法

classMyClass:def__init__(self):        self.name = "陆家嘴"        self.age = 28my_obj = MyClass()setattr(my_obj, "name", "沿江路1街20号")print(my_obj.name)

    hasattr()函数：检查对象是否具有指定的属性或方法

classMyClass:def__init__(self):        self.name = "陆家嘴"        self.age = 28my_obj = MyClass()has_name = hasattr(my_obj, "name")print(has_name)

    这些函数和属性可以帮助你在运行时动态地访问和修改对象的属性和方法。反射为编写更灵活和通用的代码提供了一种机制，可以根据需要操作对象的属性和方法

18.交换变量，这是一种非常常见和方便的操作，可以在需要时快速交换变量的值

a = 10b = 20a, b = b, aprint(a, b)  # 输出: 20 10

19.可迭代对象解包，它允许你将可迭代对象的元素解包到单独的变量中。这对于同时处理多个值非常有用

# 解包元组a, b, c = (1, 2, 3)print(a, b, c)   # 输出: 123# 解包列表x, y, z = [4, 5, 6]print(x, y, z)   # 输出: 456

20.深复制和浅复制，当处理复杂的数据结构时，深复制和浅复制允许你创建对象的副本。深复制会创建一个全新的对象，而浅复制会创建一个新对象，但共享内部数据。

importcopy# 创建一个列表original_list = [1, 2, [3, 4]]# 浅复制shallow_copy = copy.copy(original_list)# 深复制deep_copy = copy.deepcopy(original_list)# 修改原始列表中的嵌套列表original_list[2][0] = 5print(original_list)   # 输出: [1, 2, [5, 4]]print(shallow_copy)    # 输出: [1, 2, [5, 4]]print(deep_copy)       # 输出: [1, 2, [3, 4]]

21.with语句的多个上下文管理器：在一个with语句中，你可以同时使用多个上下文管理器，以便在代码块执行前后执行多个操作

classCustomContextManager1:def__enter__(self):        print("Entering CustomContextManager1")def__exit__(self, exc_type, exc_val, exc_tb):        print("Exiting CustomContextManager1")classCustomContextManager2:def__enter__(self):        print("Entering CustomContextManager2")def__exit__(self, exc_type, exc_val, exc_tb):        print("Exiting CustomContextManager2")# 使用多个上下文管理器with CustomContextManager1(), CustomContextManager2():    # 在这里执行一些操作

    比较常用的是一次打开多个文件进行操作，例如同时打开文件1和文件2，读取文件1内容处理后写入文件2

withopen("file1.txt") as file1, open("file2.txt") as file2:# 在这里可以使用file1和file2进行操作

22.装饰器，通过装饰器来复用函数，简化操作

# 创建一个装饰器函数，用于计算函数执行时间import timedef calculate_time(func):    def wrapper(*args, **kwargs):        start_time = time.time()        result = func(*args, **kwargs)        end_time = time.time()print(f"函数 {func.__name__} 执行时间为: {end_time - start_time} 秒")        return result    return wrapper# 应用装饰器到函数@calculate_timedef long_running_function():    time.sleep(2)long_running_function()

23.使用字典来代替冗长的if/else判断，提升代码可读性

def operation_add(a, b):return a + bdef operation_subtract(a, b):return a - bdef operation_multiply(a, b):return a * bdef operation_divide(a, b):return a / b# 定义一个操作字典，将操作名映射到对应的函数上operations = {"add": operation_add,"subtract": operation_subtract,"multiply": operation_multiply,"divide": operation_divide}# 使用字典进行操作选择和调用相应的函数result = operations["multiply"](2, 3)print("结果:", result)

24.字符串格式化，使用占位符和格式化字符串来构建新的字符串

name = "Alice"age = 25message = "My name is {} and I am {} years old.".format(name, age)# 输出: "My name is Alice and I am 25 years old."

25.使用lamba函数进行简单的函数定义

add = lambda x, y: x + yresult = add(2, 3)# 输出: 5

26.使用reversed函数反转可迭代对象

numbers = [1, 2, 3, 4, 5]reversed_numbers = list(reversed(numbers))# 输出: [5, 4, 3, 2, 1]

27.使用map函数对可迭代对象中的每个元素应用指定的函数

numbers = [1, 2, 3, 4, 5]squared_numbers = list(map(lambda x: x**2, numbers))# 输出: [1, 4, 9, 16, 25]

28.使用filter函数根据指定的条件筛选可迭代对象中的元素

numbers = [1, 2, 3, 4, 5]even_numbers = list(filter(lambda x: x % 2 == 0, numbers))# 输出: [2, 4]

29.生成器函数，使用yield关键字来生成一个值，并且在每次生成值后暂停执行，等待下一次调用

# 下面是一个简单的生成器函数示例，用于生成斐波那契数列def fibonacci():    a, b = 0, 1    while True:        yield a        a, b = b, a + bfib = fibonacci()print(next(fib))  # 输出：0print(next(fib))  # 输出：1print(next(fib))  # 输出：1# 生成器函数可以一次生成一个值，而不是一次生成所有值，这使得生成器函数非常适合处理大量数据或无限序列

30.使用functools模块中的partial函数进行函数参数固定：partial函数可以固定函数的部分参数，生成一个新的函数

from functools import partialdef power(x, y):return x ** ysquare = partial(power, y=2)cube = partial(power, y=3)print(square(5))  # 输出 25print(cube(5))  # 输出 125

31.使用try...else语句在try块没有引发异常时执行特定的代码

try:    # 可能会引发异常的代码    result =10/2except ZeroDivisionError:    # 如果发生ZeroDivisionError异常print("除数不能为零！")else:    # 如果没有发生异常print("结果为:", result)类似的还有try...finally无论是否发生异常，都会执行try:    # 可能会引发异常的代码    f =open('example.txt', 'r')    # 其他操作except IOError:    # 如果发生IOError异常print("无法打开文件")else:    # 如果没有发生异常print(f.read())finally:    # 无论是否发生异常，都会执行的清理代码    f.close()

32.通过signal解耦代码

import signalimport os# 定义一个事件处理函数def handle_event(signum, frame):    if signum == signal.SIGUSR1:print("接收到用户定义信号1，执行事件A")        # 执行事件A的逻辑    elif signum == signal.SIGUSR2:print("接收到用户定义信号2，执行事件B")        # 执行事件B的逻辑    else:print(f"接收到未知信号: {signum}")# 注册事件处理函数signal.signal(signal.SIGUSR1, handle_event)  # 注册处理用户定义信号1的事件处理函数signal.signal(signal.SIGUSR2, handle_event)  # 注册处理用户定义信号2的事件处理函数# 模拟发送事件信号def send_event1():    # 发送用户定义信号1print("发送用户定义信号1")    os.kill(os.getpid(), signal.SIGUSR1)def send_event2():    # 发送用户定义信号2print("发送用户定义信号2")    os.kill(os.getpid(), signal.SIGUSR2)# 执行事件send_event1()  # 执行事件1send_event2()  # 执行事件2

33. 删除list中的重复元素

lst = [1, 2, 3, 4, 3, 4, 4, 5, 6, 3, 1, 6, 7, 9, 4, 0]print(lst)unique_lst = list(set(lst))print(unique_lst)#输出效果：1234567890

34.压缩函数，zip()函数聚合来自每个可迭代对象的元素并返回一个元组迭代器。当你想同时遍历两个或多个列表时，此函数很有用

list1 = [1, 2, 3] list2 = ['a', 'b', 'c'] for x, y inzip(list1, list2):print(x, y)#输出效果:    # 1 a# 2 b# 3 c

35.列表切片,使用[start:end]或者[startstep]来实现对列表的切片操作，样例代码如下：

numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90]print(numbers[1:5])#输出效果:[20, 30, 40, 50]

*后续持续更新*

原文始发于微信公众号（像梦又似花）：分享:Python好用的函数和实例-1.0

免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉。
  • 左青龙
  • 微信扫一扫
  • weinxin
  • 右白虎
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2024年12月19日23:18:54
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出)：
                   分享:Python好用的函数和实例-1.0https://cn-sec.com/archives/3527326.html
                  免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉.

发表评论

匿名网友 填写信息