Python基础知识巧学：简洁易懂的入门教程

前言

鉴于测试需要用到Python，特此学习总结了以下内容，以供以后复习所用

Python基础

Python 简介

什么是 Python?

Python 是一门流行的编程语言。它由 Guido van Rossum 创建，于 1991 年发布。

它用于：

  • web开发（服务器端）
  • 软件开发
  • 数学
  • 系统脚本

Python 入门

Python 是一门解释型编程语言，这意味着作为开发人员，您可以在文本编辑器中编写 Python（.py）文件，然后将这些文件放入 python 解释器中执行。

在命令行上运行 python 文件的方式如下：

1
C:\Users\Your Name>python helloworld.py

任何一门语言的入门都以HelloWorld开始，现在让我们也以HelloWorld为练习敲开Python的大门。

1
print("Hello, World!")

Python 缩进

缩进指的是代码行开头的空格。

在其他编程语言中，代码缩进仅出于可读性的考虑，而 Python 中的缩进非常重要。

Python 使用缩进来指示代码块。

1
2
if 5 > 2:
  print("Five is greater than two!")

如果省略缩进，Python 会出错

Python 没有声明变量的命令。（弱数据类型，不用像Java一样声明数据的类型）

注释

单行注释

Python 拥有对文档内代码进行注释的功能。

注释以 # 开头，Python 将其余部分作为注释呈现：

1
2
# This is a comment.
print("Hello, World!")

多行注释

由于 Python 将忽略未分配给变量的字符串文字，因此您可以在代码中添加多行字符串（三引号），并在其中添加注释：

1
2
3
4
5
6
"""
This is a comment
written in
more than just one line
"""
print("Hello, World!")

Python 变量

创建变量

变量是存放数据值的容器。

与其他编程语言不同，Python 没有声明变量的命令。（弱数据类型，与Java强数据类型不同，Java需显示声明数据的类型）

首次为其赋值时，才会创建变量。

1
2
3
4
x = 5
y = "John"
print(x)
print(y)

Python 变量不需要使用任何特定类型声明，甚至可以在设置后更改其类型。

1
2
3
x = 4 # x 是 int 类型
x = "Sally" # x 现在是 str 类型
print(x)

字符串变量可以使用单引号或双引号进行声明：

1
2
3
x = "John"
# 是相同的
x = 'John'

变量名称

变量可以使用短名称（如 x 和 y）或更具描述性的名称（age、carname、total_volume）。

Python 变量命名规则：

  • 变量名必须以字母或下划线字符开头

  • 变量名称不能以数字开头

  • 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）

  • 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 合法的变量名:
    myvar = "John"
    my_var = "John"
    _my_var = "John"
    myVar = "John"
    MYVAR = "John"
    myvar2 = "John"

    # 非法变量名:
    2myvar = "John"
    my-var = "John"
    my var = "John"

请记住，变量名称区分大小写

向多个变量赋值

Python 允许您在一行中为多个变量赋值：

1
2
3
4
x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

您可以在一行中为多个变量分配相同的值：

1
2
3
4
x = y = z = "Orange"
print(x)
print(y)
print(z)

输出变量

Python 的 print语句通常用于输出变量。

如需结合文本和变量，Python 使用 + 字符:

1
2
x = "awesome"
print("Python is " + x)

您还可以使用 + 字符将变量与另一个变量相加：

1
2
3
4
x = "Python is "
y = "awesome"
z =  x + y
print(z)

对于数字，+ 字符用作数学运算符:

1
2
3
x = 5
y = 10
print(x + y)

如果您尝试组合字符串和数字，Python 会给出错误（与Java和JavaScript中会做字符串的拼接不同）

全局变量

在函数外部创建的变量（如上述所有实例所示）称为全局变量。

全局变量可以被函数内部和外部的每个人使用。

1
2
3
4
5
6
x = "awesome"

def myfunc():
  print("Python is " + x)

myfunc()

如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。

1
2
3
4
5
6
7
8
9
x = "awesome"

def myfunc():
  x = "fantastic"
  print("Python is " + x)

myfunc()

print("Python is " + x)

global 关键词

通常，在函数内部创建变量时，该变量是局部变量，只能在该函数内部使用。

要在函数内部创建全局变量，您可以使用global关键字。

1
2
3
4
5
6
7
def myfunc():
	global x
	x = "fantastic"

myfunc()

print("Python is " + x)

另外，如果要在函数内部更改全局变量，请使用 global 关键字。

1
2
3
4
5
6
7
8
9
x = "awesome"

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)

Python 数据类型

内置数据类型

在编程中，数据类型是一个重要的概念。

变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。

在这些类别中，Python 默认拥有以下内置数据类型：

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

获取数据类型

您可以使用 type() 函数获取任何对象的数据类型:

1
2
x = 5
print(type(x))

设置数据类型

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

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

设定特定的数据类型

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

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

Python 数值类型

Python 数值

Python 中有三种数值类型:

  • int
  • float
  • complex

为变量赋值时，将创建数值类型的变量:

1
2
3
x = 1    # int
y = 2.8  # float
z = 1j   # complex

Int

Int 或整数是完整的数字，正数或负数，没有小数，长度不限。

1
2
3
4
5
6
7
x = 1
y = 35656222554887711
z = -3255522

print(type(x))
print(type(y))
print(type(z))

Float

浮动或”浮点数”是包含小数的正数或负数。

1
2
3
4
5
6
7
x = 1.10
y = 1.0
z = -35.59

print(type(x))
print(type(y))
print(type(z))

浮点数也可以是带有”e”的科学数字，表示 10 的幂。

1
2
3
4
5
6
7
x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))

复数

复数用 “j” 作为虚部编写:

1
2
3
4
5
6
7
x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))

类型转换

您可以使用 int(), float(), complex()方法从一种类型转换为另一种类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
x = 1    # int
y = 2.8  # float
z = 1j   # complex

# 从 int 转换为 float:
a = float(x)

# 从浮点数转换为整数:
b = int(y)

# 从 int 转换为 complex:
c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

注释: 您无法将复数转换为其他数字类型。

随机数

Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：

1
2
3
import random

print(random.randrange(1, 10))

Python 类型转换

指定变量类型

有时您可能需要为变量指定类型。这可以通过类型转换来完成。 Python 是一门面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。

因此，使用构造函数完成在 python 中的转换:

  • int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
  • float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
  • str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 整数:
x = int(1)   # x 将是 1
y = int(2.8) # y 将是 2
z = int("3") # z 将是 3

# 浮点数:
x = float(1)     # x 将是 1.0
y = float(2.8)   # y 将是 2.8
z = float("3")   # z 将是 3.0
w = float("4.2") # w 将是 4.2

# 字符串:
x = str("s1") # x 将是 's1'
y = str(2)    # y 将是 '2'
z = str(3.0)  # z 将是 '3.0'

Python 字符串

字符串字面量

python 中的字符串字面量由单引号或双引号括起。

‘hello’ 等同于 “hello”.

您可以使用 print() 函数显示字符串字面量:

1
2
print("Hello")
print('Hello')

用字符串向变量赋值

通过使用变量名称后跟等号和字符串，可以把字符串赋值给变量:

1
2
a = "Hello"
print(a)

多行字符串

您可以使用三个引号将多行字符串赋值给变量:

1
2
3
4
5
6
7
8
9
10
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)

Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.

或三个单引号:

1
2
3
4
5
6
7
8
9
10
a = '''Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.'''
print(a)

Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.

注释: 在结果中，换行符插入与代码中相同的位置.

字符串是数组

像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。

但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。

方括号可用于访问字符串的元素。

1
2
3
# 获取位置 1 处的字符（请记住第一个字符的位置为 0）：
a = "Hello, World!"
print(a[1])

裁切

您可以使用裁切语法返回一定范围的字符。

指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。

1
2
3
# 获取从位置 2 到位置 5（不包括）的字符：
b = "Hello, World!"
print(b[2:5])

负的索引（从-1开始）

使用负索引从字符串末尾开始切片：

1
2
3
# 获取从位置 5 到位置 1 的字符，从字符串末尾开始计数：
b = "Hello, World!"
print(b[-5:-2])

字符串长度

如需获取字符串的长度，请使用 len() 函数。

1
2
a = "Hello, World!"
print(len(a))

字符串方法

Python 有一组可用于字符串的内置方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# strip() 方法删除开头和结尾的空白字符：
a = " Hello, World! "
print(a.strip()) # returns "Hello, World!"

# lower() 返回小写的字符串：
a = "Hello, World!"
print(a.lower())

# upper() 方法返回大写的字符串：
a = "Hello, World!"
print(a.upper())

# replace() 用另一段字符串来替换字符串：
a = "Hello, World!"
print(a.replace("H", "J"))

# split() 方法在找到分隔符的实例时将字符串拆分为子字符串：
a = "Hello, World!"
print(a.split(",")) # 返回 ['Hello', ' World!']

检查字符串

如需检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in关键字。

1
2
3
txt = "The rain in Spain stays mainly in the plain"
x = "ain" in txt
print(x)

字符串级联（串联）

如需串联或组合两个字符串，您可以使用 + 运算符。

1
2
3
4
a = "Hello"
b = "World"
c = a + b
print(c)

字符串格式

正如在 Python 变量一章中所学到的，我们不能像这样组合字符串和数字:

1
2
3
age = 36
txt = "My name is John, I am " + age
print(txt) # 报错

但是我们可以使用 format() 方法组合字符串和数字！

format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

1
2
3
age = 36
txt = "My name is John, and I am {}"
print(txt.format(age))

format() 方法接受不限数量的参数，并放在各自的占位符中：

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

您可以使用索引号 {0} 来确保参数被放在正确的占位符中：

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

转义字符

要在字符串中插入非法字符，请使用转义字符。

转义字符是反斜杠 \ 后跟要插入的字符。

非法字符的一个例子是双引号括起来的字符串中的双引号：

1
txt = "We are the so-called "Vikings" from the north." # 报错

要解决此问题，请使用转义字符 \"：

1
txt = "We are the so-called \"Vikings\" from the north."

Python 中使用的其他转义字符：

代码 结果
' Single Quote
\ Backslash
\n New Line
\r Carriage Return
\t Tab
\b Backspace
\f Form Feed
\ooo Octal value
\xhh Hex value

字符串方法

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 布尔值

布尔表示两值之一: True 或 False.

布尔值

在编程中，您通常需要知道表达式是 True 或 False。

您可以计算 Python 中的任何表达式，并获得两个答案之一，即True 或 False。

比较两个值时，将对表达式求值，Python 返回布尔值答案：

1
2
3
print(10 > 9)
print(10 == 9)
print(10 < 9

当在 if 语句中运行条件时，Python 返回 True 或 False:

1
2
3
4
5
6
7
a = 200
b = 33

if b > a:
  print("b is greater than a")
else:
  print("b is not greater than a")

评估值和变量

bool()函数可让您评估任何值，并为您返回 True 或 False

1
2
print(bool("Hello"))
print(bool(15))

大多数值都为 True

如果有某种内容，则几乎所有值都将评估为 True。

除空字符串外，任何字符串均为 True。

除 0 外，任何数字均为 True。

除空列表外，任何列表、元组、集合和字典均为 True。

1
2
3
bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])

某些值为 False

实际上，除空值（例如 (), [], {}, "", 数字 0, 和值 None）外，没有多少值会被评估为 False。 当然，值 False 的计算结果为 False。

1
2
3
4
5
6
7
bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

在这种情况下，一个值或对象的计算结果为 False，即如果对象由带有 len 函数的类生成的，且该函数返回 0 或 False：

1
2
3
4
5
6
class myclass():
  def __len__(self):
    return 0

myobj = myclass()
print(bool(myobj))

函数可返回布尔

可以创建返回布尔值的函数

1
2
3
4
def myFunction() :
  return True

print(myFunction())

Python 还有很多返回布尔值的内置函数，例如 isinstance() 函数，该函数可用于确定对象是否具有某种数据类型：

1
2
x = 200
print(isinstance(x, int))

Python 运算符

Python 运算符

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

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

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

Python 算术运算符

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

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

Python 赋值运算符

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

运算符 实例 等同于
= 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

Python 比较运算符

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

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

Python 逻辑运算符

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

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

Python 身份运算符

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

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

Python 成员运算符

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

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

Python 位运算符

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

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

Python 列表

Python 集合（数组）

Python 编程语言中有四种集合数据类型：

  • 列表（List） 是一种有序和可更改的集合。允许重复的成员。
  • 元组（Tuple） 是一种有序且不可更改的集合。允许重复的成员。
  • 集合（Set） 是一个无序和无索引的集合。没有重复的成员。
  • 词典（Dictionary） 是一个无序，可变和有索引的集合。没有重复的成员。

选择集合类型时，了解该类型的属性很有用。

为特定数据集选择正确的类型可能意味着保留含义，并且可能意味着提高效率或安全性。

列表

列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。

创建列表

1
2
thislist = ["apple", "banana", "cherry"]
print(thislist)

访问列表

1
2
thislist = ["apple", "banana", "cherry"]
print(thislist[1])

负的索引

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

1
2
thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

索引范围

您可以通过指定范围的起点和终点来指定索引范围。

指定范围后，返回值将是包含指定项目的新列表。

1
2
3
# 返回第三、第四、第五项：
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

通过省略起始值，范围将从第一项开始：

1
2
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])

通过省略结束值，范围将继续到列表的末尾：

1
2
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:])

负指数范围

如果要从列表末尾开始搜索，请指定负索引：

1
2
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1])

更改项目值

如需更改特定项目的值，请引用索引号：

1
2
3
thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist)

遍历列表

您可以使用 for 循环遍历列表项：

1
2
3
thislist = ["apple", "banana", "cherry"]
for x in thislist:
  print(x)

检查项目是否存在

如需确定列表中是否存在指定的项，请使用 in 关键字：

1
2
3
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
  print("Yes, 'apple' is in the fruits list")

列表长度

如需确定列表中有多少项，请使用 len() 方法:

1
2
thislist = ["apple", "banana", "cherry"]
print(len(thislist))

添加项目

如需将项目添加到列表的末尾，请使用 append() 方法：

1
2
3
thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

要在指定的索引处添加项目，请使用 insert() 方法：

1
2
3
thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)

删除项目

有几种方法可以从列表中删除项目：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# remove() 方法删除指定的项目：
thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

# pop() 方法删除指定的索引（如果未指定索引，则删除最后一项）：
thislist = ["apple", "banana", "cherry"]
thislist.pop()
print(thislist)

# del 关键字删除指定的索引：
thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)

# del 关键字也能完整地删除列表：
thislist = ["apple", "banana", "cherry"]
del thislist

# clear() 方法清空列表：
thislist = ["apple", "banana", "cherry"]
thislist.clear()
print(thislist)

复制列表

您只能通过键入 list2 = list1来复制列表，因为：list2 将只是对 list1 的引用, list1 中所做的更改也将自动在 list2 中进行。

有一些方法可以进行复制，一种方法是使用内置的 List 方法 copy()。

1
2
3
thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

制作副本的另一种方法是使用内建的方法 list()。

1
2
3
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

合并两个列表

在 Python 中，有几种方法可以连接或串联两个或多个列表。

最简单的方法之一是使用 + 运算符。

1
2
3
4
5
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list3 = list1 + list2
print(list3)

连接两个列表的另一种方法是将 list2 中的所有项一个接一个地追加到 list1 中：

1
2
3
4
5
6
7
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
  list1.append(x)

print(list1)

或者，您可以使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中：

1
2
3
4
5
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

list() 构造函数

也可以使用 list() 构造函数创建一个新列表。

1
2
thislist = list(("apple", "banana", "cherry")) # 注意双圆括号
print(thislist)

列表方法

Python 有一组可以在列表上使用的内建方法。

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

Python 元组

元组（Tuple）

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。

创建元组

1
2
thistuple = ("apple", "banana", "cherry")
print(thistuple)

访问元组

1
2
thistuple = ("apple", "banana", "cherry")
print(thistuple[1])

负索引

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

1
2
thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])

索引范围

您可以通过指定范围的起点和终点来指定索引范围。

指定范围后，返回值将是带有指定项目的新元组。

1
2
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])

注释: 搜索将从索引 2（包括）开始，到索引 5（不包括）结束。

Range of Negative Indexes

如果要从元组的末尾开始搜索，请指定负索引：

1
2
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])

更改元组值

创建元组后，您将无法更改其值。元组是不可变的，或者也称为恒定的。

但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。

1
2
3
4
5
6
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

遍历元组

您可以使用 for 循环遍历元组项目。

1
2
3
thistuple = ("apple", "banana", "cherry")
for x in thistuple:
  print(x)

检查项目是否存在

要确定元组中是否存在指定的项，请使用 in 关键字：

1
2
3
thistuple = ("apple", "banana", "cherry")
if "apple" in thistuple:
  print("Yes, 'apple' is in the fruits tuple")

元组长度

要确定元组有多少项，请使用 len() 方法：

1
2
thistuple = ("apple", "banana", "cherry")
print(len(thistuple))

添加项目

元组一旦创建，您就无法向其添加项目。元组是不可改变的。

创建有一个项目的元组

如需创建仅包含一个项目的元组，您必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。

1
2
3
4
5
6
7
# 单项元组，别忘了逗号：
thistuple = ("apple",)
print(type(thistuple))

#NOT a tuple
thistuple = ("apple")
print(type(thistuple))

删除项目

注释: 您无法删除元组中的项目。

元组是不可更改的，因此您无法从中删除项目，但您可以完全删除元组:

1
2
3
4
# del 关键字可以完全删除元组：
thistuple = ("apple", "banana", "cherry")
del thistuple
print(thistuple) #this will raise an error because the tuple no longer exists

合并两个元组

如需连接两个或多个元组，您可以使用 + 运算符：

1
2
3
4
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
print(tuple3)

tuple() 构造函数

也可以使用 tuple() 构造函数来创建元组。

1
2
thistuple = tuple(("apple", "banana", "cherry")) # 注意双圆括号
print(thistuple)

元组方法

Python 提供两个可以在元组上使用的内建方法。

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

Python 集合

集合（Set）

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

创建集合

1
2
3

thisset = {"apple", "banana", "cherry"}
print(thisset)

访问集合

您无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。

但是您可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

1
2
3
thisset = {"apple", "banana", "cherry"}
for x in thisset:
  print(x)

更改项目

集合一旦创建，您就无法更改项目，但是您可以添加新项目。

Add Items

要将一个项添加到集合，请使用 add() 方法。

要向集合中添加多个项目，请使用 update() 方法。

1
2
3
4
5
6
7
thisset = {"apple", "banana", "cherry"}
thisset.add("orange")
print(thisset)

thisset = {"apple", "banana", "cherry"}
thisset.update(["orange", "mango", "grapes"])
print(thisset)

获取 Set 的长度

要确定集合中有多少项，请使用 len() 方法。

1
2
thisset = {"apple", "banana", "cherry"}
print(len(thisset))

删除项目

要删除集合中的项目，请使用 remove(), 或 discard() 方法。

1
2
3
thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)

注释: 如果要删除的项目不存在，则 remove() 将引发错误。

1
2
3
thisset = {"apple", "banana", "cherry"}
thisset.discard("banana")
print(thisset)

注释: 如果要删除的项目不存在，则 discard() 不会引发错误。

您还可以使用 pop()方法删除项目，但此方法将删除最后一项。请记住，set 是无序的，因此您不会知道被删除的是什么项目。

pop() 方法的返回值是被删除的项目。

1
2
3
4
thisset = {"apple", "banana", "cherry"}
x = thisset.pop()
print(x)
print(thisset)

注释: 集合是无序的，因此在使用 pop() 方法时，您不会知道删除的是哪个项目。

1
2
3
4
5
6
7
8
9
# clear() 方法清空集合：
thisset = {"apple", "banana", "cherry"}
thisset.clear()
print(thisset)

# del 彻底删除集合：
thisset = {"apple", "banana", "cherry"}
del thisset
print(thisset)

合并两个集合

在 Python 中，有几种方法可以连接两个或多个集合。

您可以使用 union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中：

1
2
3
4
5
6
7
8
9
10
11
12
13
# union() 方法返回一个新集合，其中包含两个集合中的所有项目：
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

# update() 方法将 set2 中的项目插入 set1 中：
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)

注释: union() 和 update()都将排除任何重复项。

还有其他方法将两个集合连接起来，并且仅保留重复项，或者永远不保留重复项，请查看此页面底部的集合方法完整列表。

set() 构造函数

也可以使用 set() 构造函数来创建集合。

1
2
thisset = set(("apple", "banana", "cherry")) # 注意双圆括号
print(thisset)

Set 方法

Python 拥有一套能够在集合（set）上使用的内建方法。

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

Python 字典

字典（Dictionary）

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

创建字典

1
2
3
4
5
6
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

访问项目

您可以通过在方括号内引用其键名来访问字典的项目：

1
x = thisdict["model"]

还有一个名为 get() 的方法会给你相同的结果：

1
x = thisdict.get("model")

更改值

您可以通过引用其键名来更改特定项的值：

1
2
3
4
5
6
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict["year"] = 2018

遍历字典

您可以使用 for 循环遍历字典。

循环遍历字典时，返回值是字典的键，但也有返回值的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 逐个打印字典中的所有键名：
for x in thisdict:
  print(x)

# 逐个打印字典中的所有值：
for x in thisdict:
  print(thisdict[x])

# 您还可以使用 values() 函数返回字典的值：
for x in thisdict.values():
  print(x)

# 通过使用 items() 函数遍历键和值：
for x, y in thisdict.items():
  print(x, y)

检查键是否存在

要确定字典中是否存在指定的键，请使用 in 关键字：

1
2
3
4
5
6
7
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
if "model" in thisdict:
  print("Yes, 'model' is one of the keys in the thisdict dictionary")

字典长度

要确定字典有多少项目（键值对），请使用 len() 方法。

1
print(len(thisdict))

添加项目

通过使用新的索引键并为其赋值，可以将项目添加到字典中：

1
2
3
4
5
6
7
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict["color"] = "red"
print(thisdict)

删除项目

有几种方法可以从字典中删除项目：

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
# pop() 方法删除具有指定键名的项：
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.pop("model")
print(thisdict)

# popitem() 方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）：
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.popitem()
print(thisdict)

# del 关键字删除具有指定键名的项目：
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
del thisdict["model"]
print(thisdict)

# clear() 关键字清空字典：
 thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.clear()
print(thisdict)

复制字典

您不能通过键入 dict2 = dict1 来复制字典，因为：dict2 只是对 dict1 的引用， 而 dict1 中的更改也将自动在 dict2 中进行。

有一些方法可以进行复制，一种方法是使用内建的字典方法 copy()。

1
2
3
4
5
6
7
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = thisdict.copy()
print(mydict)

制作副本的另一种方法是使用内建方法 dict()。

1
2
3
4
5
6
7
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = dict(thisdict)
print(mydict)

嵌套字典

词典也可以包含许多词典，这被称为嵌套词典。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
myfamily = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}

或者，如果您想嵌套三个已经作为字典存在的字典：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}

myfamily = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}

dict() 构造函数

也可以使用 dict() 构造函数创建新的字典：

1
2
3
4
thisdict = dict(brand="Ford", model="Mustang", year=1964)
# note that keywords are not string literals
# note the use of equals rather than colon for the assignment
print(thisdict)

字典方法

Python 提供一组可以在字典上使用的内建方法。

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

Python If … Else 语句

Python 条件和 If 语句

Python 支持来自数学的常用逻辑条件：

  • 等于：a == b
  • 不等于：a != b
  • 小于：a < b
  • 小于等于：a <= b
  • 大于：a > b
  • 大于等于：a >= b

这些条件能够以多种方式使用，最常见的是”if 语句”和循环。

if 语句使用 if 关键词来写。

1
2
3
4
a = 33
b = 200
if b > a:
  print("b is greater than a")

缩进

Python 依赖缩进，使用空格来定义代码中的范围。其他编程语言通常使用花括号来实现此目的。

Elif

elif 关键字是 python 对”如果之前的条件不正确，那么试试这个条件”的表达方式。

1
2
3
4
5
6
a = 33
b = 33
if b > a:
 print("b is greater than a")
elif a == b:
 print("a and b are equal")

Else

else 关键字捕获未被之前的条件捕获的任何内容。

1
2
3
4
5
6
7
8
a = 200
b = 33
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")

简写 If

如果只有一条语句要执行，则可以将其与 if 语句放在同一行。

1
if a > b: print("a is greater than b")

简写 If … Else

如果只有两条语句要执行，一条用于 if，另一条用于 else，则可以将它们全部放在同一行：

1
2
3
a = 2
b = 330
print("A") if a > b else print("B")

And

and 关键字是一个逻辑运算符，用于组合条件语句：

1
2
3
4
5
a = 200
b = 33
c = 500
if a > b and c > a:
 print("Both conditions are True")

Or

or 关键字也是逻辑运算符，用于组合条件语句：

1
2
3
4
5
a = 200
b = 33
c = 500
if a > b or a > c:
 print("At least one of the conditions is True")

嵌套 If

您可以在 if 语句中包含 if 语句，这称为嵌套 if 语句。

1
2
3
4
5
6
7
8
x = 41

if x > 10:
 print("Above ten,")
  if x > 20:
    print("and also above 20!")
  else:
    print("but not above 20.")

pass 语句

if 语句不能为空，但是如果您处于某种原因写了无内容的 if 语句，请使用 pass 语句来避免错误。

1
2
3
4
5
a = 33
b = 200

if b > a:
  pass

Python While 循环

Python 循环

Python 有两个原始的循环命令：

  • while 循环
  • for 循环

while 循环

如果使用 while 循环，只要条件为真，我们就可以执行一组语句。

1
2
3
4
i = 1
while i < 6:
  print(i)
  i += 1

注释: 请记得递增 i，否则循环会永远继续。

while 循环需要准备好相关的变量。在这个实例中，我们需要定义一个索引变量 i，我们将其设置为 1。

break 语句

如果使用 break 语句，即使 while 条件为真，我们也可以停止循环：

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

continue 语句

如果使用 continue 语句，我们可以停止当前的迭代，并继续下一个：

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

else 语句

通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块：

1
2
3
4
5
6
i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

Python For 循环

Python For 循环

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

这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。

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

for 循环不需要预先设置索引变量。

循环遍历字符串

甚至连字符串都是可迭代的对象，它们包含一系列的字符：

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

break 语句

通过使用 break 语句，我们可以在循环遍历所有项目之前停止循环：

1
2
3
4
5
6
# 如果 x 是 "banana"，则退出循环：
fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
  if x == "banana":
    break

continue 语句

通过使用 continue 语句，我们可以停止循环的当前迭代，并继续下一个：

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

range() 函数

如需循环一组代码指定的次数，我们可以使用 range() 函数，

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

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

注意： range(10) 不是 0 到 10 的值，而是值 0 到 9。

range() 函数默认 0 为起始值，不过可以通过添加参数来指定起始值： range(3, 10),这意味着值为 3 到 10（但不包括 10）：

1
2
for x in range(2, 6):
  print(x)

range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值： range(2, 30, 3):

1
2
3
# 使用 3 递增序列（默认值为 1）：
for x in range(2, 30, 3):
  print(x)

For 循环中的 Else

for 循环中的 else 关键字指定循环结束时要执行的代码块：

1
2
3
4
for x in range(6):
  print(x)
else:
  print("Finally finished!")

嵌套循环

嵌套循环是循环内的循环。

“外循环”每迭代一次，”内循环”将执行一次：

1
2
3
4
5
6
adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

pass 语句

for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误。

1
2
for x in [0, 1, 2]:
  pass

Python 函数

函数是一种仅在调用时运行的代码块。

您可以将数据（称为参数）传递到函数中。

函数可以把数据作为结果返回。

创建函数

在 Python 中，使用 def 关键字定义函数：

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

调用函数

如需调用函数，请使用函数名称后跟括号：

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

my_function()

参数

信息可以作为参数传递给函数。

参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。

下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：

1
2
3
4
5
6
def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")

在Python文档中，参数 Arguments 通常被缩写为 args。

形式参数或实际参数?

parameter 和 argument 这两个术语可用于同一事物：传递给函数的信息。

从函数的角度来看：

parameter形式参数是函数定义中括号内列出的变量。

argument实际参数是在调用函数时发送给函数的值。

参数个数

默认情况下，必须使用正确数量的参数调用函数。 这意味着如果您的函数需要 2 个参数，则必须使用 2 个参数调用该函数，即不是更多，也不是更少。

1
2
3
4
def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil", "Refsnes")

任意参数 *args

如果您不知道将传递给函数的参数数量，请在函数定义中的参数名称前添加 *。

这样，函数将接收 tuple 元组参数，并可以相应地访问项目：

1
2
3
4
5
# 如果实际参数个数未知，在形式参数名前加一个*：
def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

Arbitrary Arguments 在 Python 文档中通常缩写为 *args。

Keyword Arguments 关键字参数

您还可以使用 key = value 语法发送参数。

这样参数的顺序无关紧要。

1
2
3
4
def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

短语 Keyword Arguments 在 Python 文档中通常缩写为 kwargs。

任意关键字参数 **kwargs

如果您不知道将传递给函数的关键字实际参数的数量，请在函数定义中的形式参数名称前添加两个星号：**。< /p>

这样，函数将接收一个dictionary 字典参数，并可以相应地访问项目：

1
2
3
4
5
# 如果关键字实参个数未知，在参数名前加一个双**：
def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

Arbitrary Kword Arguments 在 Python 文档中通常缩写为 **kwargs。

默认参数值

下面的例子展示如何使用默认参数值。

如果我们调用了不带参数的函数，则使用默认值：

1
2
3
4
5
6
7
def my_function(country = "Norway"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

以 List 传参

您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。

例如，如果您将 List 作为参数发送，它到达函数时仍将是 List（列表）：

1
2
3
4
5
6
7
def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

返回值

如需使函数返回值，请使用 return 语句：

1
2
3
4
5
6
def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

pass 语句

函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。

1
2
def myfunction():
  pass

递归

Python 也接受函数递归，这意味着定义的函数能够调用自身。

递归是一种常见的数学和编程概念。它意味着函数调用自身。这样做的好处是可以循环访问数据以达成结果。

开发人员应该非常小心递归，因为它可以很容易地编写一个永不终止的，或者使用过量内存或处理器能力的函数。但是，在被正确编写后，递归可能是一种非常有效且数学上优雅的编程方法。

在这个例子中，tri_recursion() 是我们定义为调用自身 (“recurse”) 的函数。 我们使用 k 变量作为数据，每次递归时递减(-1)。 当条件不大于 0 时（比如当它为 0 时），递归结束。

对于新的开发人员来说，可能需要一些时间来搞清楚其工作原理，最好的方法是测试并修改它。

1
2
3
4
5
6
7
8
9
10
def tri_recursion(k):
  if(k > 0):
    result = k + tri_recursion(k - 1)
    print(result)
  else:
    result = 0
  return result

print("\n\nRecursion Example Results")
tri_recursion(6)

Python Lambda 函数

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。

语法

1
lambda arguments : expression
1
2
3
# 将10添加到参数 a，并返回结果：
x = lambda a : a + 10
print(x(5))

lambda 函数可接受任意数量的参数：

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

为何使用 Lambda 函数?

当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。

假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字：

1
2
def myfunc(n):
  return lambda a : a * n

使用该函数定义来创建一个总是使所发送数字加倍的函数：

1
2
3
4
5
6
def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

如果在短时间内需要匿名函数，请使用 lambda 函数。

Python 数组

请注意，Python 没有内置对数组的支持，但可以使用 Python 列表代替。

数组

数组用于在单个变量中存储多个值：

1
cars = ["Ford", "Volvo", "BMW"]

什么是数组?

数组是一种特殊变量，能够一次包含多个值。

如果您有一个项目列表（例如，汽车品牌列表），将牌子存储在单个变量中可能如下所示：

1
2
3
car1 = "Ford"
car2 = "Volvo"
car3 = "BMW"

但是，如果您想遍历这些品牌并找到特定的汽车品牌怎么办?如果不是 3 辆车，而是 300 辆怎么办?

解决方案是数组！

数组可以在单个名称下保存多个值，您可以通过引用索引号来访问这些值。

访问数组元素

通过索引号来引用数组元素。

1
x = cars[0]

修改首个数组项目的值：

1
cars[0] = "Toyota"

数组长度

使用 len() 方法来返回数组的长度（数组中的元素数量）。

1
x = len(cars)

注释: 数组长度总是比最高的数组索引大一个。

循环数组元素

您可以使用 for in 循环遍历数组的所有元素。

1
2
for x in cars:
  print(x)

添加数组元素

您可以使用 append() 方法把元素添加到数组中。

1
cars.append("Honda")

删除数组元素

您可以使用 pop() 方法从数组中删除元素。

1
cars.pop(1)

您也可以使用 remove() 方法从数组中删除元素。

1
cars.remove("Volvo")

注释: 列表的 remove() 方法仅删除首次出现的指定值。

数组方法

Python 提供一组可以在列表或数组上使用的内建方法。

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

注释: Python 没有内置对数组的的支持，但可以使用 Python 列表代替。

Python 类和对象

Python 是一种面向对象的编程语言。

Python 中的几乎所有东西都是对象，拥有属性和方法。

类（Class）类似对象构造函数，或者是用于创建对象的”蓝图”。

创建类

如需创建类，请使用 class 关键字：

1
2
class MyClass:
  x = 5

创建对象

现在我们可以使用名为 myClass 的类来创建对象：

1
2
p1 = MyClass()
print(p1.x)

init() 函数

上面的例子是最简单形式的类和对象，在实际应用程序中并不真正有用。

要理解类的含义，我们必须先了解内置的 init() 函数。

所有类都有一个名为 init() 的函数，它始终在启动类时执行。

使用 init() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：

1
2
3
4
5
6
7
8
9
10
# 创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值：
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

注释: 每次使用类创建新对象时，都会自动调用 init() 函数。

对象方法

对象也可以包含方法。对象中的方法是属于该对象的函数。

让我们在 Person 类中创建方法：

1
2
3
4
5
6
7
8
9
10
11
# 插入一个打印问候语的函数，并在 p1 对象上执行它：
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("John", 36)
p1.myfunc()

注释: self 参数是对类的当前实例的引用，用于访问属于该类的变量。

self 参数

self 参数是对类的当前实例的引用，用于访问属于该类的变量。

它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数：

1
2
3
4
5
6
7
8
9
10
11
# 使用单词 mysillyobject 和 abc 代替 self：
class Person:
  def __init__(mysillyobject, name, age):
    mysillyobject.name = name
    mysillyobject.age = age

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()

修改对象属性

您可以这样修改对象的属性：

1
p1.age = 40

删除对象属性

您可以使用 del 关键字删除对象的属性：

1
del p1.age

删除对象

使用 del 关键字删除对象：

1
del p1

pass 语句

class 类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。

1
2
class Person:
  pass

Python 继承

继承允许我们定义继承另一个类的所有方法和属性的类。

父类是继承的类，也称为基类。

子类是从另一个类继承的类，也称为派生类。

创建父类

任何类都可以是父类，因此语法与创建任何其他类相同：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 创建一个名为 Person 的类，其中包含 firstname 和 lastname 属性以及 printname 方法：
class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

#Use the Person class to create an object, and then execute the printname method:

x = Person("John", "Doe")
x.printname()

创建子类

要创建从其他类继承功能的类，请在创建子类时将父类作为参数发送：

1
2
3
# 创建一个名为 Student 的类，它将从 Person 类继承属性和方法：
class Student(Person):
  pass

注释: 如果您不想向该类添加任何其他属性或方法，请使用 pass 关键字。

现在，Student 类拥有与 Person 类相同的属性和方法。

1
2
3
# 使用 Student 类创建一个对象，然后执行 printname 方法：
x = Student("Mike", "Olsen")
x.printname()

添加 init() 函数

到目前为止，我们已经创建了一个子类，它继承了父类的属性和方法。

我们想要把 init() 函数添加到子类（而不是 pass 关键字）。

注释: 每次使用类创建新对象时，都会自动调用 __init__() 函数。

1
2
3
4
# 为 Student 类添加 __init__() 函数：
class Student(Person):
  def __init__(self, fname, lname):
    #add properties etc.

当您添加 __init__() 函数时，子类将不再继承父的 __init__() 函数。

注释: 子的 init() 函数会覆盖对父的 init() 函数的继承。

如需保持父的 init() 函数的继承，请添加对父的 init() 函数的调用：

1
2
3
class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

现在，我们已经成功添加了 init() 函数，并保留了父类的继承，我们准备好在 init() 函数中添加功能了。

使用 super() 函数

Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性：

1
2
3
class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。

添加属性

1
2
3
4
5
# 把名为 graduationyear 的属性添加到 Student 类：
class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)
    self.graduationyear = 2019

在这例子中，2019 年应该是一个变量，并在创建 student 对象时传递到 Student 类。为此，请在 init() 函数中添加另一个参数：

1
2
3
4
5
6
7
# 添加 year 参数，并在创建对象时传递正确的年份：
class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

x = Student("Mike", "Olsen", 2019)

添加方法

1
2
3
4
5
6
7
8
# 把名为 welcome 的方法添加到 Student 类：
class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

  def welcome(self):
    print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

如果您在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承。

Python 迭代器

迭代器是一种对象，该对象包含值的可计数数字。

迭代器是可迭代的对象，这意味着您可以遍历所有值。

从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 iter() 和 next()。

迭代器 VS 可迭代对象（Iterable）

列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

所有这些对象都有用于获取迭代器的 iter() 方法：

1
2
3
4
5
6
7
# 从元组返回一个迭代器，并打印每个值：
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

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

甚至连字符串都是可迭代的对象，并且可以返回迭代器：

1
2
3
4
5
6
7
8
9
10
# 字符串也是可迭代的对象，包含一系列字符：
mystr = "banana"
myit = iter(mystr)

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

遍历迭代器

我们也可以使用 for 循环遍历可迭代对象：

1
2
3
4
5
# 迭代元组的值：
mytuple = ("apple", "banana", "cherry")

for x in mytuple:
  print(x)
1
2
3
4
5
# 迭代字符串中的字符：
mystr = "banana"

for x in mystr:
  print(x)

for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。

创建迭代器

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：
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() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 在 20 个迭代之后停止：
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)

Python 作用域

变量仅在创建区域内可用。这称为作用域。

局部作用域

在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。

1
2
3
4
5
6
# 在函数内部创建的变量在该函数内部可用：
def myfunc():
  x = 300
  print(x)

myfunc()

函数内部的函数

如上例中所示，变量 x 在函数外部不可用，但对于函数内部的任何函数均可用：

1
2
3
4
5
6
7
def myfunc():
  x = 300
  def myinnerfunc():
    print(x)
  myinnerfunc()

myfunc()

全局作用域

在 Python 代码主体中创建的变量是全局变量，属于全局作用域。

全局变量在任何范围（全局和局部）中可用。

1
2
3
4
5
6
7
8
9
# 在函数外部创建的变量是全局变量，任何人都可以使用：
x = 300

def myfunc():
  print(x)

myfunc()

print(x)

命名变量

如果在函数内部和外部操作同名变量，Python 会将它们视为两个单独的变量，一个在全局范围内可用（在函数外部），而一个在局部范围内可用（在函数内部）：

1
2
3
4
5
6
7
8
9
10
# 该函数将打印局部变量 x，然后代码还会打印全局变量 x：
x = 300

def myfunc():
  x = 200
  print(x)

myfunc()

print(x)

Global 关键词

如果您需要创建一个全局变量，但被卡在本地作用域内，则可以使用 global 关键字。

global 关键字使变量成为全局变量。

1
2
3
4
5
6
7
8
# 如果使用 global 关键字，则该变量属于全局范围：
def myfunc():
  global x
  x = 300

myfunc()

print(x)

另外，如果要在函数内部更改全局变量，也请使用 global 关键字。

1
2
3
4
5
6
7
8
9
10
# 要在函数内部更改全局变量的值，请使用 global 关键字引用该变量：
x = 300

def myfunc():
  global x
  x = 200

myfunc()

print(x)

Python 模块

什么是模块?

请思考与代码库类似的模块。

模块是包含一组函数的文件，希望在应用程序中引用。

创建模块

如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中：

1
2
3
# 在名为 mymodule.py 的文件中保存代码：
def greeting(name):
  print("Hello, " + name)

使用模块

现在，我们就可以用 import 语句来使用我们刚刚创建的模块：

1
2
3
4
# 导入名为 mymodule 的模块，并调用 greeting 函数：
import mymodule

mymodule.greeting("Jonathan")

注释: 如果使用模块中的函数时，请使用以下语法： module_name.function_name

模块中的变量

模块可以包含已经描述的函数，但也可以包含各种类型的变量（数组、字典、对象等）：

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

1
2
3
4
5
person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
}
1
2
3
4
5
# 导入名为 mymodule 的模块，并访问 person1 字典：
import mymodule

a = mymodule.person1["age"]
print(a)

为模块命名

您可以随意对模块文件命名，但是文件扩展名必须是 .py。

重命名模块

您可以在导入模块时使用 as 关键字创建别名：

1
2
3
4
5
# 为 mymodule 创建别名 mx：
import mymodule as mx

a = mx.person1["age"]
print(a)

内建模块

Python 中有几个内建模块，您可以随时导入。

1
2
3
4
5
# 导入并使用 platform 模块：
import platform

x = platform.system()
print(x)

使用 dir() 函数

有一个内置函数可以列出模块中的所有函数名（或变量名）。dir() 函数：

1
2
3
4
5
# 列出属于 platform 模块的所有已定义名称：
import platform

x = dir(platform)
print(x)

注释: The dir() 函数可用于所有模块，也可用于您自己创建的模块。

从模块导入

您可以使用 from 关键字选择仅从模块导入部件。

1
2
3
4
5
6
7
8
9
# 名为 mymodule 的模块拥有一个函数和一个字典：
def greeting(name):
  print("Hello, " + name)

person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
}
1
2
3
4
# 仅从模块导入 person1 字典：
from mymodule import person1

print (person1["age"])

注释: 在使用 from 关键字导入时，请勿在引用模块中的元素时使用模块名称。示例：person1[“age”]，而不是 mymodule.person1[“age”]。

Python 日期时间

Python 日期

Python 中的日期不是其自身的数据类型，但是我们可以导入名为 datetime 的模块，把日期视作日期对象进行处理。

1
2
3
4
5
# 导入 datetime 模块并显示当前日期：
import datetime

x = datetime.datetime.now()
print(x)

日期输出

如果我们执行上面的代码，结果将是：

1
2023-10-02 04:19:15.475555

日期包含年、月、日、小时、分钟、秒和微秒。

datetime 模块有许多方法可以返回有关日期对象的信息。

以下是一些例子，您将在本章稍后详细学习它们：

1
2
3
4
5
6
7
# 返回 weekday 的名称和年份：
import datetime

x = datetime.datetime.now()

print(x.year)
print(x.strftime("%A"))

创建日期对象

如需创建日期，我们可以使用 datetime 模块的 datetime() 类（构造函数）。

datetime() 类需要三个参数来创建日期：年、月、日。

1
2
3
4
5
6
# 创建日期对象：
import datetime

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

print(x)

datetime() 类还接受时间和时区（小时、分钟、秒、微秒、tzone）的参数，不过它们是可选的，默认值为 0，（时区默认为 None）。

strftime() 方法

datetime 对象拥有把日期对象格式化为可读字符串的方法。

该方法称为 strftime()，并使用一个 format 参数来指定返回字符串的格式：

1
2
3
4
5
6
# 显示月份的名称：
import datetime

x = datetime.datetime(2018, 6, 1)

print(x.strftime("%B"))

所有合法格式代码的参考：

指令 描述 实例
%a Weekday，短版本 Wed
%A Weekday，完整版本 Wednesday
%w Weekday，数字 0-6，0 为周日 3
%d 日，数字 01-31 31
%b 月名称，短版本 Dec
%B 月名称，完整版本 December
%m 月，数字01-12 12
%y 年，短版本，无世纪 18
%Y 年，完整版本 2018
%H 小时，00-23 17
%I 小时，00-12 05
%p AM/PM PM
%M 分，00-59 41
%S 秒，00-59 08
%f 微妙，000000-999999 548513
%z UTC 偏移 +0100
%Z 时区 CST
%j 天数，001-366 365
%U 周数，每周的第一天是周日，00-53 52
%W 周数，每周的第一天是周一，00-53 52
%c 日期和时间的本地版本 Mon Dec 31 17:41:00 2018
%x 日期的本地版本 12/31/18
%X 时间的本地版本 17:41:00
%% A % character %

Python 数学运算

Python 有一组内置的数学函数，包括一个扩展的数学模块，可让您对数字执行数学任务。

内置数学函数

min() 和 max() 函数可用于在 一个可迭代的：

1
2
3
4
5
x = min(5, 10, 25)
y = max(5, 10, 25)

print(x)
print(y)

abs() 函数返回指定数字的绝对（正）值：

1
2
3
x = abs(-7.25)

print(x)

pow(*x*, *y*) 函数返回 x 的 y 次方 (x y)。

1
2
3
4
# 返回 4 的 3 次方（与 4 * 4 * 4 相同）：
x = pow(4, 3)

print(x)

数学模块

Python 还有一个名为 math 的内置模块，它扩展了数学函数列表。

要使用它，你必须导入 math 模块：

1
import math

导入math模块后，就可以开始使用模块的方法和常量了。

math.sqrt() 方法例如，返回一个数的平方根：

1
2
3
4
5
import math

x = math.sqrt(64)

print(x)

math.ceil() 方法将数字向上舍入到最接近的整数，math.floor() 方法将数字向下舍入到最接近的整数，并返回结果：

1
2
3
4
5
6
7
import math

x = math.ceil(1.4)
y = math.floor(1.4)

print(x) # 返回 2
print(y) # 返回 1

math.pi 常量，返回 PI (3.14…) 的值：

1
2
3
4
5
import math

x = math.pi

print(x)

Python JSON

JSON 是用于存储和交换数据的语法。

JSON 是用 JavaScript 对象表示法（JavaScript object notation）编写的文本。

Python 中的 JSON

Python 有一个名为 json 的内置包，可用于处理 JSON 数据。

导入 json 模块：

1
import json

解析 JSON - 把 JSON 转换为 Python

若有 JSON 字符串，则可以使用 json.loads() 方法对其进行解析。

结果将是 Python 字典。

把 JSON 转换为 Python：

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

# 一些 JSON:
x =  '{ "name":"John", "age":30, "city":"New York"}'

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

# 结果是一个 Python 字典:
print(y["age"])

把 Python 转换为 JSON

若有 Python 对象，则可以使用 json.dumps() 方法将其转换为 JSON 字符串。

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

# 一个 Python 对象（字典）:
x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}

# 转换成 JSON:
y = json.dumps(x)

# 结果是一个 JSON 字符串:
print(y)

您可以把以下类型的 Python 对象转换为 JSON 字符串：

  • dict
  • list
  • tuple
  • string
  • int
  • float
  • True
  • False
  • None
1
2
3
4
5
6
7
8
9
10
11
import json

print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))

当 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

转换包含所有合法数据类型的 Python 对象：

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

x = {
  "name": "John",
  "age": 30,
  "married": True,
  "divorced": False,
  "children": ("Ann","Billy"),
  "pets": None,
  "cars": [
    {"model": "BMW 230", "mpg": 27.5},
    {"model": "Ford Edge", "mpg": 24.1}
  ]
}

print(json.dumps(x))

格式化结果

上面的实例打印一个 JSON 字符串，但它不是很容易阅读，没有缩进和换行。

json.dumps() 方法提供了令结果更易读的参数：

1
2
# 使用 indent 参数定义缩进数：
json.dumps(x, indent=4)

您还可以定义分隔符，默认值为（”, “, “: “），这意味着使用逗号和空格分隔每个对象，使用冒号和空格将键与值分开：

1
2
# 使用 separators 参数来更改默认分隔符：
json.dumps(x, indent=4, separators=(". ", " = "))

对结果排序

json.dumps() 方法提供了对结果中的键进行排序的参数：

1
2
# 使用 sort_keys 参数来指定是否应对结果进行排序：
json.dumps(x, indent=4, sort_keys=True)

Python 正则表达式

RegEx 或正则表达式是形成搜索模式的字符序列。

RegEx 可用于检查字符串是否包含指定的搜索模式。

RegEx 模块

Python 提供名为 re 的内置包，可用于处理正则表达式。

导入 re 模块：

1
import re

Python 中的 RegEx

导入 re 模块后，就可以开始使用正则表达式了：

1
2
3
4
5
# 检索字符串以查看它是否以 "The" 开头并以 "Spain" 结尾：
import re

txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt)

RegEx 函数

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 之间的任何字符的匹配，小写或大写
[+] 在集合中，+、*、.、|、()、$、{} 没有特殊含义，因此 [+] 表示：返回字符串中任何 + 字符的匹配项

findall() 函数

findall() 函数返回包含所有匹配项的列表。

1
2
3
4
5
6
# 打印所有匹配的列表：
import re

txt = "The rain in Spain"
x = re.findall("ai", txt)
print(x)

这个列表以被找到的顺序包含匹配项。

如果未找到匹配项，则返回空列表：

1
2
3
4
5
6
# 如果未找到匹配，则返回空列表：
import re

txt = "The rain in Spain"
x = re.findall("Portugal", txt)
print(x)

search() 函数

search() 函数搜索字符串中的匹配项，如果存在匹配则返回 Match 对象。

如果有多个匹配，则仅返回首个匹配项：

1
2
3
4
5
6
7
# 在字符串中搜索第一个空白字符：
import re

txt = "The rain in Spain"
x = re.search("\s", txt)

print("The first white-space character is located in position:", x.start())

如果未找到匹配，则返回值 None：

1
2
3
4
5
6
# 进行不返回匹配的检索：
import re

txt = "The rain in Spain"
x = re.search("Portugal", txt)
print(x)

split() 函数

split() 函数返回一个列表，其中字符串在每次匹配时被拆分：

1
2
3
4
5
6
# 在每个空白字符处进行拆分：
import re

txt = "The rain in Spain"
x = re.split("\s", txt)
print(x)

您可以通过指定 maxsplit 参数来控制出现次数：

1
2
3
4
5
6
# 仅在首次出现时拆分字符串：
import re

txt = "The rain in Spain"
x = re.split("\s", txt, 1)
print(x)

sub() 函数

sub() 函数把匹配替换为您选择的文本：

1
2
3
4
5
6
# 用数字 9 替换每个空白字符：
import re

txt = "The rain in Spain"
x = re.sub("\s", "9", txt)
print(x)

您可以通过指定 count 参数来控制替换次数：

1
2
3
4
5
6
# 替换前两次出现：
import re

txt = "The rain in Spain"
x = re.sub("\s", "9", txt, 2)
print(x)

Match 对象

Match 对象是包含有关搜索和结果信息的对象。

注释: 如果没有匹配，则返回值 None，而不是 Match 对象。

1
2
3
4
5
6
# 执行会返回 Match 对象的搜索：
import re

txt = "The rain in Spain"
x = re.search("ai", txt)
print(x) #this will print an object

Match 对象提供了用于取回有关搜索及结果信息的属性和方法：

.span() 返回的元组包含了匹配的开始和结束位置
.string 返回传入函数的字符串
.group() 返回匹配的字符串部分

1
2
3
4
5
6
7
8
# 打印首个匹配出现的位置（开始和结束位置）。
# 正则表达式查找以大写 "S" 开头的任何单词：

import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.span())
1
2
3
4
5
6
# 打印传入函数的字符串：
import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.string)
1
2
3
4
5
6
7
# 打印匹配的字符串部分。
# 正则表达式查找以大写 "S" 开头的任何单词：
import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.group())

注释: 如果没有匹配项，则返回值 None，而不是 Match 对象。

Python PIP

什么是 PIP?

PIP 是 Python 包或模块的包管理器。

注释: 如果您使用的是 Python 3.4 或更高版本，则默认情况下会包含 PIP。

什么是包（Package）?

包中包含模块所需的所有文件。

模块是您可以包含在项目中的 Python 代码库。

检查是否已安装 PIP

将命令行导航到 Python 脚本目录所在的位置，然后键入以下内容：

1
2
# 检查 PIP 版本：
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip --version

安装 PIP

如果尚未安装 PIP，可以从此页面下载并安装： https://pypi.org/project/pip/

下载包

下载包非常容易。

打开命令行界面并告诉 PIP 下载您需要的软件包。

将命令行导航到 Python 脚本目录的位置，然后键入以下内容：

1
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip install camelcase

使用包

安装包后，即可使用。

把 “camelcase” 包导入您的项目中。

1
2
3
4
5
6
7
import camelcase

c = camelcase.CamelCase()

txt = "hello world"

print(c.hump(txt))

查找包

在 https://pypi.org/，您可以找到更多的包。

删除包

请使用 uninstall 命令来删除包：

1
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip uninstall camelcase

PIP 包管理器会要求您确认是否需要删除 camelcase 包：

1
2
3
4
5
Uninstalling camelcase-02.1:
  Would remove:
    c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase-0.2-py3.6.egg-info
    c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase\*
Proceed (y/n)?

按 y 键，包就会被删除。

列出包

请使用 list 命令列出系统上安装的所有软件包：

1
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip list

Python Try Except 异常处理

try 块允许您测试代码块以查找错误。

except 块允许您处理错误。

finally 块允许您执行代码，无论 try 和 except 块的结果如何。

异常处理

当我们调用 Python 并发生错误或异常时，通常会停止并生成错误消息。

可以使用 try 语句处理这些异常：

1
2
3
4
5
# try 块将生成异常，因为 x 未定义：
try:
  print(x)
except:
  print("An exception occurred")

由于 try 块引发错误，因此会执行 except 块。

如果没有 try 块，程序将崩溃并引发错误

多个异常

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

1
2
3
4
5
6
7
# 如果 try 块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息：
try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")

Else

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

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")

这对于关闭对象并清理资源非常有用：

1
2
3
4
5
6
7
try:
  f = open("demofile.txt")
  f.write("Lorum Ipsum")
except:
  print("Something went wrong when writing to the file")
finally:
  f.close()

程序可以继续，而且不会打开文件对象。

引发异常

作为 Python 开发者，您可以选择在条件发生时抛出异常。

如需抛出（引发）异常，请使用 raise 关键词。

1
2
3
4
5
# 假如 x 小于 0，则引发异常并终止程序：
x = -1

if x < 0:
  raise Exception("Sorry, no numbers below zero")

raise 关键字用于引发异常。

您能够定义所引发异常的类型、以及打印给用户的文本。

1
2
3
4
5
# 如果 x 不是整数，则引发 TypeError：
x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allowed")

Python 用户输入

用户输入

Python 允许命令行输入。

这意味着我们能够要求用户输入。

Python 3.6 中的方法与 Python 2.7 略有不同。

Python 3.6 使用 input() 方法。

Python 2.7 使用 raw_input() 方法。

下面的例子会询问用户的姓名，当您输入名字时，名字将打印到屏幕上：

1
2
username = input("Enter username:")
print("Username is: " + username)

当执行到 input() 函数时，Python 停止执行，并在用户给出一些输入后继续执行。

Python 字符串格式化

为了确保字符串按预期显示，我们可以使用 format() 方法对结果进行格式化。

字符串 format()

format() 方法允许您格式化字符串的选定部分。

有时文本的一部分是你无法控制的，也许它们来自数据库或用户输入?

要控制此类值，请在文本中添加占位符（花括号 {}），然后通过 format() 方法运行值：

1
2
3
4
# 添加要显示价格的占位符：
price = 49
txt = "The price is {} dollars"
print(txt.format(price))

您可以在花括号内添加参数以指定如何转换值：

1
2
# 将价格格式化为带有两位小数的数字：
txt = "The price is {:.2f} dollars"

多个值

如需使用更多值，只需向 format() 方法添加更多值：

1
print(txt.format(price, itemno, count))

并添加更多占位符：

1
2
3
4
5
quantity = 3
itemno = 567
price = 49
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 = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

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

1
2
3
4
age = 36
name = "John"
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 = "Ford", model = "Mustang"))

后记

相较于Java来说Python在语法上更加简洁精炼