Python——变量、运算符、字符串、数字、注释

最新推荐文章于 2024-01-02 16:19:30 发布

meiwen_w

最新推荐文章于 2024-01-02 16:19:30 发布

阅读量319

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/weixin_43401055/article/details/105611452

版权

一、变量

在程序设计中，变量是一种存储数据的载体。在上次的文章里我们成功运行了第一个Python程序——输出“hello, world!”。现在我们来尝试在hello.py中使用一个变量。在文本编辑器中输入以下代码：

message = "hello, world!"
print(message)

运行，发现结果和之前一样：

hello, world!

这里的message就是变量，它存储了一个值，此处的值是"hello, world!"。

现在我们来输入以下代码：

message = "hello, world!"
print(message)

message = 'hello, python world!"
print(message)

运行，结果如下：

hello, world!
hello, python world!

可见在Python中我们可以随时修改变量的值，Python将始终记录变量的最新值。

1.变量的命名

每个变量都需要一个名字，在Python中，变量命名需要遵守一些规则，如若违反这些规则将引发错误。

变量名有字母、数字和下划线组成，而且数字不能打头。
不要将Python关键字和函数名作为变量名。
变量名中不可以包含空格。
避免使用小写字母l和大写字母O，因为经常被错看为数字1和0。
最好做到见名知意。例如name比n号，student_name比s_n好。

2.变量的使用及错误避免

现在我们有意编写一段会引发错误的代码，请在文本编辑器中输入以下代码：

message= "hello, world!"
print(mesage)

显然mesage拼写错误。此时解释器会提供一个traceback，指出解释器尝试运行代码是在什么地方陷入困境。以下是对上面代码Python解释器提供的traceback：

Traceback (most recent call last):
  File "hello.py", line 2, in <module>
    print(mesage)
NameError: name 'mesage' is not defined

在这里解释器指出在文件hello.py第二行要打印的变量mesage未定义。一般名称错误有两种情况，一是在打印前未给变量赋值，二是变量名拼写错误。

3.几种常见的数据类型

整型
在Python3中只有int一种整数，支持二进制（0b100换算成十进制4）、八进制（0o100换算成十进制64）、十进制（100）和十六进制（0x100换算成十进制256）的表示方法。
浮点型
浮点数也就是小数，之所以称之为浮点型是因为按照科学计数法表示时，小数点位置可变。（123.456科学计数法表示为1.23456e2）
字符串型
用单引号或者双引号括起来的文本（’hello‘、“hello”）。还可以书写成多行，用三个单引号或者三个双引号开头结尾即可。
布尔型
布尔值有两种True和False。在Python中可以直接用True或者False表示布尔值，也可以通过布尔运算计算出来（3<5计算出True）。
复数型
和数学上的复数表示一样，不同之处就是虚部为j，形如3+3j。

4.变量类型的判断和转换

变量类型的判断
在Python中可以用type函数判断变量类型。如下列代码（结果附在注释中）：

#判断变量类型
a = 12.3
b = 100
c = 'hello, world!'
d = True
e = 3+3j
print(type(a)) #<class 'float'>
print(type(b)) #<class 'int'>
print(type(c)) #<class 'str'>
print(type(d)) #<class 'bool'>
print(type(e)) #<class 'complex'>

变量类型的转换
可以使用Python中的内置函数对变量类型进行转换。

int():把指定对象转换为整数。
float():把指定对象转换为浮点数。
str():把指定对象转换为字符串形式。
chr():把整数转换为对应的一个字符。
ord():把一个字符转换为对应的编码整数。
示例代码如下（结果附在注释中）：
```
a = 12.3
b = 65
c = 'a'
print(int(a)) #12
print(float(b)) #65.0
print(str(a)) #12.3
print(chr(b)) #A  #65是大写字母A的ASCII码
print(ord(c)) #97
```
注意int()将浮点数转换为整数时直接省去小数点及小数点后面的数。

二、运算符

下表按照优先级从高到低的顺序列出了运算符。如果在编写代码过程中搞不清楚优先级，则可以使用括号来确保执行顺序。

运算符	描述
`[]` `[:]`	下标，切片
`**`	指数
`~` `+` `-`	按位取反，正号，负号
`*` `/` `%` `//`	乘，除，模，整除
`+` `-`	加，减
`>>` `<<`	右移，左移
`&`	按位与
`^` `\|`	按位异或，按位或
`<=` `<` `>` `>=`	小于等于，小于，大于，大于等于
`==` `!=`	等于，不等于
`is` `is not`	身份运算符
`in` `not in`	成员运算符
`not` `or` `and`	逻辑运算符

下面介绍几种常用的运算符

1.赋值运算符

赋值运算符的作用是将右边的值赋给左边的变量。=

#赋值运算符和复合赋值运算符的使用举例
a = 10
b = 2
a += b #相当于a = a + b
a *= a + 2 #相当于a = a * (a + 2)
print(a)

先自己算一算这里的a的值会是多少，接下来看结果：

你算对了嘛？注意上面说过的，Python将始终记录变量的最新值。

2.比较运算符

在有的书上也把比较运算符称为关系运算符，包括==(等于)、!=(不等于)、<=(小于等于)、<(小于)、>(大于)、>=(大于等于)。其中最需要注意的就是==，要与上面提到的赋值运算符区分开来，这里的==是用来比较相等的比较运算符。比较运算符产生的结果是布尔值，即True或者False。

#比较运算符的使用举例
a = 1 == 1
b = 2 < 1
c = 3 > 2
print('a =',a)
print('b =',b)
print('c =',c)
"""
注意比较运算符的优先级比赋值运算符的优先级高
故a = 1 == 1先做1==1产生布尔值True，而后将True赋给a
"""

运行结果如下：

a = True
b = False
c = True

3.逻辑运算符

逻辑运算符有三个，分别是and、or、not。
and意为而且，如果该运算符连接的两个布尔值都是True则运算结果为True；否则为False。如果and左边的布尔值为False，那么右边的表达式会被跳过，这就是“短路”。
or意为或者，如果该运算符连接的两个布尔值有一个是True则最终结果就是True；否则为False。or也有“短路”处理，即如果or左边的布尔值为True，则右边的表达式没有机会运行。
not意为否定，在该运算符后面跟一个布尔值，可以得到与之相反的值。即如果not后面是True则结果是False；反之相反。

#逻辑运算符的使用举例
a = True
b = False
c = True
m = a and b
n = a or b
p = not(1 != 2)
print('m =',m)
print('n =',n)
print('p =',p)

运行结果如下：

m = False
n = True
p = False

三、字符串

字符串就是一系列字符组成的有限序列，用单引号或者双引号括起来就可以表示一个字符串，这种灵活性可以是字符串中包含引号和撇号。也可以用三个单引号或双引号折行。

1.字符串示例

s1 = 'hello, world!'
s2 = "hello, world!"
s3 = """
hello,
world!
"""
print(s1, s2, s3,end=' ')

运行结果如下：

hello, world! hello, world! 
hello,
world!

2.转义符号

在字符串中使用\来表示转义。例如\n是换行符；\t是制表符。如果想在字符串中表示'就要写成\'；要表示\就要写成\\。

s1 = '\'hello, world!\''
s2 = '\n\\hello, world!\\\n'
print(s1, s2, end=' ')

运行结果如下：

'hello, world!' 
\hello, world!\

在\后边跟一个八进制或者十六进制数可以用来表示字符。例如\141和\x61都代表小写字母a。

s1 = '\141\142\143\x61\x62\x63'
print(s1)

运行结果如下：

abcabc

如果不希望字符串中的\表示转义，那我们可以在字符串最前面加上字母r以此说明。

s1 = r'\'hello, world!\''
s2 = r'\n\\hello, world!\\\n'
print(s1, s2, end=' ')

运行结果如下：

\'hello, world!\' \n\\hello, world!\\\n

3.运算符对字符串的作用

使用+来合并(拼接)字符串。
使用*来重复字符串的内容。
使用in和not in判断一个字符串是否包含另一个字符串（成员运算）。
使用[]和[:]从字符串中取出某个(些)字符（下标、切片运算）。

s1 = 'hello ' * 3
print(s1)
s2 = 'world!'
s1 += s2
print(s1)
print('ll' in s1) #判断'll'是否在s1中
print('good' in s1)
str1 = 'abc123456'
print(str1[2]) #从字符串中取出指定位置的字符（下标运算）
print(str1[2:5]) #从指定开始索引到指定结束索引（切片运算）注意左开右闭
print(str1[2:])
print(str1[2::2]) #从第二个开始每隔两个取一个字符
print(str1[::2]) #从默认第0个开始每个两个取一个字符
print(str1[::-1]) #逆序取全部字符
print(str1[-3:-1]) #从倒数第三个取到倒数第一个（不包括倒数第一个）

运算结果如下：

hello hello hello 
hello hello hello world!
True
False
c
c12
c123456
c246
ac246
654321cba
45

4.字符串的操作

字符串还要很多常见操作：
len(str)用来计算字符串长度
capitalize()使字符串首个字母大写
title()使每个单词的首字母大写
upper()使每个字符大写
lower()使每个字符小写
find(str, beg=0, end=len(string))从字符串中查找子串位置
index(str, beg=0, end=len(string))与find功能相同但是找不到子串会引发异常
startswith(suffix[, start[, end]])检查字符串是否以指定的字符串开头
endswith(suffix[, start[, end]])检查字符串是否以指定的字符串结尾
center(width[, fillchar])将字符串以指定的宽度居中，并在两侧填充指定字符
rjust(width[, fillchar])将字符串以指定的宽度右置，并在两侧填充指定字符
isdigit()检查字符串是否由数字构成
isalpha()检查字符串是否由字母构成
isalnum()检查字符串是否由数字和字母构成
rstrip()剔除末尾的空白后的字符串
lstrip()剔除开头的空白后的字符串
strip()剔除两端的空白后的字符串

代码如下（运行结果附在注释中）：

str1 = 'hello, world!'
#内置函数len计算字符串长度
print(len(str1)) #13
 #使字符串首个字母大写
print(str1.capitalize()) #Hello, world!
#使每个单词的首字母大写
print(str1.title()) #Hello, World!
#使每个字符大写
print(str1.upper()) #HELLO, WORLD!
#使每个字符小写
print(str1.lower()) #hello, world!
#从字符串中查找子串位置  -1表示不存在
print(str1.find('or')) #8
print(str1.find('shit')) #-1
#与find功能相同但是找不到子串会引发异常
print(str1.index('or')) #8
#print(str1.index('shit'))
#检查字符串是否以指定的字符串开头
print(str1.startswith('He')) #False
print(str1.startswith('he')) #True
#检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) #True
#将字符串以指定的宽度居中，并在两侧填充指定字符
print(str1.center(50, '*')) #******************hello, world!*******************
#将字符串以指定的宽度右置，并在两侧填充指定字符
print(str1.rjust(50, '*')) #*************************************hello, world!

str2 = 'abc123456'
#检查字符串是否由数字构成
print(str2.isdigit()) #False
#检查字符串是否由字母构成
print(str2.isalpha()) #False
#检查字符串是否由数字和字母构成
print(str2.isalnum()) #True

str3 = '     Python     '
#剔除末尾的空白后的字符串
print(str3.rstrip()) #     Python
#剔除开头的空白后的字符串
print(str3.lstrip()) #Python     #注意在这个井号前面有五个空格
#剔除两端的空白后的字符串
print(str3.strip()) #Python

5.格式化输出字符串

占位符语法
%d是整数的占位符；%f是浮点数的占位符；%%表示百分号（第一个百分号占位，第二个才是输出的百分号)。字符串后的%后面跟的变量值会替换掉占位符然后输出到终端。
如下列代码：
```
a, b = 5, 10
print('%d * %d = %d' % (a, b,  a*b))
```
运行结果如下：
```
5 * 10 = 50
```
用format完成字符串的格式，如下列代码：
```
a, b = 5, 10
print('{0} * {1} = {2}'.format(a, b, a * b))
```
其中{0}代表format中位置为0的变量。

运行结果如下：
```
5 * 10 = 50
```
在Python3.6之后的版本，有更为简洁的格式化字符串的书写方式——在字符串前面加上字母f。如下列代码：
```
a, b = 5, 10
print(f'{a} * {b} = {a * b})
```
运行结果如下：
```
5 * 10 = 50
```

四、数字

1.整数

整数运算示例代码如下：

a = 10
b = 3
print('%d + %d = %d' % (a, b, a + b))
print('%d - %d = %d' % (a, b, a - b))
print('%d * %d = %d' % (a, b, a * b))
print('%d / %d = %d' % (a, b, a / b))
print('%d // %d = %d' % (a, b, a // b))
print('%d %% %d = %d' % (a, b, a % b))
print('%d ** %d = %d' % (a, b, a ** b))

注意其中的输出使用了上面提到的占位符语法，尤其注意百分号的输出。（%d是整数的占位符；%f是浮点数的占位符；%%表示百分号（第一个百分号占位，第二个才是输出的百分号)。字符串后的%后面跟的变量值会替换掉占位符然后输出到终端。）

运行结果如下：

10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

2.浮点数

浮点数是带小数点的数字，在前面已经介绍过。大多数编程语言都使用了这个术语，所以编程时须细心设计，妥善处理浮点数，确保不管小数点出现在什么位置，数字的行为都是正常的。浮点数运算示例代码如下：

a = float(input())
b = float(input())
print('%.2f + %.2f = %.2f' % (a, b, a + b))
print('%.2f - %.2f = %.2f' % (a, b, a - b))
print('%.2f * %.2f = %.2f' % (a, b, a * b))
print('%.2f / %.2f = %.2f' % (a, b, a / b))
print('%.2f // %.2f = %.2f' % (a, b, a // b))
print('%.2f %% %.2f = %.2f' % (a, b, a % b))
print('%.2f ** %.2f = %.2f' % (a, b, a ** b))

在这个程序中，需要键盘输入两个数字，Python将这两个数字转换为浮点型。在输出时依旧使用了占位符语法，而且浮点数保留了两位小数。

10
3
10.00 + 3.00 = 13.00
10.00 - 3.00 = 7.00
10.00 * 3.00 = 30.00
10.00 / 3.00 = 3.33
10.00 // 3.00 = 3.00
10.00 % 3.00 = 1.00
10.00 ** 3.00 = 1000.00

3.在使用str()函数时的注意事项

示例代码如下：

age = 23
message = "Happy "+ age + "rd Birthday!"
print(message)

运行上述代码你会发现报错：

Traceback (most recent call last):
  File "birthday.py", line 2, in <module>
    message = "Happy " + age + "rd Birthday!"
TypeError: can only concatenate str (not "int") to str

这是一个类型错误，表示Python无法识别我们使用的信息。它不知道如何解读int这个值。像这样在字符中使用整数时，需要显式地指出你希望Python将这个整数作为字符串，调用函数str()，可以让非字符串值表示为字符串：

age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

运行结果如下：

Happy 23rd Birthday!

五、Python代码中的注释

注释起到解释说明的作用，增强了程序的可读性和可维护性。另一个作用是把源代码中不需要参与运行的代码段以注释的形式去掉。Python中代码有两种形式：

单行注释
以#开头的部分就是单行注释，井号后面的内容都会被Python解释器忽略。
```
print('hello, world!')
#你好，世界！
```
Python解释器将会忽略第二行，只执行第一行。
```
hello, world!
```

多行注释
以三个引号开头，三个引号结尾。

"""
第一个Python程序，输出hello, world!
向伟大的Dennis M. Ritchie先生致敬
"""
print('hello, world!')

Python解释器将忽略前四行，只执行第五行。

hello, world!

meiwen_w

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫