MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python基本类型函数的详细分类

2022-06-044.6k 阅读

Python基本类型函数的详细分类

数字类型相关函数

在Python中，数字类型主要包括整数（int）、浮点数（float）和复数（complex）。围绕这些数字类型，有一系列实用的函数。

整数相关函数

  1. int()函数：用于将一个数字或字符串转换为整数。
    • 将浮点数转换为整数：
num_float = 5.6
num_int = int(num_float)
print(num_int)

在上述代码中，int()函数直接截断了浮点数的小数部分，返回整数5。 - 将字符串转换为整数：字符串必须是合法的数字表示形式，否则会报错。

str_num = '10'
num = int(str_num)
print(num)

这里将字符串'10'成功转换为整数10。如果字符串包含非数字字符，如'10a'，则会抛出ValueError。 2. abs()函数：返回一个数的绝对值。对于整数，它返回整数的正值。

num = -10
abs_num = abs(num)
print(abs_num)

上述代码中，abs()函数将-10转换为10并返回。 3. divmod()函数：接受两个数字参数，返回一个包含商和余数的元组。常用于整数除法场景。

dividend = 10
divisor = 3
result = divmod(dividend, divisor)
print(result)

结果为(3, 1)，其中3是商，1是余数。

浮点数相关函数

  1. float()函数：用于将整数或字符串转换为浮点数。
    • 将整数转换为浮点数：
num_int = 5
num_float = float(num_int)
print(num_float)

这里将整数5转换为浮点数5.0。 - 将字符串转换为浮点数：字符串必须是合法的数字表示，可以包含小数点。

str_num = '5.6'
num_float = float(str_num)
print(num_float)

此代码将字符串'5.6'转换为浮点数5.6。如果字符串格式不正确，如'5a'，会抛出ValueError。 2. round()函数：对浮点数进行四舍五入。

num = 5.678
rounded_num = round(num, 2)
print(rounded_num)

上述代码将5.678四舍五入到小数点后两位，结果为5.68。round()函数的第二个参数指定保留的小数位数，如果不指定，默认将浮点数四舍五入到最接近的整数。 3. math模块中的浮点数函数：Python的math模块提供了丰富的浮点数数学运算函数。例如math.sqrt()用于计算平方根。

import math
num = 25
sqrt_num = math.sqrt(num)
print(sqrt_num)

这里math.sqrt(25)返回5.0，即25的平方根。还有math.pow()用于幂运算，math.pi表示圆周率等众多实用的常量和函数。

复数相关函数

  1. complex()函数：用于创建复数。可以通过给定实部和虚部来创建。
real_part = 3
imag_part = 4
comp_num = complex(real_part, imag_part)
print(comp_num)

上述代码创建了复数3 + 4j。也可以直接将字符串形式的复数传递给complex()函数。

str_comp = '5+6j'
comp_num = complex(str_comp)
print(comp_num)

这里将字符串'5 + 6j'转换为复数5 + 6j。 2. 复数属性和方法：复数对象有real属性用于获取实部，imag属性用于获取虚部。

comp_num = complex(3, 4)
real = comp_num.real
imag = comp_num.imag
print(real)  
print(imag)

分别输出3和4。还有abs()函数对于复数，计算的是复数的模。

comp_num = complex(3, 4)
modulus = abs(comp_num)
print(modulus)

这里计算出复数3 + 4j的模为5.0。

序列类型相关函数

序列类型在Python中非常重要，常见的序列类型有列表（list）、元组（tuple）和字符串（str）。

通用序列函数

  1. len()函数：返回序列的长度，即元素的个数。对于列表、元组和字符串都适用。
my_list = [1, 2, 3, 4]
list_length = len(my_list)
print(list_length)  

my_tuple = (1, 2, 3)
tuple_length = len(my_tuple)
print(tuple_length)  

my_str = 'hello'
str_length = len(my_str)
print(str_length)

分别输出4、3和5，即列表、元组和字符串中元素或字符的数量。 2. max()和min()函数：返回序列中的最大或最小元素。序列中的元素必须是可比较的。

my_list = [1, 5, 3]
max_num = max(my_list)
min_num = min(my_list)
print(max_num)  
print(min_num)

这里max()函数返回5，min()函数返回1。对于字符串，比较是基于字符的Unicode码点。

my_str_list = ['apple', 'banana', 'cherry']
max_str = max(my_str_list)
min_str = min(my_str_list)
print(max_str)  
print(min_str)

在字符串列表中，按照字典序比较，max()返回'cherry'，min()返回'apple'。 3. sum()函数：对数值型序列（如列表、元组）中的元素进行求和。

num_list = [1, 2, 3, 4]
total = sum(num_list)
print(total)

上述代码计算列表中元素的总和，结果为10。

列表相关函数

  1. list()函数：用于将其他可迭代对象转换为列表。
    • 将元组转换为列表：
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)

这里将元组(1, 2, 3)转换为列表[1, 2, 3]。 - 将字符串转换为列表：字符串会被拆分为单个字符的列表。

my_str = 'hello'
my_list = list(my_str)
print(my_list)

结果为['h', 'e', 'l', 'l', 'o']。 2. 列表的方法： - append()方法：在列表末尾添加一个元素。

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

列表变为[1, 2, 3, 4]。 - extend()方法：用于将另一个可迭代对象的所有元素添加到列表末尾。

my_list = [1, 2, 3]
new_list = [4, 5]
my_list.extend(new_list)
print(my_list)

列表变为[1, 2, 3, 4, 5]。 - pop()方法：移除并返回列表指定位置的元素，默认移除最后一个元素。

my_list = [1, 2, 3]
popped_item = my_list.pop()
print(popped_item)  
print(my_list)

输出3和[1, 2]，即移除并返回了最后一个元素3。 - remove()方法：移除列表中第一个匹配的元素。

my_list = [1, 2, 2, 3]
my_list.remove(2)
print(my_list)

列表变为[1, 2, 3]，移除了第一个出现的2。

元组相关函数

  1. tuple()函数：将其他可迭代对象转换为元组。
    • 将列表转换为元组：
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)

这里将列表[1, 2, 3]转换为元组(1, 2, 3)。 - 将字符串转换为元组：字符串会被拆分为单个字符的元组。

my_str = 'hello'
my_tuple = tuple(my_str)
print(my_tuple)

结果为('h', 'e', 'l', 'l', 'o')。 2. 元组的不可变性：元组一旦创建，其元素不能被修改，这使得元组在一些需要数据不可变的场景（如作为字典的键）中非常有用。虽然元组没有像列表那样丰富的修改方法，但可以通过连接和重复操作创建新的元组。

tuple1 = (1, 2)
tuple2 = (3, 4)
new_tuple = tuple1 + tuple2
print(new_tuple)  

repeat_tuple = tuple1 * 3
print(repeat_tuple)

new_tuple为(1, 2, 3, 4)，repeat_tuple为(1, 2, 1, 2, 1, 2)。

字符串相关函数

  1. str()函数：将其他类型转换为字符串。
    • 将整数转换为字符串：
num = 10
str_num = str(num)
print(str_num)

这里将整数10转换为字符串'10'。 - 将列表转换为字符串：列表元素会被转换为字符串并连接起来，默认以逗号分隔。

my_list = [1, 2, 3]
str_list = str(my_list)
print(str_list)

结果为'[1, 2, 3]'。 2. 字符串的方法： - split()方法：根据指定的分隔符将字符串拆分为子字符串列表。

my_str = 'apple,banana,cherry'
sub_str_list = my_str.split(',')
print(sub_str_list)

结果为['apple', 'banana', 'cherry']。如果不指定分隔符，默认以空白字符（空格、制表符、换行符等）分隔。 - join()方法：与split()方法相反，它使用指定的字符串连接列表中的字符串元素。

my_list = ['apple', 'banana', 'cherry']
joined_str = '-'.join(my_list)
print(joined_str)

这里使用'-'连接列表元素，结果为'apple-banana-cherry'。 - replace()方法：替换字符串中的子字符串。

my_str = 'hello world'
new_str = my_str.replace('world', 'python')
print(new_str)

输出'hello python'，即将'world'替换为'python'。 - strip()方法：移除字符串两端的空白字符。

my_str ='  hello  '
stripped_str = my_str.strip()
print(stripped_str)

结果为'hello'，移除了字符串两端的空白字符。还有lstrip()和rstrip()分别用于移除字符串左端和右端的空白字符。

集合类型相关函数

集合（set）是一种无序的、不包含重复元素的数据类型。

集合创建相关函数

  1. set()函数：用于创建集合。可以通过传递可迭代对象（如列表、元组、字符串）来创建集合，重复元素会被自动去除。
my_list = [1, 2, 2, 3]
my_set = set(my_list)
print(my_set)  

my_str = 'hello'
str_set = set(my_str)
print(str_set)

第一个集合为{1, 2, 3}，去除了列表中的重复元素2；第二个集合为{'h', 'e', 'l', 'o'}，去除了字符串中的重复字符l。也可以使用花括号{}直接创建集合，但空集合必须使用set()创建，因为{}在Python中表示空字典。

集合操作相关函数

  1. 集合方法：
    • add()方法：向集合中添加一个元素。
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)

集合变为{1, 2, 3, 4}。 - remove()方法：移除集合中的指定元素，如果元素不存在会抛出KeyError。

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)

集合变为{1, 3}。如果使用discard()方法，元素不存在时不会报错。 - 集合运算：集合支持多种运算，如并集（union()）、交集（intersection()）、差集（difference()）等。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
union_set = set1.union(set2)
intersection_set = set1.intersection(set2)
difference_set = set1.difference(set2)
print(union_set)  
print(intersection_set)  
print(difference_set)

并集union_set为{1, 2, 3, 4}，交集intersection_set为{2, 3}，差集difference_set为{1}。

字典类型相关函数

字典（dict）是Python中一种无序的键值对集合。

字典创建相关函数

  1. dict()函数：可以通过多种方式创建字典。
    • 通过关键字参数创建：
my_dict = dict(name='John', age=30)
print(my_dict)

创建了一个包含name和age键值对的字典{'name': 'John', 'age': 30}。 - 通过可迭代对象创建：可迭代对象中的元素必须是包含两个元素的可迭代对象（如元组），分别作为键和值。

my_list = [('name', 'John'), ('age', 30)]
my_dict = dict(my_list)
print(my_dict)

同样创建了{'name': 'John', 'age': 30}字典。

字典操作相关函数

  1. 字典方法：
    • get()方法：通过键获取对应的值，如果键不存在，返回指定的默认值（默认为None）。
my_dict = {'name': 'John', 'age': 30}
value = my_dict.get('name')
nonexistent_value = my_dict.get('city', 'Unknown')
print(value)  
print(nonexistent_value)

get('name')返回'John'，get('city', 'Unknown')由于city键不存在，返回默认值'Unknown'。 - items()方法：返回一个包含字典所有键值对的视图对象，可用于遍历字典。

my_dict = {'name': 'John', 'age': 30}
for key, value in my_dict.items():
    print(key, value)

会依次输出name John和age 30。 - keys()方法：返回一个包含字典所有键的视图对象。

my_dict = {'name': 'John', 'age': 30}
keys = my_dict.keys()
print(keys)

输出类似dict_keys(['name', 'age'])的视图对象，可用于迭代获取所有键。 - values()方法：返回一个包含字典所有值的视图对象。

my_dict = {'name': 'John', 'age': 30}
values = my_dict.values()
print(values)

输出类似dict_values(['John', 30])的视图对象，可用于迭代获取所有值。 - pop()方法：移除指定键的键值对，并返回对应的值。

my_dict = {'name': 'John', 'age': 30}
popped_value = my_dict.pop('age')
print(popped_value)  
print(my_dict)

返回30并移除age键值对，字典变为{'name': 'John'}。

布尔类型相关函数

布尔类型（bool）只有两个值：True和False。在Python中，许多值都可以隐式地转换为布尔值。

布尔转换相关函数

  1. bool()函数：用于将其他类型转换为布尔值。
    • 数字类型转换：0、0.0、0j（复数）转换为False，其他非零数字转换为True。
num1 = 0
bool1 = bool(num1)
num2 = 5
bool2 = bool(num2)
print(bool1)  
print(bool2)

分别输出False和True。 - 序列类型转换：空序列（空列表[]、空元组()、空字符串''、空集合set()、空字典{}）转换为False，非空序列转换为True。

my_list = []
bool_list = bool(my_list)
my_str = 'hello'
bool_str = bool(my_str)
print(bool_list)  
print(bool_str)

分别输出False和True。 2. 逻辑运算函数：and、or、not是Python中的逻辑运算符，也可看作是对布尔值进行操作的函数。and运算符在两个操作数都为True时返回True，否则返回False；or运算符只要有一个操作数为True就返回True，两个都为False时返回False；not运算符对布尔值取反。

bool1 = True
bool2 = False
and_result = bool1 and bool2
or_result = bool1 or bool2
not_result = not bool1
print(and_result)  
print(or_result)  
print(not_result)

分别输出False、True和False。