Python基础第三篇

Python基础第三篇

一、collections系列
Counter是对字典类型的补充，用于追踪值的出现次数，具备字典的所有功能 + 自己的功能
1.计数器Counter

import collections
a='abababsbsbhh'
c=collections.Counter(a) #直接列出每个元素出现了几次，传入列表和元组也一样
print(c)
#输出：Counter({'b': 5, 'a': 3, 'h': 2, 's': 2})

#most_common 列出Counter内的前几个
print c.most_common()
print c.most_common(1)
print c.most_common(3)
'''
输出：
[('b', 5), ('a', 3), ('h', 2), ('s', 2)]
[('b', 5)]
[('b', 5), ('a', 3), ('h', 2)]
'''

#update 相加
c=collections.Counter(a)
c1=collections.Counter(a)
c.update(c1)
print(c)
#输出：Counter({'b': 10, 'a': 6, 'h': 4, 's': 4})

#subtract 减
aa=collections.Counter("as")
bb=collections.Counter("htw")
aa.subtract(bb) #c-c1
print(aa)
#输出：Counter({'a': 1, 's': 1, 'h': -1, 't': -1, 'w': -1})

#elements 返回包含所有元素集合的迭代器
for item in c.elements():
print item

2、有序字典(orderedDict )

import collections
#有序字典，是对字典类型的补充，他记住了字典元素添加的顺序
#具备字典的所有功能 + 自己的功能
dic=collections.OrderedDict() #定义有序字典
dic["a1"]=1
dic["a2"]=2
dic["a3"]=3
di={}
di["a1"]=1
di["a2"]=2
di["a3"]=3
print(dic)
print(di)
#输出：
# OrderedDict([('a1', 1), ('a2', 2), ('a3', 3)]) #有序
#{'a1': 1, 'a3': 3, 'a2': 2} #无序

3、默认字典(defaultdict)

import collections
#默认字典
#defaultdict 是对字典的类型的补充，他默认给字典的值设置了一个类型。
dic=collections.defaultdict(list) #默认字典的value，也可以是元组(tuple)或字典(dict)
#相当于
dic={}
dic["k1"]=[]

4、可命名元组

#tupled的扩展
#可命名元组
import collections
t=(1,2)
#创建一个扩展tuple的类，Mytuple
Mytuple=collections.namedtuple('Mytuple',['x','y'])
tu=Mytuple(1,2) #相当于给原来的值赋了一个key
print(t)
print(tu)
print tu.x,tu.y
'''
输出：
(1, 2)
Mytuple(x=1, y=2)
1 2
'''

5、双向队列、单向队列

#双向队列，两头都可以取可以插
#线程安全
import collections
q=collections.deque() #创建队列
q.append(1)
q.append(2)
q.append(3)
print(q)

#单向队列，一个方向拿
#线程安全
import Queue
q=Queue.Queue(10) #创建队列，指定最多放10个数据
q.put(1) #进
q.put(2)
q.put(3)
print q.get() #取
print q.get()
'''
队列和栈的结构:
队列：先进先出
栈：弹夹，后加先出
'''

二、迭代器和生成器
1.迭代器

'''
只能通过循环从迭代器里拿数据
next方法：返回迭代器的下一个元素
__iter__方法：返回迭代器
'''

i=iter(range(3)) #使用内建的iter方法创建迭代器
print i.next()
print i.next() #next()方法可以访问下一个元素
print i.next()
print i.next() #python处理迭代器越界抛出StopIteration异常
'''
输出:
0
1
2
Traceback (most recent call last):
File "E:/index.py", line 82, in <module>
print i.next()
StopIteration
'''
#在for循环中，Python将自动调用iter()函数获得迭代器，自动调用next()获取元素，自动完成检查StopIteration异常的工作

2.生成器

#生成器（生成器只有使用时才创建，从而避免内存浪费）
'''
range不是生成器 和 xrange 是生成器
readlines不是生成器 和 xreadlines 是生成器
'''
for i in range(100): #返回100个元素的列表
print(i)
for i in xrange(100):#每次迭代中返回一个元素
print(i)

#带有 yield 的函数在 Python 中被称之为 generator（生成器）

#yield 记住上一次的操作，下次在执行时继续执行
def aaa(arg):
seed = 0
while True:
seed=seed+1
if seed > arg:
return
else:
yield seed #每次经过yield都会返回到print输出i，然后回到原来位置继续执行
for i in aaa(10):
print i

冒泡算法

#练习
#下标式循环
'''
有列表li=[13, 22, 6, 99, 11]
按照以下规则计算：
13 和 22 比较，将大的值放在右侧，即：[13, 22, 6, 99, 11]
22 和 6 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
22 和 99 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
99 和 42 比较，将大的值放在右侧，即：[13, 6, 22, 11, 99,]
13 和 6 比较，将大的值放在右侧，即：[6, 13, 22, 11, 99,]
'''
#冒泡算法 依次用下标对应的两个数字进行比较，大的放右边，从而进行排列
li=[13, 22, 6, 99, 11]
aa=(len(li)-1)
while aa>0:
for m in range(aa):
if li[m]>li[m+1]:
temp=li[m]
li[m]=li[m+1]
li[m+1]=temp
aa=aa-1
print(li)
#输出：[6, 11, 13, 22, 99]

三、函数
1.内置函数
常用内置函数

#常用内置函数
'''
基础
help()
dir() 不带参数时,返回当前范围内的变量、方法和定义的类型列表,带参数时,返回参数的属性、方法列表
print vars() 当前模块的所有变量
type()
reload(temp) 真正的在导入一次一个模块
id()
is()
range 产生一个序列，默认从0开始
xrange
类型转换
int()
long()
float()
complex()
str()
list()
tuple()
计算
cmp(x,y) x<y返回-1 x==y返回0 x>y返回1
abs()
boll()
divmod() #分别取商和余数
max()
min()
sum()
pow(x,y) 返回x的y次幂
len() 长度
all() 接受一个序列，如果所有都是真返回真，否则返回假
any() 接受一个序列，只要有一个真就是真
eval(dic) 把传入的字符串转换成字典
assic码转换
chr() 接收数字返回字符
ord() 接收字符返回数字
进制转换
hex() 10转16
oct() 10转8
bin() 10转2

#enumerate
自动生成一列数字对应列表里的值,从0开始
li=[11,22,33,44]
for k,v in enumerate(li,1):#从1开始
print(k,v)
输出：
(1, 11)
(2, 22)
(3, 33)
(4, 44)
'''

isinstance
　　isinstance：判断一个对象是不是某个类的实例，这个类可以是创建该对象的类，也可以是创建该对象的类的基类
在python中，判断对象类型的方法有两种，type和isinstance
a=2
print(isinstance(a,int)) #Ture
print(isinstance(a,str)) #False

print(type(a)==int) #Ture
print(isinstance(a,str)) #False
　　(2)isinstance还能判断一个对象是不是某个类的实例

class test:
pass
class AA(test):
pass
class BB:
pass

obj=AA()
#判断obj对象是不是AA类的实例
print(isinstance(obj,AA)) #Ture
print(isinstance(obj,BB)) #False

#判断obj对象是不是test类的实例
print(isinstance(obj,test)) #Ture

issubclass
　　issubclass：判断一个类是不是另一个类的派生类

class test:
pass
class AA(test):
pass
class BB:
pass

#判断AA是不是test的派生类
print(issubclass(AA,test)) #True
#判断BB是不是test的派生类
print(issubclass(BB,test)) #False

map遍历序列

#map遍历序列，对序列中每个元素进行操作，最终获得新的序列
li=[11,22,33,44]
li1=[1,2,3,4]
def func(arg):
return arg+10
print map(func,li)
#输出：[21, 32, 43, 54]

def func1(a1,a2):
return a1+a2
print map(func1,li,li1)
#输出：[12, 24, 36, 48]

print map(lambda a1,a2:a1+a2,li,li1) #lambda一句实现
#输出：[12, 24, 36, 48]

filter筛选

#filter 筛选
li=[11,22,33,44,"",False,True,0]
print filter(None,li) #传入None，返回是True的序列
#输出：[11, 22, 33, 44, True]

li1=[11,22,33,44,55,66]
print filter(lambda a:a>22,li1)#返回是True的序列
#输出:[33, 44, 55, 66]

reduce累积

#reduce 累积操作
li=[1,2,3,4,5,6]
print reduce(lambda a1,a2:a1+a2,li)
#输出：21 就是((((1+2)+3)+4)+5)+6
#print reduce(lambda a1,a2:a1+a2,li,xxx)#累加 最后还可以加参数作为初始值
print reduce(lambda a1,a2:a1*a2,li)#来乘
#输出：720

每个文件模块自己的变量

#__file__
print __file__ #当前文件路径

#__doc__
import index
print index.__doc__ #index是模块名，可查看一个文件模块的顶部注释

#__name__ 用来判断是不是程序的主文件
#当主程序执行时__name__="__main__"
if __name__=="__main__":
pass

2.自定义函数
　　def 函数名(参数):
　　 函数体
1.return 当函数执行完毕后，可以给调用者返回数据
2.参数
　　普通参数：参数可以有n个，但必须传入指定个数的参数
　　默认参数：如果默认参数不传值，则使用默认值，并且默认参数只能放在最后
　　动态参数：
　　　　动态参数一：*args

#接受多个参数,内部自动构造元组
#传入序列要加*，避免内部构造元组
li=[11,22,33]
def func(*args):
print(args)
func(li) #把传的列表当成元组的元素
func(*li) #加*把传的列表内的每个元素当成元组的元素
#输出：
#([11, 22, 33],)
#(11, 22, 33)

　　　　动态参数二：**kwargs

#构造字典(两*)
dic={"a":1,"b":2}
def func1(**kwargs):
print(kwargs)
func1(a=11)
func1(**dic)
#输出：
#{'a': 11}
#{'a': 1, 'b': 2}

结合上面两种：

def func2(*args,**kwargs):
print(args)
print(kwargs)
func2(1,2,3,a=1,b=2)
#输出：
#(1, 2, 3)
#{'a': 1, 'b': 2}

四、文件操作
1.打开文件
文件句柄 = file('文件路径', '模式')
模式：

'''
r 只读模式
w 只写模式(不可读,不存在则创建,存在则删除内容)
a 追加模式(可读,不存在则创建,存在则只追加内容)
"+" 表示可以同时读写某个文件

r+ 可读写文件(可读,可写,可追加)
w+ 写读
a+ 同a

rU 表示在读取时，可以将 自动转换成 （只能与r或r+模式一起使用）

"b" 表示处理二进制文件
rb 以2进制方式去读取文件
wb
ab
'''

2.操作文件

'''
close() 关闭文件
fileno() 文件描述符
flush() 刷新文件内部缓冲区
isatty() 判断文件是否是同意tty设备
next() 获取下一行数据，不存在，则报错
read() 读取指定字节数据
readline() 仅读取一行数据
readlines() 读取所有数据，并根据换行保存到列表
xreadlines()可用于逐行读取文件，非全部
seek() 指定文件中指针位置
tell() 获取当前指针位置
truncate() 截断指针后面的内容只留前面的
write() 写
writelines()将一个字符串列表写入文件
'''

with
　　为了避免打开文件后忘记关闭,当with代码块执行完毕时，内部会自动关闭并释放文件资源
with open('','r') as obj:
obj.read()
Python 2.7后with还支持多个文件管理
with open('','r') as obj1,open('') as obj2:
pass
五、lambda 表达式
lambda和三元运算类似，是为了简化函数，不过只能用于处理简单函数，并且能自动return

#正常函数
def lam1(arg):
return arg+1
print lam1(10)

#lambda表达式
lam2=lambda arg:arg+1#(lam2等于上面的函数名，arg等于上面的参数)
print lam2(10)

lam3=lambda a,b:a+b
print lam3(2,3)

六、递归
1、递归：在运行的过程中调用自己就叫做递归
下面举个最典型的递归案例：斐波纳契数列（1、1、2、3、5、8、13、21.....）

#用递归实现
def func(arg1,arg2):
if arg1 == 0:
print(arg1)
print(arg2)
arg3=arg1+arg2
print(arg3)
if arg3>1000:
return
func(arg2,arg3) #在函数内部调用自身
func(0,1)

上面的代码可以实现斐波纳契数列的输出
2、递归的返回值

#递归的返回值
def func(arg1,arg2):
if arg1 == 0:
print(arg1)
print(arg2)
arg3=arg1+arg2
if arg3>1000:
return arg3 #返回值
func(arg2,arg3)
result=func(0,1)
print(result) #输出：None

上面代码可以看到，输出的是None，是因为函数第一次执行时的返回值才是result，当函数一直被调用时，return arg3 的返回值是返回给了他上一次
调用的函数func(arg2,arg3)，以此往前推
如果代码如下：递归函数就能返回最后一次的返回值

def func(arg1,arg2):
if arg1 == 0:
print(arg1)
print(arg2)
arg3=arg1+arg2
if arg3>1000:
return arg3
ret=func(arg2,arg3) #把内部调用的函数的返回值赋值给ret
return ret

result=func(0,1)
print(result) #输出：1597