1.列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n]。
 2.列表定义：a = [1,2,3]
 3.列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
 list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
 list.insert(index, obj) 在编号 index 位置插入 obj。
 list.remove(obj) 移除列表中某个值的第一个匹配项
 list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
 4.获取列表中的元素
 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
 5.切片
 切片的通用写法是 start : stop : step；最后把 step 设为 -1，相当于将列表反向排列。
 6.列表的常用操作符
 列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
 list.count(obj) 统计某个元素在列表中出现的次数
 list.sort(key=None, reverse=False) 对原列表进行排序。reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
 7.「元组」定义语法为：(元素1, 元素2, …, 元素n)
 Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改。
 元组使用小括号，列表使用方括号。元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
 8.元组大小和内容都不可更改，因此只有 count 和 index 两种方法。
 9.解压（unpack）一维元组（有几个元素左边括号定义几个变量）。
 如果不关心后面的变量，可以用符号代替，例子如下：
 
 10.字符串的定义支持使用成对的单引号或双引号。
 如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。
 11.字符串的切片与拼接
 类似于元组具有不可修改性
 从 0 开始
 切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
 12. 字符串的常用内置方法
 13. 字符串的常用内置方法
 lower() 转换字符串中所有大写字符为小写。
 upper() 转换字符串中的小写字母为大写。
 swapcase() 将字符串中大写转换为小写，小写转换为大写。
 endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
 startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
 lstrip([chars]) 截掉字符串左边的空格或指定字符。
 rstrip([chars]) 删除字符串末尾的空格或指定字符。strip([chars]) 在字符串上执行lstrip()和rstrip()。
 split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。
 14.字符串格式化
 format 格式化函数
 

容器数据类型
 
列表<class ‘list’>
 元组<class ‘tuple’>
 字符串<class ‘str’>
 1、列表
 列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n]。
 关键点是「中括号 []」和「逗号 ,」
 中括号 把所有元素绑在一起
 逗号 将每个元素一一分开
 2、元组
 「元组」定义语法为：(元素1, 元素2, …, 元素n)
 小括号把所有元素绑在一起
 逗号将每个元素一一分开
 Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
 元组使用小括号，列表使用方括号。
 元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
 3、字符串
 Python 中字符串被定义为引号之间的字符集合。
 Python 支持使用成对的 单引号 或 双引号。

 
文章目录
 
1、列表 list
1.1、len()
1.2、max()和min()
1.3、reverse()
1.4、sort()
1.5、clear()
1.6、remove()
1.7、insert()和pop()
   
2、元组 tuple
2.1、len()
2.2、count()
2.4、index()
   
3、字典
3.1、clear()
3.2、keys()和values()
3.3、items()
3.4、get()
3.5、pop()
3.6、setdefault()
   
4、字符串
4.1、replace()
4.2、split()
4.3、strip()
4.4、count()
4.5、find()
4.6、join()
   
CSDN独家福利降临！！！
 

 
 
1、列表 list
 
 
 
列表(list):专门用于存储一串信息,列表用中括号[]定义,数据之间使用逗号,分隔
 
 
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
 
 
1.1、len()
 
 
 
获取列表的长度
 
 
print(len(list1))
print(len(list2))
print(len(list3))
 
 
 
1.2、max()和min()
 
 
 
获取列表中最大值和最小值
 
 
print("----list2------")
print(max(list2))
print(min(list2))

print("----list3------")
print(max(list3))
print(min(list3))
 
 
 
1.3、reverse()
 
 
 
反向列表中元素
 
 
print("----list2------")
list2.reverse()
print(list2)

print("----list3------")
list3.reverse()
print(list3)
 
 
 
1.4、sort()
 
 
 
对列表进行排序，从小到大
 
 
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 4, 5, 2, 3]
list3 = ["c", "d", "a", "b"]


print("----list2------")
list2.sort()
print(list2)

print("----list3------")
list3.sort()
print(list3)
 
 
 
1.5、clear()
 
 
 
清空列表
 
 
print("----list2------")
list2.clear()
print(list2)

print("----list3------")
list3.clear()
print(list3)
 
 
 
1.6、remove()
 
 
 
删除指定值
 
 
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]

print(list2)
list2.remove(2)
print(list2)
 
 
 
1.7、insert()和pop()
 
 
 
pop 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
 insert 插入对象
 
 
list = ["a","b","c","d"]

list.pop()
print(list)

#指定索引位置进行插入
list.insert(2,"ppx")
print(list)
 
 
 
2、元组 tuple
 
 
 
tuple元组和列表类似，不同的地方是元组元素不能修改
 
 
tup1 = (1, 2, 5 ,3, 4, 2 ,4 ,2)
 
 
2.1、len()
 
 
 
获取元组的长度
 
 
print(len(tup1))
 
 
 
2.2、count()
 
 
 
统计某元素出现的次数
 
 
print(tup1.count(2))
 
 
 
2.4、index()
 
 
 
获取指定元素的最小索引
 
 
print(tup1.index(2))
 
 
 
3、字典
 
 
 
字典是一个无序的，可修改的，以键值对存储的（键必须是不可修改类型且键不可重复，值没有要求）数据类型
 
 
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
 
 
3.1、clear()
 
 
 
清空字典
 
 
print(dict)
dict.clear()
print(dict)
 
 
 
3.2、keys()和values()
 
 
 
keys以列表返回一个字典所有的键
 
 
keys = dict.keys()

for key in keys:
    print(key)
 
 
 
 
values以列表返回字典中的所有值
 
 
values = dict.values()

for value in values:
    print(value)
 
 
 
3.3、items()
 
 
 
以列表返回可遍历的(键, 值) 元组数组
 
 
for k,v in dict.items():
    print(k+"-"+v)
 
 
 
3.4、get()
 
 
 
返回指定键的值，如果值不在字典中返回default值
 
 
print(dict.get("Alice"))
print(dict.get("afaawg"))
 
 
 
3.5、pop()
 
 
 
删除指定键值
 
 
print(dict)
dict.pop("Beth")
 
 
 
3.6、setdefault()
 
 
 
若字典中有该键，则不做任何操作，若没有则添加上
 
 
dict.setdefault("Alice","皮皮虾")
dict.setdefault("xxx","xxx")
print(dict)
 
 
 
4、字符串
 
 
 
只要是是使用单引号，双引号，三引号包裹起来的数据都是字符串
 
 
 
4.1、replace()
 
 
 
字符串替换
 
 
str = "hello world hello ppx"

#将hello替换成皮皮虾
print(str.replace("hello","皮皮虾"))
 
 
 
4.2、split()
 
 
 
字符串分割
 
 
str = "hello world hello ppx"

#使用空格进行分割
string = str.split(" ")
print(string)
 
 
4.3、strip()
 
 
 
自定义删除字符串两边的东西，默认是空格
 lstrip()去除字符串左边空格 rstrip()去除字符串右边空格
 
 
str = "        hello world hello ppx"

print(str)
#去除字符串两边的空格
string = str.strip()
print(string)

#去除字符串两边的x
s = str.strip("x")
print(s)![在这里插入图片描述](https://img-blog.csdnimg.cn/20200905162224508.png#pic_center)

 
 
 
4.4、count()
 
str = "        hello world hello ppx"

#默认全部查找
print(str.count("o"))
#自定义范围查找
print(str.count("o",0,20))
 
 
 
4.5、find()
 
str = "hello world hello ppx"

#默认全部查找
print(str.find("l"))
#指定范围查找
print(str.find("l",0,1))
 
 
 
 
返回-1表示没有找到
 
 
 
4.6、join()
 
list = ["a","b","c","d"]

print("-".join(list))
 
 

 
 
CSDN独家福利降临！！！
 

 
最近CSDN有个独家出品的活动，也就是下面的《Python的全栈知识图谱》，路线规划的非常详细,尺寸 是870mm x 560mm 小伙伴们可以按照上面的流程进行系统的学习，不要像我当初一样没人带自己随便找本书乱学，系统的有规律的学习，它的基础才是最扎实的，在我们这行，《基础不牢，地动山摇》尤其明显。
 
最后，如果有兴趣的小伙伴们可以酌情购买，为未来铺好道路！！！
 
 
 
博主会持续更新，有兴趣的小伙伴可以点赞、关注和收藏下哦，你们的支持就是我创作最大的动力！
 
更多博主开源爬虫教程目录索引（宝藏教程，你值得拥有！）
 

作者今天在复习数据类型，想着就把这些内置的方法给集中一下，方便查看。这些都是作者认为比较常用的，不足之处，请见谅。
 
List列表
 
list(列表)是python中使用最频繁的数据类型。专门存放数据，存放其中的数据被称作元素。
 
列表⽤ [ ] 定义，元素 之间使⽤ , 分隔。
列表的 索引 从 0 开始。
索引 就是元素在 列表 中的位置编号。
 
a = [1, 2, 3]
print(a[0])
print(a[1])
print(a[2])
 
列表常用的操作
 
增加元素
 
列表.append(数据)在列表末尾添加元素。
列表.insert(索引,数据)在列表指定位置插入元素。
列表.extend(可迭代对象)将可迭代对象中的元素 追加到列表中。
 
a = [1, 2, 3]
a.insert(0, 4)  # 在开始加入4
a.append(5)  # 在最后加入5
a.extend('abc')
print(a)
 
删除元素
 
列表.remove(数据) 删除第⼀个出现的指定数据
del 列表[索引] 删除指定索引的数据
列表.pop(索引) 删除指定索引数据,返回被删除的元素，默认表尾
列表.clear() 清空列表
 
a = [1, 3, 1, 3]
a.remove(3)  # 移除第一个3
print(a)
del a[0]  # 移除索引为0的元素
print(a)
print(a.pop(0))  # 返回1
a.clear() # 清空列表
 
修改元素
 
列表[索引] = 数据 修改指定索引的数据，数据不存在会报错.
 
查询元素
 
列表[索引] 根据索引取值，索引不存在会报错
列表.index(数据) 根据值查询索引，返回⾸次出现时的索引，没有查到会报错
列表.count(数据) 数据在列表中出现的次数
len(列表) 列表⻓度
if 数据 in 列表: 检查列表中是否包含某元素
 
a = [1, 2, 3]
print(a.index(3))  # 2
print(a.count(3))  # 1
print(len(a))  # 3
if 2 in a:
	print('hahaha')
 
排序
 
列表.sort()默认升序，将参数reverse设为True降序
列表.reverse() 逆序
 
a = [1, 8, 9]
a.sort()  # 默认升序
print(a)
a.sort(reverse=True)  # 降序
print(a)
a.reverse()
print(a)  # 逆序
 
python列表切片截取
 
>>>L = ['Google', 'Runoob', 'Taobao']
 
>>> L[2] 'Taobao'
 
>>> L[-2] 'Runoob'
 
>>> L[1:] ['Runoob', 'Taobao']
 
>>>
 
列表总结的大概就这多！！！
 
元组
 
元组定义
 
python元组与列表类似，不同之处在于元组的元素不可更改。元组⽤ () 定义 ，⽤于存储 ⼀串数据，元素 之间使⽤ , 分隔 。元组的索引 从 0 开始 。
 
# 定义元组
 
info_tuple = ("Scrat", 18, 1.75)
 
# 取出元素的值
 
print(info_tuple[0]) # 输出：Scrat
 
元组中 只包含⼀个元素 时，需要 在元素后⾯添加逗号
 
info_tuple = (50, )
 
元组常⽤操作
 
Tuple （元组）与列表类似，不同之处在于元组的 元素不能修改
 
info_tuple = (“Scrat”, 18, 1.75)
info_tuple[0] = “lisi” # 程序报错
 
查询
 
元组[索引] 根据索引取值，索引不存在会报错
元组.index(数据) 根据值查询索引，返回⾸次出现时的索引，没有查到会报错
元组.count(数据) 数据在元组中出现的次数
len(列表) 元组⻓度
if 数据 in 元组: 检查元组中是否包含某元素
 
遍历
 
for 元素 in 元组: 取出元组中的每个元素
 
让列表不可以被修改，以保护数据安全
 
# 元组和列表之间的转换
 
# 使⽤ `tuple` 函数 把列表转换成元组
 
list1 = [10, 11]
 
tuple1 = tuple(list1)
 
# 使⽤ `list` 函数 把元组转换成列表
 
# list1 = list(tuple1)
 
元组内置函数
 
1 cmp(tuple1, tuple2)
 比较两个元组元素。
 
2 len(tuple)
 计算元组元素个数。
 
3 max(tuple)
 返回元组中元素最大值。
 
4 min(tuple)
 返回元组中元素最小值。
 
5 tuple(seq)
 将列表转换为元组。
 
字典
 
dictionary （字典）是除列表以外 Python之中最灵活的数据类型 ，字典同样可以⽤来存储多个数据 ，通常⽤于存储描述⼀个物体的相关信息 ，字典⽤ { } 定义 。
 
字典使⽤ 键值对 存储数据，键值对之间使⽤ , 分隔：
 
键key是索引
值value是数据
键值之间用：分离
值可以是任何类型，键只能是字符串，数字或者元组。
 
a={1:2, 'a': 'as', ('as','s'):'x'}
print(a[1])
print(a['a'])
print(a[('as','s')])
 
键值必须唯一
 
字典常用操作
 
1.增
 
字典[键] = 数据 键不存在，会添加键值对；键存在，会修改键值对的值 。
 
2.删
 
del 字典[键] 删除指定的键值对 。
字典.pop(键) 删除指定键值对,返回被删除的值 。
字典.popitem()随机返回并删除最后一个元素。
字典.clear 清空字典 。
 
a = {'name': 'LIHUA',
     'age': 18,
     'sex': '男'}
# b = a.pop('name')  # 返回移除的指定键对应的值
# print(b)
# print(a)

# print(a)
# a.clear()  # 清空字典
# print(a)
 
3.改
 
字典[键] = 数据 键不存在，会添加键值对；键存在，会修改键值对的值 。
字典.setdefault(键，数据) 键值对不存在，添加键值对；存在则不做处理 。
字典1.update(字典2) 取出字典2的键值对赋值给字典1，若有相同的项则进行覆盖,不同的就添加。
 
a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
a2 = {'name': 'zzh',
      'age': 16,
      'sex': '男',
      '学号': 123456,
      '能力': '电磁炮'}

# a1.setdefault('能力', '肉')
# a1.setdefault('能力', 'no肉')  # 若键值对存在则不作任何操作，若不存在则添加
# print(a1)

a1.update(a2)  # 以a2覆盖a1
print(a1)
 
查
 
字典[键] 根据键取值，键值对不存在会报错 。
字典.get(键) 根据键取值，键值对不存在不会报错 。
字典.keys() 可进⾏遍历，获取所有键 。
字典.values() 可进⾏遍历，获取所有值 。
字典.items() 可进⾏遍历，获取所有(键，值)
 
a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
# a2 = {'name': 'zzh',
#       'age': 16,
#       'sex': '男',
#       '学号': 123456,
#       '能力': '电磁炮'}
print(a1['name'])  # 若键值对不存在报错
print(a1.get('nam'))  # 若键值对不存在不报错，返回None
print(a1.keys())  # 返回所有的键
print(a1.values())  # 返回所有的值
print(a1.items())  # 返回所有的键值对
 
遍历
 
for k in 字典.keys()遍历键
for v in 字典.values()遍历值
for k, v in 字典.item()遍历键值对
for item in 字典.items() 遍历字典的元素（以元组的形式遍历出每一项)
 
a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
for i in a1.items():
    print(i)


for k, v in a1.items():
    print(k)
    print(v)
 
一些方法
 
字典.fromkeys(seq, value):
 创建一个字典，seq为新字典的键，value为所有键的默认值，value默认为None
 
seq = ('name', 'age', 'sex')
 
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))
 
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))
 
字符串
 
字符串 就是⼀串字符，是编程语⾔中表示⽂本的数据类型，在 Python 中可以使⽤ ⼀对双引号 " 或者 ⼀对单引号 ’ 定义⼀个字符串,字符串是不可变序列，不能直接进行修改等。
 
虽然可以使⽤ " 或者 ’ 做字符串的转义，但是在实际开发中：
 
如果字符串内部需要使⽤ " ，可以使⽤ ’ 定义字符串
 如果字符串内部需要使⽤ ’ ，可以使⽤ " 定义字符串
 可以使⽤ 索引 获取⼀个字符串中 指定位置的字符，索引计数从 0 开始
 
也可以使⽤ for 循环遍历 字符串中每⼀个字符。
 
string = "Hello Python"
 
for c in string:
 
    print(c)
 
判断
 
string.isalpha() 如果 string ⾄少有⼀个字符并且所有字符都是字⺟则返回 True
string.islower() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符，并且所有这些(区分⼤⼩写的)字符都是⼩写，则返回 True
string.isupper() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符，并且所有这些(区分⼤⼩写的)字符都是⼤写，则返回 True
string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True
 string.endswith(str) 检查字符串是否是以 str 结束，是则返回 True
string.istitle()检查所有单词都是首字母大写。
string.isspace()检查所有字符都是空的字符。
string.isdigit()检查所有的字符都是数字。
 
a = '12345667889'
print(a.isdecimal())
print(a.isdigit())
b = 'ahdgkj'
print(b.isalpha())
c = 'adg4156'
print(c.isalnum())  # 判断所有字符都是字母或者数字
d = ';;;;a'
f = ';;;;A'
print(d.islower())
print(f.isupper())
 
查找，替换
 
1.string.find(str, start=0,end=len(string))
 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
 2.string.rfind(str, start=0,end=len(string)) 类似于 find()，不过是从右边开始查找
 3.string.index(str, start=0,end=len(string)) 跟 find() ⽅法类似，不过如果 str 不在 string 会报错
 4.string.rindex(str, start=0,end=len(string)) 类似于 index()，不过是从右边开始
 
a = '123456789078456'
x = a.find('7', 0, len(a))  # 找‘7’找到后返回其索引
y = a.rfind('7', 0, len(a))  # 从右边找
z = a.rfind('a', 0, len(a))
print(x)
print(y)
print(z)  # 不存在则返回-1
 
a = '123456789078456'
x = a.index('7', 0, len(a))  # 找‘7’找到后返回其索引
y = a.rindex('7', 0, len(a))  # 从右边找
# z = a.index('a', 0, len(a))
print(x)
print(y)
# print(z)  # 不存在则报错
 
string.replace(old_str, new_str, num)
 返回⼀个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次。
 
a = '123456789123456789123456789'
b = a.replace('1', 'a', 2)  # 返回一个改变过的新字符串
print(a)  # a本身不变
print(b)
 
拆分与拼接
 
string.split(str="",num)
 返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个⼦字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格。
 
string.splitlines() 返回列表，按照⾏(’\r’, ‘\n’, ‘\r\n’)分隔
 
string1 + string2 拼接两个字符串
 
string.join(seq) 返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为⼀个新的字符串
 
a = 'Hello auidfh\n nadsjk'
b = ['Hello', 'nihao', 'i love u']
x = a.split()  # 分割
y = ','.join(b)
print(x)
print(y)
 
大小写转换
 
a = 'aa bb A'
b = a.title()  # 所有的单词首字母大写
c = a.capitalize()  # 只有第一个单词首字母大写
e = a.upper()  # 字符串字符全部大写
f = a.lower()  # 字符串字符全部小写
print(b)
print(c)
print(e)
print(f)
 
文本对齐
 
a = 'adff'
c = a.rjust(10)  # 右对齐，长度填充到10
d = a.ljust(10)  # 左对齐，长度填充到10
e = a.center(10)  # 居中，长度填充到10
print(c)
print(d)
print(e)

 
 
去除空白字符
 
a = '  adff  '
c = a.rstrip()  # 去除右边的空格
d = a.lstrip()  # 去除左边的空格
e = a.strip()  # 去除两边的空格
print(c)
print(d)
print(e)
 
提示：列表除了查询⽅法和pop⽅法都没有返回值，字符串所有⽅法都有返回值
 
注意!
 

# 字符串的逆序（⾯试题）
 
print(num_str[::-1])
 
Unicode 字符串
 
Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：
 
>>> u'Hello World !'
u'Hello World !'
 
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：
 
>>> u'Hello\u0020World !'
u'Hello World !'
 
被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。
 
三引号（所见即所得）
 
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
 
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
 
内置方法
 

 
 
 
 
 
字符串格式化：
 
第一种：%形式
 
 
 
name = "周安可"
age = 18
sex = "女"
print("我的名字叫做%s,我的年龄是%d,我的性别是%s"%(name,age,sex))

 
a = 18
print('%-+10.3f'%a)  # %开始 -左对齐 +对正数加+ 10最小宽度 .3小数点精度 f指定的转换类型
 
第二种format
 
a = '{}喜欢{}！'
b = '{0}喜欢{1}！'
c = '{name1}喜欢{name2}！'
print(a.format('周安可','李淳风'))
print(b.format('周安可','李淳风'))
print(c.format(name1='周安可',name2='李淳风'))
 

 
 
字符串常量：
 
import string

print(string.ascii_lowercase)  # 小写字符
print(string.ascii_uppercase)  # 大写字符
print(string.ascii_letters)  # 大小写字符
print(string.digits)  # 数字
print(string.whitespace)  # 空白字符
print(string.punctuation)  # 标点符号
print(string.printable)  # 可打印字符串的字符，包括大小写字符，标点，空白符
print(string.hexdigits)  # '0123456789abcdefABCDEF'
print(string.octdigits)  # '01234567'

 
pypinyin库与jieba库
 

 
 
集合：
 
集合创建：
 a={1,2}
 a=set()
 集合中的元素只能是可哈希的（即不可变类型）。
 
集合元素的增加
 add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；
 update()方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。
 
集合元素删除
 pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；
 remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常；
 discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
 clear()方法清空集合删除所有元素。
 
集合运算
 
 
 
a_set = set([8, 9, 10, 11, 12, 13])
 b_set = {0, 1, 2, 3, 7, 8}
 a_set | b_set #并集
 {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
 a_set.union(b_set) #并集
 {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
 a_set & b_set #交集
 {8}
 a_set.intersection(b_set) #交集
 {8}
 a_set.difference(b_set) # 差集
 {9, 10, 11, 12, 13}
 a_set - b_set
 {9, 10, 11, 12, 13}
 a_set.symmetric_difference(b_set) #对称差集
 {0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
 a_set ^ b_set
 {0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
 
 
好累好累！终于集合好了。实际上最后的图片有大多数方法都不常用。作者觉得把作者前面分类的方法熟悉就足够用了。
 
希望能帮到大家。