python基本数据类型整数、小数、字符串、布尔、空值、列表、元组、字典、集合、bytes

python基本数据类型

python基本数据类型整数、小数、字符串、布尔、空值、列表、元组、字典、集合、bytes
- 1、整数和小数(浮点数)
- 2、布尔值和空值
- 3、字符串
- 4、列表
- 5、元组
- 6、字典
- 7、集合
- 8、bytes类型
总结

1、整数和小数(浮点数)

基本数据类型
• 数据类型指的就是变量的值的类型，也就是为变量所赋的值。

整数和小数

整数 : 所有整数例如 : a = 1 b = 100 c =999 都是int类型
小数常量 : 所有小数例如 a = 1.2 b=6.66 用float类型表示

2、布尔值和空值

布尔值和空值

布尔: 只有True 和False两个值
None常量：只有一个数值就是None 也就是空值

3、字符串

什么是字符串

字符串是由数字、字母、下划线组成的一串字符

注意
• 单引号或双引号不能混合使用
• Python中用一对双引号或者一对单引号包裹的内容就是字符串

转义字符
• 转义字符是一种特殊的字符常量。转义字符以反斜线""开头,后跟一个或几个字符。

总结
• \t 表示制表符
• \n 表示换行符
• \ 表示反斜杠
• ’ 表示 ’
• \ ‘’ 表示 ‘’

长字符串
• 长字符串又叫做文档字符串我们使用三重引号来表示一个长字符串’’’ ‘’’
• 三重引号可以换行，并且会保留字符串中的格式

'''长字符串 又叫做文档字符串 我们使用三重引号来表示一个长字符串'''''' 长字符串又叫做文档字符串
我们使用三重引号来表示一个长字符串'''

格式化字符串
• 第一种格式化字符串拼串

a = 'hello'
b = 'world'
print(a +' '+ b)

• 第二种格式化字符串参数传递

c = 'world'
print('hello',c)

• 第三种格式化字符串占位符
• %s 字符串占位
• %f 浮点数占位
• %d 整数占位

a = 1
b = 'shhdb'
c = 1.256489
print('输入的是整数%d'%a)
print('输入的是字符串%s'%b)
print('输入的是浮点数%f'%c)

• 第四种格式化字符串 f’{变量}’
• str.format ()

a = 'lyj'
print(f'这是一个女孩{a}')
print('这是一个漂亮的女孩{}'.format(a))

字符串的其他操作

#• len() 字符串的长度
a = 'sdbsdbhsdh'
print(len(a))
#• max() 最大值
a = [1,2,3,5]
print(max(a))
b = 'abc'
print(max(b))
#• min() 最小值
print(min(a))
'注意：在字符串中进行max()和min()函数时，会按照26字母的顺序进行取值，大的往后取小的往前取'
#• split()分割字符串
a = 'adshteddfbxdf'
print(a.split('d'))
#• join()拼接字符串
a="abcd"
b="1"
c="9"
print ",".join([a,b,c])
#• find()查找字符串
a = 'adshteddfbxdf'
print(a.find("edd"))
#• replace() 替换字符串
a = 's ns v vbsvvbbhv'
print(a.replace(' ',','))
#• partition() 把字符串分割为三部分
a = 'adshteddfbxdf'
print(a.partition('d'))

去空格
• s.strip() 左右两边去空格
• s.lstrip() 去左边空格
• s.rstrip() 去右边空格

字符串大小写
• s.upper() 全部大写
• s.lower() 全部小写
• s.isupper() 判断是不是大写
• s.islower() 判断是不是小写

4、列表

序列（sequence）

基本概念

序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
数据结构指计算机中数据存储的方式

序列的分类
• 可变序列（序列中的元素可以改变）：例如列表（list）
• 不可变序列（序列中的元素不能改变）：例如字符串（str）元组（tuple）

列表(list)
• 列表是Python中的一个对象
• 列表的作用
• 列表中可以保存多个有序的数据
• 列表是用来存储对象的对象

a = [1,2,3,None,'bdshsvh',[1,2,3,5]]

列表的使用
• 列表的创建：通过[]来创建一个空列表

a = [1,2,3,None,'bdshsvh',[1,2,3,5]]
print(a[0])

** 切片**
• 切片是指从现有列表中获得一个子列表
• 通过切片来获取指定的元素

• 语法: 列表[起始 : 结束 : 步长]

通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
起始位置和结束位置的索引可以不写

a = [1,2,3,4,5,6,7,8]
print(a[:])

如果省略结束位置, 则会从当前的开始位置一直截取到最后

print(a[0:])

如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素

print(a[:7])
print(a[:9])
'上述的列表a只有7个索引，但是a[:9]后面的9超出了范围，只会显示到8就结束'

如果开始位置和结束位置都省略, 则则会从第一个元素开始截取到最后一个元素
步长表示每次获取元素的间隔，默认是1(可以省略不写)
步长不能是0,但可以是是负数

print(a[0::2])
print(a[0::-1])

通用操作

‘+’ 和 *
• + 可以将两个列表拼接成一个列表
• * 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)

a = [1,2,3,4,5,5]
b = [3,4,5]
# ‘+’ 和 *
print(a+b)  # + 可以将两个列表拼接成一个列表
print(a*3)  # * 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)

in 和 not in
• in用来检查指定元素是否在列表当中
• not in 用来检查指定元素是否不在列表当中
• len() 获取列表中元素的个数
• max() 获取列表中最大值
• min() 获取列表中最小值

# in 和 not in
# • in用来检查指定元素是否在列表当中
print(1 in a)
# • not in 用来检查指定元素是否不在列表当中
print(6 not in a)
# • len() 获取列表中元素的个数
print(len(a))
# • max() 获取列表中最大值
print(max(a))
# • min() 获取列表中最小值
print(min(a))

• list.index(x[, start[, end]])
• 第一个参数获取指定元素在列表中的位置
• 第二个参数表示查找的起始位置
• 第三个参数表示查找的结束位置
• list.count(x) 统计指定元素在列表中出现的个数

# • list.index(x[, start[, end]])
#  • 第一个参数 获取指定元素在列表中的位置
#  • 第二个参数 表示查找的起始位置
#  • 第三个参数 表示查找的结束位置
print(a.index(5,2,5))
#  • list.count(x) 统计指定元素在列表中出现的个数
print(a.count(5))

修改列表

通过切片来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
通过切片来删除元素
• del list[起始 : 结束]
• list = []

a = ['ab',1,2,3,[1,2],6,8,9]
a[0]='abc'  #改变a[0]的值，相当于给a[0]重新赋值
a[1:4:2]=6,5 #根据步长给1-4之间相应的位置进行值的替换
del a[7:8]   #删除列表中的值
del a[5]
print(a)

列表的方法
• append() 像列表的最后添加一个元素
• insert(arg1,arg2) 像列表指定位置插入一个元素参数1:要插入的位置参数2:要插入的元素
• extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
• pop() 根据索引删除并返回指定元素
• remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
• reverse() 翻转列表
• sort(key=None,reverse=False) 用来对列表中的元素进行排序 reverse：True反序；False 正序

b = [1,2,3,3,4,5,9]
# • append() 像列表的最后添加一个元素
b.append(10)
print(b)
# • insert(arg1,arg2) 像列表指定位置插入一个元素  参数1:要插入的位置 参数2:要插入的元素
b.insert(3,20)
print(b)
# • extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
b.extend([1,2,3])
print(b)
# • pop() 根据索引删除并返回指定元素
b.pop(b[1])
print(b)
# • remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
b.remove(3)
print(b)
# • reverse() 翻转列表
b.reverse()
print(b)
# • sort(key=None,reverse=False) 用来对列表中的元素进行排序 reverse：True反序；False 正序
b.sort()
print(b)

5、元组

元组简介

元组表现形式tuple
元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
使用()创建元素
元组不是空元组至少有一个逗号(,) 当元组不是空元组时括号可以省略
元组解包指将元组当中的每一个元素都赋值给一个变量

tuple_1 = (1,2,3,True)   #对于元组这种不可变的数据，通常称之为常量）
print(tuple_1,type(tuple_1))
print(tuple_1[1:3])
print(tuple_1.index(2))#如果创建的不是一个空的元组，那么它里面至少有一个逗号，只做一个变量赋值时，元组括号可以省略
#空元组
c = ()
a = (10)
print(a) #数据类型为int
b = (10,)
d = 10,   #元组
e = 10, 20  #元组
print(type(b))  #元组
#元组的拆包
tuple_2 = (1,2,3,4)
a,b,c,d = tuple_2
print(a,b,c,d)
a,*b = tuple_2   #*表示匹配所有，注意：不能同时存在两个或这两个以上的*
print(a)
print(b)

6、字典

字典的基本介绍
• 字典属于一种新的数据结构称为映射(mapping)
• 字典的作用和列表类似，都是用来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
• 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
• 创建一个有数据的字典语法 {key:value}
• 字典的值可以是任意对象字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后面的会替换前面的

字典的使用
• dict()函数来创建字典

dict()                        # 创建空字典
{}
dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
dict(zip(['one', 'two', 'thr'], [1, 2, 3]))   # 映射函数方式来构造字典
{'one': 1, 'two': 2, 'thr': 3}
dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'one': 1, 'two': 2, 'three': 3}

• get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

a = {"name":"lyj",'value':1,'type':'int'}
b = {'a':1}
print(a.get('value'))

• update() 将其他字典的key-value添加到当前的字典当中

a.update(b)
print(a)

• del 删除字典中的key-value

del a['a']
print(a)

• popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回

a.popitem()
print(a)

• pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
a.pop(‘a’)
print(a)

copye()
copy() 方法用来对字典进行潜复制

c = a.copy()
print(c)

注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的

遍历字典
我们主要可以通过3种方式对字典进行遍历
• keys() 该方法返回字典所有的key

for k in a.keys():print(k,a[k])

• values() 该方法返回一个序列序列中保存有字典的值

for t in a.values():print(t)

• items() 该方法会返回字典中所有的项它返回一个序列，序列中包含有双值子序列双值分别是字典中的key和value

for i,w in a.items():print(i,w)

7、集合

集合简介

集合表现形式set 集合和列表非常相似
不同点
• 集合只能存储不可变对象
• 集合中存储的对象是无序的
• 集合不能出现重复元素
使用{}来创建集合
• 可以通过set()来将序列和字典转换成集合
• len() 使用len()来获取集合中元素的数量
• add()像集合中添加元素
• update()将一个集合中的元素添加到另一个集合当中
• pop()随机删除集合中的一个元素一般是删除最后一个元素
• remove() 删除集合中指定的元素
• clear() 清空集合

b = [1,2,3,3,4,5,9]
# • 可以通过set()来将序列和字典转换成集合
a = set(b)
# • len() 使用len()来获取集合中元素的数量
len(a)
# • add()像集合中添加元素
a.add(6)
print(a)
# • update()将一个集合中的元素添加到另一个集合当中
a.update({1,2})
# • pop()随机删除集合中的一个元素一般是删除最后一个元素
a.pop()
# • remove() 删除集合中指定的元素
a.remove(3)
# • clear() 清空集合
a.clear()

集合的运算
• & 交集运算
• | 并集运算
• - 差集运算
• ^ 亦或集
• <= 检查一个集合是否是另一个集合的子集
• < 检查一个集合是否是另一个集合的真子集
• >=检查一个集合是否是另一个集合的超集
• >检查一个集合是否是另一个集合的真超集

b = [1,2,3,3,4,5,9]
c = set(b)
d = {1,2}
# • & 交集运算
print(c&d)
# • | 并集运算
print(c|d)
# • - 差集运算
print(c-d)
print(d-c)  #错误
# • ^ 亦或集
print(c^d)
# • <= 检查一个集合是否是另一个集合的子集
print(d<=c)
# • < 检查一个集合是否是另一个集合的真子集
print(d<c)
# • >=检查一个集合是否是另一个集合的超集
print(c>=d)
# • >检查一个集合是否是另一个集合的真超集
print(d>c)

可变类型：列表字典集合值改变了，但是id不变
不可变类型：字符串元组值改变了，id也会改变

8、bytes类型

bytes介绍

在Python3以后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。
bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。
Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。

bytes创建

可以通过调用bytes()生成bytes实例，其值形式为 b’xxxxx’，对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

>>> a = b'hello'
>>> type(a)
<class 'bytes'>
>>> b = bytes('hello',encoding='utf8')
>>> type(b)
<class 'bytes'>

bytes类型常用转换
那在实际应用中，我们通常会将bytes类型与str类型做转换。

字节转为字符串

>>> d = b'world'
>>> d.decode()
'world'
>>> type(d)
<class 'bytes'>

字符串转为字节

>>> e = 'world'
>>> e.encode()
b'world'
>>> type(e)
<class 'str'>

总结

本文为学习笔记，转载请标明出处，本文仅供交流学习，请勿用于非法途径，希望本文对大家有帮助。

仅是个人意见，如有不足之处或者侵权，请留言