[TOC]

0x00 Python内置常用函数

Q：如何查看内置函数与方法？
A：dir(builtins) 或者 dir(模块)，以help查询具体方法的说明

>>> import builtins
>>> dir(builtins)

['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError']

['__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__',]

#内置函数
['abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

(1)input(提示字符串) //函数可以用来输入值到返回到变量之中是个字符类型.
(2)type(变量) //函数可以用来查询变量所指的对象类型.
(3)isinstance(变量,类型) //函数可以用来查询变量是否是该类型,判断对象 a 是否为 类 A 的实例对象.
(4)assert 表达式 //断言当这个关键字后面的条件为假的时候，程序自动崩溃并抛出AssertionError异常，常常用在程序置入检查点上。
(5)range(start,stop,step) //生成一个从start参数值到stop参数的值结束的数字序列。
(6)id(变量) //函数用于获取对象内存地址。
(7)sorted(iterator) //返回排序的列表功能与list.sort()相似
(8)reversed() //是一个对象并且返回反序排序的列表功能
(9)enumerate() //返回的是一个对象， 转换成列表并把索引值变成元组插入其中
(10)zip(a, b) //返回的是一个对象，使用list 返回各个由参数的序列组成的元组(tuple)
(11)map(fun,iterator) //根据提供的函数对指定序列做映射,返回包含每次函数返回值的新列表；
(12)filter(fun,iterator) //用于过滤序列过滤掉不符合条件的元素，返回一个迭代器对象返回为true的值;
(13)bin(intnumber) //整形转换成2进制形式 010101
(14)locals() //显示出当前局部变量符号表
(15)issubclass(class,classinfo(元组)） #判断一个类是否为另一个类的子类
isinstance(object, classinfo #判断是否是实例化对象 如果第一个参数不是对象则返回False，第二个参数不是类或者由类对象组合成得元组，会抛出一个TypeError异常；
(16)hasattr(obj,name) #判断实例化对象里面是否存在该属性
(17)getattr(obj,name,[‘找不到属性的时候提示’]) #获取类属性信息,找到则返回该值/否则返回该msg提示
(18)setattr(obj,name,value) #设置类对象属性的值,如果存在则覆盖/不存在则建立该属性
(19)selattr(obj,name) #删除对象中属性
(20)property(fget=None,fset=None,fdel=None,doc=None) #利用属性来设置属性,设置定义好的属性其参数就是写好的方法(允许编程人员轻松、有效地管理属性访问)

案例：

#!/use/bin/python3
#coding utf-8
#内置函数

#1.(input) / print
value = input("请输入一串字符或者数值:")
print("输入的值为 ：",value," | 类型：",type(value))

#2.(type)
a = '520' 
print(type(a))    #<class 'str'>
print(type(5.2))  #<class 'float'>
print(type(True))  #<class 'bool'>

#3.isinstance(类型值,类型) =>类型值能匹配上类型则为True,否则False
print(isinstance(a,str))
print(isinstance(12,int))
print(isinstance(12.5,float))
print(isinstance(True,bool))


#4.assert 断言的使用
>>> assert 3 > 4       //程序为假就assert报错
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    assert 3 > 4
    AssertionError

#5.range()-BIF函数生成序列
print(list(range(5)))  #[0, 1, 2, 3, 4]
for i in range(10):      //默认是从0开始不包含10

  print(i,end=" ")  #0 1 2 3 4 5 6 7 8 9

#6.sorted 排序功能 / 7.reversed
sorted([23,56,2,16,96,12,14])   # [2, 12, 14, 16, 23, 56, 96]
list(reversed([23,56,2,16,96,12,14]))   #reversed 返回的是一个对象, 再用reversed转换成列表显示反序  [14, 12, 96, 16, 2, 56, 23]

#8.enumerate  
list(enumerate([23, 56, 2, 16, 96, 12, 14])) #进行枚举，返回对象然后经过list返回一个（ 索引+数值）的列表元组 //[(0, 23), (1, 56), (2, 2), (3, 16), (4, 96), (5, 12), (6, 14)]
for index,line in enumerate(f): # 还可以将打开的文件进行获取index 与 每一行的值 （当文件较大的时候推荐使用）
    print(index,line)  # 0 #!/usr/bin/python3

#9.zip 列表对应
list(zip([1,2,3], [4,5,6,7]))    #//a与b的列表是一一对应的[(1, 4), (2, 5), (3, 6)]

#10.map 映射功能 注意：强大的map()后边是可以接受多个序列作为参数的。
map(lambda x: x ** 2, [1, 2, 3, 4, 5])   #使用 lambda 匿名函数与map映射 [1, 4, 9, 16, 25]
list(map(lambda x, y : [x, y], [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))  #打包形式是列表而不是元组
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]  


#11.filte 过滤出1~100中平方根是整数的数 #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(filter(lambda x: math.sqrt(x) % 1 == 0,range(100))))  

#13.bin 二进制转换
bin(255)  #'0b11111111'

#14.locals
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}


#15.issubclass()  类的内置函数.START
class t1:
  pass

class t2(t1):
  noneValue = None  #为空值,相当于C中的null
  def __init__(self,x=0):
    self.x = x

print(issubclass(t2,t1))  #t2 是 t1 的子类为真
test = t2(1024)
print(isinstance(test,t1))  #为真的实例化对象test是t1实例化对象

#16.hasattr 注意对象属性是要传入字符串
print(hasattr(test,'x'))  #‘x’是test对象的属性 返回 True

#17.getattr 获取对象属性值
print(getattr(test,'x'))   #1024
print(getattr(test,'e','实例化对象中没有 e 属性')) #有实例化对象中没有 e 属性

#18.setattr  设置对象属性值
setattr(test,e,'Hello world')
print(getattr(test,'e','实例化对象中没有 e 属性')) #hello world

#19.delattr 删除对象属性
delattr(test,'e')

#20.property() 利用属性设置属性（将方法再次进行封装调用,无论里面方法名怎么改,接口始终是不变得）！important
class getSize:
    def __init__(self,size = 0):
        self.size = size
    def getsize(self):
        return self.size
    def setsize(self,value):
        self.size = value
    def delsize(self):
        del self.size
    
    x = property(getsize,setsize,delsize,"I'm the 'x' property.") #包含该类建立得一些方法 (此时x是一个属性)

demo = getSize(1024) #实例化对象
print(demo.x)  #利用属性获取方法返回值  1024
demo.x = 2048  #利用属性设置方法值
print(demo.x)  #获取值   2048
del demo.x     #删除值

Python内置函数案例

Q：isinstance 和 type 的区别在于？
A：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
>>> class B(A):   #B 是 A 的子类
...     pass
>>> isinstance(A(), A)  #True
>>> type(A()) == A      #True
>>> isinstance(B(), A)  #True
>>> type(B()) == A      #False

---

0x01 Python字符串内建函数

(1) capitalize() 将字符串的第一个字符转换为大写.

(2) swapcase() 将字符串中大写转换为小写，小写转换为大写.

(3) lower() 转换字符串中所有大写字符为小写.
upper() 转换字符串中的小写字母为大写.

(4) title() 返回”标题化”的字符串,就是说所有单词都是以大写开始，其余字母均为小写.

(5) max(str) 返回字符串 str 中最大的字母.
min(str) 返回字符串 str 中最小的字母.
len(string) 返回字符串长度.

(6) center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

(7) zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

(8) count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

(9) find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.

(10) index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.

(11)bytes.decode(encoding=”utf-8”, errors=”strict”)
Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding=’UTF-8’,errors=’strict’)
以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’

(12) startswith(substr, beg=0,end=len(string))
检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False，如果beg 和 end 指定值，则在指定范围内检查。
endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

(13) lstrip() 截掉字符串左边的空格或指定字符。
rstrip() 删除字符串字符串末尾的空格.
strip([chars]) 在字符串上执行 lstrip()和 rstrip()
(14) expandtabs(tabsize=8) 把字符串 string中的tab符号转为空格，tab 符号默认的空格数是 8

(15) join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

(16) replace(old, new [, max]) #把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

(17) split(str=””, num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

(18) splitlines([keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

(19) maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
translate(table, deletechars=””) 使用创建的字符映射表，将字符串中的字符进行转换；根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 中

(20) partition(sep) #以字符进行分割成为元组类型

(21) format() #字符串格式化( 关键字参数key 和 未知参数{0} {1}) replacement 字段

返回boolean类型:
(20)isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False.
(21)isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回True, 否则返回 False
(22)isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
(22)islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
(23)isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
(24)isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
(25)istitle() 如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
(26)isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
(27)isdecimal() #检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

#!/usr/bin/python3
#coding:utf-8
#字符串内置方法

string = "thisisdemo"
print(string.capitalize())    #首字母大写 Thisisdemo
print(string.center(30,'-'))  #将指定字符居中,将剩下的使用-填充 Thisisdemo
print(string.count('i'))      #字符在字符串出现的次数 2

str = "Python编程语言"
str_gbk = str.encode("GBK")
print(str)   #字符编码
print("UTF-8 编码：",str.encode("UTF-8"))  # UTF-8 编码： b'Python\xe7\xbc\x96\xe7\xa8\x8b\xe8\xaf\xad\xe8\xa8\x80'
print("GBK 编码：", str_gbk )  #GBK 编码： b'Python\xb1\xe0\xb3\xcc\xd3\xef\xd1\xd4'
print(str_gbk.decode('GBK','strict'))     #字符解码 Python编程语言

print(str.endswith('言'))  #判断是否以它结尾返回 True
print(str.find('thon'))  #检测 str 是否包含在字符串中如果包含返回开始的索引值 2
print(str.rfind('thon'))  #同上只不过是从右开始查找 2

print("1234578".isdigit()) #检测字符串是不是都是数字 true
print(string.islower())   #如果字符串中包含至少一个区分大小写的字符
str = "This is String Example...Wow!!!"
print (str.title())   #将字符串所有的单词拼写首字母为大写 This Is String Example...Wow!!!
print (str.istitle())  #所有的单词拼写首字母是否为大写

print("ABC".lower())  #将大写转换成小写  abc
print("abc".upper())  #将小写转换成大写  ABC

# 创建字符映射的转换表
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab,outtab)
str = "this is string example....wow!!!"  #th3s 3s str3ng 2x1mpl2....w4w!!!
print(str.translate(trantab))  #将str字符串的存在的字符采用映射表来替代 比如 i -> 3

str.maketrans('s','S')     # {115: 83} 返回Ascii码
str.maketrans('A','a')    # {65: 97}   返回Ascill码

print(str.replace('this','demo'))  #字符串替换
print(" this is a string ".strip())  #清空两边的空格 还有lstrip() / rstrip()
print('-'.join("this"))  #将序列中的元素以指定的字符连接生成一个新的字符串 t-h-i-s
print(str.split(" ")) #字符分割返回列表 ['this', 'is', 'string', 'example....wow!!!']
print("this".zfill(10)) #原字符串右对齐，前面填充0  000000this
print("t \r his \n is \n".splitlines())  #按照 ('\r', '\r\n', \n') 进行分割字符串 返回列表 ['t ', ' his ', ' is ']
test = """
... I love you baby
... vercy
... add string"""
test.splitlines() #['', 'I love you baby', 'vercy', 'add string']

'Xiao\tJia\tYu\tPython'.expandtabs(tabsize=2)  # 把字tab符号转为空格  'Xiao  Jia Yu  Python'
'I test you'.partition('t')                    # 分割成元组 ('I ', 't', 'est you')

"{0} love {1} {2}".format("I","fishc","com")         #  //位置参数  'I love fishc com'
"{a} love {b} {c}".format(a="I",b="fishc",c="com")   #  //关键字参数 'I love fishc com'
"{0} love {b} {c}".format("I",b="fishc",c="com")      #//混合使用 #也可以将两则混合使用，但关键字参数必须在未知参数后 
"{{123123213}}".format("不打印")                      #//'{123123213}' 字符串转义

Python字符串案例

---

0x02 Python列表内建函数

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

Python包含以下方法:
(2)list.append(obj) 在列表末尾添加新的对象
(3)list.count(obj) 统计某个元素在列表中出现的次数
(4)list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
(5)list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
(6)list.insert(index, obj) 将对象插入列表
(7)list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
(8)list.remove(obj) 移除列表中某个值的第一个匹配项
(9)list.reverse() 反向列表中元素，重新排序
(10)list.sort( key=None, reverse=False 正排序 /TRUE 反排序) 对原列表进行排序
(11)list.clear() 清空列表，清空列表,留下一个Empty的列表
(12)list.copy() 复制列表

代码案例：

#!/usr/bin/python
#功能：获取列表内置方法
dir(list)  #查看内置方法

member = ['list1','list2','list3']
print("列表长度：",len(member))

#列表是一个大杂缸可以进行比较 可以进行一些 常用操作符
list1 = [123]
list2 = [234]
print(list1 > list2) #进行逻辑判断
list3 = [234]
print((list1 < list2) and (list2 == list3))  #进行逻辑判断

#列表添加方法
member.insert(0,'0insert') #头部插入    //member是对象,append()是对象的一个方法
member.insert(2,'2insert') #指定位置插入
member.extend(['list3','list4']) #从新建立的一个列表中添加到另外一个列表中，所以extend()中的数据必须是列表.
member.append(['4apped1','4apped2']) #尾部插入列表
print(member)

#列表删除元素
member.remove('2insert') #不需要知道位置,只需要知道list中的元素数据
del member[0] #加上列表的索引就删除该索引上的元素,加上列表对象就删除该列表.
print(member.pop()) #列表利用栈这个数据结构进行存储,因此有了pop()方法进行弹栈,默认从列表中取出最后一个元素给你
member.pop(2)  #还可以加入索引值，进行弹栈 
print(member,end="\n\n")

print(member.count('list3')) #统计元素出现次数
print(member.index('list2')) #元素索引,根据元素来搜索索引下标

member.reverse()  #列表重新排序
print(member,end="\n\n")

#采用sort按照指定的方式进行排序
#sort(func[指定排序的算法],key[与算法搭配的关键字])  => 默认算法归并排序
list1 = [4,8,10,58,2,6]
list1.sort()
print(list1)
list1.sort(reverse=True)  #或者直接采用reverse=True  => 列表中的元素必须是同一类型
print(list1)

#清空与复制列表
list2 = member.copy()
print(list2) #复制列表
list2.clear() #清空列表返回 []
print(list2)

Python列表案例

补充： Python 拷贝对象（深拷贝deepcopy与浅拷贝copy）

1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
2. copy.deepcopy 深拷贝 拷贝对象及其子对象

# -*-coding:utf-8 -*-
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
 
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
 
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
 
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
输出结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]  #浅拷贝 追加不会修改/但是可以修改
d =  [1, 2, 3, 4, ['a', 'b']]       #深拷贝

0x03 Python集合内建函数

(1) add() 为集合添加元素
update() 给集合添加元素
(2) clear() 移除集合中的所有元素(清空set())
(10) pop() 随机移除元素
(11) remove() 移除指定元素 ,如果 s 中不存在 obj，将引发异常
(6) discard() 删除集合中指定的元素 ,如果 s 中不存在 obj，也没事儿^_^
(3) copy() 拷贝一个集合

(4) s.union(t) |返回两个集合的并集 , s | t 合并操作：s “或” t 中的元素
(5) s.difference(t) 返回多个集合的差集, s - t 在 s 中存在,在 t 中不存在的元素
s.difference_update() 移除集合中的元素，该元素在指定的集合也存在。 s -= t
(7) intersection() 返回集合的交集 s & t
intersection_update() 删除集合中的元素，该元素在指定的集合中不存在。s &= t |s 中仅包括 s 和 t 中共有的成员
(12) symmetric_difference() 返回两个集合中不重复的元素集合,异集； s ^ t
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 s ^= t

(8) isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
(9) s.issubset(t) 判断指定集合是否为该方法参数集合的子集。 # s <= t , s 中所有的元素都是 t 的成员
s.issuperset(t) 判断该方法的参数集合是否为指定集合的子集 # s >= t t 中所有的元素都是 s 的成员
(13) fronzeset() 冻结一个集合，时期不能进行添加与修改。

案例：

#!/usr/bin/python3
#功能：集合内置函数

set1 = {1,2,3,5,6,7}
set2 = {7,11,9,10}
set1.add(8)  #添加集合元素
print("添加元素：",set1)  #添加元素： {1, 2, 3, 5, 6, 7, 8}
set1.update(set2)  #可以直接添加集合到 目标集合中
print("update：",set1)  #update： {1, 2, 3, 5, 6, 7, 8, 9, 10, 11}


set1 = set2.copy()  #拷贝集合
print("拷贝：",set1)    #拷贝： {9, 10, 11, 7}

print("pop 移除:",set2.pop())  #随机移除元素  pop 移除: 9
set2.remove(11)  #移除指定元素,元素不存在报错
set2.discard(10)  #移除指定元素，元素不存在不报错
print("remove：",set2)  #remove： {7}

set2.clear()  #清空集合
print("清空：",set2)    #清空： set()

#差集
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)  #即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
print(z)  #{'cherry', 'banana'}

x.difference_update(y)  #移除两个集合都包含的元素（直接在集合里面修改）
print("差集",x)  #差集 {'cherry', 'banana'}

#交集
x = {1,4,6}
y = {2,1,7}
z = x.intersection(y)
print("交集",z)   #交集 {1}

#并集
z = x.union(y)
print("并集：",z) #并集： {1, 2, 4, 6, 7}

#亦或集（两个集合中都不存在的集合）
z = x.symmetric_difference(y)
print("异集：",z)

#判断是否为子集
print({"a", "b", "c"}.issubset({"f", "e", "d", "c", "b", "a"})) #判断集合 x 的所有元素是否都包含在集合 y 中
print({"f", "e", "d", "c", "b", "a"}.issuperset({"a", "b", "c"}))#判断集合 y 的所有元素是否都包含在集合 x 中

#判断两个集合是否包含相同的元素
print("集合相同与否：",x.isdisjoint(y))

#冻结集合（不能被添加也不能被修改）
num = frozenset([1,2,3,4])  #frozenset({1, 2, 3, 4}) <class 'frozenset'>

Python集合案例

---

0x04 Python字典内建函数

(1) str(dict) 输出字典，以可打印的字符串表示。
(2) radiansdict.fromkeys(seq[, value]) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
(3) radiansdict.copy() 返回一个字典的浅复制
(4) radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
(5) radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
(6) radiansdict.clear() 删除字典内所有元素
(7) radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
(8) radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
(9) radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
(10) radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里,就是添加key/value
(12) pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。
key值必须给出 , 否则返回default值。
(13) popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。
(11) key in dict 如果键在字典dict里返回true，否则返回false

案例：

#!/usr/bin/python3
#coding:utf-8
#功能：字典内置函数
dict1 = {"one":'weiyigeek',"two":"tterdst"}
dict2 =dict.fromkeys(('name','age'),'weiyigeek')
print("字典：",str(dict1),"类型:",type(dict1))
print("建立字典：",str(dict2))

print("姓名：",dict1.get('one'))
print("未知：",dict1.setdefault('three',"ValueNULL"))

print("Key :",list(dict1.keys()))
print("Value :",list(dict1.values()))
print("dict :",dict1.items()) #dict_items([('one', 'weiyigeek'), ('two', 'tterdst'), ('three', 'ValueNULL')])

dict1.update({'four':'update'}) #添加键值对
print("添加键值对：",dict1) #{'one': 'weiyigeek', 'two': 'tterdst', 'three': 'ValueNULL', 'four': 'update'}

print("pop('one') :",dict1.pop('one'))  #删除指定key与值并返回值 weiyigeek
print("popitem() :",dict1.popitem())  #删除末尾key ('four', 'update')

dict2.clear()
print("清空字典：",dict2)  #清空字典： {}

#成员运算符
print("判断键是不是在字典中：",'two' in dict1)  # True

Python字典案例

0x05 Python文件系统函数

(0) open(file,mode,encoding) #打开文件名称模式格式，以及编码，返回一个f文件对象
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
(1) f.close() #关闭文件
(2) f.read([size=-1]) #从文件读取size个字符，当未给定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回 ;
(3) f.readline([size=-1]) #从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符
(4) f.writelines(seq) #向文件写入一个序列字符串列表seq，如果需要换行则要自己加入每行的换行符。
(5) f.write(str) 将字符串str写入文件
(6) f.seek(offset, from) #在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节
(7) f.tell() #返回当前在文件中的位置
(8) f.truncate([size=file.tell()]) #方法用于截断文件并返回截断的字节长度,默认是截取到文件指针当前位置(9) file.flush() #刷新文件内部缓冲(同时清空缓冲区)，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入,无返回值。
(10) file.fileno() #返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
(11) file.next() #返回文件下一行。
(12) file.isatty() #如果文件连接到一个终端设备返回 True，否则返回 False。

#文件打开模式
'r'	以只读方式打开文件（默认）
'w'	以写入的方式打开文件，会覆盖已存在的文件
'x'	如果文件已经存在，使用此模式打开将引发异常
'a'	以写入模式打开，如果文件存在，则在末尾追加写入
'b'	以二进制模式打开文件
't'	以文本模式打开（默认）
'+'	可读写模式（可添加到其他模式中使用）
'U'	通用换行符支持

open函数mode属性参数

案例：

#!/usr/bin/python3
#功能：文件系统

#文件读取
file = open('.//python.txt',mode='r+',encoding='utf-8')  
print(file)  #指针对象

#返回一个列表,文件指针指向末尾.
print(file.readlines())  
print("文件指针位置：",file.tell())

#修改文件指针指向初始位置
file.seek(0,0)

print("文件读取",file.read())  #文件读取
file.seek(0,0)
print("读取行: %s" % (file.readlines()))

#用于截断文件并返回截断的字节长度,从第10个字节以后的内容全部删除了
file.seek(10)
file.truncate()  #默认截取当前指针位置
file.seek(0,0)
print("读取行: %s" % (file.readlines()))
file.close()  #关闭文件


f = open("test.txt",'w+',encoding='utf-8')    #写入文件

print ("文件描述符为: ", f.fileno()) #文件描述符为:  3

f.write("这是一个文件写入,为了不乱码需要指定utf-8编码")
f.writelines("文件写如一行字符串")
f.flush()   #将缓存区的数据写入文件/并清空缓存区（进行选择性写入）
f.close()

文件系统实例

0x06 Python魔术方法总结

Python 的魔术方法非常强大，然而随之而来的则是责任;对象天生拥有一些神奇的方法，它们总被 双下划线所包围 ，他们是面向对象的 Python 的一切;
如果你的对象实现（重载）了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，你可以定义自己想要的行为，而这一切都是自动发生的。

(1)基本的魔法方法：

__new__(cls[, ...]) 
1.  __new__ 是在一个对象实例化的时候所调用的第一个方法
2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法
3. __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用
4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__init__(self[, ...]) 	构造器，当一个实例被创建的时候调用的初始化方法
__del__(self)	析构器，当一个实例被销毁的时候调用的方法
__call__(self[, args...]) 	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self)	定义当被 len() 调用时的行为
__repr__(self)	定义当被 repr() 调用时的行为
__str__(self)	定义当被 str() 调用时的行为
__bytes__(self)	定义当被 bytes() 调用时的行为
__hash__(self)	定义当被 hash() 调用时的行为
__bool__(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec)	定义当被 format() 调用时的行为
__bases__(self)   #补充，显示其基类

(2) 有关属性

__getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)	定义当该类的属性被访问时的行为
__setattr__(self, name, value)	定义当一个属性被设置时的行为
__delattr__(self, name)	定义当一个属性被删除时的行为
__dir__(self)	定义当 dir() 被调用时的行为
__get__(self, instance, owner)	定义当描述符的值被取得时的行为
__set__(self, instance, value)	定义当描述符的值被改变时的行为
__delete__(self, instance)	定义当描述符的值被删除时的行为

(3) 比较操作符

__lt__(self, other)	定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other)	定义小于等于号的行为：x <= y 调用 x.__le__(y)
__eq__(self, other)	定义等于号的行为：x == y 调用 x.__eq__(y)
__ne__(self, other)	定义不等号的行为：x != y 调用 x.__ne__(y)
__gt__(self, other)	定义大于号的行为：x > y 调用 x.__gt__(y)
__ge__(self, other)	定义大于等于号的行为：x >= y 调用 x.__ge__(y)

(4) 算数运算符

__add__(self, other)	定义加法的行为：+
__sub__(self, other)	定义减法的行为：-
__mul__(self, other)	定义乘法的行为：*
__truediv__(self, other)	定义真除法的行为：/
__floordiv__(self, other)	定义整数除法的行为：//
__mod__(self, other)	定义取模算法的行为：%
__divmod__(self, other)	定义当被 divmod() 调用时的行为，返回值是一个元组(a//b,a%b)
__pow__(self, other[, modulo]) 	定义当被 power() 调用或 ** 运算时的行为
__lshift__(self, other)	定义按位左移位的行为：<<
__rshift__(self, other)	定义按位右移位的行为：>>
__and__(self, other)	定义按位与操作的行为：&
__xor__(self, other)	定义按位异或操作的行为：^
__or__(self, other)	定义按位或操作的行为：|

(5) 反运算

__radd__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rsub__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmul__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rtruediv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rfloordiv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rdivmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rpow__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rlshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rrshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rand__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rxor__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__ror__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）

(5)增量赋值运算

__iadd__(self, other)	定义赋值加法的行为：+=
__isub__(self, other)	定义赋值减法的行为：-=
__imul__(self, other)	定义赋值乘法的行为：*=
__itruediv__(self, other)	定义赋值真除法的行为：/=
__ifloordiv__(self, other)	定义赋值整数除法的行为：//=
__imod__(self, other)	定义赋值取模算法的行为：%=
__ipow__(self, other[, modulo])	定义赋值幂运算的行为：**=
__ilshift__(self, other)	定义赋值按位左移位的行为：<<=
__irshift__(self, other)	定义赋值按位右移位的行为：>>=
__iand__(self, other)	定义赋值按位与操作的行为：&=
__ixor__(self, other)	定义赋值按位异或操作的行为：^=
__ior__(self, other)	定义赋值按位或操作的行为：|=

(6)一元操作符

__pos__(self)	定义正号的行为：+x
__neg__(self)	定义负号的行为：-x
__abs__(self)	定义当被 abs() 调用时的行为
__invert__(self)	定义按位求反的行为：~x

(7)类型转换

__complex__(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
__int__(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
__float__(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
__round__(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
__index__(self)
1. 当对象是被应用在切片表达式中时，实现整形强制转换
2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__
3. 如果 __index__ 被定义，则 __int__ 也需要被定义，且返回相同的值

(8)上下文管理（with 语句）

__enter__(self)
1. 定义当使用 with 语句时的初始化行为
2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
3. 
__exit__(self, exc_type, exc_value, traceback)
1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么
2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作

(9)容器类型

__len__(self)	 （返回容器中元素的个数 - 前面有讲解）
__getitem__(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)	定义当迭代容器中的元素的行为
__reversed__(self)	定义当被 reversed() 调用时的行为
__contains__(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为

案例：

class t1:
  def t1print(self):
    print('t1')

class t2:
  def t2print(self):
    print('t2')

class t3(t1,t2):
  pass

print(t3.__bases__)  # 显示其基类信息 (<class '__main__.t1'>, <class '__main__.t2'>)

0x07 Python标准异常总结

Ctrl + D  #EOFError
Ctrl + C  #KeyboardInterrupt

###### Python标准异常总结 ###############
AssertionError	断言语句（assert）失败
AttributeError	尝试访问未知的对象属性
EOFError	用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError	浮点计算错误
GeneratorExit	generator.close()方法被调用的时候
ImportError	导入模块失败的时候
IndexError	索引超出序列的范围
KeyError	字典中查找一个不存在的关键字
KeyboardInterrupt	用户输入中断键（Ctrl+c）
MemoryError	内存溢出（可通过删除对象释放内存）
NameError	尝试访问一个不存在的变量
NotImplementedError	尚未实现的方法
OSError	操作系统产生的异常（例如打开一个不存在的文件）
OverflowError	数值运算超出最大限制
ReferenceError	弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError	一般的运行时错误
StopIteration	迭代器没有更多的值
SyntaxError	Python的语法错误
IndentationError 	缩进错误
TabError	Tab和空格混合使用
SystemError	Python编译器系统错误
SystemExit	Python编译器进程被关闭
TypeError	不同类型间的无效操作
UnboundLocalError	访问一个未初始化的本地变量（NameError的子类）
UnicodeError	Unicode相关的错误（ValueError的子类）
UnicodeEncodeError	Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError	Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError	Unicode转换时的错误（UnicodeError的子类）
ValueError	传入无效的参数
ZeroDivisionError	除数为零


#以下是 Python 内置异常类的层次结构：
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
      +-- StopIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning