python基础内容学习总结 (二)

#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学习的第二部分基础内容，还有第三部分