python基础语法的数据类型

数据类型

==Python中分为六种基本数据类型 ==

• 不可变类型（又叫静态数据类型，没有增删改操作）：Number（int、float）-数值、Boolean-布 尔、String-字符串、Tuple-元组、Bytes-字节
• 可变类型（又叫动态数据类型，支持增删改操作）：列表(list)、字典(dictionary)、集合(set)

静态类型

一、静态类型：Number（int、float）-数值、Boolean-布尔、String-字符串、Tuple-元组

1. python整数类型（int）

# 将78赋值给n
n = 78
print(n)
print(type(n))
click = 1_301_547
distance = 384_000_000
print("Python教程阅读量：", click)
print("地球和月球的距离：", distance)

2. python小数/浮点数（float）类型

# 十进制形式
f1 = 12.5
print("flavue:",f1)
print("f1Type:",type(f1))
f2 = 0.3257003
print("flavue:",f2)
print("f2Type:",type(f2))

#指数形式
f3 = 0.0000847
print("f3value:",f3)
print("f3Type:",type(f3))

3、 Python bool布尔类型 Python 提供了 bool 类型来表示真（对）或假（错），True 和 False 是 Python 中的关键字，当作 为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。

bT = True
bF = False
print(bT,type(bF))

bT  = bT + 1
print(bT,type(bT))
bF = bF + 0
print(bF)

print(3 > 5, 3 < 5)

4、Python字符串

#若干个字符的集合就是一个字符串（String）。Python中的字符串必须由双引号" "或者单引号' '包围。Python 字符串中的双引号和单引号没有任何区别。

#单行字符串
str1 = '这是一个简单字符串'

 # 对引号进行转义
str2 = 'I\'m a great coder!'
str3 = "引文双引号是\"，中文双引号是“"
 # 多行字符串
str4 = """长字'aaa'符串内容"""
str5 = '''长字"bbb"符串内容'''

# 在长字符串中放置单引号或者双引号不会导致解析错误。
# 如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。

5、Python原始字符串

 # Python 支持原始字符串。在原始字符串中，\不会被当作转义字符，所有的内容都保持“原汁原味”的样
子。
# 在普通字符串或者长字符串的开头加上r前缀，就变成了原始字符串，具体格式为：
str6 = r'原始字符串内容'
 str7 = r"""原始字符串内容"""
 rstr = r'D:\Program Files\Python 3.8\python.exe'
 print(rstr)

6、Python Bytes类型及用法

bytes 类型的数据非常适合在互联网上传输，可以用于网络通信编程；bytes 也可以用来存储图片、音频、 视频等二进制格式的文件。

# 通过构造函数创建空 bytes
b1 = bytes()
# 通过空字符串创建空 bytes
b2 = b''
# 通过b前缀将字符串转换成 bytes
b3 = b'https://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])
# 为 bytes() 方法指定字符集
b4 = bytes('C语言中文网8岁了', encoding='UTF-8')
print("b4: ", b4)
# 通过 encode() 方法将字符串转换成 bytes
b5 = "C语言中文网8岁了".encode('UTF-8')
print("b5: ", b5)
# 通过 decode() 方法将 bytes 转换成字符串
str1 = b5.decode('UTF-8')
print("str1: ", str1)

7、元组(tuple)

元组也是一组可重复且有序的对象集合，任何类型的数据都可以存到元组中，但是元组中的元素是不可变的， 元组同样也支持索引截取(又叫切片)

t0 = ()
# 创建空元组
t1 = ("王昭君", "lisi", ["李思思", 12, "Python"], ("王武", "22"))  # 直接使用小括号创建元组
t2 = (1,)                          
# 当元组只有一个元素时需要在后面加上逗号
t3 = tuple(("依儿",22,"Java"))   # 或者调用内置函数tuple()，通常用于转换为元组时使用
print('t0：', t0)
print('t1：', t1)
print('t2：', t2)
print('t3：', t3)

# 读取
print(t1[1]) # 获取元组t1中第二个元素，输出：lisi
print(t1[0:2]) # 获取元组t1中第一个和第二个元素，输出：('张珊', 'lisi')
print(t1[2:-1]) # 获取元组t1中第三个至倒数第二个元素，输出：(['李思',12,'Python'],)
print(t1[1::2]) # 获取元组t1中第二个至最后一个元素，步长为2，输出出：('lisi', ('王武', '22'))
print(t1[::-1]) # 步长为-1时表示倒序排列，输出：(('王武', '22'), ['李思',12,'22'))'Python'], 'lisi', '张珊')
print(t1[2][0:-1])  # 获取元组t1中第三个元素中的第一个至倒数第
# 修改元组中的可变对象
# 修改元组t1中列表中的元素
t1[2][1] = "十" # 将12改为10
t1[2].remove("Python")  # 删除Python元素
t1[2].pop() # 删除最后一个元素
t1[2].clear() # 清空列表
t1[2].append("啊哈") # 添加一个元素
# 拼接元组
print(t2+t3) # 输出：('1', '依儿', 22, 'Java')

动态类型

二、动态类型： 列表(list)、字典(dictionary)、集合(set)

1、列表是一组可重复且有序的数据集合，任何类型的数据都可以存到列表中，会根据需要动态分配和回收内 存，是Python中使用最频繁的数据类型，列表同样也支持索引截取(又叫切片)，列表中的元素是可变的，能 够进行增删改操作

# 创建
l0 = [] #创建空列表
l1 = ["张三", 'list',12,["22","list","王武"],"赵柳"] # 直接使用中括号创建列表
l2 = list(['list',12,("22","王武"),"赵柳"]) # 或者调用内置函数list(),通常用于转换为列表时使用
print(l0,l1,l2)

 # 读取
print(l1[1])            # 获取列表l1中第二个元素，输出：lisi
print(l1[0:2])          # 获取列表l1中第一个和第二个元素，输出：['张三', 'lisi']
print(l1[-5:-2])        # 获取列表l1中第一个至倒数第三个数据，反向索引，输出：['张三','lisi', 12]
print(l1[2:-1])
print(l1[1::2])         # 获取列表l1中第一个至第二个
print(l1[:1:-2])        # 反向获取列表l1中元素，步长为-2，输出：['赵柳', 12]
print(l1[::-1])         # 步长为-1时表示倒序排列元素，输出：['赵柳', ['22', 'lisi', '王武'], 12, 'lisi', '张三']
print(l1[3][-1])        # 嵌套，l1嵌套列表中，最后一个元素
print(l1[3][0])         # 嵌套，l1嵌套列表中，第一个元素
# print(l1[5])          # 若元素不存在，则会抛出IndexError: list index out of range
print("===" * 20)
for i in l1:   # 使用for循环遍历列表中的元素
  print(i)

# 判断是否存在
print("list" in l1)
print("赵柳" not in l1)
print("22" in l1[3])    # 判断l1的嵌套列表是否包含22

# 修改
l1[1] = "李思"  # 将l1列表中第二个元素改为李思
l1[3][0] = 22  # 嵌套
l1[1:3] = ["张珊", "李四"] # 第二个和第四个修改

# 添加
# 使用函数，l.append()\l.exend()\l.insert()
l3 = [1,2]
l4 = ["一","二"]
l3.append(3)  # l3列表末尾添加元素3
l3.append(l4) # l4列表添加到l3末尾
l3.extend(l4) # 将l4元素添加到l3列表末尾
l3.insert(1,"张三")
l3.insert(0,l4)

# 删除
l1.remove("张三") # 删除指定元素
l1.pop(1) #删除第二个元素
l1.clear() #清空l1列表
del l1   # 删除l1列表

2、字典(dictionary)

字典是一组可变的无序的对象集合，字典中的元素是通过键(Key) : 值(Value)来保存的，一组键值对称为 一个元素，其中键(Key)不可重复，必须唯一，而值(Value)是可重复的，字典会浪费较大内存，是一种使用 空间换时间的数据类型

# 创建空字典
d0 = {} # 创建空字典
d1 = {"张珊":100,"李思":120,"王武":110}
d2 = dict(name="李尔",weight=116) # 调用内置函数dict()创建，通常用于转换为字典时使用

# 查询
print(d1["李思"])  # 查询中括号根据key获取value值，输出 ，120，若不存在，则输出”李思“

# 还可以使用get()方法取值，若key不存在返回None，不会变成异常，还可以设置默认value
print(d1.get("张珊"))
print(d1.get("王武",98)) # 若查询不到输出98

# 使用keys()方法获取所有keys
print(d1.keys())            # 获取字典中所有的key
print(list(d1.keys()))      # 获取字典中所有的key并转为列表
print(tuple(d1.keys()))     # 获取字典中所有的key并转为元组

# 使用value()方法获取所有value的值
print(d1.values())          # 获取字典中所有value值
print(list(d1.values()))    # 获取字典中所有的value值，转为列表
print(tuple(d1.values()))   # 获取字典中所有的value值并转为元组

# 使用items()方法获取所有的键值对
print(d1.items())           # 获取字典中所有的键值对
print(list(d1.items()))
print(tuple(d1.items()))

for item in d1:
    print(item)             # 返回字典中所有的key

# 判断key是否存在
print("李思" in d1)

# 增删改
d1["李思"] = 118 # 将李思的值改为118
d1["张三"] = 106
d1.pop("张三")    # 删除键值对
del d1["张三"]
d1.clear()        #清空字典
del d1            # 删除字典

3.集合

集合是一组可变的、无序的且不可重复的元素序列，可以理解为是没有Value值得字典，基本功能是测试元素 之间的关系和删除重复元素。

# 创建
s0 = set()      # 创建空集合
s1 = {"李思","张珊","李思","王武"}
s2 = set("李尔")

# 获取
print(s1)
for i in s1:
    print(i)

ls = list(s1)       # 将集合转换成列表
print(ls[1])
print(ls[0:2])      # 第一个和第二个两个元素

# 是否存在
print("李思" in s1)

# 添加、更新
s1.add("赵柳")        # 添加一个元素，因为集合是无序的，所以元素位置随机
# update也可以理解为新增，当存在相同元素时，相同元素会被覆盖，不同元素会新增到集合中
s1.update("张三")     # 集合中会添加两个元素，‘张’、‘三’
s1.update("张三丰")  # 集合中会更新两个元素，‘张’和‘三’，新增一个元素‘丰’

 # 删除
s1.remove("李思")  # 删除s1集合中的元素“李思”，若元素不存在，则抛出KeyError: '李思'
s1.discard("张三")  # 删除s1集合中的元素“张三”，若元素不存在，不会抛出任何异常
s1.pop()            # 随机删除任意一个元素
s1.clear()          # 清空集合中的元素
del s1              # 删除集合