长文预警！
Python基础系列会将基础内容大致分为三到五个板块，每块着重讲一方面，知识不会很难，主要是以小例子的形式解读，如果你已经入门Python，希望可以帮你温习一下；如果你想入门Python，希望可以帮你越过这个门槛。
Python原生数据类型主要有Number、String、Byte、Boolean、None、List、Tuple、Set、Dict这九种，下面先讲一下字符串、列表、元祖、集合、字典这五种，剩下的四种大家可以自己了解一下。
字符串
初始化一个字符串，方便后面在字符串上做一些操作。
In[5]:s1=naitangmao
In[6]:s1
Out[6]:naitangmao
字符串的索引，需要注意的是索引下标从0开始。
In[9]:s1[2]
Out[9]:i
字符串的切片，以冒号分隔首尾索引位置，是[start:end]结构，注意不包含end对应元素；冒号左边不写入索引表示从头开始，同理右边不写入索引表示截取到字符串末尾。
In[8]:s1[:3]#从0开始，0,1,2三个索引
Out[8]:nai
还可以利用切片结合负索引实现翻转字符串。
In[35]:s1[::-1]
Out[35]:oamgnatian
利用加法实现合并字符串。
In[49]:print(ab+%+cd)
ab%cd
查找，利用find方法查询元素时，会返回在字符串第一次出现的下标，未找到会返回-1。
In[11]:s1.find(a)
Out[11]:1
替换，replace可以实现字符串中元素的替换，比如将tang替换成空格。
In[13]:s1.replace(tang,)
Out[13]:naimao
去空格，使用strip方法可以删除一个字符串首尾的空格，然后也支持指定要删除内容。
In[23]:s2=aaabbbccc
In[24]:s2
Out[24]:aaabbbccc
In[25]:s2.strip()
Out[25]:aaabbbccc
In[26]:s2=s2.strip()
In[27]:s2.strip(a)#可以指定删除首尾的元素
Out[27]:bbbccc
切割，split方法可以根据元素切割字符串，并存入列表；如果不输入参数，会直接将原字符串存入列表。
In[30]:s1=naitangmao
In[31]:s1.split(t)
Out[31]:[nai,angmao]
In[32]:s1.split()
Out[32]:[naitangmao]
判断一个元素是否存在于字符串中。
In[37]:naiins1
Out[37]:True
分隔，利用join方法可以将一个字符串作为分隔符，分隔另一个字符串。
In[38]:s1.join(!!!)
Out[38]:!naitangmao!naitangmao!
利用%向字符串中传入参数，%s传入字符串、%d传入整数、%f传入浮点数，且可以控制小数点后的位数。
In[40]:print(naitangmao是%s！%靓仔)
naitangmao是靓仔！
In[41]:print(naitangmao%d%66)
naitangmao66
In[44]:print(naitangmao%.2f%3.)
naitangmao3.14
也可以利用format向字符串中传入参数，且不需要在意参数类型。
In[46]:{0}ai{1}ang{2}ao.format(n,66,3.14)
Out[46]:nai66ang3.14ao
利用反斜杠对字符串进行转义。
In[47]:print(\t)
In[48]:print(\\t)
\t
列表
同样初始化一个列表，然后方便对列表做一系列操作。
In[52]:list1
Out[52]:[1,3,5,7,9,11]
首先同样是列表的索引，列表也支持负索引。
In[53]:list1[2]
Out[53]:5
In[55]:list1[-2]#负索引
Out[55]:9
再拓展一下带有间隔的切片，字符串同样适用，就是在end之后再加上一个双引号，用来写入切片的间隔，这才是切片最完整的结构。
In[58]:list1[0:6:2]
Out[58]:[1,5,9]
利用index方法可以获取某个元素在列表中的位置索引，未找到的则会报错。
In[60]:list1.index(3)
Out[60]:1
利用join方法将列表中的各个元素合并为字符串。
In[]:list1=[a,b,c]
In[]:.join(list1)
Out[]:abc
count方法可以统计一个元素在列表中出现的次数。
In[63]:list1.count(5)
Out[63]:1
enumerate可以直接获取列表的索引和对应元素。
In[]:index_=[]
In[]:value_=[]
In[]:fori,vinenumerate(list1):
...:index_.append(i)
...:value_.append(v)
In[]:index_
Out[]:[0,1,2,3,4]
In[]:value_
Out[]:[3,1,4,2,5]
利用zip方法合并两个列表。
In[]:list3=list(zip(index_,value_))
In[]:list3
Out[]:[(0,3),(1,1),(2,4),(3,2),(4,5)]]
扩大列表的四种方法：
1、append：将一个元素添至列表尾部2、insert：将一个元素插入至指定位置3、extend：将一个列表的所有元素都添加至另一个列表中4、+：将两个列表合并成一个新列表
In[68]:list1.append(12)
In[69]:list1
[1,3,5,7,9,11,12]
In[78]:list1.insert(0,0)
In[79]:list1
Out[79]:[0,1,3,5,7,9,11,12]
In[80]:list1.extend([2,4])
In[81]:list1
Out[81]:[0,1,3,5,7,9,11,12,2,4]
In[82]:list2=[6,8]
In[83]:list3=list1+list2
In[84]:list3
Out[84]:[0,1,3,5,7,9,11,12,2,4,6,8]
删除列表元素的三种方法：
1、pop:从列表指定位置删除元素，并将其返回。如果没有指定索引，pop()返回最后一个元素，并从列表中删去。2、remove：从列表中删去指定元素，没有则会报错。3、del：也是利用索引删去列表中的某部分。
In[91]:list1.pop(3)
Out[91]:7
In[92]:list1
Out[92]:[1,3,5,9,11]
In[94]:list1.remove(5)
In[95]:list1
Out[95]:[1,3,9,11]
In[96]:dellist1[1:3]
In[97]:list1
Out[97]:[1,11]
翻转列表的三种方式：
1、reverse:就地倒排列表中的元素。2、reversed:函数对列表进行反转，并返回一个新的迭代器，需要用list转换3、切片结合负索引
In[99]:list1=[1,3,5,7,9,11]
In[]:print(list1.reverse())
[11,9,7,5,3,1]
In[]:list2=list(reversed(list1))
In[]:print(list2)
[11,9,7,5,3,1]
In[]:list1[::-1]
Out[]:[11,9,7,5,3,1]
实现列表排序的两种方式：
1、sort:对列表中的元素就地进行排序。2、sorted:函数对列表进行排序，形成一个新列表3、利用lambda自定义函数这两种方法默认为升序，通过参数reverse可以更改排序方式。
In[]:list2=[3,5,2,7,1]
In[]:list2.sort()
In[]:list2
Out[]:[1,2,3,5,7]
In[]:list3=sorted(list2,reverse=True)
In[]:list3
Out[]:[7,5,3,2,1]
#按照元祖中第二个元素的大小排序
In[]:list4=[(0,3),(1,1),(2,4),(3,2),(4,5)]
In[]:print(sorted(list4,key=lambdax:x[1]))
[(1,1),(3,2),(0,3),(2,4),(4,5)]
sort和reverse这类就地处理列表的操作，针对可变的列表是可以的，但如果是不可变的元祖，只能用sorted和reversed这两种方式。
拷贝列表的三种方式：
1、利用切片直接赋值，浅拷贝2、copy方法，浅拷贝3、deepcopy方法，深拷贝
In[25]:list2=list1[:]
In[26]:list3=list1.copy()
In[27]:importcopy
In[29]:list4=copy.deepcopy(list1)
深拷贝和浅拷贝的区别因为涉及到数据结构，口头叙述不容易理解，网上有很多图例讲解的博客，大家可以了解一下。
元组
元组和列表是非常相似的，有一种类似近亲的关系，也就是说列表中很多操作同样适用于元组，比如索引、切片等等，但也有一部分不同，这里主要来说一下元组的特别之处。
首先元组又被称作带锁的列表，就是元组内的元素是不能随意更改的，比如你不能给元组中的一个元素随意赋值。
In[2]:tuple1=(1,2,3)
In[3]:tuple1[2]=4
#会发生报错，告诉你不支持这样的操作
TypeError:tupleobjectdoesnotsupportitemassignment
元组的标志并不是单纯的小括号，而是逗号，或者小括号与逗号的结合，看下面这个例子。
In[31]:tuple2=(1)
In[32]:type(tuple2)
Out[32]:int
In[33]:tuple3=(1,)
In[34]:type(tuple3)
Out[34]:tuple
In[35]:tuple4=1,2,
In[36]:type(tuple4)
Out[36]:tuple
那如何初始化一个空元组呢？
In[39]:tuple5=()
In[40]:type(tuple5)
Out[40]:tuple
上面刚刚说过元组是不可变对象，自然也不会有append、insert、pop这类的操作。元组中增添可以利用+实现，删除则可以利用del，因为这是python自带的回收机制。
In[42]:tuple5=tuple5[:]+(1,2,3,4,)
In[43]:tuple5
Out[47]:(1,2,3,4)
In[50]:deltuple5#不支持切片
In[51]:tuple5
NameError:nametuple5isnotdefined
*在数值型之间为乘积运算符，而在列表和元组之间可以表示为重复运算符。
In[53]:tuple5=(1,2)
In[54]:tuple5*3
Out[54]:(1,2,1,2,1,2)
集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持联合、交、差和对称差集等数学运算。
首先可以利用大括号或set()函数创建集合，如果想要创建空集合，你必须使用set()而不是{}，{}用来创建字典。
In[57]:set1=set()
In[58]:type(set1)
Out[58]:set
集合会本身会带有去重功能。
In[55]:set1={1,1,2,2,3,3,4}
In[56]:set1
Out[56]:{1,2,3,4}
将集合转化为列表时，会自动排序。
In[74]:set2={5,5,4,2,2,0}
In[75]:list_=list(set2)
In[76]:list_
Out[76]:[0,2,4,5]
集合之间的一些运算操作。
In[60]:set1={1,2,3,4}
In[61]:set2={3,4,5}
#差
In[62]:set1-set2
Out[62]:{1,2}
#并
In[63]:set1
set2
Out[63]:{1,2,3,4,5}
#交
In[64]:set1set2
Out[64]:{3,4}
#只在set1或只在set2中
In[65]:set1^set2
Out[65]:{1,2,5}
利用add向集合中增添元素,利用remove删除元素。
In[69]:set1={1,2,3}
In[70]:set1.add(5)
In[71]:set1
Out[71]:{1,2,3,5}
In[72]:set1.remove(2)
In[73]:set1
Out[73]:{1,3,5}
字典
字典是Python中一个非常有用的原生数据类型，一般序列是用连续的整数作为索引，而字典是以关键字作为索引，且关键字要是任意不可变类型。理解字典时可以把它看做无序的键：值对(key:value对)集合，同一个字典中键必须互不相同，利用{}可以初始化一个空的字典。
In[77]:dict1={}
In[78]:type(dict1)
Out[78]:dict
如果确保一个键不在字典中，可以利用下面的方法向字典中添加元素。
In[81]:dict1={a:1,b:2}
In[82]:dict1[c]=3
In[83]:dict1
Out[83]:{a:1,b:2,c:3}
而如果这个键已经存在于字典中了，就表示为这个键赋值。
In[84]:dict1=4
In[85]:dict1
Out[85]:{a:1,b:4,c:3}
keys()方法能够一次性获得字典中所有的键，values()方法则用来获取值，items()则是获取键值对的元组形式。
In[86]:list(dict1.keys())
Out[86]:[a,b,c]
In[87]:list(dict1.values())
Out[87]:[1,4,3]
In[88]:list(dict1.items())
Out[88]:[(a,1),(b,4),(c,3)]
元组形式或者列表中嵌套的元组的形式都可以转换成字典，因为要保持不可变性。
In[89]:dict2=dict([(e,5),(f,6)])
In[90]:dict2
Out[90]:{e:5,f:6}
In[91]:dict3=dict(((g,7),(h,8)))
In[92]:dict3
Out[92]:{g:7,h:8}
当然也可以通过=赋值的形式创建一个字典。
In[93]:dict5=dict(i=8,j=9)
In[94]:dict5
Out[94]:{i:8,j:9}
查询一个键是否存在一个列表中。
In[96]:iindict5
Out[96]:True
In[97]:aindict5
Out[97]:False
根据键查询对应值的两种方式：
1、直接利用键的名字索引，不足的是如果字典中没有这个键则会发生报错。2、利用get方法，可以设置不存在键名的情况下的返回值，默认返回None。
In[98]:dict5
Out[98]:8
In[99]:dict5[a]
KeyError:a
In[]:dict5.get(i)
Out[]:8
In[]:dict5.get(a,没有)
Out[]:没有
字典中的几种删除方式：
1、pop()方法，与列表不同的是必须要传入一个字典中已有键的参数。2、popitem()，类似于列表中的pop()，随机删除一组键值对而非删除最后一个，因为字典本身无序。3、del方法，用于删除整个字典
In[]:dict3
Out[]:{g:7,h:8}
In[]:dict3.pop(g)
Out[]:7
In[]:dict3.popitem()
Out[]:(h,8)
clear()方法可以清楚字典中所有的键值对。
In[]:dict5.clear()
In[]:dict5
Out[]:{}
setdefault()方法可以传入一组键值对，如果字典中已有同名键，则返回键在字典中对应的值，否则将传入的键值对存入字典中。
In[]:dict2
Out[]:{e:5,f:6}
In[]:dict2.setdefault(e,1)
Out[]:5
In[]:dict2.setdefault(g,7)
Out[]:7
In[]:dict2
Out[]:{e:5,f:6,g:7}
update()方法可以用来更新字典：
如果字典中已有传入的键，则更新键对应的值。如果没有，则将传入的键值对存入字典中。
In[]:dict2.update({g:10})
In[]:dict2
Out[]:{e:5,f:6,g:10}
In[]:dict2.update(dict1)
In[]:dict2
Out[]:{e:5,f:6,g:10,a:1,b:4,c:3}
总结
上面就是五种数据类型基本操作的一个概括，其中比较常用的三种就是字符串、列表和字典，应该重点掌握。
接下来是几个语法表达式：
流程控制是python语法很重要的一个分支，主要包括我们经常用到的判断语句、循环语句以及各种表达式。
判断语句(if)
判断语句中最有名的应该就是if-else的组合，并且很多语言都通用这种格式，但是对于elif而言，不同语言表达形式可能会不同：
In[1]:x=5
In[2]:ifx0:
...:print(正整数)
...:elifx0:
...:print(负整数)
...:else:
...:print(零)
...:
正整数
一组判断语句可能会有零到多个elif部分，else是可选的。关键字elif是elseif的缩写，由于python对缩进的要求很严格，而这种写法恰巧可以有效地避免过深的缩进。if...elif...elif...序列用于替代其它语言中的switch或case语句。
循环语句
1、for循环
如果C语言是你最熟悉的需要，要注意python和C语言中的for语句表达形式完全不同。Python的for语句依据任意序列(字符串、列表)中的子项，按照它们在序列中的顺序来进行迭代。
In[3]:str1=mao
In[4]:foriinstr1:
...:print(i)
...:
m
a
o
对列表的循环与字符串几乎一致，只是子项不同。
In[5]:list1=[a,aa,aaa]
In[6]:foriinlist1:
...:print(i,len(i))
...:
a1
aa2
aaa3
for语句与range函数结合是一种很常见的组合，range函数主要提供一个数值序列。
In[8]:forjinrange(len(list1)):
...:print(j,list1[j])
...:
0a
1aa
2aaa
range提供的数值索引方式可以参考列表的切片，同样默认以0开始，且不包括最后一位，上面这种场合利用enumerate()函数表达会更加简单。
In[9]:fori,vinenumerate(list1):
...:print(i,v)
...:
0a
1aa
2aaa
2、while语句
In[10]:i=1
In[11]:list2=[]
In[12]:whilei=5:
...:list2.append(i)
...:i+=1
In[14]:list2
Out[14]:[1,2,3,4,5]
3、break、continue、pass
break语句的作用就是用来跳出一个for或while循环。
In[15]:foriinrange(0,5):
...:ifi==3:
...:break
...:else:
...:print(i)
1
2
可以看到在for循环中加了一个判断语句，当i等于3时会跳出for循环，不再继续执行，输出与语义符合。
continue语句的作用就是表示继续执行下一次迭代，可以结合判断语句使用，在什么条件下继续执行，或者什么条件下跳出循环。
In[20]:foriinrange(2,7):
...:ifi%2==0:
...:print(Anevennumber,i)
...:continue
...:ifi4:
...:print(beyond4)
...:break
...:
Anevennumber2
Anevennumber4
beyond4
pass语句主要起到一个占位的作用，而有的语句后面是不能为空的，比如if、for、while，可以利用pass占位，不会发生报错。
In[1]:whileTrue:
...:pass
迭代器、生成器
我们通常接触到的迭代器有序列，比如字符串、列表等等，利用iter()方法可以构建一个迭代器，与之匹配的next()方法可以迭代返回迭代器内的值，并将返回值弹出迭代器。
In[1]:it=iter(python)
In[2]:print(it)
str_iteratorobjectat0xADA75A00
In[3]:next(it)
Out[3]:p
In[4]:next(it)
Out[4]:y
当next方法迭代到最后一个值时，继续调用next方法会弹出报错。当然也可以利用for循环迭代输出：
In[6]:foriinit:
...:print(i)
t
h
o
n
如果你深入了解Python之后会发现生成器用起来会更加方便，结合函数即可。生成器的关键字为yield，生成器也具有next()方法，并且可以利用for循环迭代输出。
In[8]:defreverse(data):
...:foriinrange(len(data)-1,-1,-1):
...:yielddata
In[9]:gen=reverse(mao)
In[10]:print(gen)
generatorobjectreverseat0xAD99FDD0
In[11]:next(gen)
Out[11]:o
In[12]:foriingen:
...:print(i)
a
m
用小括号括起来的一个表达式可以用来创建一个生成器，下面将讲述如何来书写各种的表达式。
In[14]:gen2=(iforiinrange(0,5))
In[15]:print(gen2)
generatorobjectgenexprat0xADA18D60
表达式
列表表达式
各种表达式为我们创建相关数据类型提供了一种更加简单的方法，首先是列表表达式，普通的方法是通过将一些操作应用于序列的每个成员并通过返回的元素创建列表，或者通过满足特定条件的元素创建子序列。比如我们想获取10以内的平方数，利用普通方法如下：
In[16]:squares=[]
In[17]:foriinrange(10):
...:squares.append(i**2)
In[18]:squares
Out[18]:[0,1,4,9,16,25,36,49,64,81]
但一行语句就足以囊括上面的内容，可见列表表达式的简洁性。
In[20]:squares=[x**2forxinrange(10)]
In[21]:squares
Out[21]:[0,1,4,9,16,25,36,49,64,81]
上面这个列表表达式应该是比较简单的，我们还可以在表达式中加入判断语句作为筛选条件。
In[22]:list2=[x*2forxinrange(10)ifx*23]
In[23]:list2#0和2被过滤掉了
Out[23]:[4,6,8,10,12,14,16,18]
进一步可以结合两个列表的元素组成一个列表表达式:
In[24]:list3=[(x,y)forxin[1,2]foryin[2,3]ifx!=y]
In[25]:list3
Out[25]:[(1,2),(1,3),(2,3)]
在复杂一点的列表表达式就是嵌套类型的，但是这样的表达式缺点就是可读性不太好，因为你需要去思考他的一些细节，比如将一个23的矩阵转变为32的矩阵。
In[28]:mat=[[1,2,3],[4,5,6]]
In[29]:list3=[[rowforrowinmat]foriinrange(3)]
In[31]:list3
Out[31]:[[1,4],[2,5],[3,6]]
集合表达式
集合表达式与列表表达式有两处不同：
1、集合表达式需要用{}2、集合表达式返回的是集合，所以会对元素去重
In[32]:set1={iforiinabcddddddifinotinabc}
In[33]:set1
Out[33]:{d}
可以看到for语句中的字符串原本有很多d，经过条件过滤和集合去重最后只剩下了一个。
当然也可以通过set()方法将一个列表表达式转换为集合的形式。
In[34]:set2=set([(x,y)forxinrange(2)foryinrange(2)])
In[35]:set2
Out[35]:{(0,0),(0,1),(1,0),(1,1)}
字典表达式
字典是python中很常用的一种数据类型，所以字典表达式也显得尤为重要。字典表达式同样也用{}构建，只不过表达式还要用(key:value对)的形式。
In[36]:dict1={x:x**2forxinrange(1,4)}
In[37]:dict1
Out[37]:{1:1,2:4,3:9}
字典表达式也可以结合一些方法、语句实现更多的功能。
In[38]:dict2={x:len(x)forxin[aa,bb,ccc]}
In[39]:dict2
Out[39]:{aa:2,bb:2,ccc:3}
利用items()方法很容易实现键值对转换，不过需要注意字典的键需要唯一。
In[40]:dict3={v:kfork,vindict2.items()}
In[41]:dict3
Out[41]:{2:bb,3:ccc}
通过上面几个例子可以看到，表达式是由包含一个表达式的括号组成，表达式后面会跟一个for语句，之后还可以跟零或者多个for或if语句，结果最终会返回一个指定的数据类型，其中的元素是通过表达式依据后面的for和if语句计算而得出的。
最后是函数和文件：
函数在编程中是一个很重要的角色，我们可以将若干个语句组合形成一个函数，它可以接受传入参数，并在内部进行相关计算后产生输出，将语句封装成函数是为了避免重复使用几个语句造成代码冗杂，让代码更简洁可观性更强。
文件的操作主要是介绍一些关于文件的读取及写入的方法，以及每个方法的不同点和需要注意的事项，最后会介绍一下利用pickle模块存储复杂数据的方式。
函数
函数主要包括两个方面：
内置函数自定义函数内置函数就是python自带的一些函数，我们只需要给函数传入相关参数就可以进行调用，print就是最基础、最典型的一个内置函数；而自定义函数是需要我们自己按照需求，封装若干个语句形成一个新的函数。
自定义函数
1.创建函数
下面通过自定义一个计算长方体体积的函数来介绍一些属性词：
In[1]:defvol(length,width,height):
...:volume=length*width*height
...:returnvolume
上面三行代码中你需要了解：
def:定义函数的关键字length,width,height:函数的形参return:函数的返回值2.调用函数
建好一个自定义函数后，可以通过函数名(实参)的方式调用函数：
In[2]:vol(2,2,3)
Out[2]:12
在传入参数时需要注意的是，实参与形参必须完全对应，比如位置、个数等等，否则会出现报错。
In[4]:vol(2,2)
TypeError:vol()missing1requiredpositionalargument:height
如果想改变传参顺序，那么你需要指定为哪一个形参传值：
In[8]:vol(width=3,length=4,height=5)
Out[8]:60
3.函数默认值
函数的形参还可以指定默认值，假如我们将上面的vol函数中height参数默认值设为2：
In[6]:defvol(length,width,height=2):
...:volume=length*width*height
...:returnvolume
...:
In[7]:vol(2,2)
Out[7]:8
这时只向vol函数中传入两个实参，可以发现没有报错，并且得到返回值为8。也就是说如果一个形参有默认值，而调用函数时没有为这个形参传值，那么这个参数就取默认值。
4.收集函数(可变函数)
对于一个函数的形参我们也可以将其设置为可以变化的：
In[9]:deftest(*params):
...:print(参数的长度为%d%len(params))
...:print(第三个参数为%s%params[2])
...:
In[10]:test(1,2,mao,3.14,pp)
参数的长度为5
第三个参数为mao
这里需要将形参用*标识，然后在调用参数的时候可以传入若干个实参。
5.全局与局部
在函数中定义的常量被称为局部变量，也就是仅限在这个函数中可以调用，不接受在函数之外使用：
In[12]:deftest(a,b):
...:c=2
...:returna*b*c
In[13]:test(2,2)
Out[13]:8
In[14]:print(c)
NameError:namecisnotdefined
6.匿名函数lambda
如果一个函数内部的语句不是很复杂，代码量很少，我们就可以利用匿名函数，比如上面计算体积的函数：
In[20]:vol=lambdaa,b,c:a*b*c
In[21]:vol(2,2,3)
Out[21]:12
lambda表达式常常嵌套的语句中，结合相关函数使用会很简便，后面会给出例子。
7.内嵌函数
在定义函数时还支持几个函数嵌套，但用的时候需要注意逻辑关系：
In[24]:deffun1(a):
...:b=2
...:deffun2():
...:returna*b
...:returnfun2()
...:
In[25]:fun1(4)
Out[25]:8
常用内置函数
内置函数前两篇文章就有涉及过，比如常用的len、sorted、reversed、sum等等，除此之外再介绍几个比较基础的内置函数。
1.max和min
求一个序列中最大值和最小值：
In[28]:min(1,2,3)
Out[28]:1
In[29]:max(1,2,3)
Out[29]:3
2.abs
求一个数的绝对值：
In[31]:abs(-1)
Out[31]:1
3.round
四舍五入保留小数点后几位：
In[32]:round(3.,2)
Out[32]:3.56
4.pow
计算一个数的幂次方，或者再取余：
In[33]:pow(2,3)#2*2*2
Out[33]:8
In[34]:pow(2,3,3)#(2*2*2)%3
Out[34]:2
5.divmod
计算一个数的商和余数：
In[36]:divmod(10,3)
Out[36]:(3,1)
6.help
用来查询一个函数的帮助文档：
In[37]:help(abs)
Helponbuilt-infunctionabsinmodulebuiltins:
abs(x,/)
Returntheabsolutevalueoftheargument.
7.filter
filter()函数接收两个参数，第一个参数可以是一个函数或者None，第二个参数是序列。作用是对每个元素进行判断，返回True或False，filter()根据判断结果自动过滤掉序列中为False的元素，留下为True的元素，可以结合lambda表达式使用：
In[38]:list(filter(lambdax:x%2,range(10)))
Out[38]:[1,3,5,7,9]
8.map
map()函数接收两个参数，一个是函数，一个是序列。作用是将函数应用于序列中每一个元素上，同样可以结合lambda表达式使用：
In[42]:list(map(lambdax:x*2,range(10)))
Out[42]:[0,2,4,6,8,10,12,14,16,18]
文件
关于文件读写操作，open()函数是一定遇到的，如果文件已经存在则会打开文件，若不存在则会创建一个文件，通常的用法需要两个参数：open(filename,mode)。
第一个参数就是文件名字，第二个参数就指定文件将会被如何使用，可选模式常用的有以下几种：
r:以只读的方式打开文件(默认)w:以写入模式打开文件，会覆盖已存在的文件a:以写入模式打开文件，如果文件存在，则在末尾追加写入b:以二进制模式打开文件，进而会有rb、wb等模式组合1.read()方法读取
read()方法可传入一个参数size，也就是读取内容的长度。size是一个可选参数，如果不传入或者传入一个负数，那么会读取文件全部内容：
In[52]:fb=open(E:/Python基础/test.txt,r)
In[53]:fb.read(10)
Out[53]:nai\nniatan
In[54]:fb.read()
Out[54]:g\nnaitangmao
In[55]:fb.read()
Out[55]:
需要注意的有三点：
1、原文件中换行的地方在读取时以换行符\n表示，并且也占有一个单位长度2、已经被读取的内容不能被重复读取3、如果读取内容返回为空字符串，表示已经到了文件末尾2.readline()方法
readline()方法是从文件中读取单独一行，并且在这一行数据的末尾处会有一个换行符\n，如果其中一行没有数据，则会只返回一个\n，同样当返回空字符串时表示到达文件末尾。
In[59]:fb1=open(E:/Python基础/test.txt,r)
In[60]:fb1.readline()
Out[60]:nai\n
3.readlines()方法
readlines()方法也是用来读取全部文件，与read()不同之处在于前者是按行读取，并且最后返回的是一个列表，每一行数据作为一个列表元素：
In[72]:fb3=open(E:/Python基础/test.txt,r)
In[73]:fb3.readlines()
Out[73]:[nai\n,niatang\n,naitangmao]
4.遍历文件对象读取
这种方式读取出的内容看起来会比较规范一些：
In[81]:foriinfb4:
...:print(i,end=)
...:
nai
niatang
naitangmao
5.文件的写入
在进行写入操作的时候，我们需要注意的两个点：
写入的数据如果是非字符串内容，需要转换为字符串写入的方式要注意是覆盖还是追加
In[85]:fb5=open(E:/Python基础/test1.txt,w)
In[89]:list1=[1,2]
In[91]:fb5.write(str(list1))
Out[91]:6
用write写入后会返回写入字符串的长度。
6.文件关闭
切记切记切记！如果你用open()的方式打开一个文件，在操作完成之后一定要用close()方法关闭文件。
In[92]:fb5.close()
7.with方式
如果你感觉自己的记性不好，总是忘记用close()方法关闭文件，那么就要习惯利用with处理文件对象，它可以在文件用完之后自动关闭文件。
In[93]:withopen(E:/Python基础/test.txt,r)asfb:
...:data=fb.read()
In[95]:fb.closed
Out[95]:True
8.pickle
上面说了将一个非字符串写入文件是不允许的，如果有没有办法保存一份字典或者列表形式的数据呢？pickle模块就可以实现这种序列化的存储与读取：
In[96]:importpickle
In[97]:list1=[nai,tang,mao,1,2,3]
In[98]:pic_f=open(E:/Python基础/list.pkl,wb)
In[99]:pickle.dump(list1,pic_f)
In[]:pic_f.close()
dump()方法接收两个参数，第一个是要存储的内容，第二个是存储的文件对象，操作之后也需要用close()关闭文件对象，存储之后可以利用load()方法加载文件中的内容。
In[]:pic_f=open(E:/Python基础/list.pkl,rb)
In[]:list2=pickle.load(pic_f)
In[]:list2
Out[]:[nai,tang,mao,1,2,3]
In[]:pic_f.close()
利用pickle在存储或者读取的时候要注意以二进制的形式操作文件对象，也就是wb和rb，pickle很适合用来存储数据类型比较复杂并且数据量又很大的数据。