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

变量

变量的定义

• 基本语法：变量名 = 值

• 变量名是给对象贴一个用于访问的标签，给对象绑定名字的过程也称为赋值，赋值符号 “=”

  变量名自定义，要满足标识符命名规则。

• 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 = 0stu = Student()print(stu._Student__grade)
      

  • 首尾各有一个下划线的变量名通常为系统变量。例如，_name_、_doc_

  • 首尾各有两个下划线的变量名是系统定义名字，这些方法会在特定的条件下被触发执行，也可手动调用

    每个 Python 脚本在运行时都有一个 __name__ 属性。

    • 如果脚本作为模块被导入，则其 __name__ 属性的值被自动设置为模块名（.py 文件的名称）
    • 如果脚本独立运行，则其 __name__ 属性值被自动设置为 __main__

    

    利用 __name__ 属性即可控制 Python 程序的运行方式。例如，编写一个包含大量可被其他程序利用的函数的模块，而不希望该模块可以直接运行，则可以在程序文件中添加以下代码：

    if __name__ == '__main__':    print('Please use me as a module.')
    

    这样一来，程序直接执行时将会得到提示“Please use me as a module.”，而使用 import 语句将其作为模块导入后可以使用其中的类、方法、常量或其他成员。

    

赋值语句

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

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之数据类型转换

隐式类型转换

隐式类型转换 - 自动完成

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

num_int = 123
num_flo = 1.23num_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)