python导论与数据类型详解（一）
程序员文章站
2022-06-11 19:06:11
...
思维导图文本整理
Python编程基础
1、导论入门
Python简介
诞生
1989年圣诞节，吉多·范罗苏姆 (Guido van Rossum)为了打发圣诞节假期创造了Python
1991年，Python第一个公开版本正式发布
命名
Python是Guido以喜剧团体Monty Python（巨蟒小组）的名字命名的
作者
吉多·范罗苏姆 (Guido van Rossum)是荷兰人
1982年，Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机硕士学位，并在荷兰的CWI
（Centrum voor Wiskunde en Informatica，国家数学和计算机科学研究院）工作
1995年移居美国，2005年加入Google公司，目前在Dropbox公司
为什么选择Python?
代码风格
简洁
优雅
高效
人生苦短，我用Python
注：Python将许多机器硬件层面上的细节隐藏，交给底层编译器处理，并凸显逻辑层面的编程思考；
程序员将精力和时间更多用于思考程序的逻辑和高级抽象，而不是具体的实现细节。
开发效率
有很多第三方库
完善的基础代码库
高级重用机制
面向对象程序设计OOP
可移植跨平台
跨平台支持WIN、Linux/Unix、MAC主流操作系统
使用范围
使用者广泛
TIOBE排名靠前
前5
前4
前3
知名项目丰富
Youtube
Instagram
OpenStack
Google
NASA
Cisco
豆瓣
知乎
最适合初学者的编程语言！
国外很多高校开始用python作为编程第一教学语言~~~
我们学Python可以做什么？
作为网络/安全工程师，为什么学Python？
批量部署
安全渗透
安全研发
SDN软件定义网络
作为运维工程师，为什么学Python？
自动化运维
云计算运维
作为软件工程师，为什么学Python?
文本处理
Web开发
图形开发
网络爬虫
游戏开发
科学计算
全栈语言
有哪些经典的Python教材？
书籍
《A Byte of Python》
Swaroop C H
简明Python教程
《Python编程入门》
Toby Donaldson
《Python学习手册》
Mark Lutz
《Python核心编程》
Wesley J. Chun
第二版
理论
第三版
应用
《笨方法学Python》
Zed Shaw
网站
www.python.org
手册
https://docs.python.org/2/
https://docs.python.org/3/
2、环境安装
理解程序运行
语言对比
语言概览
低级语言
机器型语言
二进制代码0和1
CPU内部工作指令
硬件才能读懂
汇编语言
符号语言
高级语言
编译型语言
C
C++
解释型语言
Python
Perl
Ruby
Java属于解释型和编译型之间的一种语言
运行流程
机器语言
汇编语言
编译语言
解释语言
术语解读
source code
python源代码，即程序员最开始编写的代码
print 'hello, world'
Python源代码一般以.py格式保存
complier
编译器，将源代码编译成字节码
bytecode
源代码被编译之后的代码称为字节码
字节码一般是.pyc格式
再次运行程序则不再需要编译
字节码主要是为了实现软硬环境无关，实现可移植/跨平台
不同系统上字节码是一样的，但是根据平台不同，编译所生成的机器码有区别
字节码是源代码和机器码的中间形态
interpreter
PVM（Python Virtual Machine）
解释器/虚拟机将字节码转译为可以直接执行的机器码
native code
机器码即虚拟机/解释器能够读懂的语言
processor
CPU/处理器最终读取机器码执行程序
特点总结
机器语言是二进制执行代码，无需“翻译”过程，CPU处理器可以直接读取，其他语言最终都需要统一编译为机器语言执行
汇编语言需要一次编译过程，硬件相关无法移植，抽象程度低/可读性差，执行效率很高/开发效率较低
编译语言需要一次编译过程，硬件无关可移植，抽象程度高/可读性强，执行效率较高/开发效率较高
解释语言需要两次“翻译”，硬件无关可移植，抽象程度超高/可读性最强，执行效率较低/开发效率最高
安装开发环境
原生开发环境
Windows系统
官网下载
www.python.org
版本说明
2.7
3.5
软件安装
3.5
2.7
环境变量
我的电脑->属性->环境变量->Path->;c:\python27
WIN+R -> cmd -> DOS
输入python，查看是否进入>>>交互模式
程序执行
交互模式
选择Python安装包自带IDE工具=>IDLE
hello,world!
脚本模式
#hello.py
print 'hello, world!'
python hello.py
交互模式方便实验验证，适合小程序，即使生效不存储；
脚本模式是主要的编程模式，适合编写大中程序，能存储。
Mac/Linux/Unix系统
系统自带
输入python即可执行
代码编辑器
Sublime Text
跨平台
Windows
Mac
Unix/Linux
Notepad ++
Windows平台
Vim
Unix/Linux平台
集成开发环境IDE
PyCharm
专业的面向Python编程的IDE工具
代码调试
代码高亮
代码跳转
智能提示
自动完成
单位测试
项目管理
Django
IronPython
Google App Engine
由软件公司JetBrains开发，商业化IDE软件
社区版
专业版
Eclipse+Pydev
著名的开源集成开发平台（由IBM开发后面开源），通过PDE插件开发环境的拓展，
可以用于开发Java、C、C++、Python等
编写第一个程序
方法一
代码编辑器 + Python执行
方法二
集成开发环境IDE
PyCharm
安装python27或者35
设置环境变量
安装PyCharm
创建Python项目
创建Python文本
测试运行
交互模式
Eclipse+Pydev
安装Java虚拟机 JRE/JDK
设置环境变量
安装python27或者35
设置环境变量
安装Eclipse
安装Pydev并关联
在线安装
点击Eclipse菜单“帮助-安装新软件”
添加安装
Pydev
http://pydev.org/updates
关联Eclipse
Window-> Preferences -> PyDev
Intepreter – Python:按 “Auto-Config”, Eclipse必须发现Python的安装目录。
点击Python并Apply
离线安装
Pydev官网下载安装包
将Pydev安装包内的plugins和features文件夹内的内容复制到eclipse的解压目录的相应文件夹中
打开Eclipse中Window菜单,选择Preference, 找到左侧边栏的Pydev, 点击Interpreter-Python
点击new,找到Python安装路径应用即可
关联Python解释器
创建Python项目
创建Python文本
测试运行
3、对象类型
对象
对象的定义
编程是什么？
编程的本质便是“do things”
编程就是“一动一静”，解决事情、处理问题。
动
解决
处理
执行
静
事情
问题
东西
怎么编程？
围绕“do"解决、处理、流程为依据来进行编程，称为“面向过程编程”
POP(procedure-oriented programming)
围绕“things"东西、事情、数据为依据来进行编程，称为“面向对象编程”
OOP(object-oriented programming)
举例
我要好好学Python！
面向过程
收集教程
教材
文档
视频
学习语法
项目练手
完成学习
面向对象
对象1
我（人）
对象2
Python（物）
对象3
学习
视频
教材
文档
从学习的流程入手
从学习这件事情的对象分解开始
什么是对象？
Python是一种“面向对象编程”的语言，所以Python语言中，一切皆对象！
Python语言中，所有能够被处理的、被解决的“东西”，都称之为对象（Object）
对象有各自特性和行为，例如猴子（能上树），树懒（爱睡觉）……
对象的组成
对象的特性
对象是什么？（what)
对象的数据、对象的状态，是一种静态信息。
值value：对象表示的数据项
身份id：唯一性身份标志，是该对象的内存地址，可用内建函数id()获得
类型tpye：对象的类型决定了该对象可以保存什么类型的值，可进行什么样的操作，以及遵循什么样的规则，可以type()获得
对象的行为
对象能做什么？(how)
对象的操作、功能、方法等，是一种动态信息。
我们将对象能做的，统称为 “方法/属性/操作”
方法method
通过dir( )获得
函数function
操作operation
对象的举例
例子1：人/程序员/小明
特征
名字
小明
身高
170cm
体重
60kg
年龄
18岁
行为
吃饭
学习
工作
敲代码
例如2：物/书籍/《Python秘籍》
特征
书名
类别
页数
价格
行为
存储知识
激发灵感
对象的类型
基础对象类型
数字
字符串
列表
元组
字典
集合
进阶对象类型
文件
函数
模块
类
其他叫法
核心数据结构
内置对象类型
内置数据类型
数字
数字是什么？
整数
定义
整数便是我们平常用的最多的数字，如1、-1、0
分类
以正负区分
正整数
1
负整数
-1
以进制区分
十进制
1
20
100
十六进制
0x2f
以0x开头
八进制
012
以0开头
python2.7
只用数字0放在前面
0o12
以0o
python3.5
除了数字0，必须加入字母o的大写或者小写
范围
无穷大
实际上取决于内存大小
2 ** 100
2的100次方
浮点数
定义
浮点数即我们平常使用的小数，如10.12、7.88
举例
1.5
-1.2233
10.2e99
10.2 * 10^99
科学记数法
31.5e-12
31.5 * 10^-12
科学记数法
范围
占8个字节/64比特
遵循IEEE754规范
52bit表示底，11bit表示指数，另外1个bit表示符号
换算之后范围大概是正负10的308.25次方
浮点数除了范围限制，计算中也会出现误差
不建议使用浮点数做精确的计算
拓展
为什么浮点数计算的时候是不精确的？
①计算机存储数据的时候是需要转换成二进制的
②很多小数转换为二进制是无穷大的，但机器存储是有限的（64bit），所以需要截断处理
0.1(十进制) = 0.0001100110011001(二进制)
超出计算精度，结果保留十六位小数
③浮点数运算不精确的例子
错误
>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125783e-17
溢出
>>> 500.0 ** 10000
浮点数会溢出
Traceback (most recent call last):
File "<input>", line 1, in <module>
OverflowError: (34, 'Result too large')
>>> 500 ** 10000
整数不会溢出
50123727492064520092975559337……
复数
定义
复数涉及到-1的平方根的数字，1j表示-1的平方根
复数由实部和虚部组成，如1+2j
举例
1.11 + 2j
2.33 - 8.5j
布尔型
定义
布尔型（bool）本质是整数类型的一种，只有True和False两个值
1和0
可以用于逻辑判断，多用于判断语句中
举例
>>> 1 > 2
False
>>> 10 < 20
True
其他
分数
空值
常量
如何操作数字？
运算符
算术运算符
加法
+
1 + 1
减法
-
10 - 5
乘法
*
2 * 5
除法
/
20 / 4
整除
//
25 // 3
取余
%
25 % 3
乘方
**
>>> 3**2
9
>>> -3 ** 2
-9
>>> 4.0 ** -1.0
0.25
运算优先级
优先级高的优先计算
1 + 1 * 2
优先级相同按书写顺序计算
1 + 1 - 2
需要改变计算优先级采用括号（ ）
（ 1 + 1 ） * 2
比较运算符
==
等于
>>> 10.1 == 10.1
True
>=
大于等于
>>> -619 >= 855
False
<=
小于等于
>>> 0. <= -10.1
False
<
小于
>>> 2 < 5
True
>>> 2 < 5 < 9
True
>
大于
>>> -619 > 877
False
>>> 78 > 69 == 69
True
!=
不等于
>>> 100 != 90
True
布尔运算符
与运算
and
>>> True and True
True
>>> True and False
False
>>> False and False
False
或运算
or
>>> True or True
True
>>> True or False
True
>>> False or False
False
非运算
not
>>> not True
False
>>> not False
True
内建函数
数值计算函数
abs( )
功能
返回给定参数的绝对值
举例
>>> abs(-1)
1
>>> abs(1.2-2.1j)
2.4186773244895647
>>> abs(0.23 - 0.78)
0.55
pow( )
功能
用于进行指数运算
举例
>>> pow(2, 5)
32
>>> pow(5, 2)
25
>>> pow(1+1j, 3)
(-2+2j)
round( )
功能
用于对浮点数进行四舍五入运算，返回与第一个参数最接近的整数
有可选的小数位位数参数，告诉round函数将结果精确到小数点后指定位数
举例
>>> round(3)
3.0
>>> round(3.45)
3.0
>>> round(3.4999)
3.0
>>> round(3.4999, 1)
3.5
>>> round(8.8)
9.0
>>> round(8.4)
8.0
其他
>>> import math
>>> for eachNum in range(10):
... print round(math.pi, eachNum)
...
3.0
3.1
3.14
3.142
3.1416
3.14159
3.141593
3.1415927
3.14159265
3.141592654
对比
int( ) round( ) math.floor( )
{ 函数 int()直接截去小数部分。（返回值为整数）
{ 函数 floor()得到最接近原数但小于原数的整数。（返回值为浮点数）
{ 函数 round()得到最接近原数的整数。（返回值为浮点数）
divmod( )
功能
把除法和取余运算结合，返回一个包含商和余数的元祖
举例
>>> divmod(10, 3)
(3, 1)
>>> divmod(3, 10)
(0, 3)
>>> divmod(10,2.5)
(4.0, 0.0)
coerce( )
功能
将两个数值转换为一个类型，然后创建包含两个数值的元祖
举例
>>> coerce(10, 0.1)
(10.0, 0.1)
>>> coerce(1.3, 134L)
(1.3, 134.0)
>>> coerce(1j, 134L)
(1j, (134+0j))
类型转换函数
int( )
功能
用于将其他数字类型转换为整数
截去小数部分，并且返回整数
举例
>>> int(1.1)
1
>>> int(99.11)
99
complex( )
功能
用于将其他数字类型转换为复数
举例
>>> complex(1)
(1+0j)
float( )
功能
用于将其他数字类型转换为浮点数
举例
>>> float(1)
1.0
long( )
功能
用于将其他数字类型转换为长整数
举例
>>> long(1)
1L
bool( )
功能
用于转换一个参数为布尔值
类型值转换bool值时除了''、""、0、()、[]、{}、None、0.0、0L、0.0+0.0j、False为False，其他都为True
举例
>>> bool(0)
False
>>> bool(False)
False
>>> bool('')
False
>>> bool([])
False
>>> bool(None)
False
>>> bool(-1)
True
>>> bool(1)
True
>>> bool(True)
True
进制转换函数
hex( )
功能
用于接收一个整数对象，然后返回对应十六进制的字符串对象
举例
>>> hex(255)
'0xff'
>>> hex(2309999231)
'0x89afca7f'
oct( )
功能
用于接收一个整数对象，然后返回对应八进制的字符串对象
举例
>>> oct(255)
'0377'
>>> oct(2399919191)
'021702756127'
bin( )
功能
用于接收一个整数对象，然后返回对应二进制的字符串对象
举例
>>> bin(1)
'0b1'
>>> bin(2)
'0b10'
>>> bin(3)
'0b11'
ASCII转换函数
ord( )
功能
接收一个字符，返回其对应的整数值
范围从0到255
举例
>>> ord('a')
97
>>> ord('A')
65
chr( )
功能
接收一个整数值，返回一个字符串
范围从0到255
举例
>>> chr(97)
'a'
内置模块
math
功能
高级数学计算模块，包含很多预先编写好的函数代码
cos(x)
x的余弦
sin(x)
x的正弦
tan(x)
x的正切
sqrt(x)
x的平方根
……
举例
>>> import math
>>> math.sqrt(4)
>>> math.sqrt(4)
没有导入math模块时
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'math' is not defined
2.0
>>> math.sin(5)
-0.9589242746631385
random
功能
随机数学模块
该模块包含多个伪随机数发生器，以当前时间戳为随机数种子
举例
randrange( )
随机返回（最小值， 最大值）结果的一项整数
>>> import random
>>> random.randrange(1, 10)
8
>>> random.randrange(1, 10)
9
>>> random.randrange(1, 10)
2
uniform( )
返回二者之间的一个浮点数
>>> import random
>>> random.uniform(1, 10)
3.2570408274280154
>>>
>>> random.uniform(1, 10)
2.072617258882051
>>> random.uniform(1, 10)
1.630710796726217
choice( )
随机返回给定序列的一个元素
>>> import random
>>> random.choice([1, 2, 3])
2
>>> random.choice([1, 2, 3])
3
NumPy
变量
变量是什么？
定义
变量是一种对象引用，好比一个‘链接’，指向任何数据/对象类型
引用
指针
链接
赋值
功能
可以让代码更加容易阅读
可以方便调用对象类型
可以写出更加复杂的代码
>>> a = 1
>>> b = 2
>>> x = a + b
>>> print x
3
原理
>>> a = 123
>>> id(a)
通过id( )查看内存空间地址
140249502136112
特征
变量在第一次赋值时被创建（内存中）
第一次赋值时，Python解释器会在内存中创建对象，然后再创建变量指向这个对象
再次使用该变量时，则内存无需再创建该变量
变量像对象一样不需要一开始进行类型声明
变量本身类型不固定的语言，我们称之为动态语言，与之对应的是静态语言；
静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。
变量在表达式中使用之前必须先赋值
a = 'pinginglab'
print a
变量在表达式中使用将被替换为它们所指向的值
a = 1
a + 2
变量如果没有指向一个对象，则会被垃圾回收
如何操作变量？
变量赋值
变量赋值说明
赋值语句
var = value
var 变量
variable
= 赋值运算符
value 对象
命名规则
变量名的长度不受限制，但其中的字符必须是字母、数字或下划线（_），而不能使用空格、连字符、标点符号、引号或其他字符。
不能是‘a'或！a
变量名的第一个字符不能是数字，而必须是字母或下划线。
不能是123，可以是a123
变量名是大小写区分的，a和A的变量是不同的。
不能将Python关键字用作变量名。
不能是if/else/while/def等关键词
变量赋值（数字）
a = 123
变量赋值（布尔值）
a = True
变量赋值（字符串）
a = 'hello, world'
变量赋值（列表）
a = [1, 2, 3]
其他例子
例子1（多重赋值）
>>> a, b, c = 1, 2, 3
>>> print a
1
>>> print b
2
>>> print c
3
例子2（交叉赋值）
a = 123
b = a
a = 'xyz'
print b
图解
交换两个变量的值
a=1
b=2
a,b=b,a
附加案例
>>> a = 300
>>> b = 100 + 200
>>> id(a)
140268284424512
>>> id(b)
140268284427576
>>> c = 300
>>> d = c
>>> id(c)
140268284427744
>>> id(d)
140268284427744
>>> e = 400
>>> f = 400
>>> id(e)
140268284424680
>>> id(f)
140268284424968
序列
字符串
字符串是什么？
定义
字符串（String）即一组有序的字符组合，由字母、数字、符号等信息组成。
功能
用于存储和表现基于文本的信息
文档
txt
word
网页
html
语法
变量 = 字符串
s = 'hello, world'
单引号
双引号
三引号
主要用于多行字符串/文本说明
>>> s = """
... hello, world!
... Welcome to PINGINGLAB!
... """
单双引号混用可以使得字符串本身包含“或‘
>>> "it's python"
"it's python"
>>> 'Hi,This is "PINGINGLAB"'
'Hi,This is "PINGINGLAB"'
特征
有序
字符串中的元素按照顺序从左到右存储
不可变
概述
Python对象类型根据对象内容本身是否可修改，分为可变对象和不可变对象两类
数字、字符串、元组是不可变的；列表、字典是可变的
举例
字符串不可变举例
>>> A = '123'
>>> A[0] = '4'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'str' object does not support item assignment
列表可变举例
>>> A = [1, 2, 3]
>>> A[0] = 4
>>> A
[4, 2, 3]
如何操作字符串？
操作符
索引操作符
[]
操作语法
字符串[索引值x]
访问索引为x的字符
正向索引
s[1]
>>> s = 'hello'
>>> s[1]
'e'
反向索引
s[-1]
>>> s = 'hello'
>>> s[-1]
'o'
切片操作符
[:]
操作语法
字符串[索引值x:索引值y]
访问索引从x到y的字符，包括x不包括y
正向切片
s[0:2]
>>> s = 'hello'
>>> s[0:2]
'he'
反向切片
s[-3:-1]
>>> s[-3:-1]
'll'
默认切片
s[1:]
>>> s[1:]
'ello'
s[:-3]
>>> s[:-3]
'he'
扩展切片[start:end:step]
反向输出字符串字符
a[::-1]
连接操作符
+
s1 + s2
>>> s1 = 'hello, '
>>> s2 = 'world!'
>>> s3 = s1 + s2
>>> s3
'hello, world!'
重复操作符
*
s * n
>>> s1 = 'hello'
>>> s1 * 10
'hellohellohellohellohellohellohellohellohellohello'
成员操作符
in
>>> s1 = 'hello'
>>> 'h' in s1
True
>>> 'he' in s1
True
not in
>>> 'he' not in s1
False
内置函数
判断函数
s.isalnum()
功能
判断字符串s是否只包含字母和数字，如果是返回True，否则返回False
举例
>>> s1 = 'abc'
>>> s2 = '123'
>>> s3 = 'a1b2c3'
>>> s1.isalnum()
True
>>> s2.isalnum()
True
>>> s3.isalnum()
True
s.isalpha()
功能
判断字符串s是否只包含字母，如果是返回True，否则返回False
举例
>>> s1.isalpha()
True
>>> s2.isalpha()
False
>>> s3.isalpha()
False
s.isdigit()
功能
判断字符串s是否只包含数字字符，如果是返回True，否则返回False
举例
>>> s1.isdigit()
False
>>> s2.isdigit()
True
>>> s3.isdigit()
False
s.islower()
功能
判断字符串s是否只包含小写字母，如果是返回True，否则返回False
举例
>>> s1.islower()
True
>>> s2.islower()
False
s.isupper()
功能
判断字符串s是否只包含大写字母，如果是返回True，否则返回False
举例
>>> s4 = 'ABC'
>>> s4.isupper()
True
s.isspace()
功能
判断字符串s是否只包含空白字符，如果是返回True，否则返回False
举例
>>> s5 = ' '
>>> s5.isspace()
True
s.startswith(t)
功能
判断字符串s是否以字符t开头，如果是返回True，否则返回False
举例
>>> s = 'hello, world!'
>>> s.startswith('h')
True
>>> s.startswith('H')
False
s.endswith(t)
功能
判断字符串s是否以字符t结尾，如果是返回True，否则返回False
举例
>>> s = 'hello, world!'
>>> s.endswith('!')
True
>>> s.endswith('.')
False
其他判断函数
s.isidentifier()
功能
判断字符串s是否合法的标识符，如果是返回True，否则返回False
举例
s.isdecimal()
功能
判断字符串s是否只包含十进制数字的字符，如果是返回True，否则返回False
举例
s.isnumeric()
功能
判断字符串s是否只包含数字，如果是返回True，否则返回False
举例
s.isprintable()
功能
判断字符串s是否只包含可打印字符，如果是返回True，否则返回False
举例
s.istitle()
功能
判断字符串s大小写符合头衔要求（title-case），如果是返回True，否则返回False
举例
搜索函数
s.count(t)
功能
搜索字符t，返回字符t在字符串出现的次数
举例
>>> s = 'hello,world!'
>>> s.count('o')
2
>>> s.count('i')
0
s.find(t)
功能
搜索字符t，如果没有找到子串t，则返回-1；否则返回t在s中的起始位置
举例
>>> s = 'hello,world'
>>> s.find('o')
4
>>> s.find('i')
-1
s.index(t)
功能
与find相同，返回t在s中的起始位置，但如果在s中找不到t，则引发ValueError异常
举例
>>> s.index('o')
4
>>> s.index('i')
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: substring not found
s.rfind(t)
功能
与find相同，但从右往左搜索，返回t在s中的最后一次出现时的起始位置索引
举例
>>> s.rfind('o')
7
s.rindex(t)
功能
与index相同，但从右往左搜索，返回t在s中的最后一次出现时的起始位置索引
举例
>>> s.rindex('o')
7
格式函数
s.center(n, t)
功能
包含n个字符的字符串，其中s位于*，两边用字符t填充，t可选
举例
>>> s = 'hello'
>>> s.center(10)
' hello '
>>> s = 'hello'
>>> s.center(10,'-')
'--hello---'
s.ljust(n, t)
功能
包含n个字符的字符串，其中s位于左边，右边用字符t填充，t可选
举例
>>> s = 'hello'
>>> s.ljust(10)
'hello '
>>> s = 'hello'
>>> s.ljust(10,'-')
'hello-----'
s.rjust(n, t)
功能
包含n个字符的字符串，其中s位于右边，左边用字符t填充，t可选
举例
>>> s = 'hello'
>>> s.rjust(10)
' hello'
>>> s = 'hello'
>>> s.rjust(10,'-')
'-----hello'
s.format(vars)
功能
格式化字符串，类似%
字符映射
格式限定
举例
字符映射
>>> '{0},{1}'.format('hello','world')
通过位置
'hello,world'
>>> '{A},{B}'.format(A = 'hello',B = 'world')
通过指定
'hello,world'
格式限定
>>> '{:^10}'.format('hello')
居中对齐
' hello '
>>> '{:<10}'.format('hello')
左对齐
'hello '
>>> '{:>10}'.format('hello')
右对齐
' hello'
S.join(t)
功能
t是一个列表,将列表中的元素用S连接起来
举例
>>> l=['a','b','c']
>>> ' '.join(l)
'a b c'
>>> '-'.join(l)
'a-b-c'
剥离函数
s.strip(t)
功能
从s开头和末尾中的t字符，默认删除空白字符
举例
>>> s = ' hello, world! '
>>> s.strip()
'hello, world!'
s.lstrip(t)
功能
从s开头（左端）删除所有包含在字符串中的t字符，默认删除空格
举例
>>> s = ' hello, world! '
>>> s.lstrip()
'hello, world! '
s.rstrip(t)
功能
从s末尾（右端）删除所有包含在字符串中的t字符，默认删除空格
举例
>>> s = ' hello, world! '
>>> s.rstrip()
' hello, world!'
拆分函数
s.partition(t)
功能
将s拆分为三个字符串（head、t和tail），其中head为t前面的子串，而tail为t后面的子串
举例
>>> s = 'www.pinginglab.net'
>>> s.partition('.')
('www', '.', 'pinginglab.net')
s.rpartition(t)
功能
与partition相同，但从s的右端开始搜索t
举例
>>> s = 'www.pinginglab.net'
>>> s.rpartition('.')
('www.pinginglab', '.', 'net')
s.split(t)
功能
以t为分隔符，将s划分成一系列子串，并返回一个由这些子串组成的列表
举例
>>> s = 'www.pinginglab.net'
>>> s.split('.')
['www', 'pinginglab', 'net']
>>> s = 'Welcome to PINGINGLAB'
>>> s.split()
['Welcome', 'to', 'PINGINGLAB']
s.rsplit(t)
功能
与split相同，但从s的右端开始搜索t
举例
>>> s.rsplit('.')
['www', 'pinginglab', 'net']
s.splitlines()
功能
返回一个由s中的各行组成的列表
举例
>>> s = '''hello,world!
... Welcome to PINGINGLAB'''
>>>
>>>
>>> s.splitlines()
['hello,world!', 'Welcome to PINGINGLAB']
替换函数
s.replace(old, new)
功能
将s中的每个old替换为new
举例
>>> s = 'hello,world!'
>>> s.replace('hello','hi')
'hi,world!'
s.expandtabs(n)
功能
将s中的每个制表符tab替换为n个空格
举例
>>> s = 'hello\tworld'
>>> s.expandtabs(1)
'hello world'
>>> s.expandtabs(5)
'hello world'
大小写函数
s.lower()
功能
让s的所有字母都小写
举例
>>> s = 'Hello,World!'
>>> s.lower()
'hello,world!'
>>> s.upper()
'HELLO,WORLD!'
>>> s.capitalize()
'Hello,world!'
>>> s.title()
'Hello,World!'
>>> s.swapcase()
'hELLO,wORLD!'
s.upper()
功能
让s的所有字母都大写
举例
>>> s = 'Hello,World!'
>>> s.upper()
'HELLO,WORLD!'
s.capitalize()
功能
将s第一个字符改为大写
举例
>>> s.capitalize()
'Hello,world!'
s.swapcase()
功能
将小写字母改为大写，并将大写字母改为小写
举例
>>> s.swapcase()
'hELLO,wORLD!'
s.title()
功能
让s的大小写符合标题化的要求，即所有的单词第一个字符为大写其他小写
举例
>>> s = 'hello,world!'
>>> s.title()
'Hello,World!'
进阶操作
字符编码
编码原理
计算机只能读懂二进制0和1，处理字符时，需要将字符转换为数字存储并处理
将字符与数字相互对应的编码规则称为字符编码（码表）
编码分类
ASCII
概述
最早的字符编码规则称为ASCII编码
ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）
0-127 是ASCII 码的范围，总共128个字符
长度支持
采用1个字节8个比特来表示字符
总共最多255个字符支持
语言支持
只能支持英语
Unicode
概述
随着计算机的普及，各个国家出现了各自的字符编码集，例如中国的GB2312和GBK
由于不同国家不同地区的字符编码相互不支持，为了解决这个问题开发了Unicode(统一码/万国码）字符编码
长度支持
采用2个字节或4个字节来表示字符，一般采用2个
编码方式
Universal Character Set，简称为UCS
UCS-2就是用两个字节编码，UCS-4就是用4个字节编码
UCS编码分为UCS-2和UCS-4两个规范
语言支持
所有国家
UTF-8
概述
Unicode有些字符并不需要2个字节来进行存储和传输，例如英文只需要1个字节即可
Unicode是一个字符编码规范，UTF-8是Unicode的存储和传输的实现方式
UTF-8就是在互联网上使用最广的一种Unicode的实现方式
实现方式
UCS Transformation Format
UTF-8
采用8个比特1个字节作为基础单位
UTF-16
UTF-32
长度支持
可变长编码，采用1到6个字节来存储和传输字符
一般英文用1个字节，汉语用3个字节，比较复杂的用4到6个字节
可以有效节省空间
语言支持
所有国家
编码设置
源代码编码设置
#!/usr/bin/python
为Linux/Unix环境设置环境变量/执行路径
Windows系统忽略
更推荐的做法:#!/usr/bin/env python
#!/usr/bin/python
#!/usr/bin/python直接告知操作系统执行这个脚本的时候，直接调用/usr/bin目录下的python解释器
#!/usr/bin/python写法相当于写死了python路径，如果python默认安装到此路径，则没有任何问题
#!/usr/bin/env python
#!/usr/bin/env python 采用这种写法更加有拓展性，因为有时候python没有安装到默认路径，或者python有多版本的情况
#!/usr/bin/env python3
若指定python3环境
此时系统会到env环境设置里查找python，再调用对应路径下的解释器程序完成操作
# -*- coding: UTF-8 -*-
采用UTF-8编码打开，支持中文
若用其他编码则可能出现乱码
python 2.7 默认为ASCII编码
Python 2.7.6 (default, Sep 9 2014, 15:04:36)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin
>>> import sys
>>> print sys.getdefaultencoding()
ascii
>>> ord('a')
97
>>> ord('中')
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: ord() expected a character, but string of length 3 found
python 3.5 默认为UTF-8编码
Python 3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32
>>> import sys
>>> sys.getdefaultencoding()
'utf-8'
>>> ord('a')
97
>>> ord('中')
20013
编辑器编码设置
设置编码方式为UTF-8
转义字符
转义概述
通过引入转义字符，可以实现字符串中的特殊需求，例如换行、回车等功能
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符
转义字符
\ 续行符
\\ 反斜杠符号
>>> s = 'hello,\\world'
>>> print s
hello,\world
\' 单引号
>>> s = 'hello,\'world'
>>> print s
hello,'world
\" 双引号
>>> s = 'hello,\"world'
>>> print s
hello,"world
\n 换行
>>> s = 'hello,\nworld'
>>> print s
hello,
world
\t 横向制表符
>>> s = 'hello,\tworld'
>>> print s
hello, world
\v 纵向制表符
\r 回车
\b 退格
\a 响铃
\e 转义
\000 空
\f 换页
\ott 八进制数，tt代表的字符
\xtt 十六进制数，tt代表的字符
关闭转义
>>> s = r'hello,\tworld'
file = open(r'C:\new\test.txt', 'w')
>>> print s
hello,\tworld
格式化字符
格式化概述
通过引入格式化字符，可以实现更加复杂的字符串表达
格式化允许在一条字符串语句执行多字符替换
格式化字符采用%符号来引用
格式化语法
'字符串%d %s’ %（ 元素1，元素2，元素3 ……）
左侧
在%操作符的左侧放置一个需要进行格式化的字符串，
这个字符串带有一个或多个嵌入的转换目标，
都以%开头（例如，%d）
右侧
在%操作符右侧放置一个（或多个，嵌入到元组中）对象，
这些对象将会插入到左侧想让Python进行格式化字符串的
一个（或多个）转换目标的位置上去。
格式化字符
%s 格式化字符串
>>> 'hello, %s' % 'J'
'hello, J'
>>> 'Hello, %s, Welcome to %s' % ('J', 'PINGINGLAB')
'Hello, J, Welcome to PINGINGLAB'
%d 格式化整数
>>> '%s is %d years old' % ('J', 18)
'J is 18 years old'
>>> x = 'J'
>>> y = 18
>>> '%s is %d years old' % ( x , y)
'J is 18 years old'
增强案例
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
a = int(raw_input('请输入您的岁数:'))
b = str(raw_input('请输入您的名字:'))
c = 'hello %s,your age is %d' % (b, a)
print c
%c 格式化字符及其ASCII码
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
列表
列表是什么？
定义
列表（List）是一组有序的集合对象类型，可以包括数字、字符串甚至列表等信息。
功能
用于存储其他对象信息
支持复杂的数据存储和处理
语法
变量 = [元素1 , 元素2, 元素3 …… ]
L = ['hello', 123, [10,20] ]
特征
有序
可变
如何操作列表？
操作符
索引操作符
[]
>>> l = ['hello', 123, [10,20]]
>>> l[0]
'hello'
>>> l[1]
123
>>> l[2]
[10, 20]
>>> l[2][0]
10
>>> l[2][1]
20
替换
L[1] = 'hi'
切片操作符
[:]
>>> l = ['hello', 123, [10,20]]
>>> l[0:1]
['hello']
>>> l[0:2]
['hello', 123]
>>> l[0:3]
['hello', 123, [10, 20]]
连接操作符
+
>>> l1 = ['hello',123]
>>> l2 = [456,789]
>>> l1 + l2
['hello', 123, 456, 789]
重复操作符
*
>>> l1 * 3
['hello', 123, 'hello', 123, 'hello', 123]
成员操作符
in
>>> 'hello' in l
True
>>> 'hi' in l
False
not in
>>> 123 not in l
False
内置函数
内置函数
len( )
功能
获取列表的元素个数
举例
>>> len(l)
>>> l = [1,2,3,4,5]
5
max( )
功能
获取列表中最大的值
举例
>>> l = [1,2,3,4,5]
>>> max(l)
5
>>> l2 = ['a','b','c','d','e']
>>> max(l2)
'e'
min( )
功能
获取列表中最小的值
举例
>>> l = [1,2,3,4,5]
>>> min(l)
1
>>> l2 = ['a','b','c','d','e']
>>> min(l2)
'a'
sum( )
功能
将序列的元素相加
举例
>>> l = [1,2,3,4,5]
>>> sum(l)
15
cmp( )
功能
对比两个列表的大小
-1
小于
1
大于
0
相等
举例
>>> l1 = [1,2,3,4,5]
>>> l2 = [2,3,4,5,6]
>>> cmp(l1, l2)
-1
>>> l2 = ['a','b','c','d','e']
>>> cmp(l1,l2)
-1
>>> l3 = ['a','b','c','d','e','f']
>>> cmp(l3,l2)
1
原理
1. 对两个列表的元素进行比较.
2. 如果比较的元素是同类型的,则比较其值,返回结果.
3. 如果两个元素不是同一种类型,则检查它们是否是数字.
a. 如果是数字,执行必要的数字强制类型转换,然后比较.
b. 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
c. 否则,通过类型名字的字母顺序进行比较.
4. 如果有一个列表首先到达末尾,则另一个长一点的列表"大".
5. 如果我们用尽了两个列表的元素而且所有元素都是相等的,那么结果就是个平局,就 是说返回一个 0.
列表内置函数
列表增加
L.append( )
功能
添加元素到列表末端
举例
>>> l = [1,2,3]
>>> l.append('hi')
>>> l
[1, 2, 3, 'hi']
>>> l.append(4)
>>> l
[1, 2, 3, 'hi', 4]
L.insert( )
功能
添加元素到具体索引的位置
举例
>>> l = [1,2,3]
>>> l.insert(1,20)
>>> l
[1, 20, 2, 3]
L.extend( )
功能
在本列表的末尾添加其他列表的元素
举例
>>> l1 = [1,2,3]
>>> l2 = [4,5,6]
>>> l1.extend(l2)
>>> l1
[1, 2, 3, 4, 5, 6]
列表删除
L.pop( )
功能
默认删除List末尾的元素，可指定索引删除
举例
>>> l = [1,2,3]
>>> l.pop()
3
>>> l
[1, 2]
>>> l.pop(0)
1
>>> l
[2]
L.remove( )
功能
删除某个指定的元素(第一个匹配项）
举例
>>> l = [1,2,3,1,2]
>>> l.remove(1)
>>> l
[2, 3, 1, 2]
列表搜索
L.count( )
功能
统计某个元素在列表出现的次数
举例
>>> l = [10,20,30,10,20,10]
>>> l.count(10)
3
>>> l.count(30)
1
L.index( )
功能
找出列表某个元素第一个出现的索引位置
举例
>>> l = [10,20,30,10,20,10]
>>> l.index(20)
1
列表排序
L.reverse( )
功能
翻转列表元素位置
举例
>>> l = [1,10,5,15]
>>> l.reverse()
>>> l
[15, 5, 10, 1]
L.sort( )
功能
对列表进行排序(从小到大）
举例
>>> l.sort()
>>> l
[1, 5, 10, 15]
进阶操作
列表解析
概述
列表解析即通过特定的表达式简洁方便生成新的列表
列表迭代
列表生成式
语法
[X for Y in Z]
[X for Y in Z if J]
if J 为判断条件
X为需要得到的结果
X与Y是相关联的
Y是用于遍历Z的参数
Z是被遍历的对象
Z可以是字符串/元祖/列表/字典/函数等可迭代对象
举例
>>> [x + 1 for x in (1,2,3)]
X即x + 1
Y即x
Z即（1，2，3）
[2, 3, 4]
>>> [x for x in 'hello']
X即x
Y即x
Z即‘hello'
['h', 'e', 'l', 'l', 'o']
>>> [x * x for x in range(1,5)]
[1, 4, 9, 16]
>>> [x + 1 for x in [1,2,3,4,5] if x > 3]
[5, 6]
>>> l1 = ['hello','world']
>>> l2 = [x.upper() for x in l1]
>>> l2
['HELLO', 'WORLD']
元组
元组是什么？
定义
元组（Tuple）是一组有序不可变的集合对象类型，可以包括数字、字符串甚至列表/元组等信息。
相比列表，元组的内容不可变，并且采用小括号来创建，其他特性基本相同。
若对象内容操作时，要求是只读的，建议用元组，更安全
若经常需要修改对象内容时，建议用列表，否则每次对元组进行修改，就必须创建新的元组
通过list( )或tuple( )函数可以实现列表和元组的转换
功能
支持复杂的数据存储和处理
用于存储其他对象信息
语法
变量 = （元素1 , 元素2, 元素3 …… ）
T = （'hello', 123, （10,20））
单元组
T = ('hello',)
>>> t = ('hello')
>>> t
'hello'
>>> t = ('hello',)
>>> t
('hello',)
需要加逗号
一些表达式如数学表达式有时候也会用到括号，为了防止歧义，单元组需要加逗号来消除歧义
单列表
>>> l = ['hello']
>>> l
['hello']
>>> l = ['hello',]
>>> l
['hello']
特征
有序
不可变
如何操作元组？
操作符
索引操作符
[]
>>> t = ('hello',123,[10,20])
>>> t[0]
'hello'
>>> t[1]
123
>>> t[2]
[10, 20]
>>> t[2][1]
20
替换/修改
>>> t[0] = 'hi'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[2][0] = 5
>>> t
('hello', 123, [5, 20])
切片操作符
[:]
>>> t = ('hello',123,[10,20])
>>> t[0:1]
('hello',)
>>> t[0:2]
('hello', 123)
>>> t[0:3]
('hello', 123, [10, 20])
连接操作符
+
>>> t = ('hello',123)
>>> t1 = ('hello',123)
>>> t2 = (456,789)
>>> t = t1 + t2
>>> t
('hello', 123, 456, 789)
重复操作符
*
>>> t = ('hello', 123)
>>> t * 2
('hello', 123, 'hello', 123)
成员操作符
in
>>> t = ('hello', 123)
>>> 'hello' in t
True
>>> '456' in t
False
not in
>>> 123 not in t
False
内置函数
T.count( )
功能
统计某个元素在列表出现的次数
举例
>>> t = ('hello',10,20,30,10,20,30)
>>> t.count('hello')
1
>>> t.count(10)
2
T.index( )
功能
找出列表某个元素第一个出现的索引位置
举例
>>> t = ('hello',10,20,30,10,20,30)
>>> t.index(10)
1
映射
字典
字典是什么？
定义
字典（dict）是一种无序集合对象类型，可以存储任意的数据类型
字典也是Python中唯一的映射类型，通过"key-value"键值对的方式存储数据
与列表相比，字典是无序的，列表是有序；列表采用偏移位置来存取，字典采用键/散列映射来存取，速度快效率高
列表虽然速度慢，但是内存消耗小
字典虽然速度快，但是内存消耗大
功能
支持复杂的数据存储和处理
用于存储其他对象信息
Python最强大的“容器”
语法
变量 = {键1:值1，键2:值2，……}
d = {key1 : value1, key2 : value2，…… }
d ={'A':1,'B':2,'C':3}
原理
特征
无序
字典中信息没有按索引位置存储，而是按照散列映射关系存储
可变
键是不可变的，并且必须是唯一的
键值对根据键的散列值作为索引，若键发生变动，则无法找到对应的值
键只能由数字、字符串、元组等不可变对象组成，不能用列表
>>> d ={['a']:1,'B':2,'C':3}
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
一个键只能对应一个值
>>> d ={'A':1,'B':2,'C':3,'A':4}
>>> d
{'A': 4, 'C': 3, 'B': 2}
值是可变的，相同值可以出现在同一字典
如何操作字典？
操作符
查找操作符
d[k]
通过键'k'，查询字典中某元素的值
>>> d ={'A':1,'B':2,'C':3}
>>> d['A']
1
d[k] = v
通过键'k'，给字典中某元素赋值'v' ；若字典没有本键'k'，则新增进来
>>> d ={'A':1,'B':2,'C':3}
>>> d['A'] = 10
>>> d
{'A': 10, 'C': 3, 'B': 2}
>>> d ={'A':1,'B':2,'C':3}
>>> d['D'] = 4
>>> d
{'A': 1, 'C': 3, 'B': 2, 'D': 4}
成员操作符
in
>>> 'A' in d
True
>>> 'a' in d
False
not in
>>> 'a' not in d
True
内置函数
d.items()
功能
返回一个由字典d的键-值对组成的视图（view）
举例
>>> d ={'A':1,'B':2,'C':3}
>>> d.items()
[('A', 1), ('C', 3), ('B', 2)]
d.keys()
功能
返回一个由字典d的键组成的视图
举例
>>> d.keys()
['A', 'C', 'B']
d.values()
功能
返回一个由字典d的值组成的视图
举例
>>> d.values()
[1, 3, 2]
d.get(key)
功能
返回与key相关联的值
举例
>>> d.get('A')
1
>>> d.get('B')
2
>>> d.get('a')
无报错返回空值
d.pop(key)
功能
删除键key并返回与之相关联的值
举例
>>> d ={'A':1,'B':2,'C':3}
{'C': 3, 'B': 2}
>>> d
>>> d.pop('A')
1
d.popitem()
功能
删除某个键值对，返回字典d中的某个键-值对
举例
>>> d ={'A':1,'B':2,'C':3}
>>> d.popitem()
('A', 1)
>>> d
{'C': 3, 'B': 2}
>>> d.popitem()
('C', 3)
>>> d
{'B': 2}
>>> d.popitem()
('B', 2)
>>> d
{}
d.clear()
功能
删除字典d的所有元素
举例
>>> d ={'A':1,'B':2,'C':3}
>>> d.clear()
>>> d
{}
d.copy()
功能
（拷贝）复制字典d
举例
>>> d1 = {'A':1,'B':2,'C':3}
>>> d2 = d1.copy()
>>> d2
{'A': 1, 'C': 3, 'B': 2}
d.update(e)
功能
(合并）将e中的键值对添加到字典d中
举例
>>> d1 = {'A':1,'B':2,'C':3}
>>> d2 = {'D':4,'E':5,'F':6}
>>> d1.update(d2)
>>> d1
{'A': 1, 'C': 3, 'B': 2, 'E': 5, 'D': 4, 'F': 6}
d.setdefault(key, v)
功能
如果键key包含在字典d中，则返回其值；否则，返回v并将(key, v)添加到字典d中
举例
>>> d ={'A':1,'B':2,'C':3}
>>> d.setdefault('D',4)
4
>>> d
{'A': 1, 'C': 3, 'B': 2, 'D': 4}
d.has_key(key)
功能
判断某个key是否在字典中，如果有返回True，没有返回False
举例
>>> d ={'A':1,'B':2,'C':3}
>>> d.has_key('A')
True
>>> d.has_key('a')
False
集合
集合是什么？
定义
集合（set）是一种无序不重复对象类型
集合类似字典，但是只有键，没有值
功能
消除重复元素
将列表中的重复元素消除
实现交、并、差等数学计算
语法
变量 = set(列表/字符串 )
s = set(list)
>>> list = [1,2,3,1,2,4]
>>> s1 = set(list)
>>> s1
set([1, 2, 3, 4])
s = set(str)
>>> str = 'hello,world;hi,world'
>>> s2 = set(str)
>>> s2
set(['e', 'd', 'i', 'h', 'l', 'o', ',', 'r', 'w', ';'])
特征
无序
类似字典，没有序列/索引，不支持切片和索引访问
不重复
每个项在集合中都是唯一的
可变&不可变
可变集合
set( )
可增加删除元素
不可变集合
frozenset( )
不可增删
如何操作集合？
操作符
交集
&
功能
获取集合中相同的元素
举例
>>> l1 = [1,2,3,4,5]
>>> l2 = [2,3,4,5,6]
>>> s1 = set(l1)
>>> s1
set([1, 2, 3, 4, 5])
>>> s2 = set(l2)
>>> s2
set([2, 3, 4, 5, 6])
>>> s1 & s2
set([2, 3, 4, 5])
并集
|
功能
将集合中的元素合并
举例
>>> s1 | s2
set([1, 2, 3, 4, 5, 6])
差集
-
功能
获取集合中的不同元素，不同元素在s1中
举例
>>> s1 - s2
set([1])
^
功能
对称差分，获取集合中的不同元素，元素在不同集合中（并集减去交集）
举例
>>> s1 ^ s2
set([1, 6])
内置函数
交集
s.intersection( )
>>> s1.intersection(s2)
set([2, 3, 4, 5])
并集
>>> s.union( )
>>> s1.union(s2)
set([1, 2, 3, 4, 5, 6])
差集
s.difference( )
>>> s1.difference(s2)
set([1])
s.symmetric_difference( )
>>> s1.symmetric_difference(s2)
set([1, 6])
增加
s.add( )
功能
增加元素
举例
>>> s1
set([1, 2, 3, 4, 5])
>>> s1.add(10)
>>> s1
set([1, 2, 3, 4, 5, 10])
>>> s1.add(1)
增加已经存在的元素，集合不改变
>>> s1
set([1, 2, 3, 4, 5, 10])
s.update( )
功能
增加集合中的元素（集合叠加）
举例
>>> s1.update(s2)
>>> s1
set([1, 2, 3, 4, 5, 6, 10])
删除
s.remove( )
功能
删除特定元素；若没有该元素则报错
举例
>>> s1
set([1, 2, 3, 4, 5, 6, 10])
>>> s1.remove(1)
>>> s1
set([2, 3, 4, 5, 6, 10])
>>> s1.remove(1)
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 1
s.discard( )
功能
删除特定元素；若没有该元素不报错
举例
>>> s1
set([2, 3, 4, 5, 6, 10])
>>> s1.discard(1)
>>> s1
set([2, 3, 4, 5, 6, 10])
>>> s1.discard(2)
>>> s1
set([3, 4, 5, 6, 10])
s.pop( )
功能
删除一个元素
举例
>>> s1
set([1, 2, 3, 4, 5])
>>> s1.pop()
1
>>> s1
set([2, 3, 4, 5])
清除
s.clear( )
功能
清除该集合
举例
>>> s1
set([3, 4, 5])
>>> s1.clear()
>>> s1
set([])
判断
s.issubset
功能
判断s1是否s2的子集
举例
>>> s1
set([1, 2, 3, 4, 5, 6, 7])
>>> s2
set([2, 3, 4, 5, 6])
>>> s1.issubset(s2)
False
s.issuperset
功能
判断s1包含s2
举例
>>> s1.issuperset(s2)
True