# 字符串
可以用单引号,双引号和三引号定义
name = 'wang'
print(type(name), name) # <class 'str'> wang
name = "yi"
print(type(name), name) # <class 'str'> yi
name = '''bo'''
print(type(name), name) # <class 'str'> bo
name = """cute"""
print(type(name), name) # <class 'str'> cute
# 字符串 * n 可以将字符串打印n遍
a = '*' * 5 # '*****'
print(a)
b = '3' * 6 # '333333'
print(b)
# 字符串的输入和输出
input() # 输入,函数的到的内容就是字符串
print() # 输出 %s 或者 f"{}"
# 下标
# 下标(索引,编号)可以是正整数也可以是负整数
# 正整数下标是从0开始的,表示第一个字符
# 负整数下标是从-1开始的,表示最后一个字符
my_str = 'hello'
print(my_str[0]) # h
print(my_str[1]) # e
print(my_str[-1]) # o
print(my_str[-4]) # e
# len可以得到字符串长度
print(len(my_str)) # 5
# 使用正数下标书写字符串中最后一个元素
print(my_str[len(my_str)-1]) # o
#切片
# 切片:会得到一个新的字符串
# 切片可以获取一段数据,下标只能获得一个数据
# 切片语法:变量[start:end:step] ,start 表示开始位置的下标 , end 表示结束位置的下标, step 表示步长,下标之间的间隔,默认是1
my_str1 = my_str[1:3] # el 下标为1和2的字符
my_str2 = my_str[2:4] # ll 下标为2和3的字符
my_str3 = my_str[1:4:2] # el 下标在1到4之间,从下标1的字符开始,每隔两个字符取一个
# 当step为1时可省略不写,当end不写时可以取到最后一个元素(冒号不可省略),当start不写时表示从第第一个开始取(冒号不可省略)
my_str4 = my_str[1:] # ello
my_str5 = my_str[:2] # he 下标为0和1的,下标为2的取不到
my_str6 = my_str[:] # hello 得到和原来一样的字符
my_str7 = my_str[3:1] # 无数据
my_str8 = my_str[-3:-1] # ll
# step可以为负数
my_str9 = my_str[3:1:-1] # ll 位置换成1:3无法出结果
my_str10 = my_str[::-1] # 字符串反转 olleh
my_str11 = my_str[::2] # hlo 取下标为0,2,4的值
# 字符串常见操作
my_str = 'hello world itcast and itcastcpp' # 定义一个字符串变量
# 查找类:find(),index(),count()
# find() 在字符串中查找是否存在某个字符串
# my_str.find(sub_str, start, end)
# sub_str:要在字符串中查找的内容
# start:开始位置,从哪里开始查找,默认是0
# end:结束位置,查找到哪里结束,默认是len()
# 返回值:即方法执行的结果是什么,如果找到sub_str,返回的sub_str在my_str中的位置的正数下标,没有找到则返回-1
my_str1 = my_str.find('hello') # 0
my_str2 = my_str.find("hello", 3) # 从下标为3的位置开始查找字符串'hello' ,未找到,返回值-1
my_str3 = my_str.find("itcast") # 12 返回第一个字符的下标,空格也算一个字符
my_str4 = my_str.find("itcast", 15) # 23
# rfind() right find() 从右边(后边)开始查找
my_str5 = my_str.rfind("itcast") # 23
# index() 在字符串中查找是否存在某个字符串
# my_str.index(sub_str, start, end)
# sub_str:要在字符串中查找的内容
# start:开始位置,从哪里开始查找,默认是0
# end:结束位置,查找到哪里结束,默认是len()
# 返回值:即方法执行的结果是什么,如果找到sub_str,返回的sub_str在my_str中的位置的正数下标,没有找到则会报错
# 与find()的区别就在没找到会报错,其他操作和参数都不变
my_str2 = my_str.index("hello", 3) # 未找到,代码报错
# rindex()与rfind()一样
# count(sub_str, start, end) 统计出现次数
my_str1 = my_str.count('aaaa') # 0
my_str2 = my_str.count('hello') # 1
my_str3 = my_str.count('itcast') # 2
my_str4 = my_str.count('itcast', 20) # 1
# 字符串替换操作
# replace(old_str, new_str, count)
# old_str:将要被替换的字符串
# new_str:替换成的新的字符串
# count:替换次数,默认是全部替换
# 返回值:得到一个新的字符串,不会改变原来的字符串
my_str1 = my_str.replace('itcast', 'itheima') # hello world itheima and itheimacpp
my_str1 = my_str.replace('itcast', 'itheima', 1) # hello world itheima and itcastcpp
# 字符串切割操作
# my_sub.split(sub_str, count) 将my_str字符串按照sub_str进行切割
# sub_str: 按照什么内容切割字符,默认是空白字符(空格键,Tab键)
# count: 切割几次,默认是全部切割
# 返回值: 列表 []
result = my_str.split() # 按照空白字符全部切割 ['hello', 'world', 'itcast', 'and', 'itcastcpp']
result1 = my_str.split('itcast') # 按照'itcast'字符全部切割 ['hello world', 'and', 'cpp']
result2 = my_str.split('itcast', 1) # 按照'itcast'字符切割一次 ['hello world', 'and itcastcpp']
# rsplit() 从右边开始切割
result3 = my_str.rsplit('itcast',1) # 按照'itcast'字符从右开始切割一次 ['hello world itcast and', 'cpp']
# 字符串连接操作
# join(可迭代对象)
# 可迭代对象:str, 列表(需要列表里的每个元素都是str类型)
# str.join():将str这个字符串添加到可迭代对象的两个元素之间
# 返回值:一个新的字符产,不会改变原字符串的值
my_str = '_'.join('hello') # 会把'_'加入到'hello'每两个元素之间 即:h_e_l_l_o
my_str1 = '_*_'.join('hello') # 会把'_*_'加入到'hello'每两个元素之间 即:h_*_e_*_l_*_l_*_o
my_list = ['hello', 'cpp', 'python'] # 定义一个列表
my_list1 = '_'.join(my_list) # hello_cpp_python
my_list1 = '_*_'.join(my_list) # hello_*_cpp_*_python
my_list1 = ' '.join(my_list) # hello cpp python
# 其他操作
my_str = ' hello itcast and itcastapp '
my_str.capitalize() # 将第一个单词的首字母大写,即: Hello itcast and itcastapp
my_str.title() # 将每一个单词的首字母大写,即: Hello Itcast And Itcastapp
my_str.upper() # 将第所有字母大写,即: HELLO ITCAST AND ITCASTCPP
my_str.lower() # 将第所有字母小写,即: Hello itcast and itcastapp
my_str.islower() # 判断全部是不是小写
my_str.startswith('he') # 判断是不是以he(括号里的字符)为开头的,如果是输出True,不是则输出False,此处为True
my_str.ljust(30) # 返回一个原字符串左对齐,并使用空格填充至长度为30的新字符串即
my_str.rjust(30) # 返回一个原字符串右对齐,并使用空格填充至长度为30的新字符串
my_str.center(30) # 返回一个原字符串居中,并使用空格填充至长度为30的新字符串
my_str.lstrip() # 删除my_str左边的空白字符 hello itcast and itcastapp
my_str.rstrip() # 删除my_str右边的空白字符 hello itcast and itcastapp
my_str.strip() # 删除my_str两边的空白字符hello itcast and itcastapp
my_str.partition('itcast') # 把my_str分割成三部分,itcast前,itcast,itcast后,即:(' hello ', 'itcast', ' and itcastapp ')
my_str.rpartition('itcast') # 类似于partition,不过是从右边开始,即:(' hello itcast and ', 'itcast', 'app ')
my_str.splitlines() # 按照行分割,返回一个包含各行作为元素的列表
my_str.isalpha() # 如果my_str所有字符都是字母,则返回True,否则返回False
my_str.isdigit() # 如果my_str只包含数字则返回True,否则返回False
my_str.isalnum() # 如果my_str所有字符都是字母或数字组成,则返回True,否则返回False
my_str.isspace() # 如果my_str中只包含空格,则返回True,否则返回False
# 列表
# 列表:是一种数据类型,可以存放多个数据,列表中的数据可以是任意类型的
# 列表list,用[]进行定义
my_list = [] # 定义空列表
my_list1 = list() # 定义空列表
my_list2 = [1, 3.14, True, 'hello']
num = len(my_list2) # 求列表中数据元素的个数,即列表的长度
# 列表支持下标和切片操作
my_list3 = my_list2[1] # 3.14
my_list4 = my_list2[-1] # hello
my_list5 = my_list2[1:3] # [3.14, True]
# 下标操作和字符串不同的是,字符串不能使用下标修改其中的数据,但是列表可以使用下标修改列表中的数据
my_list2[0] = 18 # [18, 3.14, True, 'hello']
my_list2[0] = 'python' # ['python', 3.14, True, 'hello']
# 列表遍历元素
my_list = ['王一博', '酷盖', '王甜甜', '王椰啵']
for i in my_list:
print(i) # i就是列表中的每个数据
# 列表遍历下标
num = len(my_list)
i = 0
while i < num:
print(f"{my_list[i]}的下标是{i}")
i += 1
结果:
# 列表的相关操作
# 添加元素(append,extend,insert),都是在原数据上添加的,不会返回新列表
# my_list.append(数据) 向my_list中添加数据
my_list.append('谢允') # ['王一博', '酷盖', '王甜甜', '王椰啵', '谢允']
# my_str.insert(下标,数据) 在指定的下标位置添加数据
my_list.insert(0, '季向空') # 在列表下标为0的地方添加数据,即:[‘季向空’, '王一博', '酷盖', '王甜甜', '王椰啵', '谢允']
# my_list.extend(可迭代对象:str或列表) 会将可迭代对象中的数据逐个添加到列表的末尾
my_list.extend('蓝忘机') # [‘季向空’, '王一博', '酷盖', '王甜甜', '王椰啵', '谢允', '蓝', '忘', '机']
my_list.extend(['蓝忘机', 85, 1997]) # ['季向空', '王一博', '酷盖', '王甜甜', '王椰啵', '谢允', '蓝', '忘', '机', '蓝忘机', 85, 1997]
# 数据查询(index(),count(),in/not in)
# index() 根据数据值,查找元素所在的下标,找到返回元素的下标,没有找到程序报错
# 列表中没有find()方法
my_list = [1, 3.14, True, 'hello']
num = my_list.index(3.14) # 查找3.14所在下标,即:1
print(num)
# count() 统计出现的次数
num1 = my_list.count(3.14) # 统计3.14出现的次数,即:1
print(num1)
num2 = my_list.count(1) # 结果为2,因为列表中的True会被当成1,所以算出现两次
# in/not in 判断是否存在,存在是True,不存在是False
num3 = 3.14 in my_list # True
num4 = 3.14 not in my_list # False
# 删除操作
my_list = [1, 2, 4, 5, 6, 9]
# 1.根据元素数据值删除 remove(),直接删除原列表中的数据,删除的数据不存在时会报错
my_list.remove(4) # [1, 2, 5, 6, 9]
print(my_list)
# 2.根据下标删除
# pop() 默认删除最后一个数据,返回删除内容,括号里有下标时按下标删除,当输入的下标在列表中不存在时程序报错
num = my_list.pop() # 删除最后一个数据9
print(num) # 9
print(my_list) # [1, 2, 5, 6]
num = my_list.pop(2) # 删除下标为2的数据5
print(num) # 5
print(my_list) # [1, 2, 6]
# del my_list[下标] 删除列表中下标位置的数据,当输入的下标在列表中不存在时程序报错
del my_list[1] # 删除下标位置为1的数据2
print(my_list) # [1, 6]
# 列表排序
# 想要对列表中的数据进行排序,前提是列表中的数据类型是一样的
# list.sort() 直接在原列表进行排序
my_list = [1, 5, 3, 7, 9, 6]
my_list.sort() # 默认从小到大(升序),即 [1, 3, 5, 6, 7, 9]
print(my_list)
my_list.sort(reverse=True) # 从大到小(降序),即 [9, 7, 6, 5, 3, 1]
print(my_list)
# sorted(list) 不会在原列表中进行排序,会生成一个新的列表
my_list = [1, 5, 3, 7, 9, 6]
my_list1 = sorted(my_list)
print(my_list) # [1, 5, 3, 7, 9, 6]
print(my_list1) # [1, 3, 5, 6, 7, 9]
my_list2 = sorted(my_list,reverse=True)
print(my_list) # [1, 5, 3, 7, 9, 6]
print(my_list2) # [9, 7, 6, 5, 3, 1]
# 列表逆置
my_list = ['a', 'b', 'c', 'd', 'e']
my_list3 = my_list[::-1]
print(my_list) # ['a', 'b', 'c', 'd', 'e']
print(my_list3) # ['e', 'd', 'c', 'b', 'a']
# 在原列表中直接逆置 reverse()
my_list.reverse()
print(my_list) # ['e', 'd', 'c', 'b', 'a']
# 列表嵌套
school_names = [['北京大学', '清华大学'],
['浙江大学', '复旦大学'],
['四川大学', '武汉大学']]
print(school_names[1]) # ['浙江大学', '复旦大学']
print(school_names[1][1]) # 复旦大学
print(school_names[1][1][1]) # 旦
for schools in school_names:
print(schools)
# ['北京大学', '清华大学']
# ['浙江大学', '复旦大学']
# ['四川大学', '武汉大学']
for name in schools:
print(name)
# ['北京大学', '清华大学']
# 北京大学
# 清华大学
# ['浙江大学', '复旦大学']
# 浙江大学
# 复旦大学
# ['四川大学', '武汉大学']
# 四川大学
# 武汉大学
# 案例:分配工作室
# 一个学校,有三个办公室,现在有8位老师等待工位的分配,请编写程序,完成随机的分配
import random
offices = [[], [], []] # 定义一个列表存放3个办公室,对应下标0, 1, 2
teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] # 定义一个列表存放老师
for i in teachers: # 让每个老师出来选择
num = random.randint(0, 2) # 每个老师抓阄去几号办公室,即让电脑产生随机数
offices[num].append(i) # 将老师分别添加进各个offices中
print(f"老师{i}去了{num}号办公室")
print(offices) # 打印出所有办公室列表
for count in range(0, 3):
print(f"{count}号办公室有{len(offices[count])}人") # count号的办公室里有多少人
for name in offices[count]:
print(f"老师的名字为{name}") # 每个办公室里有那些老师
结果:
# 元组
# 元组 也是一种数据类型
# 元组与列表类似,可以存放多个数据,可以存放不同数据类型,但是区别在于元组不能修改里面的元素,也就是说没有增删改查的操作
# 元组用()定义
my_tuple = () # 定义空元组,无意义,因为无法修改
my_tuple1 = tuple() # 定义空元组
my_tuple2 = (3) # 定义一个数据元素是int类型
print(type(my_tuple2)) # <class 'int'>
# 要想定义一个只有一个数据元素的元组
my_tuple3 = (3,) # 数据元素后面一定要有一个逗号!!!
print(type(my_tuple3)) # <class 'tuple'>
my_tuple = (18, 3.14, True, 'hello')
# 元组支持下标和切片操作
my_tuple1 = my_tuple[1]
print(my_tuple1) # 3.14