python 入门（4）

最新推荐文章于 2023-05-18 22:37:06 发布

wgcnqad

最新推荐文章于 2023-05-18 22:37:06 发布

阅读量406

点赞数

CC 4.0 BY-SA版权

分类专栏： Python 文章标签： python

本文链接：https://blog.youkuaiyun.com/wgcnqad/article/details/49530801

Python 专栏收录该内容

6 篇文章

订阅专栏

模块，包 ##：

模块没什么好说的，相当于java的一个java文件引入模块就用import
如 import math 。
模块多了也会同名，解决这个问题就把一类模块放入一个包。
引用一个完整的模块我们需要在import 包.模块
另外包必须有init.py
当要引用某个函数我们就用
from xx.py import pow ,sin,cos
还可以给引用的函数起别名用as
如
from xx.py import pow ,sin,cos as a,b,c
如果导入的模块不存在，Python解释器会报 ImportError 错误：

动态引入包

import something
Traceback (most recent call last):
File “”, line 1, in
ImportError: No module named something
有的时候，两个不同的模块提供了相同的功能，比如 StringIO 和 cStringIO 都提供了StringIO这个功能。

这是因为Python是动态语言，解释执行，因此Python代码运行速度慢。

如果要提高Python代码的运行速度，最简单的方法是把某些关键函数用 C 语言重写，这样就能大大提高执行速度。

同样的功能，StringIO 是纯Python代码编写的，而 cStringIO 部分函数是 C 写的，因此 cStringIO 运行速度更快。

利用ImportError错误，我们经常在Python中动态导入模块：

try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO

使用future

Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。要“试用”某一新的特性，就可以通过导入future模块的某些功能来实现。

例如，Python 2.7的整数除法运算结果仍是整数：

10 / 3
3
但是，Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

10 / 3
3.3333333333333335
10 // 3
3
要在Python 2.7中引入3.x的除法规则，导入future的division：

from future import division
print 10 / 3
3.3333333333333335
当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到future中，以便旧的代码能在旧版本中测试新特性

安装第三方模块

使用pip install web.py

类

创建类 class 类名（object）: 就创建好了,object是他的父类
class Person(object):
pass
按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。类的继承将在后面的章节讲解，现在我们只需要简单地从object类继承。

有了Person类的定义，就可以创建出具体的xiaoming、xiaohong等实例。创建实例使用类名+()，类似函数调用的形式创建：
创建实例属性
虽然可以通过Person类创建出xiaoming、xiaohong等实例，但是这些实例看上除了地址不同外，没有什么其他不同。在现实世界中，区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。

如何让每个实例拥有各自不同的属性？由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值，例如，给xiaoming这个实例加上name、gender和birth属性：

xiaoming = Person()
xiaoming.name = ‘Xiao Ming’
xiaoming.gender = ‘Male’
xiaoming.birth = ‘1990-1-1’
给xiaohong加上的属性不一定要和xiaoming相同：

xiaohong = Person()
xiaohong.name = ‘Xiao Hong’
xiaohong.school = ‘No. 1 High School’
xiaohong.grade = 2

初始化实例方法

就是java中的构造器
def init(self,a,b,c):
第一个参数是self
任务
请定义Person类的init方法，除了接受 name、gender 和 birth 外，还可接受任意关键字参数，并把他们都作为属性赋值给实例。

?不会了怎么办
要定义关键字参数，使用 **kw；

除了可以直接使用self.name = ‘xxx’设置一个属性外，还可以通过 setattr(self, ‘name’, ‘xxx’) 设置属性。

参考代码:

class Person(object):
def init(self, name, gender, birth, **kw):
self.name = name
self.gender = gender
self.birth = birth
for k, v in kw.iteritems():
setattr(self, k, v)
xiaoming = Person(‘Xiao Ming’, ‘Male’, ‘1990-1-1’, job=’Student’)
print xiaoming.name
print xiaoming.job

私有

访问限制
我们可以给一个实例绑定很多属性，如果有些属性不希望被外部访问到怎么办？

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：

class Person(object):
def init(self, name):
self.name = name
self._title = ‘Mr’
self.__job = ‘Student’
p = Person(‘Bob’)
print p.name

=> Bob

print p._title

=> Mr

print p.__job

=> Error

Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘Person’ object has no attribute ‘__job’
可见，只有以双下划线开头的”__job”不能直接被外部访问。

但是，如果一个属性以”xxx“的形式定义，那它又可以被外部访问了，以”xxx“定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用”xxx“定义。

以单下划线开头的属性”_xxx”虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。

类属性

类是模板，而实例则是根据类创建的对象。

绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

定义类属性可以直接在 class 中定义：

class Person(object):
address = ‘Earth’
def init(self, name):
self.name = name
因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：

print Person.address

=> Earth

对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：

p1 = Person(‘Bob’)
p2 = Person(‘Alice’)
print p1.address

=> Earth

print p2.address

=> Earth

由于Python是动态语言，类属性也是可以动态添加和修改的：

Person.address = ‘China’
print p1.address

=> ‘China’

print p2.address

=> ‘China’

因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。
定义实例方法
一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？

虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):

def __init__(self, name):
    self.__name = name

def get_name(self):
    return self.__name

get_name(self) 就是一个实例方法，它的第一个参数是self。init(self, name)其实也可看做是一个特殊的实例方法。

调用实例方法必须在实例上调用：

p1 = Person(‘Bob’)
print p1.get_name() # self不需要显式传入

=> Bob

在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度
方法也是属性
我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：

class Person(object):
def init(self, name, score):
self.name = name
self.score = score
def get_grade(self):
return ‘A’

p1 = Person(‘Bob’, 90)
print p1.get_grade

=>

=> A

也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，p1.get_grade() 才是方法调用。

因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：

import types
def fn_get_grade(self):
if self.score >= 80:
return ‘A’
if self.score >= 60:
return ‘B’
return ‘C’

class Person(object):
def init(self, name, score):
self.name = name
self.score = score

p1 = Person(‘Bob’, 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()

=> A

p2 = Person(‘Alice’, 65)
print p2.get_grade()

ERROR: AttributeError: ‘Person’ object has no attribute ‘get_grade’

因为p2实例并没有绑定get_grade

给一个实例动态添加方法并不常见，直接在class中定义要更直观。
定义类方法
和属性类似，方法也分实例方法和类方法。

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

要在class中定义类方法，需要这么写：

class Person(object):
count = 0
@classmethod
def how_many(cls):
return cls.count
def init(self, name):
self.name = name
Person.count = Person.count + 1

print Person.how_many()
p1 = Person(‘Bob’)
print Person.how_many()
通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

任务
如果将类属性 count 改为私有属性__count，则外部无法读取__score，但可以通过一个类方法获取，请编写类方法获得__count值。

?不会了怎么办
注意类方法需要添加 @classmethod

参考代码:

class Person(object):
__count = 0
@classmethod
def how_many(cls):
return cls.__count
def init(self, name):
self.name = name
Person.__count = Person.__count + 1

print Person.how_many()
p1 = Person(‘Bob’)
print Person.how_many()