Python 基础篇：内置类型与方法详解

4）去除字符串指定元素方法

# （参数缺省时去除空格）（返回结果字符串）
a.lstrip('m')   # 去掉字符串左边的元素
a.rstrip('m')   # 去掉字符串右边的元素
a.strip('m')    # 去掉两边的元素，中间的元素不可去除

5）join 方法

# join 是用来通过某个字符串拼接一个可迭代对象的每个元素
'm'.join(str)     # 将字符串 str 中的每个元素都使用 m 连接，返回一个新字符串，原字符串 str 的内容未修改
'm'.join(list)    # 将列表转换为字符串，每个元素之间使用 m 连接

6）替换方法

# replace
st.replace('a', 'b', n)  # 将字符串 st 中的前 n 个元素 a 替换为 b，n 缺省时默认替换所有符合条件的元素 a

# 映射，可以做密码加密使用
p = str.maketrans('abcdefg', '1234567')  # 前面的字符串和后面的字符串进行映射，a-->1，c-->3
'ccaegg'.translate(p)                      # 输出结果按照上面的 maketrans 做映射后的字符串，执行结果为：331577

# tab 转化为空格
st.expandtabs(tabsize=8)  # 把字符串 st 的 tab 转为空格，默认为 8 个

7）检索

a.find(b, 3, 10)   # 从前往后查找字符串 a 中 b 的第一个字符的索引，3，10 是查找范围开始、结束的下标值，缺省时查找整个字符串
a.rfind(b, 3, 10)  # 从后往前查找
a[2]               # 按照索引查找第 3 个元素
a.index(b)         # 从左往右按值查找索引
a.rindex(b)        # 从右往左按值查找索引
a.count(b)         # 统计 b 在字符串 a 中出现的次数

8）切割字符串

# split（返回结果类型为 list）
a.split(b)         # 按照 b 分割字符串，缺省时默认为空格
a.splitlines()     # 按照换行符分割，每一行的内容作为 list 的一个元素

# partition（）（返回结果类型为 tuple）
a.partition(b)     # 将字符串 a 以从左往右第一个 b 为中心分为三部分
a.rpartition(b)    # 将字符串 a 以从右往左第一个 b 为中心分为三部分

9）随机字符库 string

import string
string.ascii_letters      # 输出所有的大小写字母
string.digits             # 输出所有（0-9）的数字
string.ascii_lowercase    # 输出小写英文字母
string.ascii_uppercase    # 输出大写英文字母

10）格式化字符串

# format（修饰符及说明符同 C 语言）
"{name}huh{age}".format(name='byz', age=18)                 # 格式化字符串显示
"{name}huh{age}".format_map({'name': 'zhangsan', 'age': 18}) # 格式化字典

# 占位符%（修饰符及说明符同 C 语言）
"%d%f%s" % (2, 3.14, "huh")

# 对齐
a.center(n, b)   # 长度总共为 n，将字符串 a 放在中间，两边补充 b 显示
a.ljust(n, b)    # 长度总共为 n，将字符串 a 放在左边，右边补充 b 显示
a.rjust(n, b)    # 长度总共为 n，将字符串 a 放在右边，左边补充 b 显示
a.zfill(n)       # 长度总共为 n，将字符串 a 放在右边，左边补充'0'显示

11）编码

str.decode(encoding[, replace])  # 解码 str
str.encode(encoding[, replace])  # 编码 str

2. list 列表

1）增加

<list>.append(<obj>)  # 追加到尾部
<list>.insert(<index>, <obj>)  # 在 index 处插入 obj
<list>.extend(<list>)  # 合并列表到尾部

2）删除

del list[<index>]      # 直接删除
<list>.pop(<index>)    # 删除并返回指定元素
<list>.remove(<obj>)   # 删除找到的第一个 obj
<list>.clear()         # 清空列表

3）修改

<list>[<index>] = <obj>  # 将 index 处的元素直接修改为 <obj>

4）检索

<list>.index(<obj>)  # 返回从左开始匹配到的第一个 <obj> 的索引
<list>.count(<obj>)  # 返回 <obj> 的个数

5）排序

<list>.sort(key=<排序规则>, reverse=<boolean>)  # 对列表的一种操作
sorted(<可迭代对象>, key=<排序规则>, reverse=<boolean>)  # 返回一个新的排序过的列表
<list>.reverse()  # 反转

6）复制

list.copy()  # 返回 list 的浅拷贝

3. dict 字典

.clear()                # 清除字段里所有的元素
.copy()                 # 字典的浅复制
.fromkeys()             # 创建字典，以序列 seq 中的元素作为键，val 为字典所有对应键的初始值
.get(key, default=None) # 设置不在字典中默认的值
key in dict             # 键是否在字典里，返回 true 或 false
.items()                # 以列表的方式遍历（键，值）元组数组
.keys()                 # 使用 list() 转换为列表
.setdefault(key, default=None)  # 为不存在于字典中的键，添加或设置键为 default
.update()               # 把字典里的键和值更新到另一个字典里
.values()               # 使用 list() 转换为列表
.pop(key[, .default])   # 删除字典键的值，返回删除键的值
.popitem()              # 随机删除字典中的一对键值（一般删除末尾的一对）

4. set 集合

1）以下方法返回一个新的集合

2）以下方法是对原来集合 s 的操作

5. 自定义类（Class）

虽然 Python 内置了丰富的数据类型，但在实际开发中，我们经常需要定义自己的类来封装数据和行为。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"Hello, I am {self.name}, {self.age} years old."

# 实例化
p = Person("Alice", 25)
print(p.introduce())

二、内置方法

较多的内置方法也是 Python 区别于其他编程语言的一个特点，熟练掌握这些内置方法的使用就已经可以实现 Python 大部分的功能，灵活使用 Python 的内置方法可以大幅度提高代码的速度以及减少代码量。

1. 类型转换

bool(object)           # 返回 object 对应的布尔值
str(object, encoding=encoding, errors=errors)  # 返回 object 对应的以 encoding 编码的字符串
int(value, base=10)    # 将 value 强制转换为 10 进制 int 型
float(value)           # 将 value 转换为浮点数
complex(real, imaginary)  # 返回一个 complex 对象复数 (real+imaginary j)
list(iterable)         # 创建一个 iterable 对应的列表
tuple(iterable)        # 返回一个新建的 iterable 的元组
set(iterable)          # 返回一个新建的 iterable 的 set 对象
dict(key1=value1, key2=value2...)  # 创建字典对象
enumerate(iterable, start=0)       # 将 iterable 转化为一个 enumerate 枚举对象

2. 对象及属性操作

object()               # 返回一个空对象 object
callable(object)       # 如果指定的对象是可调用的，则返回 True，否则返回 False
isinstance(object, class)  # 若 object 是 class 指定类型的，返回 True，否则返回 False
id(object)             # 返回 object 的 id 值
type(object)           # 返回一个 type 对象
len(object)            # 返回 object 的项目数
memoryview(obj)        # 从指定的对象返回一个内存视图对象
globals()              # 以字典类型返回当前位置的全部全局变量
locals()               # 将本地局部变量作为字典返回
vars(object)           # 返回 object 的__dic__属性
dir(object)            # 返回 object 的所有属性和方法（列表形式返回）
delattr(object, attribute)  # 删除 object 的 attribute 属性
getattr(object, attr[, default])  # 返回 object 的属性 attr 的值
hasattr(object, attribute)  # 如果 object 有 attribute 属性，返回 True，否则返回 False
setattr(object, attribute, value)  # 设置 object 的 attribute 属性值为 value
issubclass(child, father)  # 如果 child 是 father 的子类，则返回 True，否则返回 False
super()                # 用于访问父类的方法

3. 数学操作

abs(x)                 # 返回 x 的绝对值
round(number, ndigits=None)  # 返回将 number 四舍五入为小数位数为 ndigits 的数
bin(n)                 # 返回整数 n 的二进制形式的字符串，前缀 0b
hex(number)            # 返回 number 的十六进制形式的字符串，前缀 0x
oct(n)                 # 返回整数 n 的八进制形式的字符串，前缀 0o
divmod(x, y)           # 返回 x 除以 y 的商和余数组成的元组 (x//y, x%y)
pow(base, exp, mod=None)  # 返回 base^exp%mod
max()                  # 返回最大值
min()                  # 返回最小值
sum(iterable, start=0) # 返回 start 加 iterable 内元素的总和

4. 迭代器操作

all(iterable)          # 如果 iterable 中的所有项目均为 true，则 all() 函数返回 True，否则返回 False
any(iterable)          # 如果 iterable 中的任何项目为 true，则 any() 函数将返回 True，否则返回 False
iter()                 # 返回一个迭代器
next(iterator[, default])  # 返回迭代器 iterator 下一个要迭代的元素
frozenset(iterable)    # 返回一个 iterable 转变为的不可更改的 Frozenset 对象
filter(func, iterable) # 返回 iterable 中经 func 函数判断为真的部分组成的迭代器
map(function, iterable, ...)  # 返回一个 function 作用于 iterable 中每个元素得到的新元素组成的 map 对象
zip(iterables...)      # 返回一个 zip 对象，它是一个元组的迭代器
range(start=0, stop[, step=1])  # 返回一个 range 对象
slice(start, end, step)  # 返回一个切片对象
reversed(sequence)     # 返回 sequence 的反向迭代器
sorted(iterable, key=None, reverse=False)  # 返回 iterable 的以 key 排序的列表

5. 字符串操作

ascii(object)          # ascii() 函数返回任何对象的可读版本
chr(x)                 # 返回 Unicode 代码为 x 的字符
format(value, format_spec='')  # 返回按 format_spec 格式化后的字符串
ord(c)                 # 返回字符 c 的 unicode 编码

6. 字节操作

bytearray(x, encoding, error)  # 返回一个 bytearray 对象
bytes(x, encoding, error)      # 返回一个 bytes 对象

7. 编译输入输出

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)  # 编译源代码
eval(source, globals=None, locals=None)  # 执行 source 指定的 python 表达式
exec(source, globals=None, locals=None)  # 执行 source 指定的 python 代码
input(prompt)  # 提示 prompt 后返回输入对应的字符串
print(value,..., sep=' ', end='\n', file=sys.stdout, flush=False)  # 打印输出

三、文件操作

任何编程语言都需要对文件系统进行操作，且大部分的编程语言的文件操作方法大致相似，如果掌握了其中一种，其他编程语言的文件操作也可手到擒来。

1. 打开文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• file: 文件地址
• mode: 文件打开模式（如 'r', 'w', 'a', 'rb' 等）
• buffering: 寄存行缓冲区的大小（整数），-1 为默认大小
• encoding: 打开文件时的编码格式
• newline: 若不设置，universal newlines mode 工作（不同操作系统换行符不一样）

2. 文件对象的属性

f.buffer
f.closed           # 若 f 已经关闭，则返回 True，否则返回 False
f.encoding         # 文件的编码格式
f.errors
f.line_buffering
f.mode             # 文件打开模式
f.name             # 文件名
f.newlines
f.write_through

3. 文件对象的操作

f.close()          # 用于关闭一个已打开的文件
f.detach()         # 将底层缓冲区与 f 分离并返回它
f.fileno()         # 返回一个整型的文件描述符
f.flush()          # 用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件
f.isatty()         # 如果文件流是交互式的，则返回 True
f.read(size)       # 从文件的指针位置开始返回指定的字节数
f.readable()       # 如果文件可读，则返回 True，否则返回 False
f.readline(size)   # 从文件读取整行，包括 "\n" 字符
f.readlines(sizehint)  # 返回一个列表，其中包含文件中的每一行作为列表元素
f.reconfigure(encoding=None, errors=None, newline=None, line_buffering=None, write_through=None)  # 重新配置文本流
f.seek(offset)     # 设置文件流中的当前文件位置并返回该位置
f.seekable()       # 如果文件可查找，则返回 True，否则返回 False
f.tell()           # 返回文件流中的当前文件位置
f.truncate(size=None)  # 将文件大小调整至给定的字节数
f.write(str)       # 将指定的文本 str 写入文件
f.writable()       # 如果文件可写，返回 True，否则返回 False
f.writelines(list) # 将列表 list 的元素写入文件

最佳实践提示： 在使用文件操作时，推荐使用 with 语句来自动管理资源，确保文件在使用后正确关闭。

with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

通过掌握上述内置类型、方法和文件操作，你可以更高效地编写 Python 程序。建议在实际项目中多查阅官方文档，结合具体场景灵活运用。