Python的定义
Python，维基百科给出了如下介绍：
Python（英国发音：/ˈpaɪθən/ 美国发音：/ˈpaɪθɑːn/），是一种面向对象、解释型的计算机程序语言。它包含了一组功能完备的标准库，能够轻松完成很多常见的任务。它的语法简单，与其它大多数程序设计语言使用大括号不一样，它使用缩进来定义语句块。
此处提到的解释型语言，说的是源代码先翻译成中间代码，再由解释器对中间代码进行解释运行。
编译型语言和解释型语言
解释型语言写的程序不需要编译，程序在运行时才翻译成机器语言，没执行一次都要翻译一次。可以说是效率比较低。
打个比方：假如你打算阅读一本外文书，而你不知道这门外语，那么你可以找一名翻译，给他足够的时间让他从头到尾把整本书翻译好，然后把书的母语版交给你阅读；或者，你也立刻让这名翻译辅助你阅读，让他一句一句给你翻译，如果你想往回看某个章节，他也得重新给你翻译。
两种方式，前者相当于说的是编译型：首先将源代码编译生成机器语言，再有机器运行机器码，语言如C/C++;而后者就相当于我们要说的解释型：在程序运行的前一刻，还只有源程序而没有可执行程序；而程序每执行到源程序的某一条指令，则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行，总言之，就是不断地解释、执行、解释、执行……所以，解释型程序是离不开解释程序的。
编译型与解释型，两者各有利弊。前者由于程序执行速度快，同等条件下对系统要求较低，因此像开发操作系统、大型应用程序、数据库系统等时都采用它，像C/C++、Pascal/Object Pascal（Delphi）、VB等基本都可视为编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如Java、JavaScript、VBScript、Perl、Python等等。
（摘自老蔡博客http://lcbk.net/7344.html）
动态类型语言：
动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。
静态类型语言：
静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。
强类型定义语言和弱类型定义语言
（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。
（2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。
强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。
总结可得，Python是一门动态解释性的强类型定义的语言。
变量常量和数据类型
变量，维基百科解释为变数
在计算机科学中，变数是指一个表示某个存在内存中的值的名称。
声明变量：
name=“Ming”
此处即声明了一个变量，变量名为 name，name的值为 Ming
变量定义的规则：
1、变量名只能是 字母、数字或下划线的任意组合
2、变量名的第一个字符不能是数字
3、以下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
事例：
变量的赋值
name = "Alex Li"
name2 = name
print(name,name2)
name = "Jack"
print（name2）
常量 维基百科解释为常数
常数又称定数，是指一个数值固定不变的常量，与之相反的是变数
声明常量：
A=123
但事实上A仍然是一个变量，Python根本没有任何机制保证A不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法。
数据类型：
在程式设计的类型系统中，数据类型(Data type)是用来约束数据的解释。在编程语言中，常见的数据类型包括原始类型（如：整数、浮点数或字元）、多元组、记录单元、代数数据类型、抽象数据类型、参考类型、类以及函式类型。数据类型描述了数值的表示法、解释和结构，并以算法操作，或是物件在内存中的储存区，或者其它储存装置。
在Python中的数据类型主要是有以下几种：
1、数字
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
long（长整型）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
复数
复数是指能写成如下形式的数a+bi,这里a和b是实数，i是虚数单位(即-1开根)。在复数a+bi中，a称为复数的实部，b称为复数的虚部，i称为虚数单位。当虚部等于零时，这个复数就是实数；当虚部不等于零时，这个复数称为虚数。
布尔值（bool）
维基百科介绍为真值，又称逻辑值，是指示一个陈述在什么程度上是真的，在计算机编程上多成为布林值、布尔值。
仅有两个值 0或1
字符串
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充一点：字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“abcdefghij”，则s[0]=“a”，s[9]="j"。
字符串拼接：字符串的拼接若使用+号，都会在内存中重新开辟一块空间。
字符串常用功能：移除空白、分割、长度、索引、切片
格式化输出：
name=“123”
print（“ i am %s”） %name
其中%s代表字符串， %d 代表整数， %f代表浮点数
格式化输出的另一种表现形式
name =input("name:") age=input("age:") gender=input("gender:") job=input("job:") msg=''' ----------info:{_name}--------- name:{_name} age:{_age} gender:{_gender} job:{_job} '''.format( _name=name, _age=age, _gender=gender, _job=job, ) print(msg)
res:
----------infozhao---------
name:zhao
age:23
gender:男
job:IT
列表 列表使用[ ]中括号
列表是一种数据项构成的有限序列，即按照一定的线性顺序，排列而成的数据项的集合，在这种数据结构上进行的基本操作包括对元素的的查找，插入，和删除。
创建列表： name_list=['this','is','a','list','and','so','on']
print(name_list)
元组 元组使用（）小括号
元组和列表十分类似，只不过元组和字符串一样是不可变的，即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
创建元组：age=tuple((11,22,33,44,55,66))
print(age)
或者
ages=(11,22,33,44,55,66,77)
print(ages)
字典 字典使用{ }大括号
可以理解为无序的元组,什么信息都可以存放，
创建字典：person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})
流程控制
计算机程序在解决某个具体问题时，包括三种情形，即顺序执行所有的语句、选择执行部分的语句和循环执行部分语句，这正好对应着程序设计中的三种程序执行结构流程：顺序结构、选择结构和循环结构。
顺序结构
只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
选择结构：
选择结构用于判断给定的条件，根据判断的结果判断某些条件，根据判断的结果来控制程序的流程。
形式为
if<条件>：
if<条件>：
<语句1>
elif<条件>：
<语句2>：
else:
<语句3>
循环结构
包含for循环和while循环
for循环的形式为
for <循环变量> in <循环对象>：
<语句1>
可限定循环次数
for i in rang(0.len(循环对象))
<语句1>
for语句使用range()函数可以构建基于已知循环次数的循环程序，也可以以range()生成的数字作为索引来访问列表、元组、字符串中的值。
while循环的形式为
while<条件>：
<语句1>
与for循环不同的是，while语句只有在测试条件为假时才会停止。
使用while循环的情况：需要构造一种类似无限循环的程序控制结构或某种不确定运行次数的循环
字符串的使用
脱除空格 strip（）
name="li"
print(name.center(40,'-'))//打印40个字节，不够的使用‘-’填充，name放置在中间。
print(name.find('a'))//查询字母a的下标，若存在，得到下标；若不存在，输出值为-1
print(' ' in name )//检查空格是否存在于name中，若存在，显示true，若不存在，则显示false；
print(name.capitalize())//将得到的字符串的第一个字母大写。 仅是第一个字母，后续字母不变。
msg="hello, this is {name} speaking, please say you {age} for a register" msg2="hello, this is {0} speaking, please say you {1} for a register" print(msg.format(name='li',age=33)) print(msg2.format('li','23'))
输出结果：
hello, this is li speaking, please say you 33 for a register。
hello, this is li speaking, please say you 23 for a register。
//此为占位符的两种表现形式
age=input('your age :') if age.isdigit(): age=int(age) print("enjoy your life") else: print('invalid data type')
//isdigit 是判断数据类型是否为数字
print(name.islnum()) //断字符变量是否为字母或数字，若是则返回true，否则返回false。
print(name.endswith('asd'))//判断字符串是否以asd结尾，若以asd结尾，则返回true，否则返回false；
print(name.startswith('asd'))//判断字符串是否以asd开始，若以asd开始，则返回true，否则返回false；
print(name.upper().lower())//upper是将所有字母都以大写的方式表现出来，lower是将所有字母都以小写的方式表现出来。
Name=‘my name is ss’
Name.find（“name”）查找Name中“name”的位置
Name.isalnum() 如果name为数字，则返回True 否则返回False
Name.isalpha（） 如果那么为纯因为字符，则返回True，否则返回False
Name.isidentifier（）判断是否为合法的标识符，若为合法的则返回True，否则返回False
Name.istitle（）判断是否为一个标题，即是否符合骆驼命令规范
Name.isprintable（）判断是否为一个可打印文件
Name.ljust（50，*）保证一句话长50，如果长度不够，则是用*代替
Name.upper（）将字母变成大写
Name.lower（）将字母变成小写
Name.lstrip（） 去掉左边的空格
（直接用字符串）str.maketrans（）
Name.replace（“l”，“L”）将l替换为L
Name.rfind（“*”））从左边寻找某个元素，找到最右边的某个元素如*，并返回其坐标
Name.swapcase（）将字符串里面存在的大写字母改为小写字母，小写字母改为大写字母。
Name.zfill（50）字符串如果不够50位，用0填满。
列表的使用
追加
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] names=name[1:4] print(names)
//取下标为1到4的数，包括1，但不包括4
结果为 ['lisi', 'wangwu', 'zhaoliu']
names=name[1:-1] print(names)
//取下标为1到-1的数，包括1，但不包括-1 -1位最后一位，从后面倒数即为-1
结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
names=name[0:3] print(names)
//如果从头开始的话，0可以省略掉，即为[:3]
结果为['zhangsan', 'lisi', 'wangwu']
names=name[0:]
//如果想取最后一个的值，就不能写-1
names=name[0::2]
//如果想要改变name的取值步长，需要如上这么写，第一个0为开始取值的位数，第一个冒号后面跟着要取到哪个的值，此处为取到最后一个，因此可以不写，第二个冒号后面跟着取值的步长，此处为2即取值的时候是取1，3，5，7，9，隔一个取一个值。
最终可以简化为 names=name[::2]
追加
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] name.append('wangermazi') print(name)
res:
['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan','wangermazi']
//直接在最后一位上追加数值
插入
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] name.insert(2,"123") print(name)
res：
name=['zhangsan','lisi','123','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
//将“123”插入到下标为[2]的位置上。
修改
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] print(name) name[2]='thisisnew' print(name)
直接将下标为[2]的数值更改为新的
res：
['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']
['zhangsan', 'lisi', 'thisisnew', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']
删除
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] del name print(name)
//直接将此列表删除
res：
NameError: name 'name' is not defined
直接报错
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] name.remove('zhangsan') print(name) name.remove('laojiu') print(name)
//删除指定元素
结果为
第一个print ['lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']
第二个print ['lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'shiquan']
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] name.pop() print(name)
//删除最后一个数值
结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu']
扩展
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] b=['1','2','3','4'] name.extend(b) print(name)
//直接将列表b插入到列表name中最后面
结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan', '1', '2', '3', '4']
拷贝
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] names=name.copy() print(names)
复制 copy copy是直接将原来的数据复制一份，此时更改不会影响到原有的
copy的话仅仅复制第一层，而不会copy第二层，是因为第二层数据量有可能非常大
套用列表：套用的小列表仅会引用其存储地址，不会全部将此复制 数据是共享的
namess=['zhangsan',['1','2','3','4'],'lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] namesss=namess.copy() namess[1][0]='8123' namess[2]='sasss' print(namess) print(namesss)
结果为：
['zhangsan', ['8123', '2', '3', '4'], 'sasss', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']
['zhangsan', ['8123', '2', '3', '4'], 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']
若要真正全部复制一份，则需要使用一个库
引入copy ： import copy
copy.copy 跟 *.copy一样
copy.deepcopy 深度拷贝，则将数据完全复制，两个数据完全独立。
id（name）查看name的内存地址
统计
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] s=name.count('list') print(s)
排序&反转
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] name.sort() //排序 print(name)
3.0里面不同数据类型不能放在一起排序，最经典的是数字和字母无法在一起排序。
name,reverse() //反转
获取下标
name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan'] s=name.index('lisi') print(s) //若不进行循环获取，只会返回找到的第一个下标
列表的合/并/交集的使用
list_1=[1,2,3,4,5,6]
list_2=[5,6,7,8,9,10]
取两个集合的交集：
list_1.intersection(list_2)
or
list_1 & list_2
取两个集合的并集：
list_1.union(list_2)
or
list_1 | lsit_2
取两个集合中前一个集合有，第二个集合没有的：
list_1.difference(list_2)
or
list_1-list_2
判断集合1 是否是集合2的子集
list.issubset(list_2)
取两个集合都没有的部分，对称差集
list_1.symmertic_difference(list_2)
or
list_1 ^ list_2
判断两个集合是否存在交集
list_1.isdisjoint(list_2)
列表增删改查
增加：
单项 list.add()
多项： list.update([888,999,111])
删除：list.remove()
查找： if "**" in list_1
字典的操作
字典的特性：
1、字典是无序的。
2、key值必须是唯一的，所以是天生去重
字典的写法：
info={ 1234:{ "name":"liming", "age":"25", "gender":"nan" }, 2345:{ "name":"wangsan", "age":"26", "gender":"nv" } } print(info)
print(info[2345]) 打印 2345 的相关信息
info[2345]['qq']="222222222"
//若原字典内没有相关内容，则添加。若有，则更改
删除信息：
del info(2345)['qq'] //直接使用del命令删除
或者是使用.pop()
info[2345].pop('name')
获取值
v=info.get(2345)
使用一个字典更新另一个字典
info2={ 1234:{ "name":"liming", "age":"25", "gender":"nan" }, 'name':'zhaosi', } info.update(info2)
使用小字典更新大字典的值的时候，遇到相同的值的，更新覆盖；没有则创建
info.items()
使用此函数，是将字典转变为一个列表
print（info（））
print（info.items（））
结果为：
dict_items([(1234, {'name': 'liming', 'age': '25', 'gender': 'nan'}), (2345, {'name': 'wangsan', 'age': '26', 'gender': 'nv'})])
{1234: {'name': 'liming', 'age': '25', 'gender': 'nan'}, 2345: {'name': 'wangsan', 'age': '26', 'gender': 'nv'}}
获取主键
info.keys（）
获取值
info.values（）
安全的获取值： info.get（"*******"）
判断字典内是否有值可以使用print（“****” in info）
python2.7中存在如下格式：info.has_key("****")
设置默认值
info.setdefault（1234567，‘None’）若1234567值不存在，则默认输出None
dict.fromkeys（[1.2.3.4.56.7.8],'dddd'）将前面的值按个取出，然后每个都赋值‘dddd’,初始化一个新的字典，此参数跟copy中的浅copy类似
print（dict.fromkeys（[1.2.3.4.56.7.8],'dddd'））
结果为：{1: 'dddd', 2: 'dddd', 3: 'dddd', 4: 'dddd', 56: 'dddd', 7: 'dddd'}
info.popitem()随机删除字典中的一组数据
遍历字典：
for循环：
for k,v in info():
print(k,v)
#效率低，因为要有一个dict to list 的转换过程。
for item in info：
print（item，info[item]）
#效率较之前循环高很多
内置函数
函数代表绝对值 ：abs（）
ex： n = abs(-100) print(n)
res: n=100
函数内为迭代参数，所有参数为真才为真 all（）
ex: s= all([1,2,3,4,5,6,0])
print(s)
res:s =false
ex: s= all([1,2,3,4,5,6,10])
print(s)
res:s =true
函数内为迭代参数，任意参数为真，则为真 any（）
ex: s= any([1,2,3,4,5,6,0])
print(s)
res:s =true
ex: s= all([0,none,' ',1])
print(s)
res:s =true
自动执行对象的_repr_方法：ascii()
ex: class Foo:
def _repr_(self):
retrun "111"
n=ascii(Foo())
print()
十进制转换为二进制bin() 0b 二进制
十进制转换为八进制oct() 0o 十进制
十进制转换为16进制 hex() 0x 16进制
bytes() 转换字符串 按照指定的编码格式
n=bytes("李先生",encoding='uft-8')
print(n)
n=bytes("李先生",encoding='gbk')
print(n)
将之前的字节转换成字符串
str()
n=bytes('李先生'，encoding=‘utf-8’)
print(n)
s=str(n,encoding='utf-8')
print(s)
open()
open('db','r / w / x /a')
r 读取
w 写入（写入时先情况再写）
x 如果文件存在，报错，如果不存在，则创建并写入内容
a 追加
若使用rb wb 等，则是程序直接返回或是存放二进制，即0101。
若open 中使用了“r+b”类型的，则读取的时候是读取一个字节 若未使用，则读取的是一个字符
跨平台的时最好使用二进制读取，这样出现错误的情况较少。
seek（） seek永远是以字节的方式找位置 因此若读取位置存在中文则会出现乱码的情况。
seek找到的位置，若写入数据，则会将后续的内容覆盖。
tell（） 会将当前指针位置找出。
write() 写数据
fileno（）
flush（）强制刷新数据到硬盘
isatty() 判断是否同意tty设备
readable（） 判断文件是否可读
seekable（）判断是否可以移动指针
readline（） 按照行来读取文件
writeable（）文件是否可写
truncate（）用来截断数据 使用方式是使用seek（）进行定位，然后会将seek（）定位之前的截断保留。
with open（’db1‘）as f1. open('db2') as f2:
pass
函数默认返回None
ex:
li=[11,22,33,44]
def f1(arg):
arg.append(55)
li=f1(li)
若li=f1(li)这种方式，则li被重新赋值为了None，之前赋值成功的[11,22,33,44,55]被覆盖
打印 print(li) 可得 None
若f1(li)这种方式，则li赋值成为[11,22,33,44,55]
打印print（li）可得[11,22,33,44,55]
获取两个列表l1=[11,22,33] l2=[22,33,44]中相同元素集合
l1=[11,22,33]
l2=[22,33,44]
l3=set(l1)
l4=set(l2)
print(l3.symmetric_difference(l4))
结果为{11, 44}
将字符串“老男人”转换成utf-8编码的字节类型
s='老男人'
n=bytes(s,encoding='utf-8')
print(n)
s=str(n,encoding='utf-8')
print(s)
如何计算数字的绝对值
n=-100
s=abs(n)
print(s)
False的情况： [] 、{}、None、0、" "、()
chr（） 将ASCII码转换为其对应的字母
ord（）将字母转换为其对应的ASCII码
import random
s=[]
for i in range(6):
temp=random.randrange(65,91)
s1=chr(temp)
s.append(s1)
res=''.join(s)
print(res)
dir（）表示列举 一个函数能够提供的功能
print（dir（dict)）列举字典函数能够提供的功能
divmod（）
divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数
返回结果类型为tuple
isinstance（）判断实例是否为对应类的实例
filter（）
li=[11,22,33,44,55,66]
ret=filter(f2,li)
print(list(ret))
filter参数，循环第二个参数，让每个循环元素执行f2 如果函数返回值为True，表明元素合法
map()函数，可迭代的对象（可以for循环的东西）
li=[11,22,33,44,55]
def f2(a)
return a+100
result=map(f2,li) 亦或者result=map（lambda a:a+100,li) lambda表达式表达意思相似。
print(list(result))
结果即为li列表里面的每个值都增加了100
filter与map函数的区别
filter 函数返回True，将元素添加到结果中。
map 将函数返回值添加到结果中。
globals（）函数代表全局变量
locals（）函数代表局部变量
hash（）计算哈希值
hex（）将一个十10制转换为16进制。
pow（）
repr（）直接执行对应参数类型的repr参数
reversed（）反转
round（） 如round（3.2213，2）即返回3.2213仅带两位小数的数字，结果为3.22，第三位小数执行四舍五入
sorted（）效果等同于.sort（）
l1=["alex",11,22,33,44]
l2=["is",11,22,33,44]
l3=["sb",11,22,33,44]
zip（）
转换成的基本数据类型是list
数据的运算操作
a=8 00001000
b=10 00001010
C=a&b =8 (0000 1000) 与运算 相同位数上有相同的数的进行计算
C=a | b = 10（0000 1010） 或运算 只要是存在数的即进行运算
C=a ^ b =2 (0000 0010) 异或运算 相同为0 不同为1 计入运算
a=8;
计算机的原码和补码都是其自身
转二进制： 01000
计算机补码; 01000
按位取反： 10111
转为原码
按位取反： 11000
末尾加一： 11001
符号位为1 是复数 即为-9
C=a<<2 =32(00100000)集体向左移动两位
C=a>>2 =2(00000010)集体向右移动两位
文件的操作
光标位置：
f=open("user_msg.txt","r")
print(f.tell())
将光标位置回到某个位置：
f.seek(0) //0即为开始
获取文件编码
f.encoding()
获取文件句柄编号
f.fileno()
判断是否是一个tty
f.isatty()
判断是否能将光标移动到某一位置，若能移动，返回True，不能移动返回False
f.seekable()
//清空文件
f.truncate()
//从头开始截断文件到第几个字符
f.truncate（10）
open方式是以读+追加的方式打开 r+
open方式是以写读的方式打开 w+ 先创建一个文件，在往里面写
open方式是以二进制的形式读文件， “rb” 两种情况会使用：1、网络传输 2、跨平台传输
函数
函数的作用：
1、保持数据的一致性
2、保持程序的可扩展性
3、减少代码
语法：
def default（） #定义函数名
print（“hello"） #函数体
default()#调用函数
函数主要组成：
1、def
2、名称
3、函数体 {
“this is a function ”
}
4、返回值
5、参数
1、普通参数（严格按照顺序，将实际参数赋值给形式参数）
2、默认参数（必须防止在参数列表的最后）
3、指定参数（将实际参数赋值给指定的形式参数）
4、动态参数
* 默认将传入的参数，全部放置在元组中，f1（*[11,22,33,44]）
** 默认将传入的参数，全部放置在字典中。f1(**{'k1':"v1","k2","v2"})
5、万能参数， *args， **kwargs
传参传的是引用。
函数内部写入的参数为形参，传入的参数为实参
函数与过程：
过程没有返回值（ 没有返回值的函数）
函数存在返回值
默认参数
调用函数的时候，默认参数非必须传递。
形式为：
#定义
def default（ip,port=80）:
print(ip+"开放的端口为"+port)
#调用
default(10.10.10.10)
#展示
res:
10.10.10.10开放的端口为80
关键词参数
函数赋值时，函数的参数可以使用参数名称来区别，允许不按照顺序写入
形式为：
#定义
def default（ip,port）:
print(ip+"开放的端口为"+port)
#调用
default(port=80,ip=10.10.10.10)
#展示
res:
10.10.10.10开放的端口为80
位置参数
调用函数时根据函数定义的参数位置来传递参数。
形式为
#定义
def default（ip,port）:
print(ip+"开放的端口为"+port)
#调用
default(10.10.10.10,80)
#展示
res:
10.10.10.10开放的端口为80
PS
1、位置参数必须在关键字参数的前面，关键字参数之间不区分先后顺序
2、一个函数也可以作为参数传入另一个函数内。传入同一个函数则可形成递归函数
非固定参数
函数里的参数带* *即代表参数不固定。
* args 接受N个位置参数，转换成元组的形式
#定义
def default(ip,port,*arg):
print(arg)
#调用
default("10.10.10.10","80","445","123","222","213")
#展示
res ('445', '123', '222', '213')
**kwargs接受N个关键字参数，转换成字典的方式
全局变量和局部变量
全局变量是在程序一开始定义的变量
局部变量是在子程序中定义的变量
全局变量作用于整个程序
局部变量仅在定义变量的子程序内生效
当全局变量和局部变量同名时：
在定义局部变量的子程序内，局部变量生效，在其他地方全局变量生效。
递归参数
1、必须有一个明确的结束条件
2、每次进入更深一层时，问题规模相对于上次应该有所减少
3、递归效率不高，递归层次过多会导致栈溢出
三元运算和lambda表达式
三元运算符是快速实现if-else的一种形式：
if 1==1：
print('OK')
else:
print("False")
使用三元运算符实现则为以下模式：
print("OK") if 1==1 else "False"
lambda表达式
“Lambda 表达式”是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。
正常形式：
def Test(a):
return a+100
a2=Test(2)
result:102
lambda表达式：
a2=lambda a : a+100
res =a2(10)