Python 变量的定义和数据类型的转换

客官°小女子只卖身不卖艺 2023-10-15 20:38 62阅读 0赞

## 变量 ##

### 变量的定义 ###

*  基本语法：`变量名 = 值`
 *  变量名是给对象贴一个用于访问的标签，给对象绑定名字的过程也称为赋值，赋值符号 “=”
    
    变量名自定义，要满足标识符命名规则。
 *  Python中，**不需要事先声明变量名及其类型**，直接赋值即可创建各种类型的对象变量。
    
    变量在第一次赋值时被创建，再次出现时可直接使用。
 *  Python 属于 **强类型编程语言**
    
    虽然不需要在使用之前显式的声明变量及其类型，但 Python 是一种不折不扣的强类型语言，Python 解释器会根据赋值运算符右侧表达式的来自动推断变量类型，在变量被创建后，除非显式修改变量类型或删除变量，否则变量将一直保持之前的类型。
 *  Python 是一种动态类型语言，变量的类型是可以 随时变化的。
 *  Python 采用的是 基于值的内存管理方式 ，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一块内存地址。
    
    赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。
    
    Python 中的变量并不直接存储，而是存储了值的内存地址或者引用。这也是变量类型随时可以改变的原因。
 *  Python 具有自动内存管理功能，对于没有任何变量指向的值，Python 自动将其删除。
    
    Python 会跟踪所有的值，并自动删除不再有变量指向的值。因此，Python 程序员一般情况下不需要太多考虑内存管理的问题。
    
    不过显式使用 del 命令删除不需要的值或显式关闭不再需要访问的资源，仍是一个好的习惯，同时也是一个优秀程序员的基本素养之一。
 *  Python 字符串驻留机制：
    
     *  字符串长度为 0 或 1 时，默认采用驻留机制；
     *  字符串长度大于 1 时，且 字符串中只包含大小写字母、数字、下划线（ \_ ）时，采用驻留机制；
     *  对于 \[-5,256\]之间的整数数字，Python默认驻留 ；
     *  字符串 只在编译时进行驻留，而非运行时 。Python 是解释型语言，但是事实上，它的解释器也可以是理解为是一种编译器，它负责将 Python 代码翻译成字节码，也就是 .pyc 文件；
     *  用乘法得到的字符串
        
         *  如果结果长度 <=20 且字符串只包含数字、字母大小写、下划线，支持驻留。
         *  长度 >20，不支持驻留。
        
        这样的设计目的是为了保护 .pcy 文件不会被错误代码搞的过大。

### 变量（标识符）命名规则 ###

*  变量名的首字符必须是**下划线、英文字母或其他 Unicode 字符**，变量名可包含下划线、英文字母、数字或其他 Unicode 字符。
    
    例如，\_abc、r\_1 是合法的变量名，而 2abc、price$ 则不合法。
    
    注：
    
     *  **不能数字开头**
     *  以下划线开头的变量在 Python 中有特殊含义，普通变量一般不使用下划线开头，**并不是不能用下划线开头**
 *  **变量名中不能有空格或标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等）**
 *  **变量名严格区分大小写**。例如，Abc 和 abc 是两个不同的变量
 *  **不能使用 Python 保留字或关键字作变量名**
    
    注：
    
     *  保留字或关键字可以是变量名的一部分
     *  保留字和关键字在 Python 中具有特殊意义，将保留字或关键字作为变量名会导致语法错误
     *  可以导入 keyword 模块后使用 `print(keyword.kwlist)` 函数查看所有 Python 关键字
 *  **不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名**，这将会改变其类型和含义，可以通过 `dir(builtins)` 函数查看所有内置模块、类型和函数
 *  **变量的命名习惯**：
    
     *  大驼峰：即每个单词首字母都大写，例如： MyName
     *  小驼峰：第二个（含）以后的单词首字母大写，例如： myName
     *  下划线：例如： my\_name
 *  除了命名规则外，Python 还有一些**变量使用惯例**：
    
     *  **以一个下划线开头的变量约定用于指定模块的私有变量或私有函数（private）**
        
        在模块外或类外不可用使用，不能用导入模块所有变量（`from module import *`）形式导入，但可以使用单独导入模块变量（`from module import _变量名`）形式导入
        
            from Person import _abc
     *  **以两个下划线开头的变量约定是类的私有变量**（注意：不能同时以两个下划线结尾）
        
         *  在 class 类的内部，带双下划线的类变量、实例变量、方法具有正常访问权限
         *  在继承结构中，带双下划线的基类的类变量和实例变量不能被子类直接访问。
         *  在实例中，带双下划线的类变量、实例变量、方法不能被直接访问。
            
            但有办法间接访问：`对象名._className__func`
            
                class Student:
                    __grade = 0
                  
                stu = Student()
                  print(stu._Student__grade)
     *  **首尾各有一个下划线的变量名通常为系统变量**。例如，`_name_`、`_doc_`
     *  **首尾各有两个下划线的变量名是系统定义名字，这些方法会在特定的条件下被触发执行，也可手动调用**
        
        每个 Python 脚本在运行时都有一个 `__name__` 属性。
        
         *  如果脚本作为模块被导入，则其 `__name__` 属性的值被自动设置为模块名（.py 文件的名称）
         *  如果脚本独立运行，则其 `__name__` 属性值被自动设置为 `__main__`
        
        ![在这里插入图片描述][5c5f48d92ff7445b9753dcd2e6c2053a.png_pic_center]
        
        利用 **`__name__`** 属性即可**控制 Python 程序的运行方式**。例如，编写一个包含大量可被其他程序利用的函数的模块，而不希望该模块可以直接运行，则可以在程序文件中添加以下代码：
        
            if __name__ == '__main__':    
            	print('Please use me as a module.')
        
        这样一来，程序直接执行时将会得到提示“Please use me as a module.”，而使用 import 语句将其作为模块导入后可以使用其中的类、方法、常量或其他成员。
        
        ![在这里插入图片描述][6d94833286a948409e95c3753692e247.png_pic_center]

### 赋值语句 ###

赋值语句用于将数据赋值给变量。

Python 支持多种格式的赋值语句：简单赋值、序列赋值、多目标赋值和增强赋值等：

*  **简单赋值**：用于为一个变量赋值（详见 赋值运算符）
 *  **序列赋值**：可以一次性为多个变量赋值（详见 赋值运算符）
    
    在序列赋值语句中，等号左侧是元组或列表表示的多个变量，等号右侧是元组、列表或字符串等序列表示的数据。Python 按先后顺序依次将数据赋值给变量。
 *  **多目标赋值**：指用连续的多个等号将同一个数据赋值给多个变量（详见 赋值运算符）
 *  **增强赋值**：指将运算符与赋值相结合的赋值语句（详见 复合赋值运算符）
    
    示例代码：
    
        a = 5
        a += 10
        print(a)
        # 输出：15

### 数据类型 ###

Python 的六大数据类型如下所示：

*  **数字（Numbers）**：int（整型），long（长整型），complex（复数），float（浮点型），bool（布尔型）;
    
     *  **整数型：**
        
         *  **十进制整数**：如，0、-1、9、123
         *  **十六进制整数**：需要 16 个数字 0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f 来表示整数，**必须以 0x 开头**，如 0x10、0xfa、0xabcdef
         *  **八进制整数**：只需要 8 个数字 0、1、2、3、4、5、6、7 来表示整数，**必须以 0o 开头**，如 0o35、0o11
         *  **二进制整数**：只需要 2 个数字 0、1 来表示整数，**必须以 0b 开头**，如，0b101、0b100
     *  **浮点数：**
        
         *  小数点形式：0.0，-1.34，-99.
         *  科学计数法：23e4，78e-4，3.5E7
     *  **复数：**
        
        复数由实数部分和虚数部分构成，Python 语言中通常使用 a+bj 或者 complex(a,b) 表示，其中 a 表示复数的实部，b 表示复数的虚部，并且复数的实部 a 和虚部 b 都是浮点型。
 *  **字符串（String）**：“Python”，‘Python’
 *  **列表（List）**：\[1, 2, 3, 4\]，\[5,6,7, \[8,9\], 10\]
 *  **字典（Dictionary，缩写 dict）**：\{1: “study”, 2: “Python”\}
 *  **元组（Tuple）**：(1, “shuai”, 2)
 *  **集合（Set）**：\{‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’\}

注：

*  除数字类型外其他类型，均可以通过 **变量名\[索引\]** 形式获取 索引 对应的值

### 数据类型转换 ###

参考：[python之数据类型转换][python]

#### 隐式类型转换 ####

隐式类型转换 - 自动完成

对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失

num_int = 123
    num_flo = 1.23
    
    num_new = num_int + num_flo
    print("Value of num_new:", num_new)
    
    print("datatype of num_int:", type(num_int))
    print("datatype of num_flo:", type(num_flo))
    print("datatype of num_new:", type(num_new))

#### 显式类型转换 ####

显式类型转换 - 需要使用类型函数来转换

整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换，可以使用 int()、float()、str() 等预定义函数来执行显式类型转换。

**数据类型之间的转换内置函数**：

*  **int(x \[,base\])** ：将 x 转换为一个整数
    
        # 语法：
        class int(x, base=10)
        # base为进制数，默认十进制，若 x 不符合 base 规则，则报错
        
        # 实例：
        print(int(3.6))
        print(int("1001", 2))
        print(int("0xa", 16))
    
    **注意：浮点数转换为整数是向下取整，不是四舍五入**
 *  **float(x)** ：用于将整数和字符串转换成浮点数
    
        # 语法：
        float([x])
        # x -- 整数或字符串
        
        # 实例：
        str1 = "3.14"
        str2 = 2
        f1 = float(str1)
        f2 = float(str2)
        print(f1, f2)
 *  **bool(x)** ：将参数转换为布尔值
    
    参数是“0”或省略，返回 False，否则，返回 True
    
        # 实例：
        print(bool())
        print(bool(0))
        print(bool(1))
        print(bool(1.2))
        print(bool(-1))
        print(bool(-1.1))
        print(bool("a"))
 *  **str(x)** ：将对象转化为适于人阅读的形式，返回一个对象的 string 格式
    
        # 语法：
        str(object='')
        # 
        
        # 实例：
        s1 = 'python'
        s2 = {
              'python': 'python.com', 'google': 'google.com'}
        print(str(s1), str(s2))
 *  **repr(x)** ：将对象转化为供解释器读取的形式，返回一个对象的 string 格式
    
        # 语法：
        repr(object)
        
        # 实例：
        s1 = 'python'
        s2 = {
              'python': 'python.com', 'google': 'google.com'}
        print(repr(s1), repr(s2))
 *  **eval(str)** ：用来执行一个字符串表达式，并返回表达式的值
    
        # 语法：
        eval(expression[, globals[, locals]])
        # expression -- 表达式
        # globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
        # locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
        
        # 实例：
        x,y = 1,2
        e1 = eval('3 * x')
        e2 = eval('pow(2,3)')
        e3 = eval('y+10')
        print(e1, e2, e3)
 *  **tuple(s)** ：将可迭代系列（字符串，列表，字典，集合）转换为元组
    
        # 语法：
        tuple(iterable)
        
        # 实例：
        l1 = ['python', 'ruby', 'golang', 'java']
        t1 = tuple(l1)
        print(t1)
 *  **list(s)** ：将元组或字符串转换为列表
    
    元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中
    
        # 语法：
        list( seq )
        # seq -- 要转换为列表的元组或字符串
        
        # 实例：
        t1 = (123, 'Google', 'Python', 'Taobao')
        l1 = list(t1)
        s1 = "hello"
        l2 = list(s1)
        print(l1, l2)
 *  **set(s)** ：创建一个无序不重复元素集，可进行关系测试，删除重复数据（返回新的集合对象）
    
        # 语法：
        set([iterable])，
        
        # 实例：
        l1 = ['a', 'b', 'b', 'c', 'c', 'c']
        s1 = set(l1)
        print(s1)
 *  **dict(d)** ：创建一个字典
    
    d 必须是一个 (key, value) 元组序列
    
        # 语法：
        dict(**kwarg)
        dict(mapping, **kwarg)
        dict(iterable, **kwarg),
        # **kwargs -- 关键字
        # mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系
        # iterable -- 可迭代对象
        
        # 实例：
        # 传入关键字
        d1 = dict(a='a', b='b', t='t')	
        # 映射函数方式来构造字典
        d2 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
        # # 可迭代对象方式来构造字典
        d3 = dict([('one', 1), ('two', 2), ('three', 3)]) 
        print(d1)
        print(d2)
        print(d3)
 *  **complex(real \[,imag\])** ：创建一个值为 real + imag \* j 的复数或者转化一个字符串或数为复数
    
    如果第一个参数为字符串，则不需要指定第二个参数。。
    
        # 语法：
        complex([real[, imag]])
        # real -- int, long, float或字符串
        # imag -- int, long, float
        
        # 实例：
        c1 = complex(1, 2)
        c2 = complex(3)
        print(c1,c2)
 *  **frozenset(s)** ：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
    
    返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
    
        # 语法：
        frozenset([iterable])
        # iterable -- 可迭代的对象，比如列表、字典、元组等等。
        
        # 实例：
        f1 = frozenset(range(10))
        f2 = frozenset(['h','e','l','l','0'])
        print(f1)
        print(f2)
 *  **chr(x)** ：用一个范围在 range（256）内的（就是0～255）整数作参数，返回值是当前整数对应的 ASCII 字符。
    
        # 语法：
        chr(i)
        # i -- 可以是10进制也可以是16进制的形式的数字
        
        # 实例：
        print(chr(0x30), chr(0x31), chr(0x61))   # 十六进制
        print(chr(48), chr(49), chr(97))       # 十进制
 *  **ord(x)** ： chr() 函数（对于8位的 ASCII 字符串）或 unichr() 函数（对于Unicode对象）的配对函数
    
    它以一个字符（长度为1的字符串）作为参数，返回对应的 十进制 ASCII 数值，或者 Unicode 数值
    
    如果所给的 Unicode 字符超出了 Python 定义范围，则会引发一个 TypeError 的异常
    
        # 语法：
        ord(c)
        # c -- 字符
        
        # 实例：
        o1 = ord('a')
        o2 = ord('b')
        o3 = ord('c')
        print(o1,o2,o3)
 *  **hex(x)** ：用于将 10 进制整数转换成 16 进制，以字符串形式表示。
    
        # 语法：hex(x)
        
        # 实例：
        print(hex(255), hex(-42), hex(1), hex(12), type(hex(12)))
 *  **oct(x)** ：将一个整数转换成 8 进制字符串。Python3.x 版本的 8 进制以 0o 作为前缀表示
    
        # 语法：oct(x)
        # x -- 整数
        
        # 实例：
        o1 = oct(10)
        o2 = oct(20)
        o3 = oct(15)
        print(o1, o2, o3)

[5c5f48d92ff7445b9753dcd2e6c2053a.png_pic_center]: https://img-blog.csdnimg.cn/5c5f48d92ff7445b9753dcd2e6c2053a.png#pic_center
[6d94833286a948409e95c3753692e247.png_pic_center]: https://img-blog.csdnimg.cn/6d94833286a948409e95c3753692e247.png#pic_center
[python]: https://www.cnblogs.com/mrwhite2020/p/16614549.html