数据类型与序列类型

变量

# 打印
print(123)

# 变量就是专门用来保存数据的，关键词不能用于变量
# 赋值给变量num
num = 123

# 打印
# 123
print(num)

# 还可用于计算
new_num = num + 2

# 打印结果
# 123
print(new_num)

# 导入关键词模块
import keyword


# 关键词不可用于变量
# 查看关键词
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
print(keyword.kwlist)

1. 数值类型

"""

数值类型


整数  int 转换方式: int()

浮点数  float 转换方式: float()

复数  complex (了解)

布尔  bool 转换方式: bool()

"""

1. 整数

# 运算符号  + - * / % **

# 赋值计算
num = 1 + 1

# 打印结果
# 2
print(num)

# 打印类型
# <class 'int'>
print(type(num))

2. 浮点数(小数)

# 导入模块
import decimal

# 赋值计算
num = 0.1 + 0.2

# 打印结果
# 0.30000000000000004
print(num)

# 打印类型
# <class 'float'>
print(type(num))

# 精确计算
new_num = decimal.Decimal("0.1") + decimal.Decimal("0.2")

# 打印结果
# 0.3
print(new_num)

3. 布尔

# 布尔(True,False)

# 打印
# True
print(bool(True))

# 打印
# False
print(bool(False))

# 打印
# True
print(bool(1))

# 打印
# False
print(bool(0))

4. 复数(了解)

# 复数
e = 1 + 2j

# 查看类型
# <class 'complex'>
print(type(e))

# 取实部
# 1.0
print(e.real)

# 取虚部
# 2.0
print(e.imag)

5. 转换

# 小数转整数

# 赋值
num = 1.223

# 转换为整数
# 1
print(int(num))

# 类型
# <class 'int'>
print(type(int(num)))


# 整数转小数

# 赋值
num_1 = 12323

# 转换为浮点数
# 12323.0
print(float(num_1))

# 类型
# <class 'float'>
print(type(float(num_1)))

2. 序列类型

"""

序列类型


字符串  str 符号: ''  ""  """"""  转换方式: str()  不可变类型

列表  list  符号: []  转换方式: list()  可变类型

元组  tuple  符号: ()  转换方式: tuple()  不可变类型

"""

"""

可变类型: 对数据进行增删改查后，原来的数据发生变化，但内存地址不会发生改变

不可变类型: 不可以对原数据进行增删改，一旦修改，内存地址就会变化

"""

# 可变类型，例: 列表

# 赋值
num = ['a', 'b', 'c']

# 打印内存地址
# 1892807001600
print(id(num))

# 添加数据
num.append("e")

# 打印结果
# ['a', 'b', 'c', 'e']
print(num)

# 打印内存地址
# 1892807001600
print(id(num))


# 不可变类型，例 字符串

# 赋值
num = "hello world"

# 打印内存地址
# 1545194057264
print(id(num))

# upper 把所有的字母转换为大写
num_1 = num.upper()
# HELLO WORLD
print(num_1)

# 打印内存地址
# 1545195503856
print(id(num_1))


# 不可变类型，例 元组

# 赋值
num_1 = ('a', 'b', 'c', 'd')

# 打印内存地址
# 1892804106976
print(id(num_1))

# 转换为列表进行修改
num_2 = list(num_1)

# 添加数据
num_2.append('f')

# 打印
# ['a', 'b', 'c', 'd', 'f']
print(num_2)

# 打印内存地址
# 1892807014080
print(id(num_2))

# 转换回元组
num_3 = tuple(num_2)

# 打印内存地址
# 1892799396176
print(id(num_3))

1. 字符串

# 单引号
'hello world'

# 双引号
"hello world"

# 三引号 可以多行
'''
hello world
hello world
'''
"""
hello world
hello world
"""

# 引号嵌套
"'hello world'"

# 赋值
num = """abc
def
ghi
jk"""

# 打印
# abc
# def
# ghi
# jk
print(num)

2. 列表

# 列表 用逗号隔开
# 列表里可以放 变量.整数.浮点数.字符串.列表 也可以为空


# 赋值
qi = "hello world"

# 嵌套
num = [qi, 1, 2, 3, 4, 5, 6, "hello", [1, 2, [1, 2], 3]]

# 查看类型
# <class 'list'>
print(type(num))

3. 元组

# 元组 用逗号隔开 必须要有一个逗号才能算作元组
# 元组里可以放 变量.整数.浮点数.字符串.列表 也可以为空

# 赋值 可以嵌套
num = (1, 2, 3, 4, 5)

# 查看类型
# <class 'tuple'>
print(type(num))

# 不加逗号不能算作元组
num_1 = (1)

# 查看类型
# <class 'int'>
print(type(num_1))

# 只要用逗号隔开，不加括号也算是元组
num_2 = 1, 2, 3, 4, 5

# 查看类型
# <class 'tuple'>
print(type(num_2))

4. 转换

# 字符串


# 引号内只要有一个不是数字，不能转换为整数和浮点数
# 引号内是整数可以直接转整数或浮点数
# 浮点数要先转换为浮点数，再转为整数
# 任何类型都可以转换为字符串

# 赋值
num_1 = "123"

# 转换为整数
# 123
print(int(num_1))

# 转换为浮点数
# 123.0
print(float(num_1))

# 赋值
num_2 = "123.12"

# 转换为浮点数
# 123.12
print(float(num_2))

# 转换为整数
# 123
print(int(float(num_2)))


# 列表


# 赋值
num_3 = "hello world"

# 转换为列表
# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
print(list(num_3))

# 赋值
num_4 = ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

# 转换为字符串
# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
print(str(num_4))

# 类型
# <class 'str'>
print(type(str(num_4)))


# 元组


# 把列表转换为元组
# ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
print(tuple(num_4))

3. 其它操作

1. 索引

# 赋值
qi = "hello world"

# 嵌套
num = [qi, 1, 2, 3, 4, 5, 6, "hello", [1, 2, [1, 2], 3]]

# 通过索引取值
# 顺序取 0, 1, 2 ...
# 倒序取 -1, -2, -3 ...
# hello
print(num[7])  # 或 print([qi, 1, 2, 3, 4, 5, 6, "hello", [1, 2, [1, 2], 3]][7])

# 赋值
num_1 = "hello world"

# 打印结果
# o
print(num_1[4])

# 打印结果
# r
print(num_1[-3])


# 赋值
num_2 = [1, 2, 3, [4, 5, 6, [7, 8, 9]]]

# 连续索引

# 取元素 8
num_3 = num_2[-1][3][1]

# 打印
# 8
print(num_3)

2. 切片

# 切片 变量名[开始索引: 结束索引:步长]
# 左闭右开 开始索引能取到，结束索引取不到


# 赋值
num_2 = ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

# 取全部
# ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
print(num_2[0:10:])  # 也可以 num_2[0::1]或num_2[::1]或num_2[::]或num_2[:]

# 取部分
# ['l', 'l', 'o']
print(num_2[2:5:1])

# 步长数值大小决定取值距离
# 步长数值的正负决定取值方向

# 取值距离 = 步长 - 1
# ['h', 'l', 'o', 'o', 'l']
print(num_2[::3])

# 当步长为-1时 倒序排列
# ['d', 'l', 'r', 'o', 'w', 'o', 'l', 'l', 'e', 'h']
print(num_2[::-1])