第十七周-day71-Python编程基础day03

老男孩教育-张导博客：https://www.cnblogs.com/Neeo/articles/11204572.html

1. 字符串基本操作

# 按索引取值

s = 'abcdef'
print(s[0])
print(s[-2])
print(s[0:2])   # 取范围
print(s[0:6])
print(s[0:6:1])
print(s[0:6:2])   # 取a c e
print(s[0:3:1])
#输出结果
a
e
ab
abcdef
abcdef
ace	# 取a c e
abc

str1 = 'http://www.oldboyedu.com/'
print(str1[-3])        # 取倒数第三个
print(str1[0:6])       # 取前六个字符
print(str1[5:-1])      # 从第六个字符开始取到末尾
print(str1[3:7])       # 从3到8个字符之前取值
print(str1[0:-1:2])    # 两者之间 每2个字符取一个
print(str1[0:-1:4])    # 所有字符中每4个取一个
print(str1[::-1])      # 反转字符串 通过负数的步进 实现反转

注意：

字符串反转 print(s[::-1])

2. 字符串的拼接

字符串的拼接（合并） +
字符串的合并操作，也叫字符串的拼接，此操作应用十分广泛

>>> '100' + '-' + '1800' + '-' + '18000'  
'100-1800-18000' 

**字符串的复制 **

>>> name = 'oldboy'  
>>> name * 5  
'oldboyoldboyoldboyoldboyoldboy' 

相当于将元字符复制5份，组成新的字符串。

字符串成员测试：in，not in

>>> 'o' in 'oldboy'  
True  
>>> 'ol' in 'oldboy'  
True  
>>> 'od' in 'oldboy'  
False  
>>> 'od' not in 'oldboy'  
True  

字符串格式化运算符： %系列

字符串的格式化输出。格式化输出就是按照某种固定的格式进行字符串输出，这个字符串称为模板字符串，我们在模板里用格式定义符%占住一个空位，然后我们把运算得出的数据再放到这个空位里，字符串格式化运算符%的基本用法如下：

<模板字符串> % (<数据1>， …，数据n>)  

%s这个字符串格式化运算符就是说我要往字符串中放入的数据是字符串类型的值，这也是最常用的用法，但仅凭%s不足以包打天下，所以，这一节我们在学习几个其他常用的与%搭配的其他的字符，以实现不同的功能，比如商店消费的小票上，或者银行等涉及到金钱的输出都有固定格式，比如我们怎么用格式化输出￥1.50呢？你可能会说，简单，这样干：

>>> "金额：￥%s 元" % 1.50  
'金额：￥1.5 元'  

最后一位没显示出来，很明显，%s在这种情况下并不好使，所以我们面对类似的情况就要用别的格式化运算符了——浮点型%f。

>>> "金额：￥%.2f 元" % 1.50  
'金额：￥1.50 元'  

<模板字符> %[flags][width].[precision]<模板字符> % (数据1, … 数据n)

上例各参数说明如下：

• 模板字符就是普通的字符串。
• flags可以是+、-或0，+表示右对齐（默认右对齐，加号不写，写上会显示出来），-表示左对齐。
• width表示显示宽度。
• precision表示小数的位数。

print("金额：￥%+9.2f 元" % 1.50000) 
print("金额：￥%-9.2f 元" % 1.50000)  
print("金额：￥%09.2f 元" % 1.50000) 

#输出结果
金额：￥    +1.50 元
金额：￥1.50      元
金额：￥000001.50 元

上例中：

• %+9.2f表示格式化字符右对齐（一般加号可以省略不写，写上的话，会当成格式化字符填充进去）、宽度是9，小数位保留2位，需要填充的是浮点型的数据。
• %-9.2f表示格式化字符左对齐，宽度是9，小数位保留2位，需要填充的是浮点型的数据。
• %09.2f表示格式化字符填充0，宽度是9，需要填充的是浮点型的数据。

要注意的是，如果使用的是浮点型的格式定义符，那么数据也必须是浮点型数据或int类型。

>>> "金额：￥%f 元" % 4  
'金额：￥4.000000 元'  
>>> "金额：￥%.2f 元" % 4  
'金额：￥4.00 元'  
>>> "金额：￥%.2f 元" % 'str'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: a float is required   

这同样适用于其他的格式定义符，比如说如果是你用int类型的格式定义符“%d”,而你的数据是str类型，那就会报错。

>>> "金额：￥%d 元" % '1'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: %d format: a number is required, not str  
>>> "金额：￥%d 元" % 1  
'金额：￥1 元'  

3. 字符串的常用方法

方法	描述	重要程度
str.capitalize	将字符串的一个字符转换为大写	**
str.center	返回指定宽度的居中的字符串	***
str.count	返回指定字符在字符串内出现的次数	****
str.endswith	检查字符串是否以指定字符结尾	***
str.startswith	检查字符串是否在指定字符开始位置	***
str.find	判断字符是否在字符串中	***
str.index	判断字符是否在字符串中	**
str.join	以指定分割符，将seq中所有元素合并为一个新的字符串	*****
str.lower	将字符串内的所有大写字符转为小写	***
str.upper	将字符串内的所有小写字符转为大写	***
str.replace	将字符串内指定的old字符转换为new并返回为新的字符串	*****
str.split	以指定字符为分隔符分隔字符串，并返回字符串列表	*****
str.isdigit	检测字符串是否由数字组成	***
bytes.decode	指定解码方式给bytes对象解码	*****
str.encode	指定编码方式给str编码	*****
str.expandtabs	转换字符串中的tab符号为空格，tab符号默认的空格数是8	*
str.isalnum	检测字符串是否有字符和数字组成	**
str.isalpha	检测字符串是否只有字母组成	***
str.islower	检测字符串是否只有小写字母组成	***
str.isupper	检测字符串是否只有小写字母组成	***
str.isnumeric	检测字符串是否只包含数字字符	*
str.isspace	检测字符串是否只有空格组成	*
str.title	返回字符串中首字母大写其余字母小写形式	**
str.istitle	如果字符串是首字母大写其余字母小写形式的则返回 True，否则返回 False	*
str.isdecimal	检查字符串是否只包含十进制字符	*
str.ljust	返回原字符串的左对齐	*
str.rjust	返回原字符串的右对齐	*
str.lstrip	删除字符串开始的指定字符	**
str.rstrip	删除字符串末尾的指定字符	**
str.rfind	如find()方法，但从右侧开始查找	*
str.rindex	如index()方法，但从右侧开始查找	*
str.splitlines	以列表的形式按照换行符返回分割后的字符串	*
str.maketrans	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标	**
str.translate	根据字符串给出的表转换字符串的字符，要过滤掉的字符放到delete参数中	***
str.zfill	返回指定长度的字符串，原字符串右对齐，前面补0	*****
str.swapcase	将字符串中的大写字符转换位小写，小写字母转换为大写	**

Python为字符串提供了很多方法，也有很多的内置函数和声明可以应用于字符串，比如说使用len(str)方法获取字符串的长度。这里我们仅介绍最常用的字符串方法。

3.1 str.strip(‘obj’)

去除字符串两边的指定字符，默认去除字符串两边的空格或者换行符，没有指定字符则略过。返回去除指定字符后的新字符串。

s2 = '****oldb***oy*******'
print(s2.strip())  # ****oldb***oy*******
print(s2.strip('*'))  # oldb***oy

s = '*a*b  *'
print(s.strip('*'))
print(s.replace('*', ''))
print(s.replace('*', '', 2))

#执行结果
a*b  
ab  
ab  *

如上例所示，strip方法只能去除字符串两边的指定字符，那想把中间的星号去掉怎么办？

s2 = '****oldb***oy*******'
print(s2.replace('*', ''))  # oldboy

问题解决，但是replace是什么？

3.2 str.replace

str.replace(old, new, [max])

将字符串中指定字符替换成新的字符，替换次数最多不超过max次。返回替换后的新的字符串。

s1 = "'python是最美的语言', python said"
new_str = s1.replace('p', 'P')
print(new_str)  # 'Python是最美的语言', Python said
print(s1.replace('p', 'P', 1))  # 'Python是最美的语言', python said

3.3 str.split & str.rsplit

str.split(obj=’’, num) & str.rsplit(obj=’’, num)

以指定的字符分割字符串，可以指定分割次数，默认是全部分割，并以列表的形式返回。

s3 = "hello python"
print(s3.split('o'))  # ['hell', ' pyth', 'n']
print(s3.split('o', 1))  # ['hell', ' python']

分割字符串也就是说遇到指定的分割字符就以指定字符把字符串分两半！通过返回结果可以看到，这种分割顺序是从左到右开始的。对应的，我们也可以从右到左分割，我们可以用str.rsplit(obj='', num)完成：

s4 = "hello python"
print(s4.rsplit('o'))  # ['hell', ' pyth', 'n']
print(s4.rsplit('o', 1))  # ['hello pyth', 'n']

一般的，除了分割，包括替换在内的顺序都是从左到右地顺序，这是默认的。

3.4 str.join(sequence)

返回以指定字符将sequence连接后的新字符串。

s = 'abc' # a_b_c
print('_'.join(s))

#执行结果
a_b_c

需要注意的是，sequence中的元素必须是字符串类型，否则报错。

s6 = ['1', '2', '3']
s7 = [1, 2, 3]
print('-'.join(s6))  # 1-2-3
print('-'.join(s7))  # TypeError: sequence item 0: expected str instance, int found

上例中，s6和s7同为列表，但其内的元素类型不同，可以看到，如果其中的对象是int类型，就会报错。

3.5 str.upper() & str.lower()

返回字符串中英文字母大写形式的新字符串，非英文字母、本身就是大写形式的英文字母略过。

s8 = '张开说Python就像1+1等于2那么简单'
print(s8.upper())  # 张开说PYTHON就像1+1等于2那么简单

与之对应的是就是返回字符串中英文字母小写形式的新字符串，非英文字母、本身就是小写形式的英文字母略过。

s9 = '张开说Python就像1+1等于2那么简单'
print(s9.lower())  # 张开说python就像1+1等于2那么简单

这两个方法用处很多，比如我们在登录验证码的判断这里就可以用到，因为验证码是随机的，并且含有大小写和特殊字符的一串字符串，那么怎么判断呢，其中就可以通过upper()和lower()这两个方法来判断。

verification_code = '12n%C'
result = input('输入验证码: ')
if verification_code.upper() == result.upper():  # 也可以将验证码都以小写形式来判断
    print('验证码正确')
else:
    print('验证码输入错误')

3.6 str.index & str.find

str.index(obj) & str.find(obj)

返回字符串中指定字符的索引位置，顺序是从左到右的顺序，找到就返回。

s1 = 'abcd'
print(s1.find('a'))  # 0
print(s1.find('w'))  # -1

s2 = 'abcd'
print(s2.index('a'))  # 0
print(s2.index('w'))  # ValueError: substring not found

找到就返回这没错，但需要我们注意的是，如果字符串中不存在指定的字符，两个方法的返回结果也是不一样的，如果字符串没有指定字符，str.find返回-1，而str.index则报错。

3.7 str.startswith & str.endswith

str.startswith(obj) & str.endswith(obj)

判断字符串是否已指定字符开头或者结尾，并以布尔值的形式返回。

s = 'abcd'
print(s.startswith('a'))  # True
print(s.startswith('ab'))  # True
print(s.startswith('acb'))  # False

print(s.endswith('d'))  # True
print(s.endswith('cd'))  # True
print(s.endswith('cbd'))  # False

通过结果可以看到，指定字符如果是多个，必须是连续的。

3.8 str.count

str.count(obj, start=0, end=len(str))

返回字符串中，指定索引范围内的指定元素出现的次数，如果指定字符不在字符串中，则返回0。开始位置默认为0，结束位置为字符串结束的位置。

s = 'https://www.cnblogs.com/Neeo/'
print(s.count('w'))  # 3
print(s.count('w', 1, 10))  # 2
print(s.count('1'))  # 0

3.9 str.center

str.center( width， filler)

返回一个指定宽度的字符串，如果width的宽度小于字符串本身的宽度，就直接返回该字符串，否则字符串两边填充filler字符，filler默认是空格，且filler必须是单个字符，否则报错。

print('welcome to Linux59'.center(30, '☆'))

#执行结果
☆☆☆☆☆☆welcome to Linux59☆☆☆☆☆☆

3.10 str.format()

自Python 2.6版本开始，就增加了format函数，它增强了字符串格式化的功能，基本语法是通过“{}”和“:”来代替“%”。format函数可以接受不限个数的参数，位置也可不按顺序。下面通过示例来学习 一下format函数的用法：

• 按照默认顺序传参：

print('{} {}'.format('hello', 'Anthony'))  # hello Anthony

默认的，format将“hello”填充到第一个花括号内，将“oldboy”填充到第二个花括号内。相当于平行赋值。

• 按照指定位置传递参数：

print('{0} {1}'.format('hello', 'Anthony'))  # hello Anthony
print('{0} {0}'.format('hello', 'Anthony'))  # hello hello
print('{1} {0}'.format('hello', 'Anthony'))  # Anthony hello
print('{1} {1}'.format('hello', 'Anthony'))  # Anthony Anthony

上例中，我们可以这样理解，format内两个参数都有自己的位置序号。然后根据序号填充字符串。

• 设置参数：

s = 'name: {name} | url:{url}'
print(s.format(name='Anthony', url='https://www.cnblogs.com/Neeo/'))  # name: Anthony | url:https://www.cnblogs.com/Neeo/

上例中，我们为format中的参数起个别名，然后字符串根据别名填充对应的内容。

求字符串的长度

s = 'abcdefg'
print(len(s))

7

for i in s:
    print(i, s.index(i))

# 执行结果
a 0
b 1
c 2
d 3
e 4
f 5
g 6    

s = 'abcd'
print(max(s))  # d
print(min(s))  # a
print(len(s))  # 4

4. 字符集和编码详解

相关知识：https://blog.csdn.net/qq_42068856/article/details/83792174

5. 作业

1.有变量name = “aleX leNb” 完成如下操作：

# 1.有变量name = " aleX leNb " 完成如下操作：
name = "aleX leNb"

# 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())	# aleX leNb

# 移除name变量左边的"al"并输出处理结果
print(name[2:-1])	# eX leN

# 移除name变量右面的"Nb",并输出处理结果
print(name[0:-2])	# aleX le

# 移除name变量开头的a"与最后的"b",并输出处理结果
print(name[1:-1])	# leX leN

# 判断 name 变量是否以 "al" 开头,并输出结果
print(name.startswith('al')) 	# True

# 判断name变量是否以"Nb"结尾,并输出结果
print(name.endswith('Nb'))  # True

# 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
print(name.replace('l', 'p'))   # apeX peNb

# 将name变量对应的值中的第一个"l"替换成"p",并输出结果
print(name.replace('l', 'p', 1))    # apeX leNb

# 将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
print(name.split('l'))  # ['a', 'eX ', 'eNb']

# 将name变量对应的值根据第一个"l"分割,并输出结果。
print(name.split('l', 1))   # ['a', 'eX leNb']

# 将 name 变量对应的值变大写,并输出结果
print(name.upper())  # ALEX LENB

# 将 name 变量对应的值变小写,并输出结果
print(name.lower())  # alex lenb

# 将name变量对应的值首字母"a"大写,并输出结果
print(name.title())  # Alex Lenb

# 判断name变量对应的值字母"l"出现几次，并输出结果
print(name.count('l'))  # 2

# 如果判断name变量对应的值前四位"l"出现几次,并输出结果
print(name.count('l', 0, 4))    # 1

# 从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
print(name.index('N'))  # 7

# 从name变量对应的值中找到"N"对应的索引(如果找不到则返回-1)输出结果
print(name.find('N'))   # 7

# 从name变量对应的值中找到"X le"对应的索引,并输出结果
print(name.count('X le'))   # 1

# 请输出 name 变量对应的值的第 2 个字符?
print(name[1:2])    # l

# 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])  # ale

# 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])    # Nb

# 请输出 name 变量对应的值中 "e" 所在索引位置（两个e都找）?
#此题解法：https://zhidao.baidu.com/question/425671789131374252.html
find = 'e'
print([i for i,v in enumerate(name) if v==find])	# [2, 6]

2.有字符串s = “123a4b5c”

通过对s切片形成新的字符串s1,s1 = "123"
s1 = s[:3]
print(s1)   # 123

通过对s切片形成新的字符串s2,s2 = "a4b"
s2 = s[3:6]
print(s2)   # a4b

通过对s切片形成新的字符串s3,s3 = "1345"
s3 = s[0:-1:2]
print(s3)   # 1345

通过对s切片形成字符串s4,s4 = "2ab"
s4 = s[1:-1:2]
print(s4)   # 2ab

通过对s切片形成字符串s5,s5 = "c"
s5 = s[-1]
print(s5)   # c

通过对s切片形成字符串s6,s6 = "ba2"
s6 = s[-3::-2]
print(s6)   # ba2

3.使用while和for循环分别打印字符串s="asdfer"中每个元素。

# while循环
s = "asdfer"
num = 0
while True:
    print(s[num])
    num += 1
    if num == len(s):
        break

# for循环
s = "asdfer"
for i in s:
    print(i)

4.使用for循环对s=“asdfer"进行循环，但是每次打印的内容都是"asdfer”。

s = "asdfer"
for i in s:
    print(s)

5.使用for循环对s="abcdefg"进行循环，每次打印的内容是每个字符加上sb，

例如：asb, bsb，csb,…gsb。

s = "asdfer"
for i in s:
    print(i + 'sb')

#执行结果
asb
ssb
dsb
fsb
esb
rsb

6.使用for循环对s="321"进行循环，打印的内容依次是：“倒计时3秒”，“倒计时2秒”，“倒计时1秒”，“出发！”。

s = "321"
for i in s:
    # print('倒计时'+i+'秒')
	print('倒计时{}秒'.format(i))
print('出发!')	

#执行结果
倒计时3秒
倒计时2秒
倒计时1秒
出发!

7.实现一个整数加法计算器(两个数相加)：

如：content = input(“请输入内容:”) 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。

# 思路：将输入的空格可以替换为空，利用str.replace
# 分割'+'号
content = input("请输入相加的整数;格式[x+y]: ").replace(' ', '')
num = content.split('+')
print(int(num[0] + num[1]))

8.升级题：实现一个整数加法计算器（多个数相加）：

如：content = input(“请输入内容:”) 用户输入：5+9+6 +12+ 13，然后进行分割再进行计算。

# 使用for循环，先将'+'号分割定义变量，然后再利用int整型计算相加

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
num = content.split('+')
s = 0
for i in num:
    s += int(i.strip())
print(s)

# 使用for循环，直接分割后利用int整型计算相加

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
s = 0
for i in content.split('+'):
    s += int(i.strip())
print(s)

9.计算用户输入的内容中有几个整数（以个位数为单位）。

如：content = input(“请输入内容：”) # 如fhdal234slfh98769fjdla

str.isdigit()方法：https://www.runoob.com/python/att-string-isdigit.html

content = input("请输入内容: ").replace('', '')
s = 0
# 利用str.isdigit 如果字符串只包含数字则返回True的方法来统计输了多少个数字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共输入了[', s, ']个整数')

# 对照第八题的思路
# 使用for循环，直接分割后利用int整型计算相加计算整数的和
# 使用了俩个for循环，第一个实现和的计算，第二个实现输入整数的统计

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
# 定义两个变量
n = 0
s = 0
for j in content.split('+'):
    n += int(j.strip())
print('和为:', n)

# 利用str.isdigit 如果字符串只包含数字则返回True的方法来统计输了多少个数字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共输入了[', s, ']个整数')

10.写代码，完成下列需求：(升级题)

用户可持续输入（用while循环），用户使用的情况：
输入A，则显示走大路回家，然后在让用户进一步选择：
是选择公交车，还是步行？
选择公交车，显示10分钟到家，并退出整个程序。
选择步行，显示20分钟到家，并退出整个程序。
输入B，则显示走小路回家，并退出整个程序。
输入C，则显示绕道回家，然后在让用户进一步选择：
是选择游戏厅玩会，还是网吧？
选择游戏厅，则显示 ‘一个半小时到家，爸爸在家，拿棍等你。’并让其重新输入A，B, C选项。
选择网吧，则显示‘两个小时到家，妈妈已做好了战斗准备。’并让其重新输入A，B, C选项。

while True:
    print('☆耶 下课了！你打算去做什么呢？''\n\t', 'A.走大路回家☆', '\n\t', 'B.走小路回家☆', '\n\t', 'C.绕远道回家☆')
    xz = input('请告诉你的选择[A|B|C]: ')
    # xz = input('>>>:').strip()
    if xz.upper() == 'A':
        print('你选择了走大路回家')
        xz = input('☆是选择\n\tA.公交车\n\tB.还是步行？')
        if xz.upper() == 'A':
            print('10分钟后到家...')
            break
        elif xz.upper() == 'B':
            print('20分钟后到家...')
            break
    elif xz.upper() == 'B':
        print('你选择了走小路回家\n路上要小心色狼')
        break
    elif xz.upper() == 'C':
        print('你选择了绕远道回家')
        xz = input('☆是选择\n\tA.游戏厅玩会\n\tB.还是网吧？')
        if xz.upper() == 'A':
            print('一个半小时到家，爸爸在家，拿棍等你。')
        elif xz.upper() == 'B':
            print('两个小时到家，妈妈已做好了战斗准备。')
        else:
            print('输入错误')
    else:
        print('输入错误')

#选择A 执行过程
☆耶 下课了！你打算去做什么呢？
	 A.走大路回家☆ 
	 B.走小路回家☆ 
	 C.绕远道回家☆
请告诉你的选择[A|B|C]: a
你选择了走大路回家
☆是选择
	A.公交车
	B.还是步行？a
10分钟后到家...
Process finished with exit code 0

#选择B 执行过程
☆耶 下课了！你打算去做什么呢？
	 A.走大路回家☆ 
	 B.走小路回家☆ 
	 C.绕远道回家☆
请告诉你的选择[A|B|C]: b
你选择了走小路回家
路上要小心色狼

Process finished with exit code 0

#选择C 执行过程
☆耶 下课了！你打算去做什么呢？
	 A.走大路回家☆ 
	 B.走小路回家☆ 
	 C.绕远道回家☆
请告诉你的选择[A|B|C]: C
你选择了绕远道回家
☆是选择
	A.游戏厅玩会
	B.还是网吧？A
一个半小时到家，爸爸在家，拿棍等你。
☆耶 下课了！你打算去做什么呢？	# 返回，重新输入
	 A.走大路回家☆ 
	 B.走小路回家☆ 
	 C.绕远道回家☆
请告诉你的选择[A|B|C]: C
你选择了绕远道回家
☆是选择
	A.游戏厅玩会
	B.还是网吧？B
两个小时到家，妈妈已做好了战斗准备。	
☆耶 下课了！你打算去做什么呢？	# 返回，重新输入
	 A.走大路回家☆ 
	 B.走小路回家☆ 
	 C.绕远道回家☆
请告诉你的选择[A|B|C]:	

11.写代码，有如下列表，按照要求实现每一个功能

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
计算列表的长度并输出
列表中追加元素"seven",并输出添加后的列表
请在列表的第1个位置插入元素"Tony",并输出添加后的列表
请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请删除列表中的元素"ritian",并输出添加后的列表
请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
请删除列表中的第2至4个元素，并输出删除元素后的列表
请将列表所有得元素反转，并输出反转后的列表
请计算出"alex"元素在列表li中出现的次数，并输出该次数。

12.写代码，有如下列表，利用切片实现每一个功能

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通过对li列表的切片形成新的列表l5,l5 = ["c"]
通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]

13.写代码，有如下列表，按照要求实现每一个功能。

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写。
将列表中的数字3变成字符串"100"。
将列表中的字符串"1"变成数字101。

14.请用代码实现：

li = ["alex", "wusir", "taibai"]
利用下划线将列表的每一个元素拼接成字符串"alex_wusir_taibai"