人生苦短之我用Python篇（遍历、函数、类）

#遍历

info = {'key1':'value1','key2':'value2','key3':'value3'}
#方式一
for i in info:
    print(i,info[i])
#方式二
for key,value in info.items():
    print(key,value)

li = [1,2,3,5,4,7,9,7]
for index,v in enumerate(li):
 print(index,v)

函数：

---

*定义函数，函数体不执行，只有调用函数时，函数体才执行。

#写一个监控程序，监控服务器的系统状况，当cpu＼disk＼memory等指标的使用量超过阀值时即发邮件报警
#不使用函数版
while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
     
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
     
    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
#以上代码存在问题：

    #1.代码重复过多，一个劲的copy and paste不符合高端程序员的气质
    #2.如果日后需要修改发邮件的这段代码，比如加入群发功能，那你就需要在所有用到这段代码的地方都修改一遍

#函数版
def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
     
while True：
     
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
     
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
     
    if 内存占用 > 80%:
        发送邮件('内存报警')

为什么需要函数？

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

语法：

def say():      #定义函数，def为关键词，say为函数名
    print("Hello,my name is ChenTaicheng,I'm fine,Thank you.")      #函数内容，为一系列语句

say()       #调用函数

带参数

#下面这段代码
a,b = 5,8
c = a**b
print(c)
 
 
#改成用函数写
def calc(x,y): #该函数可以接受传入两个参数，即x,y，多一个不行，少一个也不行
    res = x**y
    return res #返回函数执行结果
 
c = calc(a,b) ＃结果赋值给c变量
print(c)

形参与实参

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

默认参数

def stu_register(name, age, course, country='CN'):#定义函数时设置默认参数
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)


stu_register("张三", 22, "python_devops","美国")#有传值则使用传入的值
stu_register("李四", 21, "linux")#没有传值则使用默认参数

stu_register(age=22,name='CCIE',course="python",) #使用指定参数名赋值，里面的参数就得都使用指定参数名赋值的方式

非固定参数：*args    *keyargs

非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register('ctc',22) #输出 ctc 22 ()，后面这个()就是args,只是因为没传值,所以为空
stu_register('ctc',22,'python','qypt') #输出 ctc 22 ('python', 'qypt')

还可以有一个**kwargs
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register('ctc',22) #输出ctc 22 () {}，{}#后面这个{}就是kwargs,只是因为没传值,所以为空
stu_register('ctc',22,'python','qypt') #输出 ctc 22 ('python', 'qypt') {}
stu_register('ctc',22,'python',school = 'qypt',sex = 'man') #ctc 22 ('python',) {'school': 'qypt', 'sex': 'man'}

全局变量与局部变量

'''
全局与局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
'''
name = "ChenTaicheng"  #全局变量


def change_name(name):
    print("before change:", name)
    name = "一个改变世界的人"  #局部变量
    print("after change", name)


change_name(name)

print("在外面看看name改了么?", name)

-----------------------------------------------------------------------------》
-----------------------------------------------------------------------------》
输出结果：
before change: ChenTaicheng
after change 一个改变世界的人
在外面看看name改了么? ChenTaicheng

递归与返回值

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n
    return calc(int(n / 2))


f = calc(10)
print(f)  #输出函数的返回值

输出：
10
5
2
1
1  #函数的返回值

匿名函数 ：匿名函数就是不需要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))
你也许会说，用上这个东西没感觉有毛方便呀， 。。。。呵呵，如果是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，如下
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):
    return f(x) + f(y)
 
 
res = add(3,-6,abs)  #即把一个函数名当中参数值，abs为求绝对值的函数的函数名
print(res)

 装饰器：

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。
它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。
装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

# 一个简单的例子
# def foo():
#     print("I'm foo")
#
# foo()

# 现在有新需求，需要添加一个新功能
# def foo():
#     print("NEW function")
#     print("I'm foo")
#
# foo()
#如果Bar1()，Bar2()也需要添加这个新功能，此时就需要在每个函数里添加这个新功能的代码，就造成了大量的重复代码，
#所以就可以重新定义个函数用于表示这个新功能
#如下
# def foo():
#     print("I'm foo")
#
#
# def NEW_F(func):
#     print("NEW function")
#     func()
#
# NEW_F(foo)
#我们每次都要将一个函数作为参数传递给NEW_F函数。而且这种方式已经破坏了原有的代码逻辑结构，
# 之前执行业务逻辑时，执行运行bar()，但是现在不得不改成NEW_F(foo)。
#此时就需要装饰器了







#简单装饰器
# def foo():
#     print("I'm foo")
#
#
# def NEW_F(func):
#
#     def wrapper(*args,**keyargs):
#         print("NEW function")
#         return func(*args,*keyargs)
#     return wrapper
#
# foo = NEW_F(foo)
# foo()
#函数NEW_F就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像foo被
#NEW_F装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式
# 被称为面向切面的编程(Aspect-Oriented Programming)。
#@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作
# def NEW_F(func):
#
#     def wrapper(*args,**keyargs):
#         print("NEW function")
#         return func(*args,*keyargs)
#     return wrapper
#
#
# @NEW_F      #需注意装饰器函数必须先定义再应用
# def foo():
#     print("I'm foo")
#
#
# foo()
#如上所示，这样我们就可以省去foo = NEW_F(foo)这一句了，直接使用foo()了
#如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。

# 带参数的装饰器
# 装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@NEW_F，
# 该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，
# 提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
def logging_f(level):
    def decorator(func):
        def wrapper(*args,**keyargs):
            if level == "warn":
                print('出现紧急情况!')
            return func(*args)
        return wrapper
    return decorator


@logging_f(level="warn")
def foo():
    print("I'm foo")

foo()
#上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。
# 我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，
# 并把参数传递到装饰器的环境中。

 


类

---

面向对象

类

对象

# #
class Foo:  # class 类名

    def F1(self, name):  # 定义函数，在类中叫做方法
        print('Hello,world!')
        print(name)
        return '返回值'


# 调用类
# 创建对象
obj = Foo()  # 对象 = 类名（）
# 通过对象执行方法
r = obj.F1('chentaicheng')  # 对象.方法()
print(r)
# #

构造方法，self

析构方法

# #
class Foo:

    def __init__(self,name,age,addr):
        self.name = name
        self.age = age
        self.addr = addr

    def F1(self,name):
        print('Hello,world!')
        print(name)
        return '返回值'

    def __del__(self):#析构方法
        print("没有[%s]这个人了"%self.name)

#创建对象，即运行类名()就会自动先执行类中的__init__方法
obj = Foo('chentaicheng',21,'shantou')
print(obj.addr)   #obj.addr即使self.addr
del obj #del会触发析构方法
##

面向对象三大特性：封装、继承、多态

# 多态： 可对不同类的对象使用同样的操作。
# 封装：对外部世界隐藏对象的工作细节。
# 继承：以普通的类为基础建立专门的类对象。

封装：例子：__init__方法，把类（参数，参数……）括号里的参数封装到对象中去。

继承：

# 自己有先执行自己的，没有再从父类中找
# 没有共同父类时，一条道走到黑
# 有共同的一个父类时，从左先执行，走到顶端（未到父类）就不走缩回去

 

#先上一个比较简单的单继承语法。在python3中，基类的构造函数不会被自动调用，需要手动调用，同样的方法也是这样，需要手动调用。
可以使用类名称 + init方法，也可以使用super语法进行调用。在下面这个例子中，子类继承了基类的方法和字段。字段会在基类中初始化。
#

class BaseClass:
    def __init__(self):
        self.name = 'BaseClass'

        print('BaseCalss: Constructor called')

    def getname(self):
        print('BaseCalss: self name equals ' + self.name)


class DerivedClass(BaseClass):
    def __init__(self):
        super().__init__()

        print('DerivedClass: Constructor called')


if __name__ == '__main__':
    class1 = BaseClass()

    class1.getname()

    class2 = DerivedClass()

    class2.getname()
#
运行结果：
BaseCalss: Constructor called
BaseCalss: self name equals BaseClass
BaseCalss: Constructor called
DerivedClass: Constructor called
BaseCalss: self name equals BaseClass

子类也可以overwrite父类的方法，那么父类的方法就不会被调用，除非手动调用：

class BaseClass:
    def __init__(self):
        self.name = 'BaseClass'

        print('BaseCalss: Constructor called')

    def getname(self):
        print('BaseCalss: self name equals ' + self.name)


class DerivedClass(BaseClass):
    def __init__(self):
        super().__init__()

        print('DerivedClass: Constructor called')

    def getname(self):
        print('self.name init value is ' + self.name)

        self.name = 'DerivedClass'

        print('DerivedClass: self name equals ' + self.name)


if __name__ == '__main__':
    class1 = BaseClass()

    class1.getname()

    class2 = DerivedClass()

    class2.getname()
#
#         运行结果：
BaseCalss: Constructor called
BaseCalss: self name equals BaseClass
BaseCalss: Constructor called
DerivedClass: Constructor called
self.name init value is BaseClass
DerivedClass: self name equals DerivedClass

python不仅仅支持单继承，还支持多继承，字段和方法都可以被继承。在多继承super()只能代表继承的第一个父类，所以您在子类的构造函数中，不能单独使用super().__init__()，
那只是表示调用其中一个基类的构造函数。所以用super就不是那么好用了。还是要用会原来的类名 + init方法来调用。

class BaseClass1:
    def __init__(self):
        self.name1 = 'BaseClass1_Name1'

        self.name = 'BaseClass1_Name'

        print('BaseCalss1: Constructor called')

    def getname1(self):
        print('BaseCalss1: self name1 equals ' + self.name1)

    def getname(self):
        print('BaseCalss1: getname called, name equal ' + self.name)


class BaseClass2:
    def __init__(self):
        self.name2 = 'BaseClass2_Name2'

        self.name = 'BaseClass2_Name'

        print('BaseClass2: Constructor called')

    def getname2(self):
        print('BaseClass2: self name2 equals ' + self.name2)

    def getname(self):
        print('BaseCalss2: getname called, name equal ' + self.name)


class DerivedClass2(BaseClass1, BaseClass2):
    def __init__(self):
        BaseClass1.__init__(self)

        BaseClass2.__init__(self)

        print('DerivedClass: Constructor called')


if __name__ == '__main__':
    class1 = BaseClass1()

    class1.getname1()

    class2 = BaseClass2()

    class2.getname2()

    class3 = DerivedClass2()

    class3.getname1()

    class3.getname2()

    class3.getname()
#
#         运行结果：
BaseCalss1: Constructor called
BaseCalss1: self name1 equals BaseClass1_Name1
BaseClass2: Constructor called
BaseClass2: self name2 equals BaseClass2_Name2
BaseCalss1: Constructor called
BaseClass2: Constructor called
DerivedClass: Constructor called
BaseCalss1: self name1 equals BaseClass1_Name1
BaseClass2: self name2 equals BaseClass2_Name2
BaseCalss1: getname called, name equal BaseClass2_Name

我们可以看到，当两个基类有方法重名的时候，python3会按照您继承类的从左到右的顺序查找您调用的方法DerivedClass2(BaseClass1,BaseClass2)。在这个例子中，是先找BaseClass1，然后再找BaseClass2。如果您的代码需要多层继承的话，可以参开多重继承的Diamond Problem问题。

class A1:
    def foo1(self):
        print("Call A1's foo1")


class A2:
    def foo1(self):
        print("Call A2's foo1")

    def foo2(self):
        print("Call A2's foo2")


class B1(A1, A2):
    pass


class B2(A1, A2):
    def foo2(self):
        print("Call B2's foo2")


class C(B1, B2):
    pass


if __name__ == '__main__':
    class1 = C()

    class1.foo1()

    class1.foo2()

#         运行结果：
Call A1's foo1
Call B2's foo2

所以对于python3的多层继承来说，因为都是新式类，总是从左到右，广度优先的方式进行。

多态：

多态（英语：Polymorphism），是指面向对象程序运行时，相同的消息可能会送给多个不同的类之对象，而系统可依据对象所属类，引发对应类的方法，而有不同的行为。
简单来说，所谓多态意指相同的消息给予不同的对象会引发不同的动作称之。在面向对象程序设计中，多态一般指子类型多态（Subtypepolymorphism）。
上面的定义有点让初学者费解，黄哥用“打开”这个动作来描述面向对象的多态。"打开"，可以是打开门，打开窗户，打开书等等。"打开"这个动作，碰到不同的对象门，窗户，书，有不同的行为模式。
这个就是多态。

# 示例一：
class Door(object):
    def open(self):
        print("打开门")


class Windows(object):
    def open(self):
        print("打开窗户")


class Book(object):
    def open(self):
        print("打开书")


lst = [Door(), Windows(), Book()]

for item in lst:
    item.open()

# 示例二 一般用继承来说明多态的例子
class Animal:
    def __init__(self, name):
        self.name = name

    def talk(self):
        raise NotImplementedError("Subclass must implement abstract method")


class Cat(Animal):
    def talk(self):
        return 'Meow!'


class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'


animals = [Cat('Missy'),
           Cat('Mr. Mistoffelees'),
           Dog('Lassie')]

for animal in animals:
    print(animal.name + ': ' + animal.talk())

# #python 内置有很多多态的应用
# 同样的 ＋号 可以用在不同的对象相加，体现（相仿：指相加这个事情）了多态的功能。
# print (1 + 2)
# print ("hello " + 'world')
#
# # len 函数传不同的参数，也体现了多态的功能。
# print (len("python"))
# print (len([2, 4, 5, 7]))
#

 

 

---

 

---

 

 

成员：

---

 

 

字段：静态字段/普通字段

class Foo:

    stati = '静态字段'

    def F1(self):
        general = '普通字段'
        print(general)
        return 'F1返回值'

print(Foo.stati)    #静态字段加载类时自动创建,所以可以直接使用
obj = Foo()
obj.F1()

方法：函数在类中就叫做方法。

普通方法　　　　#由对象调用执行
@staticmethod　　　#由类调用执行
@calssmethod　　　#由类调用执行

class Foo:
    @classmethod
    def F1(cls,a1):  #cls必须要的
        print('f1',a1)

    @staticmethod
    def F2(a1):  #参数至少一个
        print(123,a1)

Foo.F1(111)     #由类调用，不需传入参数
Foo.F2(121)     #由类调用，至少传入一个参数

属性:具有方法的写作形式，具有字段的访问形式,即增删改差

@property　　@x.setter　　@x.deleter

统计页数
class pager:

    def __init__(self,all_count):
        self.all_count = all_count

    @property
    def all_pager(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1+1

    @all_pager.setter
    def all_pager(self,values):
        print('调用了setter')

    @all_pager.deleter
    def all_pager(self):
        print('调用了deleter')


p = pager(11)       #创建对象
ret = p.all_pager    #对象调用类中的方法，不加property时应该是p.all_paper()，使用了property后调用方法不用加（)
#即加了@property后，调用该方法不用需要 对象.方法（）而直接 对象.方法
print(ret)

p.all_pager = 111  #类中的all_paper方法使用了@property,则在使用p.all_paper = 时就会调用 类中加了all_paper.setter下面的方法，并且all_paper.setter下面的方法名也必须为all_paper

del p.all_pager

*反射：把字符串反射成内存地址

hasattr()　　、　　delattr()　　、　　setattr()　　、　　getattr()

反射即想到4个内置函数分别为:getattr、hasattr、setattr、delattr  获取成员、检查成员、设置成员、删除成员下面逐一介绍先看例子：

class Foo(object):
 
    def __init__(self):
        self.name = 'abc'
 
    def func(self):
        return 'ok'
 
obj = Foo()
#获取成员
ret = getattr(obj, 'func')#获取的是个对象
r = ret()
print(r)
#检查成员
ret = hasattr(obj,'func')#因为有func方法所以返回True
print(ret)
#设置成员
print(obj.name) #设置之前为:abc
ret = setattr(obj,'name',19)
print(obj.name) #设置之后为:19
#删除成员
print(obj.name) #abc
delattr(obj,'name')
print(obj.name) #报错

对于反射小节：

1.根据字符串的形式导入模块。
2.根据字符串的形式去对象（某个模块）中操作其成员　

 

 

---

转载于:https://www.cnblogs.com/tcheng/p/5876235.html