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模块
import json res =json.loads(vipData) #字符串vipData转字典 ret=json.dumps(json) #字典转json（字符串）
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模块
