首页 > 代码库 > Python零散函数

Python零散函数

 

1. python json.dumps() json.dump()的区别

  注意cat ,是直接输出文件的内容

  load和loads都是实现“反序列化”,区别在于(以Python为例):

  • loads针对内存对象,即将Python内置数据序列化为字串

    如使用json.dumps序列化的对象d_json=json.dumps({‘a‘:1, ‘b‘:2}),在这里d_json是一个字串‘{"b": 2, "a": 1}‘

    d=json.loads(d_json)  #{ b": 2, "a": 1},使用load重新反序列化为dict

  • load针对文件句柄

    如本地有一个json文件a.json则可以d=json.load(open(‘a.json‘))

    相应的,dump就是将内置类型序列化为json对象后写入文件

2. sorted和sort

  sorted(iterable, cmp=None, key=None, reverse=False)

  

3. 请定义Person类的__init__方法,除了接受 name、gender 和 birth 外,还可接受任意关键字参数,并把他们都作为属性赋值给实例。

class Person(object):
    def __init__(self,name,gender,birth,**kw):
        self.name = name
        self.gender = gender
        self.birth = birth
        for key,value in kw.items():
            setattr(self,key,value)
        

xiaoming = Person(Xiao Ming, Male, 1990-1-1, job=Student)

print xiaoming.name
print xiaoming.job

 

34 请给 Person 类添加一个类属性 count,每创建一个实例,count 属性就加 1,这样就可以统计出一共创建了多少个 Person 的实例。

class Person(object):
    count = 0
    def __init__(self,name):
        self.name = name
        Person.count += 1
        

p1 = Person(Bob)
print Person.count

p2 = Person(Alice)
print Person.count

p3 = Person(Tim)
print Person.count

5. 类的私有变量不可以直接获取,但可以用方法实例或者类私有方法获取

# 通过实例的方法获取
class Person(object):
    __count = 0
    def __init__(self,name):
        self.name = name
        Person.__count += 1 

    def get_count(self):
        return Person.__count

p1 = Person(Alice)
p2 = Person(Tom)

print p1.get_count()
# => 2

# 通过类私有方法获取
class Person(object):
    __count = 0
    def __init__(self,name):
        self.name = name
        Person.__count += 1 

    @classmethod
    def get_count(self):
        return self.__count

p1 = Person(Alice)
p2 = Person(Tom)

print Person.get_count()
# => 2

 6. 类的继承和组合

  每个类的定义都需要继承,没有的话,就从object继承

  6.1 组合:has关系

技术分享

  6.2 继承:is关系

技术分享

    示例:

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher,self).__init__(name,gender)
#或者Person.__init__(self,name,gender)
        self.course = course

 

 

7. python中多态

类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 Person 派生出 Student和Teacher ,并都写了一个 whoAmI() 方法:

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return I am a Person, my name is %s % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return I am a Student, my name is %s % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return I am a Teacher, my name is %s % self.name

 

在一个函数中,如果我们接收一个变量 x,则无论该 x 是 Person、Student还是 Teacher,都可以正确打印出结果:

def who_am_i(x):
    print x.whoAmI()

p = Person(Tim, Male)
s = Student(Bob, Male, 88)
t = Teacher(Alice, Female, English)

who_am_i(p)
who_am_i(s)
who_am_i(t)
运行结果:

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

 

这种行为称为多态。也就是说,方法调用将作用在 x 的实际类型上。s 是Student类型,它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法,但调用 s.whoAmI()总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。

由于Python是动态语言,所以,传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法即可:

class Book(object):
    def whoAmI(self):
        return I am a book

 

这是动态语言和静态语言(例如Java)最大的差别之一。动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用。

任务

Python提供了open()函数来打开一个磁盘文件,并返回 File 对象。File对象有一个read()方法可以读取文件内容:

例如,从文件读取内容并解析为JSON结果:

import json
f = open(/path/to/file.json, r)
print json.load(f)

 

由于Python的动态特性,json.load()并不一定要从一个File对象读取内容。任何对象,只要有read()方法,就称为File-like Object,都可以传给json.load()。

请尝试编写一个File-like Object,把一个字符串 r‘["Tim", "Bob", "Alice"]‘包装成 File-like Object 并由 json.load() 解析。

import json

class Students(object):
    def read(self):
        return ["Tim", "Bob", "Alice"]

s = Students()

print json.load(s)

 

 

 

8. python 类的特殊方法

技术分享

 

 需要说明的是,对于单纯的数字可以用内建的cmp()函数进行sorted()

但如果不是单纯数字或者不是单纯字母,我们就需要自己定义__cmp__()

定义的__cmp__() 函数里面,可以使用cmp()进行优选排序,cmp()是升序,-cmp()是降序

示例

class Student(object):

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

    def __str__(self):
        return (%s: %s) % (self.name, self.score)

    __repr__ = __str__

    def __cmp__(self, s):
        if self.score == s.score:
            return cmp(self.name,s.name)
        return -cmp(self.score,s.score)

L = [Student(Tim, 99), Student(Bob, 88), Student(Alice, 99)]
print sorted(L)


#返回结果:[(Alice: 99), (Tim: 99), (Bob: 88)]

 

 

 

  

 

Python零散函数