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 = 0
stu = 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.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)