Python

一、简介

官网：https://www.python.org/

历史

Python 是由著名的“龟叔” Guido van Rossum 在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。

Python 本身也是由诸多其他语言发展而来的，这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

Python 源代码同样遵循 GPL(GNU General Public License)协议。

Python 2.0 于 2000 年 10 月 16 日发布，增加了实现完整的垃圾回收，并且支持 Unicode。

Python 3.0 于 2008 年 12 月 3 日发布，此版不完全兼容之前的 Python 源代码。不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。

Python 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。

**官方宣布，2020 年 1 月 1 日， 停止 Python 2 的更新。**这里学习python3

Python2.x 与 3.x 版本区别： https://www.runoob.com/python/python-2x-3x.html

简介

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

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

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言： Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

Python 特点

• 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++程序，让你的程序的用户获得"脚本化"的能力。

Python 应用

• Youtube - 视频社交网站
• Reddit - 社交分享网站
• Dropbox - 文件分享服务
• 豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
• 知乎 - 一个问答网站
• 果壳 - 一个泛科技主题网站
• Bottle - Python微Web框架
• EVE - 网络游戏EVE大量使用Python进行开发
• Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
• Inkscape - 一个开源的SVG矢量图形编辑器。
• …

二、环境搭建

Windows下

python环境：https://www.python.org/ftp/python/3.6.0python-3.6.0-amd64.exe （新版本不稳定，这里选择3.6）

pycharm（写代码的）：https://download.jetbrains.com.cn/python/pycharm-professional-2021.2.2.exe

安装python环境

打开下载好的exe，傻瓜式安装

这里为了避免因为权限问题安装失败，最后右键以管理员身份运行

1、这里选自定义安装

2、下一步

3、选择一个位置，别放C盘， 文件夹名最好别有中文或空格

4、install 安装完毕

5、配置环境变量

右键我的电脑——属性——高级系统设置——环境变量

新建

D:\Program Files\Python\Python3.6\

D:\Program Files\Python\Python3.6\Scripts\

6、测试， win + R 输入 cmd 打开小黑窗，输入python，出现版本号则证明安装成功！

安装pycharm

下载好后双击打开

PyCharm配置Python解释器

首先安装 PyCharm 完成之后，打开它会显示如下所示的界面：

找到setting

等待 PyCharm 配置成功，它会再次回到图 8 所示的界面，由此就成功的给 PyCharm 设置好了 Python 解释器。

PyCharm运行第一个python程序

new 一个 Project

创建后可以看到，它自动帮我们创建了一个 main.py文件

# This is a sample Python script.

# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.


def print_hi(name):
    # Use a breakpoint in the code line below to debug your script.
    print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.


# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    print_hi('PyCharm')

# See PyCharm help at https://www.jetbrains.com/help/pycharm/

点击运行，成功输出，配置成功！

以后我们就可以用它写代码啦

三、基础语法

3.1、编码

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

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

3.2、标识符

命名规则

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

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

标识符即 类名、方法名、变量名。

3.3、python保留字

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

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

3.4、注释

注释（Comments）用来向用户提示或解释某些代码的作用和功能，它可以出现在代码中的任何位置。Python 解释器在执行代码时会忽略注释，不做任何处理，就好像它不存在一样。

注释掉的代码不执行。

注释的最大作用是提高程序的可读性，没有注释的程序简直就是天书，让人吐血！

千万不要认为你自己写的代码规范就可以不加注释，甩给别人一段没有注释的代码是对别人的不尊重，是非常自私的行为；你可以喜欢自虐，但请不要虐待别人。

单行注释

Python 使用井号#作为单行注释的符号，语法格式为：

# 注释内容

#使用 print输出数字
print(100)
print( 3 + 100 * 2)
print( (3 + 100) * 2 )

print( 36.7 * 14.5 )  #输出乘积

从井号#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。

多行注释

多行注释指的是一次性注释程序中多行的内容（包含一行）。

Python 使用三个连续的单引号’''或者三个连续的双引号"""注释多行内容，具体格式如下：

'''
使用 3 个单引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
'''

"""
使用 3 个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
"""

3.5、行与缩进

和其它程序设计语言（如 Java、C 语言）采用大括号“{}”分隔代码块不同，Python 采用代码缩进和冒号（ : ）来区分代码块之间的层次。

在 Python 中，对于类定义、函数定义、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。

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

注意，Python 中实现对代码的缩进，可以使用空格或者 Tab 键实现。但无论是手动敲空格，还是使用 Tab 键，通常情况下都是采用 4 个空格长度作为一个缩进量（默认情况下，一个 Tab 键就表示 4 个空格）。

缩进的空格数是可变的，但是同一个级别代码块的语句必须包含相同的缩进空格数。

3.6、多行语句

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

total = item_one + \
        item_two + \
        item_three

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

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

Python 也可以在同一行中使用多条语句，语句之间使用分号 ; 分割

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

四、基本数据类型

任何编程语言都需要处理数据，比如数字、字符串、字符等，我们可以直接使用数据，也可以将数据保存到变量中，方便以后使用。

**变量（Variable）**可以看成一个小箱子，专门用来“盛装”程序中的数据。每个变量都拥有独一无二的名字，通过变量的名字就能找到变量中的数据。

从底层看，程序中的数据最终都要放到内存（内存条）中，变量其实就是这块内存的名字。

4.1、变量赋值

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

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

多个变量赋值

# 同时为多个变量赋值a = b = c = 1# 也可以为多个对象指定多个变量a, b, c = 1, 2, "runoob"

更多赋值例子

abc = 12.5  #将小数赋值给变量abcabc = 85  #将整数赋值给变量abcabc = "http://c.biancheng.net/"  #将字符串赋值给变量abc# 除了赋值单个数据，你也可以将表达式的运行结果赋值给变量sum = 100 + 20  #将加法的结果赋值给变量rem = 25 * 30 % 7  #将余数赋值给变量str = "C语言中文网" + "http://c.biancheng.net/"  #将字符串拼接的结果赋值给变量

注意，变量的值一旦被修改，之前的值就被覆盖了，不复存在了，再也找不回了。换句话说，变量只能容纳一个值。

在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，C语言、C++、Java是强类型语言的代表。

和强类型语言相对应的是弱类型语言，Python、JavaScript、PHP等脚本语言一般都是弱类型的。

弱类型语言有两个特点：

• 变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
• 变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。

注意，弱类型并不等于没有类型！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型，

>>> num = 10>>> type(num)<class 'int'>>>> num = 15.8>>> type(num)<class 'float'>

此外还可以用 isinstance 来判断：

>>> a = 111>>> isinstance(a, int)True

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

4.2、标准数据类型

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

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

其中：

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

4.3、Number（数字）

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

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

4.3.1、整数类型（int）

整数就是没有小数部分的数字，Python 中的整数包括正整数、0 和负整数。

有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。如CJava提供了 byte、 short、int、long。

而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。

当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。

#将 78 赋值给变量 nn = 78print(n)print( type(n) )#给x赋值一个很大的整数x = 8888888888888888888888print(x)print( type(x) )#给y赋值一个很小的整数y = -7777777777777777777777print(y)print( type(y) )运行结果：78<class 'int'>8888888888888888888888<class 'int'>-7777777777777777777777<class 'int'>

在 Python 中，可以使用多种进制来表示整数：

• 十进制形式

  • 我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。

  • 注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

• 二进制形式

  • 由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。

• 八进制形式

  • 八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。
  • 在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。

• 十六进制形式

  • 由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，

为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

click = 1_301_547distance = 384_000_000print("Python教程阅读量：", click)print("地球和月球的距离：", distance)Python教程阅读量：1301547地球和月球的距离：384000000

4.3.2、浮点型（float）

浮点数即 我们平常看到的小数形式

Python中的小数有两种形式：

• 十进制形式 如 34.6、346.0、0.346。书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

• 指数形式

  • aEn 或 aena 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。
    

Python 只有一种小数类型，就是 float。Java、C语言都有两种小数类型，分别是 float 和 double

4.3.3、复数( complex)

复数由实数部分和虚数部分构成，复数的虚部以j或者J作为后缀，可以用a + bj，或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

4.3.4、bool

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True == 1、 False== 0 会返回 True，但可以通过 is 来判断类型。

>>> True==1True>>> False==0True>>> 5>3True>>> 4>20False>>> True+12>>> False+11>>> 1 is TrueFalse>>> 0 is FalseFalse

4.4、字符串

若干个字符的集合就是一个字符串（String）。Python中的字符串必须由双引号" "或者单引号' '包围，具体格式为：

"字符串内容"'字符串内容'"123789""123abc"

4.4.2、转义字符

当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：

'I'm a great coder!'

对于这种情况，我们有两种处理方案：

1) 对引号进行转义

在引号前面添加反斜杠\就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：

str1 = 'I\'m a great coder!'str2 = "引文双引号是\"，中文双引号是“"print(str1)print(str2)# 运行结果：I'm a great coder!引文双引号是"，中文双引号是“

2) 使用不同的引号包围字符串

如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：

str1 = "I'm a great coder!"  #使用双引号包围含有单引号的字符串str2 = '引文双引号是"，中文双引号是“'  #使用单引号包围含有双引号的字符串print(str1)print(str2)# 运行结果和上面相同。

转义字符集 https://www.runoob.com/python3/python3-string.html

4.4.3、Python长字符串

Python 长字符串由三个双引号"""或者三个单引号'''包围，语法格式如下：

"""长字符串内容"""'''长字符串内容'''

在长字符串中放置单引号或者双引号不会导致解析错误。如果长字符串没有赋值给任何变量，相当于注释。

para_str = """这是一个多行字符串的实例多行字符串可以使用制表符TAB ( \t )。也可以使用换行符 [ \n ]。"""print (para_str)# 以上实例执行结果为：这是一个多行字符串的实例多行字符串可以使用制表符TAB (    )。也可以使用换行符 [  ]。

4.4.4、Python原始字符串

转义字符有时候会带来一些麻烦，例如我要表示一个包含 Windows 路径D:\Program Files\Python 3.8\python.exe这样的字符串，在 Python 程序中直接这样写肯定是不行的，不管是普通字符串还是长字符串。因为\的特殊性，我们需要对字符串中的每个\都进行转义，也就是写成D:\\Program Files\\Python 3.8\\python.exe这种形式才行。

这种写法需要特别谨慎，稍有疏忽就会出错。为了解决转义字符的问题，Python 支持原始字符串。在原始字符串中，\不会被当作转义字符，所有的内容都保持“原汁原味”的样子。

在普通字符串或者长字符串的开头加上r前缀，就变成了原始字符串，具体格式为：

str1 = r'原始字符串内容'str2 = r"""原始字符串内容"""

rstr = r'D:\Program Files\Python 3.8\python.exe'print(rstr)# 输出结果：D:\Program Files\Python 3.8\python.exe    str1 = r'I\'m a great coder!'print(str1)# 输出结果：I\'m a great coder!

4.4.5、字符串常用方法

方法	描述
str(obj)	将要转换的对象转换为字符串
repr(obj)	将要转换的对象转换为字符串
len()	获取字符串长度或字节数
split()	分割字符串方法
join()	合并字符串方法
count()	统计字符串出现的次数
find()	检测字符串中是否包含某子串
index()	检测字符串中是否包含某子串
ljust()、rjust()、center()	字符串对齐
startswith()、endswith()	检索字符串是否以指定字符串开头、结尾
title()、lower() 、upper()	对字符串中的字母进行大小写转换
strip()、lstrip()、rstrip()	去除字符串中空格或特殊字符
format()	格式化输出
encode()、decode()	字符串编码转换
dir()、help()	用来查看某个函数或者模块的帮助文档

4.5、数据类型转换

常用数据类型转换函数

函 数	作 用
int(x)	将 x 转换成整数类型
float(x)	将 x 转换成浮点数类型
complex(real，[,imag])	创建一个复数
str(x)	将 x 转换为字符串
repr(x)	将 x 转换为表达式字符串
eval(str)	计算在字符串中的有效 Python 表达式，并返回一个对象
chr(x)	将整数 x 转换为一个字符
ord(x)	将一个字符 x 转换为它对应的整数值
hex(x)	将一个整数 x 转换为一个十六进制字符串
oct(x)	将一个整数 x 转换为一个八进制的字符串

五、运算符

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

5.1、算术运算符

以下假设变量 a=10，变量 b=21：

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

5.2、比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(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

5.3、赋值运算符

运算符	描述	实例
=	简单的赋值运算符	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() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

5.5、位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100b = 0000 1101-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001~a  = 1100 0011

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

5.6、逻辑运算符

运算符	逻辑表达式	描述	实例
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

5.7、成员运算符

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

5.8、身份运算符

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

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

5.9、运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ |	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

六、序列

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

在Python中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

• 序列索引
• 序列切片
• 序列相加
• 序列相乘
• 检查元素是否包含在序列中

6.1、列表

Python中没有数组，但是加入了更加强大的列表。

从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]list2 = [1, 2, 3, 4, 5 ]list3 = ["a", "b", "c", "d"]list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。

6.1.1、创建列表

1) 使用 [ ] 直接创建列表

使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

listname = [element1 , element2 , element3 , ... , elementn]# listname 表示变量名，element1 ~ elementn 表示列表元素。

下面定义的列表都是合法的：

num = [1, 2, 3, 4, 5, 6, 7]name = ["C语言中文网", "http://c.biancheng.net"]program = ["C语言", "Python", "Java"]emptylist = [ ]      # 使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有

2) 使用 list() 函数创建列表

除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。

#将字符串转换成列表list1 = list("hello")print(list1) 	 # ['h', 'e', 'l', 'l', 'o']#将元组转换成列表tuple1 = ('Python', 'Java', 'C++', 'JavaScript')list2 = list(tuple1)print(list2)	 # ['Python', 'Java', 'C++', 'JavaScript']#将字典转换成列表dict1 = {'a':100, 'b':42, 'c':9}list3 = list(dict1)print(list3)	 # ['a', 'b', 'c']#将区间转换成列表range1 = range(1, 6)list4 = list(range1)print(list4) 	 # [1, 2, 3, 4, 5]#创建空列表print(list())	 # []

6.1.2、访问列表元素

可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），列表索引从 0 开始，第二个索引是 1，依此类推。

也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的格式为：

listname[i]

其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

使用切片访问列表元素的格式为：

listname[start : end : step]

其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

#使用索引访问列表中的某个元素print(url[3])  #使用正数索引print(url[-4])  #使用负数索引#使用切片访问列表中的一组元素print(url[9: 18])  #使用正数切片print(url[9: 18: 3])  #指定步长print(url[-6: -1])  #使用负数切片# 运行结果：pe['b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g']['b', 'n', 'e']['s', 'h', 'e', 'l', 'l']

6.1.3、更新列表

可以使用 append() 方法来添加列表项

list = ['Google', 'Runoob', 1997, 2000]print ("第三个元素为 : ", list[2])list[2] = 2001print ("更新后的第三个元素为 : ", list[2])list1 = ['Google', 'Runoob', 'Taobao']list1.append('Baidu')print ("更新后的列表 : ", list1)# 输出结果：第三个元素为 :  1997更新后的第三个元素为 :  2001更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

6.1.4、删除列表

对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。

实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。

语法格式为：

del listname# listname 表示要删除列表的名称。

删除列表元素

list = ['Google', 'Runoob', 1997, 2000]print ("原始列表 : ", list)del list[2]print ("删除第三个元素 : ", list)# 输出结果：原始列表 :  ['Google', 'Runoob', 1997, 2000]删除第三个元素 :  ['Google', 'Runoob', 2000]

6.1.5、列表脚本操作符

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

6.1.6、列表函数&方法

函数	描述
len(list)	返回列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

方法	描述
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort(key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

6.2、元组

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
• 元组使用小括号 ( )，列表使用方括号 [ ]。

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

6.2.1、创建元组

1) 使用 ( ) 直接创建

通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

tuplename = (element1, element2, ..., elementn)

其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素。

下面的元组都是合法的：

num = (7, 14, 21, 28, 35)course = ("Python教程", "http://c.biancheng.net/python/")abc = ( "Python", 19, [1,2], ('c',2.0) )course = "Python教程", "http://c.biancheng.net/python/" #  不需要括号也可以print(course) # ('Python教程', 'http://c.biancheng.net/python/')

• 元组中的元素没有个数限制，只要是Python支持的数据类型就可以
• 元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同
• 元组是 tuple 类型
• 元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组

需要注意的是：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。

>>> tup1 = (50)>>> type(tup1)     # 不加逗号，类型为整型<class 'int'>>>> tup1 = (50,)>>> type(tup1)     # 加上逗号，类型为元组<class 'tuple'>

2) 使用tuple()函数创建元组

#将字符串转换成元组tup1 = tuple("hello")print(tup1)#将列表转换成元组list1 = ['Python', 'Java', 'C++', 'JavaScript']tup2 = tuple(list1)print(tup2)#将字典转换成元组dict1 = {'a':100, 'b':42, 'c':9}tup3 = tuple(dict1)print(tup3)#将区间转换成元组range1 = range(1, 6)tup4 = tuple(range1)print(tup4)#创建空元组print(tuple())# 运行结果为：('h', 'e', 'l', 'l', 'o')('Python', 'Java', 'C++', 'JavaScript')('a', 'b', 'c')(1, 2, 3, 4, 5)()

6.2.2、访问元组

和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。

tup1 = ('Google', 'Runoob', 1997, 2000)tup2 = (1, 2, 3, 4, 5, 6, 7 )tup3 = tuple("http://c.biancheng.net/shell/")print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])print(url[9: 18])  #使用正数切片print(url[9: 18: 3])  #指定步长print(url[-6: -1])  #使用负数切片# 输出结果：tup1[0]:  Googletup2[1:5]:  (2, 3, 4, 5)('b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g')('b', 'n', 'e')('s', 'h', 'e', 'l', 'l')

6.2.3、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。# tup1[0] = 100# 创建一个新的元组tup3 = tup1 + tup2print (tup3)# 输出结果：(12, 34.56, 'abc', 'xyz')

6.2.4、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('Google', 'Runoob', 1997, 2000)print (tup)del tupprint ("删除后的元组 tup : ")print (tup)# 运行结果为：('Google', 'Runoob', 1997, 2000)删除后的元组 tup : Traceback (most recent call last):  File "test.py", line 8, in <module>    print (tup)NameError: name 'tup' is not defined

6.2.5、元组运算符

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

6.2.6、元组内置函数

函数	描述
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(iterable)	将可迭代系列转换为元组。

6.3、字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

类似于java中的map

6.3.1、创建字典

1) 使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

使用{ }创建字典的语法格式如下：

dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

需要注意的是，同一字典中的各个键必须唯一，不能重复。

2) 通过 fromkeys() 方法创建字典

可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典

knowledge = ['语文', '数学', '英语']scores = dict.fromkeys(knowledge, 60)print(scores)# 运行结果为：{'语文': 60, '英语': 60, '数学': 60}

可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。

3) 通过 dict() 映射函数创建字典

通过 dict() 函数创建字典的写法有多种

a = dict(str1=value1, str2=value2, str3=value3)demo = [('two',2), ('one',1), ('three',3)]demo = [['two',2], ['one',1], ['three',3]]demo = (('two',2), ('one',1), ('three',3))demo = (['two',2], ['one',1], ['three',3])a = dict(demo)

注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。

6.3.2、访问字典

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("dict['Name']: ", dict['Name'])print ("dict['Age']: ", dict['Age'])# 输出结果：dict['Name']:  Runoobdict['Age']:  7

如果键不存在则会抛异常

6.3.3、修改字典

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}dict['Age'] = 8               # 更新 Agedict['School'] = "菜鸟教程"  # 添加信息print ("dict['Age']: ", dict['Age'])print ("dict['School']: ", dict['School'])# 输出结果：dict['Age']:  8dict['School']:  菜鸟教程

6.3.4、删除字典

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}del dict['Name'] # 删除键 'Name'dict.clear()     # 清空字典del dict         # 删除字典print ("dict['Age']: ", dict['Age'])print ("dict['School']: ", dict['School'])# 这里会抛异常，以为字典不存在

字典键的特性

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

6.3.5、字典内置函数&方法

函数	描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典，可以打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

内置方法	描述
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict	如果键在字典dict里返回true，否则返回false
radiansdict.items()	以列表返回一个视图对象
radiansdict.keys()	返回一个视图对象
radiansdict.setdeafault(key,default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.valuses()	返回一个视图对象
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的最后一对键和值。

6.4、集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}或者set(value)

6.4.1、集合的基本操作

1、添加元素

语法格式如下：

s.add( x )s.update( x )

x 可以有多个，用逗号分开。参数可以是列表，元组，字典等

2、移除元素

语法格式如下：

s.remove( x ) # 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。s.discard( x ) # 此方法也是移除集合中的元素，且如果元素不存在，不会发生错误。s.pop() # 随机删除集合中的一个元素# set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

语法格式如下：

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> len(thisset)3

4、清空集合

语法格式如下：

s.clear() # 清空集合 s。

5、判断元素是否在集合中存在

语法格式如下：

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> "Runoob" in thissetTrue>>> "Facebook" in thissetFalse>>>

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

6.4.2、内置方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

学完这些基础知识，我们就可以开始尝试写代码啦！

七、流程控制

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

7.1、条件语句

7.1.1、if

if 表达式：	代码块

age = int( input("请输入你的年龄：") )if age < 18 :    print("你还未成年，建议在家人陪同下使用该软件！")    print("如果你已经得到了家长的同意，请忽略以上提示。")#该语句不属于if的代码块print("软件正在使用中...")

7.1.2、if else

if 表达式：    代码块 1else：    代码块 2

改进上面的代码，年龄不符合时退出程序：

age = int( input("请输入你的年龄：") )if age < 18 :    print("警告：你还未成年，不能使用该软件！")    print("未成年人应该好好学习，读个好大学，报效祖国。")else:    print("你已经成年，可以使用该软件。")    print("时间宝贵，请不要在该软件上浪费太多时间。")print("软件正在使用中...")

7.1.3、if elif else

if 表达式 1：    代码块 1elif 表达式 2：    代码块 2elif 表达式 3：    代码块 3...//其它elif语句else：    代码块 n

# 判断一个人的身材是否合理：height = float(input("输入身高（米）："))weight = float(input("输入体重（千克）："))bmi = weight / (height * height)  #计算BMI指数if bmi<18.5:    print("BMI指数为："+str(bmi))    print("体重过轻")elif bmi>=18.5 and bmi<24.9:    print("BMI指数为："+str(bmi))    print("正常范围，注意保持")elif bmi>=24.9 and bmi<29.9:    print("BMI指数为："+str(bmi))    print("体重过重")else:    print("BMI指数为："+str(bmi))    print("肥胖")

7.1.4、 if嵌套

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

if 表达式1:    语句    if 表达式2:        语句    elif 表达式3:        语句    else:        语句elif 表达式4:    语句else:    语句

实例

num=int(input("输入一个数字："))if num%2==0:    if num%3==0:        print ("你输入的数字可以整除 2 和 3")    else:        print ("你输入的数字可以整除 2，但不能整除 3")else:    if num%3==0:        print ("你输入的数字可以整除 3，但不能整除 2")    else:        print  ("你输入的数字不能整除 2 和 3")

7.2、循环语句

7.2.1、while循环

while 条件表达式：    代码块

n = 100sum = 0counter = 1while counter <= n:    sum = sum + counter    counter += 1print("1 到 %d 之和为: %d" % (n,sum))

7.2.2、for循环

语法

for 迭代变量 in 字符串|列表|元组|字典|集合：    代码块

测试

languages = ["C", "C++", "Perl", "Python"]for x in languages:    print (x)

7.2.3、循环嵌套

i = 0if i<10:    for j in range(5):        print("i=",i," j=",j)

7.2.4、break 和 continue

• break 跳出当前循环体

n = 5while n > 0:    n -= 1    if n == 2:        break    print(n)print('循环结束。')

• continue 直接执行下一次循环

n = 5while n > 0:    n -= 1    if n == 2:        continue    print(n)print('循环结束。')

7.2.5、循环结构中else用法

while 循环使用 else 语句

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

while <expr>:    <statement(s)>else:    <additional_statement(s)># expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。

测试

count = 0while count < 5:    print (count, " 小于 5")    count = count + 1else:    print (count, " 大于或等于 5")

for 循环使用 else 语句

for n in range(2, 10):    for x in range(2, n):        if n % x == 0:            print(n, '等于', x, '*', n//x)            break    else:        # 循环中没有找到元素        print(n, ' 是质数')

7.2.6、pass语句

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

7.3、迭代器与生成器

7.3.1、迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

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

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

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

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

list=[1,2,3,4]it = iter(list)    # 创建迭代器对象for x in it:    print (x, end=" ")# 运行结果1 2 3 4

也可以使用 next() 函数：

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()
        
# 输出结果如下：
1
2
3
4

7.3.2、生成器

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

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

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

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

# 使用 yield 实现斐波那契数列：
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()