python基础3 集合三元运算深浅拷贝函数

一上节课拾遗

1 运算符

　　　字符串判断： “hello” in "asdasfhelloasdfsadf"

　　　列表元素判断："li" in ['li', 'ok']

　　　字典key判断：key in dic.keys()

2 基本的数据类型

 上节拾忆
基本数据类型

1

2

3

4

5

6

    字典：

列表一句变字典

li = [11,12,13]

dic = dict(enumerate(li,10))

print(11)

print(dic)

1、创建
            a = {"k1": 123}
            a = dict()
            
            li = [11,22,33]
            new_dict = dict(enumerate(li))
            print(new_dict)
        2、字典内部功能
            keys() #
            values()
            items()
            pop()
　　　　　　　get() #获取字典的key对应的value，如果该key不存在，则返回None
　　　　　　　fromkeys(seq,value=None) #  将有序的seq 作为字典的key，而value则为所有可以的公共值。共享其值
            
    　　　　key()  3版本取的时候 要么将字典的key 用list类进行转换 要么for循环放到空列表里面
　　　　　　　　2 版本 print(dic.keys()) 直接返回 一个列表
　　　　　　　　　　  
　　　　　　　　3 版本 print(dic.keys()) 返回的是一个类

　　　　　　fromkeys(seq,value=None) 解释：
　　　　　　　　
　　　　　　　　　　默认不写value的话，所有的值为None
n = dict.fromkeys(['k1', 'k2'], [])   #默认逗号后面不给的话，key对应的value都是None

n['k1'].append(2)  #我们修改逗号后面的空列表元素 打印 所有key的value也会修改
print(n)

n['k1'] = 3  # 而单独修改key的value的话，只有 这个key的value改了，而其他的key对应的value都不变
print(n)

n = dict.fromkeys()  #默认逗号后面不给的话，key对应的value都是None
print(n)

python基础3 集合三元运算深浅拷贝函数

二 集合 set

set集合，是一个无序且不重复的元素集合

 set
集合class

 set集合练习

 set集合练习

练习：寻找差异

# 数据库中原有
old_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
}
   
# cmdb 新汇报的数据
new_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
}

需要删除：？需要新建：？需要更新：？注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新

 set集合练习题答案
寻找差异 

三、三元运算符

python 的三元运算

　　变量名 = 变量1 if 条件判断成立 else 变量2

　　　　　　意指: 条件成立变量名值为变量1 否则为变量2

name = "eric" if 1 == 1 else "alex"
print("==",name)

lambda 带if条件的三元运算

1

2

3

4

5

6

7

8

l1 = [11,22,33,44,55]

#
for i in l1:

#    
if i % 2 == 0:

#        
m = map(lambda x:x+100,[i,])

#        
l1[l1.index(i)] = list(m)[0]

#
print(l1)

k=map(lambda x:(x+100) if (x%2==0) else x,l1)

print(list(k))

四深浅拷贝

1 数字和字符串

对于数字和字符串而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

python基础3 集合三元运算深浅拷贝函数

import copy
# ######### 数字、字符串 #########
n1 = 123
# n1 = "i am alex age 10"
print(id(n1))
# ## 赋值 ##
n2 = n1
print(id(n2))
# ## 浅拷贝 ##
n2 = copy.copy(n1)
print(id(n2))
  
# ## 深拷贝 ##
n3 = copy.deepcopy(n1)
print(id(n3))

二、其他基本数据类型

对于字典、元祖、列表而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。

1、赋值

赋值，只是创建一个变量，该变量指向原来内存地址，如：

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n2 = n1

python基础3 集合三元运算深浅拷贝函数

2、浅拷贝

浅拷贝，在内存中只额外创建第一层数据

import copy
  
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n3 = copy.copy(n1)

python基础3 集合三元运算深浅拷贝函数

3、深拷贝

深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）最底层数据要满足第一条赋值变量的条件

import copy
  
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n4 = copy.deepcopy(n1)

python基础3 集合三元运算深浅拷贝函数

五函数

1、背景

在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
    
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
    
    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

一看上述代码，if条件语句下的内容可以被提取出来公用，如下：

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

对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

2、定义和使用

1 def 函数名(参数):
2        
3     ...
4     函数体
5     ...
6     返回值

函数的定义主要有如下要点：

def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。注意是返回给函数调用者

2.1 返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

以上要点中，比较重要有参数和返回值：

如下  n5 返回值 返回给其调用者  再返回给上一层调用者。  如果 n4 n3 n2 n1 都不加return 则返回none
def n5():
    return 5
def n4():
    return n5()
def n3():
    return n4()
def n2():
    return n3()
def n1():
    return  n2()

ret1 = n1()
print(ret1)

 1 def 发送短信():
 2        
 3     发送短信的代码...
 4    
 5     if 发送成功:
 6         return True
 7     else:
 8         return False
 9    
10    
11 while True:
12        
13     # 每次执行发送短信函数，都会将返回值自动赋值给result
14     # 之后，可以根据result来写日志，或重发等操作
15    
16     result = 发送短信()
17     if result == False:
18         记录日志，短信发送失败...

2.2 、参数

为什么要有参数？

对比：

无参数

 View
Code

有参数

 View
Code

2.2.1 函数参数种类

函数的有三中不同的参数：

普通参数
默认参数
动态参数

普通参数

 View
Code

默认参数

 View
Code

动态参数1 ： *args 意指可以传入多个元素以逗号分割

 View
Code

如果元素参数是一个列表呢？我们把列表传入输出的一个元素是列表，但是我们想把列表的每个元素当一个参数。调用的时候加*

 1 #!/usr/bin/env python
 2 # _*_ coding:utf-8 _*_
 3 __author__ = 'liujianzuo'
 4 a=[1,3,4]
 5 def fuc(*args):
 6     #print(args)
 7     return args
 8 ret=fuc(a)
 9 print(ret)
10 
11 结果：
12 C:\Python35\python3.exe E:/py_test/s4/s5.py
13 ([1, 3, 4],)
14 
15 
16 
17 #!/usr/bin/env python
18 # _*_ coding:utf-8 _*_
19 __author__ = 'liujianzuo'
20 a=[1,3,4]
21 def fuc(*args):
22     #print(args)
23     return args
24 ret=fuc(*a)
25 print(ret)
26 C:\Python35\python3.exe E:/py_test/s4/s5.py
27 (1, 3, 4)

动态参数2：*args 意指可以传入多个元素以key= value key的格式是按照变量名的命名规范为标准的

 View
Code

如果元素参数是一个字典呢？我们把列表传入输出的一个元素是字典，但是我们想把字典的每个key value当一个参数。调用的时候加** 只加*是key

 View
Code

动态参数3 ： *args **kwargs

 View
Code

 1 #!/usr/bin/env python
 2 # _*_ coding:utf-8 _*_
 3 __author__ = 'liujianzuo'
 4 a={"k1":2,"k2":3}
 5 b=[1,2,3]
 6 def fuc(*args,**kwargs):
 7     #print(args)
 8     return args,kwargs
 9 ret=fuc(*b,**a)
10 print(ret)

C:\Python35\python3.exe E:/py_test/s4/s5.py
((1, 2, 3), {'k2': 3, 'k1': 2})

扩展：发送邮件实例

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'


def email(p,text,subject):
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    ret = True
    try:

        msg = MIMEText(text, 'plain', 'utf-8')
        msg['From'] = formataddr(["武沛齐",'[email protected]'])
        msg['To'] = formataddr(["走人",'[email protected]'])
        msg['Subject'] = subject

        server = smtplib.SMTP("smtp.126.com", 25)
        server.login("[email protected]", "WW.3945.59")
        server.sendmail('[email protected]', [p,], msg.as_string())
        server.quit()
    except:
        ret = False
    return ret


r1=email("[email protected]","python test email +===","subject==pyhon")
if r1:
    print("发生成功")
else:
    print("发送失败")

函数变量：局部变量与全局变量

函数外的变量定义的全局变量，在函数内部修改不了，因为，函数内部需要global一下否则在函数内部只能是局部变量，只是变量名跟全局变量相同而已

 全局变量与局部变量区别

[email protected]:~/py_training/seminar6/day3$ cat sayHi1.py

age =28   #程序全局变量
def sayHi(name):
        age = 29  #函数局部变量
        '''this is my first test function'''
        print "hello %s,how are you?,my age is %s!" %(name,age)

sayHi('liujianzuo')
print 'age:',age

[email protected]:~/py_training/seminar6/day3$ python sayHi1.py 
hello liujianzuo,how are you?,my age is 29!
age: 28

注释全局变量

#age =28

def sayHi(name):

age = 29

'''this is my first test function'''

print "hello %s,how are you?,my age is %s!" %(name,age)

sayHi('liujianzuo')

print 'age:',age

报错如下

[email protected]:~/py_training/seminar6/day3$ python sayHi1.py

hello liujianzuo,how are you?,my age is 29!

age:

Traceback (most recent call last):

File "sayHi1.py", line 9, in <module>

print 'age:',age

NameError: name 'age' is not defined

更改方法;让局部变全局 global更改局部变全部不建议使用

#age =28

def sayHi(name):

global age

age = 29

'''this is my first test function'''

print "hello %s,how are you?,my age is %s!" %(name,age)

sayHi('liujianzuo')

print 'age:',age

执行

[email protected]:~/py_training/seminar6/day3$ python sayHi1.py

hello liujianzuo,how are you?,my age is 29!

age: 29

注释局部变量

age =28

def sayHi(name):

# age = 29

'''this is my first test function'''

print "hello %s,how are you?,my age is %s!" %(name,age)

sayHi('liujianzuo')

print 'age:',age

执行

[email protected]:~/py_training/seminar6/day3$ python sayHi1.py

hello liujianzuo,how are you?,my age is 28!

age: 28

练习题

1、简述普通参数、指定参数、默认参数、动态参数的区别

2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及【其他】的个数

3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。

4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

dic = {"k1": "v1v1", "k2":
[11,22,33,44]}

PS:字典中的value只能是字符串或列表

8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

 View
Code

　　知识点 all（）函数

all(iterable)
版本：该函数在python2.5版本首次出现，适用于2.5以上版本，包括python3，兼容python3版本。
说明：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；函数等价于：

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
# a={"k1":2,"k2":3}
b=[1,2,3,""]
print(all(b))

def dju(args):
    if type(args) is str:
        if len(b) == 0:
            ret = True
            return "str  have no empty", ret
        else:
            ret =False
            return "str  have no empty", ret
    elif type(args) is list:
        if all(args):
            ret=True
            return "list  have no empty", ret
        else:
            ret=False
            return "list have empty", ret
    elif type(args) is tuple:
        args=list(args)
        if all(args):
            ret = True
            return "tuple have no empty", ret
        else:
            ret = False
            return "tuple have  empty", ret

r1=dju(b)
print(r1)

def func(arg1, arg2,time1):

    if arg1 == 0:
        print
    arg1, arg2
    arg3 = arg1 + arg2
    time1+=1
    if time1 == 11:
        return  arg3

    return  func(arg2, arg3,time1)

ret=func(0, 1 , 3)
print(ret)

python基础3 集合 三元运算 深浅拷贝 函数

注释全局变量

注释局部变量

练习题

相关推荐

python基础3 集合三元运算深浅拷贝函数