在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())       # 返回True
print(str0.isalpha())       # 返回True
print(str5.isalnum())       # 返回True
print(str6.isspace())       # 返回True
print(str4.isnumeric())     # 返回True
print(str1.islower())       # 返回True
print(str2.isupper())       # 返回True
print(str7.istitle())       # 返回True

print(str1.startswith("hello"))     #返回True
print(str1.endswith("world"))       #返回True

字符串处理类包括：

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

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

# 字符串处理方法
"""
====字符串大小写转化处理
upper()             : 转化小写字母为大写字母
lower()             : 转化大写字母为小写字母
capitalize()        : 把字符串的第一个字母大写,其它字母变小写
swapcase()          : 翻转字符串的大小写
expandtabs()        : 把字符串中的tab符号转化为空格，tabs默认的空格是8

====去除或填充空格
strip()             : 删除两边的字符串 
lstrip()            : 删除字符串前面的空格
rstrip()            : 删除字符串后面的空格
center(width)       : 把一个字符串居中，并使用空格填充成至width新的字符串
zfill(width)        : 返回长度width的字符串，原字符串向右对齐，前面填充0
ljust(witdh)        : 返回长度width的字符串，源字符串左对齐，剩余的用空格填充
"""


# 字符串定义
str1 = "hello world"
str2 = "HELLO WORLD"
str3 = "hello WORLD"
str4 = "hello   world   "
str5 = " Hello World "

# 方法调用
print(str1.upper())             # 返回: HELLO WORLD
print(str2.lower())             # 返回: hello world
print(str3.capitalize())        # 返回: Hello world
print(str3.swapcase())          # 返回: HELLO world
print(str4.expandtabs())        # 返回: hello   world

print(str5.strip())             # 返回: Hello World
print(str5.lstrip())            # 返回: Hello World
print(str5.rstrip())            # 返回:  Hello World
print(str5.center(20))          # 返回：     Hello World
print(str5.zfill(20))           # 返回： 0000000 Hello World
print(str5.ljust(20))          # 返回：  Hello World

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

# 字符串处理方法
"""
====字符串查找
find(str)             : 查找str是否包含在整个字符串中，如果找到则返回索引值，否则返回-1
index(str)            : 查找str是否包含在整个字符串中，如果找到则返回索引值，否则报异常
rfind(str)            : 和find()类似，返回字符串最后一次出现的位置，没有匹配到则返回-1
rindex(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'))                   # 返回: 4
print(str1.index('o'))                  # 返回: 4
print(str1.rfind('o'))                  # 返回: 7
print(str1.rindex('o'))                 # 返回: 7
print(str1.count('o'))                  # 返回: 2

print(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#d
print(str1.replace('world','python'))   # 返回：hello python


print(str4.encode('utf-8'))             # 返回: b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(str4.encode().decode())           # 返回: 你好
print(str5.format('world'))             # 返回: hello world

2.列表字典

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'] = 20
print(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])           # 返回 ：2
print(lst1.index('a'))   # 返回 : 3
print(lst1.count('a'))   # 返回 : 2
lst1.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'))      # 返回 ：1
print(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.共同属性

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

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))         # 返回 ：列表长度: 4
print("字符串长度:",len(str1))       # 返回 ： 字符串长度: 4
print("字典长度:",len(dct))          # 返回 : 字典长度: 4

# 2.查看最大值
print("列表最大值:",max(lst1))         # 返回 ：列表最大值: d
print("字符串最大值:",max(str1))       # 返回 ：字符串最大值: d
print("字典最大值:",max(dct))          # 返回 : 字典最大值: d

# 3.查看最小值
print("列表最小值:",min(lst1))         # 返回 ：列表最小值: a
print("字符串最小值:",min(str1))       # 返回 ：字符串最小值: a
print("字典最小值:",min(dct))          # 返回 : 字典最小值: a

# 4. 查看元素在
print("元素b在列表中:",'b' in lst1)         # 返回 ：元素b在列表中: True
print("元素b在字符串中:",'b' in str1)       # 返回 ：元素b在字符串中: True
print("元素b在字典中:",'b' in dct)          # 元素b在字典中: True

3.2 相连操作

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

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

# 列表,字典 ,字符串
"""
=== 列表、字典、字符串相连操作
+           : 列表，字符串的相连操作
**          ：字典的相连操作

"""

# 变量定义
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)               # 返回 ：字符串相连: abcd12
print("列表相连:",lst1 + lst2)                 # 返回 ： 列表相连: ['a', 'b', 'c', 'd', 1, 2]
print("字典相连:",{**dct1,**dct2})             # 返回 : 字典相连: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'g': 6}

3.3 相互转化

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

# 列表,字典 ,字符串
"""
=== 列表、字典、字符串间的相互转化
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转化为字符串: abcd
print("将列表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.使用场景

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

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"))                              # 返回: 21
print("直接调用函数:",eval("pow(2,2)"))                             # 返回: 4
print("进行的条件判断:",eval("'hello' if a > 2 else 'world'"))      # 返回: hello


# 调用exec方法
exec ("print('hello python')")                                  # 返回 : hello python

x = """
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进行运算

字典推导式

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