Python3 基础语法

最新推荐文章于 2024-05-11 02:07:32 发布

hhq2lcl

最新推荐文章于 2024-05-11 02:07:32 发布

阅读量1.2k

点赞数

文章标签： python

本文链接：https://blog.csdn.net/hhq2lcl/article/details/79925938

版权

1.1.编码

默认情况下， Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。当然你也可
以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

1.2.标识符
第一个字符必须是字母表中字母或下划线 '_'。
标识符的其他的部分有字母、数字和下划线组成。
标识符对大小写敏感。

在 Python 3 中，非 -ASCII 标识符也是允许的了。

1.3.python 保留字
保留字即关键字，我们不能把它们用作任何标识符名称。 Python 的标准库提供了一个 keyword
module，可以输出当前版本的所有关键字：
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del',
'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with',

'yield']

1.4.注释
Python 中单行注释以 # 开头，实例如下：

#!/usr/bin/python3
# 第 一 个 注 释
print ("Hello, Python!") # 第 二 个 注 释

执行以上代码，输出结果为：

Hello, Python!

多行注释可以用多个 # 号：

#!/usr/bin/python3
# 第 一 个 注 释
# 第 二 个 注 释
print ("Hello, Python!")

执行以上代码，输出结果为：

Hello, Python!

1.5.行与缩进
python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 ({})。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下

if True:
    print ("True")
else:
    print ("False")

以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")

 print ("False") # 缩 进 不 一 致 ， 会 导 致 运 行 错 误

以上程序由于缩进不一致，执行后会出现类似以下错误：

File "test.py", line 6

print("False")    #缩进不一致，会导致运行错误。


IndentationError: unindent does not match any outer indentation level

1.6.多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 (\)来实现多行语句，例
如：

total = item_one + \
item_two + \
item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 (\)，例如：

total = ['item_one', 'item_two', 'item_three',

'item_four', 'item_five']

1.7.数据类型
python 中数有四种类型：整数、长整数、浮点数和复数。
整数，如 1
长整数是比较大的整数
浮点数如 1.23、 3E-2

复数如 1 + 2j、 1.1 + 2.2j

1.8.字符串
python 中单引号和双引号使用完全相同。
使用三引号 ('''或 """)可以指定一个多行字符串。
转义符 '\'
自然字符串，通过在字符串前加 r 或 R。如 r"this is a line with \n" 则 \n 会显示，并不是
换行。 python 允许处理 unicode 字符串，加前缀 u 或 U，如 u"this is an unicode string"。字
符串是不可变的。按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is
string。
word = '字符串 '
sentence = "这是一个句子。 "
paragraph = """这是一个段落，

可以由多行组成 """

1.9.空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行， Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

1.10. 等待用户输入
执行下面的程序在按回车键后就会等待用户输入：

#!/usr/bin/python3
input("\n\n 按 下 enter 键 后 退 出 。 ")

以上代码中， "\n\n"在结果输出前会输出两个新的空行。一旦用户按下键时，程序将退出。

1.11. 同一行显示多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号 (;)分割，以下是一个简单的实例：

#!/usr/bin/python3
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

执行以上代码，输入结果为：

$ python3 test.py
runoob

1.12. 多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像 if、 while、 def 和 class 这样的复合语句，首行以关键字开始，以冒号 ( : )结束，该行之后的
一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句 (clause)。
如下实例：

if expression :
    suite
elif expression :
    suite
else :
    suite

1.13. 命令行参数
很多程序可以执行一些操作来查看一些基本信， Python 可以使用 -h 参数查看各参数帮助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数，具体使用可以参照 Python 3 命
令行参数。

2. Python3 基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在
Python 中，变量就是变量，它没有类型，我们所说的 "类型 "是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名 ,等号（=）运算符右边是存储在变
量中的值。例如：

counter	=100	#	整 型 变 量
miles=1000.0	#	浮 点 型 变 量
name="runoob"	#	字 符 串
print(counter)
print(miles)
print(name)

执行以上程序会输出如下结果：

100
1000.0
runoob

2.1.多个变量赋值
Python 允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为 1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

2.2.标准数据类型
Python3 中有六个标准的数据类型：
Number（数字） String（字符串） List（列表）
Tuple（元组） Sets（集合） Dictionary（字典）
2.2.1.Number（数字）

Python3 支持 int、 float、 bool、 complex（复数）。

在 Python 3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
第 6 页共 117 页
内置的 type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把
True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
当你指定一个值时， Number 对象就会被创建：

var1 = 1
var2 = 10

您也可以使用 del 语句删除一些对象引用。
del 语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用 del 语句删除单个或多个对象。例如：

del var
del var_a, var_b

数值运算

>>> 5 + 4 # 加 法
9 >
>> 4.3 - 2 # 减 法
2.3
>>> 3 * 7 # 乘 法
21
>>> 2 / 4 # 除 法 ， 得 到 一 个 浮 点 数
0.5
>>> 2 // 4 # 除 法 ， 得 到 一 个 整 数
0 >
>> 17 % 3 # 取 余
2 >
>> 2 ** 5 # 乘 方
32

注意：
1、 Python 可以同时为多个变量赋值，如 a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法（/）总是返回一个浮点数，要获取整数使用 //操作符。

4、在混合计算时， Python 会把整型转换成为浮点数。

数值类型实例
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b)表示，复

数的实部 a 和虚部 b 都是浮点型

2.2.2.String（字符串）
Python 中的字符串用单引号 (')或双引号 (")括起来，同时使用反斜杠 (\)转义特殊字符。字符串的
截取的语法格式如下：

  变 量 [头 下 标 :尾 下 标 ]

索引值以 0 为开始值， -1 为从末尾的开始位置。
加号 (+) 是字符串的连接符，星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例
如下：

#!/usr/bin/python3
str = 'Runoob'
print(str)	#输 出 字 符 串
print(str[0:-1])#输 出 第 一 个 个 到 倒 数 第 二 个 的 所 有 字 符
print(str[0])	#输 出 字 符 串 第 一 个 字 符
print(str[2:5])	#输 出 从 第 三 个 开 始 到 第 五 个 的 字 符
print(str[2:])	#输 出 从 第 三 个 开 始 的 后 的 所 有 字 符
print(str*2)    #输 出 字 符 串 两 次
print(str+"TEST")#连 接 字 符 串

执行以上程序会输出如下结果：

Runoob
Runoo
R n
oo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 (\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个

r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

另外，反斜杠 (\) 可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者
'''...''' 跨越多行。

注意， Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

与 C 字符串不同的是， Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm'会

导致错误。

注意：
1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
2、字符串可以用 +运算符连接在一起，用 *运算符重复。
3、 Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

4、 Python 中的字符串不能改变。

2.2.3.List（列表）

List（列表）是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串，甚至可以包含列表（所谓嵌套）。列表是写在方括号 ([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变 量 [头 下 标 :尾 下 标 ]

索引值以 0 为开始值， -1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist=[123,'runoob']
print(list)	#输 出 完 整 列 表
print(list[0])	#输 出 列 表 第 一 个 元 素
print(list[1:3])#从 第 二 个 开 始 输 出 到 第 三 个 元 素
print(list[2:])	#输 出 从 第 三 个 元 素 开 始 的 所 有 元 素
print(tinylist*2)#输 出 两 次 列 表
print(list+tinylist)#连 接 列 表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与 Python 字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 删 除
>>> a
[9, 2, 6]

List 内置了有很多方法，例如 append()、 pop()等等，这在后面会讲到。

注意：
1、 List 写在方括号之间，元素用逗号隔开。
2、和字符串一样， list 可以被索引和切片。
3、 List 可以使用 +操作符进行拼接。

4、 List 中的元素是可以改变的。

2.2.4.Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 (())里，元素之间
用逗号隔开。
第 10 页共 117 页
元组中的元素类型也可以不相同：

#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print(tuple)	#输 出 完 整 元 组
print(tuple[0])	#输 出 元 组 的 第 一 个 元 素
print(tuple[1:3])#输 出 从 第 二 个 元 素 开 始 到 第 三 个 元 素
print(tuple[2:])#输 出 从 第 三 个 元 素 开 始 的 所 有 元 素
print(tinytuple*2)#输 出 两 次 元 组
print(tuple+tinytuple)#连 接 元 组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从 0 开始， -1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组。

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1 
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11 # 修 改 元 组 元 素 的 操 作 是 非 法 的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>># 修 改 元 组 元 素 的 操 作 是 非 法 的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () # 空 元 组
tup2 = (20,) # 一 个 元 素 ， 需 要 在 元 素 后 添 加 逗 号# 空 元 组
tup2 = (20,) # 一 个 元 素 ， 需 要 在 元 素 后 添 加 逗 号

string、 list 和 tuple 都属于 sequence（序列）。

注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。

4、元组也可以使用 +操作符进行拼接。

2.2.5.Set（集合）

集合（set）是一个 无序不重复 元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 ({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，

因为 { } 是用来创建一个空字典。

#!/usr/bin/python3
student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}) 
print(student) # 输 出 集 合 ， 重 复 的 元 素 被 自 动 去 掉
# 成 员 测 试
if('Rose' in student) :
    print('Rose 在 集 合 中 ')
else :
    print('Rose 不 在 集 合 中 ')
# set 可 以 进 行 集 合 运 算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a	-b)	#a 和 b 的 差 集
print(a	|b)	#a 和 b 的 并 集
print(a	&b)	#a 和 b 的 交 集
print(a	^b)	#a 和 b 中 不 同 时 存 在 的 元 素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在 集 合 中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

2.2.6.Dictionary（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。
列表是 有序 的对象结合，字典是 无序 的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 "{ }"标识，它是一个无序的键 (key) : 值 (value)对集合。
键 (key)必须使用不可变类型。
在同一个字典中，键 (key)必须是唯一的。

#!/usr/bin/python3
dict = {}
dict['one']="1-菜 鸟 教 程 "
dict[2]	="2-菜 鸟 工 具 "
tinydict={'name':'runoob','code':1,'site':'www.runoob.com'}
print(dict['one'])	#输出键为'one'的值
print(dict[2])         #输出键为2的值
print(tinydict)         #输出完整的字典
print(tinydict.keys()) #输出所有键
print(tinydict.values()) #输出所有值

以上实例输出结果：

1 - 菜 鸟 教 程
2 - 菜 鸟 工 具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

另外，字典类型也有一些内置的函数，例如 clear()、 keys()、 values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。

3、创建空字典使用 { }。

2.3.Python 数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名
即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

      函数                  描述

int(x [,base])         将 x 转换为一个整数
float(x)               将 x 转换到一个浮点数
complex(real [,imag])  创建一个复数
str(x)                 将对象 x 转换为字符串
repr(x)                将对象 x 转换为表达式字符串
eval(str)              用来计算在字符串中的有效 Python 表达式,并返回一个对象
tuple(s)               将序列 s 转换为一个元组
list(s)                将序列 s 转换为一个列表
set(s)                 转换为可变集合
dict(d)                创建一个字典。d必须是一个序列 (key,value)元组。
frozenset(s)           转换为不可变集合
chr(x)                 将一个整数转换为一个字符
unichr(x)              将一个整数转换为 Unicode 字符
ord(x)                 将一个字符转换为它的整数值
hex(x)                 将一个整数转换为一个十六进制字符串
oct(x)                 将一个整数转换为一个八进制字符串

3. Python3 解释器

Linux/Unix 的系统上，一般默认的 python 版本为 2.x ，我们可以将 python3.x 安装在
/usr/local/python3 目录中。
安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境
变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。
$ PATH=$PATH:/usr/local/python3/bin/python3 # 设置环境变量
$ python3 --version
Python 3.4.0
在 Window 系统下你可以通过以下命令来设置 Python 的环境变量，假设你的 Python 安装在
C:\Python34 下 :

set path=%path%;C:\python34

3.1.交互式编程

我们可以在命令提示符中输入 "Python"命令来启动 Python 解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> flag=True
>>> if flag:
... print("flag条 件 为	True!")
...
flag条件为True!

3.2.脚本式编程

将如下代码拷贝至 hello.py 文件中：
print ("Hello, Python!");
通过以下命令执行该脚本：
python3 hello.py
输出结果为：
Hello, Python!
在 Linux/Unix 系统中，你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直
接执行：
#! /usr/bin/env python3
然后修改脚本权限，使其有执行权限，命令如下：
$ chmod +x hello.py
执行以下命令：
./hello.py
输出结果为：
Hello, Python!4. Python3 注释
确保对模块 , 函数 , 方法和行内注释使用正确的风格
Python 中的注释有单行注释和多行注释：
Python 中单行注释以 #开头，例如：：
# 这是一个注释
print("Hello, World!")
多行注释用三个单引号（'''）或者三个双引号（"""）将注释括起来，例如 :
1、单引号（'''）
#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")
2、双引号（"""）
第 16 页共 117 页
#!/usr/bin/python3
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号
"""
print("Hello, World!")
5. Python3 运算符
5.1.什么是运算符？
本章节主要说明 Python 的运算符。举个简单的例子 4 +5 = 9 。例子中， 4 和 5 被称为操作数，
"+" 称为运算符。
Python 语言支持以下类型的运算符 :
算术运算符比较（关系）运算符赋值运算符逻辑运算符
位运算符成员运算符身份运算符运算符优先级
接下来让我们一个个来学习 Python 的运算符。
5.2.Python 算术运算符
以下假设变量 a 为 10，变量 b 为 21：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回 x 的 y 次幂	a**b 为 10 的 21 次方
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

以下实例演示了 Python 所有算术运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
第 17 页共 117 页
print ("1 - c 的值为： ", c)
c = a - b
print ("2 - c 的值为： ", c)
c = a * b
print ("3 - c 的值为： ", c)
c = a / b
print ("4 - c 的值为： ", c)
c = a % b
print ("5 - c 的值为： ", c)
# 修改变量 a 、 b 、 c
a = 2
b = 3
c = a**b
print ("6 - c 的值为： ", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值为： ", c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2
Python 比较运算符
以下假设变量 a 为 10，变量 b 为 20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.

第 18 页共 117 页

>	大于 - 返回 x 是否大于 y	(a > b) 返回 False。
<	小于 - 返回 x 是否小于 y。所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意，这些变量名的大写。	(a < b) 返回 true。
>=	大于等于 - 返回 x 是否大于等于 y。	(a >= b) 返回 False。
<=	小于等于 - 返回 x 是否小于等于 y。	(a <= b) 返回 true。

以下实例演示了 Python 所有比较运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")
if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")
if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
第 19 页共 117 页
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")
if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")
以上实例输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
5.3.Python 赋值运算符
以下假设变量 a 为 10，变量 b 为 20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

以下实例演示了 Python 所有赋值运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
第 20 页共 117 页
c = a + b
print ("1 - c 的值为： ", c)
c += a
print ("2 - c 的值为： ", c)
c *= a
print ("3 - c 的值为： ", c)
c /= a
print ("4 - c 的值为： ", c)
c = 2
c %= a
print ("5 - c 的值为： ", c)
c **= a
print ("6 - c 的值为： ", c)
c //= a
print ("7 - c 的值为： ", c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864
5.4.Python 位运算符
按位运算符是把数字看作二进制来进行计算的。 Python 中的按位运算法则如下：
下表中变量 a 为 60， b 为 13 二进制格式如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
第 21 页共 117 页
~a = 1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为 1,则该位的结果为 1,否则为 0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为 1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把 1 变为 0,把 0 变为 1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<" 右边的数指定移动的位数，高位丢弃，低位补 0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位， ">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了 Python 所有位运算符的操作：
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值为： &#

最低0.47元/天解锁文章

hhq2lcl

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Python3 基础语法

1.1.编码默认情况下， Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。当然你也可以为源码文件指定不同的编码：# -*- coding: cp-1252 -*-1.2.标识符第一个字符必须是字母表中字母或下划线 '_'。标识...
复制链接

扫一扫