Python 入门

一、简介

特点

1. 可读性强
2. 简洁，简洁，简洁（程序员再也不需要关注复杂的语法，而是关注任务本身）
3. 面向对象
4. 免费和开源
5. 可移植性和跨平台
6. 丰富的库（丰富的标准库， 多种多样的扩展库）
7. 可扩展性（可嵌入到 C 和 C++ 语言，胶水式语言）

开发环境

Windows 安装 Python 环境：

• 在 Python 官网下载安装包安装
• 使用 Scoop 安装

Linux 和 MacOS 都自带 Python

IDE 推荐：

• PyCharm
• IDLE

IDLE 快捷键：

Hello World

 复制代码
print('Hello World!')

交互模式

在终端中键入 python 可以进入交互模式。

• >>> 为提示符
• 关闭交互窗口:（1）Ctrl-Z + Enter （2）quit() 、 exit() （3）关闭窗口
• 中断程序执行：Ctrl-C

 复制代码
Python 3.7.4 (tags/v3.7.4:e09359112e, Jul  8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

:::info 交互模式下使用帮助：

• 键入 help() 进入帮助模式
• 键入 help(object) 直接获取 object 的帮助 :::

 复制代码
>>> help()
Welcome to Python 3.7's help utility!
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.7/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics".  Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".
help>

 复制代码
>>> help('float')
Help on class float in module builtins:
class float(object)
 |  float(x=0, /)
 |
 |  Convert a string or number to a floating point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 -- More  --

:::info 查看 Python 关键字： :::

 复制代码
help> keywords
Here is a list of the Python keywords.  Enter any keyword to get more help.
False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not

:::info 查看 Python 符号： :::

 复制代码
help> symbols
Here is a list of the punctuation symbols which Python assigns special meaning
to. Enter any symbol to get more help.
!=                  +                   <=                  __
"                   +=                  <>                  `
"""                 ,                   ==                  b"
%                   -                   >                   b'
%=                  -=                  >=                  f"
&                   .                   >>                  f'
&=                  ...                 >>=                 j
'                   /                   @                   r"
'''                 //                  J                   r'
(                   //=                 [                   u"
)                   /=                  \                   u'
*                   :                   ]                   |
**                  <                   ^                   |=
**=                 <<                  ^=                  ~
*=                  <<=                 _

程序的构成 ★

• Python 程序由模块组成。一个模块对应一个 python 源文件，一般后缀名是 .py 。
• 模块由语句组成。运行Python 程序时，按照模块中语句的顺序依次执行。
• 语句是Python 程序的构造单元，用于创建对象、变量赋值、调用函数、控制语句等。

（1）模块
模块是包含了我们能复用的代码的文件，包含了不同的函数定义，变量。模块文件通常以 .py 为扩展名。

（2）对象
Python 中，一切皆对象。每个对象由：标识（Identity）、类型（Type）、值（Value）组成。

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

对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

 复制代码
>>> a = 3
>>> a
3
>>> id(a)
8791153078592
>>> type(a)
<class 'int'>
>>> b = 'python'
>>> b
'python'
>>> id(b)
49754992
>>> type(b)
<class 'str'>

（3）引用
在Python 中，变量也称为：对象的引用。因为，变量存储的就是对象的地址。变量通过地址引用了“对象”。

变量位于栈内存；对象位于堆内存。

• Python 是动态类型语言

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

• Python 是强类型语言

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

 复制代码
>>> a = 3
>>> b = 3
>>> id(3)
8791153078592
>>> id(a)
8791153078592
>>> id(b)

二、基础概念

注释

• 行注释 #
• 段注释 '''

行连接符 \

 复制代码
>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> b = 'abcdefg\
hijklmn\
opqrst\
uvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> b
'abcdefghijklmnopqrstuvwxyz'

标识符

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

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

:::info Python 交互模式中使用帮助查看关键字 :::

:::tips Python 标识符命名规则 :::

https://www.yuque.com/poetdp/kf/kceaum?inner=ennbu

简单赋值语句

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

（2）删除变量和垃圾回收机制
可以通过 del 语句删除不再使用的变量。

 复制代码
>>> a = 3
>>> del a
>>> a
Traceback (most recent call last):
 File "<pyshell#42>", line 1, in <module>
   a
NameError: name 'a' is not defined

（3）链式赋值（用于同一个对象赋值给多个变量）

 复制代码
a = b = 123  #相当于：a = 123; b = 123

（4）系列解包赋值

 复制代码
a,b,c = 4,5,6  #相当于：a = 4; b = 5; c = 6

常量（不支持）

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

 复制代码
>>> MAX_SPEED = 120
>>> MAX_SPEED
120
>>> MAX_SPEED = 130 #实际是可以改的，只能逻辑上不做修改
>>> MAX_SPEED
130

基本数据类型 ★

（1） 整型

整数，除 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. 浮点数：直接舍去小数部分。
2. 布尔值：True 转为1，False 转为0。
3. 字符串：符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

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

整型范围：
Python 2 中，int 是 32 位，可以存储从 -2147483648 到 2147483647 的整数（约 ±21 亿）。long 类型是 64 位，可以存储 -2 63 ~ 2 63 - 1 之间的数值。
Python 3 中，int 可以存储任意大小的整数，long 被取消。Python 3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适合科学运算的特点。

（2）浮点型
小数，用 a * 10^b 形式的科学计数法表示，如 3.14 表示成 314e-2。浮点数在内存中也是按照科学计数法存储的。

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

（3）布尔型
表示真假，仅包含：True 、False

Python 2 中没有布尔值，直接用数字 0 表示 False，用数字 1 表示 True。
Python 3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数字相加。

（4）字符串型
由字符组成的序列。“abc”,”sxt”,“尚学堂”,”百战程序员”

数字和基本运算符
Python 支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下
运算。
运算符 说明 示例 结果

运算符

（1）算术运算符

除数为0，会产生异常：
>>> 3/0
Traceback (most recent call last):
File ““, line 1, in
3/0
ZeroDivisionError: division by zero
使用divmod()函数同时得到商和余数：
>>> divmod(13,3)
(4, 1)

（2）关系运算符

（3）逻辑运算符

（4）同一运算符

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

（5）位运算符

（6）赋值运算符

:::danger 与 C 和 JAVA 不一样，Python 不支持自增（++）和自减（—） :::

（7）运算符优先级

三、序列 ★

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。
序列中存储的是整数对象的地址，而不是整数对象的值。python中常用的序列结构有：
字符串、列表、元组、字典、集合

字符串

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

字符串的本质是：字符序列。Python 的字符串是不可改变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

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

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

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

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

（2）字符串的创建
我们可以通过 ' 或 " 创建字符串。例如：a=’abc’; b=”abc”
使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。

连续 ''' 或 """ ，可以帮助我们创建多行字符串。

（3）字符串的长度
Python 允许空字符串的存在，不包含任何字符且长度为 0。
len() 用于计算字符串含有多少字符。

（4）字符串的拼接

• 可以使用 + 将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。
  • 如果 + 两边都是字符串，则拼接。
  • 如果 + 两边都是数字，则加法运算。
  • 如果 + 两边类型不同，则抛出异常。
• 可以将多个字面字符串直接放到一起实现拼接。例如：’aa’’bb’==>’aabb’

（5）字符串的复制
使用 * 可以实现字符串复制。

（6）字符串的输入输出
我们前面调用 print() 时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行符。我们可以自己通过参数 end = “任意字符串”。实现末尾添加任何内容。

我们可以使用 input() 从控制台读取键盘输入的内容。

str() 可以帮助我们将其他数据类型转换为字符串。

当我们调用 print() 函数时，解释器自动调用了 str() 将非字符串的对象转成了字符串。

（7）[] 提取字符
字符串的本质就是字符序列，可以通过在字符串后面添加 [] ，在 [] 里面指定偏移量，提取该位置的单个字符。
正向搜索：最左侧第一个字符，偏移量是 0，第二个偏移量是 1，以此类推。直到 len(str)-1 为止。
反向搜索：最右侧第一个字符，偏移量是 -1，倒数第二个偏移量是 -2，以此类推，直到 -len(str) 为止。

（8）字符串的替换
字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现。

（9）slice 切片
切片 slice 操作可以让我们快速的提取子字符串。标准格式为：
[起始偏移量start：终止偏移量end：步长step]

典型操作(三个量为正数的情况)如下：
操作 说明 示例 结果
[:] 提取整个字符串“abcdef”[:] “abcdef”
[start:]从start 索引开始到结尾“abcdef”[2:] “cdef”
[:end]从头开始知道end-1 “abcdef”[:2] “ab”
[start:end]从start 到end-1 “abcdef”[2:4] “cd”
[start:end:step]从start 提取到end-1，步长是step “abcdef”[1:5:2] “bd”

其他操作（三个量为负数）的情况：
示例 说明 结果
“abcdefghijklmnopqrstuvwxyz” [-3:] 倒数三个“xyz”
“abcdefghijklmnopqrstuvwxyz” [-8:-3] 倒数第八个到倒数第三个(包头不包尾) ‘stuvw’
“abcdefghijklmnopqrstuvwxyz”[::-1] 步长为负，从右到左反向提取 ‘zyxwvutsrqponmlkjihgfedcba’

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始
偏移量小于0 则会当做0，终止偏移量大于“长度-1”会被当成-1。例如：

 复制代码
>>> "abcdefg"[3:50]
'defg'

（10）**split()** 分割和 **join()** 拼接
split() 可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。示例代码如下：

 复制代码
>>> a = "to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']

join() 的作用和 split() 作用刚好相反，用于将一系列子字符串连接起来。示例代码如下：

 复制代码
>>> a = ['sxt','sxt100','sxt200']
>>> '*'.join(a)
'sxt*sxt100*sxt200'

:::tips 使用字符串拼接符 +，会生成新的字符串对象，因此不推荐使用 + 来拼接字符串。推荐使用join 函数，因为 join() 在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。 :::

（11）字符串驻留机制和字符串比较
字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。
Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。

字符串比较和同一性：
我们可以直接使用 == / != 对字符串进行比较，是否含有相同的字符。
我们使用 is / not is ，判断两个对象是否同一个对象。

成员操作符：
in / not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

（12）字符串常用方法汇总
常用查找方法
s = ‘123abc456abc’
方法 说明 结果
len(s) 字符串长度 12
s.startswith(‘123’) 是否以指定字符串开头 True
s.endswith(‘123’) 是否以指定字符串结尾 False
s.find(‘abc’) 第一次出现字符串的位置 3
s.rfind(‘高’) 最后一次出现指定字符串的位置
s.count(“编程”) 指定字符串出现了几次3
a.isalnum() 所有字符全是字母或数字False

去除首尾信息
我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。

大小写转换
示例说明结果
a.capitalize() 产生新的字符串,首字母大写’Gaoqi love programming, love sxt’
a.title() 产生新的字符串,每个单词都首字母大写’Gaoqi Love Programming, Love Sxt’
a.upper() 产生新的字符串,所有字符全转成大写’GAOQI LOVE PROGRAMMING, LOVE SXT’
a.lower() 产生新的字符串,所有字符全转成小写’gaoqi love programming, love sxt’
a.swapcase() 产生新的,所有字母大小写转换’GAOQI LOVE PROGRAMMING, LOVE sxt’

格式排版
center()、ljust()、rjust()这三个函数用于对字符串实现排版。
其他方法
1. isalnum() 是否为字母或数字
2. isalpha() 检测字符串是否只由字母组成(含汉字)。
3. isdigit() 检测字符串是否只由数字组成。
4. isspace() 检测是否为空白符
5. isupper() 是否为大写字母
6. islower() 是否为小写字母

字符串的格式化
Python2.6 开始，新增了一种格式化字符串的函数str.format()，它增强了字符串格式化的
功能。
基本语法是通过{} 和: 来代替以前的% 。
format 函数可以接受不限个参数，位置可以不按顺序。
我们可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化，非常方便。
填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
数字格式化
浮点数通过f，整数通过d 进行需要的格式化。
可变字符串
在Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，智
能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用io.StringIO
对象或array 模块。

列表

列表：用于存储任意数目、任意类型的数据集合。

列表是内置可变序列，是包含多个元素的有序连续的内存空间。
列表大小可变，根据需要随时增加或缩小。

列表定义的标准语法格式：a = [10,20,30,40]
列表中的元素可以各不相同，可以是任意类型。比如：a = [10,20,’abc’,True]

方法要点描述：
list.append(x) 增加元素将元素x 增加到列表list 尾部
list.extend(aList) 增加元素将列表alist 所有元素加到列表list 尾部
list.insert(index,x) 增加元素在列表list 指定位置index 处插入元素x
list.remove(x) 删除元素在列表list 中删除首次出现的指定元素x
list.pop([index]) 删除元素删除并返回列表list 指定为止index 处的元素，默认是最后一个元素
list.clear() 删除所有元素删除列表所有元素，并不是删除列表对象
list.index(x) 访问元素返回第一个x 的索引位置，若不存在x 元素抛出异常
list.count(x) 计数返回指定元素x 在列表list 中出现的次数
len(list) 列表长度返回列表中包含元素的个数
list.reverse() 翻转列表所有元素原地翻转
list.sort() 排序所有元素原地排序
list.copy() 浅拷贝返回列表对象的浅拷贝

（1）列表的创建

• 基本语法 [] 创建

 复制代码
>>> a = [10,20,'gaoqi','sxt']
>>> a = [] #创建一个空的列表对象

• list() 创建

使用list()可以将任何可迭代的数据转化成列表。

 复制代码
>>> a = list() #创建一个空的列表对象
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = list("gaoqi,sxt")
>>> a
['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']

• range() 创建整数列表

range() 可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：
range([start,] end [,step])
start 参数：可选，表示起始数字。默认是0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为1
python 3 中 range() 返回的是一个 range 对象，而不是列表。我们需要通过 list() 方法将其转换成列表对象。

• 推导式生成列表

使用列表推导式可以非常方便的创建列表，在开发中经常使用。

 复制代码
>>> a = [x*2 for x in range(5)] #循环创建多个元素
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if x%9==0] #通过if 过滤元素
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

（2）列表元素的增加和删除
当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

• append() 方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。

 复制代码
>>> a = [20,40]
>>> a.append(80)
>>> a
[20, 40, 80]

• + 运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

 复制代码
>>> a = [20,40]
>>> id(a)
46016072
>>> a = a+[50]
>>> id(a)
46015432

• extend() 方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

 复制代码
>>> a = [20,40]
>>> id(a)
46016072
>>> a.extend([50,60])
>>> id(a)
46016072

• 乘法 * 扩展

使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复。

 复制代码
>>> a = ['sxt',100]
>>> b = a*3
>>> a
['sxt', 100]
>>> b
['sxt', 100, 'sxt', 100, 'sxt', 100]

适用于乘法操作的，还有：字符串、元组。

列表元素的删除

• del 删除

删除列表指定位置的元素。

 复制代码
>>> a = [100,200,888,300,400]
>>> del a[1]
>>> a
[100,200,300,400]

• pop() 方法

pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

 复制代码
>>> a = [10,20,30,40,50]
>>> a.pop()
50
>>> a
[10, 20, 30, 40]
>>> a.pop(1)
20
>>> a
[10, 30, 40]

• remove() 方法

删除首次出现的指定元素，若不存在该元素抛出异常。

 复制代码
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.remove(20)
>>> a
[10, 30, 40, 50, 20, 30, 20, 30]
>>> a.remove(100)
Traceback (most recent call last):
File "<pyshell#208>", line 1, in <module>
a.remove(100)
ValueError: list.remove(x): x not in list

（3）列表元素访问和计数

• 通过索引直接访问元素

我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则
会抛出异常。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a[2]
30
>>> a[10]
Traceback (most recent call last):
File ““, line 1, in
a[10]
IndexError: list index out of range

• index() 获得指定元素在列表中首次出现的索引

index() 可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，
start 和end 指定了搜索的范围。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>> a.index(20,3) #从索引位置3 开始往后搜索的第一个20
5
>>> a.index(30,5,7) #从索引位置5 到7 这个区间，第一次出现30 元素的位置
6

• count() 获得指定元素在列表中出现的次数

count() 可以返回指定元素在列表中出现的次数。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3

• len() 返回列表长度

len() 返回列表长度，即列表中包含元素的个数。
>>> a = [10,20,30]
>>> len(a)
3

成员资格判断
判断列表中是否存在指定的元素，我们可以使用count()方法，返回0 则表示不存在，返回
大于0 则表示存在。但是，一般我们会使用更加简洁的in 关键字来判断，直接返回True
或False。
切片操作
切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等等。切片的格式如下：
切片slice 操作可以让我们快速提取子列表或修改。标准格式为：
[起始偏移量start:终止偏移量end[:步长step]]
注：当步长省略时顺便可以省略第二个冒号

典型操作(三个量为正数的情况)如下：

其他操作（三个量为负数）的情况：
切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始
偏移量小于0 则会当做0，终止偏移量大于“长度-1”会被当成”长度-1”。
列表的遍历
for obj in listObj:
print(obj)
复制列表所有的元素到新列表对象
如下代码实现列表元素的复制了吗？
list1 = [30,40,50]
list2 = list1
只是将list2 也指向了列表对象，也就是说list2 和list2 持有地址值是相同的，列表对象本
身的元素并没有复制。
我们可以通过如下简单方式，实现列表元素内容的复制：
list1 = [30,40,50]
list2 = [] + list1
注：我们后面也会学习copy 模块，使用浅复制或深复制实现我们的复制操作。
列表排序
修改原列表，不建新列表的排序
>>> a = [1,4,3,2,3]
>>> a
[1, 4, 3, 2, 3]
>>> id(a)
43128968
>>> a.sort()
>>> a
[1, 2, 3, 3, 4]
>>> id(a)
43128968
>>> a.sort(reverse = True)
>>> a
[4, 3, 3, 2, 1]
>>> id(a)
43128968
>>> import random
>>> random.shuffle(a)
>>> a
[3, 2, 3, 1, 4]
>>> id(a)
43128968
建新列表的排序
我们也可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。
>>> a = [20,10,30,40]
>>> id(a)
46016008
>>> a = sorted(a) #默认升序
>>> a
[10, 20, 30, 40]
>>> id(a)
45907848
>>> a = [20,10,30,40]
>>> id(a)
45840584
>>> b = sorted(a)
>>> b
[10, 20, 30, 40]
>>> id(a)
45840584
>>> id(b)
46016072
>>> c = sorted(a,reverse=True) #降序
>>> c
[40, 30, 20, 10]
reversed() 返回迭代器
内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数
reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c

>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
我们打印输出c 发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用
list(c)进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象
在第一次时已经遍历结束了，第二次不能再使用。
列表相关的其他内置函数汇总
max 和min
用于返回列表中最大和最小值。
[40, 30, 20, 10]
>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3
sum
对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。
>>> a = [3,10,20,15,9]
>>> sum(a)
57

多维列表
二维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

元组

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。
因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如下操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度len()、最大值max()、最小值min()、求和sum()等。

（1）元组的创建

• 通过 () 创建元组。小括号可以省略。

a = (10,20,30) 或者a = 10,20,30
如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数1，(1,)
解释为元组。
>>> a = (1)
>>> type(a)

>>> a = (1,) #或者a = 1,
>>> type(a)

• 通过 tuple() 创建元组

tuple(可迭代的对象)
例如：
b = tuple() #创建一个空元组对象
b = tuple(“abc”)
b = tuple(range(3))
b = tuple([2,3,4])
总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

（2）元组的元素访问和计数
1. 元组的元素不能修改
2. 元组的元素访问和列表一样，只不过返回的仍然是元组对象。
3. 列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象。

zip
zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip 对象。
>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

生成器推导式创建元组
从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推
导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的next()
方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如
果需要重新访问其中的元素，必须重新创建该生成器对象。
【操作】生成器的使用测试
>>> s = (x2 for x in range(5))
>>> s
at 0x0000000002BDEB48>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s) #只能访问一次元素。第二次就为空了。需要再生成一次
[]
>>> s
at 0x0000000002BDEB48>
>>> tuple(s)
()
>>> s = (x2 for x in range(5))
>>> s.next()
0
>>> s.next()
2
>>> s.next()
4

元组总结
1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。
“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是，列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据，并且可重复。
一个典型的字典的定义方式：
a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
字典的创建
1. 我们可以通过{}、dict() 来创建字典对象。
>>> a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> b = dict(name=’gaoqi’,age=18,job=’programmer’)
>>> a = dict([(“name”,”gaoqi”),(“age”,18)])
>>> c = {} #空的字典对象
>>> d = dict() #空的字典对象
2. 通过zip()创建字典对象
>>> k = [‘name’,’age’,’job’]
>>> v = [‘gaoqi’,18,’techer’]
>>> d = dict(zip(k,v))
>>> d
{‘name’: ‘gaoqi’, ‘age’: 18, ‘job’: ‘techer’}
3. 通过fromkeys 创建值为空的字典
>>> a = dict.fromkeys([‘name’,’age’,’job’])
>>> a
{‘name’: None, ‘age’: None, ‘job’: None}
字典元素的访问
为了测试各种访问方法，我们这里设定一个字典对象：
a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
1. 通过[键] 获得“值”。若键不存在，则抛出异常。
>>> a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> a[‘name’]
‘gaoqi’
>>> a[‘age’]
18
>>> a[‘sex’]
Traceback (most recent call last):
File ““, line 1, in
a[‘sex’]
KeyError: ‘sex’
2. 通过get()方法获得“值”。推荐使用。优点是：指定键不存在，返回None；也可以设
定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”。
>>> a.get(‘name’)
‘gaoqi’
>>> a.get(‘sex’)
>>> a.get(‘sex’,’一个男人’)
‘一个男人’
3. 列出所有的键值对
>>> a.items()
dict_items([(‘name’, ‘gaoqi’), (‘age’, 18), (‘job’, ‘programmer’)])
4. 列出所有的键，列出所有的值
>>> a.keys()
dict_keys([‘name’, ‘age’, ‘job’])
>>> a.values()
dict_values([‘gaoqi’, 18, ‘programmer’])
5. len() 键值对的个数
6. 检测一个“键”是否在字典中
>>> a = {“name”:”gaoqi”,”age”:18}
>>> “name” in a
True
字典元素添加、修改、删除
1. 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，
则新增“键值对”。
>>>a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> a[‘address’]=’西三旗1 号院’
>>> a[‘age’]=16
>>> a
{‘name’: ‘gaoqi’, ‘age’: 16, ‘job’: ‘programmer’, ‘address’: ‘西三旗1 号院’}
2. 使用update()将新字典中所有键值对全部添加到旧字典对象上。如果key 有重复，则直
接覆盖。
>>> a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> b = {‘name’:’gaoxixi’,’money’:1000,’sex’:’男的’}
>>> a.update(b)
>>> a
{‘name’: ‘gaoxixi’, ‘age’: 18, ‘job’: ‘programmer’, ‘money’: 1000, ‘sex’: ‘男的’}
3. 字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定
键值对，并返回对应的“值对象”；
>>> a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> del(a[‘name’])
>>> a
{‘age’: 18, ‘job’: ‘programmer’}
>>> b = a.pop(‘age’)
>>> b
18
4. popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元
素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有”最后的元素”或者其
他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先
获取键的列表）。
>>> a = {‘name’:’gaoqi’,’age’:18,’job’:’programmer’}
>>> a.popitem()
(‘job’, ‘programmer’)
>>> a
{‘name’: ‘gaoqi’, ‘age’: 18}
>>> a.popitem()
(‘age’, 18)
>>> a
{‘name’: ‘gaoqi’}
序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
>>> x,y,z=(20,30,10)
>>> x
20
>>> y
30
>>> z
10
>>> (a,b,c)=(9,8,10)
>>> a
9
>>> [a,b,c]=[10,20,30]
>>> a
10
>>> b
20
序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用
items()；如果需要对“值”进行操作，则需要使用values()；
>>> s = {‘name’:’gaoqi’,’age’:18,’job’:’teacher’}
>>> name,age,job=s #默认对键进行操作
>>> name
‘name’
>>> name,age,job=s.items() #对键值对进行操作
>>> name
(‘name’, ‘gaoqi’)
>>> name,age,job=s.values() #对值进行操作
>>> name
‘gaoqi’
字典核心底层原理(重要)
字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的
每个单元叫做bucket。每个bucket 有两部分：一个是键对象的引用，一个是值对象的引
用。

集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典
中的“键对象”，因此是不能重复的且唯一的。
集合创建和删除
1. 使用{}创建集合对象，并使用add()方法添加元素
>>> a = {3,5,7}
>>> a
{3, 5, 7}
>>> a.add(9)
>>> a
{9, 3, 5, 7}
2. 使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保
留一个。
>>> a = [‘a’,’b’,’c’,’b’]
>>> b = set(a)
>>> b
{‘b’, ‘a’, ‘c’}
3. remove()删除指定元素；clear()清空整个集合
>>> a = {10,20,30,40,50}
>>> a.remove(20)
>>> a
{10, 50, 30}
集合相关操作
像数学中概念一样，Python 对集合也提供了并集、交集、差集等运算。我们给出示例：
>>> a = {1,3,’sxt’}
>>> b = {‘he’,’it’,’sxt’}
>>> a|b #并集
{1, 3, ‘sxt’, ‘he’, ‘it’}
>>> a&b #交集
{‘sxt’}
>>> a-b #差集
{1, 3}
>>> a.union(b) #并集
{1, 3, ‘sxt’, ‘he’, ‘it’}
>>> a.intersection(b) #交集
{‘sxt’}
>>> a.difference(b) #差集
{1, 3}

四、控制语句

五、函数