Python语法

发表于 | 分类于
Python语法

前言

推荐文档：https://www.w3school.com.cn/python/index.asp

打印

1
print("Hello, World!")

注释

1
# print("Hello, World!")

数据类型

类型： 示例
文本类型： str
数值类型： int, float, complex
序列类型： list, tuple, range
映射类型： dict
集合类型： set, frozenset
布尔类型： bool
二进制类型： bytes, bytearray, memoryview

设置数据类型

在 Python 中，当您为变量赋值时，会设置数据类型：

数据类型 示例
str x = “Hello World”
int x = 29
float x = 29.5
complex x = 1j
list x = [“apple”, “banana”, “cherry”]
tuple x = (“apple”, “banana”, “cherry”)
range x = range(6)
dict x = {“name” : “Bill”, “age” : 63}
set x = {“apple”, “banana”, “cherry”}
frozenset x = frozenset({“apple”, “banana”, “cherry”})
bool x = True
bytes x = b”Hello”
bytearray x = bytearray(5)
memoryview x = memoryview(bytes(5))

设定特定的数据类型

如果希望指定数据类型，则您可以使用以下构造函数：

数据类型 示例
str x = str(“Hello World”)
int x = int(29)
float x = float(29.5)
complex x = complex(1j)
list x = list((“apple”, “banana”, “cherry”))
tuple x = tuple((“apple”, “banana”, “cherry”))
range x = range(6)
dict x = dict(name=”Bill”, age=36)
set x = set((“apple”, “banana”, “cherry”))
frozenset x = frozenset((“apple”, “banana”, “cherry”))
bool x = bool(5)
bytes x = bytes(5)
bytearray x = bytearray(5)
memoryview x = memoryview(bytes(5))

字典的方法

方法 描述
clear() 删除字典中的所有元素
copy() 返回字典的副本
fromkeys() 返回拥有指定键和值的字典
get() 返回指定键的值
items() 返回包含每个键值对的元组的列表
keys() 返回包含字典键的列表
pop() 删除拥有指定键的元素
popitem() 删除最后插入的键值对
setdefault() 返回指定键的值。如果该键不存在，则插入具有指定值的键。
update() 使用指定的键值对字典进行更新
values() 返回字典中所有值的列表

列表/数组的方法

方法 描述
append() 在列表的末尾添加一个元素
clear() 删除列表中的所有元素
copy() 返回列表的副本
count() 返回具有指定值的元素数量。
extend() 将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index() 返回具有指定值的第一个元素的索引
insert() 在指定位置添加元素
pop() 删除指定位置的元素
remove() 删除具有指定值的项目
reverse() 颠倒列表的顺序
sort() 对列表进行排序

集合的方法

方法 描述
add() 向集合添加元素。
clear() 删除集合中的所有元素。
copy() 返回集合的副本。
difference() 返回包含两个或更多集合之间差异的集合。
difference_update() 删除此集合中也包含在另一个指定集合中的项目。
discard() 删除指定项目。
intersection() 返回为两个其他集合的交集的集合。
intersection_update() 删除此集合中不存在于其他指定集合中的项目。
isdisjoint() 返回两个集合是否有交集。
issubset() 返回另一个集合是否包含此集合。
issuperset() 返回此集合是否包含另一个集合。
pop() 从集合中删除一个元素。
remove() 删除指定元素。
symmetric_difference() 返回具有两组集合的对称差集的集合。
symmetric_difference_update() 插入此集合和另一个集合的对称差集。
union() 返回包含集合并集的集合。
update() 用此集合和其他集合的并集来更新集合。

元组的方法

方法 描述
count() 返回元组中指定值出现的次数。
index() 在元组中搜索指定的值并返回它被找到的位置。

字符串

格式化

基本格式化

我们可以使用 format() 方法对结果进行格式化。

1
2
3
4
5
quantity = 3
itemno = 567
price = 52
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))

索引号

您可以使用索引号（花括号 {0} 内的数字）来确保将值放在正确的占位符中：

1
2
3
4
5
quantity = 3
itemno = 567
price = 52
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

此外，如果要多次引用相同的值，请使用索引号：

1
2
3
4
age = 63
name = "Bill"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

命名索引

您还可以通过在花括号 {carname} 中输入名称来使用命名索引，但是在传递参数值 txt.format(carname = “Ford”) 时，必须使用名称：

1
2
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Porsche", model = "911"))

其它方法

Python 有一组可以在字符串上使用的内建方法。

注释：所有字符串方法都返回新值。它们不会更改原始字符串。

方法 描述
capitalize() 把首字符转换为大写。
casefold() 把字符串转换为小写。
center() 返回居中的字符串。
count() 返回指定值在字符串中出现的次数。
encode() 返回字符串的编码版本。
endswith() 如果字符串以指定值结尾，则返回 true。
expandtabs() 设置字符串的 tab 尺寸。
find() 在字符串中搜索指定的值并返回它被找到的位置。
format() 格式化字符串中的指定值。
format_map() 格式化字符串中的指定值。
index() 在字符串中搜索指定的值并返回它被找到的位置。
isalnum() 如果字符串中的所有字符都是字母数字，则返回 True。
isalpha() 如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal() 如果字符串中的所有字符都是小数，则返回 True。
isdigit() 如果字符串中的所有字符都是数字，则返回 True。
isidentifier() 如果字符串是标识符，则返回 True。
islower() 如果字符串中的所有字符都是小写，则返回 True。
isnumeric() 如果字符串中的所有字符都是数，则返回 True。
isprintable() 如果字符串中的所有字符都是可打印的，则返回 True。
isspace() 如果字符串中的所有字符都是空白字符，则返回 True。
istitle() 如果字符串遵循标题规则，则返回 True。
isupper() 如果字符串中的所有字符都是大写，则返回 True。
join() 把可迭代对象的元素连接到字符串的末尾。
ljust() 返回字符串的左对齐版本。
lower() 把字符串转换为小写。
lstrip() 返回字符串的左修剪版本。
maketrans() 返回在转换中使用的转换表。
partition() 返回元组，其中的字符串被分为三部分。
replace() 返回字符串，其中指定的值被替换为指定的值。
rfind() 在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex() 在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust() 返回字符串的右对齐版本。
rpartition() 返回元组，其中字符串分为三部分。
rsplit() 在指定的分隔符处拆分字符串，并返回列表。
rstrip() 返回字符串的右边修剪版本。
split() 在指定的分隔符处拆分字符串，并返回列表。
splitlines() 在换行符处拆分字符串并返回列表。
startswith() 如果以指定值开头的字符串，则返回 true。
strip() 返回字符串的剪裁版本。
swapcase() 切换大小写，小写成为大写，反之亦然。
title() 把每个单词的首字符转换为大写。
translate() 返回被转换的字符串。
upper() 把字符串转换为大写。
zfill() 在字符串的开头填充指定数量的 0 值。

运算符

运算符用于对变量和值执行操作。

Python 在以下组中划分运算符：

  • 算术运算符
  • 赋值运算符
  • 比较运算符
  • 逻辑运算符
  • 身份运算符
  • 成员运算符
  • 位运算符

算术运算符

算术运算符与数值一起使用来执行常见的数学运算：

运算符 名称 实例
+ 加 x + y
- 减 x - y
* 乘 x * y
/ 除 x / y
% 取模 x % y
** 幂 x ** y
// 地板除（取整除） x // y

赋值运算符

赋值运算符用于为变量赋值：

运算符 实例 等同于
= x = 5 x = 5
+= x += 3 x = x + 3
-= x -= 3 x = x - 3
*= x *= 3 x = x * 3
/= x /= 3 x = x / 3
%= x %= 3 x = x % 3
//= x //= 3 x = x // 3
**= x **= 3 x = x ** 3
&= x &= 3 x = x & 3
` =` x \ = 3 x = x \ 3
^= x ^= 3 x = x ^ 3
>>= x >>= 3 x = x >> 3
<<= x <<= 3 x = x << 3

比较运算符

比较运算符用于比较两个值：

运算符 名称 实例
== 等于 x == y
!= 不等于 x != y
> 大于 x > y
< 小于 x < y
>= 大于或等于 x >= y
<= 小于或等于 x <= y

逻辑运算符

逻辑运算符用于组合条件语句：

运算符 描述 实例
and 如果两个语句都为真，则返回 True。 x > 3 and x < 10
or 如果其中一个语句为真，则返回 True。 x > 3 or x < 4
not 反转结果，如果结果为 true，则返回 False not(x > 3 and x < 10)

身份运算符

身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置：

运算符 描述 实例
is 如果两个变量是同一个对象，则返回 true。 x is y
is not 如果两个变量不是同一个对象，则返回 true。 x is not y

成员运算符

成员资格运算符用于测试序列是否在对象中出现：

运算符 描述 实例
in 如果对象中存在具有指定值的序列，则返回 True。 x in y
not in 如果对象中不存在具有指定值的序列，则返回 True。 x not in y

位运算符

位运算符用于比较（二进制）数字：

运算符 描述 实例
& AND 如果两个位均为 1，则将每个位设为 1。
` ` OR 如果两位中的一位为 1，则将每个位设为 1。
^ XOR 如果两个位中只有一位为 1，则将每个位设为 1。
~ NOT 反转所有位。
<< Zero fill left shift 通过从右侧推入零来向左移动，推掉最左边的位。
>> Signed right shift 通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。

if else

1
2
3
4
5
6
7
8
a = 200
b = 66
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

循环

while循环

在 i 等于 3 时退出循环：

1
2
3
4
5
6
i = 1
while i < 7:
  print(i)
  if i == 3:
    break
  i += 1

for循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

循环字符串

循环遍历单词 “banana” 中的字母：

1
2
for x in "banana":
  print(x)

循环列表

1
2
3
4
5
fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x) 
  if x == "banana":
    break

循环字典

方式1

1
2
3
d = {'name1' : 'pythontab', 'name2' : '.', 'name3' : 'com'}
for key in d:
    print (key, ' value : ', d[key])

方式2

1
2
for key, value in d.items():
    print (key, ' value : ', value)

range函数

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

使用 range() 函数：

1
2
for x in range(10):
  print(x)

迭代器

从元组返回一个迭代器，并打印每个值：

1
2
3
4
5
6
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

创建迭代器

要把对象/类创建为迭代器，必须为对象实现 iter() 和 next() 方法。

正如您在 Python 类/对象 一章中学到的，所有类都有名为 init() 的函数，它允许您在创建对象时进行一些初始化。

  • __iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。

  • __next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

StopIteration

如果你有足够的 next() 语句，或者在 for 循环中使用，则上面的例子将永远进行下去。

为了防止迭代永远进行，我们可以使用 StopIteration 语句。

在 next() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误：

在 20 个迭代之后停止：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

函数

1
2
3
4
def my_function():
  print("Hello from a function")

my_function()

Lambda

1
2
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

异常

try 块将生成异常，因为 x 未定义：

1
2
3
4
try:
  print(x)
except:
  print("An exception occurred")

多个异常

您可以根据需要定义任意数量的 exception 块，例如，假如您要为特殊类型的错误执行特殊代码块：

如果 try 块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息：

1
2
3
4
5
6
try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")

Else

如果没有引发错误，那么您可以使用 else 关键字来定义要执行的代码块：

在本例中，try 块不会生成任何错误：

1
2
3
4
5
6
try:
  print("Hello")
except:
  print("Something went wrong")
else:
  print("Nothing went wrong")

Finally

如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块。

1
2
3
4
5
6
try:
  print(x)
except:
  print("Something went wrong")
finally:
  print("The 'try except' is finished")

模块

在名为 mymodule.py 的文件中保存代码：

1
2
def greeting(name):
  print("Hello, " + name)

导入名为 mymodule 的模块，并调用 greeting 函数：

1
2
3
import mymodule

mymodule.greeting("Bill")

with

1
2
3
4
5
6
7
8
9
10
11
try:
    f = open('xxx')
except:
    print('fail to open')
    exit(-1)
try:
    do something
except:
    do something
finally:
    f.close()

虽然这段代码运行良好，但比较冗长。
而使用with的话，能够减少冗长，还能自动处理上下文环境产生的异常。如下面代码：

1
2
with open("1.txt") as file:
    data = file.read()

with 工作原理

（１）紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量；
（２）当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。
with工作原理代码示例：

1
2
3
4
5
6
7
8
9
10
class Sample:
    def __enter__(self):
        print "in __enter__"
        return "Foo"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print "in __exit__"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "Sample: ",

代码的运行结果如下：

1
2
3
in __enter__
Sample:  Foo
in __exit__

可以看到，整个运行过程如下：
（１）enter()方法被执行；
（２）enter()方法的返回值，在这个例子中是”Foo”，赋值给变量sample；
（３）执行代码块，打印sample变量的值为”Foo”；
（４）exit()方法被调用；

exit()方法中有３个参数， exc_type, exc_val, exc_tb，这些参数在异常处理中相当有用。

  • exc_type：　错误的类型
  • exc_val：　错误类型对应的值
  • exc_tb：　代码中错误发生的位置

日期

1
2
3
4
5
6
7
8
import datetime

x = datetime.datetime(2020, 5, 17)

print(x)

y = datetime.datetime.now()
print(y)

JSON

字符串转对象

1
2
3
4
5
6
7
8
9
10
import json

# 一些 JSON:
x =  '{ "name":"Bill", "age":63, "city":"Seatle"}'

# 解析 x:
y = json.loads(x)

# 结果是 Python 字典：
print(y["age"])

对象转字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import json

# Python 对象（字典）：
x = {
  "name": "Bill",
  "age": 63,
  "city": "Seatle"
}

# 转换为 JSON：
y = json.dumps(x)

# 结果是 JSON 字符串：
print(y)

当 Python 转换为 JSON 时，Python 对象会被转换为 JSON（JavaScript）等效项：

Python JSON
dict Object
list Array
tuple Array
str String
int Number
float Number
True true
False false
None null

正则表达式

re 模块提供了一组函数，允许我们检索字符串以进行匹配：

函数 描述
findall 返回包含所有匹配项的列表
search 如果字符串中的任意位置存在匹配，则返回 Match 对象
split 返回在每次匹配时拆分字符串的列表
sub 用字符串替换一个或多个匹配项

元字符

元字符是具有特殊含义的字符：

字符 描述 示例
[] 一组字符 “[a-m]”
\ 示意特殊序列（也可用于转义特殊字符） “\d”
. 任何字符（换行符除外） “he..o”
^ 起始于 “^hello”
$ 结束于 “world$”
* 零次或多次出现 “aix*”
+ 一次或多次出现 “aix+”
{} 确切地指定的出现次数 “al{2}”
` ` 两者任一 “falls\ stays”
() 捕获和分组

特殊序列

特殊序列指的是 \ 后跟下表中的某个字符，拥有特殊含义：

字符 描述 示例
\A 如果指定的字符位于字符串的开头，则返回匹配项 “\AThe”
\b 返回指定字符位于单词的开头或末尾的匹配项 r”\bain” r”ain\b”
\B 返回指定字符存在的匹配项，但不在单词的开头（或结尾处） r”\Bain” r”ain\B”
\d 返回字符串包含数字的匹配项（数字 0-9） “\d”
\D 返回字符串不包含数字的匹配项 “\D”
\s 返回字符串包含空白字符的匹配项 “\s”
\S 返回字符串不包含空白字符的匹配项 “\S”
\w 返回一个匹配项，其中字符串包含任何单词字符 （从 a 到 Z 的字符，从 0 到 9 的数字和下划线 _ 字符） “\w”
\W 返回一个匹配项，其中字符串不包含任何单词字符 “\W”
\Z 如果指定的字符位于字符串的末尾，则返回匹配项 “Spain\Z”

集合（Set）

集合（Set）是一对方括号 [] 内的一组字符，具有特殊含义：

集合 描述
[arn] 返回一个匹配项，其中存在指定字符（a，r 或 n）之一
[a-n] 返回字母顺序 a 和 n 之间的任意小写字符匹配项
[^arn] 返回除 a、r 和 n 之外的任意字符的匹配项
[0123] 返回存在任何指定数字（0、1、2 或 3）的匹配项
[0-9] 返回 0 与 9 之间任意数字的匹配
[0-5][0-9] 返回介于 0 到 9 之间的任何数字的匹配项
[a-zA-Z] 返回字母顺序 a 和 z 之间的任何字符的匹配，小写或大写
[+] 在集合中，+、*、.、\ 、()、$、{} 没有特殊含义，因此 [+] 表示：返回字符串中任何 + 字符的匹配项

示例

检索字符串以查看它是否以 “China” 开头并以 “country” 结尾：

1
2
3
4
import re

txt = "China is a great country"
x = re.search("^China.*country$", txt)

文件处理

所有方法

方法 描述
close() 关闭文件。
detach() 从缓冲区返回分离的原始流（raw stream）。
fileno() 从操作系统的角度返回表示流的数字。
flush() 刷新内部缓冲区。
isatty() 返回文件流是否是交互式的。
read() 返回文件内容。
readable() 返回是否能够读取文件流。
readline() 返回文件中的一行。
readlines() 返回文件中的行列表。
seek() 更改文件位置。
seekable() 返回文件是否允许我们更改文件位置。
tell() 返回当前的文件位置。
truncate() 把文件调整为指定的大小。
writeable() 返回是否能够写入文件。
write() 把指定的字符串写入文件。
writelines() 把字符串列表写入文件。

打开文件

在 Python 中使用文件的关键函数是 open() 函数。

open() 函数有两个参数：文件名和模式。

有四种打开文件的不同方法（模式）：

  • “r” - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错。
  • “a” - 追加 - 打开供追加的文件，如果不存在则创建该文件。
  • “w” - 写入 - 打开文件进行写入，如果文件不存在则创建该文件。
  • “x” - 创建 - 创建指定的文件，如果文件存在则返回错误。

此外，您可以指定文件是应该作为二进制还是文本模式进行处理。

  • “t” - 文本 - 默认值。文本模式。
  • “b” - 二进制 - 二进制模式（例如图像）。

示例

此外，您可以指定文件是应该作为二进制还是文本模式进行处理：

1
f = open("demofile.txt")

以上代码等同于：

1
f = open("demofile.txt", "rt")

因为 “r” (读取)和 “t” (文本)是默认值，所以不需要指定它们。