Python 基础 (-)

 

该笔记源自尚学堂,非原创

Python 单词是“大蟒蛇”的意思。但是龟叔不是喜欢蟒蛇才起这个名字，而是正在追剧：英国电视喜剧片《蒙提·派森的飞行马戏团》(Monty Python and the Flying Circus)。

 

使用 www.python.org 提供的 interactive shell 入门 Python

 

· 特点

1. 可读性强

可读性远比听上去重要的多得多。一个程序会被反复的修改，可读性强意味着让你可以在更短时间内学习和记忆，直接提高生产率。

1. 简洁，简洁，简洁

研究证明，程序员每天可编写的有效代码数是有限的。完成同样功能只用一半的代码，其实就是提高了一倍的生产率。

Python 是由 C 语言开发，但是不再有 C 语言中指针等复杂数据类型，Python 的简洁性让开发难度和代码幅度大幅降低，开发任务大大简化。程序员再也不需要关注复杂的语法，而是关注任务本身。

 

完成这样的螺旋线，代码只有几行：

import turtle t = turtle.Pen() for x in range(360): t.forward(x) t.left(59)

1. 面向对象
2. 免费和开源
3. 可移植性和跨平台

Python 会被编译成与操作系统相关的二进制代码，然后再解释执行。这种方式和 java 类似，大大提高了执行速度，也实现了跨平台。

1. 丰富的库（丰富的标准库， 多种多样的扩展库）
2. 可扩展性。     可嵌入到 C 和 C++语言。     胶水式语言。

· 应用范围

1. 科学计算
2. 人工智能
3. WEB 服务端和大型网站后端。

YouTube、gmail 等应用基于 python 开发。

1. GUI 开发（图形用户界面开发）
2. 游戏开发
3. 移动设备

嵌入式设备

1. 系统运维
2. 大数据
3. 云计算

· 什么时候不应该用 Python

1. Python 是解释执行。性能较低。

因此，一些影响性能的功能可以使用 C/C++/JAVA/GO（GO 是一种新语言，写起了像 Python，性能像 C）去开发。

不过，不用担心 Python 解释器会越来越快。

· 版本和兼容问题解决方案

目前主要两个版本：Python2 和 Python3

Python2：

2000 年 10 月发布。最新版本是 2.7，已经停止更新，不会再有 2.8 以后了。预计

2020 年退出历史舞台。

Python3：

2008 年发布。Python3 有了较大的提升，不兼容 Python2。

兼容问题解决：

1. Python3 的很多新特性也被移植到了 Python2.7，作为过渡。如果程序可以在 2.7 运行，可以通过一个名为 2to3（Python 自带的一个脚本）的转换工具无缝迁移到 Python3.

2. 建议大家学习从 Python3 开始，毕竟这才是未来。

· Python 解释器

Python 程序的执行依赖于 Python 解释器。常用的 Python 解释器有：

1. CPython

使用 c 语言实现的解释器，最常用的解释器。通常说的解释器指的就是它。

1. Jython

使用 java 语言实现的解释器。Jython 可以直接调用 java 类库，适合在 java 平台上开发

1. IronPython

.NET 平台上使用的解释器。可直接调用.NET 平台的类，适合.NET 平台上开发

1. PyPy

使用 Python 语言实现的解释器

Python 开发入门

Python 下载安装和配置

进入官网：www.python.org/downloads/

下载

安装（和安装一般软件区别不大）

环境变量问题

勾选：“Add Python to environment variable”。 这样就会将 Python 添加到环境变量 Path 中，我们可以在 windows 的命令行模式下运行 Python 解释器。

 

问题：由于 dll 缺失造成安装出错：

 

下载 dll 修复软件，运行修复即可，重启计算机。

 

Python 开发环境

开发环境，英文是 IDE（Integrated Development Environment 集成开发环境）。

不要纠结于使用哪个开发环境。开发环境本质上就是对 Python 解释器 python.exe 的封装，核心都一样。可以说：“开发环境 IDE，只是解释器的一个外挂而已”，只是为了让程序员更加方便编程，减少出错率，尤其是拼写错误。

常用的开发环境如下：

1. IDLE
2. Pycharm
3. wingIDE
4. Eclipse
5. IPython

交互模式(脚本 shell 模式)

1. 进入命令行窗口，输入：python

 

1. >>>即为“提示符”
2. 关闭交互窗口：

(1)    Ctrl+Z 和回车

(2)    输入 quit()命令

(3)    直接关闭命令行窗口

1. 中断程序执行：ctrl+C

交互模式工作原理和 Python 处理文件的方式一样。除了一点：当你输入一些值时，交互模式会自动打印输出。Py 文件中则必须使用 print 语句。

IDLE 开发环境使用入门

IDLE 介绍

1. IDLE 是 Python 的官方标准开发环境，Python 安装完后同时就安装了 IDLE。
2. IDLE 已经具备了 Python 开发几乎所有功能（语法智能提示、不同颜色显示不同类型等等），也不需要其他配置，非常适合初学者使用。
3. IDLE 是 Python 标准发行版内置的一个简单小巧的 IDE，包括了交互式命令行、编辑器、调试器等基本组件，足以应付大多数简单应用。
4. IDLE 是用纯 Python 基于 Tkinter 编写，最初的作者正是 Python 之父 Guido van

IDLE实(Rossum。) 操

1. 交互模式

启动 IDLE，默认就是进入交互模式。

1  编写和执行 Python 源文件

IDLE 常用快捷键

快捷键		说明
Alt+N	Alt+P	查看历史命令上一条、下一条
Ctrl+F6		重启 shell，以前定义的变量全部失效
F1		打开帮助文档
Alt+/		自动补全前面曾经出现过的单词
Ctrl + [	Ctrl + ]	缩进代码和取消缩进
Alt+M		打开模块代码，先选中模块，然后按下此快捷键，会帮你打开改模块的 py 源码供浏览
Alt+C		打开类浏览器，方便在源码文件中的各个方法体之间切换
F5		运行程序

第一个 Python 源程序

源码

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

将源代码保存到：d:/python_exec/mypy01.py

在 IDLE 中单击 F5 或者 run-->run module 执行这个源程序。

第一个 Python 程序中需要注意的小要点：

1. 不要在程序中，行开头处增加空格。空格在 Python 中有缩进的含义。
2. 符号都是英文符号，不是中文。比如：(,”

程序基本格式

1. 恰当的空格，缩进问题

(1)    逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。

(2)    语句从新行的第一列开始。

(3)    缩进风格统一：每个缩进层次使用 单个制表符 或四个空格（IDE 会自动将制表符设置成 4 个空格）

Python 用缩进而不是{}表示程序块

1. Python 区分大小写
2. 注释

(1)    行注释

每行注释前加#号。当解释器看到#，则忽略这一行#后面的内容

(2)    段注释

使用三个连续单引号（'''）。当解释看到'''，则会扫描到下一个'''，然后忽略他们之间的内容。

开始学习图形化程序设计

为了让初学者更加容易接受编程，我们这里先从海龟画图开始讲解。这样，大家在不接

触其他编程概念时，就能开始做出一些简单的效果。提高兴趣，寓教于乐。

>>> import turtle	#导入 turtle 模块
>>> turtle.showturtle()	#显示箭头
>>> turtle.write("高淇")	#写字符串
>>> turtle.forward(300)	#前进 300 像素
>>> turtle.color("red")	#画笔颜色改为 red
>>> turtle.left(90) >>> turtle.forward(300)	#箭头左转 90 度
>>> turtle.goto(0,50) >>> turtle.goto(0,0)	#去坐标（0,50）
>>> turtle.penup() >>> turtle.goto(0,300)	#抬笔。这样，路径就不会画出来
>>> turtle.pendown()	#下笔。这样，路径就会画出来
>>> turtle.circle(100)	#画圆

绘制奥运五环标记

源码：

import turtle turtle.width(10)

turtle.color("blue") turtle.circle(50)

turtle.color("black") turtle.penup() turtle.goto(120,0) turtle.pendown() turtle.circle(50)

turtle.color("red") turtle.penup() turtle.goto(240,0) turtle.pendown() turtle.circle(50)

turtle.color("yellow") turtle.penup() turtle.goto(60,-50) turtle.pendown() turtle.circle(50)

turtle.color("green") turtle.penup() turtle.goto(180,-50) turtle.pendown() turtle.circle(50)

运行结果：

 

本章实操作业

1. 建立 Python 开发环境，并完成第一个 Python 程序。将整个过程使用图文描述出来。
2. 根据老师代码，完成奥运五环的绘图程序

 

1. 使用海龟绘图，输出四个矩形：

 

第2章(1) 编程基础概念

Python 程序的构成

 

1. Python 程序由模块组成。一个模块对应 python 源文件，一般后缀名是：.py。
2. 模块由语句组成。运行 Python 程序时，按照模块中语句的顺序依次执行。

2   语句是 Python 程序的构造单元，用于创建对象、变量赋值、调用函数、控制语句等。

Python 文件的创建和执行

前面使用的交互式环境，每次只能执行一条语句；为了编写多条语句实现复杂的逻辑，本章开始我们通过创建 Python 文件，并执行该文件。

在 IDLE 环境中，我们可以通过 File-->new 创建 Python 文件，并可以编辑该文件内容。我们也可以通过 File-->save/save as 保存文件。一般保存成扩展名为 py 的文件。

需要执行编辑好的文件，可以用快捷键 F5 或者点击 Run-->Run module。

代码的组织和缩进

很多编程语言通过字符(例如：花括号{})、关键字(例如：begain/end)来划分代码块。同时，在配合代码的缩进增加可读性。“龟叔”设计 Python 语言时，直接通过缩进来组织代码块。“缩进”成为了 Python 语法强制的规定。缩进时，几个空格都是允许的，但是数目必须统一。我们通常采用“四个空格”表示一个缩进。

同时，也要避免将“tab 制表符”或者 tab 与空格混合的缩进风格。目前，常用的编辑器一般设置成：tab 制表符就是 4 个空格。

Python 官方推荐的 PEP-8 代码风格详细说明，有兴趣的同学可以参考： https://www.python.org/dev/peps/pep-0008/ 使用注释#

注释是程序中会被 Python 解释器忽略的一段文本。程序员可以通过注释记录任意想写的内容，通常是关于代码的说明。

Python 中的注释只有单行注释，使用#开始知道行结束的部分。

>>> # 注释是个好习惯，方便自己方便他人

>>> a = [10,20,30]     #生成一个列表对象，变量 a 引用了这个变量使用\行连接符

一行程序长度是没有限制的，但是为了可读性更强，通常将一行比较长的程序分为多行。这是，我们可以使用\行连接符，把它放在行结束的地方。Python 解释器仍然将它们解释为同一行。

>>> a = [10,20,30,40,\

50,60,70,\

80,90,100]

>>> a

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

>>> a = 'abcdefghijklmnopqrstuvwxyz'

>>> b = 'abcdefg\ hijklmn\ opqrst\ uvwxyz'

>>> a

'abcdefghijklmnopqrstuvwxyz'

>>> b

'abcdefghijklmnopqrstuvwxyz'

对象

Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值）组成。

1. 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj) 可返回对象 obj 的标识。
2. 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用 type(obj)获得对象的所属类型。
3. 值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值。对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

源码：

>>> a = 3

>>> a

3

>>> id(3)

1531372336

>>> type(3)

<class 'int'>

>>> b = "我爱你"

>>> id(a)

1531372336

>>> type(a)

<class 'int'>

>>> print(a)

3

>>> id(b)

46806816

>>> type(b) <class 'str'>

示意图：

 

引用

在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。

变量通过地址引用了“对象”。

变量位于：栈内存（压栈出栈等细节，后续再介绍）。

对象位于：堆内存。

·Python 是动态类型语言

变量不需要显式声明类型。根据变量引用的对象，Python 解释器自动确定数据类型。

·Python 是强类型语言

每个对象都有数据类型，只支持该类型支持的操作。

 

标识符

基本用法

标识符：用于变量、函数、类、模块等的名称。标识符有如下特定的规则：

1. 区分大小写。如：sxt 和 SXT 是不同的
2. 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
3. 不能使用关键字。比如：if、or、while 等。
4. 以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类的构造函数。

【操作】使用 Python 帮助系统查看关键字
>>> help() help> keywords
False		def		if		raise
None		del		import		return
True		elif		in		try
and		else		is		while
as		except		lambda		with
assert	finally		nonlocal		yield
break	for		not
class	from		or
continue	global		pass

注：无需刻意去背关键字，后面都会学习。

Python 标识符命名规则开发中，我们通常约定俗称遵守如下规则：

类型	规则	例子
模块和包名	全小写字母，尽量简单。若多个单词之间用下划线	math, os, sys
函数名	全小写字母，多个单词之间用下划线隔开	phone, my_name
类名	首字母大写，采用驼峰原则。多个单词时，每个单词第一个字母大写，其余部分小写	MyPhone、MyClass、 Phone
常量名	全大写字母，多个单词使用下划线隔开	SPEED、MAX_SPEED

变量和简单赋值语句

变量的声明和赋值

变量的声明和赋值用于将一个变量绑定到一个对象上，格式如下：变量名 = 表达式

最简单的表达式就是字面量。比如：a = 123 。 运行过程中，解释器先运行右边的表达式，生成一个代表表达式运算结果的对象；然后，将这个对象地址赋值给左边的变量。

【操作】变量在使用前必须先被初始化（先被赋值）

>>> my_name Traceback (most recent call last): File "<pyshell#17>", line 1, in <module> my_name NameError: name 'my_name' is not defined

 

变量 my_name 在被使用前未做赋值，因此报错：’my_name’is    not  defined。删除变量和垃圾回收机制

可以通过 del 语句删除不在使用的变量。

【操作 55】删除变量示例

>>> a=123

>>> del a

>>> x

Traceback (most recent call last):

File "<pyshell#20>", line 1, in <module> x

NameError: name 'x' is not defined

如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。

链式赋值

链式赋值用于同一个对象赋值给多个变量。 x=y=123     相当于：x=123; y=123 系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）

>>> a,b,c=4,5,6       相当于：a=4;b=5;c=6

【操作】使用系列解包赋值实现变量交换

>>> a,b=1,2 >>> a,b=b,a

>>> print(a,b)

2 1

常量

Python 不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。

>>> MAX_SPEED = 120

>>> print(MAX_SPEED)

120

>>> MAX_SPEED = 140      #实际是可以改的。只能逻辑上不做修改。

>>> print(MAX_SPEED)

140

最基本内置数据类型和运算符

每个对象都有类型，python 中最基本的内置数据类型：

1. 整型

整数，2345,10,50

1. 浮点型

小数，3.14 或者科学计数法 314e-2

1. 布尔型

表示真假，仅包含：True、False

1. 字符串型

由字符组成的序列。 “abc”,”sxt”,“尚学堂”,”百战程序员” 数字和基本运算符

Python 支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加法	3+2	5
-	减法	30-5	25
*	乘法	3*6	18
/	浮点数除法	8/2	4.0
//	整数除法	7//2	3
%	模（取余）	7%4	3
**	幂	2**3	8

【操作】基本运算符的使用

>>> a = 7/2

>>> a

3.5

>>> a = 7//2

>>> a

3

>>> a = 7%2

>>> a

1

>>> 7%4 3

>>> 2**3

8

>>> 3/0

Traceback (most recent call last):

File "<pyshell#37>", line 1, in <module>

3/0

ZeroDivisionError: division by zero

>>> divmod(10,5)

(2, 0)

>>> divmod(10,3)

(3, 1)

除数为 0，会产生异常：

>>> 3/0 Traceback (most recent call last): File "<pyshell#31>", line 1, in <module> 3/0 ZeroDivisionError: division by zero

使用 divmod()函数同时得到商和余数：

>>> divmod(13,3)

(4, 1)

divmod()是一个函数，我们以后会详细介绍。他返回的是一个元组(后续将会学习)。

整数

Python 中，除 10 进制，还有其他三种进制：

        ·0b 或 0B，二进制   0    1

        ·0o 或 0O，八进制   0    1    2    3    4    5    6    7

       ·0x 或 0X，十六进制 0  1    2    3    4    5    6    7    8    9    a    b    c    d    e    f

这三种进制可以非常方便的进行“位运算”操作。位运算知识后续将会介绍。

【操作】测试不同进制

>>> 12

12

>>> 0b101

5

>>> 0o19

SyntaxError: invalid syntax

>>> 0o10

8

>>> 0xff

255

>>> 0xf

15

>>> 0x10 16

使用 int()实现类型转换：

1. 浮点数直接舍去小数部分。如：int(9.9)结果是：9
2. 布尔值 True 转为 1，False 转为 0。    如：int(True)结果是 1
3. 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

>>> int("456")

456

>>> int("456abc")

Traceback (most recent call last):

File "<pyshell#41>", line 1, in <module> int("456abc")

ValueError: invalid literal for int() with base 10: '456abc'

>>> int("456.78")

Traceback (most recent call last):

File "<pyshell#42>", line 1, in <module>

int("456.78") ValueError: invalid literal for int() with base 10: '456.78' >>>

自动转型：

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0

整数可以有多大？

Python2 中，int 是 32 位，可以存储从-2147483648 到 2147483647 的整数（约±

21 亿）。Long 类型是 64 位，可以存储：-2^63--2^63-1 之间的数值。

Python3 中，int 可以存储任意大小的整数，long 被取消。我们甚至可以存储下面的值：

>>> googol = 10**100

>>> googol

1000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000

000

Googol 也是 Google 最初的名字，这也是 Google 最初的含义。

Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适合科学运算的特点。

浮点数

浮点数，称为 float。

浮点数用 ab¹⁰ 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。

这些数字在内存中也是按照科学计数法存储。

类型转换和四舍五入

1. 类似于 int()，我们也可以使用 float()将其他类型转化成浮点数。
2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0
3. round(value)可以返回四舍五入的值

注：但不会改变原有值，而是产生新的值

增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。

a = a + 1        等价于：     a +=1

增强型赋值运算符

运算符	例子	等价
+=	a += 2	a = a + 2
-=	a -= 2	a = a-2
*=	a *= 2	a = a * 2
/=	a /= 2	a = a / 2
//=	a //= 2	a = a//2
**=	a **= 2	a = a**2
%=	a %= 2	a = a % 2

注意：“+=”中间不能加空格！时间的表示

计算机中时间的表示是从“1970 年 1 月 1 日 00:00:00”开始，以毫秒（1/1000 秒）进行计算。我们也把 1970 年这个时刻成为“unix 时间点”。

这样，我们就把时间全部用数字来表示了。

 

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒

（1/1000 毫秒）精度的浮点值。例如：1530167364.8566。

>>> import time

>>> b = int(time.time())

>>> b

1530168754

>>> totalMinutes = b/60

>>> totalMinutes

25502812.566666666

>>> totalMinutes = b//60

>>> totalMinutes

25502812

>>> totalHours = totalMinutes//60

>>> totalHours

425046

>>> totalDays = totalHours//24

>>> totalDays

17710

>>> totalYears = totalDays//365

>>> totalYears

48

【操作】定义多点坐标_绘出折线_并计算起始点和终点距离源码

import turtle import math

#定义多个点的坐标

x1,y1 = 100,100 x2,y2 = 100,-100 x3,y3 = -100,-100 x4,y4 = -100,100

#绘制折线

turtle.penup() turtle.goto(x1,y1) turtle.pendown() turtle.goto(x2,y2)

turtle.goto(x3,y3) turtle.goto(x4,y4) #计算起始点和终点的距离 distance = math.sqrt((x1-x4)**2 + (y1-y4)**2) turtle.write(distance)

运行结果：                       

布尔值

Python2 中没有布尔值，直接用数字 0 表示 False,用数字 1 表示 True。

Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数字相加。

>>> a = True

>>> b = 3

>>> a+b

4

比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。

以下假设变量 a 为 15，变量 b 为 30：

运算符	描述	实例
==	等于 - 比较对象的值是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象的值是否不相等	(a != b) 返回 true.
>	大于 - 返回 x 是否大于 y	(a > b) 返回 False。
<	小于 - 返回 x 是否小于 y。	(a < b) 返回 true。
>=	大于等于 - 返回 x 是否大于等于 y。	(a >= b) 返回 False。
<=	小于等于 - 返回 x 是否小于等于 y。	(a <= b) 返回 true。

逻辑运算符

运算符	格式	说明
or 逻辑或	x or y	x 为 true，则不计算 y，直接返回 true x 为 false，则返回 y
and 逻辑与	x and y	x 为 true，则返回 y 的值 x 为 false，则不计算 y，直接返回 false
not 逻辑非	not    x	x 为 true，返回 false x 为 false，返回 true

同一运算符同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

运算符	描述
is	is 是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。

== 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__()方法。

整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。

·总结

1、   is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；

2、   == 比较的是两个对象的内容是否相等，值是否相等；

3、   小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；

4、   is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。

【操作】同一运算符测试

>>> a = 1000

>>> b = 1000

>>> a == b

True

>>> a is b

False

>>> id(a)

46764560

>>> id(b)

46765216

>>> c = 10

>>> d = 10

>>> c is d

True

>>> id(c)

1388831648

>>> id(d)

1388831648

基本运算符

我们在前面讲解了“+”、“-”、“*”、“/”、“//”、“%”等运算符，这里我们继续讲解一些其他运算符，并进行学习和测试。

运算符	说明
and ,      or    ,      not	布尔与、布尔或、布尔非
is    ,    is    not	同一性判断，判断是否为同一个对象
<,<=,>,>=,!=,==	比较值是否相当，可以连用
|       ^           &	按位或，按位异或、按位与
<<, >>	移位
~	按位翻转
+,-,*,/,//,%	加，减，乘，浮点除、整数除、取余
**	幂运算

1. 比较运算符可以连用，并且含义和我们日常使用完全一致。

>>> a = 4

          >>> 3<a<10   #关系运算符可以连用

True

2. 位操作

>>> a = 0b11001

>>> b = 0b01000

>>> c = a|b

          >>> bin(c)         #bin()可以将数字转成二进制表示

'0b11001'

>>> bin(c&b)

'0b1000'

>>> bin(c^b)

'0b10001'

>>> a = 3

          >>> a<<2     #左移 1 位相当于乘以 2.左移 2 位，相当于乘以 4

12

>>> a = 8

          >>> a>>1         #右移 1 位相当于除以 2.

3. 加法操作

          (1)   数字相加                     3+2    ==> 5

(2)  字符串拼接	“3”+“2”==> “32”
(3)  列表、元组等合并 4. 乘法操作	[10,20,30]+[5,10,100] ==>[10,20,30,5,10,100]
(1)  数字相乘	3*2         ==>      6
(2)  字符串复制	“sxt”*3           ==>         ”sxtsxtsxt”
(3)  列表、元组等复制	[10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

复合赋值运算符复合赋值可以让程序更加精炼，提高效率。

运算符	描述	示例	等价于
+=	加法赋值字符串拼接	sum += n a       += “sxt”	sum = sum + n a =       a + “sxt”
-=	减法赋值	num1        -= n	num = num - n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a/=b	a = a / b
//=	整数除赋值	a//=b	a = a//b
%=	取余赋值	a%=b	a = a % b
**=	幂运算赋值	a**=2	a = a**2
<<=	左移赋值	a<<=2	a = a<<2
>>=	右移赋值	a>>=2	a = a>>2
&=	按位与赋值	a&=b	a = a&b
|=	按位或赋值	a|=b	a=a|b
^=	按位异或赋值	a^=b	a = a^b

注：与 C 和 JAVA 不一样，Python 不支持自增(++)和自减(--) 运算符优先级问题如下优先级，从高到低。

运算符	描述
**	指数 (最高优先级)
~	按位翻转
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

【操作】使用 python 表示数学式： 510x13(y1)(ab) 9(5 12x)

                                                                                 5                    x                   x        y

(5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)

第2章(2) 字符串

字符串基本特点

很多人初学编程时，总是担心自己数学不行，潜意识里认为数学好才能编程。实际上，大多数程序员打交道最多的是“字符串”而不是“数字”。因为，编程是用来解决现实问题的，因此逻辑思维的重要性远远超过数学能力。

字符串的本质是：字符序列。Python 的字符串是不可变的，我们无法对原字符串做任

何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

Python 不支持单字符类型，单字符也是作为一个字符串使用的。

字符串的编码

Python3 直接支持 Unicode，可以表示世界上任何书面语言的字符。Python3 的字符默认就是 16 位 Unicode 编码，ASCII 码是 Unicode 编码的子集。

使用内置函数 ord()可以把字符转换成对应的 Unicode 码；使用内置函数 chr()可以把十进制数字转换成对应的字符。

>>> ord('A')

65

>>> ord('高')

39640

>>> chr(66)

'B'

>>> ord('淇')

28103

引号创建字符串

我们可以通过单引号或双引号创建字符串。例如：a=’abc’;         b=”sxt”

使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。例如：

>>> a = "I'm a teacher!"

>>> print(a) I'm a teacher!

>>> b = 'my_name is "TOM"'

>>> print(b) my_name is "TOM"

连续三个单引号或三个双引号，可以帮助我们创建多行字符串。例如：

>>> resume = ''' name="gaoqi"

company="sxt"       age=18

lover="Tom"'''

>>> print(resume) name="gaoqi"

company="sxt"    age=18 lover="Tom"

空字符串和 len()函数

Python 允许空字符串的存在，不包含任何字符且长度为 0。例如：

>>> c = ''

>>> len(c)

0

len()用于计算字符串含有多少字符。例如：

>>> d = 'abc 尚学堂'

>>> len(d)

6

转义字符

我们可以使用“\+特殊字符”，实现某些难以用字符表示的效果。比如：换行等。常见的转义字符有这些：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\b	退格(Backspace)
\n	换行
\t	横向制表符
\r	回车

【操作】测试转义字符的使用

>>> a = 'I\nlove\nU'

>>> a

'I\nlove\nU'

>>> print(a)

I

love

U

>>> print('aaabb\ cccddd') aaabbcccddd

字符串拼接

1. 可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。

(1)    如果+两边都是字符串，则拼接。

(2)    如果+两边都是数字，则加法运算。

(3)    如果+两边类型不同，则抛出异常。

1. 可以将多个字面字符串直接放到一起实现拼接。例如：’aa’’bb’==>’aabb’

【操作】字符串拼接操作

>>> a = 'sxt'+'gaoqi'

>>> a

'sxtgaoqi'

>>> b = 'sxt''gaoqi'

>>> b

'sxtgaoqi'

字符串复制

使用*可以实现字符串复制。

【操作】字符串复制操作

>>> a = 'Sxt'*3

>>> a

'SxtSxtSxt'

不换行打印

我们前面调用 print 时，会