Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。

一.列表

=====================================================
1.列表的定义及格式：

列表是个有序的，可修改的，元素用逗号隔开，用中括号包围的序列。

格式：变量名 = [ 元素1，元素2，元素3...]

作用：存储多个数据

列表推导式:重点

 '''列表推导式'''

 list_t = [i for i in range(10)]

 print(list_t)  # [0,1,2,3,4,5,6,7,8,9]

 '''实例'''

 print('实例：')

 for i in range(101):

     if i % 2 == 0:

         print(i)

 print("等同于实例")

 listDouble = [i for i in range(101) if i % 2 == 0]

 print(listDouble)

2.列表的索引：

通过索引获取表中的书记，索引从0开始

注意：不要索引越界

s = [ 'hello',a,b,c ]

print(s[1])

输出结果：a

用for循环遍历列表：

name = [ 'zs','ls','ww' ]

for i in name:

print( i )

输出结果：zs

3.列表的添加：append(), insert(), extend() 方法。

 # append

 lst = ['悟空','八戒','唐僧']       

 lst.append('白骨精')      # append   向列表末尾增加指定元素

 print(lst)

 # 输出结果：   ['悟空', '八戒', '唐僧', '白骨精']

 -------------------------------------------------------------------------------------------

  # insert

 lst = ['悟空','八戒','唐僧']

 lst.insert(1,'白骨精')     # insert  往列表制定位置添加制定元素，负索引倒叙插入。超过索引插入末尾

 print(lst)

 # 输出结果： ['悟空', '白骨精', '八戒', '唐僧']

 ------------------------------------------------------------------------------------------

 #extend

 lst = ['悟空','八戒','唐僧']

 lst1 = ['悟空','八戒','唐僧','悟空']

 lst.extend(lst1)                # 将一个列表中的元素添加到另一个列表的尾部合并，不会去重。

 print(lst)

 # 输出结果： ['悟空', '八戒', '唐僧', '悟空', '八戒', '唐僧', '悟空']

4.列表的删除：pop()，remove()，clear()，del 方法。

 # pop  删除指定索引位上的元素，默认删除-1的数据

 lst = ['悟空','八戒','唐僧']

 lst.pop(1)

 print(lst)

 输出结果：['悟空', '唐僧']

 lst = ['悟空','八戒','唐僧']

 lst.pop()

 print(lst)

 输出结果：['悟空', '八戒']

 -----------------------------------------------------------------------------------------

 # remove 从左往右删除指定的元素，

 lst = ['悟空','八戒','唐僧']

 lst.remove('八戒')

 print(lst)

 # 输出结果：['悟空', '唐僧']

 -----------------------------------------------------------------------------------------

 # clear   清空列表中所有的元素，返回一个空列表

 lst = ['悟空', '八戒', '唐僧']

 lst.clear()

 print(lst)

 输出结果：[ ]

 -----------------------------------------------------------------------------------------

 # del    删除整个列表或列表的数据，del是python内置功能，不是列表独有的

 lst = ['悟空', '八戒', '唐僧']

 del lst           

 print(lst)

 输出结果：NameError: name 'lst' is not defined   （报错）因为不存在，所有报错
=============================
del 还能指定删除某位置的数据
=============================

 newL = [5, 8, 6, 5, 74, 5, 5, 46, 1]

 del newL[8]  # # 删除指定索引值为8的数据，这里删除最后一个数据1

 print(newL)  # [5, 8, 6, 5, 74, 5, 5, 46]

5.列表的查询：count()，index() 方法。

 # count 返回指定元素在列表的个数

 lst  = ['hello','world','hello','python']

 print(lst.count('hello'))  # 输出2

 lst = ['悟空', '八戒', '唐僧', '悟空']

 num1 = lst.index('悟空')  # index 查看指定数据在列表的索引位置

 print("悟空在", num1)  # 这里输出0

6.列表的修改：直接修改，方式如下：list[要修改的数据的索引值]=新的数据

 lst = ['悟空', '八戒', '唐僧']  

 lst[0] = '白龙马'   # 将列表第一位数值为替换为‘白龙马’

 print(lst)

 输出结果：['白龙马', '八戒', '唐僧']

7.列表的切片：

 '''列表的切片'''

 listCut = [i for i in range(20) if i % 2 != 0]  # 生成0-20所有单数的列表

 print("例子列表", listCut)  # 输出：例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

 # 输出：例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

 print(listCut[0: 6])  # 0到5左边开始索引的数据 左闭右开（左边0是包含索引值，右边6是6之前的索引值）

 # 输出[1, 3, 5, 7, 9, 11]

 print(listCut[::2])  # 每隔2个数字取一个值

 # 输出[1, 5, 9, 13, 17]

 print(listCut[::-1])  # 逆序/反序排序 等同于List.reverse()

 # 输出[19, 17, 15, 13, 11, 9, 7, 5, 3, 1]

 print(listCut[-4:])  # 取后四位，负数是右边开始取

 # 输出[13, 15, 17, 19]

 print(listCut[-4:-1])  # 右边开始取，取后4位到后2位值，左闭右闭，（-4包括，-1包括）

 # 输出[13, 15, 17]

8.列表的排序和翻转:sort()，reverse() 方法。

 sort（） 按照ascii码表顺序进行排序

 lst = ['tom', 'james', 'jerry', 'zs', 'ls']

 lst.sort()

 print(lst)  # 从小到大排序

 输出结果：['james', 'jerry', 'ls', 'tom', 'zs']

 lst.sort(reverse=True)  # 有大到小排序

 print(lst)

 输出结果：['zs', 'tom', 'ls', 'jerry', 'james']

 ------------------------------------------------------------------------------------

 reverse()  将列表翻转（逆序）

 lst = ['tom', 'james', 'jerry', 'zs', 'ls']

 lst.reverse()

 print(lst)

 输出结果：['ls', 'zs', 'jerry', 'james', 'tom']

9.列表的拷贝：copy()方法。

 浅拷贝：

 lst1 = ['西施','貂蝉',['悟空','八戒']

 lst2 = lst1.copy()   #将lst1 的内容拷贝一份给lst2,  两者的id 不一样

 print(lst2)

 lst2[0] = '杨贵妃'   #lst2 中的西施改成杨贵妃

 print(lst2)

 输出结果：['西施', '貂蝉', ['悟空', '八戒']

          ['杨贵妃', '貂蝉', ['悟空', '八戒']

 ------------------------------------------------------------------------------------

 深拷贝：

 import copy

 lst1 = ['西施','貂蝉',['悟空','八戒']

 lst2 = copy.deepcopy(lst1)

 print(lst2)

 lst2[0] = '杨贵妃'

 print(lst2)

 输出结果：['西施', '貂蝉', ['悟空', '八戒']

          ['杨贵妃', '貂蝉', ['悟空', '八戒']

二.元祖

=====================================================
1.元组的定义及特点:

定义：

通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。

通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst)

特点：

元组是有序的，不能更改的，由于元组不可变，所以遍历元组要比列表快。

2.元组的访问：

通过索引，默认从0开始

 通过索引，默认从0开始

 tup = (1,2.2,True,'hello')  #  获得2.2的值，一定要注意索引越界的问题

 print(tup[1])

 # 输出结果：2.2

 -------------------------------------------------------------------------------------------

 通过切片：

 tup = (1,2.2,True,'hello')

 print(tup[0:4:2])

 # 输出结果：(1,True)

 -----------------------------------------------------------------------------------------

 访问多维元组：

 tup = (('zs',10),('ls',11),('ww',12))

 print(tup[1][0])

 # 输出结果：ls

3.使用多个变量来接受元组的值：

 tup = (('zs',10),('ls',11),('ww',12))

 name,age,height,weight = ('zs',18,1.64,150)

 print(name)

 print(age)

 print(height)

 print(weight)

 for name, age in tup:     #for 循环遍历多重元组，注意变量的数目一致性

     print(name,age)

 输出结果：          zs

                    18

                    1.64

                    150

                    zs 10

                    ls 11

                    ww 12

4.元组的方法：index()，count()，len() 方法。

 tup = ('a','b','c','c','b','a','x')

 print(tup.index('b'))  # index() 获取数据在元组的索引值

 print(tup.index('a',2,len(tup)))   # len()获取元组的长度值

 print(tup.count('a'))  # count() 获取数据在元组的总个数

 输出结果： 1

          5

          2

5.一个逗号的魅力：

 tup = (1,)

 print(tup)  # 输出结果（1，）

 tup1 = (1)

 print(tup1)  # 输出结果 1

三.字典

=====================================================

1.字典的定义及格式：

定义：字典是一个无序的，可以修改的，元素呈键对值的形式，以逗号分隔，大括号包围的序列。

格式：变量名={key：value，key：value}

注意：字典中的key是不可变的类型，value是可变类型的

定义如下：

 # 字典是无序的数据集合

 # 键（key）值（value）对

 # 键只能使用字符串，元组 ，数字（不可变），值可以是任何的数据类型

 tony = {

     "name": "TONY",

     "age": 27,

     "height": 1.73,

     "weight": 55,

       6: (6,),

       (7,): ()

 }

 print(tony)

 # 输出为：{'name': 'TONY', 'age': 27, 'height': 1.73, 'weight': 55, 6: (6,), (7,): ()}

取值如下：

 tony_dic = {"name": 'tony', "height": 1.73, (6,): (7,)}

 # 字典的取值

 print(tony_dic["name"])  # 输出tony

 print(tony_dic[(6,)])  # 输出(7,)

2. 字典的增加：setdefault() 方法。

 # setdefault（）键存在就不添加，不存在就添加默认的值。

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 dic.setdefault('weight', 170)  # 键存在就不添加，不存在就添加默认的值。

 print(dic)

 dic.setdefault('weight', 180)

 print(dic)

 输出结果：{'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}

 {'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}

 ---------------------------------------------------------------------------------------

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 dic['name'] = 'ww'  # 根据key键来设置值，如果key存在就直接覆盖原有的值

 print(dic)

 输出结果： {'name': 'ww', 'age': 10, 'height': 1.75}

3.字典的删除：pop()，popitem()，clear()，del 方法。

 pop()

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 dic.pop('name')   # 根据键删除值

 print(dic)

 输出结果： {'age': 10, 'height': 1.75}

 ------------------------------------------------------------------------------------------

 popitem()

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 dic.popitem()   # 随机删除一个键值对

 print(dic)

 输出结果：{'name': 'zs', 'age': 10}

 -----------------------------------------------------------------------------------------

 clear()

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 dic.clear()   #  清空字典里所有的键值对

 print(dic)

 输出内容：{}  # 字典还是存在的，只是没有数据，所有输出空字典。

 =======================================

 del dic  # 字典删除

 print（dic） # 字典删除了，所有输出会报错，找不到字典

 输出结果：NameError: name 'dic' is not defined  （报错）

4.字典的修改：使用键修改或者update()方法。

 # 使用key修改：

  dic = {'name':'zs','age':10,'height':1.78}

  dic['name'] = '张三'

  print(dic)

 输出结果： {'name':'张三','age':10,'height':1.78}

 ---------------------------------------------------------------------------------------

 update（）    按照字典的格式更新键的内容，若果字典不存在这个键，就创建这个键和值

 dic = {'name': 'zs', 'age': 10, 'height': 1.78}

 dic1 = {'name':'张三','weight':152}

 dic.update(dic1)

 print(dic)

 输出结果：{'name': '张三', 'age': 10, 'height': 1.78, 'weight': 152}

5.字典的查找：get()，keys()，values()，items()，len()方法。

 c = {'name': 'zs', 'age': 10, 'height': 1.78}

 print(dic.get('name'))     # get()根据键来获取相应的值，如果键不存在，默认返回None

 print(dic.keys())          # 返回一个包含字典所有key的列表

 print(dic.values())        # 返回一个包含字典所有value的列表

 print(dic.items())         # 返回字典键值，返回呈元组的形式

 print(len(dic))            # 测量字典键值对的个数，注意是键值对。

 输出结果：

           zs

           dict_keys(['name', 'age', 'height'])

           dict_values(['zs', 10, 1.78])

           dict_items([('name', 'zs'), ('age', 10), ('height', 1.78)])

           3

6.for 循环及字典的遍历：keys()，values()，items() 方法，其中items()方法有两种遍历方式。

 dic = {'name': 'zs', 'age': 10, 'height': 1.75}

 # 获取所有的key

 for key in dic:

     print(key)           

 for key in dic.keys():

     print(key)

 输出结果：

          name

          age

          height

 -------------------------------------------------------------------------------------

 # 获取所有的value

 for value in dic.values():

     print(value)

 输出结果：zs

          10

          1.75

 -------------------------------------------------------------------------------------

 # 获取所有的键值对，并以元组的形式返回：

 for item in dic.items():

     print(item)

 输出结果：

          ('name', 'zs')

          ('age', 10)

          ('height', 1.75)

 # 字典的遍历：

 for key,value in dic.items():

     print(key,value)

 输出结果：

           name zs

           age 10

           height 1.75
------------------------------------

7:字典的各种排序，sorted()方法运用。后面可以接keys()，values()，items()，还有lamda方法

 dic_height = {"tony": 1.73,

               "lucy": 1.88,

               "lili": 1.66,

               "kity": 1.70

              }
-------------------------------------

 '''输出value值的列表'''

 v = sorted(dic_height.values())  # 通过value排序，从小到大,升序排序

 v2 = sorted(dic_height.values(), reverse=True)  # 通过value排序，从小到大,降序排序
------------------------------------------------------------------------------------

 '''输出key值的列表'''

 d = sorted(dic_height.keys())   # 通过key顺序升序排序

 d2 = sorted(dic_height.keys(), reverse=True)  # 通过key顺序降序排序

 k = sorted(dic_height)  # 通通过key顺序升序排序(默认排序key)

 k2 = sorted(dic_height, reverse=True)  # 通通过key顺序降序排序(默认排序key)
------------------------------------------------------------------------------------

 '''输出（'key',value)为元组的数据列表'''

 i = sorted(dic_height.items())  # 通过key顺序排升序，输出元组数据类型的列表

 i2 = sorted(dic_height.items(), reverse=True)  # 通过key顺序排降序，输出元组数据类型的列表

 t = sorted(dic_height.items(), key=lambda item: item[1])  # 1和-1结果一样

 # 通过value顺序排升序，输出元组数据类型的列表

 t2 = sorted(dic_height.items(), key=lambda item: item[1], reverse=True)  # 1和-1结果一样

 # 通过value顺序排降序，输出元组数据类型的列表

 ---------------------------------------------------------------------------------------

 ###############################################

 print(v)  # 输出为：[1.66, 1.7, 1.73, 1.88]

 print(v2)  # 输出为：[1.88, 1.73, 1.7, 1.66]

 print(d)  # 输出为：['kity', 'lili', 'lucy', 'tony']

 print(d2)  # 输出为：['tony', 'lucy', 'lili', 'kity']

 print(k)  # 输出为：['kity', 'lili', 'lucy', 'tony']

 print(k2)  # 输出为：['tony', 'lucy', 'lili', 'kity']

 print(i)  # 输出为:[('kity', 1.7), ('lili', 1.66), ('lucy', 1.88), ('tony', 1.73)]

 print(i2)  # 输出为:[('tony', 1.73), ('lucy', 1.88), ('lili', 1.66), ('kity', 1.7)]

 print(t)  # 输出为:[('lili', 1.66), ('kity', 1.7), ('tony', 1.73), ('lucy', 1.88)]

 print(t2)  # 输出为:[('lucy', 1.88), ('tony', 1.73), ('kity', 1.7), ('lili', 1.66)]

其实还有更复杂的排序，关键在于lamda方法的使用这里先不讲lamda方法。

四.字符串

=====================================================

1.字符串的创建定义以及遍历，for...in... 方法：

字符串是有序的，不可更改的，元素用引号包围的序列。

三引号，双引号或单引号中的数据就是字符串。例如："hello" 'world'

 str1 = "hello python"  # 空格也占用字符

 str2 = "我们是8期的学员"

 print(str1[5])  # 空格被打印，索引5是空格

 print(str1[3])  # 打印顺数索引3的数据 打印l

 print(str1[-1])   # 打印逆数第一个数据，打印n

 print(str1[::-1])  # 逆序打印（翻转），打印nohtyp olleh

 for char in str2:  # 字符串遍历

     print(char)  # 逐个竖着输出"我们是8期的学员"

 我

 们

 是

 8

 期

 的

 学

 员

2.字符串的统计操作，len()，count()，index()方法。

 str1 = "hello python"

 # 字符串长度的统计

 print(len(str1))  # 输出12

 # 字符出现的次数

 print(str1.count("thon"))  # 输出1

 print(str1.count("l"))  # 输出2

 print(str1.count("abcd"))  # 输出0

 # 某一个字符串出现的位置

 print(str1.index("llo"))  # "llo"里面的第一个字母出现的索引位置 输出2

 print(str1.index("abcd"))  # 会报错substring not found，因为abcd不存在

3.字符串的查找：count()，find()，rfind()，index()，rindex()方法。

 s = 'Hello world Python'   # 注意：字符串中的空格也算在索引内

 print(s.count('o'))        # 计算'o'在是中的个数。输出3

 print(s.find('l'))         # 查找，返回从左第一个指定字符的索引，找不到返回-1，输出2

 print(s.find('c'))         # 字符串中没有发现就返回-1 输出-1

 print(s.rfind('o'))        # 字符串从右至左找第一个字符，但是索引是从左往右索引。输出16

 print(s.index('h'))        # 寻找指定字母在字符串的位置的索引，找不到会报错。输出0
 

 print(s.rindex('h'))       # 和rfind类似，但是找不到会报错 输出15

4.字符串的拆分和连接：

拆分：split()，partition()，splitlines()，

 s = 'Hello world Python'

 print(s.split('w'))    # 按照指定内容进行拆分，分为指定部分前 和指定部分后两部分。返回列表形式。

 输出结果： ['Hello ', 'orld Python']

 print(s.partition('orl'))   # 按照指定内容进行拆分，分为指定部分前 ，指定部分和 指定部分后三部分，返回元组形式。

 输出结果： ('Hello w', 'orl', 'd Python')

 s = 'Hello\n world\n Python'

 print(s.splitlines())               # 按照换行符分割，返回列表的形式

 输出结果：  ['Hello', ' world', ' Python']

 print(s.splitlines(keepends=False))  # keepends=False   默认不显示换行符,返回列表的形式

 输出结果：['Hello', ' world', ' Python']

 print(s.splitlines(keepends=True))  # keppends=True       默认显示换行符，返回列表的形式

  输出结果：['Hello\n', ' world\n', ' Python']

连接：join()方法。

 str1 = "    \t\n登鹳雀楼\n\t王之涣\r\n 白日依山尽  \t \n黄河入海流\t\n 欲穷千里目\n\r\t更上一层楼"

 print(str1)

 输出很乱，如下：

 登鹳雀楼

     王之涣

  白日依山尽

 黄河入海流

  欲穷千里目

     更上一层楼

 #  拆分字符串

 poemList = str1.split()  # 默认空白字符分割()里面可以写分割字符str.split("分割关键字符")

 print(poemList)

 输出：['登鹳雀楼', '王之涣', '白日依山尽', '黄河入海流', '欲穷千里目', '更上一层楼']

 # 字符串的合并

 ret = " ".join(poemList)  # 用空格连接

 print(ret)

 输出：登鹳雀楼 王之涣 白日依山尽 黄河入海流 欲穷千里目 更上一层楼

 ret = ",".join(poemList)  # 用，连接

 print(ret)

 输出：登鹳雀楼,王之涣,白日依山尽,黄河入海流,欲穷千里目,更上一层楼

5.字符串的替换：一般使用replace()方法就可以，translate,maketrans合用比较复杂，这里不介绍。

 s = 'Hello world Python'

 print(s.replace('o', ''))  # 将字符串中所有的o 替换成0 默认全部替换

 print(s.replace('o', '', 2))  # 第三个参数，是指定替换的个数

 # 输出结果：     Hell0 w0rld Pyth0n

 #               Hell0 w0rld Python

  ----------------------------------------------------------------------------------

 # translate, maketrans

 # 按照对应关系来替换内容

 s = 'Hello world,'

 a = 'world,'

 b = 'python'

 ret = str.maketrans(a, b)

 s1 = s.translate(ret)  # 必须一一对应

 print(s1)

 # 输出结果: Hehhy python

6.字符串的修饰：center()，ljust()，rjust()，zfill()方法。

 # center：将字符串按指定长度居中，若果不能左短右长，可以指定填充内容，默认以空格填充。

 s = 'hello'

 print(s.center(10,'*'))   # 填充长度是10 ，用 * 填充

 输出结果：**hello***

 -------------------------------------------------------------------------------------

 # ljust：让字符串在指定的长度左齐，可以指定填充内容，默认以空格填充

 # rjust：让字符串在指定的长度右齐，可以指定填充内容，默认以空格填充。

 # ljust 和 rjust

 s = 'hello'

 print(s.ljust(15, '~'))

 print(s.rjust(15, '*'))

 输出结果：hello~~~~~~~~~~

          **********hello

 -----------------------------------------------------------------------------------------

 # zfill:  将字符串填充到指定长度，不足的地方从左开始填充0

 s = 'hello'

 print(s.zfill(10))

 输出结果：00000hello

 -----------------------------------------------------------------------------------------

 # strip: 去除空白符

 poem = [

     "\t\n你好大玛",

     "哥哥，弟弟你好\r",

     "小妹你好",

     "小姐你好\t\n",

 ]

 print(poem)

 输出为：['\t\n你好大玛', '哥哥，弟弟你好\r', '小妹你好', '小姐你好\t\n']

 for poem_str in poem:

      print(poem_str.strip().center(10))  # 空格填充剧中，并去除空白符。

 输出为：

    你好大玛

  哥哥，弟弟你好

    小妹你好

    小姐你好

7.字符串的变形转换：upper()，lower()，swapcase()，title()，capitalize()，expandtabs()方法。

 # upper   将字符串中所有字母转换为大写

 # lower   将字符串中所有字母转化为小写

 # swapcase 将字符串中字母大小写互换

 # title    将字符串中单词首字母转化为大写 

 # capitalize 只有字符串首字母大写

 # expandtabs 将字符串中（'\t'）符号转化为tab(4个空格）

 # -------------------------------------------------------------------------------------

 s = 'Hello python'

 print(s.upper())

 print(s.lower())

 print(s.swapcase())

 print(s.title())

 print(s.capitalize())

 s1 = 'hello\tpython'

 print(s1.expandtabs())

 -----------------------------------------------------------------------------------------

输出结果：HELLO PYTHON
hello python

hELLO PYTHON
Hello Python
Hello python
hello python

8.字符串的格式化：format()方法。

# format()用法：

# 相对基本格式化输出采用'%'的方法，format()功能更强大，

# 通过传入参数进行格式化，并使用大括号{}代替 %

# 1.使用位置参数：位置必须一一对应：

name = 'zs'

age = 19

print('大家好，我叫{}，今年{}岁'.format(name, age))  # 位置必须一一对应

print('大家好，我叫{0}，我叫{0}，我叫{0}，今年{1}岁'.format(name, age)) #索引位置对应参数

输出结果：大家好，我叫zs，今年19岁

        大家好，我叫zs，我叫zs，我叫zs，今年19岁

-----------------------------------------------------------------------------------------

# 2.使用关键字参数：

print('我叫{name}，今年{age}岁了'.format(name='zs', age=19))

输出结果：我叫zs，今年19岁了

9.字符串的判断：

大部分判断都是返回bool型

 # 判断字符串中是否只包含数字(详细)

 numStr = ""

 numStr1 = "2312.22"

 numStr2 = "四"

 numStr3 = "\u00b2"

 numStr4 = "⑴"         # 输入法V+数字产生的数字符合

 # isdecimal只可以判断整数型字符串,不能判断小数等其他类型

 print("isdecimal分析结果")

 print(numStr.isdecimal())  # True

 print(numStr1.isdecimal())  # False

 print(numStr2.isdecimal())  # False

 print(numStr3.isdecimal())  # False

 print(numStr4.isdecimal())  # False

 # isdigit可以判断整数型字符串,"\u00b2",⑴,但不能判断小数，汉字数字(大写)

 print("isdigit分析结果")

 print(numStr.isdigit())  # True

 print(numStr1.isdigit())  # False

 print(numStr2.isdigit())  # False

 print(numStr3.isdigit())  # True

 print(numStr4.isdigit())  # True

 # isnumeric可以判断整型数字，汉字的数字(大写数字)，⑴，"\u00b2",但不能判断小数

 print("isnumeric分析结果")

 print(numStr.isnumeric())  # True

 print(numStr1.isnumeric())  # False

 print(numStr2.isnumeric())  # True

 print(numStr3.isnumeric())  # True

 print(numStr4.isnumeric())  # True

 -----------------------------------------------------------------------------------------

 '''其他判断类型'''

 s = 'Hello123'

 print(s.isalnum())  # True       判断字符串是否完全由数字和字母组成

 s1 = 'abcde'

 print(s1.isalpha())  # True        判断字符串是否完全由字母组成

 s2 = 'abc123'

 print(s2.isdigit())  # False          判断zfc是否完全由数字组成，上面已经详细介绍

 s3 = '  abcDE'

 print(s3.isupper())  # False        判断字符串内字符是否全是大写

 s4 = 'abcd'

 print(s4.islower())  # True        判断字符串内字符是否全是小写

 s5 = 'Hello Python'

 print(s5.istitle())  # True       判断字符串中的单词首字母是否大写

 s6 = '     '

 print(s6.isspace())  # True        判断字符串是否完全由空格组成

 s7 = 'hello python'

 print(s7.startswith('h', 2, 4))  # False      判断字符串在指定范围内是否已指定字符开头

 print(s7.endswith('lo', 0, 5))  # True       判断字符串在指定范围内是否已指定字符结尾

 s8 = "hello world"

 print(s8.startswith("hello"))  # True       判断是否某个字符串开头

 print(s8.endswith("ld"))  # True      判断是否某个字符串结尾

方法有如下：

isdecimal()，isdigit()，isnumeric()，isalnum()，isalpha()，isupper()，islower()，istitle()，isspace()，startswith()，endswith()。

=====================================================================================================================================================
学习还有复查资料整合出来的，留着以后工作有用，或者学习经常查看，这里学习安之老师布置这个作业！虽然整合了我一天时间！-_-!

巴特西

Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。

二.元祖

三.字典

四.字符串

最新文章

热门文章