Python复习总结（2）

SHYLearn_Python

3. 格式化输入与输出

3.1 格式化输入

a = input(<info>)
a = input(repr(str))

3.2 格式化输出

3.2.1 print语句

print(a, b)   同行以空格隔开输出
print(a, b,s ep=',')  以逗号隔开进行输出
print(s, ewp='\n')   以换行隔开进行输出
print(name, end='!')  每个输出都要添加!
print(' i love %s ' % s)  print 格式化输出
# 对字符串的每个元素进行换行输出
for item in list:
    print(item)  

3.2.2 字符串方法format()

print('{0} : {1} : {2}'.format(hour, minute, second))
# 按照对齐格式化进行排列
print('{0:3},{1:5}'.format(12, 534)) :后面的内容为只等的格式，表示占位数，如果不够，在前面用空格补齐

3.2.3 数据输出的格式类型

# a表示占位，不够，按照原长度打印，多了左侧空格补齐，小数点后面为保留几位小数，f位数据类型
print('i love %a.bf', num)
- b 以二进制形式输出
- c 输出证书值对应的unicode字符
- d 以十进制形式输出数值
- e 以科学计数法形式输出
- o 以八进制形式输出
- x 以小写形式的十六进制输出
- X 以大写形式的十六进制输出

4. 函数

4.1 函数定义及调用函数

- def funname(para1, para2,*，para3...):
    函数体
# 在参数列表中使用（*），代表调用函数时，在（*）后面的参数都必须指定参数名称，如下
funname(para1, para2，para3=2...)   调用函数
- def fun(strname, age=32)：   后面的参数位默认形参，默认形参必须放在后面
- 对元组和列表进行解包
def fun(*person):
fun('shy','21')
mylist = ['shy','21']
fun(*mylist)
- 对字典进行解包定义参数及调用
def fun(**person)
print('姓名',person['name'],'年纪',person['age'])
fun('shy','21')
mydict = {'name':'shy','age':21}
fun(**mydict)

4.2 函数类型

4.2.1 python内置函数

下图python3.8官方文档给出的内置函数库：

官方中文文档的连接：https://docs.python.org/zh-cn/3/library/functions.html

4.2.2 匿名函数与可迭代函数

• 匿名函数

# 匿名函数
lambda para1, para2... : 表达式
r = lambda x,y:x*y

# 匿名函数与reduce函数的组合应用
reduce(fun, seq, initial)  #用序列值依次调用fun
from funtools import reduce
a = reduce(lambda x,y:x + y, range(1,101))  #实现求1~100的和

# 匿名函数与map函数的组合应用
map(fun, seq[,seq,])  #将seq内部的元素作为参数依次调用
t = map(lambda x:x**2,[1,2,3,4,5])  #返回一个map对象
print(list(t))   #打印值为[1,4,9,16,25]
y =map(lambda x,y:x+y,[1,2,3],[4,5,6])
print(list(t))   # 打印值为[5,7,9]

# 匿名函数与filter函数的组合应用
filter(fun or none, seq)  #将序列对象依次放到fun中，如果返回true就留下
t = filter(lambda x:x%2==0, [1,2,3,4,5,6])
print(list(t))   # 打印值为[2,4,6]

• 可迭代函数

# 每个生成器对象会有一个__next__()方法
t = filter(lambda x:x%2==0, [1,2,3,4,5,6])
print(t.__next__())  # 打印2
print(t.__next__())  # 打印4

4.2.3 生成器函数与工厂函数

• 生成器函数

# 生成器与迭代器不同，迭代器的内容存在内存里，用next函数遍历，生成器用完立即销毁
def Reverse(data):
    for idx in range(len(data)-1,-1,-1):
        yield data[idx]   # 生成器函数用yield返回
for c in Reverse('Python'):
    print(c, end = ' ')  # 打印 n o h t y P

# 生成器表达式
mylist = [x*x for x in range(3)]  # 使用生成器表达式返回一个对象

• 工厂函数

# 闭合函数
def wrapperfun(strname):
    def recorder(age)：
        print(strname,age)
    return recorder

fun = wrapperfun('shy')
fun(37)    # 打印 shy 37

# 装饰器属性：在原有的函数包一个函数，不改变原代码的基础上，添加新功能
def checkParams(fn):    # 装饰器函数
    def wrapper(strname):
        if isinstance(strname.(str))：
            return fn(strname)  # 判断字符串类型
        print ('error')  
        return
    return wrapper

def wrapperfun(strname):
    def recorder(age)：
        print(strname,age)
    return recorder
wrapperfun2 = checkParams(wrapperfun)
fun = wrapperfun('shy')
fun(37)  # 打印 shy 37
fun = wrapperfun2(37)  # 输入不合法

• @修饰符

def checkParams(fn):    # 装饰器函数
    def wrapper(strname):
        if isinstance(strname.(str))：
            return fn(strname)  # 判断字符串类型
        print ('error')  
        return
    return wrapper

@checkParams   # 使用装饰器函数对wrapperfun函数进行修饰
def wrapperfun(strname):
    def recorder(age)：
        print(strname,age)
    return recorder

fun = wrapperfun('shy')
fun(37)  # 打印 shy 37
fun = wrapperfun2(37)  # 输入不合法

4.4.4 偏函数与递归函数

• 偏函数

# 偏函数是重新定义一个函数，并指定了默认参数值
from funtools import partial
partial(fun, *args, **keywords)

• 递归函数

# 递归函数是自己调用自己的函数，所有的函数调用都是压栈的过程，所以耗内存，栈空间有限，如果程序栈空间地址写满，程序最后会崩溃
def fun(n):
    return n*fun(n-1)

4.4.5 eval 和 exec函数

• eval函数

# exec执行不返回结果，eval执行返回结果
dic = {}
dic['b'] = 3
exec('a=4',dic)
print(dic.keys())   #打印dict_keys(['a','__builtins__','b'])
# 使用这两个函数第一个参数一定是可执行代码

4.3 变量的作用域

4.3.1 global语句

# global 可以把局部声明为全局
a = 6
def func():
    global a
    a = 5
print(a)   # 打印5

4.3.2 nonlocal语句

# nonlocal可以把全局往下一作用域调用
a = 6
def func():
    a = 7
    def nested():
        nonlocal a
            a+=1
    nested()
    print('本地:',a)   #打印 8
func()
print('全局',a)  # 打印6
print(a)   # 打印5

5. 面向对象的程序设计

5.1 类的结构

class MyClass：
    def __init__(self,属性):  # 构造函数
        self.属性 = 属性
        pass
    def getname(self):
        return self.name
    ......

myc = MyClass(属性)   # 初始化实例对象，构造函数的属性
a = myc.getname()   

# 类还具有一些内置属性
__name__   名称
__doc__  类的文档字符串
__nodule__ 类的模块
if __name__ == '__main__':

5.2 类方法

@classmthod  # 声明为类方法，可以直接用类名进行调用，当然初始化实例对象进行调用也是正确的
def fun(cls):
@staticmethod  # 等同于普通函数，只是被封装在类中，独立于整个类
def fun()  # 同上的调用方式，且参数没有限制要求

5.3 类的私有化属性

# 私有化属性方法，在类的属性前面加双下划线，同时会提供一个私有化属性的访问函数，不可以被修改,但可以针对具体实例进行对象修改
clas MyClass:
    __Occupation = 'scientist'

    def __init__(sefl,name,age)；
    def getOccupation(self):
        return self.__Occupation
# 使用装饰器函数实现类的私有化
clas MyClass:
    __Occupation = 'scientist'

    def __init__(sefl,name,age)；
    @property  # 装饰为属性，使类的私有化属性也可以被访问
    def getOccupation(self):
        return self.__Occupation

5.4 类的继承

5.4.1 继承结构体

class DerivedClass(FatherClass1, FatherClass2)：
    pass

class Record:
    """ A record class """
    __Ocuupation = "scientist"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def showrecode(self):
        print("Occupation:",self.getOccupation())
    
    def getOccupation(self):
        return self.__Occupation

class GirlRecord(Record):
    """ A girlrecord class """
    def showrecode(self):
        Record.showrecode(self)
        print("the girl:", self.name, "age:", self.age)

myc = GirlRecord("Anaa", 21)
myc.showrecode()

5.4.2 super()函数

# 保障了调用父类方法时只调用一次
class Record:
    """ A record class """
    __Ocuupation = "scientist"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def showrecode(self):
        print("Occupation:",self.getOccupation())
    
    def getOccupation(self):
        return self.__Occupation

class GirlRecord(Record):
    """ A girlrecord class """
    def showrecode(self):
        super().showrecode(self)
        print("the girl:", self.name, "age:", self.age)

class MaleRecord(Record):
    """ A girlrecord class """
    def showrecode(self):
        super().showrecode(self)
        print("the girl:", self.name, "age:", self.age)
        
class ThisRecord(GirlRecord, MaleRecord):
    """ A girlrecord class """
    def showrecode(self):
        super().showrecode(self)
        print("the girl:", self.name, "age:", self.age)
myc = ThisRecord("Anaa", 21)
myc.showrecode()

5.5 类相关的内置函数

• 判断实例（isinstance)

isinstance(object, class_name)

• 判断字类（issubclass)

issubclass(class1, class2)

• 判断类实例中是否包含某一个属性（hasattr)

hasattr(object, name)

• 获得类实例中的某一个属性（getattr)

getattr(object, name[,default])

• 设置类实例中的某一个属性值（setattr)

setattr(object, name, value)

5.6 重载运算符

class MyClass:
    """ A record class"""
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):  # 将值转化为字符串进行输出
        retrun "name:"+self.name;"age:"+str(self.age)
    
    __repr__ = __str__  # 转化为解释器读取的形式

    def __lt__(self, record):  #重载比较运算符
        if self.age < record.age:
            return True
        else:
            return False

    def __add__(self, record):   #重载加号运算符
        return MyClass(self.name, self.age+record.age)

myc = MyClass("A", 42)
myc1 = MyClass("B", 23)

print(repr(myc))  
print(myc)
print(str(myc))
print(myc<myc1)
print(myc+myc1)

• 运算符重载

 方法名                  运算符和表达式      说明
__add__(self,rhs)        self + rhs        加法
__sub__(self,rhs)        self - rhs         减法
__mul__(self,rhs)        self * rhs         乘法
__truediv__(self,rhs)    self / rhs          除法
__floordiv__(self,rhs)   self //rhs          地板除
__mod__(self,rhs)        self % rhs       取模(求余)
__pow__(self,rhs)        self **rhs         幂运算
合赋值算术运算符的重载:
方法名                  运算符和表达式      说明
__iadd__(self,rhs)       self += rhs        加法
__isub__(self,rhs)       self -= rhs         减法
__imul__(self,rhs)       self *= rhs         乘法
__itruediv__(self,rhs)   self /= rhs        除法
__ifloordiv__(self,rhs)  self //=rhs        地板除
__imod__(self,rhs)       self %= rhs     取模(求余)
__ipow__(self,rhs)       self **=rhs       幂运算

比较算术运算符的重载:
方法名                  运算符和表达式      说明
__lt__(self,rhs)       self < rhs        小于
__le__(self,rhs)       self <= rhs       小于等于
__gt__(self,rhs)       self > rhs        大于
__ge__(self,rhs)       self >= rhs       大于等于
__eq__(self,rhs)       self == rhs       等于
__ne__(self,rhs)       self != rhs       不等于
        

位运算符重载
方法名              运算符和表达式        说明
__and__(self,rhs)       self & rhs           位与
__or__(self,rhs)        self | rhs           位或
__xor__(self,rhs)       self ^ rhs           位异或
 __lshift__(self,rhs)    self <<rhs           左移
 __rshift__(self,rhs)    self >>rhs           右移

反向位运算符重载

方法名            运算符和表达式       说明
__and__(self,lhs)       lhs & rhs        位与
__or__(self,lhs)         lhs | rhs       位或
__xor__(self,lhs)       lhs ^ rhs        位异或
__lshift__(self,lhs)    lhs <<rhs        左移
__rshift__(self,lhs)    lhs >>rhs        右移

复合赋值位相关运算符重载
方法名              运算符和表达式          说明
__iand__(self,rhs)       self & rhs       位与
__ior__(self,rhs)        self | rhs       位或
__ixor__(self,rhs)       self ^ rhs       位异或
__ilshift__(self,rhs)    self <<rhs       左移
__irshift__(self,rhs)    self >>rhs       右移

一元运算符的重载
方法名              运算符和表达式       说明
__neg__(self)         - self           负号
__pos__(self)         + self           正号
__invert__(self)      ~ self           取反