xyZGHio

樱花同载酒，终似少年游

0%

Python变量类型之Numbers数字、String字符串

发表于 阅读数： 评论数：
本文字数： 7.4k 阅读时长 ≈ 15 分钟

本文介绍Python3变量类型中的Numbers数字、String字符串类型

abstract.png

注释

单行注释：以#开头

1
2
# 使用#的单行注释
print("Hello, World!")

多行注释：使用三个单引号 或 双引号

1
2
3
4
5
6
7
8
9
"""
使用三个双引号的
多行注释
"""

'''
使用三个单引号的
多行注释
'''

Hello World

# coding=utf-8 用于声明python源文件的编码格式。因为只有声明了文件的编码格式，python解释器才知道使用何种方式对源文件进行解码。由于python 3默认源文件编码采用的是utf-8格式。故当源文件使用utf-8编码时，上述文件编码格式声明可以省略

1
2
3
4
5
# coding=utf-8

# 打印消息，print默认会在末尾添加换行符
print("Hello, World!")
print("I'm Aaron")

figure 1.png

变量类型

Numbers 数字

Python 3的数字类型具体有：int整型、float浮点型、bool布尔型、complex复数。特别地：

  • Python 2中有int、long类型。而在Python 3没有long类型，且对int类型没有大小限制。故可以直接当作long类型使用
  • Python 3中, bool是int的子类。故True、False可以和数字进行运算，分别代表1、0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# int 整型
num1 = 24  
num2 = 2

# float 浮点数
num3 = 2.0
num4 = 1.23

# bool布尔型
b1 = True
b2 = False

# 无论是整数、浮点数，均可用下划线按任意位数进行划分。以便于阅读
apple_count = 1_0000_000
orange_count = 22_2
apple_price = 3.20_21
orange_price = 89_123.22

常见的数学运算符如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
num1 = 24  # int 整型
num2 = 2  # int 整型
num3 = 2.0  # float 浮点数

print("--------- 加减乘除运算 -------------")
print("2+24:", num2+num1)
print("2-24:", num2-num1)
print("2*24:", num2*num1)
# Python中，任意两个数进行除法操作，即使这两个数都是整数且能整除，结果依然会使用浮点数表示
print("24/2:", num1/num2)
print("(24+2) * 4:", (num1+num2) * 4)

print("--------- 幂运算 -------------")
print("2的3次方:", 2**3)

print("--------- 取模运算 -------------")
print("27%10 : ", 21%10)

print("--------- 整除运算 -------------")
# 整除运算符: 对结果往小的方向取整
print("9//3 : ", 9//3)
print("9//2 : ", 9//2)
print("-9//2 : ", -9//2)
print("9//-2 : ", 9//-2)

print("--------- 浮点运算 -------------")
# Python中，无论进行任何运算，只要有操作数为浮点数，结果必然使用浮点数表示
print("24+2.0:", num1+num3)
print("24*2.0:", num1*num3)
print("3*0.1:", 3*0.1)

figure 2.png

在Python 3中, bool是int的子类。故True、False可以和数字进行运算，分别代表1、0。故对于bool布尔型变量可通过is身份运算符(是否指向同一个对象)来判断类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
b1 = True
b2 = False
# Python 3, bool是int的子类
print("变量 b1 是否为 int类型及其子类: ", isinstance(b1, int))

print("---------------- ==运算符: 判断值是否相等 -------------------------")
print("b1<True>==1 : ", b1==1, ", b1<True>==True: ", b1==True)
print("b2<False>==0 : ", b2==0, ", b2<False>==False: ", b2==False)


print("------ 布尔变量可以和数字进行运算, True、False分别代表1、0 ---------")
print("b1<True> + 9 : ", b1+9)
print("b2<False> * 9 : ", b2*9)

print("-------- is身份运算符: (是否指向同一个对象)来判断类型 -----------------")
print("b1<True> is 1 :", b1 is 1, ", b1<True> is True :", b1 is True )
print("b2<False> is 0 :", b2 is 0, ", b2<False> is False :", b2 is False)

figure 3.png

String 字符串

Python 3中可使用单引号 或 双引号包裹来表示字符串；
此外，还可以使用f-string 格式化(format)字符串，实现在字符串中使用指定变量的值进行替换；
此外，为避免对字符串中的反斜杠\进行转义，还可以使用raw string原始字符串。其通常用于处理字符串中存在多个反斜线的情况。典型地场景有：正则表达式、目录路径等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 使用单引号 或 双引号包裹均可
name = "aaron zhu"
sex = '男性'
print("my name:", name, "my sex:", sex)

print("--------- f-string 格式化(format)字符串 -------------------")
first_name = "Bob"
last_name = "Wang"
# f-string 格式化(format)字符串 可以在字符串中使用指定变量的值进行替换
# 用法：在引号前添加f, 然后将变量名放到{}花括号里引用即可
full_name = f"my full name is {first_name} {last_name}"
welcome_msg = f'Hello, {full_name}'
print( full_name )
print( welcome_msg )

print("--------- raw string 原始字符串 -------------------")
msg1 = "He say.\nLet\'s go. Bye~"
print("msg 1:",msg1)
# 原始字符串 不会对反斜杠\进行转义
# 用法：在引号前添加 r 或 R
msg2 = r"He say.\nLet\'s go. Bye~"
print("msg 2:",msg2)
msg3 = R"He say.\nLet\'s go. Bye~"
print("msg 3:",msg3)

figure 4.png

字符串常见操作函数如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
print("--------------- 字符串切片 ---------------")
# Python中字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
# 1. 变量[start] ---->>>> 只截取start处的一个字符
# 1. 变量[start:] ---->>>> 截取start(包含)开始后的所有字符
# 2. 变量[start:end] ---->>>> 截取start(包含)开始到end(不包含)的所有字符
name = "AaronZhu"
print("first char:", name[0], "last char: ", name[-1]);
print("last name:", name[5:]);
print("first name:", name[0:5]);

print("--------------- 大小写转换 ---------------")
name = "aaron zhu"
print("每个单词的首字母变为大写:", name.title())
print("字母全部变为小写:", name.lower())
print("字母全部变为大写:", name.upper())

print("--------------- 删除多余空格 ---------------")
name  = "  Aaron  Zhu        "
print("删除字符串两侧的空格:", name.strip(), "END" )
print("删除字符串左侧的空格:", name.lstrip(), "END" )
print("删除字符串右侧的空格:", name.rstrip(), "END" )

print("--------------- 删除前后缀 ---------------")
baidu_url = "https://www.baidu.com"
print("删除指定前缀:", baidu_url.removeprefix("https://") )
print("删除指定后缀:", baidu_url.removesuffix(".com") )


print("--------------- 分隔字符串 ---------------")
delimiter = "."
name = "Bob.Aaron.tony"
names = name.split(delimiter)
print("names:", names)

print("--------------- 连接字符串 ---------------")
delimiter = "/"
names = ["home", "bin", "test", "tool"]
# join方法接受一个可迭代对象，将其中的元素拼接为一个字符串
# 其中，各元素之间通过方法调用者的字符串进行连接
# Note: 可迭代对象中的元素必须全部是字符串，否则会抛异常
join_res = delimiter.join(names)
print("join_res:", join_res)

figure 5.png

关于字符串格式化，这里补充说明下f-string 格式化(format)字符串是Python 3.6中才新引入的。在此之前格式化字符串主要有两种办法：古老的繁琐的%运算符格式化字符串、Python 2.6 版本中引入的str.format()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
name = "Luca"
age = 18
weight = 66.66
likes = ["阅读","旅行","运动"]

# %运算符 格式化字符串
# 字符串中使用%d、%s等占位符,然后在%运算符右侧将要插入的值作为元组进行传递，即可以将这些值插入到字符串中
# 示例入戏：
# "xxx %s xxxxxx" % (value1,)
# "xxx %s xx %s xxx" % (value1, value2)
my_info1 = "我叫%s, 芳龄%d岁。体重只有%.4f公斤。我喜欢%s" % (name, age, weight, likes)
print("my info 1: ", my_info1)

# str.format()方法 格式化字符串 : 使用{}作为占位符
my_info2 = "我叫{}, 芳龄{}岁。体重只有{}公斤。我喜欢{}".format(name, age, weight, likes)
print("my info 2: ", my_info2)

figure 6.png

类型判断：type函数、isinstance函数

  • type函数: 获取变量的实际类型
  • isinstance函数: 判断某变量是否为指定类型及其子类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 同时给多个变量赋值
name, age, weight, is_man = "WangBob", 23, 61.52, True
# print函数支持格式化输出, %d: 格式化为整数, %f: 格式化为浮点数, %s: 格式化为字符串 
print("我的姓名是%s, 我的年龄是%d, 我的体重是%.2fKg, 我的性别是男的:%s " %(name, age, weight, is_man))

print("-------------- type 函数 ------------------------")
# type函数: 获取变量的实际类型
print("变量name的类型: ",type(name) );
print("变量age的类型: ",type(age) );
print("变量weight的类型: ", type(weight) );
print("变量is_Man的类型: ", type(is_man) );

print("--------------  isinstance函数 ------------------------")
# isinstance函数: 判断某变量是否为指定类型及其子类
print("变量name 是否为 str类型及其子类: ", isinstance(name, str))
print("变量age 是否为 int类型及其子类: ", isinstance(age, int))
print("变量weight 是否为 float类型及其子类: ", isinstance(weight, float))
print("变量weight 是否为 int类型及其子类: ", isinstance(weight, int))
print("变量is_Man 是否为 bool类型及其子类: ", isinstance(is_man, bool))
print("变量is_Man 是否为 int类型及其子类: ", isinstance(is_man, int))

figure 7.png

脚本执行方式

当我们以脚本方式运行python时，与其他语言脚本类似。我们通常有两种方式：

  1. 将脚本文件作为可执行程序来运行。例如：./hello.py
  2. 将脚本文件作为参数传递给解释器运行。例如：python3 hello.py

第一种方式下，我们需要在脚本的第一行指定解释器信息。用于告知系统该脚本使用何种解释器进行执行。语法为 #!解释器的路径信息。同时，必须给该脚本添加x执行权限

1
2
3
#!/usr/local/bin/python3

print("Hello World")

figure 8.png

而在第二种方式下，不仅无需在脚本文件第一行指定解释器信息（写了也没用），而且也无需给该脚本添加x执行权限。下图中我们直接在脚本文件第一行指定了错误的解释器信息，也不会影响它的运行。进一步证明了其不会被使用

figure 9.png

参考文献

  1. Python编程·第3版：从入门到实践 Eric Matthes著
  2. Python基础教程·第3版 Magnus Lie Hetland著
  3. 流畅的Python·第1版 Luciano Ramalho著
推荐文章
请我喝杯咖啡捏～

欢迎关注我的微信公众号：青灯抽丝