1. str 字符串 

特性：有序、不可变序列，支持索引、切片

s = "hello"

遍历

# 1.直接遍历字符
for c in s:
    print(c)
# 2.下标遍历
for i in range(len(s)):
    print(i, s[i])
# 3.下标+字符
for idx, char in enumerate(s):
    print(idx, char)

基础运算

s1 + s2        # 拼接
s * 3          # 重复
"el" in s      # 成员判断
s[0]           # 索引取值
s[1:3]         # 切片
s[::-1]        # 反转
len(s)         # 长度

全部常用内置方法

s.capitalize()      # 首字母大写
s.title()           # 每个单词首字母大写
s.upper()           # 全部大写
s.lower()           # 全部小写
s.swapcase()        # 大小写互换

s.strip()           # 去除首尾空白
s.lstrip()          # 去除左侧空白
s.rstrip()          # 去除右侧空白

s.split(",")        # 分割成列表
s.rsplit(",")
s.splitlines()      # 按换行分割

"|".join(["a","b"]) # 拼接序列为字符串

s.replace("h","H")  # 替换

s.find("ll")        # 查找，找不到返回-1
s.rfind("ll")
s.index("ll")       # 找不到抛异常
s.rindex("ll")

s.count("l")        # 统计字符出现次数

s.startswith("he")
s.endswith("lo")

s.isdigit()         # 是否纯数字
s.isalpha()         # 是否纯字母
s.isalnum()         # 字母+数字
s.isspace()         # 是否全空白字符
s.islower()
s.isupper()

s.center(10,"-")    # 居中填充
s.ljust(10,"-")
s.rjust(10,"-")

s.zfill(8)          # 左侧补0

---

2. list 列表

特性：有序、可变序列，允许重复元素

lst = [10,20,30]

遍历

# 直接遍历元素
for item in lst:
    print(item)
# 下标遍历
for i in range(len(lst)):
    print(i, lst[i])
# 下标+元素
for idx, val in enumerate(lst):
    print(idx, val)
# 倒序遍历
for val in reversed(lst):
    print(val)

基础运算

lst1 + lst2     # 拼接
lst * 2         # 重复
20 in lst       # 成员判断
lst[0]          # 索引取值
lst[1:]         # 切片
lst[::-1]       # 反转
len(lst)
lst[1] = 99     # 修改元素

全部内置方法

# 增
lst.append(40)          # 尾部追加
lst.insert(1, 15)       # 指定下标插入
lst.extend([50,60])     # 合并序列

# 删
lst.pop()               # 删除末尾，返回元素
lst.pop(0)              # 删除指定下标
lst.remove(20)          # 删除第一个匹配元素
lst.clear()             # 清空列表

# 查询
lst.index(20)           # 获取下标
lst.count(10)           # 统计数量

# 排序反转
lst.sort()              # 原地升序
lst.sort(reverse=True)  # 降序
lst.reverse()           # 原地反转

# 复制
lst.copy()              # 浅拷贝

---

3. tuple 元组

特性：有序、不可变序列，一级元素不能修改

t = (1,2,3)
t_single = (5,)  # 单个元素必须加逗号

遍历

for item in t:
    print(item)
for i in range(len(t)):
    print(t[i])
for idx,val in enumerate(t):
    print(idx,val)

基础运算

t1 + t2         # 拼接
t * 3           # 重复
2 in t          # 成员判断
t[0]
t[1:3]
t[::-1]
len(t)

内置方法

t.index(2)      # 返回元素下标
t.count(3)      # 统计次数

---

4. dict 字典（Python3.7 + 有序

特性：可变，键值对；key 唯一，key 必须不可变类型

d = {"name":"张三","age":18}

遍历

# 只遍历key（默认）
for k in d:
    print(k, d[k])
# 遍历所有键
for k in d.keys():
    print(k)
# 遍历所有值
for v in d.values():
    print(v)
# 同时遍历键和值（最常用）
for k, v in d.items():
    print(k, v)

基础运算

"name" in d     # 判断key是否存在
len(d)
d["name"]       # 通过key取值
d["age"] = 20   # 新增/修改键值

全部内置方法

d.get("age", 0)                 # 取值，可设置默认值
d.keys()                        # 获取所有键
d.values()                      # 获取所有值
d.items()                       # 获取键值对

d.update({"gender":"男"})        # 批量更新/新增

d.pop("age")                    # 删除指定key，返回value
d.popitem()                     # 删除最后一组键值对
d.clear()                       # 清空字典

d.copy()                        # 浅拷贝

# 创建字典静态方法
dict.fromkeys(["a","b"], 10)    # 使用序列生成字典，统一默认值

---

5. set 集合

特性：可变、无序、元素唯一、自动去重；无索引

s = {1,2,3}
empty_s = set()   # 空集合！{}是空字典

遍历

# 唯一方式：不能用下标遍历
for item in s:
    print(item)

基础运算

3 in s          # 成员判断
len(s)
# 集合运算
a = {1,2,3}
b = {3,4,5}
a & b       # 交集
a | b       # 并集
a - b       # 差集
a ^ b       # 对称差集
a <= b      # 子集
a >= b      # 超集

全部内置方法

# 添加
s.add(4)                    # 添加单个元素
s.update([5,6])             # 批量添加序列元素

# 删除
s.remove(3)                 # 删除，不存在报错
s.discard(99)               # 删除，不存在不报错（推荐）
s.pop()                     # 随机删除一个元素
s.clear()                   # 清空集合

# 集合运算方法（等价运算符）
s.intersection(b)           # 交集
s.union(b)                  # 并集
s.difference(b)             # 差集
s.symmetric_difference(b)   # 对称差集

# 原地更新集合
s.intersection_update(b)
s.difference_update(b)
s.symmetric_difference_update(b)

s.issubset(b)               # 是否子集
s.issuperset(b)             # 是否超集
s.isdisjoint(b)             # 是否无交集

s.copy()                    # 拷贝集合

---