[Python知识库]python基础之可迭代对象、函数

1.可迭代对象总结

• 列表：list

  • 表示方式:[]

  • 本质：是一种有序的，可变的，可以用来存储重复元素的集合

  • 系统功能：

    • 增：append extend insert

    • 删除： remove pop clear del

    • 改：
      - 列表[索引] = 值 reverse
      - sort: 升序 （默认的） 排序：reverse = True key :自定义排序规则

    • 查：

      • len count index max/min
      • 拷贝：
        • 列表.copy
        • copy.copy
        • copy.deepcopy
          #有没有拷贝就看是不是可变的，可变的就有拷贝的必要

  • 遍历方式：直接遍历元素、遍历索引

• 元组tuple:

"""

1 表示方式： （）    #当对应的元组中只有一个元素时候一定要添加逗号   （a,）

2本质：有序的，不可变的，可以存储重复元素的集合

3系统功能：查： len     

                             count()#只是在元组和列表中有这个，因为她两可以存储重复的元素的

			  index  

			max/min

4 遍历方式 ： 元素 遍历

                        索引遍历

"""

• 字典

字典：dict

1 表示方式 ： {}

2 本质:无序的，可变的，可以存储键值对的集合

3 系统功能：增：  字典[key] = vaule #（key不存在）

			       update 

				setdefault

			删除：pop(key)

					popitem  #随机删除一个

					clear

                                       del

			改：字典[key] = vaule  #key存在

			查：len #查键值对的对数

				get#通过key获取vaule，好处：key不存在不会报错

			拷贝：copy     copy.copy    copy.deepcopy

                   

                     其他：fromkeys      #船舰字典的

    4创建方式：[面试题]

	dict1 = {key:vaule .....}

           dict1 = {} ;   dict1[key] = vaule

	dict1{key=vaule,.......}

         dict1(zip([key....],[vaule....]))#zip(seq1,seq2)是映射，里面的参数就是两个序列#dict([(),()])和这个有点像 

        dict{[(key,vaule)......]}

          from   case  

5 遍历方式：

                       for key in 字典   #这个遍历的是key

			for key in 字典.keys()

			for  vaule in 字典.value()

			for vaule,vaule in 字典.items()

• 集合

"""
集合：set

1.表示方式：set()

                         {xx,xx}

2.本质：无序的，可变得，不允许存储对应元素的集合

3 系统功能：增：add   update

                     删：remove 

				clear

                             pop#因为没索引

                             # del不能删除其中的元素，因为字典是无序的，无法用索引来删除字典中的指定的元素，而那个列表可以是因为列表是有序的

 del 字典  #这是删除整个字典

                                discard #和remove比较得好处：不会报错

                       查：len   max  min   copy

4 遍历方式：只能遍历元素



"""

• 字符串

"""
1 表示方式：单引号，双引号和三引号

2本质：有序的，不可变的，可以存储重复字符的集合

3系统功能：

4遍历方式：元素

                    索引


len()    count()

1.系统功能

1.1转换

evil()：将str转换为有效的表达式				

upper():将小写字母转换为大写

lower():大---》小

swapcase():大---》小  小----》大

capitalize():首单词的首字母大写，其他全部小写        

title():每个单词的首字母大写，其他全部小写        

ord(),chr()

"""

# 1.eval()  将一个字符串中的Python代码转换出来    
# list1 = input("请输入一个列表：")
# print(list1,type(list1))
# r = eval(list1)
# print(r,type(r))

eval("print('hfajhgkajh')")

# print(int("3 + 4"))
print(eval("3 + 4"))

# 2.大小写转换
str1 = "This is A TeXT"
print(str1.upper())
print(str1.lower())
print(str1.title())   # 每个单词的首字母大写
print(str1.capitalize())  # 首单词的首字母大写
print(str1)

"""
1.2查找

find():从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到返回-1				

rfind():从右往左进行检索

index()：从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到则直接报错		  

rindex():从右往左进行检索

"""


'''
1.3填充

center(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居中显示			       

ljust(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居左显示，

rjust(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居右显示，

zfill(width)：原字符串居右显示，剩余的字符默认用0填充

'''
"""
center(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居中显示
ljust(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居左显示，
rjust(width[,fillchar]):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居右显示，

zfill(width)：原字符串居右显示，剩余的字符默认用0填充
"""
# 1.
s1 = "hello"
# a.省略fillchar,默认使用空格填充，注意：width指的是填充之后整个字符串的长度
s2 = s1.center(30)
print(s2)
# b.不省略fillchar，可以自定义,注意：fillchar的长度只能为1
# s2 = s1.center(30,"****")  # TypeError: The fill character must be exactly one character long
s2 = s1.center(30,"*")
print(s2)

# 2
s2 = s1.ljust(30,"*")
print(s2)
s2 = s1.rjust(30,"*")
print(s2)

# 3
# 注意：原字符串居右显示，zfill只能指定宽度，默认使用0填充,不能自定义填充字符
s2 = s1.zfill(30)
print(s2)
s2 = s1.rjust(30,"0")
print(s2)
"""
1.4提取

strip():去除一个指定字符串中两端指定的子字符       		

lstrip():去除一个指定字符串中左边指定的子字符

rstrip():去除一个指定字符串中右边指定的子字符
1.5合并和分割    

''.join(列表名)：使用指定的子字符串将列表中的元素连接【列表-----》字符串】		

列表名.split(''):使用指定的子字符串将原字符串进行分割，得到一个列表  【字符串-----》列表】

1.6替换

replace(old,new):将原字符串中的old替换为new			

映射替换：

	maketrans():生成映射表

	translate():根据映射表将指定字符串中的指定字符替换为映射表中对应的字符

1.7判断

isalpha():一个字符串非空并字符全部是字母才返回True    

isalnum():一个字符串非空并字符是字母或者数字才返回True   

isupper()/islower()/istitle():和upper，lower,title有关

isdigit()/isdecimal():一个字符串非空并字符全部是数字才返回True      

startswith()；判断一个字符串是否是以指定自字符串开头【前缀】    

endswith():判断一个字符串是否是以指定自字符串结尾【后缀】    

1.8编码和解码

encode():编码			

decode()；解码      

"""
# 字节类型：b"xxxx"

"""
编解码实际上指的是字符串类型【str】和字节类型【bytes】之间的类型转换
编码：将字符串类型转换为字节类型，实现方式：bytes()或者encode()
解码：将字节类型转换为字符串类型，实现方式：str()或者decode()

字符串表示：单引号，双引号和三引号
字节表示：b''

常用的编码格式：utf-8
              gbk
"""
# 一、编码
# 1.bytes(str,encoding="xx")
s1 = "fha23532%$##张健康"
print(type(s1))
b1 = bytes(s1,encoding="utf-8")
print(type(b1))
print(b1)
b1 = bytes(s1,encoding="gbk")
print(type(b1))
print(b1)

# 2.字符串.encode(encoding)
s1 = "fha23532%$##张健康"
b1 = s1.encode("utf-8")
print(b1)
b2 = s1.encode("gbk")
print(b2)

# 二、解码
# 注意：编解码的编码格式必须保持一致
# 1.str(bytes,encoding)
print(str(b1,encoding="utf-8"))
print(str(b2,encoding="gbk"))

# 2.字节.decode(encoding)
print(b1.decode(encoding="utf-8"))
print(b2.decode(encoding="gbk"))
"""
1.9格式化   

占位符

format()

f""

"""

# 1.占位符
"""
%d：整型
%f:浮点型
%s:一切对象【实体】
"""
# 注意：数量和类型的双重匹配
name = "jack"
age = 20
gender = "male"
print("姓名：%s,年龄：%d,性别：%s" % (name,age,gender))
# print("姓名：%d,年龄：%d,性别：%s" % (name,age,gender)) #TypeError: %d format: a number is required, not str
# print("姓名：%s,年龄：%d,性别：%s" % (name,age))  #TypeError: not enough arguments for format string

# 2.format()
# a.{}为空，则默认将指定的数据依次填充到其中，此时{}和数据的数量必须保持一致
print("姓名：{},年龄：{}，性别:{}".format(name,age,gender))
# print("姓名：{},年龄：{}，性别:{}，{}".format(name,age,gender))  # IndexError: tuple index out of range

# b.{}不为空，则会根据给定数据元组中的索引进行匹配，此时{}和数据的数量可以不一致
print("姓名：{0},年龄：{1}，性别:{2}，{0}".format(name,age,gender))
print("姓名：{0}".format(name,age,gender))
print("姓名：{0}，年龄：{0}，性别:{0}".format(name,age,gender))
print("姓名：{2}，年龄：{0}，性别:{1}".format(name,age,gender))

# 3.f""        
print(f"姓名：{name},年龄：{age},性别：{gender}")
print(f"{name}-{name}-{age}")

2.函数

• 本质：对某些特殊功能的封装

• 优点：

  a.简化代码结构，提高应用的模块性

  b.提高了代码的复用性

  c.提高了代码维护性

  d.提高了代码的可读性

• 语法：

	def  函数名(变量1，变量2....):
	      函数体
	        return   返回值

• 说明：

  • def是一个关键字，是definition的缩写，专门定义函数

  • .函数名：遵循合法标识符的规则和规范即可，尽量做到见名知意

  • (变量1，变量2…):被称为形式参数，是一个参数列表，都只是没有赋值的变量

  • 函数体：封装某些特殊的功能

  • return是一个关键字，表示返回，只能用在函数中，表示结束函数，可以单独使用，也可以携带数据，当携带数据，则表示该函数的返回值

  • 返回值:常量，变量，表达式

  • 函数的定义分为两部分：函数的声明和函数的实现

  • 变量1，变量2… 和 return 返回值 可以根据具体的需求选择性的省略

# 1.定义无参无返回值的函数
"""
a.如果函数没有参数，声明部分的（）不能省略
b.一个函数一旦被定义之后，都需要手动调用，否则无法执行
c.定义一个函数相当于定义了一个变量，函数名相当于是变量名，同样在内存中开辟空间
"""
print("start")
def test():
    print("hello")
# num = 10
# print(type(num))
# print(type(test))  # <class 'function'>
print("end")

# 2.定义有参无返回值的函数
"""
a.在函数声明部分出现的参数被称为形式参数，简称形参，只是一个变量，等待外界传参
b.形参的数量和类型需要根据具体的需求决定
"""
def check(num1,n1,m,a,num2):
    print("2222",n1)

# 3.定义有参有返回值的函数
# return表示返回，只能使用在函数中，作用是结束函数，并将指定的数据返回
def func(num1,num2):
    print("3333",num1,num2)
    return num1 + num2

• 函数调用

• 如果要确定一个函数的定义，则只需要确定两个要素

  • 参数:判断需求中是否有未知项参与运算【有无，数量，类型】

  • 返回值：判断函数体执行完毕之后是否有运算结果

# 语法：函数名(参数)
"""
形式参数：出现在函数的声明部分，简称形参，本质是一个变量
实际参数：出现在函数的调用部分，简称实参，本质是一个数据

当函数调用的时候，需要进行传参
传参：实参给形参赋值的过程
"""
# 1.函数的基本调用
def test():
    print("hello")
test()   # 注意：当形参为空，则实参也要为空，但是（）不能省略

def check(num1,num2):
    print("2222",num1,num2)
    print(num1 + num2)
check(3,5)   # 原理：num1 = 3   num2 = 5
# check("abc",3)  # TypeError: can only concatenate str (not "int") to str

def func(num1,num2):
    print("3333",num1,num2)
    return num1 + num2
r = func(4,7)
print(r)
print(func(2,5))

print("*"* 30)

# 2.函数之间的相互调用
def func1():
    print("11111")
    func2()

def func2():
    print("22222")
    func3()

def func3():
    num = 10
    print("3333")

print("start")
func1()
print("over")
# 入栈：func1--->func2--->func3
# 出栈：func3--->func2---->func1

# print(num)

# 3.恶意调用【递归】
# def a():
#     print("aa")
#     b()
# def b():
#     print("bb")
#     a()
# a()

# def a():
#     print("aa")
#     a()
# a()


"""
注意：
1.函数的使用一定要先定义，然后才能调用
2.一个函数一旦被定义完成，理论上可以调用无数次
3.代码执行的过程中，一旦遇到函数，则优先执行指定的函数，当函数执行完毕之后，则继续执行后面得到代码
4.函数调用的原理：
    调用：入栈
    调用结束：出栈
5.多个函数之间可以相互调用，但是，要避免恶意调用，如：A调用了B，B调用了A
"""


def add(num1,num2):
    resule = num1 + num2
    return resule
r = add(23,5)  # r = resule
print(r)

• 参数

  • 形式参数：简称形参，定义在函数的声明部分，本质是一个没有值的变量，用于接收实参的值

  • 实际参数：简称实参，出现在函数的调用过程中，本质是一个有值的变量或者常量，用于给形参赋值

  • 传参：实参给形参赋值的过程

参数分类：

• 必须参数
• 默认参数
• 关键字参数
• 不定长参数（可变参数）

# 1.注意1：如果形参是必需参数，则实参的数量和形参的数量必须匹配
def test1(a,b):
    print("gajhg")
test1(5,8)
test1(5,"fag")
test1("abc",True)

# 2.注意：如果参数是必需参数，而且在函数体中对参数的类型有限制，则实参需要类型的匹配
def test2(a,b):
    print("gajhg",a + b)
test2(5,8)
# test2("abc",8)
# test2(8,"abc")

# 3.注意：如果参数是必需参数，而且在函数体中对参数的顺序有限制，则实参必须按照顺序进行传参
def test3(name,age,gender):
    print("姓名：%s-年龄：%d-性别：%s" % (name,age,gender))
test3(10,"zhangsan","male")

3.大练兵

"""
已知字符串：“this is a test of Python”
a.统计该字符串中字母s出现的次数
b.取出子字符串“test”
c.采用不同的方式将字符串倒序输出
d.将其中的"test"替换为"exam"
"""
str1 = "this is a test of Python"

#a.
#法一
count1 = 0
for ch in str1:
    if ch == "s":
        count1 += 1
print(count1)

#法二
count2 = str1.count("s")
print(count2)

#b
str2 = str1[10:14]
print(str2)

#c
#法一
s1 = str1[::-1]
print(s1)

#法二
s2 = ""
i = len(str1) - 1    #倒序遍历
while i >= 0:
    s2 += str1[i]   #拼接字符串
    i -= 1
print(s2)

#法三
list1 = list(str1)
list1.reverse()

#d.将其中的"test"替换为"exam"        
#注意：但凡涉及字符串的更改，都是生成了一个新的字符串
str1 = "this is a test of Python"
str1.replace("test","exam")
print(str1)

"""
输入一个字符串，判断字符串中有多少个字母？多少个数字？
多少个其他符号？
例如:'hello, nice to meet you. i am 18. my birthday is 1999-05-23'
  -- 结果: 字母的个数为33个，数字个数为10个， 其他字符为16个
"""
input_str = input("请输入：")
letter_count = 0
digit_count = 0 
other_count = 0

for ch in input_str:
    if ch.isalpha():  #有缺陷，最好还是需要通过(ch >= "a" and ch <= "z") or (ch >= "A" and ch <= "Z")判断
        letter_count += 1
    elif ch.isdigit():
        digit_count += 1
    else:
        other_count += 1
"""
以下是一段歌词，请从这段歌词中统计出朋友出现的次数

“这些年一个人，风也过，雨也走，有过泪，有过错, 还记得坚持甚么，真爱过才会懂，会寂寞会回首，终有梦终有你在心中。朋友一生一起走，那些日子不再有，一句话，一辈子，一生情，一杯酒。朋友不曾孤单过，一声朋友你会懂，还有伤，还有痛，还要走，还有我。”
"""
str1 = "这些年一个人，风也过，雨也走，有过泪，有过错, 还记得坚持甚么，真爱过才会懂，会寂寞会回首，终有梦终有你在心中。朋友一生一起走，那些日子不再有，一句话，一辈子，一生情，一杯酒。朋友不曾孤单过，一声朋友你会懂，还有伤，还有痛，还要走，还有我。"
c = str1.count("朋友")

"""
编写敏感词过滤程序

说明：在网络程序中，如聊天室、聊天软件等，经常需要对一些用户所提交的聊天内容中的敏感性词语进行过滤。如“性”、“色情”、“爆炸”、“恐怖”、“枪”、“军火”等，这些都不可以在网上进行传播，要求输入一段文本，如果包含以上的敏感词汇，需要*替换掉
例如：“军火走私” ---- 结果为 "**走私"
"""
data = input("请输入")
words = ['性'、'色情'、'爆炸'、'恐怖'、'枪'、'军火']

for word in words:
    print(data)
    if data.find(word) != -1:
        # 替换
        data = data.replace(word,"*" * len(word))
print(data)

"""
.输入一个用户名，判断用户名是否合法。用户名要求：由英文字母或数字组成，长度是6到12位

例如：‘abcd’ --- 不合法  "123456" -- 合法 ‘ABC23’ -- 不合法   ‘ABC123’ -- 合法
“abc 124” --- 不合法
"""
 
username = input("请输入你的用户名：")
# isalnum()有缺陷，最好还是需要通过(ch >= "a" and ch <= "z") or (ch >= "A" and ch <= "Z") or (ch >= "0" and ch <= "9")判断
if username.isalnum() and 6 <= len(username) <= 12:
	print("用户名{}合法".format(username)) 
else:
	print("用户名{}不合法".format(username))

"""
随机生成长度为5的验证码， 验证码的组成是英文字母或者数字
"""
import random
letter_digit_list = []
# 大写字母
for i in range(65, 91):
    letter_digit_list.append(chr(i))
# 小写字母
for j in range(97, 123):
    letter_digit_list.append(chr(j))
# 数字
for k in range(10):
    letter_digit_list.append(str(k))

code = ""
for n in range(5):
    code += random.choice(letter_digit_list)
print(code)

"""
实现将字符串"1,2,3"   变成列表 ["1","2","3"]
"""
str1 = "1,2,3"
list1 = str1.split(",")


"""

判断输入的字符串是否是 .py 结束
"""
data = input("请输入字符串：")
result = data.endswith(".py")



"""
输入一个字符串，将字符串中所有的数字符取出来产生一个新的字符串 

例如： 输入: 'abc1shj23kls99+2kkk'   输出： '123992'
"""
new_str = input("请输入一段文本：")
new_str = ""
for ch in a:
    if ch.isdigit():
        new_str += ch
print(new_str)

"""
输入用户名，判断用户名是否合法，用户名的要求：必须由数字和字母
且只能有数字和字母，并且第一个字符是大写字母

例如：  'Abc'  — 不合法    '123'  — 不合法   'abc123'  — 不合法    'Abc123ahs' — 合法
"""
 
username = input("请输入用户名:")
if username[0].isupper() and not username.isdigit() and not username.isalpha()
and username.isalnum():
	print("用户名{}合法".format(username)) 
else:
	print("用户名{}不合法".format(username))


"""
输入两个字符串，打印两个字符串中公共的字符，如果没有公共字符打印
 公共字符不存在
例如： 字符串1为 abc123a , 字符串2为  huak33 , 打印 a3
"""

str1 = input("请输入第一段文本：")
str2 = input("请输入第二段文本：")
equal_list = [] 
for ch in str1:
    if ch in str2 and ch not in equal_list:
        equal_list.append(ch)
equal_str = "".join(equal_list)  
print(equal_str)

"""
  如下字符串:  "01#张三#60-02#李四#90-03#王五#70", 每一部分表示
  学号#姓名#分数，提取学生信息存放于列表中，并按照成绩对学生降
  序排序
  
结果显示为:
[{"学号":'02', '姓名':'李四', '分数':90}, {"学号":'03', '姓名':'王五', '分数':70}, {"学号":'01', '姓名':'张三', '分数':60}]
"""

info_str = "01#张三#60-02#李四#90-03#王五#70"
info_list = info_str.split("-")
all_stu_list = []
for stu_info in info_list:
    stu_list = stu_info.split("#")
    stu_dict = {"学号": stu_list[0], '姓名': stu_list[1], '分数':int(stu_list[2])}
    all_stu_list.append(stu_dict)

for i in range(len(all_stu_list) - 1):
    for j in range(i + 1, len(all_stu_list)):
        if all_stu_list[i]["分数"] < all_stu_list[j]["分数"]:
            all_stu_list[i], all_stu_list[j] = all_stu_list[j],all_stu_list[i]
print(all_stu_list)


# 1.，有如下变量，请按照要求实现每个功能
name = "gouguoQ "

# a.移除name变量对应值的两边的空格，并输出移除后的内容
name = "      gouguoQ          "
print(name)
"""
strip():去除一个指定字符串中两端指定的子字符       		
lstrip():去除一个指定字符串中左边指定的子字符
rstrip():去除一个指定字符串中右边指定的子字符
"""
# 语法： 字符串.strip(char),char默认为空格，也可以自定义
a1 = name.strip()
print(a1)
name = "***hfahf*********"
a2 = name.strip("*")
print(a2)
print(name)
a3 = name.lstrip("*")
a4 = name.rstrip("*")
print(a3)
print(a4)

# 使用场景：一般用于去除用户输入的数据中可能产生的空格

# b.判断name变量对应的值是否以"go"开头，并输出结果
# c.判断name变量对应的值是否以"Q"结尾，并输出结果
"""
startswith()；判断一个字符串是否是以指定自字符串开头【前缀】    
endswith():判断一个字符串是否是以指定自字符串结尾【后缀】
"""
name = "gouguoQ "
b = name.startswith("go")
print(b)
c = name.endswith("Q")
print(c)

# 使用场景：判断文件的后缀，判断邮箱，判断网址url等

# d.将name变量对应的值中的"o"，替换为"p"，并输出结果
name = "gouguoQ "
# 情况一：replace,replace(old,new,count)
d = name.replace("o",'p')
print(d)

# 需求：将good--->bad
s1 = "nice good nice good good good"
# 注意1：默认情况下新的字符串会将原字符串中旧的字符串全部替换掉
s2 = s1.replace("good","bad")
print(s2)
# 注意2：可以指定替换的次数
s3 = s1.replace("good","bad",2)
print(s3)

# 情况二：映射替换
"""
maketrans(str1,str2):生成一个映射表,注意：str1和str2的长度必须相等
translate():翻译，借助于映射表，将指定字符串中的字符替换为映射中对应的字符
"""
str1 = "718750157018151234"
t = str.maketrans("1234563","abcdefx")
str2 = str1.translate(t)
print(str1)
print(str2)

t1 = str.maketrans("o","p")
name2 = name.translate(t1)
print(name2)

# e.将name变量对应的值根据"o"分割，并输出结果
"""
split(char,count),用char将原字符串进行分隔，注意：得到的结果为一个列表，字符串----》列表
"""
s1 = "abc-hello-3223-fhajghak-ffh"
# 注意1：默认情况下全部分割
r1 = s1.split("-")
print(r1)
# 注意2：可以自定义分割次数
r2 = s1.split("-",2)
print(r2)

# 注意3：字符串中的split只能分割有规律的字符串
# 可以借助于列表操作
s1 = "abc-----hello---3223-fhajghak----ffh"
r3 = s1.split("-")
print(r3)
for substr in r3[:]:
    if substr == "":
        r3.remove(substr)
print(r3)

# 正则表达式:分割没有规律的字符串
import  re
r4 = re.split(r"-{1,}",s1) # -{1,}表示-至少出现一次
print(r4)

name = "gouguoQ "
# g.将name变量对应的值变大写，并输出结果
print(name.upper())

# h.将name变量对应的值变成小写，并输出结果
print(name.lower())
# i.请输出name变量对应的值的第二个字符
# 访问字符串中的字符
print(name[1])
# j.请输出name变量对应的值的前三个字符
# 切片
print(name[:3])

# k.请输出name变量对应值的后2个字符
print(name[-1:-3:-1])
print(name[len(name) - 2:])

# l.请输出name变量中的值"Q的索引的位置
"""
find(substr,start,end):从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到返回-1				
rfind():从右往左进行检索
index()：从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到则直接报错		  
rindex():从右往左进行检索
"""
l1 = name.index("Q")
l2 = name.find("Q")
print(l1,l2)

# 特殊：find返回-1.index报错
# l1 = name.index("x")   # ValueError: substring子字符串 not found
l2 = name.find("x")
print(l2)

# m.获取子序列，仅不包含最后一个字符，如：woaini则获取woain  root则获取roo
print(name[:len(name) - 1])
# n.利用下划线将列表li = ['gou', 'guo', 'qi']的每一个元素拼接成字符串gou_guo_qi
"""
连接字符串.join(list),将一个列表中的元素使用指定的子字符串进行连接，得到一个新的字符串
"""
li = ['gou', 'guo', 'qi']
n = "_".join(li)
print(n)  #gou_guo_qi
li1 = n.split("_")
print(li1)