python高级数据类型_进阶部分(黑马学习笔记)

一、*本博文内容:

• 数据类型分类
• 列表常见操作及其详解
• 元组常见操作及其详解
• 字典常见操作及其详解
• 字符串常见操作及其详解
• 数据类型转换

二、数据类型分类(按照内存地址分类)

• 不可变数据类型:

1. 数字类型
2. 布尔类型
3. 字符串类型
4. 元组类型

• 可变数据类型:

1. 列表
2. 字典

三、列表

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]语法：

1. 追加(append):

列表名.append(self,object)

参数说明:
object:是你要添加的内容可以是任意的数据类型

2. 插入(insert):

列表名.insert(self,index,object)

参数说明:
index:你想插入的数据的下标(或者说是索引)
object:同理与append的是一个意思(这里不细说)

3. 扩充(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]语法:

1. 清空(clear):

列表名.clear()

注意:
clear在用的时候前提是变量名引用的对象必须要有，不能为空;
否则会报错

2. 弹出(pop):

列表名.pop(self,index)

参数说明:
index: 确定要删除的元素的索引的值
如果不进行设置，则进行自动删除最后一个元素

3. 移除(remove):

列表名.remove(self,object)

参数说明：
object:是你要删除的值
(
如果没有的你要删除的值的话会进行报错
如果对object不进行设置值，那么python会自动删除第一个元素
)

4. 删除(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]语法:

1. 统计长度(len):

变量名 = len(列表名)
注意:
len函数返回的是一个列表的长度
所以需要一个变量接收返回值

2. 统计列表中某个元素出现的次数

变量名 = 列表名.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]语法:

1. 排序(sort):

列表名.sort(self,key,reverse)

注意:
返回值为None

参数说明:
key：是以其中什么元素的值为标准进行排序
reverse:
是否进行转置;
一般情况是从小到大，则默认reverse是设置的是默认值False;
如果想要从大到小,则进行设置为True

2. 转置(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.应用场景:

1. 元组多用以保存不可更改的不同数据类型
2. 作为函数的参数和返回值(一个参数可以接受任意多个数据，返回任意多个数据)
3. 格式字符串
   例如:

name = "小明"
print("我是一个%s" % name)

注释:
1. ("我是一个%s" % name) #这就是一个元组

4. 让数据类型为的列表数据进行数据类型的转换

2.语法:

元组名 = (object1,object2,.......)

3.注意事项:

1. 元组定义单个数据的时候应注意加一个逗号
2. python不加逗号的时候,只会看括号里面的内容
3. 例子:

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]增加/修改操作

1. 如果字典中没有该键值对则利用键去访问的时候就是增加
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]统计

• 语法

1. 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)

1. 语法:

字符串名.count(self,x,start,end)

参数与前面的是一样的

2. 例子

str_one = "I love china, i am a studen"

count_num = str_one.count("a")
print(count_num)

[3]字符串的查找和替换

1. 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值

2. 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) 

4. 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)

• 截图:
  
• 注意:

1. 我们需要知道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. 指定的区间属于左闭右开型
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引 数字可以省略，冒号不能省略
4. 同时也支持倒序,
   即所谓倒序索引就是 从右向左 计算索引
   最右边的索引值是 -1，依次递减

七、内置函数

[1]描述:

内置函数	描述	适用的数据对象
len(item)	计算容器中元素个数	全部的高级数据对象
del(item)	删除变量	全部的数据对象
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较

[2]注意事项:

del是内置函数同时有两种方法删除
如:

八、公共方法

描述:

方法名	适用对象
字符串[开始索引:结束索引:步长]	只对有序的的数据类型才会有切片(言外之意:字典没有切片)