字符串和列表的内置方法

1 > 字符串内置方法

1.1 > 去除首尾指定字符并且选择方向

str = '####Bob##' 
# 定义一个叫str的字符串变量 赋值####Bob##

1.1.1 > .strip() 移除首尾特定字符

str = '####Bob##'  # 移除#号键
print(str.strip('#'))  # 移除了首尾的#号键
# 打印 >>> Bob

1.1.2 > .lstrip() 移除左边特定字符

str = '####Bob##'  # 移除左边 #号键
print(str.lstrip('#'))  # 移除了左边的#号键
# 打印 >>> Bob

1.1.3 > .rstrip()移除右侧特定字符

str = '####Bob##'  # 移除字符串右侧特定字符
print(str.rstrip('#')) # 移除了右边的#号键
# 打印 >>> Bob

1.2 > 字符串英文大小写相关操作

str = 'Bob98Pd'  
# 定义一个叫str的字符串变量 赋值'Bob98Pd'

1.2.1 > .lower() ---- 小写

str = 'Bob98Pd'
# 定义一个叫str的字符串变量 赋值'Bob98Pd'  
print(str.lower())
# 将字符串中所有的英文字母变为小写
# 打印 >>> bob98pd

1.2.2 > .upper() ---- 大写

str = 'Bob98Pd'  
# 定义一个叫str的字符串变量 赋值'Bob98Pd' 
print(str.upper())
# 将字符串中所有的英文字母变为大写
# 打印 >>> BOB98PD

1.2.3 > .islower() 与 .isupper()

str = 'Bob98Pd'   
# 定义一个叫str的字符串变量 赋值'Bob98Pd'
print(str.islower())# 判断字符串中所有的英文字母是否是纯小写  结果是布尔值
print(str.isupper())# 判断字符串中所有的英文字母是否是纯大写  结果是布尔值

# 打印 >>> flose 
# 打印 >>> flose 

1.3 > 判断字符串的开头或者结尾是否是指定的字符

str = 'Bob98Pd'   
# 定义一个叫str的字符串变量 赋值'Bob98Pd' 

1.3.1>.startswith 用于判断开头

str = 'Bob98Pd'   
# 定义一个叫str的字符串变量 赋值'Bob98Pd' 
print(str.startswith('B'))
# 判断字符串是否以'B'开头
# 打印 >>> True

1.3.2>.endswith 用于判断结尾

str = 'Bob98Pd'   
# 定义一个叫str的字符串变量 赋值'Bob98Pd' 
print(str.endswith('p'))
# 判断字符串是否以'p'结尾头
# 打印 >>> False

1.4 > 格式化输出 .format用法

  字符串的格式化可以直接用占位符（%s，%d）来运行，但我们最为推荐的就是使用format()来实现该功能，下面是它的一些用法

用法1：与占位符一样 用{}来占位

	print('My name is {} both in {} my age is {}'.format('bob', 2000, 22))
	# 打印 >>> My name is bob both in 2000 my age is 22
     
用法2:根据索引取值  可以反复使用

	print('My name is {0}, {0}, {0}, {2} both in {1} my age is {2}, {0}'.format('bob', 2000, 22))
	# 打印 >>> My name is bob,bob,bob,22 both in 2000 my age is 22,bob

用法3：可以指名道姓的进行取值

	print('My name is {name} both in {year} my age is {age}'.format(name='bob', year=2000, age=22))
	# 打印 >>> My name is bob both in 2000 my age is 22
	
用法4: 直接使用已经定义好的变量

	name = 'bob'
	year = 2000
	age = 22
	print(f'My name is {name} both in {year} my age is {age}')
	# 打印 >>> My name is bob both in 2000 my age is 22

1.5 > 拼接字符串的几种方法 和.join() 用法

先定义两个字符串变量

	str1 = '日照香炉生紫烟 遥看瀑布挂前川'
	str2 = '飞流直下三千尺 疑是银河落九天'

方法1: 用 + 号拼接 但是当字符串很大时，效率太低了

	print(str1 + str2) 
	# 打印 >>> 日照香炉生紫烟 遥看瀑布挂前川飞流直下三千尺 疑是银河落九天
	
方法2: 用 * 拼接 

	print（str1 * 3）# 后面的数字的意思就是重复多少次
	# 打印 >>> 日照香炉生紫烟 遥看瀑布挂前川日照香炉生紫烟 遥看瀑布挂前川日照香炉生紫烟 遥看瀑布挂前川
	
方法3: 用 | 拼接 用.join()用法

	print('|'.join(str1)) 
	# 打印 >>> 日|照|香|炉|生|紫|烟| |遥|看|瀑|布|挂|前|川
	
方法4: 用 $ 拼接 用.join()用法

	 print('$'.join(['恭', '喜', '发', '财']))
	 # 打印 >>> 恭$喜$发$财
	

1.6 > 替换字符串中指定的字符 .replace()用法

先定义一个字符串变量str
	str = 'iconman is NB NB NB iconman '

用法1: 

  直接进行全部替换
	print(str.replace('iconman', 'superman'))
	将str中全部的 'iconman' 替换成 'superman'
	# 打印 >>> superman is NB NB NB superman 

用法2: 

  指定更换的个数
  	print（str.replace('NB', 'GOOD', 2)）
  	将str中的 'NB' 替换成 'GOOD' 只替换两个

1.7 > 判断字符串中是否是纯数字 .isdigit() 用法

先定义三个字符串变量str1，str2，str3
	str1 = 'Bob666'
	str2 = '123'
	str3 = '123.13'
	
用法: 判断字符串是否是纯数字

	print(str1.isdigit())
	# 打印 >>> False
	print(str2.isdigit())
	# 打印 >>> True
	print(str3.isdigit())
	# 打印 >>> True

1.8 > 查找指定字符对应的索引值 .find()用法

先定义一个字符串变量str
	str = 'iconman is NB NB NB iconman '
	
用法1: 从左往右查找 查找一个就结束

	print(str.find('m'))
	# 打印 >>> 4

用法2: 指定范围查找 查找一个就结束

	print(str.find('h', 1, 9))
	# 从左往右查找从下标为1的字符开始到 下标为9的字符结束
	# 打印 >>> -1     -1 意思是没有 找不到
	

1.9 >文本位置改变的四种方法

先定义一个字符串变量name
	name = 'Bob'

方法1: 居中对齐

	print(name.center(30, '-'))
	# 输出30个字符，字符不够用 - 自动补齐 Bob居中对齐
	# 打印 >>> -------------Bob--------------

方法2: 左对齐

	print（name.ljust(30, '@')）
	# 输出30个字符，字符不够用 @ 自动补齐 Bob左对齐
	#打印 >>> Bob@@@@@@@@@@@@@@@@@@@@@@@@@@@

方法3: 右对齐
	
	print（name.rjust(30, '#')）
	# 输出30个字符，字符不够用 # 自动补齐 Bob左对齐
	# 打印 >>> ############################Bob

方法3: 自动用0补齐
		
	print（name.zfill(30)）
	# 输出30个字符，字符不够用 0 自动补齐 Bob右对齐
	# 打印 >>> 0000000000000000000000000000Bob

1.10 > 英文字符的大小写转换 .captalize(),.swapcase(),.title()的用法。

1> .captalize()首字母大写

	name = 'nice meet you'
	print(name.captalize()) # 输出name将其中首字母大写
	# 打印 >>> Nice meet you 

2> .swapcase() 大小写反转

	name = 'Nice meEt yOu'
	print(name.swapcase()) # 输出name将其中字母大小写反转  # 打印 >>> nICE MEeT YoU

3> .title() 使每个单词的首字母大写
	name = 'nice meet you'
	print(name.title()) # 输出name将其中单词首字母都大写
	# 打印 >>> Nice Meet You

2 > 列表内置方法

   list可以转换支持for循环的数据类型,例如：字符串、列表、 字典、元组、集合。

	 print(list(11))  # 不行
	 print(list(11.11))  # 不行
     print(list('jason'))  # ['j', 'a', 's', 'o', 'n']
     print(list({'name': 'jason', 'pwd': 123}))  # ['name', 'pwd']
     print(list((11,22,33,44,55)))  # [11, 22, 33, 44, 55]
     print(list({1, 2, 3, 4, 5}))  # [1, 2, 3, 4, 5]
     print(list(True))

2.1 > 常见的几种操作

   定义一个列表变量name = [‘jason’, ‘bob’, ‘tom’,‘tony’,‘jerry’]

操作1: 索引取值

	print(name[0]) # 取列表变量当中第一个元素
	# 打印 >>> jason
	print(name[-1])# 取列表变量当中最后一个元素
	# 打印 >>> jerry

操作2: 切片操作

	print(name[1:4]) # 从列表当中下标为1的元素开始取值到下标为4的元素结束
	# 打印 >>> bob tom tony
	
	print(name[-4:-1)  # 从列表当中倒数第4的元素开始取值到倒数第一元素结束
	# 打印 >>> bob tom tony
	
	 print(name[-1:-4:-1]) # 从列表当中倒数第1的元素开始(从右往左)取值到倒数第三的元素结束
	 # 打印 >>> tom tony jerry
	
操作3: 间隔（步长）

	print(name[0:4:2]) # 从列表当中下标为0的元素开取值到下标为4的元素结束 间隔2个元素 依此取值
	# 打印 >>> jason tom 

操作4: 统计列表中元素的个数

	print(len(name)) #共有五个元素
	# 打印 >>> 5
	
操作5.成员运算

	'''最小判断单位是元素不是元素里面的单个字符'''
	print('j' in name) # 判断j这字符是否在列表name里
	# 打印 >>> False
	
	print('bob' in name)# 判断bob 这字符串是否在列表name里
	# 打印 >>> True

操作6.列表添加元素的方式 .append()的用法

	6.1> 尾部追加'单个'元素
	
		name.append('Wu') # 将Wu这个元素加入name列表
		print(name)
		# 打印 >>> ['jason', 'bob', 'tom','tony','jerry', 'Wu']
		
	6.2> 指定位置插入'单个'元素 .insert()的用法
	
		name.insert(0, 225) # 将 225放在下标为0的元素前面自己变成下标为0的元素
		# 打印['225, ''jason', 'bob', 'tom','tony','jerry', 'Wu']
		
		name.insert(2.885） # 将 885放在下标为0的元素前面自己变成下标为0的元素
		# 打印['225, ''jason', '885', 'bob', 'tom','tony','jerry', 'Wu']
	6.3> 合并列表 .extend()用法
	
	name，extend([11,22,33,44,55]) # 将列表name 与列表[11,22,33,44,55]合并
	print(name) 
	# 打印 >>> ['225, ''jason', '885', 'bob', 'tom','tony','jerry', 'Wu',11,22,33,44,55]

7.删除元素

	7.1> 通常删除方式 del用法
	
		del name[0] # 删除name列表第一个元素
		print(name)
		# 打印 >>> ['jason', '885', 'bob', 'tom','tony','jerry', 'Wu',11,22,33,44,55]
		
	7.2> 就地删除 .remove()用法
	
		name.remove('jerry') # 删除name元素当中的jerry
		print(name)
		# 打印 >>> ['jason', '885', 'bob', 'tom','tony', 'Wu',11,22,33,44,55]
		
	7.3> 延迟删除
	
		print(name.pop())  # 默认是尾部弹出
		print(name)
		# 打印 >>> 55 
		print(name.pop(3)) # 指定索引值
		# 打印 >>> tom 
		
操作8: 修改列表元素

	name[0] = 'jason20' # 修改列表第一个元素
	print(name)
	# 打印 >>> ['jason', '885', 'bob', 'tom','tony', 'Wu',11,22,33,44,55]
	
操作9: 列表的排序
	s = [66, 88, 77, 11, 22, 33, 55, 44]
	
 	9.1> .sort() 升序排序
 			s.sort()  # 将列表s 升序排序
 			print(s)
 			# 打印 >>> [11, 22, 33, 44, 55, 66, 77, 88]
 			
 	9.2> .sort(reverse=True) 可以修改为降序
 	  	 	 s.sort(reverse=True)  # 将列表s 降序排序
 	   		 print(s)
 	  		 # 打印 >>> [88，77，66，55，44，33，22，11]

操作10:翻转 .reverse()
	s = [66, 88, 77, 11, 22, 33, 55, 44]
	s.reverse()  # 将列表s顺序颠倒
	print(s)
	# 打印 >>> [44,55,33,22,11,77,88,66]

操作11.比较运算
	s1 = [11, 22, 33]
	s2 = [1, 2, 3, 4, 5, 6, 7, 8]
	print(s1 > s2)  # True
 """列表在做比较的时候 其实比的是对应索引位置上的元素"""

操作12.统计列表中某个元素出现的次数 .count()
	l1 = [11, 22, 33, 44, 33, 22, 11, 22, 11, 22, 33, 22, 33, 44, 55, 44, 33]
	print(l1.count(11)) # 统计元素11出现的次数
	

3 > 可变类型与不可变类型

   可变类型的意思就是这数据类型它的值改变，但是内存地址不改变 ，修改的是其本身
  不可变类型的意思就是这数据类型它的值改变，内存地址肯定变，修改过程产生了新的值

例如：当数据类型是列表时
 s2 = [1, 2, 3]
 print(id(s2))  # 1656888244360
 s2.append(11111111)
 print(id(s2))  # 1656888244360
'''在列表中加入了111111 值改变了 但是内存地址还一样不会改变'''

例如：当数据类型是字符串时
s1 = '  jason  '
print(id(s1))  # 2031270602224
res = s1.strip()
print(id(res))  # 2031269757648
'''在字符串中去掉了头尾的空格键值改变了 内存地址也改变了'''

  所以说，可变类型包括 列表。不可变类型包括 字符串

4 > 队列与堆栈

4.1 > 队列

  队列的意思就是类似与超市排队结账的情景，先进先出。
  下面用列表来模拟队列的特征。

 new_list = []
   '''先进'''
 new_list.append(111)
 new_list.append(222)
 new_list.append(333)
    '''先出'''
 for i in new_list:
     print(i)
 print(new_list.pop(0))  # 111
 print(new_list.pop(0))	 # 222
 print(new_list.pop(0))	 # 333

4.2 > 堆栈

  堆栈的意思就是类似与叠衣服情景，先进后出。
  下面用列表来模拟堆栈的特征。

new_list = []
# 先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 后出
print(new_list.pop())  # 333
print(new_list.pop())  # 222
print(new_list.pop())  # 111