Python变量和数据类型

1.1 变量

在Python中，变量是一个存储信息的容器，用于保持数据值。Python是动态类型语言，这意味着在创建变量时不需要声明数据类型；与之相对的是静态语言，在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言。动态类型语言的类型会在赋值时自动确定，同时变量的类型也可以在其生命周期中改变。

1.1.1 变量的创建和变量的命名规则

在Python中，变量在首次赋值时自动确定：

x = 5
name = "Alice"

这里，x是一个整数类型的变量，name是一个字符串类型的变量。

Python中的变量可以在运行时改变类型(动态性)：

x = 4       # x 是一个整数类型
x = "Sally" # x 现在是一个字符串类型

变量名必须遵循一些 规则：

• 必须以字母（a-z, A-Z）或下划线（_）开头。
• 其余部分可以包含字母，数字（0-9）和下划线。
• 变量名是大小写敏感的，这意味着Name和name是两个不同的变量。
• 不允许使用Python关键字作为变量名。
• 应避免使用Python内置函数和类名作为变量名，以免造成冲突。

PS：后两条规则不需要记忆，因为在IDE中都会显示不同的颜色。

# 合法的变量名
my_var = "Python"
_var = 23
myVar = "Python"
MYVAR = "Python"
myvar2 = "Python"

# 非法的变量名
2myvar = "Python" # 不能以数字开始
my-var = "Python" # 不能包含减号
my var = "Python" # 不能包含空格

1.1.1.1 Python 关键字

关键字是保留的单词，用于定义语言的结构和布局。在Python中，关键字不能用作变量名、函数名或任何其他标识符名称。截至Python 3.10版本，以下是所有的Python关键字：

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

这些关键字的含义和用法是固定的，每个关键字在Python语言中都有特定的功能。

1.1.1.2 Python 内置函数

Python 内置函数是随Python解释器提供的一组函数，无需导入任何模块即可直接使用。这些函数可以简化标准任务，并且是任何环境下Python的核心部分。截至Python 3.10版本，以下是一些常用的内置函数：

• abs(): 返回一个数的绝对值。
• all(): 如果可迭代对象的所有元素都为真（或可迭代对象为空），则返回True。
• any(): 如果可迭代对象的任一元素为真，则返回True。
• bin(): 将一个整数转换为一个二进制字符串。
• bool(): 将一个值转换为布尔值。
• callable(): 检查对象是否可调用。
• chr(): 返回对应于整数 i 的Unicode字符。
• dict(): 创建一个新字典。
• dir(): 尝试返回对象的属性列表。
• divmod(): 返回一对数的商和余数。
• enumerate(): 返回一个枚举对象。
• eval(): 解析并执行表达式。
• filter(): 使用过滤器函数过滤可迭代对象。
• getattr(): 获取对象的属性值。
• globals(): 返回当前全局符号表的字典。
• hasattr(): 检查对象是否有给定属性。
• hash(): 返回对象的哈希值。
• help(): 调用内置的帮助系统。
• hex(): 将一个整数转换为一个十六进制字符串。
• id(): 返回对象的唯一标识符。
• input(): 允许用户输入。
• int(): 将一个值转换为整数。
• isinstance(): 检查对象是否是类的实例。
• issubclass(): 检查一个类是否是另一个类的子类。
• iter(): 获取迭代器。
• len(): 返回对象的长度。
• list(): 创建一个新列表。
• map(): 将函数应用于可迭代对象的每个项。
• max(): 返回最大值。
• min(): 返回最小值。
• next(): 返回迭代器的下一个元素。
• object(): 返回一个新的无特征对象。
• oct(): 将一个整数转换为八进制字符串。
• open(): 打开文件并返回对应的文件对象。
• ord(): 返回一个字符的Unicode编码。
• pow(): 返回x的y次方。
• print(): 打印给定的对象。
• range(): 生成一个数值序列。
• repr(): 返回对象的字符串表示。
• reversed(): 返回一个反向的迭代器。
• round(): 四舍五入到给定的精度。
• set(): 创建一个新集合。
• setattr(): 设置对象的属性值。
• slice(): 返回一个切片对象。
• sorted(): 返回已排序的列表。
• str(): 创建一个新字符串对象。
• sum(): 对一个序列进行求和。
• tuple(): 创建一个新元组。
• type(): 返回对象的类型。
• vars(): 返回对象的__dict__属性。
• zip(): 创建一个聚合了来自每个可迭代对象的元素的迭代器。

1.1.1.3 Python 类名

在Python中，类名指内置的类名和用户自定义类的名称。以下是一些常见的内置类名：

• int: 表示整数类型。
• float: 表示浮点数类型。
• complex: 表示复数类型。
• list: 表示列表类型。
• tuple: 表示元组类型。
• dict: 表示字典类型。
• set: 表示集合类型。
• frozenset: 表示不可变集合类型。
• str: 表示字符串类型。
• bytes: 表示字节序列。
• bytearray: 表示可变的字节序列。
• memoryview: 表示内存视图对象。
• object: 所有类的基类。
• type: 类的类型；它本身也是一个类。
• bool: 表示布尔类型。
• enumerate: 枚举类型，用于返回枚举对象。
• filter: 过滤器类型，用于构造迭代器。
• map: 映射类型，用于构造迭代器。
• range: 范围类型，用于表示不可变的序列数。
• slice: 切片类型，用于表示由 slice() 构造的切片对象。
• Exception: 所有异常的基类。

这些类名在Python中被广泛使用，是创建和操作相应数据类型对象的基础。

创建自定义类时，建议遵循大驼峰命名约定（CamelCase），即每个单词的首字母都大写，例如 MyClass。这有助于区分内置类名和用户自定义的类名。

1.1.2 变量的赋值和变量的作用域

变量可以通过=符号进行赋值，也可以使用多重赋值或链式赋值：

# 多重赋值
a, b, c = 5, 3.2, "Hello"

# 链式赋值
a = b = c = "Python"

变量的作用域决定了在哪里可以访问这个变量。在Python中，有以下几种作用域：

• 局部作用域（Local）：在函数或者类的方法中定义的变量，只能在该函数内部访问。
• 全局作用域（Global）：在函数之外定义的变量，可以在整个程序内访问。
• 内置作用域（Built-in）：Python的内置名称空间。

def my_function():
    local_var = 5  # 局部变量
    print(local_var)

global_var = 10  # 全局变量
my_function()
print(global_var)

这一块内容在函数章节需要被深刻理解。

1.1.3 可变对象和不可变对象

在Python中，变量实际上是对对象的引用。当创建一个变量时，就创建了一个对象，并将变量指向它。例如：

x = [1, 2, 3]

这里，x是指向列表对象[1, 2, 3]的引用。

• 不可变类型（immutable）： 一旦创建，其内容不能改变。字符串、整数、浮点数和元组都是不可变的。
• 可变类型（mutable）： 对象的内容可以改变。列表、字典和集合都是可变的。
  在Python中，有些对象是可变的（例如列表、字典、集合），而有些对象是不可变的（例如整数、浮点数、字符串、元组）。不可变对象一旦创建，其内容不能改变。

a = 1000
print(id(a))

a += 1
print(id(a))

首先写a = 1000，会先创建一个int 1000 的物件，并将a 指向int 1000 物件的位置，可以用id(a) 来看到他的记忆体位置是第一个。

再来修改a += 1时，会产生新的int 1001，并将a 指向这个新产生的物件，用id(a) 来看到他的记忆体位置变成第二个。

从 Code 中可以看出，当修改a 时，并不会去修改1000 这个物件的值，而是会重新创造出一个新的物件，称之为Immutable objects。

详细内容请见Python 基礎教學：什麼是 Immutable & Mutable objects

1.1.4 删除变量

可以使用del语句来删除变量，这会从名称空间中移除变量的名字。

x = "hello"
del x

1.1.5 变量类型和数据类型的关系

Python中的变量不仅可以是基本数据类型，如整数、浮点数、布尔值和字符串，还可以是数据结构，如列表、元组、字典和集合等。

• 整数（int）： 不带小数的数字。
• 浮点数（float）： 带小数的数字。
• 字符串（str）： 文本数据，用单引号或双引号括起来。
• 布尔值（bool）： 只有True或False的逻辑值。
• 列表（list）： 有序的元素集合，元素可以是不同类型。
• 字典（dict）： 键值对集合。
• 元组（tuple）： 不可变的有序元素集合。
• 集合（set）： 无序且元素唯一的集合。

# 基本数据类型
num = 10        # 整数
price = 10.99   # 浮点数
flag = True     # 布尔值
name = "Alice"  # 字符串

# 数据结构
numbers = [1, 2, 3]            # 列表
coordinates = (10.0, 20.0)     # 元组
person = {"name": "Alice", "age": 25} # 字典
unique_numbers = {1, 2, 3}     # 集合

1.2 数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。¹ 在Python中，能够直接处理的数据类型有三类：字符串（string）、数字（number）、布尔值（boolean）。

内置函数	转换对象
type()	查询类别
bool()	布尔值
complex()	复数
float()	浮点数
int()	整数
str()	字符串

1.2.1 数值（number）

主要用于各种数学运算。int 用于整数运算，float 用于需要小数的运算，而 complex 用于复数学领域。

类型	描述	示例
整型int	正或负的整数，无小数点	10
长整型long	无限大小的整数	6321L
浮点数float	整数和小数构成	2.23, 2.5e2
复数complex	实数和虚数构成	2+3j

a = 5
b = 5.10
c = 1+2j
print('打印数字以及对应的数据类型:',a,type(a))
print('打印数字以及对应的数据类型:',b,type(b))
print('打印数字以及对应的数据类型:',c,type(c))
# Another way to create a complex number
c = complex(1, 2)
print("c: ", c)
print("再次打印c以及对应的数据类型:", type(c))

对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。¹

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。¹

1.2.2 字符串（string）

str: 字符串类型，用于表示文本数据。字符串是不可变的序列类型。

字符串或串(String)是用于处理文本 的数据类型：

python中一般用单引号' '，双引号" "，三单引号''' '''，三双引号""" """来标识字符串，三引号用于多行文本。

d = 'Hi'
print('打印对应的数据类型:',d,type(d))
rand = "hello kitty"
print(rand)
fruits = '🍌','🍒','🍐','🍈','🍇','🍓','🍉'
print(fruits)

1.2.2.1 转义字符（Escape Characters）

转义字符	描述
\n	end the current line of text and start a new one （换行）
\t	skip to the next “tab stop” in the text （制表符）
’	do not interpret the ’ as a string delimiter
"	do not interpret the " as a string delimiter
\	put a backslash character into the string

t = '*\t*\n**\t**\n***\t***\n'
print(t)

1.2.2.2 原始字符串(Raw Strings)

在Python中，前缀 r 表示原始字符串（raw string）。这意味着在这个字符串中，反斜杠 \ 是没有特殊含义的，它们会被直接按字面意思处理，而不会被解释为转义字符。这在处理包含很多反斜杠的字符串时非常有用，比如文件路径。

print('C:\some\name') # here \n means newline!
print(r'C:\some\name') # note the r before the quote

1.2.2.3 格式化字符串文字(F-Strings)

f-string提供了一种非常快速且可读性强的方式来嵌入Python表达式到字符串常量中。

1. 在大括号 {} 中，可以直接写入Python表达式，它们会在运行时被计算和替换。
2. 花括号中的表达式可以有一个可选的格式说明符，也可以指定填充参数来填充空白。
3. 格式化输出特定数字，可以指定四舍五入的单位。
4. 还可以输出一致长度使得数据列表。

name = "World"
print(f"Hello, {name}!")

print(f"Let's test string alignment and minimum width|{name:<20}|")
print(f"Let's test string alignment and minimum width|{name:^20}|")
print(f"Let's test string alignment and minimum width|{name:>20}|")
print(f"Let's test string alignment and minimum width|{name:0>20}|")

pi = 3.14159265
print(f'Pi is equal to {pi:.4f}')

for i in range(5, 16):
    print(f'{i:03}')

1.2.2.4 字符操作（String Operations）

Syntax	Example	Output
Concatenation	“hello”+“world”	helloworld
Indexing (from beginning)	“helloworld”[0]	h
Indexing (from end)	“helloworld”[-1]	d
Slicing	“helloworld”[2:4]	ll
String length	len(“helloworld”)	10
Membership test	“o” in “helloworld”	True
Comparison	“helloworld”<“hello”	False
Replication	“hello”*2	hellohello

string = 'hello World!'
print('原字符串(注意空格也占据一个字符)：         ',string)
print('字符串的第一个元素(注意索引为0)：          ',string[0])
print('字符串的倒数第一个元素(支持负索引)：       ',string[-1])
print('字符串索引2至5(注意索引的话左包含右不包含)：',string[2:6])
print('字符串索引2至最后：                       ',string[2:])
print('字符串索引-2至最后：                      ',string[-2:])
print('字符串重复2遍：',string * 2)
print('字符串的拼接：',string + ' and Wind welcomes everyone!')
print('字符串的比较：',string < ' and Wind welcomes everyone!')

1.2.2.5 字符串相关函数

方法	功能
capitalize()	大写句首的字母
upper()	将小写字母变成大写字母
lower()	将大写字母变成小写字母
split()	把句子分成单词
find(x)	找到给定词x在句中的索引，找不到返回-1
replace(x,y)	把句中x替代成y
strip(x)	删除句首或句尾含x的部分

print('将首字母变成大写:','hello word !'.capitalize())
print('将小写字母变成大写字母:','hello word !'.upper())
print('将大写字母变成小写字母:','HELLO WORD !'.lower())
print('把句子分成单词:','hello word !'.split())
print('把句中x替代成y:','hello word !'.replace('word','python'))

1.2.3 布尔值（boolean）和空值（None）

• bool: 用于表示逻辑值。可以有两个值：True 或 False。
• NoneType: 它有一个单一的值 None。它通常用来表示缺少值，或者当没有任何东西返回时。

布尔值只有 True和False两个值，布尔值在数字运算中， True代表1，False代表0。

1. 关系运算和逻辑运算返回的就是布尔值，如 1>2 等。
2. 布尔值可以用and、or和not运算。
   • and运算是与运算，只有所有都为True，and运算结果才是True；
   • or运算是或运算，只要其中有一个为True，or运算结果就是True；
   • not运算是非运算，它是一个单目运算符，把True变成False，False变成True。

print(type(True))
print(True + 1)
print(1 > 2)
print(True and False and True)
print(5 > 3 and 3 > 1)
print(True or False)
age = 14
if age >= 18: #<------布尔值判断
   print('adult(成年人)')
else:
   print('teenager(青年人)')

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

e = True
f = None
print("The type of variable e is", type(e))
print("The type of variable f is", type(f))

1.3 控制台输出（print）

在Python中，print() 函数非常灵活，几乎可以打印任何可以被字符串表示的对象，包括字符串本身、数值、对象等等。print() 的基本使用非常简单，但它也提供了许多参数来定制输出格式。

以下是 print() 函数的一些基本特性和使用方式：

1.3.1 基本用法

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• *objects：这是位置参数，可以是任意数量的对象，这些对象将依次被转换为字符串并打印出来。
• sep=' '：字符串之间的分隔符，默认是空格。
• end='\n'：字符串末尾的结束符，默认是换行符。
• file=sys.stdout：输出流的目标，默认是标准输出。
• flush=False：立即把内容输出到流文件，不进行缓存。

print(value1, value2, value3, ...)

• value1, value2, value3, ...：可以指定一个或多个值，这些值将被依次打印出来。

1.3.2 关键参数

• sep：指定输出时各值之间的分隔符，默认为一个空格。

  print('Apple', 'Banana', 'Cherry', sep=', ')
  # 输出：Apple, Banana, Cherry
  

  print("Python", "is", "NB", sep="-")
  # 输出：Python-is-NB
  

• end：指定打印完所有值后的结束符，默认为换行符 (\n)。

  print('Hello', end=' ')
  print('World')
  # 输出：Hello World
  

  print("Hello, World!", end=" <3\n")
  # 输出：Hello, World! <3
  # 并开始新的一行
  

• file：标准输出是 print() 函数的默认目标，但是可以通过 file 参数将输出重定向到文件或者其他类文件对象（任何有 write() 方法的对象）。

  with open('file.txt', 'w') as file:
      print('Hello, file!', file=file)
  # 将输出写入到 'file.txt' 文件中
  

  with open('output.txt', 'w') as f:
     print('Save this to a file', file=f)
  

• flush：布尔值，指定是否强制将输出刷新到流，默认为 False。如果为 True，则会将输出立即推送到文件或者终端，有助于实时观察输出结果。

1.3.3 高级字符串格式化

print() 函数通常与字符串格式化方法一起使用，如 % 操作符、str.format() 方法或者 f-strings。

# 使用 % 操作符
name = 'World'
print('Hello, %s!' % name)
# 输出：Hello, World!

# 使用 str.format() 方法
print('Hello, {}!'.format(name))
# 输出：Hello, World!

# 使用 f-strings
print(f'Hello, {name}!')
# 输出：Hello, World!

---

1. Resource ↩︎ ↩︎ ↩︎