一直是悬浮，什么叫悬浮。就是总感觉自己不太会，基础没打好。特以此篇告诫自己，告别python最基础的语法，让自己脚步落到实处，踏实了，才不会被踩空，才能走得更远。我从来不相信什么懒洋洋的自由 我向往的自由是通过勤奋和努力实现的更广阔的人生 那样的自由才是珍贵的 有价值的 我相信一万小时定律 从不相信天上掉馅饼的灵感和坐等的成就 做一个自由又自律的人 靠誓必实现的决心认真的活着.
一、什么是python：
1、Python 是一门有条理的和强大的面向对象的程序设计语言，类似于Perl, Ruby, Scheme, Java。
知识点解析：
（1）什么叫面向对象
是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。
(2)为什么是有条理，强大呢？
有条理：
1、设计者开发时总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。这在由Tim Peters写的Python格言（称为The Zen of Python）里面表述为：There should be one-- and preferably only one --obvious way to do it. 这正好 和 Perl语言（另一种功能类似的高级动态语言）的中心思想TMTOWTDI（There's More Than One Way To Do It）完全相反。
2、ython的作者有意的设计限制性很强的语法，使得不好的编程习惯（例如if语句的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的缩进规则。
强大：
1、Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。
2、开发效率非常高，Python有非常强大的第三方库，基本上你想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子。
3、高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
4、移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工 作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行
5、可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
6、可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。
二、python是一门什么样的语言。
解释型语言
编译型vs解释型区别
编译型
优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。
解释型
优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。
缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。
三、python基础语法：
数据类型包括：列表，字典，字符串，元组，数字
其中：可变：列表，字典 ； 不可变：字符串，元组，数字
对于访问来说：数字是没法遍历；字符串，列表，元组可以根据下标可以遍历访问；字典可以通过键值进行访问
对于存放类型来说：数字和字符串只能存放本身，数字只能存放数字，字符串只能存放字符串；字典，列表，元组可以存放各种基础数据类型
1、Number 数字开端：
（1）特点：
Python Number 数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
您也可以使用del语句删除一些 Number 对象引用。
- del语句的语法：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象，例如：
del var
del var_a, var_b
- Python 支持四种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
- 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
- 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
| int | long | float | complex |
|---|---|---|---|
| 10 | 51924361L | 0.0 | 3.14j |
| 100 | -0x19323L | 15.20 | 45.j |
| -786 | 0122L | -21.9 | 9.322e-36j |
| 080 | 0xDEFABCECBDAECBFBAEl | 32.3+e18 | .876j |
| -0490 | 535633629843L | -90. | -.6545+0J |
| -0x260 | -052318172735L | -32.54e100 | 3e+26J |
| 0x69 | -4721885298529L | 70.2-E12 | 4.53e-7j |
- 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
- Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
Python Number 类型转换
int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
Python math 模块、cmath 模块
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
要使用 math 或 cmath 函数必须先导入：
import math
实例
>>> import cmath
>>> cmath.sqrt(-1)
1j
>>> cmath.sqrt(9)
(3+0j)
>>> cmath.sin(1)
(0.8414709848078965+0j)
>>> cmath.log10(100)
(2+0j)
>>>
Python数学函数
函数 返回值 ( 描述 ) abs(x) 返回数字的绝对值，如abs(-10) 返回 10 ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5 cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0 floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4 log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0 max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。 min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。 modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 pow(x, y) x**y 运算后的值。 round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 sqrt(x) 返回数字x的平方根
Python随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
函数 描述 choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1 random() 随机生成下一个实数，它在[0,1)范围内。 seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 shuffle(lst) 将序列的所有元素随机排序 uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。
Python三角函数
Python包括以下三角函数：
函数 描述 acos(x) 返回x的反余弦弧度值。 asin(x) 返回x的反正弦弧度值。 atan(x) 返回x的反正切弧度值。 atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。 cos(x) 返回x的弧度的余弦值。 hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。 sin(x) 返回的x弧度的正弦值。 tan(x) 返回x弧度的正切值。 degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 radians(x) 将角度转换为弧度
Python数学常量
常量 描述 pi 数学常量 pi（圆周率，一般以π来表示） e 数学常量 e，e即自然常数（自然常数）。
2、字符串
在python有各种各样的string操作函数。在历史上string类在python中经历了一段轮回的历史。在最开始的时候，python有一个专门的string的module，要使用string的方法要先import，但后来由于众多的python使用者的建议，从python2.0开始， string方法改为用S.method()的形式调用，只要S是一个字符串对象就可以这样使用，而不用import。同时为了保持向后兼容，现在的 python中仍然保留了一个string的module，其中定义的方法与S.method()是相同的，这些方法都最后都指向了用S.method ()调用的函数。要注意，S.method()能调用的方法比string的module中的多，比如isdigit()、istitle()等就只能用 S.method()的方式调用。
对一个字符串对象，首先想到的操作可能就是计算它有多少个字符组成，很容易想到用S.len()，但这是错的，应该是len(S)。因为len()是内置函数，包括在__builtin__模块中。python不把len()包含在string类型中，乍看起来好像有点不可理解，其实一切有其合理的逻辑在里头。len()不仅可以计算字符串中的字符数，还可以计算list的成员数，tuple的成员数等等，因此单单把len()算在string里是不合适，因此一是可以把len()作为通用函数，用重载实现对不同类型的操作，还有就是可以在每种有len()运算的类型中都要包含一个len()函数。 python选择的是第一种解决办法。类似的还有str(arg)函数，它把arg用string类型表示出来。
格式化输出：
-
1. 格式化字符串
字符串格式化使用字符串格式化操作符即百分号%来实现。在%左侧放置一个字符串(格式化字符串)，而右侧则放置希望格式化的值(可以是元组或字典等)。
注意：
如果格式化里面包含了百分号，那么必须使用%%，这样Python就不会将百分号误认为是转换说明符了。
基本的转换说明符包含以下部分，注意其中的顺序：
- %字符：标记转换说明符的开始
- 转换标识(可选)：
-表示左对齐；+表示在转换值之前要加上正负号；""空白字符表示正数之前保留空格；0表示转换值若位数不够则用0填充 - 最小字段宽度(可选)：转换后的字符串至少应该具有该值指定的宽度。如果是
*，则宽度会从值元组中读出 - 点(
.)后跟精度值(可选)：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将会从元组中读出。 - 转换类型，详见下表：
| 字符串格式转换类型 | |
| 格式 | 描述 |
| %c | 字符及其ASCII码 |
| %s | 字符串(使用str转换任意Python对象) |
| %r | 字符串(使用repr转换任意Python对象) |
| %d(%i) | 有符号整数(十进制) |
| %u | 无符号整数(十进制) |
| %o | 无符号整数(八进制) |
| %x | 无符号整数(十六进制) |
| %X | 无符号整数(十六进制大写字符) |
| %e | 浮点数字(科学计数法) |
| %E | 浮点数字(科学计数法，用E代替e) |
| %f(%F) | 浮点数字(用小数点符号) |
| %g | 浮点数字(根据值的大小采用%e或%f) |
| %G | 浮点数字(类似于%g) |
| %p | 指针(用十六进制打印值的内存地址) |
| %n | 存储输出字符的数量放进参数列表的下一个变量中 |
-
1.1 简单转换
简单的转换只需要写出转换类型即可，如下：
1 # --- coding: utf-8 --- 2 from math import pi 3 4 # 输出：'price of eggs: $42' 5 print 'price of eggs: $%d' % 42 6 7 # 输出：'Hexadecimal price of eggas: 2a' 8 print 'Hexadecimal price of eggas: %x' % 42 9 10 # 输出：'Pi: 3.141593...' 11 print 'Pi: %f...'% pi 12 13 # 输出：'Very inexact estimate of pi: 3' 14 print 'Very inexact estimate of pi: %i' % pi 15 16 # 输出：'using str: 42' 17 print 'using str: %s' % 42L 18 19 # 输出：'Using repr: 42L' 20 print 'Using repr: %r' %42L
-
1.2 字段宽度和精度
转换说明符可以包括字段宽度和精度。字段宽度是转换后的值保留的最小字符个数，精度(对于数字转换来说)则是结果中应该包含的小数位数，或者(对于字符串转换来说)是转换后的值所能包含的最大字符个数。
1 # --- coding: utf-8 --- 2 from math import pi 3 4 # 输出: 3.141593 5 print '%10f' % pi # 字段宽：10 6 7 # 输出: 3.14 8 print '%10.2f' % pi # 字段宽：10，精度：2 9 10 # 输出:3.14 11 print '%.2f' % pi #精度2 12 13 # 输出:Guido 14 print '%.5s' % 'Guido van Rossum' # 精度：5 15 16 # 输出:Guido(使用元组参数-精度) 17 print '%.*s' % (5,'Guido van Rossum') # 精度：5 18 19 # 输出: Guido(使用元组参数-字段宽，精度) 20 print '%*.*s' % (10,5,'Guido van Rossum') # 字段宽：10，精度：5
-
1.3 符号、对齐和0填充
在字段宽度和精度值之前可以(可选)放置一个"标表"，该标表的值可以是：
0(零)：表示数字将会用0进行填充+(加号)：表示不管是正数还是负数都标示出符号(在对齐时很有用)-(减号)：表示左对齐数值- 空格：表示正数前加上空格，这对需要对齐正负数时会很有用
具体使用方法可以参考下面的示例：
1 # --- coding: utf-8 ---
2 from math import pi
3
4 # 输出:0000003.14
5 print '%010.2f' % pi
6
7 # 输出:3.14
8 print '%-10.2f' % pi
9
10 # 输出:
11 # 10
12 # -10
13 print ('% 5d' % 10) + '
' + ('% 5d' % -10)
14
15 # 输出:
16 # +10
17 # -10
18 print ('%+5d' % 10) + '
' + ('%+5d' % -10)
2. 常用字符串函数
Python为字符串创建了很多有用的函数，了解更多请参考Python文档：http://docs.python.org/2/library/string.html，下面例举了一下常用的字符函数。
-
2.1 find
find函数可以在一个较长的字符串中查找子字符串。并返回子串所在位置的最左端索引，如果没有找到则返回：-1，S.find(substr, [start, [end]])
#返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索 如下所示：
1 # --- coding: utf-8 ---
2 title = "Monty Python's Flying Circus"
3
4 # 返回:6
5 print title.find('Python')
6
7 # 返回:-1
8 print title.find('ruby')
9
10 # 返回:6,提供查找起始点(包含)
11 print title.find('Python',6)
12
13 # 返回:6,提供查找起始点(包含)和结束点(不包含)
14 print title.find('Python',6,12)
-
2.1 join
join函数用来在队列中添加元素，和split函数作用相反。如下：
1 # --- coding: utf-8 --- 2 seq = ['1','2','3','4','5'] 3 sep = '+' 4 dirs ='','usr','bin','env' 5 6 # 输出:1+2+3+4+5 7 print sep.join(seq) 8 9 # 输出:/usr/bin/env 10 print '/'.join(dirs) 11 12 # 输出:C:usrinenv 13 print 'C:' + '\'.join(dirs)
-
2.2 lower
lower函数返回字符串的小写字母版本。如下：
1 # --- coding: utf-8 --- 2 # 输出：apple 3 print 'APPLE'.lower()
-
2.3 replace
replace函数返回某字符串的所有匹配项均被替换自后得到字符串。如下：
1 # --- coding: utf-8 ---
2 # 输出：Theez eez a test.
3 print 'This is a test.'.replace('is','eez')
-
2.4 split
join的逆函数，用来将字符串分割成序列，如下：
1 # --- coding: utf-8 ---
2 seq = '1+2+3+4+5'
3 unix_dirs ='/usr/bin/env'
4 windows_dir = r'C:usrinenv'
5
6 print seq.split('+')
7 print unix_dirs.split('/')
8 print windows_dir.split('\')
9 # 分别打印输出：
10 # ['1', '2', '3', '4', '5']
11 # ['', 'usr', 'bin', 'env']
12 # ['C:', 'usr', 'bin', 'env']
-
2.5 strip
strip函数剔除字符串两侧空格字符串(默认)：
1 # --- coding: utf-8 ---
2 fruit = ' apple and orange '
3 print repr(fruit)
4 print repr(fruit[:].strip())
5 print repr(fruit.strip(' app'))
6 # 分别输出：
7 # ' apple and orange '
8 # 'apple and orange'
9 # 'le and orange'
2.6 translate
translate函数和replace函数一样，用于替换字符串中的某个部分，但是和replace不同，translate只处理单个字符，而且可以同时进行多个替换。在使用translate函数转换之前，需要一张转换表，转换表中是以某个字符替换某个字符的对应关系，这个表中有 256个字符，我们可以通过使用string模块中的maketrans函数简化这一操作：
1 # --- coding: utf-8 ---
2 from string import maketrans
3 table = maketrans('cs','kz')
4 # 输出：thiz iz an inkredible tezt
5 print 'this is an incredible test'.translate(table)
字符串中字符大小写的变换：
S.lower() #小写
S.upper() #大写
S.swapcase() #大小写互换
S.capitalize() #首字母大写
String.capwords(S)
#这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起 经过测试目前3.0无法使用
S.title() #只有首字母大写，其余为小写，模块中没有这个方法
字符串在输出时的对齐： （没有测试）
S.ljust(width,[fillchar])
#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.center(width, [fillchar]) #中间对齐
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足
字符串中的搜索和替换：
S.index(substr, [start, [end]])
#与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]])
#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]]) #计算substr在S中出现的次数
结果为：6，3，9 所以在py3.0中 3和9区间中是错误的，无法用区间取值
S.replace(oldstr, newstr, [count])
#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
S.strip([chars])
#把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
S.lstrip([chars])
S.rstrip([chars])
S.expandtabs([tabsize])
#把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
字符串的分割和组合：
目前extande测试方法无法测试出来 没有被替换。需要进一步研究
S.join(seq) #把seq代表的序列──字符串序列，用S连接起来 是sep.join（s）
字符串的mapping，这一功能包含两个函数：
String.maketrans(from, to) （不进行测试）相关请看https://blog.csdn.net/u014351782/article/details/46740297
#返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
S.translate(table[,deletechars])
# 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
字符串还有一对编码和解码的函数：
重点：编码和解码https://blog.csdn.net/m0_38080253/article/details/78841280（此博客详细讲解了encode和decode，还包括其他编码方式）
S.encode([encoding,[errors]])
# 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。这一部分内容涉及codecs模块，不是特明白
S.decode([encoding,[errors]])
字符串的测试函数，这一类函数在string模块中没有，这些函数返回的都是bool值：
S.startwith(prefix[,start[,end]])
#是否以prefix开头
S.endwith(suffix[,start[,end]])
#以suffix结尾
S.isalnum() 以下判断会在一些练习题中出现 在这里不做练习：
#是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isdigit() #是否全是数字，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的
字符串类型转换函数，这几个函数只在string模块中有：
string.atoi(s[,base])
#base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串
string.atol(s[,base]) #转成long
string.atof(s[,base]) #转成float
这里再强调一次，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个新的字符串，原字串并没有变。其实这也是有变通的办法的，可以用S=list(S)这个函数把S变为由单个字符为成员的list，这样的话就可以使用S[3]='a'的方式改变值，然后再使用S=" ".join(S)还原成字符串
3、列表
列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
一、列表具有特点：1、是python的一个内建数据解构；2、可以把列表看做一个容器；3、该荣期被隔成不同的空间，每个空间都可以存放任何类型的‘物’；4、列表内物体只有前后位置关系；5、列表每一个各自中的‘物‘可以替换的；6、列表是一个可变的序列。
二、语法：
列表名=【列表内容】
三、使用list函数创建列表
L = list()创建空字符串
四、列表运算
+运算 亲测没有-
# a = [1,2,3]+[4,5,6]
# b = a+[7,8]
# c = [9,10]
# d = b + c
# print(d)
# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+=运算
# a = [1,2,3]
# a += [4,5,6]
# print(a)
# [1, 2, 3, 4, 5, 6]
*运算（复制）
# a = [8] * 5
# print(a)
# [8, 8, 8, 8, 8]
*=运算
# a = [1,2,3]
# a *= 8
# print(a)
# [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3,
关系运算
返回True或者False
# a = [9,2,3]
# b = [4,100,6]
# print(a != b)
# print(a > b)
# True
# True
in运算
# a = ['a',2,'1']
# print('1' in a)
# True
、
and,or，no运算
and用法
Python 中，and 和 or 执行布尔逻辑演算，但是它们并不返回布尔值，而是返回它们实际进行比较的值之一。
'a' and 'b'
'b'
'' and 'b'
''
'a' and 'b' and 'c'
'c'
使用 and 时，在布尔上下文中从左到右演算表达式的值。0、''、[]、()、{}、None 在布尔上下文中为假；其它任何东西都为真。默认情况下，布尔上下文中的类实例为真，但是你可以在类中定义特定的方法使得类实例的演算值为假。如果布尔上下文中的所有值都为真，那么 and 返回最后一个值。在这个例子中，and 演算'a' 的值为真，然后是 'b' 的演算值为真，最终返回 'b'。 如果布尔上下文中的某个值为假，则 and 返回第一个假值。在这个例子中，'' 是第一个假值。
or用法
'a' or 'b'
'a'
'' or 'b'
'b'
'' or [] or {}
{}
可以看出，使用 or 时，在布尔上下文中从左到右演算值，就像 and 一样。如果有一个值为真，or 立刻返回该值。如果所有的值都为假，or 返回最后一个假值。
not用法
not[] True not[1,2] False
五、列表索引与切片访问
1、列表索引index
索引从0开始，列表最后一个成员的索引为列表长度-1
2、列表切片slice
切片语法同字符串[起始：结束：步长]
3、列表slice
通过切片获得新列表
列表切片赋值
切片赋值一次此修改多个列表元素
切片赋值可以增加列表元素
切片赋值可以不替换任何元素的情况下，为列表插入新元素
切片赋值可以删除列表元素
六、常用列表函数
1、len函数
可以用来得到序列长度
2、max函数，3、min函数
得到序列最大值
得到序列最小值
4、sum函数
---可以得到列表中所有元素的和
---sum(列表【，起始值】)
---起始值可以省略，缺省为0 # -*- coding:utf-8 -*-
a=[1,2,3]
b = sum(a)
print(b,type(b))
d = sum([b,10])
print(d)
"""
6 <class 'int'>
16
Process finished with exit code 0
"""
5、index函数:得到列表中某个元素的索引（下标）
---L.index(value)
---value:要找的元素
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,33,88,9]
b = a.index(9) #相同的元素只会操作第一次出现的位置
print(b)
"""
5
Process finished with exit code 0
"""
6、append函数
----L.append(object)
----object要添加的元素
----返回None
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,33,88,9]
b = a.append("alex")
print(a)
print(b)
c = a.append([11,22])
print(a)
print(c)
"""
[1, 2, 3, 5, 6, 9, 10, 33, 88, 9, 'alex']
None
[1, 2, 3, 5, 6, 9, 10, 33, 88, 9, 'alex', [11, 22]]
None
Process finished with exit code 0
"""
7、合并列表（extend）
向列表追加另一个列表
----L.extend(iterable)
----iterable要添加的元素（可以迭代对象）
----返回None
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,33,88,9]
b = a.extend("alex")
print(a)
print(b)
c = a.extend(100)
print(a)
print(c)
"""
[1, 2, 3, 5, 6, 9, 10, 33, 88, 9, 'a', 'l', 'e', 'x']
None
c = a.extend(100)
TypeError: 'int' object is not iterable
Process finished with exit code 0
"""
跟元组一样，用加号（+）将两个列表加起来即可实现合并：
# -*- coding:utf-8 -*-
x=list(range(1, 13, 2))
x + ['b', 'a']
print(x)
"""
[1, 3, 5, 7, 9, 11, 'b', 'a']
Process finished with exit code 0
"""
对于已定义的列表，可以用extend方法一次性添加多个元素：
# -*- coding:utf-8 -*-
x=[1, 3, 5, 7, 9, 11]
x2=[3, 6, 1]
x.extend(x2)
print(x)
"""
[1, 3, 5, 7, 9, 11, 3, 6, 1]
Process finished with exit code 0
"""
需要说明的是：加号（+）执行列表的合并是非常浪费资源的，因为必须创建一个新列表并将所有对象复制过去，而用extend将元素附加到现有列表（尤其是在构建一个大列表时）就会好很多。
因此，在进行列表合并操作时，尤其是对于大数据量的列表合并，强烈建议使用extend函数。
8.insert函数：向列表指定位置插入元素
---L.insert(index,object)
---index:位置
---object要插入的元素
---返回None
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,33,88,9]
b = a.insert(2,["alex","rose"])
print(a)
print(b)
c = a.insert(5,100)
print(a)
print(c)
"""
[1, 2, ['alex', 'rose'], 3, 5, 6, 9, 10, 33, 88, 9]
None
[1, 2, ['alex', 'rose'], 3, 5, 100, 6, 9, 10, 33, 88, 9]
None
Process finished with exit code 0
"""
9、pop函数
---L.pop([index])
---删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回移除元素
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,33,88,9]
b = a.pop()
print(a)
print(b)
c = a.pop(2)
print(a)
print(c)
d = a.pop(-1)
print(a)
print(d)
"""
[1, 2, 3, 5, 6, 9, 10, 33, 88]
9
[1, 2, 5, 6, 9, 10, 33, 88]
3
[1, 2, 5, 6, 9, 10, 33]
88
Process finished with exit code 0
"""
10、remove函数：
---L.remove(x）
---从列表中删除第一次出现在列表中的值
---返回None
a=[1,2,3,5,6,9,10,"alex",33,88,9]
b = a.remove(5)
print(a)
print(b)
c = a.remove("alex")
print(a)
print(c)
"""
[1, 2, 3, 6, 9, 10, 'alex', 33, 88, 9]
None
[1, 2, 3, 6, 9, 10, 33, 88, 9]
None
Process finished with exit code 0
"""
11、del 语句删除列表元素
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
b = a.remove(5)
print(a)
print(b)
c = a.remove("alex")
print(a)
print(c)
"""
[1, 2, 3, 6, 9, 10, 'alex', 33, 88, 9]
None
[1, 2, 3, 6, 9, 10, 33, 88, 9]
None
Process finished with exit code 0
"""
12、copy函数
---L.copy() 浅复制处解析
---复制此列表（只复制一层，不会复制深层对象）
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
b =a.copy()
print(a,id(a))
print(b,id(b))
c =a is b
print(c)
d =a
print(d,id(d))
"""
[1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9] 44549704
[1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9] 44549744
False
[1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9] 44549704
Process finished with exit code 0
"""
13、reverse
---列表的反转，只反转排列顺序，列表的值是不会改变的
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
print("反转前的数据===》",a)
b =a.reverse()
print("反转后的数据===》",a)
print(b)
"""
反转前的数据===》 [1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9]
反转后的数据===》 [9, 88, 33, 'alex', 10, 9, 6, 5, 3, 2, 1]
None
Process finished with exit code 0
"""
14.sort
--Lsort(reverse = False)
---将列表的顺序按值得小到大的顺序进行排列
列表的sort方法可以实现就地排序（无需创建新对象，字符串按首字母进行排序）：
# -*- coding:utf-8 -*-
a=[1,72,3,45,6,9,10,33,88,9]
print("排序前的数据===》",a)
b =a.sort()
print("排序后的数据===》",a)
print(b)
s=['a','ab','3e','z']
print("排序前的数据===》",s)
g=s.sort()
print("排序后的数据===》",s)
"""
排序前的数据===》 [1, 72, 3, 45, 6, 9, 10, 33, 88, 9]
排序后的数据===》 [1, 3, 6, 9, 9, 10, 33, 45, 72, 88]
None
排序前的数据===》 ['a', 'ab', '3e', 'z']
排序后的数据===》 ['3e', 'a', 'ab', 'z']
Process finished with exit code 0
"""
sort有几个很好用的选项，一个是次要排序键，即一个能够产生可用于排序的值的函数。如可以通过长度对一组字符串进行排序：
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
b=['a','nl','drz','mowgt','aa']
b.sort(key=len)
print(b)
"""
['a', 'nl', 'aa', 'drz', 'mowgt']
Process finished with exit code 0
"""
再比如是否进行降序排列，如下面通过对首字母进行降序排列的示例：
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
b=['a','nl','drz','mowgt','aa']
b.sort(key= lambda x:x[0], reverse=True)
print(b)
"""
['nl', 'mowgt', 'drz', 'a', 'aa']
Process finished with exit code 0
"""
15、clean：清空列表
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
print("清空前的数据===》",a)
b =a.clear()
print("清空后的数据===》",a)
print(b)
"""
清空前的数据===》 [1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9]
清空后的数据===》 []
None
Process finished with exit code 0
"""
7、列表的遍历
1）使用while循环
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
i=0
while i<len(a):
print(a[i])
i+=1
"""
1
2
3
5
6
9
10
alex
33
88
9
Process finished with exit code 0
"""
2）使用for循坏
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
for i in a:
print(i)
"""
1
2
3
5
6
9
10
alex
33
88
9
Process finished with exit code 0
"""
8、列表复制
浅复制只复制一层
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a=[1,2,3,5,6,9,10,"alex",33,88,9]
b=a
print(b)
b[0]="rose"
print(b)
print(a)
print(a is b)
"""
[1, 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9]
['rose', 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9]
['rose', 2, 3, 5, 6, 9, 10, 'alex', 33, 88, 9]
True
Process finished with exit code 0
"""
深拷贝需要使用copy模块
---全部复制
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
import copy
a=[1,2,3,5,[6,9,10],"alex",33,88,9]
b = copy.deepcopy(a)
print(a,id(a))
print(b,id(b))
print(a is b)
b[4][0]=40
print(b)
"""
[1, 2, 3, 5, [6, 9, 10], 'alex', 33, 88, 9] 47178256
[1, 2, 3, 5, [6, 9, 10], 'alex', 33, 88, 9] 47179016
False
[1, 2, 3, 5, [6, 9, 10], 'alex', 33, 88, 9]
[1, 2, 3, 5, [40, 9, 10], 'alex', 33, 88, 9]
Process finished with exit code 0
"""
9、列表推导式语法
列表推导式是用可迭代对象依次生成列表内元素的方式
语法：
【表达式for 变量 in 可迭代对象】
或
【表达式 for 变量 in 可迭代对象 if 条件语句】
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
y = [ x**2 for x in range(1,10)]
print(y)
z =[x**2 for x in range(1,10) if x%2==1]
print(z)
"""
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 9, 25, 49, 81]
Process finished with exit code 0
"""
列表推导式嵌套语法
【表达式1 for 变量1 in 可迭代对象1 if 条件语句1 for 变量2 in 可迭代对象3 if 条件语句2】
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
y = [x*y for x in [2,3,5] for y in [7,11,13]]
print(y)
"""
[14, 22, 26, 21, 33, 39, 35, 55, 65]
Process finished with exit code 0
"""
10、列表与字符串
字符串拆分与拼接
----S.split (sep = None,maxsplit = -1) --->list of string
-----S.join(iterable) ---->str
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
a="beijing is captical !"
b =a.split(" ")
print(b)
c = a.split(maxsplit=1)
d = a.split(maxsplit=2)
f = a.split(maxsplit=3)
print(c)
print(d)
print(f)
print("-------join--------")
g="/"
print(g)
h = g.join(["C:","progrom file","python"])
print(h)
"""
['beijing', 'is', 'captical', '!']
['beijing', 'is captical !']
['beijing', 'is', 'captical !']
['beijing', 'is', 'captical', '!']
-------join--------
/
C:/progrom file/python
Process finished with exit code 0
"""
11、字符串与列表比较
---列表 和字符串都是序列，元素之间有先后关系
---字符串中的每个元素只能存储字符，而列表可以存储任意类型
---字符串是不可变的序列，而列表是可以改变的序列
- --------------------
作者：阿紫_PP
来源：CSDN
原文：https://blog.csdn.net/ruanxingzi123/article/details/83188390
版权声明：本文为博主原创文章，转载请附上博文链接
4、字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
访问字典里的值
把相应的键放入到方括号中，如下实例:
实例
以上实例输出结果：
dict['Name']: Runoob
dict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
实例
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
实例
dict['Age']: 8
dict['School']: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
实例
但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
File "test.py", line 9, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
注：del() 方法后面也会讨论。
字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住
（1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
实例
以上实例输出结果：
dict['Name']: 小菜鸟
（2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
实例
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
字典内置函数&方法
Python字典包含了以下内置函数：
| 序号 | 函数及描述 | 实例 |
|---|---|---|
| 1 | len(dict) 计算字典元素个数，即键的总数。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3
|
| 2 | str(dict) 输出字典，以可打印的字符串表示。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
|
| 3 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(dict)
<class 'dict'>
|
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | radiansdict.clear() 删除字典内所有元素 |
| 2 | radiansdict.copy() 返回一个字典的浅复制 |
| 3 | radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | key in dict 如果键在字典dict里返回true，否则返回false |
| 6 | radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表 |
| 8 | radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。 |
例子
#字典类型
#创建字典
#空字典
var = dict()
print(var,type(var))
var = {}
print(var,type(var))
#创建具有多个数据的字典
#1.
var = {'黑':'black','白':'white','蓝':'blue'}
print(var,type(var))
#2.
var = dict({'黑':'black','白':'white','蓝':'blue'})
print(var,type(var))
#3.
var = dict(黑 = 'black',白 = 'white',蓝 = 'blue')
print(var,type(var))
#4.
var = [
['黑','black'],
['白','white'],
['蓝','blue']
]
result = dict(var)
print(result,type(result))
#5.
keys = ['黑','白','蓝']
values = ['black','white','blue']
result = dict(zip(keys,values))
print(result,type(result))
#元素 -> 键值对 -> 键+值
#基本操作
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
#访问字典:
print(var['赵云'])
#修改字典
var['郭嘉'] = '天妒'
print(var)
#删除元素
del var['郭嘉']
print(var)
#添加元素
var['周瑜'] = '公瑾'
print(var)
#序列操作
#成员检测 ->针对于键的操作而不是值
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
result = '士元' in var
print(result)
#len() 检测字典中元素的个数
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
result = len(var)
print(result)
#max() 获取字典中最大的键如果不是数字键 获取最大编码的值
var = {'a':1,'b':2,'c':3,'晷':12}
result = max(var)
print(result)
#min() 获取字典中最小的键如果不是数字键 获取最小编码的值
var = {'a':1,'b':2,'c':3,'晷':12}
result = min(var)
print(result)
#字典的遍历
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
#方法1:先遍历键,再使用变量和键来获取对应的值
for i in var:
print(i,var[i])
#方法2:同时遍历键和值
result = var.items()
print(result,type(result))#不是标准的列表类型
for k,v in var.items():
print(k,v)
#字典推导式
var = {'ag':'sfsf','bg':'fsdf','cg':'df'}
#普通推导式
result = {k:v for k,v in var.items()}
print(result)
#带有判断条件的推导式
result = { k:v for k,v in var.items() if len(v) == 2}
print(result)
#多循环的字典推导式
girls= {'zb':'bo','mm':'mei','jj':'jun'}
boys = {'ll':'le','ff':'fei','ji':'jiao'}
result = { g+b:gv +bv for g,gv in girls.items() for b,bv in boys.items()}
print(result)
#字典相关函数
var = {'孙行者':'孙悟空','沙和尚':'沙悟净','猪八戒':'猪悟能'}
#clear 清空字典
var.clear()
print(var,id(var))
#copy() 复制字典
newvar = var.copy()
print(newvar,id(newvar))
#fromkeys() 使用序列(键)和指定的值(值)制作一个字典
list = ['fda','fsd','jgj','hfg']
result = dict.fromkeys(list,'小鸟')
result = {}.fromkeys(list,'小鸟')
print(result)
#get() 获取字典中指定键的值
result = var.get('猪八戒','默认值')#result =var['猪八戒']
print(result)
#setdefault() 向字典中添加一个元素[不存在的键则添加,存在的键不做任何操作]
var.setdefault('小白龙','小白龙')
print(var)
#update() 修改字典中的元素
var.update(孙行者 = '孙猴子')
print(var)
var.update({'孙行者':'齐天大圣','猪八戒':'天蓬元帅','唐僧':'唐玄奘'})
print(var)
#pop() 删除字典中指定的元素
result = var.pop('唐僧')
print(var)
print(result)
#popitem() 随机删除字典中的一个元素
result = var.popitem()
print(var)
print(result)
#keys() 获取字典中的所有键组成的容器
var = {'苹果':'Apple','梨':'pear'}
result = var.keys()
print(result)
for i in result:
print(i)
#values() 获取字典中的所以值组成的容器
result = var.values()
print(result)
#items() 获取字典中的所有键和值组成的2级容器
result = var.items()
print(result)
元组
Python的元组和列表类似，不同之处在于元组中的元素不能修改(因此元组又称为只读列表)，且元组使用小括号而列表使用中括号，如下:
1 tup1=('physics','chemistry',1997,2000)
2 tup2=(1,2,3,4,5,6)
特别注意:
1、元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义
tup1=（50，）
2、元组中的元素值使不允许修改的，但可以对元组进行连接组合
1 tup1=(12,34.56)
2 tup2=('abc','xyz')
3
4 tup1[0]=100 #非法操作，元组中的元素是不允许被修改的
5
6 tup3=tup1+tup2 #python运行元组进行连接组合
7 print(tup3)# 输出:(12,34.56,'abc','xyz')
3、元组中的元素是不允许删除的，但可以使用del语句来删除整个元组
4、元组之间可以使用+和*，即允许元组进行组合连接和重复复制，运算后会生成一个新的元组
1 tup1=(1,2,3) 2 tup2=(3,4,5) 3 4 tup3=tup1+tup2 #输出：tup3=(1,2,3,3,4,5) 5 tup4=tup1*3 #输出： tup4=(1,2,3,1,2,3,1,2,3)
5、元组运行切片操作
6、任意无符号的对象，以逗号隔开，默认为元组
1 a=1,2,3,'hello' 2 print(a) #输出：(1,2,3,'hello')
7、对元组进行操作的内建函数
——cmp(tup1,tup2): 比较两个元组元素
——len(tup): 返回元组中元素的个数
——max(tup): 返回元组中元素最大的值
——min(tup): 返回元组中元素最小的值
——tuple(seq): 将列表转化为元组
8、元组的方法（元组没有列表中的增、删、改的操作，只有查的操作）
——tuple.index(obj)：从元组中找出某个值第一个匹配项的索引值
——tuple.count(obj)： 统计某个元素在元组中出现的次
集合
特点：
1、不同元素组成
2、是无序的
3、集合中的元素必须是不可变类型（数字，字符串，元组）
4、定义集合的方式：test = {'xyy','xyyp',1,2,3,4}或test = set('xyy')
三、集合功能：
add() 往集合中添加元素，一次只能添加一个元素
|
1
2
3
4
|
test = {'xyy','xyyp',1,2,3,4}test.add(5)test.add('xyp')print(test) |
结果：
clear() 清空集合内容
|
1
2
3
|
test = {'xyy','xyyp',1,2,3,4}test.clear()print(test) |
结果：
copy() 复制一份新的集合内容
|
1
2
3
|
test = {'xyy','xyyp',1,2,3,4}n = test.copy()print(n) |
结果：
pop() 删除随机的一个元素
|
1
2
3
|
test = {'xyy','xyyp',1,2,3,4}test.pop()print(test) |
结果：
remove() 删除指定的内容，如果指定的内容不存在会报错
|
1
2
3
|
test = {'xyy','xyyp',1,2,3,4}test.remove('xyyp')print(test) |
结果：
discard() 删除指定的内容，如果指定的内容不存在不会报错
|
1
2
3
4
|
test = {'xyy','xyyp',1,2,3,4}test.discard('xyy')test.discard('xyyfg')print(test) |
结果：
update() 往集合里面添加多个元素，比add强大一点
|
1
2
3
4
|
test = {'xyy','xyyp','xyp'}test.update(('Jony','Tom')) // 添加的是元组的话结果就是完整的字符串test.update('Jony','Tom') // 添加的是字符串的话结果就是单个字符print(test) |
结果：
isdisjoint() 判断两个集合有木有相同的元素，没有则为真（True）
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyyx','xypc'}n = test1.isdisjoint(test2) // test1和test2没有相同的元素print(n) |
结果：
四、Python的集合关系运算：
1、交集：intersection() 会输出两个集合的相同内容
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'} // 定义两个集合，两个集合有相同和不同的元素test2 = {'xyy','xyp','fg'}n = test1.intersection(test2)print(n) |
结果：
或者：
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n = test1&test2 // intersection可以用&符号代替print(n) |
结果：
2、并集：union() 会输出两个集合的不同内容，并合成一个集合
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n = test1.union(test2)print(n) |
结果：
或者：
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n = test1|test2 // 一个竖线（|）就表示union这个功能print(n) |
3、差集：difference()第一个集合减去第二个集合得出第一个集合不同于第二个集合的一个元素，反过来意思一样
|
1
2
3
4
5
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n1 = test1.difference(test2) //test1集合减去test2集合n2 = test2.difference(test1) //test2集合减去test1集合print(n1,n2) |
结果：
或者：
|
1
2
3
4
5
6
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n1 = test1-test2 // 用减号（-）代替differenceprint(n1)n2 = test2-test1print(n2) |
结果：
4、交叉补集：symmetric_difference()只取两个集合不同的部分
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','fg'}n2 = test1.symmetric_difference(test2)print(n2) |
结果：
或者：
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp','Tom'}n = test1^test2 //symmetric_difference()可以用^代替print(n) |
结果：
5、子集：issubset()判断谁是谁的子集
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp'}n = test2.issubset(test1) //两个集合有相同的部分，但是第二个比第一个元素少，所以第二个是第一个的子集print(n) |
结果：
6、父集：issuperset()判断谁是谁的父集
|
1
2
3
4
|
test1 = {'xyy','xyyp','xyp'}test2 = {'xyy','xyp'}n = test1.issuperset(test2) //两个集合有相同的部分，但是第一个比第二个元素多，所以第一个是第二个的父集print(n) |
结果：
