Python基础-列表、元组、字典、字符串(精简解析),全网最齐全。

一.列表

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

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

格式:变量名 = [ 元素1,元素2,元素3…]

作用:存储多个数据

列表推导式:重点

 

 1 '''列表推导式'''
 2 list_t = [i for i in range(10)]
 3 print(list_t)  # [0,1,2,3,4,5,6,7,8,9]
 4 
 5 '''实例'''
 6 print('实例:')
 7 for i in range(101):
 8     if i % 2 == 0:
 9         print(i)
10 
11 print("等同于实例")
12 listDouble = [i for i in range(101) if i % 2 == 0]
13 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

                  ls

                  ww

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

 1 # append 
 2 lst = ['悟空','八戒','唐僧']       
 3  
 4 lst.append('白骨精')      # append   向列表末尾增加指定元素
 5  
 6 print(lst)
 7  
 8 # 输出结果:   ['悟空', '八戒', '唐僧', '白骨精']
 9  
10 -------------------------------------------------------------------------------------------
11  # insert 
12 lst = ['悟空','八戒','唐僧']
13  
14 lst.insert(1,'白骨精')     # insert  往列表制定位置添加制定元素,负索引倒叙插入。超过索引插入末尾
15  
16 print(lst)
17  
18 # 输出结果: ['悟空', '白骨精', '八戒', '唐僧']
19 ------------------------------------------------------------------------------------------
20 #extend
21  
22 lst = ['悟空','八戒','唐僧']
23  
24 lst1 = ['悟空','八戒','唐僧','悟空']
25  
26 lst.extend(lst1)                # 将一个列表中的元素添加到另一个列表的尾部合并,不会去重。
27  
28 print(lst)
29  
30 # 输出结果: ['悟空', '八戒', '唐僧', '悟空', '八戒', '唐僧', '悟空']

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

 1 # pop  删除指定索引位上的元素,默认删除-1的数据
 2  
 3 lst = ['悟空','八戒','唐僧']
 4  
 5 lst.pop(1)
 6  
 7 print(lst)
 8  
 9 输出结果:['悟空', '唐僧']
10  
11 lst = ['悟空','八戒','唐僧']
12  
13 lst.pop()
14  
15 print(lst)
16  
17 输出结果:['悟空', '八戒']
18 -----------------------------------------------------------------------------------------
19 # remove 从左往右删除指定的元素,
20  
21 lst = ['悟空','八戒','唐僧']
22  
23 lst.remove('八戒')
24  
25 print(lst)
26  
27 # 输出结果:['悟空', '唐僧']
28 -----------------------------------------------------------------------------------------
29 # clear   清空列表中所有的元素,返回一个空列表
30  
31 lst = ['悟空', '八戒', '唐僧']
32  
33  
34  
35 lst.clear()
36  
37  
38  
39 print(lst)
40  
41 输出结果:[ ]
42 -----------------------------------------------------------------------------------------
43 # del    删除整个列表或列表的数据,del是python内置功能,不是列表独有的
44  
45  
46 ​lst = ['悟空', '八戒', '唐僧']
47  
48 del lst           
49  
50 print(lst)
51  
52 输出结果:​​​​NameError: name 'lst' is not defined   (报错)因为不存在,所有报错
=============================
del 还能指定删除某位置的数据
=============================
1 newL = [5, 8, 6, 5, 74, 5, 5, 46, 1]
2 del newL[8]  # # 删除指定索引值为8的数据,这里删除最后一个数据1
3 print(newL)  # [5, 8, 6, 5, 74, 5, 5, 46]

 



 5.列表的查询:count(),index() 方法。

1 # count 返回指定元素在列表的个数
2  
3 lst  = ['hello','world','hello','python']
4  
5 print(lst.count('hello'))  # 输出2
1 lst = ['悟空', '八戒', '唐僧', '悟空']
2 num1 = lst.index('悟空')  # index 查看指定数据在列表的索引位置
3 print("悟空在", num1)  # 这里输出0

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

1 lst = ['悟空', '八戒', '唐僧']  
2  
3 lst[0] = '白龙马'   # 将列表第一位数值为替换为‘白龙马’
4  
5 print(lst)
6  
7 输出结果:['白龙马', '八戒', '唐僧']

7.列表的切片:

 1 '''列表的切片'''
 2 listCut = [i for i in range(20) if i % 2 != 0]  # 生成0-20所有单数的列表
 3 print("例子列表", listCut)  # 输出:例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 4 # 输出:例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 5 print(listCut[0: 6])  # 0到5左边开始索引的数据 左闭右开(左边0是包含索引值,右边6是6之前的索引值)
 6 # 输出[1, 3, 5, 7, 9, 11]
 7 print(listCut[::2])  # 每隔2个数字取一个值
 8 # 输出[1, 5, 9, 13, 17]
 9 print(listCut[::-1])  # 逆序/反序排序 等同于List.reverse()
10 # 输出[19, 17, 15, 13, 11, 9, 7, 5, 3, 1]
11 print(listCut[-4:])  # 取后四位,负数是右边开始取
12 # 输出[13, 15, 17, 19]
13 print(listCut[-4:-1])  # 右边开始取,取后4位到后2位值,左闭右闭,(-4包括,-1包括)
14 # 输出[13, 15, 17]

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

 1 sort() 按照ascii码表顺序进行排序
 2  
 3 lst = ['tom', 'james', 'jerry', 'zs', 'ls']
 4  
 5 lst.sort()
 6  
 7 print(lst)  # 从小到大排序
 8  
 9 输出结果:['james', 'jerry', 'ls', 'tom', 'zs']
10  
11  
12 lst.sort(reverse=True)  # 有大到小排序
13  
14  
15 print(lst)
16  
17 输出结果:['zs', 'tom', 'ls', 'jerry', 'james']
18 ------------------------------------------------------------------------------------
19 reverse()  将列表翻转(逆序)
20  
21 lst = ['tom', 'james', 'jerry', 'zs', 'ls']
22  
23 lst.reverse()
24  
25 print(lst)
26  
27 输出结果:['ls', 'zs', 'jerry', 'james', 'tom']

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

 1 浅拷贝:
 2  
 3 lst1 = ['西施','貂蝉',['悟空','八戒']
 4  
 5 lst2 = lst1.copy()   #将lst1 的内容拷贝一份给lst2,  两者的id 不一样
 6  
 7 print(lst2)
 8  
 9 lst2[0] = '杨贵妃'   #lst2 中的西施改成杨贵妃
10  
11 print(lst2)
12  
13 输出结果:['西施', '貂蝉', ['悟空', '八戒']
14          ['杨贵妃', '貂蝉', ['悟空', '八戒']
15  
16 ------------------------------------------------------------------------------------
17  
18 深拷贝:
19  
20 import copy
21  
22 lst1 = ['西施','貂蝉',['悟空','八戒']
23  
24 lst2 = copy.deepcopy(lst1)
25  
26 print(lst2)
27  
28 lst2[0] = '杨贵妃'
29  
30 print(lst2)
31  
32 输出结果:['西施', '貂蝉', ['悟空', '八戒']
33          ['杨贵妃', '貂蝉', ['悟空', '八戒']

 

二.元祖

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

定义:

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

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

特点:

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

2.元组的访问:

通过索引,默认从0开始

 1 通过索引,默认从0开始
 2  
 3 tup = (1,2.2,True,'hello')  #  获得2.2的值,一定要注意索引越界的问题
 4  
 5  
 6 print(tup[1])
 7  
 8 # 输出结果:2.2
 9 -------------------------------------------------------------------------------------------
10 通过切片:
11  
12 tup = (1,2.2,True,'hello')
13  
14 print(tup[0:4:2])
15  
16 # 输出结果:(1,True)
17 -----------------------------------------------------------------------------------------
18 访问多维元组:
19  
20 tup = (('zs',10),('ls',11),('ww',12))
21  
22 print(tup[1][0])
23  
24 # 输出结果:ls

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

 1 tup = (('zs',10),('ls',11),('ww',12))
 2  
 3 name,age,height,weight = ('zs',18,1.64,150)
 4  
 5 print(name)
 6  
 7 print(age)
 8  
 9 print(height)
10  
11 print(weight)
12  
13 for name, age in tup:     #for 循环遍历多重元组,注意变量的数目一致性
14  
15     print(name,age)
16  
17  
18  
19 输出结果:          zs
20                    18
21                    1.64
22                    150
23                    zs 10
24                    ls 11
25                    ww 12

  4.元组的方法:index(),count(),len() 方法。

 1 tup = ('a','b','c','c','b','a','x')
 2  
 3  
 4  
 5 print(tup.index('b'))  # index() 获取数据在元组的索引值
 6  
 7  
 8  
 9 print(tup.index('a',2,len(tup)))   # len()获取元组的长度值
10  
11  
12  
13 print(tup.count('a'))  # count() 获取数据在元组的总个数
14  
15  
16  
17  
18 输出结果: 1
19           
20          5
21              
22          2

5.一个逗号的魅力:

1 tup = (1,)
2  
3 print(tup)  # 输出结果(1,)
4  
5 tup1 = (1)
6  
7 print(tup1)  # 输出结果 1

 

三.字典

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

1.字典的定义及格式:

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

格式:变量名={key:value,key:value}

注意:字典中的key是不可变的类型,value是可变类型的

定义如下:

 1 # 字典是无序的数据集合
 2 # 键(key)值(value)对
 3 # 键只能使用字符串,元组 ,数字(不可变),值可以是任何的数据类型
 4 tony = {
 5     "name": "TONY",
 6     "age": 27,
 7     "height": 1.73,
 8     "weight": 55,
 9       6: (6,),
10       (7,): ()
11 }
12 print(tony)
13 # 输出为:{'name': 'TONY', 'age': 27, 'height': 1.73, 'weight': 55, 6: (6,), (7,): ()}

取值如下:

1 tony_dic = {"name": 'tony', "height": 1.73, (6,): (7,)}
2 # 字典的取值
3 print(tony_dic["name"])  # 输出tony
4 print(tony_dic[(6,)])  # 输出(7,)

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

 1 # setdefault()键存在就不添加,不存在就添加默认的值。
 2 
 3 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
 4 
 5 dic.setdefault('weight', 170)  # 键存在就不添加,不存在就添加默认的值。
 6 
 7 print(dic)
 8 
 9 dic.setdefault('weight', 180)
10 
11 print(dic)
12 
13 输出结果:{'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}
14 
15 {'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}
16 
17 ---------------------------------------------------------------------------------------
18 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
19 
20 dic['name'] = 'ww'  # 根据key键来设置值,如果key存在就直接覆盖原有的值
21 
22 print(dic)
23 
24 输出结果: {'name': 'ww', 'age': 10, 'height': 1.75}

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

 1 pop()
 2  
 3 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
 4  
 5 dic.pop('name')   # 根据键删除值
 6  
 7 print(dic)
 8  
 9 输出结果: {'age': 10, 'height': 1.75}
10 ------------------------------------------------------------------------------------------
11 popitem()
12  
13 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
14  
15 dic.popitem()   # 随机删除一个键值对
16  
17 print(dic)
18  
19  
20 输出结果:{'name': 'zs', 'age': 10}
21  
22 -----------------------------------------------------------------------------------------
23 clear()
24  
25 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
26  
27 dic.clear()   #  清空字典里所有的键值对
28  
29 print(dic)
30  
31  
32 输出内容:{}  # 字典还是存在的,只是没有数据,所有输出空字典。
33 =======================================
34  
35 del dic  # 字典删除
36  
37 print(dic) # 字典删除了,所有输出会报错,找不到字典
38  
39 输出结果:NameError: name 'dic' is not defined  (报错)

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

 1 # 使用key修改:
 2     
 3  dic = {'name':'zs','age':10,'height':1.78}
 4  
 5  dic['name'] = '张三'
 6  
 7  print(dic)
 8  
 9  
10 输出结果: {'name':'张三','age':10,'height':1.78}
11  
12 ---------------------------------------------------------------------------------------
13  
14 update()    按照字典的格式更新键的内容,若果字典不存在这个键,就创建这个键和值
15  
16 dic = {'name': 'zs', 'age': 10, 'height': 1.78}
17  
18 dic1 = {'name':'张三','weight':152}
19  
20 dic.update(dic1)
21  
22 print(dic)
23  
24  
25 输出结果:{'name': '张三', 'age': 10, 'height': 1.78, 'weight': 152}

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

 1 c = {'name': 'zs', 'age': 10, 'height': 1.78}
 2  
 3 print(dic.get('name'))     # get()根据键来获取相应的值,如果键不存在,默认返回None
 4  
 5 print(dic.keys())          # 返回一个包含字典所有key的列表
 6  
 7 print(dic.values())        # 返回一个包含字典所有value的列表
 8  
 9 print(dic.items())         # 返回字典键值,返回呈元组的形式
10  
11 print(len(dic))            # 测量字典键值对的个数,注意是键值对。
12  
13  
14  
15  
16 输出结果:
17           zs
18  
19           dict_keys(['name', 'age', 'height'])
20  
21           dict_values(['zs', 10, 1.78])
22  
23           dict_items([('name', 'zs'), ('age', 10), ('height', 1.78)])
24  
25           3

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

 1 dic = {'name': 'zs', 'age': 10, 'height': 1.75}
 2  
 3 # 获取所有的key
 4  
 5 for key in dic:
 6  
 7     print(key)           
 8  
 9 for key in dic.keys():
10     
11     print(key)
12  
13 输出结果:
14          name
15  
16          age
17  
18          height
19 -------------------------------------------------------------------------------------
20 # 获取所有的value
21  
22 for value in dic.values():
23  
24     print(value)
25  
26 输出结果:zs
27  
28          10
29  
30          1.75
31 -------------------------------------------------------------------------------------
32 # 获取所有的键值对,并以元组的形式返回:
33  
34 for item in dic.items():
35     
36     print(item)
37  
38  
39 输出结果:
40          ('name', 'zs')
41  
42          ('age', 10)
43  
44          ('height', 1.75)
45  
46  
47 # 字典的遍历:
48  
49 for key,value in dic.items():
50  
51     print(key,value)
52  
53  
54 输出结果:
55  
56           name zs
57  
58           age 10
59  
60           height 1.75
------------------------------------

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

 1 dic_height = {"tony": 1.73,
 2               "lucy": 1.88,
 3               "lili": 1.66,
 4               "kity": 1.70
 5              }
-------------------------------------
6 '''输出value值的列表''' 7 v = sorted(dic_height.values()) # 通过value排序,从小到大,序排序 8 v2 = sorted(dic_height.values(), reverse=True) # 通过value排序,从小到大,序排序
------------------------------------------------------------------------------------
9 '''输出key值的列表''' 10 d = sorted(dic_height.keys()) # 通过key顺序序排序 11 d2 = sorted(dic_height.keys(), reverse=True) # 通过key顺序序排序 12 k = sorted(dic_height) # 通通过key顺序序排序(默认排序key) 13 k2 = sorted(dic_height, reverse=True) # 通通过key顺序序排序(默认排序key)
------------------------------------------------------------------------------------
14 '''输出('key',value)为元组的数据列表''' 15 i = sorted(dic_height.items()) # 通过key顺序排序,输出元组数据类型的列表 16 i2 = sorted(dic_height.items(), reverse=True) # 通过key顺序排序,输出元组数据类型的列表 17 t = sorted(dic_height.items(), key=lambda item: item[1]) # 1和-1结果一样 18 # 通过value顺序排序,输出元组数据类型的列表 19 t2 = sorted(dic_height.items(), key=lambda item: item[1], reverse=True) # 1和-1结果一样 20 # 通过value顺序排序,输出元组数据类型的列表 21 --------------------------------------------------------------------------------------- 22 ############################################### 23 print(v) # 输出为:[1.66, 1.7, 1.73, 1.88] 24 print(v2) # 输出为:[1.88, 1.73, 1.7, 1.66] 25 print(d) # 输出为:['kity', 'lili', 'lucy', 'tony'] 26 print(d2) # 输出为:['tony', 'lucy', 'lili', 'kity'] 27 print(k) # 输出为:['kity', 'lili', 'lucy', 'tony'] 28 print(k2) # 输出为:['tony', 'lucy', 'lili', 'kity'] 29 print(i) # 输出为:[('kity', 1.7), ('lili', 1.66), ('lucy', 1.88), ('tony', 1.73)] 30 print(i2) # 输出为:[('tony', 1.73), ('lucy', 1.88), ('lili', 1.66), ('kity', 1.7)] 31 print(t) # 输出为:[('lili', 1.66), ('kity', 1.7), ('tony', 1.73), ('lucy', 1.88)] 32 print(t2) # 输出为:[('lucy', 1.88), ('tony', 1.73), ('kity', 1.7), ('lili', 1.66)]

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

四.字符串

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

1.字符串的创建定义以及遍历,for…in… 方法:

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

三引号,双引号或单引号中的数据就是字符串。例如:”hello”      ‘world’

 1 str1 = "hello python"  # 空格也占用字符
 2 str2 = "我们是8期的学员"
 3 print(str1[5])  # 空格被打印,索引5是空格
 4 print(str1[3])  # 打印顺数索引3的数据 打印l
 5 print(str1[-1])   # 打印逆数第一个数据,打印n
 6 print(str1[::-1])  # 逆序打印(翻转),打印nohtyp olleh
 7 
 8 for char in str2:  # 字符串遍历
 9     print(char)  # 逐个竖着输出"我们是8期的学员"
10 
11 12 13 14 8
15 16 17 18

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

 1 str1 = "hello python"
 2 # 字符串长度的统计
 3 print(len(str1))  # 输出12
 4 # 字符出现的次数
 5 print(str1.count("thon"))  # 输出1
 6 print(str1.count("l"))  # 输出2
 7 print(str1.count("abcd"))  # 输出0
 8 # 某一个字符串出现的位置
 9 print(str1.index("llo"))  # "llo"里面的第一个字母出现的索引位置 输出2
10 print(str1.index("abcd"))  # 会报错substring not found,因为abcd不存在

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

 1 s = 'Hello world Python'   # 注意:字符串中的空格也算在索引内
 2  
 3 print(s.count('o'))        # 计算'o'在是中的个数。输出3
 4  
 5 print(s.find('l'))         # 查找,返回从左第一个指定字符的索引,找不到返回-1,输出2
 6  
 7 print(s.find('c'))         # 字符串中没有发现就返回-1 输出-1
 8  
 9 print(s.rfind('o'))        # 字符串从右至左找第一个字符,但是索引是从左往右索引。输出16
10  
11 print(s.index('h'))        # 寻找指定字母在字符串的位置的索引,找不到会报错。输出0
12 13 print(s.rindex('h')) # 和rfind类似,但是找不到会报错 输出15 14 15

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

          拆分:split(),partition(),splitlines(),

 1 s = 'Hello world Python'
 2  
 3 print(s.split('w'))    # 按照指定内容进行拆分,分为指定部分前 和指定部分后两部分。返回列表形式。
 4 
 5 输出结果: ['Hello ', 'orld Python']
 6 
 7  
 8 print(s.partition('orl'))   # 按照指定内容进行拆分,分为指定部分前 ,指定部分和 指定部分后三部分,返回元组形式。
 9 
10 输出结果: ('Hello w', 'orl', 'd Python')
11 
12                               
13 s = 'Hello\n world\n Python'
14  
15 print(s.splitlines())               # 按照换行符分割,返回列表的形式
16 
17 输出结果:  ['Hello', ' world', ' Python']
18 
19  
20 print(s.splitlines(keepends=False))  # keepends=False   默认不显示换行符,返回列表的形式
21 
22 输出结果:['Hello', ' world', ' Python']
23 
24  
25 print(s.splitlines(keepends=True))  # keppends=True       默认显示换行符,返回列表的形式
26  
27  输出结果:['Hello\n', ' world\n', ' Python']
28          

             连接:join()方法。

 1 str1 = "    \t\n登鹳雀楼\n\t王之涣\r\n 白日依山尽  \t \n黄河入海流\t\n 欲穷千里目\n\r\t更上一层楼"
 2 print(str1)
 3 
 4 输出很乱,如下:
 5         
 6 登鹳雀楼
 7     王之涣
 8  白日依山尽       
 9 黄河入海流    
10  欲穷千里目
11     更上一层楼
12 
13 #  拆分字符串
14 poemList = str1.split()  # 默认空白字符分割()里面可以写分割字符str.split("分割关键字符")
15 print(poemList)
16 输出:['登鹳雀楼', '王之涣', '白日依山尽', '黄河入海流', '欲穷千里目', '更上一层楼']
17 
18 # 字符串的合并
19 ret = " ".join(poemList)  # 用空格连接
20 print(ret)
21 输出:登鹳雀楼 王之涣 白日依山尽 黄河入海流 欲穷千里目 更上一层楼
22 
23 ret = ",".join(poemList)  # 用,连接
24 print(ret)
25 输出:登鹳雀楼,王之涣,白日依山尽,黄河入海流,欲穷千里目,更上一层楼

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

 1 s = 'Hello world Python'
 2 
 3 print(s.replace('o', '0'))  # 将字符串中所有的o 替换成0 默认全部替换
 4 
 5 print(s.replace('o', '0', 2))  # 第三个参数,是指定替换的个数
 6 
 7 # 输出结果:     Hell0 w0rld Pyth0n
 8 #               Hell0 w0rld Python
 9 
10  ----------------------------------------------------------------------------------
11 # translate, maketrans
12 # 按照对应关系来替换内容
13 
14 
15 s = 'Hello world,'
16 a = 'world,'
17 b = 'python'
18 ret = str.maketrans(a, b)
19 s1 = s.translate(ret)  # 必须一一对应
20 print(s1)
21 
22 # 输出结果: Hehhy python

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

 1 # center:将字符串按指定长度居中,若果不能左短右长,可以指定填充内容,默认以空格填充。
 2  
 3 s = 'hello'
 4  
 5 print(s.center(10,'*'))   # 填充长度是10 ,用 * 填充
 6  
 7 输出结果:**hello***
 8 -------------------------------------------------------------------------------------
 9 # ljust:让字符串在指定的长度左齐,可以指定填充内容,默认以空格填充
10       
11 # rjust:让字符串在指定的长度右齐,可以指定填充内容,默认以空格填充。
12  
13 # ljust 和 rjust
14 s = 'hello'
15 print(s.ljust(15, '~'))
16 print(s.rjust(15, '*'))
17  
18 输出结果:hello~~~~~~~~~~
19          **********hello
20 -----------------------------------------------------------------------------------------
21 # zfill:  将字符串填充到指定长度,不足的地方从左开始填充0
22  
23 s = 'hello'
24  
25 print(s.zfill(10))
26  
27 输出结果:00000hello
28 -----------------------------------------------------------------------------------------
29 # strip: 去除空白符
30 
31 poem = [
32     "\t\n你好大玛",
33     "哥哥,弟弟你好\r",
34     "小妹你好",
35     "小姐你好\t\n",
36 ]
37 print(poem)
38 输出为:['\t\n你好大玛', '哥哥,弟弟你好\r', '小妹你好', '小姐你好\t\n']
39 
40 
41 for poem_str in poem:
42      print(poem_str.strip().center(10))  # 空格填充剧中,并去除空白符。
43 输出为:
44    你好大玛   
45  哥哥,弟弟你好  
46    小妹你好   
47    小姐你好 

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

 1 # upper   将字符串中所有字母转换为大写
 2 
 3 # lower   将字符串中所有字母转化为小写
 4 
 5 # swapcase 将字符串中字母大小写互换
 6 
 7 # title    将字符串中单词首字母转化为大写 
 8 
 9 # capitalize 只有字符串首字母大写
10 
11 # expandtabs 将字符串中('\t')符号转化为tab(4个空格)
12 # -------------------------------------------------------------------------------------
13 s = 'Hello python'
14 
15 print(s.upper())
16 
17 print(s.lower())
18 
19 print(s.swapcase())
20 
21 print(s.title())
22 
23 print(s.capitalize())
24 
25 s1 = 'hello\tpython'
26 
27 print(s1.expandtabs())
28 
29 
30 
31 -----------------------------------------------------------------------------------------

 

  输出结果: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型

 1 # 判断字符串中是否只包含数字(详细)
 2 numStr = "12414"
 3 numStr1 = "2312.22"
 4 numStr2 = ""
 5 numStr3 = "\u00b2"
 6 numStr4 = ""         # 输入法V+数字产生的数字符合
 7 
 8 # isdecimal只可以判断整数型字符串,不能判断小数等其他类型
 9 print("isdecimal分析结果")
10 print(numStr.isdecimal())  # True
11 print(numStr1.isdecimal())  # False
12 print(numStr2.isdecimal())  # False
13 print(numStr3.isdecimal())  # False
14 print(numStr4.isdecimal())  # False
15 
16 # isdigit可以判断整数型字符串,"\u00b2",⑴,但不能判断小数,汉字数字(大写)
17 print("isdigit分析结果")
18 print(numStr.isdigit())  # True
19 print(numStr1.isdigit())  # False
20 print(numStr2.isdigit())  # False
21 print(numStr3.isdigit())  # True
22 print(numStr4.isdigit())  # True
23 
24 # isnumeric可以判断整型数字,汉字的数字(大写数字),⑴,"\u00b2",但不能判断小数
25 print("isnumeric分析结果")
26 print(numStr.isnumeric())  # True
27 print(numStr1.isnumeric())  # False
28 print(numStr2.isnumeric())  # True
29 print(numStr3.isnumeric())  # True
30 print(numStr4.isnumeric())  # True
31 -----------------------------------------------------------------------------------------
32 
33 '''其他判断类型'''
34 
35 s = 'Hello123'
36 print(s.isalnum())  # True       判断字符串是否完全由数字和字母组成
37 
38 s1 = 'abcde'
39 print(s1.isalpha())  # True        判断字符串是否完全由字母组成
40 
41 s2 = 'abc123'
42 print(s2.isdigit())  # False          判断zfc是否完全由数字组成,上面已经详细介绍
43 
44 s3 = '  abcDE'
45 print(s3.isupper())  # False        判断字符串内字符是否全是大写
46 
47 s4 = 'abcd'
48 print(s4.islower())  # True        判断字符串内字符是否全是小写
49 
50 s5 = 'Hello Python'
51 print(s5.istitle())  # True       判断字符串中的单词首字母是否大写
52 
53 s6 = '     '
54 print(s6.isspace())  # True        判断字符串是否完全由空格组成
55 
56 s7 = 'hello python'
57 print(s7.startswith('h', 2, 4))  # False      判断字符串在指定范围内是否已指定字符开头
58 print(s7.endswith('lo', 0, 5))  # True       判断字符串在指定范围内是否已指定字符结尾
59 
60 s8 = "hello world"
61 print(s8.startswith("hello"))  # True       判断是否某个字符串开头
62 print(s8.endswith("ld"))  # True      判断是否某个字符串结尾

 方法有如下:

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

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