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

Python 基础篇：内置类型与方法详解 | 极客日志

help()

a.endswith('d')      # 判断字符串 a 是否以 d 结尾，执行结果为布尔值
a.startswith('d')    # 判断字符串 a 是否以 d 开头，执行结果为布尔值
a.isalnum()          # 判断字符串 a 是否包含数字和字母，返回结果为布尔值
a.isalpha()          # 判断字符串 a 是否都是英文字母，返回结果为布尔值
a.isdigit()          # 判断字符串 a 是否都为数字，返回结果为布尔值
a.isspace()          # 判断字符串 a 是否都为空格，返回结果为布尔值
a.istitle()          # 判断字符串 a 是否首字母大写，返回结果为布尔值
a.islower()          # 判断输入的字符串是否为小写字母，返回结果为布尔值
a.isupper()          # 判断输入的字符串是否为大写字母
a.lower()            # 将字符串中的大写字母变成小写
a.upper()            # 将字符串中的小写字母变成大写
a.swapcase()         # 大小写字母反转
a.capitalize()       # 对字符串的首字母进行大写
a.title()            # 对字符串中空格隔开的所有首字母进行大写

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

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

# 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 个

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 中出现的次数

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

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

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

# 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'显示

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

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

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

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

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

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

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

.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()              # 随机删除字典中的一对键值（一般删除末尾的一对）

集合（S）.方法名	等价符号	方法说明
s.issubset(t)	s<=t	子集（允许不严格意义上的子集）：s 中所有的元素都是 t 的成员
s<t	真子集（严格意义上的子集）：s!=t 且 s 中所有的元素都是 t 的成员
s.issuperset(t)	s>=t	超集（允许不严格意义上的超集）：t 中所有的元素都是 s 的成员
s>t	超集（严格意义上的超集）：t!=s 且 t 中所有的元素都是 s 的成员
s.union(t)	s	t
s.intersection(t)	s&t	交集操作：s 与 t 中的交集
s.difference(t)	s-t	差集操作：在 s 中存在但在 t 中不存在的元素
s.symmetric_difference(t)	s^t	对称差分操作：s 或 t 中的元素，而不是两者共有的元素
s.copy()	无	返回 s 的拷贝（浅复制）

集合（S）.方法名	等价符号	方法说明
s.update(t)	s	= t
s.intersection_update(t)	s &= t	交集修改操作：s 中仅包含 s 与 t 共有的元素
s.difference_update(t)	s -= t	差集修改操作：s 中仅包括 s 中存在但 t 中不存在的元素
s.symmetric_difference_update(t)	s ^= t	对称差分修改操作
s.add(obj)		添加操作：将 obj 添加到 s
s.remove(obj)		删除操作：将 obj 从 s 中移除，若不存在会引发异常
s.discard(obj)		丢弃操作：将 obj 从 s 中删除，如果不存在也没事
s.pop()		弹出操作：移除并返回 s 中的任意一个元素
s.clear()		清除操作：清除 s 中的所有元素
s.isdisjoint(t)		若 s 与 t 无交集，则返回 True，否则返回 False

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())

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 枚举对象

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()                # 用于访问父类的方法

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 内元素的总和

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 排序的列表

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

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

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)  # 打印输出

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

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

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 open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

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

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

一、基本的内置类型

1. str 字符串

1）条件判断方法

2）取值方法

3）元素判断与操作的方法

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

5）join 方法

6）替换方法

7）检索

8）切割字符串

9）随机字符库 string

10）格式化字符串

11）编码

2. list 列表

1）增加

2）删除

3）修改

4）检索

5）排序

6）复制

3. dict 字典

4. set 集合

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

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

5. 自定义类（Class）

二、内置方法

1. 类型转换

2. 对象及属性操作

3. 数学操作

4. 迭代器操作

5. 字符串操作

6. 字节操作

7. 编译输入输出

三、文件操作

1. 打开文件

2. 文件对象的属性

3. 文件对象的操作

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具