python基础知识学习第三课

# 字符串(接第二课)
# 5.字符串替换
# 语法：变量名.replace(原字符串，新字符串，次数)
# 可以指定替换次数，如果不指定，则全部替换
# str="python,world,python,hello"
# print("这个是替换之前的字符串",str)
# print("这个是替换之后的字符串",str.replace("python","linux",1))#指定次数后替换的是从左边开始的要替换的字符串
# print("这个是替换之后的字符串",str.replace("python","linux"))#不指定次数全部替换
# print("替换后查看原字符串结果",str)#打印结果是原字符串，说明替换时，仅在当次输出临时替换，显示替换后的结果，原字符串是一种不可变数据类型

# 6.替换指定位置的小字符串(字符串的拆分和拼接)
# 格式：变量名.split('切分标记',次数)#分隔后的数据会生成一个列表
# 替换字符串"python,world,python,hello"中的第二个python为其它内容
# 把第二python替换为linux
# str="python,world,python,hello"
# list=str.split(",")#通过逗号把原字符串进行分隔
# print(list)#分隔完打印生成的列表
# list[2]="linux"#通过索引替换列表中的数据
# print(list)#打印替换后列表的数据
# new_str1=",".join(list)#通过逗号拼接将新列表中的内容重新生成字符串
# print(new_str1)#打印重新拼接后的字符串
#如果不指定切分标记，字符串整体作为列表的一个元素
# list=str.split()

# 7.字符串的大小写转换
# 01.字符串转换为小写
# 格式:字符串名.lower()
# str="AABBcc"
# print(str)
# print(str.lower())#打印转换为小写后的内容
# 02.字符串转换为大写
# 格式:字符串名.upper()
# str="aabbccDD"
# print(str)
# print(str.upper())#打印转换为大写后的内容

# 8.字符串的拆分
# 格式：变量名.split('切分标记',次数)
# 可以指定切分次数，如果不指定，则全部切分
# my_str = 'hello,python,python,java'
# print(my_str.split(',')) # 不指定次数，全部切分，返回结果：['hello', 'python', 'python', 'java']
# print(my_str.split(',', 1)) #指定切分1次，返回列表：['hello', 'python,python,java']
# print(my_str.split('python')) # 仅做理解，返回列表：['hello,', ',', ',java']

# 若不指定切分标记，默认切分字符串中的回车符\r、制表符\t(代表4个空格)、换行符\n、空格
# info_str1 = 'he\rllo,\tpytho\nn,py thon,java'
# info_str2 = 'hello,python,python,java'
# print(info_str1)
# print(info_str1.split())
# print(info_str2)
# print(info_str2.split()) # 未指定切分标记，字符串整体作为列表的一个元素

# 9.字符串的拼接
# 01字符串的加法拼接
# str="hello"
# str1="python"
# print(str1+str)#拼接后没有空格
# 02字符串的逗号拼接
# str="hello"
# str1="python"
# print(str,str1)#逗号拼接有空格
# 03指定内容作为分隔符，拼接变量中的所有元素，拼接成一个新字符串
# 格式：'拼接内容'.join(变量名)
# my_str='0123456789'
# print('#'.join(my_str))
# print('$'.join(my_str))
# print(''.join(my_str)) #空
# print(' '.join(my_str)) #空格

# 10.字符串的切片
# 1.通过字符串的切片，获取字符串中指定部分的字符
# 语法：字符串[开始索引：结束索引：步长]
# 步长：获取数据的步调长度，步长为正1时，可以省略
# 注意：切片的范围：包含开始位置索引，不包含结束位置的索引，只能获取到结束位置索引的前一个位置的数据，是一个左闭右开的区间[ )。

# str="hello,python"
#切出字符串"hello"
# print(str[0:5])#切片的范围，包含开始位置索引，不包含结束位置的索引，步长为1时可以省略
# #切出字符串"eo"
# print(str[1:5:3])#索引从指定位置开始切片，指定位置先被切出，然后通过步长切片
# #把hello,python切出来
# print(str[::])#开始位置索引是边界，开始位置索引可以省略，步长为1可以省略，结束位置索引为边界，可以省略
# #把python切出来
# print(str[6::])#结束位置为索引边界，可以省略，步长为1可以省略
# 练习：切出字符串，开始索引是6，切到字符串结尾，步长为2
# info_str = 'hello,python'
# print(info_str[6::2])

# 2.倒序切片，步长是负数（表示倒序方向切片）
# str="hello,python"
#切出 nohtyp
# print(str[-1:-7:-1])#获取开始索引，不获取结束位置索引，-1表示从右往左切，步长为1
# print(str[:-7:-1])#开始位置是字符串边界，开始位置索引可以省略
# print(str[11:5:-1])#倒序切片，可以用正序的索引号，注意开始和结束位置，不包含结束位置的索引号
# print(str[-10:-7:1])#正序切片，也可以用倒序的索引号，注意开始和结束位置，不包含结束位置的索引号
# print(str[-10:5:1])#正序索引和倒序索引号，可以一起使用，注意开始结束位置索引，不包含结束位置索引号。
# 面试题：将字符串str1逆(倒)序输出
# str1="hello,python"
# print(str1[::-1])#开始位置和结束位置为边界，可以省略
# 总结：
# 开始位置索引是边界时，可以省略
# 结束位置索引是边界时，可以省略
# 步长为1时，可以省略
# 切片范围：获取开始索引位置字符，不获取结束位置索引字符

# 列表
# 列表：存放多个变量组成大量数据
# 列表可以存放多个数据，并且列表是有序的序列容器，列表是可变的
# 1.列表格式
# list1=[值1,值2,值3...]
# list1=list()#空列表
# print(list1)
# 列表可以存储任意类型的数据:数字类型、字符串、列表、元组、字典。
# 例如:
# my_list=[100,12.35,True,"hello",[10,22],(44,"py"),{"name":"流川枫"}]
# print(my_list)

# 2.列表中的数据通过索引号的方式来访问：（列表是有序的数据容器）
# 格式：列表名[索引号码]
# my_list=[100,12.35,True,"hello",[10,22],(44,"py"),{"name":"流川枫"}]
# print(my_list[3])
# print(my_list[-1])#逗号分隔了不同索引号的数据

# 3.列表的添加
# 01.在指定位置插入数据
# 语法：列表名.insert(索引号,数据)
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:",list1)
# list1.insert(2,"A")#在指定的索引号位置插入数据。插入数据，打印列表，分两步走
# print(list1)
#插入位置的索引号的数据往后边移动

# 02.向列表中插入小列表
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# list1.insert(10,[10,22])#在列表中插入小列表
# print(list1)

# 03.在列表末尾追加数据
# 格式:列表名.append(数据)
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# list1.append("李白")#在列表末尾追加数据。追加数据，打印列表，分两步走
# print(list1)
# list1.append(12)
# print(list1)

# 4.合并列表数据
# 把列表2的数据合并到列表1中去
# 语法：列表1.extend(列表2)
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# list1.extend([10,55,66])#把列表2数据放到列表1中，列表2的数据在列表1末尾显示
# print(list1)

# list1=[1,2,3,4,5,6,7,8,9]
# list2=[10,55,66]
# print("这是原来的列表:", list1)
# list1.extend(list2)#把列表2数据放到列表1中，列表2的数据在列表1末尾显示
# print(list1)

# 5.列表的删除
# 01.删除指定索引的数据
# 语法:del 列表[索引] #中间有空格
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# del list1[4]
# print(list1)
# del list1[-1]
# print(list1)

# 02.把列表从内存当中清除(变量是保存在内存中的)
# 语法: del 列表名
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# del list1 #删除后 list1 变量不存在
# print(list1)

# 03.清空列表
# 语法：格式：列表名.clear() 清空列表内容
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# list1.clear()#清空后列表变成空列表
# print(list1)

# 04.删除列表的末尾数据(可以返回删除的数据)
# 语法:列表名.pop()
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# num=list1.pop()#删除末尾的最后的数据。可以用变量来接收删除的数据
# print(num)
# print(list1)#打印的是删除末尾数据的列表

# 05.删除指定索引数据(可以返回删除的数据)
# 语法：列表名.pop(索引号)
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# num=list1.pop(3)#pop后的括号内写索引号
# print(num)#打印删除掉的数据
# print(list1)#打印删除数据后的列表

# 6.列表的修改
# 列表中的数据是可以修改的(字符串不能修改)
# 格式:列表名[索引号]=新内容
# list1=[1,2,3,4,5,6,7,8,9]
# print("这是原来的列表:", list1)
# list1[1]=10
# print(list1)

# 7.列表的查询
# 01.通过索引号获取数据
# 格式:列表名[索引号]
# list1=[1,2,3,4,5,6,7,8,9]
# print(list1[6])

# 02.通过数据获取索引号
# 格式:列表名.index(数据)
# list1=[1,2,3,4,5,6,7,8,9]
# print(list1.index(4))#数字4的索引号是3

# 8.列表的高级操作
# 01.统计列表中的数据个数
# 格式:len(列表名)
# list1=[1,2,3,4,5,6,7,[8,9]]
# print(len(list1))#列表中的数据是通过逗号分隔的

# 02.统计数据在列表中出现的次数
# 格式：列表名.count(数据)
# list1=[1,2,8,3,4,5,5,6,"2",7,[8,9]]
# print(list1.count("2"))
# print(list1.count(8))
# print(list1.count([8,9]))
# print(list1.count(5))

# 03.列表的排序
# 升序
# 格式:列表名.sort() 先排序，后打印，两步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.sort()#升序排序
# print(my_list)#打印排序后的列表

# 降序
# 格式：列表名.sort(reverse=True) 先排序，后打印，两步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.sort(reverse=True)#对列表降序排序
# print(my_list)#打印降序后的列表

# 列表的逆序、反转
# 格式: 列表名.reverse()先反转，再打印，两步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.reverse()#逆序
# print(my_list)打印逆序后的列表

# 9.列表的拷贝
# 格式:新列表名=原列表名.copy()
# id()函数可以查看变量保存数据的内存地址，括号内填写变量名
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# print(my_list,id(my_list))
# list1=my_list.copy()
# print(list1,id(list1))
#copy后的内存地址发生变化

# 10.dir()函数，查看变量(对象)所有的方法和属性
# print(dir(str))#查看字符串的所有方法和属性
# print(dir(list))#查看列表的所有方法和属性
# print(dir(tuple))#查看元组的所有方法和属性
# print(dir(dict))#查看字典的所有方法和属性

# 元组
# 元组和列表一样，都是用来存储多个数据
# 通过元组可以存放多个数据，并且这些数据不会被修改
# 1.列表和元组异同
# 相同点:
# 1.都是序列
# 2.都可以存储任意类型数据
# 3.都可以通过索引访问
# 不同点:
# 1.使用方括号[]创建列表，使用小括号()创建元组
# 2.列表是可变的，元组是不可变的，这是二者之间的关键差异
# 3.可以修改列表的值，不能修改元组的值。(元组中的数据修改是收到限制的，当元组中包
# 含列表或字典，列表和字典中的数据是可以修改的)
# 4.由于列表是可变的，不能将列表作为字典的键，但是元组可以作为字典的键

# 2.元组的应用场景
# 1.函数进阶部分，函数的参数使用到了元祖，函数的多个返回值使用到了元祖
# 2.print格式化输出多个变量 print('姓名:%s,年龄：%s,身高:%s' % (name, age, hight))
# 3.列表与元祖进行格式相互转换时
# 4.要求对数据只读，不能修改的场景。

# 3.定义元组(元素组合)
# 格式:元组名=(数据1，数据2，数据3...)
# 空元组： 元组名=()或元组名=tuple()
# a=()
# b=tuple()
# print(a)
# print(b)

# 空列表
# c=[]
# print(c)
# d=list()
# print(d)

# 例：
# my_tuple=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# my_tuple1=()
# print(my_tuple)
# print(my_tuple1)

# 4.元组中只有一个数据时，需要加逗号
# 格式:元组名=(数据,)
# tuple1=("aa",)#不加逗号括号会被当做运算符中的括号。打印结果为字符串或数字类型
# tuple2=("aa")
# print(type(tuple1))
# print(type(tuple2))
# print(tuple1)
# print(tuple2)

# 5.访问元组中的数据，通过索引(元组是有序的数据容器)
# 格式:元组名[索引号]
# my_tuple=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# print(my_tuple[2])
# print(my_tuple[5])

# 6.修改元组中的数据，是受到限制的
# 当元组中包含列表或字典，列表和字典的数据时可以修改的
# tuple1=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# list1=tuple1[5]#通过索引号获取元组中的列表元素，赋值给变量list1
# print(list1)#打印一下拿出来的列表中的内容[10,22]
# list1[0]=60#通过列表的索引号修改列表中的值
# print(list1)#打印一下修改后的列表
# print(tuple1)#打印修改数据后的元组的内容