一、*本博文内容:
- 数据类型分类
- 列表常见操作及其详解
- 元组常见操作及其详解
- 字典常见操作及其详解
- 字符串常见操作及其详解
- 数据类型转换
二、数据类型分类(按照内存地址分类)
- 不可变数据类型:
- 数字类型
- 布尔类型
- 字符串类型
- 元组类型
- 可变数据类型:
- 列表
- 字典
三、列表
1.应用场景:
专门用于存储一系列同类型的信息
2.语法:
列表名 = [object1,object2,object3,.....]
#注意:元素之间用','隔开
3.索引:
- 从0开始,索引就是和数组下标类似。
- 索引也可以是负的,倒数第一个的索引是-1。
- 倒数第二个的索引就是-2…以此类推。
例如
a[8] = [0,1,2,3,4,5,6,7] #定义了一个存储0-7的列表
print(a[0]) #输出0
print(a[1]) #输出1
print(a[2]) #输出2
print(a[3]) #输出3
print(a[4]) #输出4
print(a[5]) #输出5
print(a[6]) #输出6
print(a[7]) #输出7
b = [1,2,3] #定义一个存储1-3的列表
print(a[-1]) #输出3
print(a[-2]) #输出2
print(a[-3]) #输出1
4.列表常用的操作:
- 查值,取索引
[1] 语法:
变量名 = 列表名.index(self,object,from,to)
[2] 参数以及返回值说明:
参数 | 说明 |
---|---|
self | 是类的概念,这里不解释,一般不用管 |
object | 是要查找的值 |
from | 起始索引值 |
to | 终止索引值 |
[3] 注意事项:
如果没有找到会报错
[4] 返回值:
是数据类型为int的整数
[5]注意:
也可以不直接用列表名进行index方法(其本质:变量名仅仅就是引用或者说是标签)
如:
a = [1,2,3].index(1)
print(a)
- 修改列表
[1] 语法:
a = [1,2]
a[2] = "name"
print(a) #输出a的话,显示[1,"name"]
[2] 注意:
修改已有的列表的元素的话,直接利用索引进行修改即可
- 增加数据
[1]语法:
- 追加(append):
列表名.append(self,object)
参数说明:
object:是你要添加的内容可以是任意的数据类型
- 插入(insert):
列表名.insert(self,index,object)
参数说明:
index:你想插入的数据的下标(或者说是索引)
object:同理与append的是一个意思(这里不细说)
- 扩充(extend):
列表名.extend(self,iterable)
参数说明:
1. iterable:可迭代对象(可迭代的意思就是:能够一次返回该对象中的一个元素)
2. 常见的可迭代对象:
3. 集合数据类型:
字典,列表,元组
迭代器对象(没学,不做说明)
注意事项:
'+'与extend的区别:
1.extend方法不可以在控制台直接输出,需要理由print语句才行
2.'+'但是可以在控制台直接输出
如 '+'与extend的区别(针对于list数据类型) :
[2]例子:
a = [1,2,3]
#one append
a.append(4)
print(a) #输出的结果就是:[1, 2, 3, 4]
#two insert
a.insert(1,"I love china")
print(a) #输出的结果就是:[1, 2, 3, 4, 'I love china']
#three extend
b = ["This","is","a","extend"]
a.extend(b)
print(a) #输出的结果就是:[1, 2, 3, 4, 'I love china', 'This', 'is', 'a', 'extend']
- 删除:
[1]语法:
- 清空(clear):
列表名.clear()
注意:
clear在用的时候前提是变量名引用的对象必须要有,不能为空;
否则会报错
- 弹出(pop):
列表名.pop(self,index)
参数说明:
index: 确定要删除的元素的索引的值
如果不进行设置,则进行自动删除最后一个元素
- 移除(remove):
列表名.remove(self,object)
参数说明:
object:是你要删除的值
(
如果没有的你要删除的值的话会进行报错
如果对object不进行设置值,那么python会自动删除第一个元素
)
- 删除(del):
del 列表名
注意:
1. 我们必须知道del是python中的一个关键字,是python中的一个删除机制;
2. 一旦调用这个删除机制,那么python会把变量名引用的那个数据直接从内存中删除;
3. 同时我们这个变量将不能再引用,除非进行再定义.
[2]例子:
a = [0,1,2,3,4,5]
a.pop(2)
print(a) #显示[0, 1, 3, 4, 5]
a.remove(5)
print(a) #显示[0, 1, 3, 4]
a.clear()
print(a) #显示一个空列表
del a
print(a) #显示报错
- 统计:(count)
[1]语法:
- 统计长度(len):
变量名 = len(列表名)
注意:
len函数返回的是一个列表的长度
所以需要一个变量接收返回值
- 统计列表中某个元素出现的次数
变量名 = 列表名.count(self,object)
参数说明:
object:
想要对列表中进行统计的元素的值
[2]例子:
a = ["a","a","a","a","b","c"]
a_len = len(a)
print("a的长度是%d" % a_len) #输出的是a的长度是6
a_count = a.count("a")
print("a出现的个数是%d" % a_count) #a出现的个数是4
- 排序::
[1]语法:
- 排序(sort):
列表名.sort(self,key,reverse)
注意:
返回值为None
参数说明:
key:是以其中什么元素的值为标准进行排序
reverse:
是否进行转置;
一般情况是从小到大,则默认reverse是设置的是默认值False;
如果想要从大到小,则进行设置为True
- 转置(reverse):
列表名.reverse(self)
[2]例子:
a = ["a","s","e","a","c"]
a.reverse()
print(a)
a = ["a","s","e","a","c"]
print(a)
a.sort()
print(a)
a.sort(reverse=True)
print(a)
四、元组
1.应用场景:
- 元组多用以保存不可更改的不同数据类型
- 作为函数的参数和返回值(一个参数可以接受任意多个数据,返回任意多个数据)
- 格式字符串
例如:
name = "小明"
print("我是一个%s" % name)
注释:
1. ("我是一个%s" % name) #这就是一个元组
- 让数据类型为的列表数据进行数据类型的转换
2.语法:
元组名 = (object1,object2,.......)
3.注意事项:
- 元组定义单个数据的时候应注意加一个逗号
- python不加逗号的时候,只会看括号里面的内容
- 例子:
a = (1,2,3)
print(a) #输出(1, 2, 3)
a = (1,)
print(a) #输出(1,)
a = (1)
print(a) #输出1
4.元组的常用操作:
查值,取索引(index)
[1] 语法:
变量名 = 元组名.index(self,x,start,end)
参数说明:
self:此处省略说明
x:是要查找的值
start:起始位置
end:终点位置
注意:
返回的是元素所在的位置
统计:(count)
[1]语法
变量名 = 元组名.count(self,x)
参数说明:
x:想要对元组中进行统计的元素的值
注意:
返回的是统计的个数
[2]例子
a = ("1","a","b","2","1","1")
a_count = a.count("1")
print(a_count) #输出3
a_index = a.index("a")
print(a_index) #输出1
5.与列表的区别:
列表中的数据元素是可以更改的
但是元组中的数据元素是不可以更改的
五、字典
1.应用场景:
使用多个键值对存储描述一个物体的相关联的信息的时候,
我们可以利用多个字典嵌套一列表这中结构
2.字典的特点:
字典之间存储数据元素是利用键值对进行存取的
3.语法:
字典名 = {key1:value1,......}
参数说明:
key:是字典的键,是不可变类型(这个很重要)
value:这是字典的值,任意数据类型
注意:
1.键值对必须唯一
2.如果重名的话都遵守后来者居上的理念,后来的会覆盖先有的
例如:
peopleOne = {"name":"小明",
"age":18,
"sex":'men'}
4.字典的常用操作:
[1]取值:
字典名[key]
例如:
dict_one = {"name":小明,"age":18}
print(dict_one[name]) #输出的结果为小明
[2]增加/修改操作
- 如果字典中没有该键值对则利用键去访问的时候就是增加
- 如果该键值对存在的话就是修改
例如:
dict_one = {"name":"小明"}
dict_one["name"] = "小白" #将字典中的name的值改为小白
dict_one["age"] = 18 #增加字典中的age-18这对键值对
print(dict_one) #输出的结果为{"name":"小明","age":18}
[3]删除(pop)
- 语法:
字典名.pop(self,key)
参数说明:
self:此处省略
key:字典中的键值对中的键
- 例子:
people = {"name":"小明","age":18,"年龄":18}
people.pop("年龄") #删除了'年龄-18'这个键值对
print(people) #输出的结果是{"name":"小明","age":18}
[4]统计
- 语法
- len统计个数
变量名 = len(字典名)
- 例子
people = {"name":"小明","age":18,"年龄":18}
length = len(people)
print(length) #输出的结果为3
[5]合并(update)
- 语法
dict2.update(dict1)
参数说明:
dict1:是要往dict2里面合并的数据
- 例子:
people = {"name":"小明","age":"18"}
place = {"place":"BeiJing","country":"china"}
people.update(place)
print(people) #输出的结果是:'name': '小明', 'age': 18, 'place': 'Beijing', 'country': 'china'}
- 注意:
如果被合并的字典包含已经存在的键值对,会覆盖原有的键值对
[6]清空字典(clear)
- 语法:
字典名.clear()
- 例子:
dict_one = {"name":"小马","age":18}
dict_one.clear()
print(dict_one) #输出的结果直接是一个空字典
六、字符串
1.定义:
一般使用双引号,或者单引号括起来的内容就是字符串
注意:大多数情况下我们使用的是双引号
2.字符串常用的操作:
[1]查值,取索引(index)
- 语法
字符串名.index(self,sub,start,end)
参数说明:
sub:你要在字符串查找的子串的位置
start:起始位置
end:终止位置
- 例子:
str_one = "I love china"
index_num = str_one.index("I love")
print(index_num) #返回的结果是0
[2]统计:
- 1.统计长度(len)
注释:和前面的 len函数是一样的,这里就不在过多的解释了
str_one = "I am a student"
length = len(str_one)
print(length)
- 2.统计出现的个数(count)
- 语法:
字符串名.count(self,x,start,end)
参数与前面的是一样的
- 例子
str_one = "I love china, i am a studen"
count_num = str_one.count("a")
print(count_num)
[3]字符串的查找和替换
- startswith,endswith
- 语法
str1.startswith(self,prefix,strat,end)
str1.endswith(self,suffix,strat,end)
参数说明:
prefix:前缀,就是以什么开头的
suffix:后缀,就是以什么结尾的
start:开始的位置
end:结束的位置
- 例子
str_one = "I am from china"
print(str_one.startswith("china")) #输出的是False
print(str_one.startswith("I")) #输出的是True
print(str_one.endswith("china")) #输出的是True
print(str_one.endswith("I")) #输出的是False
- 注意:
在引用这两个方法的时候我必须知道返回的是bool值
- find
- 语法
str1.find(self,sub,start,end)
参数说明:
sub:要在str1中查找的子串
注意:
find与index的区别:
find如果找不到的话返回的是-1
但是对于index如果找不到的话直接报错
- 例子
str_one = "I am from china"
find_num = str_one.find("am") #查找存在的子串,返回的是下标
print(find_num)
find_num = str_one.find("sdfas") #查找不存在的子串,直接返回-1
print(find_num)
- replace
- 语法:
str1.replace(self,old,new,count)
参数说明:
old:str1中旧的字符串
new:替换str1中旧的字符串的新字符串
count:替换的最大次数
注意事项:
1. 我们的replace方法是生成了一个新的字符串,原来的字符串没有改变
2. 原理:因为字符串是不可变类型,如果对原有的字符串进行改值,那么会在内存中再开辟一个空间来存储新的字符串
- 例子:
str_one = "I am from china china"
str_two = str_one.replace("china","henan",1)
print("这是字符串one:",str_one)
#输出的结果为:这是字符串one: I am from china china
print("这是字符串two:",str_two)
#输出的结果为:这是字符串two: I am from henan china
[4]文本对齐
- 主要有:
名称 | 说明及其语法 |
---|---|
ljust(左对齐) | str1.ljust(self,width,fillchar) |
rjust(右对齐) | str1.rjust(self,width,fillchar) |
center(居中) | str1.center(self,width,fillchar) |
参数名称 | 参数说明 |
---|---|
width | 指定的长度 |
fillchar | 如果长度不够的话,填充的字符 |
- 语法:
str_one = "I am from china china"
print(str_one.ljust(50,"*"))
print(str_one.rjust(50,"*"))
print(str_one.center(50,"-"))
- 截图:
[5]去除空白字符
- 主要有:
名称 | 说明及其语法 |
---|---|
strip(左右都去除) | str1.strip(self,chars) |
rstrip(右去除) | str1.rstrip(self,chars |
lstrip(左去除) | str1.lstrip(self,chars) |
参数 | 说明 |
---|---|
chars | 是要去除的字符 |
- 例子:
str_one = "I aam from china china I"
print(str_one.strip("I"))
print(str_one.rstrip("I"))
print(str_one.lstrip("I"))
截图:
[6]拆分与拼接
- 定义
方法名 | 语法 |
---|---|
split(拆分) | str1.split(self,sep,maxsplit) |
join(拼接) | str1.join(self,iterable) |
- 参数说明:
sep:以sep这个参数,将str1拆分
maxsplit:最大的拆分次数(如果不设置,则进行全部的拆分)
iterable:可迭代对象 - 例子:
str_one = "I aam from china china I"
list_one = str_one.split("I")
print(list_one)
str_two = "I".join(list_one)
print(str_two)
- 截图:
- 注意:
- 我们需要知道split返回的是一个列表(必须知道)
3.字符串的切片操作:
[1]应用场景:
多用于取子集合中的一些数据
[2]语法:
字符串[开始索引:结束索引:步长]
[3]例子:
str_one = "I love china"
print(str_one[::])
print(str_one[::2])
print(str_one[::-1])
print(str_one[0:5])
[6]截图:
[5]注意事项:
- 指定的区间属于左闭右开型
- 从头开始,开始索引 数字可以省略,冒号不能省略
- 到末尾结束,结束索引 数字可以省略,冒号不能省略
- 同时也支持倒序,
即所谓倒序索引就是 从右向左 计算索引
最右边的索引值是 -1,依次递减
七、内置函数
[1]描述:
内置函数 | 描述 | 适用的数据对象 |
---|---|---|
len(item) | 计算容器中元素个数 | 全部的高级数据对象 |
del(item) | 删除变量 | 全部的数据对象 |
max(item) | 返回容器中元素最大值 | 如果是字典,只针对 key 比较 |
min(item) | 返回容器中元素最小值 | 如果是字典,只针对 key 比较 |
[2]注意事项:
del是内置函数同时有两种方法删除
如:
八、公共方法
描述:
方法名 | 适用对象 |
---|---|
字符串[开始索引:结束索引:步长] | 只对有序的的数据类型才会有切片(言外之意:字典没有切片) |