6.数据类型及type()函数：

1.数字类型分类：

1.数字类型：int（整数）float（浮点数/小数）bool（布尔）=参与运算时，True=1/False=02.非数字类型：str"字符串"list[列表]tuple（元组）dict{字典}

2.通过type（）函数可以查看当前数据所属类型=使用：type（变量名）/type（数据）

a=

print(type(a))#int（整数）

a=.5

print(type(a))#float（浮点数/小数）

a=True

b=False

print(type(a),type(b))#bool（布尔）

print(a+1,b+1)#参与运算时，True=1/False=0

a="你好"

print(type(a))#str"字符串"

a=[10,20,30]

print(type(a))#list[列表]

a=(10,20,30)

print(type(a))#tuple（元组）

a={one:1,"two":2}

print(type(a))#dict{字典}

PS:python中变量数据是自动类型推导：根据等号右边的数据类型自动推导出等号左边出变量中保存的数据类型

7.字符串的定义

1.定义：自定义变量/在变量中存储相应字符串，字符串主要用于处理文本数据

2.格式：成对的单引号，成对的双引号，三个成对的单引号，三个成对的双引号

a=成对的单引号字符串

b="成对的双引号字符串"#成对的双引号字符串可以嵌套成对的单引号字符串="成对的单引号字符串"

c="""三个成对的双引号字符串"""#三个成对的单引号字符串

print(a,b,c)

print(type(a),type(b),type(c))

3.特殊符号处理：

a="I\msmart"#\是转义字符

print(a)

a=r"I\msmart"#r打印原生字符串，就是字符串里有啥就打印啥

print(a)

8.input函数的使用

获取用户信息，将信息保存到变量里，一般来说input是阻塞的除非用户停止运行

user=input("请输入用户名：")

print(user)

pwss=input("请输入密码：")

print(pwss)

9.字符串索引

1.字符串是一种有序的容器（字符串中数据是有顺序的，可以通过索引访问）

2.索引：字符在字符串中位置下标，索引下标默认从零开始,反之则从-1开始

定义一个索引：

#索引值：045.....11

#a="hello,python"

3.查询字符串：

1.根据索引查询字符串中的数据：

格式：字符串名[索引值]

my_str="hello,python"

print(my_str[1])#返回e

2.通过数据获取索引

格式：字符串名.index(数据值)

my_str="hello,python"

print(my_str.index(o))#返回4

print(my_str.index(python))#输入多个只会获取最左边字符串"n"的索引值

3.统计字符串的长度

格式：len(字符串)

my_str="hello,python"

print(len(my_str))#返回12，长度十二位

4.统计大字符串中某个小字符串出现的次数

格式：大字符串.count(小字符串)

my_str="hello,python,hello,python,hello"

print(my_str.count(o))#返回5，有5个o字符串

print(my_str.count(python))#返回2，有两个python字符串

10.字符串的查找与替换：

1.字符串的查找：

1.string.startswith(str)

判断：变量名.startswith(字符串)检查字符串是否以xxx开头，是则返回True,否则返回False/可以查询多个字符串

my_str="hello,python,python"

#单个字符串

print(my_str.startswith("h"))#返回True，是以h开头的

print(my_str.startswith("e"))#返回False，不是以e开头的

#多个字符串

print(my_str.startswith("hello"))#返回True，是以h开头的

print(my_str.startswith("ello"))#返回False，不是以e开头的

2.string.endswith(str)

判断：变量名.endswith(字符串)检查字符串是否以xxx结束，是则返回True,否则返回False/可以查询多个字符串

my_str="hello,python,python"

#单个字符串

print(my_str.endswith("n"))#返回True，是以n结尾的

print(my_str.endswith("o"))#返回False，不是以o结尾的

#多个字符串

print(my_str.endswith("python"))#返回True，是以n结尾的

print(my_str.endswith("pytho"))#返回False，不是以o结尾的

3.string.find(str,start=0,end=len(string))

判断：变量名.find(字符串)在指定范围内查找字符串的索引值，找到则返回索引值，未找到则，返回-1，往下的代码依旧执行

my_str="hello,python,python"

print(my_str.find("h"))#已查到到，返回索引值0

print(my_str.find("j"))#未查找到，返回-1

print(my_str.find("python"))#返回最左边第一个字符串的索引值6

变量名.find("查找内容",从第几个索引值开始查找，len（查找范围））/PS：通过数据获取索引的index函数报错后后面的代码无法正常执行，而find函数可以正常执行

my_str="hello,python,python"

print(my_str.find("python",7))#指定查找范围，从8索引值往后查找最左边第一个字符串的索引值

print(my_str.find("python",7,len(my_str)))#指定范围内查找

print(my_str.find("java",1,len(my_str)))#指定范围内字符串查找不到返回-1

print("上行代码报错是否会继续执行？")#这行代码依旧执行

2.字符串的替换：

string.replace(old_str,new_str,num=string.count(old))把string中的old_str替换成new_str

1.变量.replace("替换字符串","被替换字符串"，替换次数)

my_str="hello,python,python,java"

print(my_str.replace("python","go"))#num值没有指定，默认全部替换

print(my_str.replace("python","go",1))#num值指定为1，替换1次

11.字符串的拆分与拼接

1.拆分：

string.split(str="",num)以str为分隔符拆分string

格式：字符串.split("分隔符",分隔次数)

str默认包含\r\t\n和空格，返回列表

info_str="hello,python,java"

print(info_str.split(","))#返回列表[hello,python,java]

print(info_str.split(",",1))#指定切分次数,返回列表[hello,python,java]

#切分字符串不适用，切分字符一般安装逗号来切,如果以字符串来切就会破坏原来的数据结构

print(info_str.split("python"))#返回列表[hello,,,java]，可以看到返回直接切没了原来的数据

2.转义字符切分：具有特殊功能的字符串：

\r回车符\tTab键\n换行符linux/unix操作系统换行符空格\r\nwindows系统换行符

string.split(str="",num)以str为分隔符拆分string

格式:字符串.split("指定转义字符在字符串内")

如果split没有定义切分，会以转义字符切分,通过指定分隔符对字符串进行切片

info_str="hell\ro,py\tthon,java"

print(info_str.split())#返回列表[hell,o,py,thon,ja,va]

splitlines()按照行(\r,\r\n,\n)分隔字符串，返回一个包含各行作为元素的列表

info_str="hell\ro,p\r\nython,ja\nva"#返回列表[hell,o,p,ython,ja,va]

print(info_str.splitlines())

3.字符串的拼接：+

格式：字符串1+字符串2

my_str_1="hello"

my_str_2="python"

print(my_str_1+my_str_2)

4.常用拼接：str.join(sequence)以string作为分隔符，将sequence中所有的元素（的字符串表示）合并为新的字符串

格式："字符串".join(变量名)

my_str="0456789"

print("#".join(my_str))#返回0#1#2#3#4#5#6#7#8#9通过指定字符连接序列中元素后生成的新字符串

print("$".join(my_str))#返回0$1$2$3$4$5$6$7$8$9

print("".join(my_str))#返回0456789

12.字符串切片

作用：从大字符串中切出小字符串切片的范围，包含开始位置索引，不包含结束位置索引，只能获取到结束位置索引值的前一个字符，获取数据需要调整步长，步长1可以省略

定义一个字符串

索引：045.....11

info_str="hello,python"

1.切出字符串hello

格式：字符串名[开始位置索引值：结束位置索引值：步长]

索引：045.....11

info_str="hello,python"

print(info_str[0:5:1])

print(info_str[0:5:])#步长为正1时可以省略

print(info_str[0:5])#步长为正1时冒号可以省略

print(info_str[:5])#开始位置索引值是字符串的边界，开始位置索引值可以省略

2.切出字符串python

索引：045.....11

info_str="hello,python"

print(info_str[6:12:1])

print(info_str[6:12])#步长为正1时冒号可以省略

print(info_str[6:])#结束位置索引值是字符串的边界，结束位置索引值可以省略

3.切出字符串开始索引值为6，切到字符串结束位置，步长为2

索引：045.....11

info_str="hello,python"

print(info_str[6::1])#返回python，步长为1

print(info_str[6::2])#返回pto，步长为2，从开始索引隔一个字符串取

4.倒叙切片步长是负数

索引：045.....11

info_str="hello,python"

print(info_str[-1:-7:-1])#开始位置索引值是字符串的边界，开始位置索引值可以省略

print(info_str[:-7:-1])

print(info_str[11:5:-1])#结束位置索引值是字符串的边界，结束位置索引值可以省略

print(info_str[:5:-1])

5.面试题-字符串的逆序

info_str="hello,python"

print(info_str[:-13:-1])#开始位置索引值是字符串的边界，开始位置索引值可以省略

print(info_str[::-1])#结束位置索引值是字符串的边界，结束位置索引值可以省略

print(info_str[11::-1])#开始位置索引值是字符串的边界，开始位置索引值可以省略

print(info_str[::-1])#结束位置索引值是字符串的边界，结束位置索引值可以省略

切片中开始索引或结束索引涉及到字符串的边界，则开始索引或结束索引可以省略

正序切片，从左往右，如果字符串结束索引是字符串的末尾，则字符串索引可以省略。

步长为1，步长可以省略，步长前面的冒号也可以省略

13.列表的定义：

1.单个数据存放再变量中2.多个变量组成大量数据就可以存放再列表当中3.列表可以用于存放多个数据4.列表是原来存放多个数据的有序容器

列表名=list()list()等价于[]空列表

my_list_01=list()

my_list_02=[]

格式：变量名[数据1，数据2，数据3]

my_list=[,12.3,True,"hello",.6]

print(my_list)#列表：[,12.3,True,hello,.6]

print(type(my_list))#类型：classlist

列表中的数据可以通过索引（下标）的方式来访问:

#列表名[索引值]my_list=[,12.3,True,"hello",.6]

print(my_list[0])#获取到：通过索引值访问数据

print(my_list[1])#获取到：12.3

print(my_list[2])#获取到：True

print(my_list[3])#获取到：hello

print(my_list[4])#获取到：.6

14.列表的常见操作：

1.增=删=改=查

2.列表的快速格式化ctrl+alt+l(在列表逗号后面添加空格符合格式)

1.增加：

1.在指定位置插入数据

格式：列表.insert(索引,数据)

info_list=[1,2,3,4,5,6,7,8,9]

info_list.insert(2,)

print(info_list)#返回list列表：增加数据[1,2,,3,4,5,6,7,8,9]插入到索引值后面一位

2.插入小列表

格式：列表.insert(索引,[数据])

info_list=[1,2,3,4,5,6,7,8,9]

info_list.insert(2,[,])#在索引值的后一位插入小列表

print(info_list)#返回[1,2,[,],3,4,5,6,7,8,9]

3.在末尾追加数据

格式：列表.append(数据)

info_list=[1,2,3,4,5,6,7,8,9]

info_list.append()#在末尾追加数据

print(info_list)#返回[1,2,3,4,5,6,7,8,9,]

4.在末尾插入小列表

格式：列表.append(索引,[数据])

info_list=[1,2,3,4,5,6,7,8,9]

info_list.append([,])#在末尾插入小列表

print(info_list)#返回[1,2,3,4,5,6,7,8,9,[,]]

5.列表合并

格式：列表1.extend(列表2)将列表2的数据追加到列表1(把列表2合并到列表1去)

info_list_01=[1,2,3]#列表1

info_list_02=[4,5,6]#列表2

info_list_01.extend(info_list_02)#把列表2合并到列表1

print(info_list_01)#返回[1,2,3,4,5,6]

2.删除：

1.删除指定的数据

格式：del列表[索引]

#索引：045678

info_list=[1,2,3,4,5,6,7,8,9]

delinfo_list[0]

print(info_list)#返回[2,3,4,5,6,7,8,9]，索引为0的1已被删除

#拓展：把列表从内存清除

#delinfo_list

#print(info_list)#NameError:nameinfo_listisnotdefined列表已删除

2.删除第一个出现的指定的数据=常用

格式:列表.remove(数据)

info_list=[1,2,3,4,4,5,6,7,8,9]

info_list.remove(4)

print(info_list)#返回[1,2,3,4,5,6,7,8,9]，remove只会删除第一个出现的指定数据

3.删除末尾数据

格式：列表.pop()

info_list=[1,2,3,4,5,6,7,8,9]

num=info_list.pop()

print(info_list)#返回[1,2,3,4,5,6,7,8]末尾数据被删除

print(num)#定义变量，返回被删除的数据

4.删除索引指定数据

格式：列表.pop(索引)

#索引：045678

info_list=[1,2,3,4,5,6,7,8,9]

num=info_list.pop(8)

print(info_list)#返回[1,2,3,4,5,6,7,8]

print(num)#返回被删除的数据

5.清空列表

格式：列表.clear()

info_list=[1,2,3,4,5,6,7,8,9]

info_list.clear()

print(info_list)#返回空列表[]

3.修改：

1.修改指定索引的数据，列表中的数据可以修改

格式：列表[索引]=数据

#索引：045678

info_list=[1,2,3,4,5,6,7,8,9]

info_list[0]=#将索引为0的值修改为

print(info_list)#返回[,2,3,4,5,6,7,8,9]

4.查询：

1.通过索引获取数据

格式：列表名[索引]

#索引：045678

info_list=[1,2,3,4,5,6,7,8,9]

print(info_list[0])#返回数据1

print(info_list[1])#返回数据2

2.通过数据获取索引，只会获取数据在列表中第一次出现的索引值

格式：列表名.index(数据)

#索引：0456789

info_list=[1,2,3,4,5,6,7,8,9,2]

print(info_list.index(2))#返回索引值1

print(info_list.index(2))#列表中索引9的值2不会被获取因为，只会获取数据在列表中第一次出现的索引值

5.列表的高级操作：

1.统计：

1.统计列表长度：

格式：len(列表)

my_list=[1,2,3,4,5,55,6.6,7,-8,9,0.2]

print(len(my_list))#返回11，列表长度为11个

2.数据在列表中出现的次数

格式：列表.count(数据)

my_list=[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

print(my_list.count(4))#返回3次

print(my_list.count(55))#返回2次

print(my_list.count())#没有这个数据返回0

2.排序：

1.升序(从小到大排序)

格式：列表.sort()

my_list=[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

my_list.sort()

print(my_list)#返回[-8,0.2,1,2,3,4,4,4,6.6,7,9,55,55]

2.降序(从大到小排序)

格式：列表.sort(reverse=True)

my_list=[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

my_list.sort(reverse=True)#返回[55,55,9,7,6.6,4,4,4,3,2,1,0.2,-8]

3.逆转，反转,倒序

格式：列表.reverse()

my_list=[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

my_list.reverse()

print(my_list)#返回[0.2,9,-8,7,6.6,55,55,4,4,4,3,2,1]就是倒序了

3.列表拷贝：

格式：列表名.copy()

my_list=[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

new_list=my_list.copy()#将my_list的列表拷贝到new_list里去

print(new_list)#返回[1,2,3,4,4,4,55,55,6.6,7,-8,9,0.2]

可以查看内存地址来分辨是不是拷贝过去的：id()函数

print(my_list,id(my_list))#内存