Python 温习

关于Python内置函数的示例

 1 Type "copyright", "credits" or "license()" f重写or more information.
 2 >>> class Student:
 3     def __init__(self,score):
 4         self.score=score
 5     def __len__(self):
 6         return self.score
 7 
 8     
 9 >>> Jack=Student()
10 >>> Jack=Student(103)
11 >>> Jack
12 <__main__.Student object at 0x02BDA470>
13 >>> len(Jack)
14 103

 1 >>> class qwe(str):
 2     def upper(self):
 3         return self.lower()
 4 
 5     
 6 >>> a='ASD'
 7 >>> a=qwe(a)
 8 >>> a
 9 'ASD'
10 >>> a.upper()
11 'asd'

测试对象属性的部分方法.

 1 Type "copyright", "credits" or "license()" for more information.
 2 >>> class Student():
 3     pass
 4 
 5 >>> Jack=Student()
 6 >>> hasattr(Jack,'name')
 7 False
 8 >>> Jack.name='Jack'
 9 >>> Jack.name
10 'Jack'
11 >>> hasattr(Jack,'score')
12 False
13 >>> setattr(Jack,'socre',103)
14 >>> Jack.socre
15 103

 1 Type "copyright", "credits" or "license()" for more information.
 2 >>> class Student():
 3     name='jack'
 4 
 5     
 6 >>> jack=Student()
 7 >>> jack.name
 8 'jack'
 9 >>> getattr(jack,name)
10 Traceback (most recent call last):
11   File "<pyshell#5>", line 1, in <module>
12     getattr(jack,name)
13 NameError: name 'name' is not defined
14 >>> getattr(jack,'name')
15 'jack'
16 >>> getattr(jack,'score',404)
17 404

关于类的实例属性和类属性

由于Python是动态语言,根据类创建的实例可以任意绑定属性 . (s.name='jack')

给实例绑定属性的方法是通过实例变量直接赋值,或者通过self变量 . 

下面就是通过self变量来绑定类属性.

如果类本身就有该属性的话 , 当声明实例变量之后 , 会自动绑定类中提供的属性 , 但是如果在通过实例变量直接再将该属性再次赋值 , 这次的值可以覆盖类中的属性 , 当删除通过实例变量赋值过的属性之后 , 类中的属性就会自动重新绑定到实例变量上面.

 1 >>> class Student():
 2     name='Student'
 3 
 4     
 5 >>> s=Student()
 6 >>> s.name
 7 'Student'
 8 >>> s.name='jack'
 9 >>> s.name
10 'jack'
11 >>> del s.name
12 >>> s
13 <__main__.Student object at 0x02EE34B0>
14 >>> s.name
15 'Student'
16 >>> 

 

当类已经写好之后如何分别在 实例变量和类中 再次加入方法 , 方法的作用范围是什么?

2016年7月26日 02:33:28 ......不早了 去冲个澡再来 .  

 1 Type "copyright", "credits" or "license()" for more information.
 2 >>> class Student:
 3     pass
 4 
 5 >>> jack=Student()
 6 >>> # 先开始给实例变量绑定属性 (只作用于该变量)
 7 >>> def Set_age(self,age):　　#　　和普通的类一样 这里也必须是 self 
 8     self.age=age
 9 
10     
11 >>> Set_age(jack,18)
12 >>> jack.age
13 18
14 >>> loser=Student()
15 >>> loser.age
16 Traceback (most recent call last):
17   File "<pyshell#11>", line 1, in <module>
18     loser.age
19 AttributeError: 'Student' object has no attribute 'age'

上面的是比较简单的 . 直接写一个函数 , 套进去就行 . 

下面开始将 类 绑定方法 并且观察作用范围 . 

 1 >>> from types import MethodType
 2 >>> class Student():
 3     pass
 4 
 5 >>> def Set_age(self,age):
 6     self.age=age
 7 
 8     
 9 >>> jack=Student()
10 >>> Student.Set_age=MethodType(Set_age,Student)
11 >>> loser=Student()
12 >>> jack.Set_age(18)
13 >>> loser.Set_age(28)
14 >>> jack.age
15 28
16 >>> 
17 >>> loser.age
18 28

可以看出来 , 不管添加方法是在该实例变量声明之前 还是 声明之后 这个实例变量都可以使用添加进去的方法 . 但是在添加之前 是不能让 已经声明的实例变量使用 将要添加的方法的.

如何限制实例的属性 .

 1 >>> class Student():
 2     __slots__=('name')
 3 
 4     
 5 >>> jack=Student()
 6 >>> jack.name='Jack'
 7 >>> jack.score=19
 8 Traceback (most recent call last):
 9   File "<pyshell#5>", line 1, in <module>
10     jack.score=19
11 AttributeError: 'Student' object has no attribute 'score'

 1 >>> class Student():
 2     __slots__=('name')
 3 
 4     
 5 >>> class Teacher(Student):
 6     pass
 7 
 8 >>> jack=Teacher()
 9 >>> jack.score=18
10 >>> jack.score
11 18

当继承的时候 __slots__是不起作用的 ,  

当我们用　　Python　　的　　print　　输出的时候他们是调用该实例对象对应的类中 __str__函数 , 当直接调用该实例对象的时候 运行的是 __repr__

 1 >>> class Student():
 2     def __init__(self,name):
 3         self.name=name
 4     def __str__(self):
 5         return ('Student named %s' %self.name)
 6 
 7     
 8 >>> jack=Student('Jack')
 9 >>> print(jack)
10 Student named Jack
11 >>> jack
12 <__main__.Student object at 0x02E41ED0>
13 >>> class Student():
14     def __init__(self,name):
15         self.name=name
16     def __str__(self):
17         return ('Student named %s' %self.name)
18     __repr__=__str__
19 
20     
21 >>> jack=Student('Jack')
22 >>> jack
23 Student named Jack

__iter__ 迭代

如果一个类被用于 for 循环 , 类似list 和 tuple那样 , 就必须实现一个 __iter__方法 , 该方法返回一个迭代对象 , 然后 , Python 的 for 循环就会 开始调用 __next__方法 拿到循环的下一个值 . 直到遇到 StopIteration错误时推出循环 .

下面我们写一个 Fib 类 , 可以用作for循环 ,                                              

 1 >>> class Fib():
 2     def __init__(self):
 3         self.a,self.b=0,1 # 初始化两个计数器 a,b
 4     def __iter__(self):
 5         return self # 实例的本身就是迭代对象 , 故只返回自己
 6     def __next__(self):
 7         self.a,self.b=self.b,self.a+self.b # 计算下一个值   # 在这里 没有先后之分 . 
 8         return self.a # 返回下一个值
 9 
10     
11 >>> for i in Fib():
12     print(i)
13 1
14 1
15 2
16 3
17 5
18 8
19 13
20 21
21 34
22 55
23 89
24 144
25 233
26 377
27 610
28 987
29 1597
30 2584
31 4181
32 6765

 

                                                                                                                                                                                                                                                                                                                                                                                           

 

转载于:https://www.cnblogs.com/A-FM/p/5706005.html