python常用函数和模块

1: type(100)　　

type查看数据类型　　

2: round(2/6, 4)　　

取一定的小数位数,取2/6的值的小数4位，2/6保留4位输出的结构是浮点型不是字符串，输出的结果自动四舍五入

3：常用的运算符号

　　+:加  　　-：减　　　　 *：乘　　　　 / ：除　　　　//：整除，9//4=2　　　　%：求余，9 %4=1　　　　**：次方，2**4=16　　
　　混合运算：+ - * /    （有括号先做括号，没有括号先做乘除，没有乘除从左到有） 

4：import keyword ;print(keyword.kwlist)　　　　

用于获取对象内存地址 ，里面可以放对象也可以放变量

6:   info="abcde" ,print(info[0])   

　　print(info[5])超范围，越界报错　　　
　　序列类型（字符串）根据下标取值

7：len()　　　　　　　　

可以获取字符串（str），列表（list），元组（tuple)，集合（set）,字典（dict）或者变量的长度 

8：index()　　　　　　　

　　获取某个元素的下标,如果该元素存在返回第一个出现的下标,只返回一个
　　如果该元素不存在---报错（该元素一定要有）   　　
　　print(info.index("a"))      得到结果：0

 10：map(function，序列对象)　　　

　　map() 会根据提供的函数对指定序列做映射，序列对象中每一个元素都调用func函数然后生成一个新的序列对象
　　第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
　　c=map(str,b)　　　b是列表，把b中的元素map成str类型（把列表b中的元素全部转化成字符串类型，然后成一个新的c列表）
　　python 2：map返回的是一个列表
　　python 3：map返回的是一个迭代器（对象）

11：list（列表的序列化操作）

　　alist=[10,3.14,"hello",[100,200]]
　　alist[0]　　　　：获取列表alist的第一个元素
　　alist[-1][0]　　  ：取值列表里面嵌套的子列表里面的元素,获取第一个元素
　　alist[1:1+2]　　：列表的切片--[3.14, 'hello']
　　alist[::-1]　　　　翻转列表

12：list（列表的常用的内置函数和操作）

　　list.apeend()　　　　  　apeend尾部追加alist.append(40)，在列表末尾添加新的对象
　　list.count(obj)        统计某个元素在列表中出现的次数
　　list.extend(seq)       在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
　　　　　　　　　　　　　　　　list1 = ['Google', 'Runoob', 'Taobao']
　　　　　　　　　　　　　　　　list2=list(range(5))                         序列range5生成一个列表：[0, 1, 2, 3, 4]
　　　　　　　　　　　　　　　　list1.extend(list2)                          扩展列表,列表list1后面加上list2

　　list.index(obj)　　　　  从列表中找出某个值第一个匹配项的索引位置    
　　
　　list[2] = 2001  　　　　 更新列表第三个元素的值     
　　squares += [36, 49, 64, 81, 100]   　　列表还支持拼接操作       　　　　
　　alist.insert(1,50)　　　insert插入)在alist列表的1的序列位置插入50，以前的1位置和1后面位置的元素全部往后移动一位
　　　　　　　　　　　　　　   如果下标比较大，如果insert插入的下标>len，不会报错，等价于append

　　del alist[1]　　　　　   del方法通过下标删除第二个元素，del删除没有返回值的，通过下标删除，del方法修改原本的alits列表
　　del alist[1:1+2]　　　　用切片来删除，相连删除，删除第二和第三个（切片中间两个绑定一起删除）
　　del alist[1::2]　　　　 用切片来删除，跳跃删除，，从第二个开始，到最后一个，步长2个删除一个
　　res=alist.pop(1)　　　  pop删除方法是带返回值的（pop方法运行后会得到一个被删除的返回值，可以用变量接收起来）
　　　　　　　　　　　　　　　　pop根据下标删除，pop方法本身不支持删除一段

　　alist.remove(20)　　　 remove方法删除：通过值来删除，相对效率低，remove一次只能删除第一次出现的一个，多个重复的删除不了，
　　　　　　　　　　　　　　  remove删除的元素一定要存在，不存在会报错

　　alist+[30,40]　　　　　列表的拼接，临时合并，新对象，新地址存放，不影响原来列表

　　list.reverse()　　　　反向列表中元素
　　reversed(list)
　　reverse是list的内置方法，reversed是个函数
　　reverse()是列表的内建方法，作用是将整个列表原地翻转,reverse是改变原来的list,
　　reversed()实现的效果与reversed()一致，但返回的是一个新的迭代器对象。

　　list.sort( key=None, reverse=False)　　　　对原列表进行排序 ，修改原来列表里面的排序 
　　　　　　　　　　　　　　　　　　　　　　　　　　　key：指代排序标准的函数 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，
　　　　　　　　　　　　　　　　　　　　　　　　　　　指定可迭代对象中的一个元素来进行排序，指定排序标准的函数
　　　　　　　　　　　　　　　　　　　　　　　　　　  reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）
　　　　　　　　　　　　　　　　　　　　　　　　　　  该方法没有返回值，但是会对列表的对象进行排序。

　　list[tu1]　　　　　　　 元组--转--列表 ，转换出来的是另外一个新对象，对转换前的tu1对象不会产生影响
　　
　　len(list)            列表元素个数
　　
　　max(list)            返回列表元素最大值

　　min(list)            返回列表元素最小值

　　list.clear()         清空列表

　　list.copy()          复制列表                    需要import  copy模块

　　enumerate()　　　　　　序列（列表）遍历：索引位置和对应值可以使用 enumerate() 函数同时得到
　　　　　　　　　　　　　　 print(list(enumerate(['tic', 'tac', 'toe'])))　　输出：　　　　[(0, 'tic'), (1, 'tac'), (2, 'toe')]
　　zip()　　　　　　　　　同时遍历两个或更多的序列，可以使用 zip() 组合

　　　　　　　　　　　　　　questions = ['name', 'quest', 'favorite color']
　　　　　　　　　　　　　　answers = ['lancelot', 'the holy grail', 'blue']
　　　　　　　　　　　　　　print(list(zip(questions, answers)))　　　　　　　　

13：tuple（元组的常用的内置函数和操作），

　　元组称为不可变的列表（不能删，不能增加，不能修改，只能查）
　　tu1=(100,)　　　　　　　　　　　　　　　　　　　  定义元组的时候，如果元组内只有一个元素，需要加 ,才能定义成元组，
　　tup1 = ()                   　　　　　　　　　 创建空元组
　　tup3 = "a", "b", "c", "d"                   不需要小括号也可以创建一个元组
　　touple(alist)　　　　　　　　　　　　　　　　　　 列表--转--元组  ，不改变原对象alist列表，另存新地址，
　　string、list 和 tuple 都属于 sequence（序列）。
　　与字符串一样，元组的元素不能修改。
　　元组与字符串列表类似，下标索引从 0 开始，可以进行截取，组合等
　　修改元组（不可修改）　　tup1[0] = 100           这样操作元组肯定报错
　　删除元组：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，　　del tup 
　　元组也可以被索引和切片，方法一样。　　　　元组切片出来还是元组类型
　　注意构造包含 0 或 1 个元素的元组的特殊语法规则。
　　元组也可以使用+操作符进行拼接。
　　元组的不可变指的是元组所指向的内存中的内容不可变，元组里面嵌套列表，里面的列表可变的
　　 t = 12345, 54321, 'hello!'                  t就是一个元组     t=(12345, 54321, 'hello!')
　　 u = t, (1, 2, 3, 4, 5)                            u输出等于：((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))       元组嵌套元组
　　 元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

tup[1:4:步长]        　　元组索引，截取
len(tuple) 　　　　　　　　计算元组元素个数。
max(tuple)              返回元组中元素最大值。（和列表类似）
min(tuple)
tuple(iterable)         将可迭代系列转换为元组
tuple(list1)            将列表转化成元组
tuple(range(20))        创建一个0-19的数字元素的元组

14:关系运算符

　　in 和not in　　　　在和不在和,1:前者是后者的一个元素    2:判断前者是后者连续的一段  
　　>  <  ==　　　　　大于，小于，等于

15：逻辑运算符(且and，或or，非not)　　：多个逻辑运算符在一块遵守优先级得关系：not非  > and且  > or或

　　and(且)　　　　条件1 and 条件2 --全真为真，一假为假（必须条件1和条件2都为真才是真）
　　　　　　　　　　print(3>1 and 3==0)   真 and 假=False　　（3>1为真，第二个条件要判断，需要全真为真）
　　　　　　　　　　条件1为真，条件2一定运行（需要两个同时为真），条件1为假，条件2一定不会执行（没必要，一假为假）　

　　or（或）　　　　条件1 or 条件2 --一真为真，全假为假（必须条件1和条件2只要有一个为真就是真）
　　　　　　　　　　print(3>1 or 3==0)   真 or 假=为True　　（3>1为真，第二个条件不需要判断，一个为真就是真）
　　　　　　　　　　条件1为真，条件2一定不会运行（没必要，一真为真），条件1为假，条件2一定会执行（需要两个同时为假才是假）

　　not（非）　　　真的非----假，假得非----真
　　　　　　　　　　print( not 3>1)    3>1为真，not真就是假（首先运行关系运算符，再运行逻辑运算符）

15:各种运算符号的优先级关系

算术运算符（+ - * /）　　 > 　　关系运算符(>  <  ==) 　　> 　　逻辑运算符(且and，或or，非not)

16:copy 模块：

　　import copy
　　blist=copy.copy(alist) 　　　　　　　　 copy.copy()浅拷贝 ，简简单单的拷贝，只拷贝外层的数据，
　　　　　　　　　　　　　　　　　　　　　　　  但是列表里面嵌套的列表对象浅拷贝只拷贝外层数据，列表嵌套的列表还是原来的对象

　　blist=copy.deepcopy(alist)　　　　　　copy.deepcopy()深拷贝，不光外层的拷贝了，内部的子列表也会拷贝　　

17：input()函数　　　　

input是接收控制台的输入,接收到的值一定是字符串类型 ，input会阻塞代码 ，回车结束输入，不输入一直等待，不会自己退出　　 

18:  int()

数据转换成int类型，被转化的字符串里必须是数字类型才能转换

19：float()　：数据转换成float小数类型

20：get_sum.__doc__　　　

函数名+.__doc__属性查看函数的说明，不要加括号（函数名+括号就变成调用了，不加括号是个对象，函数对象）

9  :str（字符串的序列化操作）　　字符串sequence类型　

　　一个序列，若干个元素组成（若干个元素按照一定顺序进行排布组成一个序列）（有顺序就有下标，有索引index）     

　　strl[5:9]  　　　　　　　　  取第6个到9个的元素，sequence操作:切片,字符串被切片操作后不影响原对象（切出来的对象另存新地址）

　　string[start:end],　　　　 从start开始，到end结束，但不包括end　　　　
　　　　　　　　　　　　　　　　  string[第一刀下标:第二刀下标，步长]    步长默认是1,第二刀下标：是第一刀下标+获取元素的长度
　　　　　　　　　　　　　　　　  左含右不含

　　string[start:]　　　　　　 从start开始，到字符串结束

　　string[:end]　　　　　　　　从第一个字符开始，到end位置结束，但是不包括end

　　string[start:end:2]　　　　隔一个取一个

　　string[start:end:3]　　　　隔两个取一个

　　string[::1]　　　　　  　　 原对象输出   

　　string[::-1]　　　　　　　 字符串或者列表反序输出
　　　　　　　　　　　　　　　　（-1的话需要先写右边的元素，再写左边的元素如： print(info[3:1:-1])表示从第四个输出到第二个（不包含第二个）

　　python 反向输出字符串

    方法一：采用列表reversed函数,先把字符串转成列表
        info="abcdefg"
        str = list(info)
        str.reverse()
        print(''.join(str))      #空字符串加反向排列的列表元素，一个个加

    方法二：采用分片（常用）
    def string_reverse(str):
         return str[::-1]

21：str（字符串对象的一些常用内置函数）

　　len()　　　　  　　len()可以获取字符串或者变量的长度
　　index()　　　　　  如果查找的元素存在返回第一个出现的下标，只返回一个        
　　　　　　　　　　　　 如果查找的元素不存在---报错（该元素一定要有）   
　　　　　　　　　　　　　　str.index("a")    　

　　count()　　     　 count方法，计算字符串里面一个元素出现的次数，有返回值，返回一个int类型，没有找到元素返回 0
　　　　　　　　　　　　  　　def count(self, sub, start=None, end=None)
　　　　　　　　　　　　　　　　　　start和end两个参数可以设置指定范围找
　　　　　　　　　　　　　　　　　　str1.count("a",0,3)　　　　下标0找到下标3，（找0，1，2三个元素，不会找下标为3的元素）
　　　　　　　　　　　　　　　　　　str1.count("ab",0,3)　　　　count还能找一段字符　　　　　

　　endswith()　　　　 endswith(suffix, beg=0, end=len(string)) 　　
　　　　　　　　　　    检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False
　　　　　　　　　　　　　　"139 123 789".endswith("89")   返回True

　　startswith(substr, beg=0,end=len(string)) 　　检查字符串是否是以指定子字符串 substr 开头，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

　　find()　　　　　　  find(str, beg=0, end=len(string))
　　　　　　　　　　　　  find返回指定的字符串在字符串中出现的位置（find查找，找到，找不到，探索未知，）---返回下标
　　　　　　　　　　　　　str1.find("b")　　如果找到该元素,返回第一个出现的下标，类似环境变量path，没有找到元素返回-1，
　　　　　　　　　　　　  index和find的区别，index是求一个元素的下标（找的元素一定要先存在，不存在就报错）
　　　　　　　　　　　　  find是找元素下标，可以没有找不到，找不到返回-1

　　isalnum() 　　　　isalnum() 方法检测字符串是否由字母和数字组成，
　　　　　　　　　　　　str.isalnum()无参数,有一个字符，并且所有的字符都是字母或数字就返回true

　　isalpha()　　　　 检查字符串中是否都是字母（返回布尔类型）    "abc".isalpha()

　　Isdigit()　　　　 检查字符串中是否都是数字（返回布尔类型）     "abc".Isdigit()

　　islower()　　　　 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
　　　　　　　　　　　　检测字符是不是都是小写

　　isnumeric()　　　 如果字符串中只包含数字字符，则返回 True，否则返回 False　
　　　　　　　　　　　　isnumeric() 方法检测字符串是否只由数字组成，
　　　　　　　　　　　　数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。　
　　　　　　　　　　　　指数类似 ² 与分数类似 ½ 也属于数字 

　　isspace()        如果字符串中只包含空白，则返回 True，否则返回 False.

　 istitle()  　　　　如果字符串是标题化的(见 title())则返回 True，否则返回 False
　　　　　　　　　　　　istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写

　 isupper()　　　　　如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
　　　　　　　　　　　　检测字符串是不是全部都是大写

   str.join(sequence)拼接 将sequence类型的参数的元素字符串合并（连接）到一个字符串,str作为分隔符
　　　　　　　　　　　　";".join(["i","like","play","fotball"])　　输出：i;like;play;fotball

　 str.split("x")　　 分割方法，类似切片，切割（切点），括号里面是切点 1：切点会被删除（切点保留不了）  2：返回的是一个列表

　 lower()　　　　 　　将字符串里面的大写字母全部转换成小写字母

　 upper()　　　　　　 将字符串里面的所有字母转换成大写字母 

　 capitalize()      将字符串的第一个字符转换为大写        str.capitalize()不改变原来的字符串

　 title()　　　　    把每个单词的第一个字母转化为大写，其余小写

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

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

　 strip()　　　　 　　移除字符串头尾指定的字符（默认为空格）或字符序列。
　　　　　　　　　　　　　　1:默认去空格，如果需要去其他的也可以:"***abc   xdex***".strip("*")　　去掉前后的*符号也是可以的
　　　　　　　　　　　　　　2:只能去头尾的,中间不能去

　 lstrip()　　　　　　将字符串前置的空格删除(left  左边) 

　 rstrip()　　　　　　将字符串后置的空格删除（right  右边）

　 center(width, fillchar) 　返回一个指定的宽度 width，居中的字符串，fillchar 为填充的字符，默认为空格。 
　　　　　　　　　　　　　　　　　　 str = "[runoob]"
　　 　　　　　　　　　　　　　　　　print ("str.center(40, '*') : ", str.center(40, '*')) 　　
　　　　　　　　　　　　　　　　　　 输出：str.center(40, '*') :  ****************[runoob]****************

　 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'
　 encode：编码　　decode：解码

　 expandtabs(tabsize=8)       把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

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

　 maketrans() 　　　　　　　　　 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
　　　　　　　　　　　　　　　　　　 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

　 max(str)                    返回字符串 str 中最大的字母。

　 min(str)                    返回字符串 str 中最小的字母。

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

  str.rjust(width[, fillchar])　　字符串靠右, 并在左边填充空格。
　　　　　　　　　　　　　　　　　　　　 还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。  
　str.zfill()　　　　　　　　　　 在数字的左边填充 0　　　　'12'.zfill(5) 输出：'00012'        

23：max()　　　　求最大值函数

　　print(max(11,22,33,44))
　　print(max([11,22,33,44]))
　　print(max((11,22,33,44)))
　　多个值，列表，元组都是可以运行的  maxt函数可以求多个值，求元组，列表里面的最大元素

24：json模块

?

1 2 3 4

<strong>import json res =json.loads(vipData)      #字符串vipData转字典 ret=json.dumps(json)          #字典转json（字符串）   </strong>

26： isinstance　　

　　可以判断数据类型     
　　isinstance(a, int)              #返回一个布尔值，True　　
　　type()不会认为子类是一种父类类型。
　　isinstance()会认为子类是一种父类类型。

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

27：dict字典：字典以关键字为索引，字典是另一种可变容器模型，且可存储任意类型对象。

　　dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])　　构造函数 dict() 可以直接从键值对序列中构建字典：{'Runoob': 1, 'Google': 2, 'Taobao': 3} 
　　dict(Runoob=1, Google=2, Taobao=3)　　　　　　　　　　　　{'Runoob': 1, 'Google': 2, 'Taobao': 3}
　　{x: x**2 for x in (2, 4, 6)}　　　　　　　　　　　　　　　　　　   字典生成式：{2: 4, 4: 16, 6: 36}
　　字典的关键字必须为不可变类型，可以是int，str，不可以是list列表等类型，且不能重复，键必须是唯一的，但值则不必
　　字典值可以取任何数据类型（python对象），但键必须是不可变的，如字符串，数字。
　　dict_a={}             创建一个空字典  
　　访问字典里的值，把相应的键放入到方括号中： dict['Name']            Name键不存在报错
　　修改字典：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
　　dict['Age'] = 8                     age键存在就是更新 Age的值，不存在就是添加键值对　
　　{x: x**2 for x in (2, 4, 6)} 　　字典推导可以用来创建任意键和值的表达式词典

　　字典内置函数and方法　

　　del dict['Name']                    删除字典里面的name键和其对应的值

　　dict()　　　　　　　　　　　　　　　　　　直接从键值对元组列表中构建字典。
　　　　　　　　　　　　　　　　　　　　　　　　dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) 输出：{'sape': 4139, 'jack': 4098, 'guido': 4127} 
　　　　　　　　　　　　　　　　　　　　　　　　dict(sape=4139, guido=4127, jack=4098)　　输出：{'sape': 4139, 'jack': 4098, 'guido': 4127}

　　dict.clear()                        清空字典，原本的字典对象还在，只是里面为空了

　　del dict                            删除字典，字典对象都不在了

　　len(dict)                           计算字典元素个数，即键的总数

　　str(dict)                           字典强转字符串

　　type(variable)                      返回输入的变量类型，如果变量是字典就返回字典类型 

　　dict.copy()                         返回一个字典的浅复制 

　　dict.fromkeys()                     创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
　　dict.fromkeys(seq[, value])         seq：字典键值列表，value：可选参数, 设置键序列（seq）对应的值，默认为 None
　　　　　　　　　　　　　　　　　　　　　　　 seq = ('name', 'age', 'sex')
 　　　　　　　　　　　　　　　　　　　　　　　dict = dict.fromkeys(seq)         dict={'age': None, 'name': None, 'sex': None}
　　　　　　　　　　　　　　　　　　　　　　　 dict = dict.fromkeys(seq, 10)     dict={'age': 10, 'name': 10, 'sex': 10}

　　dict.get(key, default=None)　　　　　 返回指定键的值，如果键不在字典中返回default参数设置的默认值
　　　　　　　　　　　　　　　　　　　　　　　　　　key：字典中要查找的键。
　　　　　　　　　　　　　　　　　　　　　　　　　　default：如果指定的键不存在时，返回该默认值

　　key in dict                         如果键在字典dict里返回true，否则返回false

　　dict.values()　　　　　　　　　　　　　　返回一个字典值的迭代器，可以使用 list() 来转换为列表，也可也直接进行迭代

　　dict.items()                        以列表返回可遍历的(键, 值) 元组数组
　　　　　　　　　　　　　　　　　　　　　　　 返回一个列表嵌套元组对象：dict_items([('name', 'Tom'), ('age', 20), ('location', '北京')])当成列表使用就行

　　dict.keys()                        返回一个迭代器，可以使用 list() 来转换为列表　　dict_keys(['name', 'age', 'location'])

　　dict.setdefault(key, default=None) 和get()类似根据键取字典里面的值，但键不存在字典中不会报错，将会添加键并将值设为default

　　dict.update(dict2)                  把字典dict2的键/值对更新到dict里

　　pop(key[,default])                 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

　　popitem()                          随机返回并删除字典中的最后一对键和值。返回的值就是删除的值，
　　　　　　　　　　　　　　　　　　　　　　　如果字典已经为空，却调用了此方法，就报出KeyError异常。

28：集合（set）：集合是一个无序的不重复元素序列。基本功能包括关系测试和消除重复元素。  

　　可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
　　parame = {value01,value02,...}　　　　　　　　　　   创建集合
　　set(value)                          　　　　　　　　 创建集合value是一个序列特性的对象，如列表，字符串
　　 a = {x for x in 'abracadabra' if x not in 'abc'} 集合推导式              输出： {'r', 'd'}

集合的常用函数和操作

　 a = set('abracadabra')                   创建集合{'b', 'c', 'd', 'r', 'a'}             
　　b = set('alacazam')                      创建集合{'m', 'c', 'z', 'l', 'a'}
　　a - b                                    求差集：集合a中包含而集合b中不包含的元素              {'r', 'd', 'b'}
　　a | b                                    求并集：集合a或b中包含的所有元素                     {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
　　a & b                                    求交集：集合a和b中都包含了的元素                     {'a', 'c'}
　　a ^ b                                    ^不同时包含于a和b的元素 　　　　　　　　　　　　　　　　 {'r', 'd', 'b', 'm', 'z', 'l'}  
　　-：差集             +：并集                  &：交集                  ^：不同时包含于a和b的元素   

　　a = {x for x in 'abracadabra' if x not in 'abc'}     输出：{'d', 'r'}          集合推导式   

　　s.add( x )                          　　 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

　　s.update( x )                       　　 添加元素，参数可以是列表，元组，字典等，
　　　　　　　　　　　　　　　　　　　　　　　　　　 update的参数必须式字符串或者列表或者元组，具有迭代特征的参数，传字符串把会字符串一个个字符添加到集合里面 
　　s.remove( x )                       　　 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

　　s.discard( x )                      　　 也是移除集合中的元素，且如果元素不存在，不会发生错误

　　s.pop()                             　　 随机删除集合中的一个元素，并且pop会把随机删除的元素的值返回出来
　　　　　　　　　　　　　　　　　　　　　　　　　　set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
　　len(s)  　　　　　　　　　　　　　　　　　　　计算集合元素个数   

　　s.clear()     　　　　　　　　　　　　　　　 清空集合      

　　x in s     　　　　　　　　　　　　　　　　　 判断元素是否在集合中存在    

　　copy()                              　　 拷贝一个集合　 　

　　difference()                        　　 返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
　　　　　　　　　　　　　　　　　　　　　　　　　　set.difference(set)　　求x-y的差集
　　difference_update()　　　　　　　　　　　　 difference_update() 方法用于移除两个集合中都存在的元素，
　　　　　　　　　　　　　　　　　　　　　　　　　　difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，
　　　　　　　　　　　　　　　　　　　　　　　　　　而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。　
　　　　　　　　　　　　　　　　　　　　　　　　　　set.difference_update(set)　
　　　　　　　　　　　　　　　　　　　　　　　　　　x = {"apple", "banana", "cherry"}
　　　　　　　　　　　　　　　　　　　　　　　　　　y = {"google", "microsoft", "apple"}
　　　　　　　　　　　　　　　　　　　　　　　　　　x.difference_update(y)
　　　　　　　　　　　　　　　　　　　　　　　　　　print(x)
　　　　　　　　　　　　　　　　　　　　　　　　　　difference_update是直接对x集合进行操作，没有返回值，把x集合里面和y集合重合的部分删除，生成一个新的x集合
　　discard()                               删除集合中指定的元素

　　intersection()                          intersection() 方法用于返回两个或更多集合中都包含的元素，即交集
　　　　　　　　　　　　　　　　　　　　　　　　　　set.intersection(set1, set2 ... etc)   返回一个新的集合，该集合的元素既包含在集合 x 又包含在集合 y 中
　　　　　　　　　　　　　　　　　　　　　　　　　　x = {"apple", "banana", "cherry"}
　　　　　　　　　　　　　　　　　　　　　　　　　　y = {"google", "runoob", "apple"}
　　　　　　　　　　　　　　　　　　　　　　　　　　z = x.intersection(y)
　　intersection_update()                   intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集
　　　　　　　　　　　　　　　　　　　　　　　　　　intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，
　　　　　　　　　　　　　　　　　　　　　　　　　　而 intersection_update() 方法是在原始的集合上移除不重叠的元素
　　　　　　　　　　　　　　　　　　　　　　　　　　x = {"apple", "banana", "cherry"}  　　# y 集合不包含 banana 和 cherry，被移除
　　　　　　　　　　　　　　　　　　　　　　　　　　y = {"google", "runoob", "apple"}
　　　　　　　　　　　　　　　　　　　　　　　　　　x.intersection_update(y) 
　　　　　　　　　　　　　　　　　　　　　　　　　　print(x) 
　　isdisjoint()                            判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。两个集合完全没有交集返回True 

　　issubset()                              用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False  
　　　　　　　　　　　　　　　　　　　　　　　　　　z = x.issubset(y)    ：判断集合 x 的所有元素是否都包含在集合 y 中 
　　issuperset()                            用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。
　　　　　　　　　　　　　　　　　　　　　　　　　　z = x.issuperset(y)  ：集合 y 的所有元素是否都包含在集合 x 中 
　　symmetric_difference()                  返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。 
　　　　　　　　　　　　　　　　　　　　　　　　　　z = x.symmetric_difference(y) ：两个集合组成的新集合，但会移除两个集合的重复元素：   
　　symmetric_difference_update()           移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
　　　　　　　　　　　　　　　　　　　　　　　　　　x.symmetric_difference_update(y)：原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中，
　　　　　　　　　　　　　　　　　　　　　　　　　　操作原始集合x

29：Python数据类型转换函数

　　int(x [,base]) 　　　　　　　　　　将x转换为一个整数
　　float(x) 　　　　 　　　　 　　　　 将x转换到一个浮点数 
　　complex(real [,imag]) 　　 　　  创建一个复数
　　str(x) 　　　　　　　　　　 　　    将对象 x 转换为字符串 
　　repr(x) 　　　　　　　　   　　　　 将对象 x 转换为表达式字符串
　　eval(str) 　　　　　　　　 　　　　 用来计算在字符串中的有效Python表达式,并返回一个对象
　　tuple(s) 　　　　　　　　   　　　　将序列 s 转换为一个元组
　　list(s) 　　　　　　　　　　 　　　　将序列 s 转换为一个列表
　　set(s) 　　　　　　　　　　 　　　　 转换为可变集合
　　dict(d) 　　　　　　　　　  　　　　 创建一个字典。d 必须是一个 (key, value)元组序列。 
　　frozenset(s) 　　　　　　       　　转换为不可变集合
　　chr(x) 　　　　　　　　　　 　　　　  转换一个[0, 255]之间的整数为对应的ASCII字符
　　ord(x) 　　　　　　　　　　 　　　　　　将一个字符转换为它的整数值（根据ascill码转）
　　hex(x) 　　　　　　　　　　 　　　　　　将一个整数转换为一个十六进制字符串
　　oct(x) 　　　　　　　　　　 　　　　　　将一个整数转换为一个八进制字符串　
　　bin()　　　　　　　　　　   　　　　　　转换一个整数对象为二进制字符串
　　int('0x10', 16)　　　　　　  　　　　16进制转换为10进制数
　　int('xxxx', 8)　　　　　　  　　　　  8 进制转换为10进制数
　　int('xxx',2)　　　　　　　　 　　　　　　2 进制转换为10进制数　　

res = struct.pack('>I', 10240099)　　　　　　　　　　　　
print(res, len(res))　　　　　　
print(hex(10240099), len(hex(10240099)))
print(bin(0xff000000), len(bin(0xff000000)))

输出：

 b'\x00\x9c@c' 4
 0x9c4063 8
 0b11111111000000000000000000000000 32

30：数学函数：数学math模块，math模块为浮点运算提供了对底层C函数库的访问:　

　　abs(x) 　　　　　　　　返回数字的绝对值，如abs(-10) 返回 10
　　ceil(x)    　　 　　  返回数字的上入整数，　　如math.ceil(4.1) 　　返回 5
　　cmp(x, y) 　　   　　 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
　　exp(x)    　　　　 　　返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

 31：dir() 函数　　　很重要

　　内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回，如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称: 　
　　dir(sys)    返回：变量名，函数名，类名  　

32：str()和repr()

　　str()： 　　函数返回一个用户易读的表达形式。
　　repr()： 　　产生一个解释器易读的表达形式

            s = 'Hello, Runoob'
            print(str(s))                           #Hello, Runoob
            print(repr(s))                          #'Hello, Runoob'
            print(str(1/7)) 

　　repr() 函数可以转义字符串中的特殊字符

            ... hello = 'hello, runoob\n'
            >>> hellos = repr(hello)
            >>> print(hellos)
            'hello, runoob\n'     

　　repr() 的参数可以是 Python 的任何对象

            ... repr((x, y, ('Google', 'Runoob')))
            "(32.5, 40000, ('Google', 'Runoob'))"    

 33：计算三角形的面积

        a = float(input('输入三角形第一边长: '))
        b = float(input('输入三角形第二边长: '))
        c = float(input('输入三角形第三边长: '))
         
        # 计算半周长
        s = (a + b + c) / 2
         
        # 计算面积
        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
        print('三角形面积为 %0.2f' %area)

 34：i.bit_length()　　　　　　bit_length 把int数字转换成二进制最少的位数,

35：bytearray() 函数：bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

class bytearray([source[, encoding[, errors]]])
    如果 source 为整数，则返回一个长度为 source 的初始化数组；
    如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
    如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
    如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
    如果没有输入任何参数，默认就是初始化数组为0个元素。
    
    返回新字节数组。

实例：
>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')
>>>

 36：struct模块