Python篇-Python快速入门

简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。

Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

特点

1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。

2.易于阅读：Python代码定义的更清晰。

3.易于维护：Python的成功在于它的源代码是相当容易维护的。

4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。

5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。

6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。

7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。

8.数据库：Python提供所有主要的商业数据库的接口。

9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。

10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得”脚本化”的能力。

安装

1
2
sudo apt install python
python --version

或者去官网下载

运行

Python 命令行参数

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
usage: /Users/biaoyang/PycharmProjects/python-awsome/venv/bin/python3 [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-b     : issue warnings about str(bytes_instance), str(bytearray_instance)
         and comparing bytes/bytearray with str. (-bb: issue errors)
-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser; also PYTHONDEBUG=x
-E     : ignore PYTHON* environment variables (such as PYTHONPATH)
-h     : print this help message and exit (also --help)
-i     : inspect interactively after running script; forces a prompt even
         if stdin does not appear to be a terminal; also PYTHONINSPECT=x
-I     : isolate Python from the user's environment (implies -E and -s)
-m mod : run library module as a script (terminates option list)
-O     : remove assert and __debug__-dependent statements; add .opt-1 before
         .pyc extension; also PYTHONOPTIMIZE=x
-OO    : do -O changes and also discard docstrings; add .opt-2 before
         .pyc extension
-q     : don't print version and copyright messages on interactive startup
-s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE
-S     : don't imply 'import site' on initialization
-u     : force the stdout and stderr streams to be unbuffered;
         this option has no effect on stdin; also PYTHONUNBUFFERED=x
-v     : verbose (trace import statements); also PYTHONVERBOSE=x
         can be supplied multiple times to increase verbosity
-V     : print the Python version number and exit (also --version)
         when given twice, print more information about the build
-W arg : warning control; arg is action:message:category:module:lineno
         also PYTHONWARNINGS=arg
-x     : skip first line of source, allowing use of non-Unix forms of #!cmd
-X opt : set implementation-specific option. The following options are available:

         -X faulthandler: enable faulthandler
         -X showrefcount: output the total reference count and number of used
             memory blocks when the program finishes or after each statement in the
             interactive interpreter. This only works on debug builds
         -X tracemalloc: start tracing Python memory allocations using the
             tracemalloc module. By default, only the most recent frame is stored in a
             traceback of a trace. Use -X tracemalloc=NFRAME to start tracing with a
             traceback limit of NFRAME frames
         -X showalloccount: output the total count of allocated objects for each
             type when the program finishes. This only works when Python was built with
             COUNT_ALLOCS defined
         -X importtime: show how long each import takes. It shows module name,
             cumulative time (including nested imports) and self time (excluding
             nested imports). Note that its output may be broken in multi-threaded
             application. Typical usage is python3 -X importtime -c 'import asyncio'
         -X dev: enable CPython's "development mode", introducing additional runtime
             checks which are too expensive to be enabled by default. Effect of the
             developer mode:
                * Add default warning filter, as -W default
                * Install debug hooks on memory allocators: see the PyMem_SetupDebugHooks() C function
                * Enable the faulthandler module to dump the Python traceback on a crash
                * Enable asyncio debug mode
                * Set the dev_mode attribute of sys.flags to True
                * io.IOBase destructor logs close() exceptions
         -X utf8: enable UTF-8 mode for operating system interfaces, overriding the default
             locale-aware mode. -X utf8=0 explicitly disables UTF-8 mode (even when it would
             otherwise activate automatically)
         -X pycache_prefix=PATH: enable writing .pyc files to a parallel tree rooted at the
             given directory instead of to the code tree

--check-hash-based-pycs always|default|never:
    control how Python invalidates hash-based .pyc files
file   : program read from script file
-      : program read from stdin (default; interactive mode if a tty)
arg ...: arguments passed to program in sys.argv[1:]

Other environment variables:
PYTHONSTARTUP: file executed on interactive startup (no default)
PYTHONPATH   : ':'-separated list of directories prefixed to the
               default module search path.  The result is sys.path.
PYTHONHOME   : alternate <prefix> directory (or <prefix>:<exec_prefix>).
               The default module search path uses <prefix>/lib/pythonX.X.
PYTHONCASEOK : ignore case in 'import' statements (Windows).
PYTHONUTF8: if set to 1, enable the UTF-8 mode.
PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.
PYTHONFAULTHANDLER: dump the Python traceback on fatal errors.
PYTHONHASHSEED: if this variable is set to 'random', a random value is used
   to seed the hashes of str and bytes objects.  It can also be set to an
   integer in the range [0,4294967295] to get hash values with a
   predictable seed.
PYTHONMALLOC: set the Python memory allocators and/or install debug hooks
   on Python memory allocators. Use PYTHONMALLOC=debug to install debug
   hooks.
PYTHONCOERCECLOCALE: if this variable is set to 0, it disables the locale
   coercion behavior. Use PYTHONCOERCECLOCALE=warn to request display of
   locale coercion and locale compatibility warnings on stderr.
PYTHONBREAKPOINT: if this variable is set to 0, it disables the default
   debugger. It can be set to the callable of your debugger of choice.
PYTHONDEVMODE: enable the development mode.
PYTHONPYCACHEPREFIX: root directory for bytecode cache (pyc) files.

基础语法

编码

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

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

上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白俄罗斯语、马其顿语、俄语、塞尔维亚语。

标识符

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

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

1
2
3
4
5
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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. 单行注释：#
  2. 多行注释可以用多个 # 号，还有 ‘’’ 和 “””：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/python3

# 第一个注释
# 第二个注释

'''
第三注释
第四注释
'''

"""
第五注释
第六注释
"""
print ("Hello, Python!")

行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

以下实例缩进为四个空格:

1
2
3
4
5
if __name__ == '__main__':
    if True:
        print("True")
    else:
        print("False")

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

1
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 </font> 来实现多行语句，例如：

1
2
3
total = item_one + \
        item_two + \
        item_three

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

1
2
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

用户输入

1
2
3
4
if __name__ == '__main__':
    # 用户输入
    name = input('Please enter your name: ')
    print('Hello,', name)

导入模块

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： *from somemodule import

  1. 导入模块
1
2
3
4
5
6
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)
  1. 导入模块中的指定成员
1
2
3
4
from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

基本数据类型

标准数据类型

Python3 中常见的数据类型有：

  • Number（数字）
  • String（字符串）
  • bool（布尔类型）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数) - 复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位。如 1 + 2j、 1.1 + 2.2j
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if __name__ == '__main__':
    # 整数
    integer_number = 10
    print('Integer Number:', integer_number)
    # 布尔类型
    boolean = True
    print('Boolean:', boolean)
    # 浮点数
    float_number = 10.5
    print('Float Number:', float_number)
    # 复数
    complex_number = 1 + 2j
    print('Real Part:', complex_number.real)
    print('Imaginary Part:', complex_number.imag)
    print('Complex Number:', complex_number)

字符串(String)

  • Python 中单引号 ‘ 和双引号 “ 使用完全相同。
  • 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。
  • 转义符 </font>。
  • 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。
  • 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
  • 字符串可以用 + 运算符连接在一起，用 *** 运算符重复。
  • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  • Python 中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
  • 字符串切片 str[start:end]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引。
  • 字符串的切片可以加上步长参数 step，语法格式如下：str[start:end:step]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
if __name__ == '__main__':
    # 字符串
    string = 'Hello, Python!'
    print('String:', string)
    # 字符串长度
    print('String Length:', len(string))
    # 字符串索引
    print('String Index:', string[0])
    # 字符串切片
    print('String Slice:', string[0:5])
    # 指定步长
    print('String Slice:', string[0:5:2])
    # 字符串拼接
    print('String Concatenation:', string + ' I am learning Python.')
    # 转义
    print('Escape:', 'I\'m learning Python.')
    # 原始字符串
    print('Raw String:', r'I\'m learning Python.')

bool(布尔类型)

布尔类型即：True/False

  1. bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。

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
36
37
38
39
if __name__ == '__main__':
    # 布尔类型的值和类型
    a = True
    b = False
    print(type(a))  # <class 'bool'>
    print(type(b))  # <class 'bool'>

    # 布尔类型的整数表现
    print(int(True))  # 1
    print(int(False))  # 0

    # 使用 bool() 函数进行转换
    print(bool(0))  # False
    print(bool(42))  # True
    print(bool(''))  # False
    print(bool('Python'))  # True
    print(bool([]))  # False
    print(bool([1, 2, 3]))  # True

    # 布尔逻辑运算
    print(True and False)  # False
    print(True or False)  # True
    print(not True)  # False

    # 布尔比较运算
    print(5 > 3)  # True
    print(2 == 2)  # True
    print(7 < 4)  # False

    # 布尔值在控制流中的应用
    if True:
        print("This will always print")

    if not False:
        print("This will also always print")

    x = 10
    if x:
        print("x is non-zero and thus True in a boolean context")

List(列表)

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

加号 + 是列表连接运算符，星号 *** 是重复操作。

List 内置了有很多方法，例如 append()、pop() 等等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if __name__ == '__main__':
    # !/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)  # 打印tinylist列表两次
    print(list + tinylist)  # 打印两个列表拼接在一起的结果

    list.append('new')  # 在列表末尾添加一个新元素
    print(list)

Tuple(元组)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。有点类似常量数组。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

元组中的元素类型也可以不相同：

1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    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)  # 连接元组

Set(集合)

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 **set() 而不是 { }，因为 { }** 是用来创建一个空字典。

创建格式：

1
2
3
parame = {value01,value02,...}
或者
set(value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
if __name__ == '__main__':
    # 集合
    set1 = {'a', 'b', 'c', 'd', 'e'}
    set2 = {'b', 'c'}
    print(set1)  # 输出集合，重复的元素会被自动去掉
    print(set2)
    # 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 中不同时存在的元素

字典(字典)

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

1
2
3
4
5
6
7
8
9
10
11
if __name__ == '__main__':
    # 字典
    dict = {}
    dict['one'] = 'This is one'
    dict[2] = 'This is two'
    tinydict = {'name': 'mikey', 'code': 1, 'site': 'www.biadu.com'}
    print(dict['one'])  # 输出键为'one'的值
    print(dict[2])  # 输出键为 2 的值
    print(tinydict)  # 输出完整的字典
    print(tinydict.keys())  # 输出所有键
    print(tinydict.values())  # 输出所有值

bytes类型

在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。

与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：

此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码：

1
x = bytes("hello", encoding="utf-8")

与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。例如：

1
2
3
x = b"hello"
y = x[1:3]  # 切片操作，得到 b"el"
z = x + b"world"  # 拼接操作，得到 b"helloworld"

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) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

运算符

算术运算符

以下假设变量 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次方
// 取整除 - 往小的方向取整数 plain >>> 9//2 4 >>> -9//2 -5

比较运算符

以下假设变量 a 为 10，变量 b 为20：

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

赋值运算符

以下假设变量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
:= 海象运算符，这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。Python3.8 版本新增运算符。 在这个示例中，赋值表达式可以避免调用 len() 两次:
plain if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

位运算符

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

逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

优先级运算符

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

运算符 描述
<font style="color:rgb(51, 51, 51);">(expressions...)</font>,
<font style="color:rgb(51, 51, 51);">[expressions...]</font>, <font style="color:rgb(51, 51, 51);">{key:</font><font style="color:rgb(51, 51, 51);"> </font><font style="color:rgb(51, 51, 51);">value...}</font>, <font style="color:rgb(51, 51, 51);">{expressions...}</font>		 圆括号的表达式
<font style="color:rgb(51, 51, 51);">x[index]</font>, <font style="color:rgb(51, 51, 51);">x[index:index]</font>, <font style="color:rgb(51, 51, 51);">x(arguments...)</font>, <font style="color:rgb(51, 51, 51);">x.attribute</font> 读取，切片，调用，属性引用
await x await 表达式
<font style="color:rgb(51, 51, 51);">**</font> 乘方(指数)
<font style="color:rgb(51, 51, 51);">+x</font>, <font style="color:rgb(51, 51, 51);">-x</font>, <font style="color:rgb(51, 51, 51);">~x</font> 正，负，按位非 NOT
<font style="color:rgb(51, 51, 51);">*</font>, <font style="color:rgb(51, 51, 51);">@</font>, <font style="color:rgb(51, 51, 51);">/</font>, <font style="color:rgb(51, 51, 51);">//</font>, <font style="color:rgb(51, 51, 51);">%</font> 乘，矩阵乘，除，整除，取余
<font style="color:rgb(51, 51, 51);">+</font>, <font style="color:rgb(51, 51, 51);">-</font> 加和减
<font style="color:rgb(51, 51, 51);"><<</font>, <font style="color:rgb(51, 51, 51);">>></font> 移位
<font style="color:rgb(51, 51, 51);">&</font> 按位与 AND
<font style="color:rgb(51, 51, 51);">^</font> 按位异或 XOR
` `
<font style="color:rgb(51, 51, 51);">in</font>``<font style="color:rgb(51, 51, 51);">,</font>``<font style="color:rgb(51, 51, 51);">not</font><font style="color:rgb(51, 51, 51);"> </font><font style="color:rgb(51, 51, 51);">in</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">is</font>``<font style="color:rgb(51, 51, 51);">,</font>``<font style="color:rgb(51, 51, 51);">is</font><font style="color:rgb(51, 51, 51);"> </font><font style="color:rgb(51, 51, 51);">not</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);"><</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);"><=</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">></font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">>=</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">!=</font>``<font style="color:rgb(51, 51, 51);">,</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">==</font> 比较运算，包括成员检测和标识号检测
<font style="color:rgb(51, 51, 51);">not</font><font style="color:rgb(51, 51, 51);"> </font><font style="color:rgb(51, 51, 51);">x</font> 逻辑非 NOT
<font style="color:rgb(51, 51, 51);">and</font> 逻辑与 AND
<font style="color:rgb(51, 51, 51);">or</font> 逻辑或 OR
<font style="color:rgb(51, 51, 51);">if</font>``<font style="color:rgb(51, 51, 51);"> </font><font style="color:rgb(51, 51, 51);">--</font><font style="color:rgb(51, 51, 51);"> </font>``<font style="color:rgb(51, 51, 51);">else</font> 条件表达式
<font style="color:rgb(51, 51, 51);">lambda</font> lambda 表达式
<font style="color:rgb(51, 51, 51);">:=</font> 赋值表达式

条件控制

if

1
2
3
4
5
6
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

match…case

1
2
3
4
5
6
7
8
9
match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

循环语句

while循环

1
2
while 判断条件(condition)：
    执行语句(statements)……

while-else

1
2
3
4
while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

for循环

1
2
3
4
for <variable> in <sequence>:
    <statements>
else:
    <statements>

range函数

如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列，例如:

1
2
3
4
5
6
7
8
>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 推导式是一种强大且简洁的语法，适用于生成列表、字典、集合和生成器。

Python 支持各种数据结构的推导式：

  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式

列表推导式

1
2
3
4
5
6
7
[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

案例

1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    # 推导式
    names = ['Bob', 'Tom', 'alice', 'Jerry', 'Wendy', 'Smith']
    new_names = [name.upper() for name in names if len(name) > 3]
    print(new_names)
    # 计算 30 以内可以被 3 整除的整数：
    numbers = [x for x in range(30) if x % 3 == 0]
    print(numbers)

字典推导式

1
2
3
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

案例

1
2
3
4
5
6
if __name__ == '__main__':
    listdemo = ['Google', 'Runoob', 'Taobao']
    # 将列表中各字符串值为键，各字符串的长度为值，组成键值对
    newdict = {key: len(key) for key in listdemo}
    print(newdict)

集合推导式

1
2
3
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

案例

1
2
3
if __name__ == '__main__':
    a = {x for x in 'abracadabra' if x not in 'abc'}
    print(a)

元组推导式(生成器表达式)

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

1
2
3
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

案例

1
2
3
4
if __name__ == '__main__':
    a = (x for x in range(1, 10))# 返回的是生成器对象
    print(a)
    print(tuple(a)) # 使用 tuple() 函数，可以直接将生成器对象转换成元组

迭代器与生成器

迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
if __name__ == '__main__':
    # 迭代器
    list = [1, 2, 3, 4]
    it = iter(list)  # 创建迭代器对象
    print(next(it))  # 输出迭代器的下一个元素
    print(next(it))
    for x in it:
        print(x, end=' ')
    print('\n')
    # 也可以使用 next() 函数：
    import sys
    list = [1, 2, 3, 4]
    it = iter(list)  # 创建迭代器对象
    while True:
        try:
            print(next(it))
        except StopIteration:
            sys.exit()

  1. 自定义迭代器：把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 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):
        x = self.a
        self.a += 1
        return x


if __name__ == '__main__':
    myclass = MyNumbers()
    myiter = iter(myclass)

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

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

调用一个生成器函数，返回的是一个迭代器对象。

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
36
37
38
39
if __name__ == '__main__':
    def countdown(n):
        while n > 0:
            yield n
            n -= 1


    # 创建生成器对象
    generator = countdown(5)

    # 通过迭代生成器获取值
    print(next(generator))  # 输出: 5
    print(next(generator))  # 输出: 4
    print(next(generator))  # 输出: 3

    # 使用 for 循环迭代生成器
    for value in generator:
        print(value)  # 输出: 2 1

    import sys


    def fibonacci(n):  # 生成器函数 - 斐波那契
        a, b, counter = 0, 1, 0
        while True:
            if (counter > n):
                return
            yield a
            a, b = b, a + b
            counter += 1


    f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成

    while True:
        try:
            print(next(f), end=" ")
        except StopIteration:
            sys.exit()

函数

函数定义

1
2
3
def 函数名（参数列表）:
    函数体

函数参数

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必须参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    # 可写函数说明
    def printme(str):
        "打印任何传入的字符串"
        print(str)
        return
    # 调用 printme 函数，不加参数会报错
    printme() 
    printme(str='abc')

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

1
2
3
4
5
6
7
if __name__ == '__main__':
    # 可写函数说明
    def printme(str):
        "打印任何传入的字符串"
        print(str)
        return
    printme(str='abc')

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

1
2
3
4
5
6
7
8
9
10
11
12
# 可写函数说明
def printinfo(name, age=35):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=50, name="mikey")
print("------------------------")
printinfo(name="mikey") # 默认打印35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

1
2
3
4
5
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

案例

1
2
3
4
5
6
7
8
9
10
11
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

匿名函数

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。
1
2
lambda [arg1 [,arg2,.....argn]]:expression

案例

1
2
x = lambda a : a + 10
print(x(5))

装饰器

类似于java的AOP

装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。

装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。

装饰器的语法使用 @decorator_name 来应用在函数或方法上。

Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。

装饰器的应用场景：

  • 日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
  • 性能分析: 可以使用装饰器来测量函数的执行时间。
  • 权限控制: 装饰器可用于限制对某些函数的访问权限。
  • 缓存: 装饰器可用于实现函数结果的缓存，以提高性能。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # 这里是在调用原始函数前添加的新功能
        before_call_code()
        
        result = original_function(*args, **kwargs)
        
        # 这里是在调用原始函数后添加的新功能
        after_call_code()
        
        return result
    return wrapper

# 使用装饰器
@decorator_function
def target_function(arg1, arg2):
    pass  # 原始函数的实现

带参装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

类装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
class DecoratorClass:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        # 在调用原始函数之前/之后执行的代码
        result = self.func(*args, **kwargs)
        # 在调用原始函数之后执行的代码
        return result

@DecoratorClass
def my_function():
    pass

数据结构

列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

方法 描述
list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
if __name__ == '__main__':
    a = [66.25, 333, 333, 1, 1234.5]
    print(a.count(333), a.count(66.25), a.count('x'))
    a.insert(2, -1)
    a.append(333)
    print(a)
    a.index(333)
    print(a)
    a.remove(333)
    print(a)
    a.reverse()
    print(a)
    a.sort()
    print(a)

栈

在 Python 中，可以使用列表（list）来实现栈的功能。栈是一种后进先出（LIFO, Last-In-First-Out）数据结构，意味着最后添加的元素最先被移除。列表提供了一些方法，使其非常适合用于栈操作，特别是 append() 和 pop() 方法。

用 append() 方法可以把一个元素添加到栈顶，用不指定索引的 pop() 方法可以把一个元素从栈顶释放出来。

栈操作

  • 压入（Push）: 将一个元素添加到栈的顶端。
  • 弹出（Pop）: 移除并返回栈顶元素。
  • 查看栈顶元素（Peek/Top）: 返回栈顶元素而不移除它。
  • 检查是否为空（IsEmpty）: 检查栈是否为空。
  • 获取栈的大小（Size）: 获取栈中元素的数量。
1
2
3
4
5
6
7
8
if __name__ == '__main__':
    stack = []
    stack.append('a')
    print(stack)
    stack.append('b')
    print(stack)
    print(stack.pop())
    print(stack)

队列

在 Python 中，列表（list）可以用作队列（queue），但由于列表的特点，直接使用列表来实现队列并不是最优的选择。

队列是一种先进先出（FIFO, First-In-First-Out）的数据结构，意味着最早添加的元素最先被移除。

使用列表时，如果频繁地在列表的开头插入或删除元素，性能会受到影响，因为这些操作的时间复杂度是 O(n)。为了解决这个问题，Python 提供了 collections.deque，它是双端队列，可以在两端高效地添加和删除元素。

使用 collections.deque 实现队列:

collections.deque 是 Python 标准库的一部分，非常适合用于实现队列。

以下是使用 deque 实现队列的示例：

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
from collections import deque

if __name__ == '__main__':

    # 创建一个空队列
    queue = deque()

    # 向队尾添加元素
    queue.append('a')
    queue.append('b')
    queue.append('c')

    print("队列状态:", queue)  # 输出: 队列状态: deque(['a', 'b', 'c'])

    # 从队首移除元素
    first_element = queue.popleft()
    print("移除的元素:", first_element)  # 输出: 移除的元素: a
    print("队列状态:", queue)  # 输出: 队列状态: deque(['b', 'c'])

    # 查看队首元素（不移除）
    front_element = queue[0]
    print("队首元素:", front_element)  # 输出: 队首元素: b

    # 检查队列是否为空
    is_empty = len(queue) == 0
    print("队列是否为空:", is_empty)  # 输出: 队列是否为空: False

    # 获取队列大小
    size = len(queue)
    print("队列大小:", size)  # 输出: 队列大小: 2

集合

同5.9.7

字典

同5.9.8

模块

import 语句

1
import module1[, module2[,... moduleN]

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

1
from modname import name1[, name2[, ... nameN]]

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

1
2
3
4
if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

说明： 每个模块都有一个name__属性，当其值是’__main‘时，表明该模块自身在运行，否则是被引入。

说明：name 与 main 底下是双下划线， _ _ 是这样去掉中间的那个空格。

输入和输出

美化输出

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

  • str()： 函数返回一个用户易读的表达形式。
  • repr()： 产生一个解释器易读的表达形式。
1
2
3
import math
print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

读取键盘输入

1
2
str = input("请输入：");
print ("你输入的内容是: ", str)

读写文件

open() 将会返回一个 file 对象，基本语法格式如下:

1
open(filename, mode)
  • filename：包含了你要访问的文件名称的字符串值。
  • mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 
1
2
3
4
5
6
7
# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

错误和异常

Python 有两种错误很容易辨认：语法错误和异常。

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

异常处理

try/except

1
2
3
4
5
6
while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")
1
2
3
4
5
6
7
8
9
10
11
12
13
import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try/except…else

1
2
3
4
5
6
7
8
for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

try-finally

1
2
3
4
5
6
7
8
9
10
11
12
try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

抛出异常

1
raise [Exception [, args [, traceback]]]
1
2
3
x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

自定义异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

面向对象

  • 类(Class):** **用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 方法：类中定义的函数。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 局部变量：定义在方法中的变量，只作用于当前实例的类。
  • 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。
  • 实例化：创建一个类的实例，类的具体对象。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

相关类库

Anaconda 集成环境

Anaconda 发行版包含了 Python。

Anaconda 是一个集成的数据科学和机器学习环境，其中包括了 Python 解释器以及大量常用的数据科学库和工具。

Anaconda 包及其依赖项和环境的管理工具为 conda 命令，文与传统的 Python pip 工具相比 Anaconda 的conda 可以更方便地在不同环境之间进行切换，环境管理较为简单。

参考资料

官网

菜鸟教程

编程语言 > Python
#Python
Python篇-Python快速入门
https://mikeygithub.github.io/2021/02/27/yuque/Python篇-Python快速入门/
作者
Mikey
发布于
2021年2月27日
许可协议