在python语言中，常见的数据类型包括字符串、列表、元祖、字典、集合等 。 其中，最为常用的还是字符串、列表和字典 ，这些数据类型也都有很多的操作方法， 这些方法我们也没必要记 ，因为用得多了你自然而然就会了 ，如果没有记住的，从网上也会找一大堆这资料 。

但是，每次用到的时候还得百度 ，而每次百度的结果都是千篇一律 ，于是就想能否将这些简单的方法整理的不一样点呢 ？ 除了具有当工具书查阅之外，是否也可以让其具有一些其它属性呢 ？ 比如怎么样整理的更容易被记住和理解呢 ？ 再比如可以将其它用途都整合到一起呢 ？这篇文章就是向这方面努力的 ，至于能不能做到，那就是另外一回事了 。

本文仍然是以整理基础语法为主 ，路过的高手请忽略此文 。

1.字符串

以下是对字符串方法的整理。

上图是对字符串方法进行了一个分类整理 ，总觉得这些方法有一定的规律可循 ，找到这些规律有助于我们容易地理解和记忆 。比如：

字符串的方法可以被划分为两大类 ，分别为判断字符串和处理字符串 。

其中判断字符串方法的主要特点是 ：

都是返回的bool值全字符串判断都是以is开头 + 功能字符结束 ，如判断是否为全大写 ： isupper()局部字符串判断只有判断开头和结尾 ，分别为startswith ，endswith

也正因为是判断类的方法，故常用于条件判断 。

# 字符串方法"""===全字符判断isdight()       : 是否只包含数字isalpha()       : 是否只包含字母isalnum()       : 是否只包含数字和字母isspace()       : 是否只包含空格isnumeric()     : 是否只包含数字字符islower()       : 是否只包含全小写字母isupper()       : 是否只包含全大写字母istitle()       : 是否以标题化显示====局部字符判断startswith()     : 是否以某某开头endswith()       : 是否以某某结尾"""# 字符串定义str0 = "helloworld"str1 = "hello world"str2 = "HELLO WORLD"str3 = "1234"str4 = "一二"str5 = "h1m2j3"str6 = "   "str7 = "Hello World"# 方法调用print(str3.isdigit())       # 返回Trueprint(str0.isalpha())       # 返回Trueprint(str5.isalnum())       # 返回Trueprint(str6.isspace())       # 返回Trueprint(str4.isnumeric())     # 返回Trueprint(str1.islower())       # 返回Trueprint(str2.isupper())       # 返回Trueprint(str7.istitle())       # 返回Trueprint(str1.startswith("hello"))     #返回Trueprint(str1.endswith("world"))       #返回True

字符串处理类包括：

去除或填充空格、数字字符串查找字符串切割改变字符串编码或格式 。

处理类字符中的去除或填充

# 字符串处理方法"""====字符串大小写转化处理upper()             : 转化小写字母为大写字母lower()             : 转化大写字母为小写字母capitalize()        : 把字符串的第一个字母大写,其它字母变小写swapcase()          : 翻转字符串的大小写expandtabs()        : 把字符串中的tab符号转化为空格，tabs默认的空格是8====去除或填充空格strip()             : 删除两边的字符串 lstrip()            : 删除字符串前面的空格rstrip()            : 删除字符串后面的空格center(width)       : 把一个字符串居中，并使用空格填充成至width新的字符串zfill(width)        : 返回长度width的字符串，原字符串向右对齐，前面填充0ljust(witdh)        : 返回长度width的字符串，源字符串左对齐，剩余的用空格填充"""# 字符串定义str1 = "hello world"str2 = "HELLO WORLD"str3 = "hello WORLD"str4 = "hello   world   "str5 = " Hello World "# 方法调用print(str1.upper())             # 返回: HELLO WORLDprint(str2.lower())             # 返回: hello worldprint(str3.capitalize())        # 返回: Hello worldprint(str3.swapcase())          # 返回: HELLO worldprint(str4.expandtabs())        # 返回: hello   worldprint(str5.strip())             # 返回: Hello Worldprint(str5.lstrip())            # 返回: Hello Worldprint(str5.rstrip())            # 返回:  Hello Worldprint(str5.center(20))          # 返回：     Hello Worldprint(str5.zfill(20))           # 返回： 0000000 Hello Worldprint(str5.ljust(20))          # 返回：  Hello World

字符串查找|切割|编码转化

# 字符串处理方法"""====字符串查找find(str)             : 查找str是否包含在整个字符串中，如果找到则返回索引值，否则返回-1index(str)            : 查找str是否包含在整个字符串中，如果找到则返回索引值，否则报异常rfind(str)            : 和find()类似，返回字符串最后一次出现的位置，没有匹配到则返回-1rindex(str)           : 和index()类似，从右边开始炒作count(str)            : 返回str在字符串的次数====字符串切割split(str)            : 通过str将字符串进行分割，分割后的元素将放在列表中 splitlines(str)       : 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表partition(str)        : 通过str将字符串进行分割，分割后会形成一个有3个元素的元祖，第一个为左边的子串，第二个分隔符本身，第三个为分隔符右边的子串rpartition(str)       : 类似于partition() ，只不过是从右边分割join(str)             : 以str为分隔符，将所有元素合并为一个新的字符串replace(old,new)      : 以字符串中的old替换为new====改变字符串编码或格式 encode()              : 以encodeing指定的格式编码字符串             decode()              : 以decode指定的格式编码字符串format()              : 格式化字符串"""# 字符串定义str1 = "hello world"str2 = "HELLO \nWORLD\n abcd"str3 = "hello.world"str4 = "你好"str5 = "hello {}"# 方法调用print(str1.find('o'))                   # 返回: 4print(str1.index('o'))                  # 返回: 4print(str1.rfind('o'))                  # 返回: 7print(str1.rindex('o'))                 # 返回: 7print(str1.count('o'))                  # 返回: 2print(str1.split())                     # 返回: ['hello', 'world']print(str2.splitlines())                # 返回: ['HELLO ', 'WORLD', ' abcd']print(str3.partition('.'))              # 返回: ('hello', '.', 'world')print(str3.rpartition('.'))             # 返回：('hello', '.', 'world')print('#'.join(str1))                   # 返回：h#e#l#l#o# #w#o#r#l#dprint(str1.replace('world','python'))   # 返回：hello pythonprint(str4.encode('utf-8'))             # 返回: b'\xe4\xbd\xa0\xe5\xa5\xbd'print(str4.encode().decode())           # 返回: 你好print(str5.format('world'))             # 返回: hello world

1.列表和字典的新增/修改/删除 ：

# 字典 和 列表"""=== 列表新增(插入)append()                : 在列表末尾追加元素insert(index,obj)       : 在列表的某个位置追加元素 extend(seq)             ：将序列中的元素添加到列表中 ，序列可以是列表，字符串、元祖--- 列表修改 ---lst[index] = value      ： 进行列表赋值--- 列表删除 ---clear()                 : 删除列表内的所有元素pop()                   : 删除列表内最后的一个元素remove(obj)             : 移除列表的某个值=== 字典新增(插入)fromkeys(seq,[val])     : 以seq中元素作为键，val为字典值作为初始值，创建新字典--- 字典修改 ---dct[key] = value        : 对字典中的key赋值update(dict2)           : 将dict2的键值对更新到当前字典--- 字典删除 ---clear()                 : 删除字典内所有的元素pop(key)                : 删除字典内给定键的值popitem()               : 删除字典中的最后一个键值对 ，这个像列表中的pop方法=="""# 列表定义lst1 = [1,2,3]lst2 = ['a','b']# 1.1 列表元素新增lst1.append(4)print(lst1)             # 返回 : [1,2,3,4]lst1.insert(1,5)print(lst1)             # 返回 : [1, 5, 2, 3, 4]   将5插入到第二个位置lst1.extend(lst2)print(lst1)             # 返回 : [1, 5, 2, 3, 4, 'a', 'b']# 1.2 列表元素修改lst1[0] = 'xyz'print(lst1)             # 返回 : ['xyz', 5, 2, 3, 4, 'a', 'b']# 1.3 列表元素删除lst1.pop()print(lst1)            # 返回 ：['xyz', 5, 2, 3, 4, 'a']lst1.remove('xyz')print(lst1)            # 返回 : [5, 2, 3, 4, 'a']lst1.clear()print(lst1)            # 返回 : []# 2.1 字典元素新增tp = ('a','b','c')dct = dict.fromkeys(tp)print(dct)              # 返回 : {'a': None, 'b': None, 'c': None}dct1 = dict.fromkeys(tp,100)print(dct1)             # 返回 : {'a': 100, 'b': 100, 'c': 100}# 2.2 字典元素修改dct1['a'] = 20print(dct1)             # 返回 : {'a': 20 'b': 100, 'c': 100}dct1.update({'d':'abc','e':'tt'})print(dct1)             # 返回 ：{'a': 20, 'b': 100, 'c': 100, 'd': 'abc', 'e': 'tt'}# 2.3 字典元素删除dct1.popitem()print(dct1)             # 返回 : {'a': 20, 'b': 100, 'c': 100, 'd': 'abc'}dct1.pop('b')print(dct1)             # 返回 : {'a': 20, 'c': 100, 'd': 'abc'}dct1.clear()print(dct1)             # 返回 : {}# 字典 和 列表"""=== 列表查询通过下标获取        index(obj)              : 查找值对应的下标 count(obj)              ：统计某个值在列表中出现的次数--- 列表排序 ---sort()                  : 列表排序--- 列表翻转 ---reverse()               ：列表翻转=== 字典查询get()                   : 以seq中元素作为键，val为字典值作为初始值，创建新字典keys()                  : 返回字典中所有的键values()                : 返回字典中所有的值items()                 : 返回字典中所有的键值对"""# 列表定义lst1 = ['a','c','c','a','b','a']# 1 列表元素查询print(lst1[1])           # 返回 ：2print(lst1.index('a'))   # 返回 : 3print(lst1.count('a'))   # 返回 : 2lst1.sort()print(lst1)              # 返回 : ['a', 'a', 'a', 'b', 'c', 'c']lst1.reverse()print(lst1)              # 返回 : ['c', 'c', 'b', 'a', 'a', 'a']# 字典定义dct = {'a':1,'b':2,'c':3}# 2. 字典查询print(dct.get('a'))      # 返回 ：1print(dct.keys())        # dict_keys(['a', 'b', 'c']) ，取出所有键，可以通过for循环print(dct.values())      # dict_values([1, 2, 3])，取出所有值，可以通过for循环print(dct.items())       # dict_items([('a', 1), ('b', 2), ('c', 3)]) ，取出所有键值对，可以通过for循环

同时，针对字符串，列表，字典都属于序列 ，那它们之间就会有一些共同点和联系，接下来我们来看看它们的一些共同点：

3.1 公共方法

首先 ，针对它们有的一些公共方法和操作，比如：

len(seq) : 查看序列(字符串/列表/字典)的长度max(seq) : 查看序列(字符串/列表/字典)中的最大值min(seq) ：查看序列(字符串/列表/字典)中的最小值[not] in seq : 查看元素在序列(字符串/列表/字典)中for x in seq : 对序列进行循环

# 列表,字典 ,字符串"""=== 列表、字典、字符串共同方法len(seq)                : 查看序列(字符串/列表/字典)的长度max(seq)                : 查看序列(字符串/列表/字典)中的最大值min(seq)                ：查看序列(字符串/列表/字典)中的最小值[not] in seq            : 查看元素在序列(字符串/列表/字典)中for x in seq            : 对序列进行循环"""# 变量定义lst1 = ['a','b','c','d']str1 = "abcd"dct = {'a':1,'b':2,'c':3,'d':4}# 1.查看长度print("列表长度:",len(lst1))         # 返回 ：列表长度: 4print("字符串长度:",len(str1))       # 返回 ： 字符串长度: 4print("字典长度:",len(dct))          # 返回 : 字典长度: 4# 2.查看最大值print("列表最大值:",max(lst1))         # 返回 ：列表最大值: dprint("字符串最大值:",max(str1))       # 返回 ：字符串最大值: dprint("字典最大值:",max(dct))          # 返回 : 字典最大值: d# 3.查看最小值print("列表最小值:",min(lst1))         # 返回 ：列表最小值: aprint("字符串最小值:",min(str1))       # 返回 ：字符串最小值: aprint("字典最小值:",min(dct))          # 返回 : 字典最小值: a# 4. 查看元素在print("元素b在列表中:",'b' in lst1)         # 返回 ：元素b在列表中: Trueprint("元素b在字符串中:",'b' in str1)       # 返回 ：元素b在字符串中: Trueprint("元素b在字典中:",'b' in dct)          # 元素b在字典中: True

其次 ，它们还有一些相似的用法 ，比如在列表和字符串都有相加的操作 ，也就是两个列表的元素进行相加或者两个字符串的相连 ，那么在字典其实也有类似操作 ，具体如下 ：

+ ： 使用+进行相连操作** : 使用两个**也可以对两个字典进行相连 。

# 列表,字典 ,字符串"""=== 列表、字典、字符串相连操作+           : 列表，字符串的相连操作**          ：字典的相连操作"""# 变量定义lst1 = ['a','b','c','d']lst2 = [1,2]str1 = "abcd"str2 = '12'dct1 = {'a':1,'b':2,'c':3,'d':4}dct2 = {'e':5,'g':6}# 进行相连操作print("字符串相连：",str1 + str2)               # 返回 ：字符串相连: abcd12print("列表相连:",lst1 + lst2)                 # 返回 ： 列表相连: ['a', 'b', 'c', 'd', 1, 2]print("字典相连:",{**dct1,**dct2})             # 返回 : 字典相连: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'g': 6}

当然，这三者之间也都有相互转化的需求 ，它们都可以通过一些方法进行直接转化，以下为相互转化的示意图 。

# 列表,字典 ,字符串"""=== 列表、字典、字符串间的相互转化list()              : 将其它类型转化为列表str()               : 将其它类型转化为字符串dict()              : 将其它类型转化为字典 ,需要借助于zip函数join()              : 将字符串加工后以列表返回eval()              : 执行表达式函数 ，如：可以将字符串形式的字典转化成字典 """# 变量定义lst1 = ['a','b','c','d']lst2 = [1,2,3,4]str1 = "abcd"str2 = "{'a':1,'b':2,'c':3,'d':4}"dct1 = {'a':1,'b':2,'c':3,'d':4}# 进行相互转化操作print("将字符串str1转化为列表:",list(str1))                   # 返回： 将字符串str1转化为列表: ['a', 'b', 'c', 'd']print("将列表lst1转化为字符串:","".join(lst1))                # 返回： 将列表lst1转化为字符串: abcdprint("将列表lst1,lst2转化为字典:",dict(zip(lst1,lst2)))     # 返回: 将列表lst1,lst2转化为字典: {'a': 1, 'b': 2, 'c': 3, 'd': 4}print("将字典dct1转化为列表:",list(dct1))                    # 返回 ：将字典dct1转化为列表: ['a', 'b', 'c', 'd']print("将字典dct1转化为字符串:",str(dct1))                   # 返回 : 将字典dct2转化为字符串: {'a': 1, 'b': 2, 'c': 3, 'd': 4}print("将字符串str2转化为字典:",eval(str2))                  # 返回 ：将字符串str2转化为字典: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

最后，让我们再总结一下，以上几个数据类型的主要使用场景 ，

4.1 场景总结

字符串

字符串处理后产生一个新的字符串 ，也就是上面介绍到的字符串处理字符串判断 ，返回bool类型 ，也就是上面介绍到的字符串判断字符串转化 ，可以将字符串转化成其它类型 ，如列表和字典等可以将其它类型转化为字符串，如列表和字典等字符串循环，获取长度等 。

列表/字典

对列表/字典内的元素进行增、删、改、查 ，只是针对当前内的列表/字典内元素的变化。列表相连 ，列表/字典复制操作等，可以形成一个新的列表/字典 。列表转化成其它类型 将列表转化为其它类型 ，如字符串和字典将其它类型转化为列表，如字符串和列表列表循环 ，获取长度等 。4.2 其它用法

除此之外 ，字符串内如果是一个表达式，函数等。那么 ，字符串也有对应的方法可以进行处理 ; 同样列表和字典内也可以是表达式 ，即生成式 。接下来，我们就介绍下这几种使用使用方式 ：

用法介绍：

eval() : 执行一个字符串表达式exec() :执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。列表推导式 ：可以生成一个新的列表字典推导式 ： 可以生产一个新的字典使用{}+[]来实现条件判断

eval和exec介绍

# eval , exec"""=== 列表、字典、字符串间的相互转化eval()              : 执行一个字符串中的表达式exec()              : 执行储存在字符串或文件中的Python语句"""a = 3# 调用eval方法print("数学公式的计算:",eval("a * 7"))                              # 返回: 21print("直接调用函数:",eval("pow(2,2)"))                             # 返回: 4print("进行的条件判断:",eval("'hello' if a > 2 else 'world'"))      # 返回: hello# 调用exec方法exec ("print('hello python')")                                  # 返回 : hello pythonx = """for i in range(3):    print(i,end=" ")"""exec (x)                                                       # 返回 : 0 1 2

列表推导式

#语法：    [ operation(x) for x in list condition ]    说明 ，最外面是一个列表，内部是一个for循环语句 ，最前面是返回值#实例    print([random.randint(1,10)+x for x in range(0,10) if x % 2 == 0])#结果：    [3, 3, 14, 15, 12]#说明：    #对列表推导式常使用的几种用法    用法1：[x for x in iterable ]                  #循环后直接打印    用法2：[x for x in iterable if condition(x) ]  #对x的条件判断    用法3：[operation(x) for x iterable if condition(x)]  #对x条件判断后，再对x进行运算    用法4: [operation(x,y) for x in iterable for y in iterable1] #嵌套循环，对x,y进行运算

字典推导式

#语法：    {<operation_key:operation_value> for key,value in dict condition }       说明，最外面是一个字典，内部是for循环的字典 ，返回的是键值对#实例：    d = {'chinese': 88, 'math': 92, 'english': 93, 'history': 84}    print("成绩大于90分的科目：", {k: '优秀' for k, v in d.items() if v >= 90})#输出    成绩大于90分的科目： {'math': '优秀', 'english': '优秀'}#说明：    for循环后的表达式可以是条件表达式或者循环表达式，主要是进行筛选或嵌套循环    返回结果是一个根据表达式运算后生成出来的新字典 。

使用{}+[]来实现条件判断

#语法：    {True: <return_true>, False: <return_false>}[<condition_expression>]#实例：    score = 92    print({True:'优秀',False:'良好'}[ score >= 90 ])#结果：    优秀#说明：    在[]中写条件语句，在()中写返回为真和返回为假的值，一定要注意顺序