python基本数据预处理语法函数(2)

1、字符串格式化方法format的用法：

< ^ >    #分别为左对齐、居中、右对齐
'{:>18,.2f}'.format(70305084.0)      #:冒号+空白填充+右对齐+固定宽度18+浮点精度.2+浮点数声明f
'{:^10}'.format('test')     #返回test居中，共计10个字符
'{1} {0}'.format('one', 'two')    #{}中的数字代表排列的顺序
'my name is {name},age is {age}'.format(name='hoho',age=19)
'{0:*>10}'.format(10)  # 右对齐
'{0:*<10}'.format(10)  ##左对齐，冒号后跟以*作为填充
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print ('my name is {name}, age is {age},from {province}'.format(**b_dict))    #通过字典来对句子进行填充
print ('{:>7.2%}'.format(0.2))   #以百分比的形式输出值
i=1 j=2
print('{} shape is {}'.format(i,j))   #返回1 shape is 2

def sayhi(a,b):
    print('%s 的后面是 %s' %(a ,b))
sayhi('i','ii')

2、enumerate的用法：

list=['这','是','一个','测试']
for i,item in enumerate(list):
    print(i,item)
#输出

0 这
1 是
2 一个
3 测试

3、datetime包

from datetime import datetime, timezone
datetime.today()   #返回当天信息
dt=datetime.now()   #返回现在的信息
dt.year
dt.hour
dt.minute  #返回当前的分钟
dt.second     #返回当前的秒
dt.weekday()   #返回星期几

4、filter函数

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
#输出结果：[1, 3, 5, 7, 9]

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(newlist)
#输出结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

5、json模块()

1）json.dumps()

#json.dumps用于将dict类型的数据转换为str，因为如果直接将dict类型的数据写入json文件会报错，所以在写入数据时需要用到该函数
import json
name_emb = {'a':'','b':'','c':'','d':''}
jsObj = json.dumps(name_emb)
print(name_emb)
print(jsObj)
print(type(name_emb))
print(type(jsObj))
###返回结果如下：
{'a': '', 'b': '', 'c': '', 'd': ''}
{"a": "", "b": "", "c": "", "d": ""}
<class 'dict'>
<class 'str'>

name_emb = {'a':'','b':'','c':'','d':''}
emb_filename = ('/home/cqh/faceData/emb_json.json')
jsObj = json.dumps(name_emb)
with open(emb_filename, "w") as f:
    f.write(jsObj)
    f.close()    

2）json.loads()

import json
name_emb = {'a':'','b':'','c':'','d':''}
jsDumps = json.dumps(name_emb)
jsLoads = json.loads(jsDumps)
print(name_emb)
print(jsDumps)
print(jsLoads)
print(type(name_emb))    #返回class：dict
print(type(jsDumps))  　#返回class：str
print(type(jsLoads))    #返回class：dict   

6、self的简单讲解：

self表示类的实例，而非类，以如下代码为例：

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
t=Test()
t.prt()

输出结果为：

<__main__.Test object at 0x000001DCCF2C12E8>
<class '__main__.Test'>

由结果可以发现，self代表类的实例，self.__class__指向类。

在解释器内部，t.qrt()等价于Test.prt(Test())

在继承的时候，继承的是传入的实例，而非定义了self的类的实例。以如下为例：

class Parent:
    def pprt(self):
        print(self)

class Child(Parent):
    def cprt(self):
        print(self)
c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()

在运行c.pprt()的时候，由于self指得是Child类的实例，self中未定义pprt()的方法，所以沿着继承树网上找，找到了父类Parent中定义的pprt()方法，所以成功调用。

在如下例子中，self指的是描述符类的实例：

class Desc:
    def __get__(self, ins, cls):
        print('self in Desc: %s ' % self )
        print(self, ins, cls)
class Test:
    x = Desc()
    def prt(self):
        print('self in Test: %s' % self)
t = Test()
t.prt()
t.x

这里调用的是t.x，也就是Test类的实例t的属性x，由于实例t中并没有定义属性x，所以找到了类属性x。该属性是描述符属性，为Desc类的实例，所以这里就没有用Test的任何方法。若直接运行Test.x也能得到相同的结果。

另一个实例：

class person:
    def __init__(self,name,job=None,pay=10):
        self.name=name
        self.job=job
        self.pay=pay
    def getLastName(cls):
        return cls.name.split('a')[-1]
    def getRaise(self,percent):
        self.pay=(int)(self.pay*(1+percent))
        return self.pay
p=person('xiaoming','jixie')   #用于实例化一个对象
p.getLastName()
p.getRaise(0.8)

在这里self指的是被实例化的对象p，需要调用当前的方法或者属性时，直接使用self.来进行调用就可以。

在这里init通常被称为构造函数，用于初始化，即当实例化一个对象时，对新对象进行初始化，通过传入新对象的参数将新对象的所有属性都初始化。

7、super函数的应用：

参考：http://python.jobbole.com/86787/

通过super函数实现父类的调用：

class animal(object):
    def __init__(self,name):
        self.name=name
    def greet(self):
        print('hello i am %s' %self.name)
class dog(animal):
    def greet(self):
        super().greet()
        print('我擦 擦')
dog=dog('dog')
dog.greet()
#返回：hello i am dog  我擦 擦

这里animal是父类，dog是子类，我们在dog类定义了greet方法，为了同时实现父类的功能，又调用了父类的方法，从而得到相应的输出结果。

另一个继承的例子：

class Base(object):
    def __init__(self):
        print ("enter Base")
        print ("leave Base")
class A(Base):
    def __init__(self):
        print ("enter A")
        super(A, self).__init__()
        print ("leave A")
class B(Base):
    def __init__(self):
        print ("enter B")
        super(B, self).__init__()
        print ("leave B")
class C(A, B):
    def __init__(self):
        print ("enter C")
        super(C, self).__init__()
        print ("leave C")

输出结果为：

>>> c = C()
enter C
enter A
enter B
enter Base
leave Base
leave B
leave A
leave C