Python数据类型：编程新手的必修课

啊猪是的读来过倒

已于 2024-05-24 17:58:04 修改

阅读量394

点赞数 10

分类专栏： python 文章标签： python 开发语言

于 2024-05-17 18:00:22 首次发布

本文链接：https://blog.csdn.net/m0_48173416/article/details/138954980

版权

python 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

在这里插入图片描述

系列文章目录

类型	表示	表示	备注
整型	int	整数
布尔	bool	True/False
浮点型	float	小数
字符串	str	" "	由一系列字符组成的不可变序列容器
列表	list	[ ]	由一系列元素组成的可变序列容器
元组	tuple	( )	由一系列变量组成的不可变序列
字典	dict	{ }	由一系列键值对组成的可变映射容器
集合	set	{ }	由一系列不重复不可变的数据组成的可变容器

字符串

概念

概念：由一系列字符组成的不可变序列容器。
不可变：	1.没有增删改方法  
	   	2.所有的操作都不会直接修改原数据
序列：有序的排列。支持索引和切片操作

索引与切片

索引：

索引：又称之为下标、编号
语法：字符串[下标]
规则：从左往右，从0开始；从右往左，从-1开始

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长] (左闭右开)

# 切片
# 语法：列表[开始下标:结束下标:步长]
# 特点：
# 1.取头不取尾，取不到结束下标对应的数据
# 2.步长不写默认为1,步长可以是正负数
# 3.下标可以正负数混搭
# 4.[:m]:从列表开头取到下标为m的前一位
# 5.[n:]:从列表下标为n的位置取到列表结尾
# 6.[n:m]:从下标为n的位置取到m的前一位
# 7.[:]、[::]:取整个列表
# 8.[::-1]:将列表中元素反转

常见操作方法

查询类方法

	1.index：str.index(substring, beg=0, end=len(string))返回开始的索引值
  	2.find：str.find(str, beg=0, end=len(string)) 返回开始的索引值
  	3.count：str.count(sub, start= 0,end=len(string)) 返回子串出现的次数

判别类方法

    startswith：是否以某个字符串为开头
    endswith：是否以某个字符串为结尾
  	isupper：是大写字母吗
  	islower：是小写字母吗
  	istitle：字符串是标题化的吗
  	isalpha：是全字母吗
  	isalnum：是全字母或全数字或全字母数字吗
  	isdigit：是数字吗
	isspace：只包含空白字符（空格 /n /t等）吗

调整类方法

	capitalize：将字符串的第一个字符变大写，其他字母变小写
  	title：使字符串标题化（字符串中所有单词首字母大写，其他小写）
    upper：变成大写
    lower：变成小写
    center：该方法返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。

操作类方法

	replace(str1,str2)：把str1替换为str2
    split(str,num)：以str分割字符串，num可以指定分割几次
    join：str.join(sequence)：将序列中的元素以指定的字符连接生成一个新的字符串。
    strip：只能删除开头或是结尾的字符，不能删除中间部分的字符

补充方法

	 字符串 + 字符串    拼接
 	 字符串 * 数字      复制
     字符 in  字符串：判断字符是否在字符串中
  	 字符 not in  字符串：判断字符是否不在字符串中
  	 len(字符串)：统计字符串的长度、统计字符串中字符的个数

点这里，有更加详细的字符串方法使用技巧0.0

列表

概念

概念：由一系列元素组成的可变序列容器
可变：1.有增删改方法  
	    2.所有的操作都会直接作用于原数据
序列：支持索引与切片操作

三种定义方法

# 列表定义    list    []
# 1.直接定义
	my_list = [10,1.2,"hello",[1,2]]
# 2.构造法--->本质上是数据类型转换 list(可迭代对象)
	my_list = list("hahahhaha")
# 3.列表推导式-->	本质上是通过for循环增加数据
# 语法：[要增加的数据 for循环 判断]
	my_list = [i**2 for i in range(1,10) if i % 2 == 0]

索引与切片

索引：

索引：又称之为下标、编号
语法：字符串[下标]
规则：从左往右，从0开始；从右往左，从-1开始

切片：

# 切片
# 语法：列表[开始下标:结束下标:步长]
# 特点：
# 1.取头不取尾，取不到结束下标对应的数据
# 2.步长不写默认为1,步长可以是正负数
# 3.下标可以正负数混搭
# 4.[:m]:从列表开头取到下标为m的前一位
# 5.[n:]:从列表下标为n的位置取到列表结尾
# 6.[n:m]:从下标为n的位置取到m的前一位
# 7.[:]、[::]:取整个列表
# 8.[::-1]:将列表中元素反转

常用操作方法

增加数据

# 列表增加数据的方法
my_list = ["貂蝉","西施","孙悟空","王昭君","杨玉环"]

# 1.append()
# 语法：列表.append(数据)
# 作用：将数据作为一个整体添加到列表尾部
my_list.append("唐僧")
print(my_list)

# 2.insert()
# 语法：列表.insert(下标,数据)
# 作用：将数据作为一个整体添加到指定下标位置前
my_list.insert(1,"白龙马")
print(my_list)

# 3.extend()
# 语法：列表.extend(可迭代对象)
# 作用：将可迭代对象进行拆分依次添加到列表尾部
# 注：常用来增加列表。
my_list.extend([1,2,3,4,5])
print(my_list)

修改数据

# 列表修改数据
# 思路：	1.通过下标找到要修改的数据   
#		2.直接重新赋值
# 语法：列表[下标] = 新值
# 作用：将列表中指定下标对应的值进行修改


my_list = ["貂蝉","西施","孙悟空","王昭君","杨玉环"]
my_list[2] = "唐僧"
print(my_list)

删除数据

# 列表删除数据方法

my_list = ["花园宝宝","天线宝宝","海绵宝宝","熊出没","大角牛","蜡笔小新","黑猫警长","火影忍者","葫芦娃"]

# 1.pop()
# 语法：列表.pop(index)
# 作用：删除指定下标对应的数据，如果下标不存在则报错；不指定下标，默认删除列表尾部的元素；
my_list.pop(3)
print(my_list)

# 2.remove()
# 语法：列表.remove(数据)
# 作用：从列表中删除指定数据；如果数据不存在则报错
my_list.remove("火影忍者")
print(my_list)

# 3.clear()
# 语法：列表.clear()
# 作用：清空列表，列表仍然存在
my_list.clear()
print(my_list)

# del--->delete缩写
# 语法：del 列表     del 列表[下标]
# 作用：删除列表，列表不存在； 删除列表指定下标对应的数据，如果下标不存在则报错
del my_list[3]
print(my_list)

查询数据

# 列表查询数据方法

my_list = ["花园宝宝","大角牛","天线宝宝","海绵宝宝","熊出没","大角牛","蜡笔小新","黑猫警长","火影忍者","大角牛","葫芦娃"]

# 1.index
# 语法：列表.index(数据,start,end)
# 作用：查询数据在指定范围内的第一次出现位置在*整个列表*中的下标；如果不指定范围，则默认从列表中查询；如果数据不存在则报错
print(my_list.index("大牛",2,50))

# 2.count
# 语法：列表.count(数据)
# 作用：查询指定数据在整个列表中出现的次数；如果数据不存在则次数为0
print(my_list.count("宝宝"))

排序与反转

排序:

# 列表排序

list1 = [78,68,-25,94,34,-108,7]

# abs()
# 语法：abs(数字)
# 作用：获取数字的绝对值
# print(abs(-10))


# sort()
# 语法：列表.sort(key排序规则，reverse反转)
# 作用：不指定任何参数，默认将列表中的元素按照指定规则进行升序排序；如果指定参数reverse=True则实现降序排序
# my_list.sort(key=abs,reverse=True)
my_list.sort(key=abs,reverse=True)
print(my_list)

反转：

# 列表反转

list1 = ["玛卡巴卡","唔西迪西","依古比古","汤姆布利伯"]

# 第一种方式：列表[::-1]
list2 = list1[::-1]
print(list2)

# 第二种方法：
# reverse()
# 语法：列表.reverse()
# 作用：将列表中的元素进行反转
list1.reverse()
print(list1)

补充方法

# 补充方法
# 列表 + 列表：实现列表元素拼接
# 列表 * 整数：实现列表元素复制
# 元素 in 列表：判断元素是否在列表中；如果在则返回True，不在则返回False；(***列表嵌套需要注意，只能判断在最小的列表中***)
# 元素 not in 列表：判断元素是否不在列表中；如果不在则返回True，在则返回False；(列表嵌套需要注意，只能判断在最小的列表中)
# len(列表)：统计列表的长度、统计列表中元素的个数

元组

概念

元组  tuple  ()

元组是由一系列变量组成的不可变序列容器
不可变：1.没有增删改方法  
	   2.所有的操作都不会直接作用于原数据
序列：有序的排列，支持索引和切片操作

定义方法

# 元组的定义   tuple    ()

# 定义有多个数据的元组
my_tuple = (10,2.3,"hello",[1,2,3],(1,2,3))
print(my_tuple)
print(type(my_tuple))

# 定义单个数据的元组--->元组中只有一个数据，需要在这个数据后加逗号
# 如果数据后不加逗号，当前这个变量的类型与数据的类型一致
my_tuple = (10,)
print(my_tuple)
print(type(my_tuple))

索引与切片

索引：

my_tuple = ("玛卡巴卡","唔西迪西","依古比古","汤姆布利伯","小点点")

# 元组的索引
# 语法：元组[索引]
# 特点：从左往右，从0开始；从右往左，从-1开始
print(my_tuple [2])
print(my_tuple [-2])

切片：

# 元组的切片
# 语法：元组[开始下标:结束下标:步长]
# 特点：
# 1.取头不取尾
# 2.步长不写默认为1
# 3.下标可以正负数混搭
# 4.[n:m]:从下标为n的位置取到下标为m的前一位
# 5.[n:]:从下标为n的位置取到元组结束
# 6.[:m]:从元组开始取到下标为m的前一位
# 7.[:]、[::]:取整个元组
# 8.[::-1]:将元组中的变量反转

常用操作方法

查询方法

my_tuple = ("玛卡巴卡","小点点","唔西迪西","小点点","依古比古","汤姆布利伯","小点点")

# 元组查询数据方法

# index()
# 语法：元组.index(数据，start，end)
# 作用：查询数据在指定范围内第一次出现的位置的下标(如果不指定范围，从整个元组中查询)
print(my_tuple.index("小点点"))

# count()
# 语法：元组.count(数据)
# 作用：统计数字在整个元组中出现的次数，如果数据不存在则次数为0
print(my_tuple.count("点点"))

补充方法

# 补充：
# 元组 + 元组：元组中的变量实现拼接
# 元组 * 整数：元组中的变量复制n次
# 变量 in 元组：判断变量是否在元组中存在，如果存在则返回True，否则返回False
# 变量 not in 元组：判断变量是否不在元组中存在，如果不存在则返回True，否则返回False
# len(元组)：统计元组的长度、统计元组中变量的个数

字典

概念

字典：由一系列键值对组成的可变映射容器
# 键不重复且不可变
# 支持的类型（不可变数据类型）：整型、浮点型、字符串、元组
# 键 key：name age gender   
# 值 value：张三  18  男     值支持所有的数据类型
# 键值对 item："name":"张三"   一一对应的关系
键值对：一个键和一个值组成一个键值对
可变：1.有增删改方法    2.所有的操作会直接作用于原数据
映射：键与值一一对应的关系

定义方法

# 1.直接定义
dict1 = {"name":18.6,"age":18.6,"gender": {"男":"女"}}
print(dict1)
print(type(dict1))


# 2.构造法 ---》本质数据类型转换    dict(键=值,键=值……)
dict2 = dict(name="李四",age=16,sex="女")
print(dict2)
print(type(dict2))

常用操作方法

查询具体数据方法

# 字典查询数据的方法
my_dict = {"name":"张三","age":18,"gender":"男"}


# 1.通过键查询值
# 语法：字典名[键]
# 作用：查询字典中指定键对应的值，如果键不存在则报错
print(my_dict["age"])


# 2.get()
# 语法：字典.get(键,默认值)
# 作用：查询字典中指定键对应的值，如果键不存在则返回None；如果指定默认值且键不存在则返回默认值
print(my_dict.get("phone",110))

增加、修改数据方法

my_dict = {"name":"张三","age":18,"gender":"男"}
# 增加和修改使用同一个语法格式，满足：有则修改，无则增加

# 字典增加数据的方法
# 语法：字典名[键] = 值
my_dict["address"] = "北京某桥洞下"
print(my_dict)


# 字典修改数据的方法
# 语法：字典名[键] = 值
my_dict["age"] = 19
print(my_dict)

删除数据方法

my_dict = {"name":"张三","age":18,"gender":"男"}

# 字典删除数据方法
# clear()
# 语法：字典.clear()
# 作用：清空字典，字典仍然存在
my_dict.clear()
print(my_dict)

# del
# 语法：del 字典      del 字典[键]
# 作用：删除字典，字典不存在; 删除指定键对应的键值对，如果键不存在则报错
del my_dict["phone"]
print(my_dict)

查询数据方法

my_dict = {"name":"张三","age":18,"gender":"男"}

# 1.查询字典中所有的键
# keys()
# 语法：字典.keys()
# 作用：获取字典中所有的键
# 结果：dict_keys(['name', 'age', 'gender'])
print(my_dict.keys())
print(type(my_dict.keys()))

# 2.查询字典中所有的值
# values()
# 语法：字典.values()
# 作用：获取字典中所有的值
# 结果：dict_values(['张三', 18, '男'])
print(my_dict.values())
print(type(my_dict.values()))

# 3.查询字典中所有的键值对
# items()
# 语法：字典.items()
# 作用：获取字典中所有的键值对
# 结果：dict_items([('name', '张三'), ('age', 18), ('gender', '男')])
print(my_dict.items())
print(type(my_dict.items()))

补充方法

# 补充方法
键 in 字典：判断键是否在字典中存在，如果存在则返回True，否则返回False
键 not in 字典：判断键是否在字典中不存在，如果不存在则返回True，否则返回False
len(字典)：统计字典的长度、统计字典中键值对的数量

集合

概念

集合：由一系列不重复不可变的数据组成的可变容器

#集合中的数据具有无序性、唯一性
#数据：必须是不可变数据类型的数据(整型、浮点型、字符串、元组)且要求数据不重复
#可变：1.有增删方法  
#	 2.所有的操作会直接作用于原函数

集合没有修改方法？
修改操作思路：通过下标找到要修改的数据，重新赋值
集合具有无序性，找不到要修改的数据

定义

# 定义集合    set    {}

# 1.定义有数据的集合
# 1.要求数据必须是不可变类型的数据
# 2.集合中的元素具有无序性
# 3.集合中的元素具有唯一性
my_set = {10,1.2,"hello",(1,2,3),10}
print(my_set)
print(type(my_set))


# 2.定义空集合 --》 构造法--->数据类型转换

my_set = set()
print(my_set)
print(type(my_set))

常用操作方法

增加数据方法

# 往集合中增加数据

# add()
# 语法：集合.add(数据)
# 作用：将数据增加到集合中（不可变数据类型）
my_set.add("world")
print(my_set)

# update()
# 语法：集合.update(可迭代对象)
# 作用：将可迭代对象中的数据进行拆分添加到集合中
# **支持的数据类型：**字符串、列表、元组(列表、元组中的元素必须不可变)、字典(将键增加到集合中)
my_set.update()
print(my_set)

查询数据方法

数据 in 集合：判断数据是否在集合中，如果在则返回True，否则返回False
数据 not in 集合：判断数据是否不在集合中，如果不在则返回True，否则返回False

删除数据方法


my_set = {"张三","李四","喜羊羊","小灰灰","玛卡巴卡"}

# 集合删除数据方法

# pop()
# 语法：集合.pop()
# 作用：从集合中任意删除一个元素
my_set.pop()
print(my_set)

# remove()
# 语法：集合.remove(数据)
# 作用：从集合中删除指定数据，如果数据不存在则报错
my_set.remove("羊羊")
print(my_set)

# discard()
# 语法：集合.discard(数据)
# 作用：从集合中删除指定数据，如果数据不存在则不进行任何删除操作且不报错
my_set.discard("张三三")
print(my_set)

# clear()
# 语法：集合.clear()
# 作用：清空集合，集合仍然存在
my_set.clear()
print(my_set)

# del
# 语法：del 集合
# 作用：删除集合，集合不存在
del my_set
print(my_set)

交集与并集

# 交集与并集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

# 交集  &    ---》取交叉重合的部分数据
print(set1 & set2)

# 并集  |   ---》 将多个集合中的数据存放在一起展示(自动去重-->数据具有唯一性)
print(set1 | set2)

补充

公共方法

+
	作用：拼接
	支持的类型：字符串、列表、元组
*
	作用：复制
	支持的类型：字符串、列表、元组
in
	作用：判断元素是否在数据中存在
	支持的类型：字符串、列表、元组、字典(键是否存在)、集合
not in
	作用：判断元素是否在数据中不存在
	支持的类型：字符串、列表、元组、字典(键是否存在)、集合

内置函数

	len()：统计长度、统计数据中元素的个数
	max()：获取最大值
	min()：获取最小值
	sum()：求和
	del()：删除数据
	......

在这里插入图片描述

啊猪是的读来过倒

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Python数据类型：编程新手的必修课

Python基础数据类型：构建编程世界的基石Python的编程世界离不开其基础数据类型，它们就像搭建房屋的砖瓦，是构建任何复杂程序的基础。从整数、浮点数、复数等数字类型，到字符串、列表、元组、字典和集合等复合数据类型，每一个都有其独特的魅力和应用场景。掌握这些数据类型，不仅能帮助我们更好地理解Python的编程逻辑，还能在数据处理、算法实现、Web开发等各个领域发挥巨大作用。让我们一同探索Python数据类型的奥秘，开启编程之旅！
复制链接

扫一扫