• python基础(三元运算+深浅拷贝+函数参数)


    三元运算

    三元运算,又称三目运算,主要作用是减少代码量,是对简单的条件语句的缩写。

    1 书写格式:
    2 result = 值1 if 条件 else 值2
    3 即如果条件成立,则将值1赋给result变量,如果不成立,将值2赋给result变量
    4 eg:name = "tina" if 1==1 else "fei"
    name = "tina" if 1!=1 else "fei"
    print(name)
    执行结果如下:
    fei 
    小练习:
    a = 1 if True else 0
    print(a)
    b=1 if False else 0
    print(b)
    c = "Fire" if True else "Water"
    print(c)
    d = "Fire" if False else "Water"
    print(d)
    
    执行结果如下:
    1
    0
    Fire
    Water 

    深浅拷贝

    1、对于数字和字符串而言,赋值、浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址
    只要是拷贝,不管是深拷贝还是浅拷贝以及赋值,其地址id都是一样的。
     
    import copy
    #数字类型
    n1 = 222
    print(id(n1))
    #赋值
    n2 = n1
    print(id(n2))
    #字符串类型
    n1 = "tina is a beauty"
    n2 = n1
    print(id(n1),id(n2))
    ###执行结果如下:
    1638075088
    1638075088
    948823211080 948823211080
    ###由此可以看出字符串和数字类型的赋值,其内存指向的是同一块内存###
    #浅拷贝
    n1 = 22
    n2 = "asdf"
    n3 = copy.copy(n1)
    n4 = copy.copy(n2)
    print(id(n1),id(n3))
    print(id(n2),id(n4))
    执行结果如下:
    1638068688 1638068688
    168374752680 168374752680
    ###由此可以看出字符串和数字类型的浅拷贝,其内存指向的是同一块内存###
    #深拷贝
    n3 = copy.deepcopy(n1)
    n4 = copy.deepcopy(n2)
    print(id(n1),id(n3))
    print(id(n2),id(n4))
    执行结果如下:
    1638068688 1638068688
    778961474984 778961474984 
    ###由此可以看出字符串和数字类型的深拷贝,其内存指向的是同一块内存###

    画图说明:

    2、对于列表、元组、字典而言,浅拷贝只拷贝最外层,深拷贝是全部拷贝,除了最底层的值(数字、字符串)不变。
    值是拷贝的索引
    #赋值
    n1 = {"k1":"222","k2":"tina",'k3':['beauty',123]}
    n2 = n1
    print(id(n1),id(n2))
    执行结果如下:
    1003839407944 1003839407944
    
    # ###结合上面数字字符串的内容可以看出任何类型的赋值,其内存指向的是同一块内存###

     

    #浅拷贝(在内存中开创一块空间,创建第一层数据,相当于只拷贝了索引)
    import copy
    n1 = {"k1":"222","k2":"tina",'k3':['beau',123]}
    n2 = copy.copy(n1)
    print(id(n1),id(n2))
    执行结果如下:
    715111778248 712964936072
    #内存地址是不一样的

    #深拷贝(在内存中将与所有的数据重新创建一份,但由于python内部对数字和字符串的优化:永远指向同一块内存,所以最后一层不改变)
    import copy
    n1 = {"k1":"222","k2":"tina",'k3':['beau',123]}
    n2 = copy.deepcopy(n1)
    print(id(n1),id(n2))
    执行代码如下:
    205036701640 205037113416

    函数

     1、概念:

    • 面向过程编程:

            根据业务逻辑从上到下实现功能,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,也就是将之前实现的代码块复制到现需功能处

    • 函数式编程:

            将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可,函数式编程最重要的是增强代码的重用性和可读性

    • 面向对象编程:

            对函数进行分类和封装,让开发“更快更好更强...”

     2、函数的定义及使用:

    1 def  函数名(参数):
    2       ......
    3       函数体
    4       ......
    5       返回值
     
    函数定义的关键点:
    • def:表示函数的关键字
    • 函数名:函数的名称,日后根据函数名调用函数
    • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888]中的最大数等
    • 参数:为函数体提供数据
    • 返回值:当函数执行完毕后,可以给调用者返回数据

    返回值不是必须的,如果没有return语句,则Python默认返回值None。

    函数名的命名规则(跟变量一样):

    函数名必须以下划线或字母开头,可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号;

    函数名是区分大小写的。

    函数名不能是保留字。

     3、函数的返回值:

    返回值的作用是:判断函数是否执行成功,如果没有写return返回值时,默认返回none

    函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。
    例如:
    def 发送短信():
          发送短信的代码
         。。。。。。
          if 发送成功:
              return True
          else:
              return False
    
    while True:
        result = 发送短信()
        if result == False:
            记录日志,短信发送失败...
    
     # 每次执行发送短信函数,都会将返回值自动赋值给result
     # 之后,可以根据result来写日志,或重发等操作   
    ###函数的返回值###
    #返回一个值:
    def onevalue(a,b):
        c = a + b
        return c
    print(onevalue(1,2))
    #返回多个值:
    def secondvalue(a,b,c):
        d = a + b + c
        return(a,b,c,d)
    print(secondvalue(11,22,33))
    #返回多个值:
    def somevalue(a,b):
     c = a + b
     return (a,b,c)
    x,y,z = somevalue(1,2)
    print('x:',x,'y:',y,'z:',z)
    执行结果如下:
    3
    (11, 22, 33, 66)
    x: 1 y: 2 z: 3

     4、函数参数:

    (1)实现形式:

    • 无参数时:
    def CPU报警邮件()
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
    
    def 硬盘报警邮件()
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
    
    def 内存报警邮件()
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
     
    while True:
     
        if cpu利用率 > 90%:
            CPU报警邮件()
     
        if 硬盘使用空间 > 90%:
            硬盘报警邮件()
     
        if 内存占用 > 80%:
            内存报警邮件()
    
    无参数实现
    • 有参数时:
    def 发送邮件(邮件内容)
    
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
    
     
    while True:
     
        if cpu利用率 > 90%:
            发送邮件("CPU报警了。")
     
        if 硬盘使用空间 > 90%:
            发送邮件("硬盘报警了。")
     
        if 内存占用 > 80%:
            发送邮件("内存报警了。")
    
    有参数实现

    (2)参数的种类:

    • 普通参数
    形参,实参,传参
    def email(p,text,subject):
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr
    
        msg = MIMEText(text,'plain','utf-8')
        msg['From'] = formataddr(["菲菲",'wptawy@126.com'])
        msg['To'] = formataddr(['hhhh','424662508@qq.com'])
        msg['Subject'] = subject
    
        server = smtplib.SMTP('smtp.126.com',25)
        server.login('wptawy@126.com','WW.3945.59')
        server.sendmail('wptawy@126.com',[p,],msg.as_string())
        server.quit()
    email("1156997553@qq.com","youjianneirong","zhuti")
    ##其中,p,text,subject就是形参,"1156997553@qq.com","youjianneirong","zhuti"是实参,即实参是执行函数时实际传入的值。
    ######### 定义函数 ######### 
    
    # name 即为函数aa的形式参数,简称:形参
    def aa(name):
        print name
    
    ######### 执行函数 ######### 
    #  'tina' 就是函数func的实际参数,简称:实参
    func('tina')
    • 默认参数
    def fun(name, age = 18):
        print("%s:%d" %(name,age))
    # 指定参数
    fun('tina', 19)
    # 使用默认参数
    fun('tony')
    执行结果如下:
    tina:19
    tony:18
    
    注:默认参数需要放在参数列表最后
    • 动态参数

    (a)一个星号的动态参数(*args):

    一个*号传递的参数默认定义为元祖类型
    def f1(*a):
        print(a,type(a))
    f1(123,456,[222,33])
    执行结果如下:
    (123, 456, [222, 33]) <class 'tuple'>
    def func(*args):
        print(args)
    
    # 执行方式一
    func(11,33,4,4454,5)
    执行结果如下:
    (11, 33, 4, 4454, 5) <class 'tuple'>
    
    # 执行方式二
    li = [11,2,2,3,3,4,54]
    func(*li)
    执行结果如下:
    (11, 2, 2, 3, 3, 4, 54) <class 'tuple'>

    (b)两个星号的动态参数(**kwargs):

    两个*号传递的参数默认定义为字典类型
    def f1(**a):
        print(a,type(a))
    f1(k1=123,k2=456)
    执行结果如下:
    {'k1': 123, 'k2': 456} <class 'dict'>
    def func(**kwargs):
        print(kwargs,type(kwargs))
    
    # 执行方式一
    func(name='tina',age=18)
    执行结果如下:
    {'name': 'tina', 'age': 18} <class 'dict'>
    
    # 执行方式二
    li = {'name':'tina', 'age':18, 'gender':'female'}
    func(**li)
    执行结果如下:
    {'gender': 'female', 'name': 'tina', 'age': 18} <class 'dict'>

    (c)*args和**kwargs的结合:

    def f2(p,*a,**aa):
        print(p,type(p))
        print(a,type(a))
        print(aa,type(aa))
    f2(11,22,33,k1=123,k2=456)
    执行结果如下:
    11 <class 'int'>
    (22, 33) <class 'tuple'>
    {'k2': 456, 'k1': 123} <class 'dict'>
    def show (*arg,**kwargs):
        print (arg,type(arg))
        print (kwargs,type(kwargs))
    show([11,22,33],[44],['a','b'],k1='v1',k2='v2')
    执行结果:
      ([11, 22, 33], [44], ['a', 'b']) <class 'tuple'>
      {'k2': 'v2', 'k1': 'v1'} <class 'dict'>
    
    ##结论:同时传递两个带*号的参数,在形参定义里,第一个形参只能是带一个*号,第二个形参只能是带两个*号,同时在参数传递的时候,第一个参数只能是普通的定义,第二个参数是字典的定义
    
    def show (*arg,**kwargs):
        print (arg,type(arg))
        print (kwargs,type(kwargs))
    
    li = [[11,22,33],[44],['a','b']]
    di = {'k1':'v1','k2':'v2'}
    show (li,di)
    
    show(*li,**di)
    
    执行结果:
      ([[11, 22, 33], [44], ['a', 'b']], {'k1': 'v1', 'k2': 'v2'}) <class 'tuple'>
      {} <class 'dict'>
      ([11, 22, 33], [44], ['a', 'b']) <class 'tuple'>
      {'k1': 'v1', 'k2': 'v2'} <class 'dict'>
    
    ##结论:通过第一种方式来传参数,python默认认为传到了第一个*号的形参那里,第二个*号不会接收参数。通过第二种方式来传递参数,才能将匹配的参数传给对应的形参。

     (d)动态参数的应用

    动态参数的应用:
    s = '{0} is {1}'
    li = ['tina','charming']
    re = s.format(*li)
    print(re)
    
    s = '{a} is {b}'
    di = {'a':'tina','b':'charming'}
    re = s.format(**di)
    print(re)
    
    执行结果为:
    tina is charming
    tina is charming

      5、全局变量和局部变量:

    全局变量也称为外部变量,它是在函数外部定义的变量。 它不属于哪一个函数,它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量,一般应作全局变量说明。 只有在函数内经过说明的全局变量才能使用。全局变量的说明符为global。 但在一个函数之前定义的全局变量,在该函数内使用可不再加以说明。

    局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。

    PERSON = "tina"
    def fun1():
        a = 123
        global PERSON
        PERSON = "fei"
        print(a)
    def fun2():
        a = 456
        print(PERSON)
        print(a)
    fun1()
    fun2()
    
    执行结果如下:
    123
    fei
    456

    *注:全局变量要大写,局部变量要小写

  • 相关阅读:
    类的无参方法笔记
    类的无参预习内容
    类和对象
    洛谷 题解 P2010 【回文日期】
    洛谷 题解 CF711A 【Bus to Udayland】
    洛谷 题解 P2676 【超级书架】
    洛谷 题解 CF903B 【The Modcrab】
    洛谷 题解 P1585【魔法阵】
    HDU 2553【N皇后问题】
    一些函数
  • 原文地址:https://www.cnblogs.com/tina-python/p/5467730.html
Copyright © 2020-2023  润新知