本文详细介绍了Python的基础数据类型，包括number（数值）、string（字符串）、tuple（元组）、list（列表）、dict（字典）和set（集合）。讲解了它们的定义、操作、内置函数以及常用方法，如字符串的格式化、列表的增删查改、字典的键值对操作等。此外，还涵盖了切片操作和集合的运算。内容深入浅出，适合Python初学者学习。
学习记录。。。。。。
目录
综述
变量：用来存储各种类型的数据。python中的变量不需要声明，每个变量在使用前必须赋值，变量赋值以后该变量才会被创建。在python中，变量就是变量，它没有类型，而我们这里所说的类型指的是这个变量所指向的内存中的对象的类型。
python的常见数据类型有：number（数值）、string（字符串）、tuple（元组）、list（列表）、dict（字典）、set（集合）
python的常见数据类型还可以分为可变数据类型和不可变数据类型，其中，number、string、tuple是不可变的数据类型，list、dict、set是可变的数据类型
对于可变和不可变数据类型的理解：同一个数据，当数据发生改变的时候，数据存储的物理位置发生了变化，则该数据即便在界面呈现的是同一个数据，但其实本质上已经发生了变化，则这种数据类型被称为不可变的数据类型， 反之则为可变数据类型。我们可以通过id(变量名)来获取数据的存储位置，以下是示例：
查看变量的数据类型可以用：type()或isinstance()
示例：
# 查看number这个变量存储的数据的数据类型
number = 1
print(type(number))
print(isinstance(number,int))number类型（数值）
定义：不通过任何符号进行标识，定义number类型的时候，直接将数值赋给变量即可。
number（数值）类型包含有四种不同的数值类型：int（整型）、float（浮点型）、bool（布尔）、complex（复数）
其中，bool因为存储的时候存的是0（False）和1（True），所以也归为number类型。
运算符：
+（加）：a + b（a加b）
-（减）：a - b（a减b）
*（乘）：a * b（a乘以b）
/和//（除）：a / b（a除以b，结果返回float型，不管是否整除）；a // b（a除以b并取商的整数部分，不会对结果进行四舍五入，其结果可能是int型也有可能是float型，取决于除数和被除数的类型，当两者都是int型时，结果将会是int型，有一个是float型，则结果为float型）
**（求幂）：a ** b（a的b次幂）
%（取余）：a % b（a除以b后取余数）
函数：
# 导入python模块，pycharm快捷方式：Ctrl+Alt+空格 或者 Alt+回车
import math
import random
# abs()获取绝对值
print(abs(-2))
# 返回：2
# floor()返回数字的下舍整数
print(math.floor(5.6))
# 返回：5
# ceil()返回数字的上入整数(只要小数点后不为0，那么返回值就是整数值+1)
print(math.ceil(5.01))
print(math.ceil(5.00))
# 依次返回：6、5
# random()返回0-1之间随机生成的一个实数
print(random.random())
# 返回示例：0.171513807152179
# randint(a,b)返回a~b之间随机生成的一个整数
print(random.randint(100, 200))
# 返回示例：161
# round(数值,精确度)进行四舍五入，没有精确度则取整，有精确度的时候若得到的值末尾为0，则返回结果会不展示末尾的0
print(round(4.78),round(4.78,1))
# 返回：5 4.8
# trunc()去掉整数部分
print(math.trunc(4.7))
# 返回：4string类型（字符串）
定义：通过单引号、双引号或三引号（英文符号）括起来的为string类型的数据。示例：
str_0 = 'string'
str_1 = "string"
str_2 = '''string'''字符串切片：见切片章节
字符的转义：在特殊字符前添加符号 \
１）常用的转义字符有：
\n 表示换行符
\t 表示制表符
\\ 表示输入反斜杠\(因为反斜杠本身具有特殊的用途，想要直接输入就需要在前面再加入一个反斜杠，其余的有特殊用途的符号也是一样的)
...
２）批量转义：
当一个字符串中有非常多需要进行转义的字符，比如计算机路径，我们可以用print(R"D:\download")或者print(r"D:\download")来批量转换
字符串格式化：
#第一种格式化方式
print("%s[住址：%s，年龄：%d]，恭迎城主大人"%("花城", "鬼市", 810))
#输出：花城[住址：鬼市，年龄：810]，恭迎城主大人
#第二种格式化方式
print("{}[住址：{}，年龄：{}]，恭迎太子殿下".format("谢怜", "菩荠观", 817))
#输出：谢怜[住址：菩荠观，年龄：817]，恭迎太子殿下
#第二种方式会比第一种方式要更具有灵活性，比如：
print("{1}[住址：{0}，年龄：{2}]，恭迎太子殿下".format("谢怜", "菩荠观", 817))
#输出：菩荠观[住址：谢怜，年龄：817]，恭迎太子殿下
#第三种格式化方式：字面量格式化3.6版本后才支持
name = '谢怜'
address = '菩荠观'
age = 817
print(f"{name}[住址：{address}，年龄：{age}]，恭迎太子殿下")
#输出：谢怜[住址：菩荠观，年龄：817]，恭迎太子殿下字符串内置函数：
#join(seq) 以指定的分隔符把seq中的元素合并成一个新字符串
join_str = "helloworld"
new_str = "-".join(join_str)
print(new_str)
#返回：h-e-l-l-o-w-o-r-l-d
#split() 通过分隔符截取字符串，得到一个列表
names = "谢怜;花城"
name1 = names.split(";")
print(name1, type(name))
#返回：['谢怜', '花城'] <class 'list'>
#replace(原字符, 新字符) 替换字符串
str_old = "1234567"
new_str = str_old.replace("123", "000")
print(new_str)
#返回：0004567
#find(查找字符, 开始索引, 结束索引) 查找字符串，如果存在返回位置索引值，没有会返回-1
ss_str = "12345678"
print(ss_str.find("123"))
#返回：0
#index(查找字符, 开始索引, 结束索引) 查找字符串，如果存在返回索引值，没有会报异常（常用？）
#count(查询字符, 开始索引, 结束索引) 返回某个字符指定范围出现的次数
print(ss_str.count("8"))
#返回：1
#startswith(匹配字符, 开始索引, 结束索引) 判断是否以某个字符开头
print(ss_str.startswith("123"))
#返回：True
#endswith(匹配字符, 开始索引, 结束索引) 判断是否以某个字符结尾
print(ss_str.endswith("789"))
#返回：False
#strip()/lstrip()/rstrip() 去空格/左边去空格/右边去空格
#format() 字符串格式化
#capitalize()/upper()/lower()/title() 大小写转换
#max()/min() 取最大值/最小值tuple类型（元组）
定义：用小括号()括起来的元素集合被定义为元组（tuple），元素集合可以是number，也可以是string，元素与元素之间用英文的逗号,进行隔开。
# 定义元组，元组可以存储多个数据
tup1 = (1, 2, 'abc')
print(type(tup1))
print(tup1)
#返回：
#<class 'tuple'>
#(1, 2, 'abc')
# 定义空元组
tup2 = ()
print(type(tup2))
print(tup2)
#返回：
#<class 'tuple'>
#()
# 定义只有一个元素的元组
tup3 = (1,)
print(type(tup3))
#返回：
#<class 'tuple'>元组切片：见切片章节
元组运算符：
+：a + b（a元组和b元组的元素组合）
*：a * number（a元组重复number次）
in：存在
not in：不存在
# 加法示例
tup1 = (1,2,3)
tup2 = (4,5,6)
tup_new = tup1 + tup2
print(tup_new)
#返回：（1,2,3,4,5,6）
# 乘法示例
tup = (1,2,3)
tup_new = tup * 3
print(tup_new)
#返回：(1, 2, 3, 1, 2, 3, 1, 2, 3)list类型（列表）
定义：用中括号[]括起来的元素集合被定义为列表（list），该元素集合可以由任意的数据类型的元素构成，元素与元素之间用英文的逗号,进行隔开。
# 定义列表
list1 = [88,'test',(1,2,3),[1,2,3]]
print(type(list1))
#返回：<class 'list'>列表切片：见切片章节
列表运算符：
+：a + b（a列表和b列表的元素进行拼接）
*：a * number（a列表的元素循环重复number次）
in：存在
not in：不存在
列表的内置函数：
# append()向列表末尾增加一个元素
list1 = ['test1', 'test2', 'test3']
list1.append('test4')
print(list1)
#返回：['test1', 'test2', 'test3', 'test4']
# insert(index,object)可以造指定位置插入值，index代表索引值，object代表值
list1 = ['test1', 'test2', 'test3']
list1.insert(1, 'test4')
print(list1)
#返回：['test1', 'test4', 'test2', 'test3']
# extend()向列表中批量添加多个元素
list1 = ['test1', 'test2', 'test3']
list1.extend(['test4', 'test5', 'test6'])
print(list1)
#返回：['test1', 'test2', 'test3', 'test4', 'test5', 'test6']
# pop()根据索引删除列表中的元素，当不传入索引值的时候，删除最后一个，否则删除指定索引值的元素，pop()函数会返回被删除的值
list1 = ['test1', 'test2', 'test3']
list1.pop()
print(list1)
list1 = ['test1', 'test2', 'test3']
list1.pop(0)
print(list1)
#分别返回：['test1', 'test2']和['test2', 'test3']
# clear()清除列表所有元素
list1 = ['test1', 'test2', 'test3']
list1.clear()
print(list1)
#返回：[]
# copy()复制列表
list1 = ['test1', 'test2', 'test3']
list1_copy=list1.copy()
print(list1_copy)
#返回：['test1', 'test2', 'test3']
# remove()根据值进行删除
list1 = ['test1', 'test2', 'test3']
list1.remove('test2')
print(list1)
#返回：['test1', 'test3']
# index()查找元素，若有匹配值，则返回索引值，否则报错
list1 = ['test1', 'test2', 'test3']
print(list1.index('test2'))
#print(list1.index('test4'))会报错，注释了
#返回：1
# count()查找某个元素在列表中出现的次数
list1 = ['test1', 'test2', 'test3', 'test1']
print(list1.count('test1'))
#返回：2
# sort()对列表进行正序排序
list1 = ['test1', 'test2', 'test3', 'test1']
list1.sort()
print(list1)
#返回：['test1', 'test1', 'test2', 'test3']
# reverse()对列表进行反转
list1 = ['test1', 'test2', 'test3', 'test1']
list1.reverse()
print(list1)
#返回：['test1', 'test3', 'test2', 'test1']dict类型（字典）
定义：用大括号{}括起来的键值对集合被定义为字典（dict），每一对键值对之间用英文的逗号,进行隔开，键值对的表现形式以key-value的形式存在，其中，key必须是唯一的，否则取最后面定义的值，value只能是不可变数据类型。
# 定义字典
dict1 = {'color': 'green', 'points': 5}
print(type(dict1))
#返回：<class 'dict'>字典取值：变量名[key]、变量名.get(key)
字典相关方法：
# 字典取值：变量名[key]、变量名.get(key)
dict1 = {'color': 'green', 'points': 5}
print(dict1["color"])
print(dict1.get("points"))
#依次返回：green和5
# 修改元素的值：变量名[存在的key] = value
dict1 = {'color': 'green', 'points': 5}
dict1["color"]="red"
print(dict1)
#返回：{'color': 'red', 'points': 5}
# 添加键值对
dict1 = {'color': 'green', 'points': 5}
dict1['x_position'] = 0
print(dict1)
#返回：{'color': 'green', 'points': 5, 'x_position': 0}
# clear()清空元素
dict1 = {'color': 'green', 'points': 5}
dict1.clear()
print(dict1)
#返回：{}
# 删除键值对
dict1 = {'color': 'green', 'points': 5}
del dict1["color"]
print(dict1)
#返回：{'points': 5}
# 复制字典
dict1 = {'color': 'green', 'points': 5}
dict_copy = dict1.copy()
print(dict_copy)
#返回：{'color': 'green', 'points': 5}
# fromkeys()可批量创建一个value值相同的字典
keys=["color","points","x_position","y_position"]
dict1=dict.fromkeys(keys,"")
print(dict1)
#返回：{'color': '', 'points': '', 'x_position': '', 'y_position': ''}
# items()循环读取到字典中所有的数据key,value
dict1 = {'color': 'green', 'points': 5}
for key,value in dict1.items():
print(key,value)
#返回：color green points 5 *结果是两行，这边在一行展示*
# update()可用于字典合并
dict1 = {'color': 'green', 'points': 5}
dict2 = {'x_position': 0, 'y_position': 25}
dict1.update(dict2)
print(dict1)
#返回：{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
# pop(key)根据key值进行删除，必须需要有key值
dict1 = {'color': 'green', 'points': 5}
dict1.pop("color")
print(dict1)
#返回：{'points': 5}
# popitem()删除键值对，默认删除最后一对键值对
dict1 = {'color': 'green', 'points': 5}
dict1.popitem()
print(dict1)
#返回：{'color': 'green'}
# 删除对象
dict1 = {'color': 'green', 'points': 5}
del dict1set类型（集合）
定义：用大括号{}括起来的元素集合被定义为集合（set），元素与元素之间用英文的逗号,进行隔开，元素的只支持不可变数据类型。
# 定义集合
set1 = {1,2,3,4,(1,2,3)}
print(type(set1))
#返回：<class 'set'>
# 定义空集合
set1 = set()
print(set1)
print(type(set1))
#依次返回：set()和<class 'set'>集合的运算：
set1 = {1,2,3,4,5}
set2 = {6,7,8,9,10,5,4}
# 交集
set_new = set1 & set2
print(set_new)
print("通过方法进行交集运算：",set1.intersection(set2))
#返回1：{4, 5}
#返回2：通过方法进行交集运算： {4, 5}
# 并集
set_new = set1 | set2
print(set_new)
print("通过方法进行并集运算",set1.union(set2))
#返回1：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
#返回2：通过方法进行并集运算 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
# 差集：set1-set2返回set1集合的所有元素，但是不会包含set2中的元素，注意前后关系
set_new = set1 - set2
print(set_new)
print("通过方法进行差集运算",set1.difference(set2))
#返回1：{1, 2, 3}
#返回2：通过方法进行差集运算 {1, 2, 3}
# 异或：set1^set2返回两个集合相同元素之外的其他元素的集合
set_new = set1 ^ set2
print(set_new)
print("通过方法进行异或运算",set1.symmetric_difference(set2))
#返回1：{1, 2, 3, 6, 7, 8, 9, 10}
#返回2：通过方法进行异或运算 {1, 2, 3, 6, 7, 8, 9, 10}
# issubset()判断是否为子集合，是返回true，不是返回false
set3 = {6,10}
print(set3.issubset(set1))
#返回：False集合相关方法：
# isdisjoint()判断两个集合是否包含相同元素，如果没有则返回true，否则返回false
set1 = {1,2,3,4,5,6}
set2 = {5,6,7,8,9,0}
if set1.isdisjoint(set2):
print("没有重复的元素")
else:
print("有重复的元素")
#返回：有重复的元素
# 增加集合元素
set1 = {1,2,3,4,5,6}
set1.add(9)
print(set1)
#返回：{1, 2, 3, 4, 5, 6, 9}
# 批量增加集合元素
set1 = {1,2,3,4,5,6}
set1.update({7,8,9})
print(set1)
#返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 移除元素
set1 = {1,2,3,4,5,6}
set1.remove(3)
print(set1)
#返回：{1, 2, 4, 5, 6}切片
因string、tuple、list和dict类型都可以使用切片进行截取，在这里单独拎出来进行记录，以下先定义这几种数据类型，用于下文中示例使用
#定义一个string类型
str_section = '12345678901234123'
#定义一个tuple类型
tup_section = ('xielian', 'huacheng', 34, 'test', 87)
#定义一个list类型
list_section = 切片语法格式：变量名[start: end: step]
变量名：可以是string、tuple、list、dict类型的变量的变量名
start：开始索引，索引值从左到右，从0开始
end：结束索引
step：步长，默认是1
场景：
1）正序截取单个字符/元素
变量名[索引值] --索引值从0开始
示例：
#string
print(str_section[2])
#返回：3
#tuple
print(tup_section[2])
#返回：34 2）倒序截取单个字符/元素
变量名[索引值] --索引值从-1开始
示例：
#string
print(str_section[-3])
#返回：1
#tuple
print(tup_section[-3])
#返回：34 3）正序截取某一段的字符/元素
变量名[开始索引值: 结束索引值] --注意差一原则，可以理解成这是一个左闭右开的区间
示例：
#string
print(str_section[2:9])
#返回：3456789
#tuple
print(tup_section[1:4])
#返回：('huacheng', 34, 'test') 4）从某个字符开始，截取到最后(正序)
变量名[开始索引值: ] --开始索引值可以是正数，也可以是负数，总之就是从定位的位置开始，截取到最后
示例：
#string
print(str_section[5:])
#返回：678901234123
#tuple
print(tup_section[2:])
#返回：(34, 'test', 87) 5）从第一个字符开始，截取到指定位置(正序)
变量名[ :结束索引值]
示例：
#string
print(str_section[:12])
#返回：123456789012
#tuple
print(tup_section[:-3])
#返回：('xielian', 'huacheng') 6）字符串反转
变量名[::-1]
示例：
#string
print(str_section[::-1])
#返回：32143210987654321
#tuple
print(tup_section[::-1])
#返回：(87, 'test', 34, 'huacheng', 'xielian')
扫一扫
1094
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
