本文详尽地介绍了Python的基础语法，包括数据类型、字符串格式化、对象、运算符、循环、函数、异常处理、模块、日期、JSON和正则表达式等内容，适合初学者快速掌握Python编程。
前言
推荐文档：Python 教程
打印
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 值。 |
对象
对象定义
1 2 3 4 5 6 7 8 9 10 | class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1 = Person("Bill", 63)
p1.myfunc()
|
判断为空
1 | if (p1 is None): |
删除属性或对象
1 2 | del p1.age del p1 |
继承
1 | class Student(Person): |
运算符
运算符用于对变量和值执行操作。
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” (文本)是默认值，所以不需要指定它们。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
