一.列表
=====================================================
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 #extend21 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,74,46,1]2 del newL[8] # # 删除指定索引值为8的数据，这里删除最后一个数据13 print(newL) # [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,9,11,13,15,17,19] 4 # 输出：例子列表 [1,19] 5 print(ListCut[0: 6]) # 0到5左边开始索引的数据 左闭右开（左边0是包含索引值，右边6是6之前的索引值） 6 # 输出[1,11] 7 print(ListCut[::2]) # 每隔2个数字取一个值 8 # 输出[1,17] 9 print(ListCut[::-1]) # 逆序/反序排序 等同于List.reverse()10 # 输出[19,1]11 print(ListCut[-4:]) # 取后四位，负数是右边开始取12 # 输出[13,19]13 print(ListCut[-4:-1]) # 右边开始取，取后4位到后2位值，左闭右闭，（-4包括，-1包括）14 # 输出[13,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‘,‘ls‘,‘tom‘,‘zs‘]10 11 12 lst.sort(reverse=True) # 有大到小排序13 14 15 print(lst)16 17 输出结果：[‘zs‘,‘james‘]18 ------------------------------------------------------------------------------------19 reverse() 将列表翻转（逆序）20 21 lst = [‘tom‘,‘ls‘]22 23 lst.reverse()24 25 print(lst)26 27 输出结果：[‘ls‘,‘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 copy21 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,) 。以逗号分割的，以小括号包围的序列。
通过tuple函数定义: lst=[1,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,‘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‘,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 输出结果： zs20 1821 1.6422 15023 zs 1024 ls 1125 ww 12
4.元组的方法：index()，count()，len() 方法。
1 tup = (‘a‘,‘b‘,‘c‘,‘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 输出结果： 119 20 521 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"]) # 输出tony4 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‘,‘height‘: 1.75,‘weight‘: 170}14 15 {‘name‘: ‘zs‘,‘weight‘: 170}16 17 ---------------------------------------------------------------------------------------18 dic = {‘name‘: ‘zs‘,‘height‘: 1.75}19 20 dic[‘name‘] = ‘ww‘ # 根据key键来设置值，如果key存在就直接覆盖原有的值21 22 print(dic)23 24 输出结果： {‘name‘: ‘ww‘,‘height‘: 1.75}
3.字典的删除：pop()，popitem()，clear()，del 方法。
1 pop() 2 3 dic = {‘name‘: ‘zs‘,‘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‘,‘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‘,‘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‘:‘张三‘,‘height‘:1.78}11 12 ---------------------------------------------------------------------------------------13 14 update（） 按照字典的格式更新键的内容，若果字典不存在这个键，就创建这个键和值15 16 dic = {‘name‘: ‘zs‘,‘height‘: 1.78}17 18 dic1 = {‘name‘:‘张三‘,‘weight‘:152}19 20 dic.update(dic1)21 22 print(dic)23 24 25 输出结果：{‘name‘: ‘张三‘,‘height‘: 1.78,‘weight‘: 152}
5.字典的查找：get()，keys()，values()，items()，len()方法。
1 c = {‘name‘: ‘zs‘,‘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 zs18 19 dict_keys([‘name‘,‘age‘,‘height‘])20 21 dict_values([‘zs‘,10,1.78])22 23 dict_items([(‘name‘,‘zs‘),(‘age‘,(‘height‘,1.78)])24 25 3
6.for 循环及字典的遍历：keys()，values()，items() 方法，其中items()方法有两种遍历方式。
1 dic = {‘name‘: ‘zs‘,‘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 name15 16 age17 18 height19 -------------------------------------------------------------------------------------20 # 获取所有的value21 22 for value in dic.values():23 24 print(value)25 26 输出结果：zs27 28 1029 30 1.7531 -------------------------------------------------------------------------------------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 zs57 58 age 1059 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.66]25 print(d) # 输出为：[‘kity‘,‘lili‘,‘lucy‘,‘tony‘]26 print(d2) # 输出为：[‘tony‘,‘kity‘]27 print(k) # 输出为：[‘kity‘,‘tony‘]28 print(k2) # 输出为：[‘tony‘,‘kity‘]29 print(i) # 输出为:[(‘kity‘,1.7),(‘lili‘,1.66),(‘lucy‘,1.88),(‘tony‘,1.73)]30 print(i2) # 输出为:[(‘tony‘,1.73),(‘kity‘,1.7)]31 print(t) # 输出为:[(‘lili‘,1.88)]32 print(t2) # 输出为:[(‘lucy‘,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 815 期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"里面的第一个字母出现的索引位置 输出210 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‘)) # 字符串从右至左找第一个字符，但是索引是从左往右索引。输出1610 11 print(s.index(‘h‘)) # 寻找指定字母在字符串的位置的索引，找不到会报错。输出0
12 13 print(s.rindex(‘h‘)) # 和rfind类似，但是找不到会报错 输出1514 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‘,‘ 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,maketrans12 # 按照对应关系来替换内容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 和 rjust14 s = ‘hello‘15 print(s.ljust(15,‘~‘))16 print(s.rjust(15,‘*‘))17 18 输出结果：hello~~~~~~~~~~19 **********hello20 -----------------------------------------------------------------------------------------21 # zfill: 将字符串填充到指定长度，不足的地方从左开始填充022 23 s = ‘hello‘24 25 print(s.zfill(10))26 27 输出结果：00000hello28 -----------------------------------------------------------------------------------------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 = 19print(‘大家好，我叫{}，今年{}岁‘.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()) # True11 print(numStr1.isdecimal()) # False12 print(numStr2.isdecimal()) # False13 print(numStr3.isdecimal()) # False14 print(numStr4.isdecimal()) # False15 16 # isdigit可以判断整数型字符串,"\u00b2",⑴,但不能判断小数，汉字数字(大写)17 print("isdigit分析结果")18 print(numStr.isdigit()) # True19 print(numStr1.isdigit()) # False20 print(numStr2.isdigit()) # False21 print(numStr3.isdigit()) # True22 print(numStr4.isdigit()) # True23 24 # isnumeric可以判断整型数字，汉字的数字(大写数字)，⑴，"\u00b2",但不能判断小数25 print("isnumeric分析结果")26 print(numStr.isnumeric()) # True27 print(numStr1.isnumeric()) # False28 print(numStr2.isnumeric()) # True29 print(numStr3.isnumeric()) # True30 print(numStr4.isnumeric()) # True31 -----------------------------------------------------------------------------------------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‘,4)) # False 判断字符串在指定范围内是否已指定字符开头58 print(s7.endswith(‘lo‘,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()。
=====================================================================================================================================================学习还有复查资料整合出来的，留着以后工作有用，或者学习经常查看，这里学习安之老师布置这个作业！虽然整合了我一天时间！-_-!总结
以上是内存溢出为你收集整理的Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。全部内容，希望文章能够帮你解决Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）