• 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

        • 1

      • 以两个下划线开头的变量约定是类的私有变量（注意：不能同时以两个下划线结尾）

        • 在 class 类的内部，带双下划线的类变量、实例变量、方法具有正常访问权限

        • 在继承结构中，带双下划线的基类的类变量和实例变量不能被子类直接访问。

        • 在实例中，带双下划线的类变量、实例变量、方法不能被直接访问。

          但有办法间接访问：对象名._className__func

            class Student:
    __grade = 0
  
stu = Student()
  print(stu._Student__grade)

          • 1
          • 2
          • 3
          • 4
          • 5

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

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

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

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

        在这里插入图片描述

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

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

        • 1
        • 2

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

        在这里插入图片描述


    赋值语句

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

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

    • 简单赋值：用于为一个变量赋值（详见 赋值运算符）

    • 序列赋值：可以一次性为多个变量赋值（详见 赋值运算符）

      在序列赋值语句中，等号左侧是元组或列表表示的多个变量，等号右侧是元组、列表或字符串等序列表示的数据。Python 按先后顺序依次将数据赋值给变量。

    • 多目标赋值：指用连续的多个等号将同一个数据赋值给多个变量（详见 赋值运算符）

    • 增强赋值：指将运算符与赋值相结合的赋值语句（详见 复合赋值运算符）

      示例代码：

      a = 5
a += 10
print(a)
# 输出：15

      • 1
      • 2
      • 3
      • 4

    数据类型

    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))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    显式类型转换

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

    整型和字符串类型运算结果会报错，输出 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))

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

      注意：浮点数转换为整数是向下取整，不是四舍五入

    • float(x) ：用于将整数和字符串转换成浮点数

      # 语法：
float([x])
# x -- 整数或字符串

# 实例：
str1 = "3.14"
str2 = 2
f1 = float(str1)
f2 = float(str2)
print(f1, f2)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10

    • 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"))

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    • str(x) ：将对象转化为适于人阅读的形式，返回一个对象的 string 格式

      # 语法：
str(object='')
# 

# 实例：
s1 = 'python'
s2 = {'python': 'python.com', 'google': 'google.com'}
print(str(s1), str(s2))

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    • repr(x) ：将对象转化为供解释器读取的形式，返回一个对象的 string 格式

      # 语法：
repr(object)

# 实例：
s1 = 'python'
s2 = {'python': 'python.com', 'google': 'google.com'}
print(repr(s1), repr(s2))

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

    • 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)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12

    • tuple(s) ：将可迭代系列（字符串，列表，字典，集合）转换为元组

      # 语法：
tuple(iterable)

# 实例：
l1 = ['python', 'ruby', 'golang', 'java']
t1 = tuple(l1)
print(t1)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

    • list(s) ：将元组或字符串转换为列表

      元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中

      # 语法：
list( seq )
# seq -- 要转换为列表的元组或字符串

# 实例：
t1 = (123, 'Google', 'Python', 'Taobao')
l1 = list(t1)
s1 = "hello"
l2 = list(s1)
print(l1, l2)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10

    • set(s) ：创建一个无序不重复元素集，可进行关系测试，删除重复数据（返回新的集合对象）

      # 语法：
set([iterable])，

# 实例：
l1 = ['a', 'b', 'b', 'c', 'c', 'c']
s1 = set(l1)
print(s1)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

    • 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)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    • 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)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    • frozenset(s) ：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

      返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

      # 语法：
frozenset([iterable])
# iterable -- 可迭代的对象，比如列表、字典、元组等等。

# 实例：
f1 = frozenset(range(10))
f2 = frozenset(['h','e','l','l','0'])
print(f1)
print(f2)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    • 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))       # 十进制

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

    • 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)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    • hex(x) ：用于将 10 进制整数转换成 16 进制，以字符串形式表示。

      # 语法：hex(x)

# 实例：
print(hex(255), hex(-42), hex(1), hex(12), type(hex(12)))

      • 1
      • 2
      • 3
      • 4

    • oct(x) ：将一个整数转换成 8 进制字符串。Python3.x 版本的 8 进制以 0o 作为前缀表示

      # 语法：oct(x)
# x -- 整数

# 实例：
o1 = oct(10)
o2 = oct(20)
o3 = oct(15)
print(o1, o2, o3)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

  • 相关阅读:
    【算法挨揍日记】day29——139. 单词拆分、467. 环绕字符串中唯一的子字符串
    iOS开发-自定义下拉刷新控件PullDownRefreshView
    设计模式---原型模式
    字节跳动岗位薪酬体系曝光，看完感叹：不服不行
    Python xlwings打开excel表格进行最大化
    信息学奥赛一本通：2044：【例5.12】回文字串
    540、RabbitMQ详细入门教程系列 -【100%消息投递消费（二）】 2022.08.31
    代码随想录刷题|完全背包理论基础 LeetCode 518. 零钱兑换II 377. 组合总和 Ⅳ
    别再自己瞎写工具类了，Spring Boot 内置工具类应有尽有， 建议收藏
    关于#网络#的问题：采用CRC方法进行校验，求数据冗余码FCS（相关搜索：计算机网络）
  • 原文地址：https://blog.csdn.net/footless_bird/article/details/132807950