python的常见函数方法的基本功能

输入输出常用的

input()、print()

input():接收用户输入。
print():输出内容。

#键入一个变量X
x = input()

#基本输出
print("Hello, World!")

#输出多个值
print("Hello", "World", "!")

#输出时不换行
print("Hello,", end=" ")
print("World!")

#输出变量
s = 'name'
print("Hello,"+s)

range()

range():用于生成一个整数序列。

#一个参数
for i in range(4):
	print(i)	#输出 0,1,2,3 
	
#两个参数
for i in range(4, 10):
	print(i)	#输出 4,5,6,7,8,9

#三个参数
for i in range(0,10,2):
	print(i)	#输出 0,2,4,6,8

#反向序列
for i in range(5, 0, -1):
    print(i)  # 输出: 5,4,3,2,1

split()

split():分隔字符串

#默认分隔符
s1 = input().split()
print(s1)

#指定分隔符
s2 = input().split(',')
print(s2)

#分隔次数的限制
s3 = input().split(',',2)
print(s3)

join()

join():将序列中的元素连接成一个字符串。（列表、元组、字典都可以作为参数）

#连接字符串列表
words = ['Hello', 'World']
sentence = ' '.join(words)
print(sentence)  # 输出: "Hello World"

#自定义分隔符
words = ['one', 'two', 'three']
result = '-'.join(words)
print(result)  # 输出: "one-two-three"

请注意，join() 方法只能接受可迭代对象，如果传入的是非可迭代对象，将会引发 TypeError。此外，可迭代对象中的元素最终都会被转换为字符串（如果它们不是字符串的话），然后才能被连接。

map()

map():用于简化对序列的遍历和元素的同步处理。

#一行输入多个整型参数,并且用','隔开。
x,y,z = map(int,input().split(','))

#用于将序列中的元素转换为不同的类型。
strings = ['1', '2', '3']
numbers = map(int, strings)
print(list(numbers))  # 输出: [1, 2, 3]

#对列表中的每个元素应用函数。
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16]

#map() 可以与内建函数一起使用。
words = ["hello", "world", "python"]
upper_words = map(str.upper, words)
print(list(upper_words))  # 输出: ['HELLO', 'WORLD', 'PYTHON']

#对列表（或任何可迭代对象）中的每个元素应用一个函数，执行批量转换。
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(numbers)  # 输出：[1, 4, 9, 16]

filter()

filter():filter 函数用于过滤序列，从中选择符合条件的元素。filter 函数接受两个参数：一个函数和一个序列。传入的函数用于判断序列中的每个元素是否符合条件，返回 True 或 False。

# 定义一个简单的过滤函数
def is_positive(x):
    return x < 0

# 使用 filter 函数过滤列表中的正数
numbers = [-10, -3, -1, 0, 1, 7]
positive_numbers = filter(is_positive, numbers)

# 打印过滤后的元素
for num in positive_numbers:
    print(num)   #输出: -10, -3, -1

注意，由于 filter 返回的是一个迭代器，如果你想要得到一个列表，可以使用 list() 函数将其转换

positive_numbers_list = list(filter(lambda x: x < 0, numbers))
print(positive_numbers_list)

str数据常用的

upper()、lower()、capitalize()、title()、swapcase() 、istitle()、

这些函数都是Python中字符串（str）的一类方法，它的作用是将字符串中的字母进行操作。这个方法不会改变原始字符串，而是返回一个新的字符串，其中包含转换后的字母。

#upper():将字符串中的所有小写字母转换为大写。
s = "Hello World"
upper_s = s.upper()
print(upper_s)  # 输出: "HELLO WORLD"

#lower():将字符串中的所有大写字母转换为小写字母。
s = "HELLO WORLD"
print(s.lower())  # 输出: "hello world"

#capitalize():将字符串的第一个字母转换为大写，其余字母转换为小写。
s = "hello world"
print(s.capitalize())  # 输出: "Hello world"

#title():将字符串中每个单词的首字母转换为大写，其余字母转换为小写。这个方法通常用于标题或标题的格式化。
s = "hello world, this is a test"
print(s.title())  # 输出: "Hello World, This Is A Test"

#swapcase():将字符串中的大写字母转换为小写，小写字母转换为大写。
s = "Hello World"
print(s.swapcase())  # 输出: "hELLO wORLD"

#istitle():检查字符串是否是标题格式（即每个单词的首字母大写，其余字母小写）。这个方法不会改变字符串，只是返回一个布尔值。
s = "Hello World"
print(s.istitle())  # 输出: True

replace()

replace():用于将字符串中的某些子字符串替换为另一个子字符串，并生成新的字符串，原始字符串不会被修改。

#替换字符串中的特定子字符串。
s = "Hello World"
new_s = s.replace("World", "Python")
print(new_s)  # 输出: "Hello Python"

#替换所有匹配的子字符串。
s = "aabbcc"
new_s = s.replace("a", "d")
print(new_s)  # 输出: "ddbbc"

#可以指定一个可选的 count 参数来限制替换的次数。
s = "aabbcc"
new_s = s.replace("a", "d", 1)  # 只替换第一个出现的 "a"
print(new_s)  # 输出: "dabbc"

#可以替换字符串中的多个字符或子字符串。
s = "Hello World"
new_s = s.replace("H", "J").replace("W", "T")
print(new_s)  # 输出: "Jello Torld"

eval()

eval():计算传入的字符串表达式的值

#计算字符串形式的数学表达式。
expression = "1 + 2 * 3"
result = eval(expression)
print(result)  # 输出: 7

如果需要计算字符串形式的表达式，并且输入来源是可信的，eval() 是一个非常方便的工具。但在处理不可信的输入时，应该使用更安全的方法，比如限制输入的格式或使用正则表达式验证输入。

isalpha()、isdigit()

isalpha():判断字符串中的所有字符是否都是字母，字符串至少有一个字符，并且所有字符都是字母，则返回True，否则返回False。

#检查字符串是否只包含字母。
s = "HelloWorld"
print(s.isalpha())  # 输出: True
t = "Hello World"
print(t.isalpha())  # 输出: False，因为包含空格

isdigit():判断字符串中的所有字符是否都是数字，字符串至少有一个数字，并且所有字符都是数字，则返回True，否则返回False。

#检查字符串是否只包含数字。
s = "123456"
print(s.isdigit())  # 输出: True
t = "12345a"
print(t.isdigit())  # 输出: False，因为包含字母'a'

encode()

encode():用于将字符串编码为指定格式的字节序列。

#默认编码为 UTF-8
text = "Hello, 世界!"
encoded_text = text.encode()  # 默认使用 UTF-8 编码
print(encoded_text)  # 输出: b'Hello, \xe4\xb8\x96\xe7\x95\x8c!'

#指定编码
encoded_text = text.encode('utf-16')  # 指定使用 UTF-16 编码
print(encoded_text)  # 输出: b'\xff\xfeH\x00e\x00l\x00l\x00o\x00,\x00 \x00\xe4\xb8\x96\x00\xe7\x95\x8c\x00!\x00'

int数据常用

abs()

abs():取数的绝对值

#计算一个数的绝对值。
print(abs(-10))  # 输出: 10
print(abs(10))   # 输出: 10
print(abs(0))    # 输出: 0

#abs()函数可以接受一个可迭代对象（如元组、列表等），返回其中的最大绝对值。
print(abs([-1, -2, -3]))  # 输出: 3

bin()、oct()、hex()

bin():十进制转二进制，返回前缀 ‘0b’。
oct():十进制转八进制，返回前缀 ‘0o’。
hex():十进制转十六进制，返回前缀 ‘0x’。

number = 15

#转换为二进制
print(bin(number)) # 0b1111

#转换为八进制
print(oct(number)) # 0o17

#转换为十六进制
print(hex(number)) # 0xf

#去除前缀
print(bin(number)[2:])  # 1111
print(oct(number)[2:])  # 17
print(hex(number)[2:])  # f

排序常用的

sort()、sorted()

sort():直接对原列表进行排序。
sorted():返回一个排序后的新列表。

#sort()
#对列表升序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

#使用 reverse=True 参数进行降序排序，True:降序， False:升序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

#sorted()
#对列表升序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

#使用 reverse=True 参数进行降序排序，True:降序， False:升序
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

#根据自定义函数的返回值进行排序。
numbers = [5, 2, 9, 1, 5]
# 按元素的个位数排序
sorted_numbers = sorted(numbers, key=lambda x: x % 10)
print(sorted_numbers)  # 输出: [1, 2, 5, 5, 9]

reversed()

reversed(): 用于反转序列的元素顺序.
这个函数可以作用于任何序列类型，包括列表（list）、元组（tuple）、字符串（string）以及集合（set）。reversed() 返回的是一个迭代器，而不是原地修改原始序列。

#反转列表
my_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(my_list))
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

#反转元组
my_tuple = (1, 2, 3, 4, 5)
reversed_tuple = tuple(reversed(my_tuple))
print(reversed_tuple)  # 输出: (5, 4, 3, 2, 1)

#反转字符串
my_string = "hello"
reversed_string = ''.join(reversed(my_string))
print(reversed_string)  # 输出: "olleh"

#反转集合 （注意：集合是无序性的）
my_set = {1, 2, 3, 4, 5}
reversed_set = set(reversed(my_set))
print(reversed_set)  # 输出可能是: {1, 2, 3, 4, 5}，但顺序不保证

#直接迭代反转
#如果你不需要将反转的结果存储为一个新的序列，可以直接迭代 reversed() 函数的返回值。
for item in reversed(my_list):
    print(item, end=' ')  # 直接打印反转后的元素

保留小数常用的

format()

format():它允许你将变量插入到字符串中，并且可以控制它们的格式，包括小数点后的位数。

# 保留两位小数
number = 3.1415926
print("{:.2f}".format(number))  # 输出: 3.14

# 格式化为货币
print("{:,.2f}".format(1234567.891))  # 输出: 1,234,567.89

另一种和format()函数功能类似的是：格式化字符串字面量（f-string）来保留小数点后指定位数。

# 使用 f-string
num = 3.1415926
print(f"{num:.2f}")  # 同样输出: '3.14'

round()

round():可以将数字四舍五入到指定的小数位数。

num = 3.1415926
# 四舍五入到两位小数
rounded_num = round(num, 2)
print(rounded_num)  # 输出: 3.14

math.floor()、math.ceil()

math.floor():需要向下取整到特定小数位数的情况
math.ceil():需要向上取整到特定小数位数的情况
使用这两个个函数需要引入math模块，即：import math

import math

num = 3.1415926
# 向下取整到小数点后两位
floored_num = math.floor(num * 100) / 100
print(floored_num)  # 输出: 3.14

# 向上取整到小数点后两位
ceiling_num = math.ceil(num * 100) / 100
print(ceiling_num)  # 输出: 3.15

random模块常用函数

使用该模块函数，需要程序头部引用import random

random.random()、random.uniform()、random.randint()、random.choice()

random.random()：返回一个在 [0.0, 1.0) 范围内的随机浮点数。

rand_float = random.random()
print(rand_float)

random.uniform(a, b)：返回一个在 [a, b] 或 [b, a] 范围内的随机浮点数。

rand_float = random.uniform(1.5, 4.5)
print(rand_float)

random.randint(a, b)：返回一个在 [a, b] 范围内的随机整数。

rand_int = random.randint(1, 10)
print(rand_int)

random.choice(sequence)：从非空序列中返回一个随机选择的元素。

item = random.choice(['apple', 'banana', 'cherry'])
print(item)

本文章中的函数仅适合入门新手，分类并不全面，部分函数的参数也不仅限一种数据类型，建议读者根据实际问题分析选择合适的函数，多去尝试。如需了解更多函数，及更多深入的用法，请查阅python官方文档

如文章内容有问题或建议请私信我，持续更新中…