#coding:utf-8
#函数的高级特性,切片:对经常取指定索引范围的操作用循环比较繁琐
#因此用切片操作
L=[]
n=1
while n<=99:
L.append(n)
n=n+2
print L
#按照左闭右开原则
print L[0:3] #1,3,5
print L[:3] #同上0可以省略
print L[1:3] #3,5
#倒数第一个元素的索引是-1
print L[-1] #99
print L[-2:-1] #97
print L[:10]
print L[-10:]
print L[10:20]
print L[::5] #所有数每5个取一个
L1=L[:] #所有元素复制给L3
print L1
print L[:10:2] #前十个数,每两个取一个
#tuple是一种list,tuple不可变tuple切片之后仍为tuple
L4=(1,2,3,4,5,6,)
print L4[:3]
print 'ABCDEFG'[:2]
print 'ABCDEFG'[::2] #ACEG
#迭代(默认迭代key)
m={"a":1,"b":2,"c":3}
for x in m:
print x,"=",m[x]
#迭代value
for v in m.itervalues():
print v
#迭代key value
for k,v in m.items():
print k,"=",v
for x in "ABC":
print x
#判断对象是否可迭代
from collections import Iterable
print isinstance("abc",Iterable)#True
print isinstance([1,2,3],Iterable)#True
print isinstance(223,Iterable)#Flase
#python内置的enumerate函数可以把一个list变成索引—元素对,
for i,value in enumerate(["A","B","C"]):
print i,value #i代表下标
for x,y in [(1,2),(3,4),(5,6)]:
print x,y
#列表生成式,python内置简单强大可以用来创建list的生成式
#例子:
print range(1,11)#列出的是1-10
print [x*x for x in range(1,11)]#列出的是1-10的平方
#因此列表生成式可以使用两个变量来生成list
d2 = {1:'A',2:'B',3:'C'}
print [str(k) + '=' + v for k,v in d2.iteritems()]
#生成器:一边循环一边计算的机制,
L=[x*x for x in range(1,11)]
print L
g=(x*x for x in range(10))
print g
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
print g.next()
for x in g:
print x
print 'hdsdhdhhdhd'
#生成器高级内容
def f(max):
n,a,b=0,0,1
while n<max:
yield b #遇到yield语句返回
a,b=b,a+b
n=n+1
for x in f(6):
print x
#odd函数遇到yield之后就中断,下次又继续执行三次之后没有可以执行的了
#第四次调用next()报错
def odd():
print 'step 1'
yield 1
print 'step 2'
yield 3
print 'step 3'
yield 5
o=odd()
o.next()
o.next()
o.next()
#函数是编程:python提供部分支持,不是纯的函数式编程语言
#高阶函数:变量可以指向函数,函数可以接受变量,那么一个函数就可以接收另一个函数作为参数,这种函数为高阶函数
print abs(-1)#绝对值
print abs
x=abs
print x
print x(-10)
#让函数的参数可以用函数代替
def add(x,y,f):
return f(x)+f(y)
print add(-5,6,abs)
#map():接收两个参数,函数和序列,map将传入的函数一次作用到序列的每个元素,并将结果作为新的list返回
#例子:
def f(x):
return x*x
print map(f,[1,2,3,4,5,6,7,8,9]) #[1, 4, 9, 16, 25, 36, 49, 64, 81]
#reduce:将一个函数作用在一个序列上接收两个参数,将结果继续和序列的下一个元素做累积运算
def add(x,y):
return x+y
print reduce(add,[1,2,3,4,5]) #15
#将序列和为字符串
def fn(x,y):
return x*10+y
print reduce(fn,[1,2,3,4,5]) #12345
'''
重点题
'''
def char2num(s):
return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
print map(char2num,'13579')
print reduce(fn,map(char2num,'13579'))#map得到值,reduce转为串
#filter:过滤序列:接收一个函数和一个序列作用是将传入的函数一次作用于每个元素,然后根据返回值是ture还是false决定保留还是丢弃该元素
def is_odd(n):
return n%2==1
print filter(is_odd,[1,2,4,5,6,9,10,15])
print '-----------------'
#sorted(也是一个高阶函数)
#>>>sorted([36,5,12,9,21])
#倒叙排序例子
def rever(x,y):
if x>y:
return -1
if x<y:
return 1
return 0
print sorted([36,5,12,9,21],rever)
#闭包:当一个函数返回了一个函数后,内部的局部变量还被新函数引用
#例子:
def ok(*args):
def sum():
ax=0
for n in args:
ax=ax+n
return ax
return sum
f=ok(1,2,3,4)
print f()
#面向对象:
std1={'name':'Michael','score':98}
std2={'name':'cccc','score':46}
def print_score(std):
print '%s:%s' %(std['name'],std['score'])
print_score(std1)
print '----------------'
class Student(object):
def __init__(self,name,score):#__init__一定不能写错左右各两个下划线(改了半个多小时)
self.name=name
self.score=score
def print_score(self):
print '%s:%s' %(self.name,self.score)
mike=Student('Mike',99)
jack=Student('shang',33)
mike.print_score()
jack.print_score()
#__init__ 的第一个参数必须是self,传入参数时必须与__init__方法匹配的参数
#self 无需传值
'''
class Hotel(object):
def __init__(self, room, cf=1.0, br=15):
self.room = room
self.cf = cf
self.br = br
def cacl_all(self, days=1):
return (self.room * self.cf + self.br) * days
if __name__ == '__main__':
stdroom = Hotel(200)
big_room = Hotel(230, 0.9)
print stdroom.cacl_all()
print stdroom.cacl_all(2)
print big_room.cacl_all()
print big_room.cacl_all(3)
'''
print '--------------------'
#数据的封装:
class Student(object):
def __init__(self,name,score):
self.name=name
self.score=score
def _print_score(self):
print'%s %s' %(self.name,self.score)
def setName(self,name):
self.name=name
def getName(self):
return self.name
mike=Student('Mike',99)
jack=Student('shang',33)
mike.name="nnnn"
mike.setName("fff")
print mike.getName()
print '--------------'
#访问限制:内部属性不被外部访问,可以在属性的名称前加两个下划线__,#实例变量名如果以两个下划线开头,则变量变为私有变量
#得到值或者修改值的时候调用setget方法即可
#__XXX__以双下划线开头以双下划线结尾的特殊变量,是可以直接访问的
#继承
class Animal(object):
def run(self):
print "Animal run"
class Dog(Animal):
def make(self):
print "Dog make"
def run(self):
print "dog run"
#多态
def go(animal):
animal.run()
ani=Animal()
dog=Dog()
go(dog)
go(ani)
print isinstance(ani,Dog) #false
print isinstance(dog,Animal) #true
print '---------------'
#获取对象信息
#1.type()
print type(123)
#2.isinstance()
print isinstance(u'a',unicode)
print '---------------'
#dir 获取一个对象的所有属性和方法:
print dir(object)
print dir(str)
print '---------------'
#getattr() setattr() hasattr
class MyObject(object):
def __init__(self):
self.x = 9
def power(self):
return self.x * self.x
obj = MyObject()
print hasattr(obj, 'x')# 有属性'x'吗?
print hasattr(obj, 'y') # 有属性'y'吗?
print setattr(obj, 'y', 19) # 设置一个属性'y'
print hasattr(obj, 'y') # 有属性'y'吗?
getattr(obj, 'y') # 获取属性'y'
print obj.y # 获取属性'y'
print getattr(obj, 'z', 404) # 获取属性'z',如果不存在,返回默认值404
print hasattr(obj,'')
print getattr(obj,'power') #获取属性power
fn = getattr(obj, 'power')#???
print fn()
print '-------高级面向对象--------'
#动态绑定的两种方式
class Student(object):#该类成员为空
pass
s1=Student()
s1.name='mike'#绑定属性
print s1.name
def ok(self,age):#age初始化
self.age=age
# #动态绑定方法
from types import MethodType
# #给实例s1绑定方法
s1.ok=MethodType(ok,s1,Student)#把ok绑定Student类的s1对象
s1.ok(120)#调用实例方法
print s1.age#age并不是私有的
s3=Student()
#动态定义的方法,对另一个实例失效
#s3.ok(50);
#我们可以使用给class绑定方法,
Student.ok=MethodType(ok,None,Student)#绑定到Student类,所有对象通用
s2=Student()
s2.ok(100)
print s2.age
s3=Student()
s3.ok(200)
print s3.age
print '-------__slots__限制class属性------定义的属性对继承的子类不起作用--'
class Student(object):
__slots__=('name','age')
s=Student()
s.age=100
s.name="mike"
#s.score=90 没定义所以没有这个属性
print s.age
print s.name
print '----使用@property-访问类的变量--就是说函数名字可以相同注释不同--'
class S(object):
@property
def birth(self):
return self._birth
@birth.setter
def birth(self,value):
self._birth=value
s=S()
s._birth='AAA'
print s._birth
print '----多重继承---一个子类可以同时拥有多个父类-'
class People(object):
def eat(self):
print "Animal Eat"
class Runnable(object):
def run(self):
print "Runnable run"
class Stu(People,Runnable):
def go(self):
print "Stu go"
s=Stu()# s继承了两个类就有了三个方法
s.eat()
s.go()
s.run()
#定制类:形如__XXX__
#__str__:打印整体类对象类似__repr__都可以重写
class stu(object):
def ok(self):
return "student :ok"
def __str__(self):#重写
return "student:使用了__str__"
def __repr__(self):#重写
return "student:使用了__str__"
print stu()
#__iter__:如果一个类想被用于for...in循环,该方法返回一个迭代对象然后python的for循环就会不断调用该迭代对象的的next()方法拿到循环的下一个值
#直到遇到StopIteration错误时推出循环
class Foo:
def __init__(self):
print '初始化开始'
self.a=0
def next(self):
self.a=self.a+2
return '*'*self.a
def __iter__(self):
print "开始了:%d"%self.a
return self
f=Foo()
for i in f:
if len(i)<12:
print i+'\n'
else:
break
这是本人自己python学习的第二部分基础内容,还有第三部分