python基础-第三篇-函数编程

基本数据类型之set

• set是无序不允许重复的集合
• set创建：s = set（） 创建空集合  s = {11,22,33}
• 转换s = set（可迭代数据）

li = [11,22,33,44]
s = set(li)
print(s)  #结果为{33, 11, 44, 22}

• 集合元素的添加与清空

se = {11,22,33}
se.add(44)
print(se)  #结果为{33, 11, 44, 22}
se.clear()
print(se)  #结果为set()

• set_name1.difference（set_name2） 找到name1中存在，name2不存在的元素组成新的集合

se = {11,22,33}
be = {33,55}
ret1 = se.difference(be)
ret2 = be.difference(se)
print(ret1)  #结果为{11, 22}
print(ret2)  #结果为{55}

• set_name1.difference_update（set_name2） 找到name1中存在，name2不存在的元素组成的集合更新给自己

se = {11,22,33}
be = {33,55}
se.difference_update(be)
print(se)  #{11, 22}

• set_name1.isdisjoint（set_name2） name1和name2无交集返回Ture，有交集就返回False

se = {11,22,33}
be = {33,55}
ret = se.isdisjoint(be)
print(ret)  #结果为False

• set_name1.issubset（set_name2）   name1是否为name2的子序列
• set_name1.issuperset（set_name2）  name1是否为name2的父序列

s1 = {11,22,33,44,55}
s2 = {11,22}
ret = s2.issubset(s1)  #s2是s1的子序列吗？
print(ret)  #结果为True
ret1 = s1.issuperset(s2)  #s1是s2的父序列吗？
print(ret1)  #结果为True

• set_name1.symmetric_difference（set_name2）  把两集合相同的元素剔除，用剩下的元素组成新的集合
• set_name1.symmetric_difference_update（set_name2）  把两集合相同的元素剔除，用剩下的元素组成的集合赋给name1

se = {11,22,33,44}
be = {11,22,77,55}
ret = se.symmetric_difference(be)
print(ret)  #结果为{33, 44, 77, 55}
se.symmetric_difference_update(be)
print(se)  #结果为{33, 44, 77, 55}

• set_name.discard(元素项)和set_name.remove（元素项）  都是移除，不过remove移除不存在的元素会报错

se = {11,22,33,44}
se.discard(44)
print(se) #结果为{33, 11, 22}
se.remove(22)
print(se) #结果为{33, 11}
se.discard(44)
# se.remove(44) #报错

• set_name1.intersection（set_name2） 求两集合的交集

se = {11,22,33,44}
be = {11,22,77,55}
ret = se.intersection(be)
print(ret)  #结果为{11, 22}

• set_name1.union（set_name2） 求两集合的并集，为新的集合

se = {11,22,33,44}
be = {11,22,77,55}
ret = se.union(be)
print(ret)  #结果为{33, 11, 44, 77, 22, 55}

• set_name.pop（） 不需要参数，随机删除一个

se = {11,22,33,44,4,4,5,1,5,2,8,4,9,6,5,65,2,5,2,58,2,58,2,8,52,8,6,654,487,4}
for i in range(10):
    ret = se.pop()
    print(ret)
    print(se,type(se))

• set_name1.update（set_name2） 取并集并附给name1

se = {11,22,33,44}
be = {11,22,77,55}
se.update(be)
print(se) #结果为{33, 11, 44, 77, 22, 55}

三元运算

• 格式：name = 值1 if 条件 else 值2
• 条件成立，就值1赋给name，否则把值2赋给name
• 可以这么说三元运算就是条件语句的简化版

name = 12 if 2>3 else 25
print(name)  #结果为25
name = 12 if 1==1 else 25
print(name)  #结果为12

不同数据类型在内存的存址方式

• str（字符串） 一次性创建，不能修改，如果要修改必须重新创建

• list（列表） 存址方式为链表形式，元素之间记住了上一个元素的位置，下一个元素的位置

深浅拷贝

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

import copy
str1 = 'alex'
str2 = str1  #赋值
str3 = copy.copy(str1)  #浅拷贝
str4 = copy.deepcopy(str1)  #深拷贝
print(id(str1),id(str2),id(str3),id(str4))
#结果为8373168 8373168 8373168 8373168

import copy
num1 = 1234
num2 = num1  #赋值
num3 = copy.copy(num1)  #浅拷贝
num4 = copy.deepcopy(num1)  #深拷贝
print(id(num1),id(num2),id(num3),id(num4))
#结果为1331088 1331088 1331088 1331088

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

import copy
dict1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
dict2 = dict1  #赋值
dict3 = copy.copy(dict1)
dict4 = copy.deepcopy(dict1)
print(id(dict1),id(dict2),id(dict3),id(dict4))
#结果为10077192 10077192 10505160 10464264

　　看到这结果，我们可以得出，赋值对于字典而言，其内存地址是没有发生变化的，但是对浅拷贝和深拷贝的话，其内存地址都改变了，你可能会想，浅拷贝和深拷贝有啥区别了？

• 浅拷贝只拷贝第一层，深拷贝除了最后一层不拷贝，其他的都拷贝

浅拷贝：

import copy
dict1 = {"k1": "wu", "k2": 123, "k3": {'偶像':'景女神','人生格言':['景女神是最棒的','我们都是最棒的']}}
dict2 = copy.copy(dict1)  #浅拷贝
# dict2['k1'] = 'jingliyang'  #在第一层，dict1没有跟着dict2变化
# print(dict1)  #结果为{'k1': 'wu', 'k2': 123, 'k3': {'偶像': '景女神', '人生格言': ['景女神是最棒的', '我们都是最棒的']}}
# print(dict2)  #结果为{'k1': 'jingliyang', 'k2': 123, 'k3': {'偶像': '景女神', '人生格言': ['景女神是最棒的', '我们都是最棒的']}}

dict2['k3']['人生格言'] = '每天很美好'  #看到没，在第二层，dict1贱贱的跟着dict2变化了
print(dict1)  #结果为{'k2': 123, 'k3': {'人生格言': '每天很美好', '偶像': '景女神'}, 'k1': 'wu'}
print(dict2)  #结果为{'k2': 123, 'k3': {'人生格言': '每天很美好', '偶像': '景女神'}, 'k1': 'wu'}

附图：

深拷贝：

import copy
dict1 = {"k1": "wu", "k2": 123, "k3": {'偶像':'景女神','人生格言':['景女神是最棒的','我们都是最棒的']}}
dict2 = copy.deepcopy(dict1)  #深拷贝
# dict2['k1'] = '景丽洋'   #在这里改变第一层，dict1没有跟着dict2变化
# print(dict1)  #{'k3': {'人生格言': ['景女神是最棒的', '我们都是最棒的'], '偶像': '景女神'}, 'k1': 'wu', 'k2': 123}
# print(dict2)  #{'k1': '景丽洋', 'k3': {'人生格言': ['景女神是最棒的', '我们都是最棒的'], '偶像': '景女神'}, 'k2': 123}

dict2['k3']['人生格言'] = '景女神，加油！'  #你看，第二层dict1还是没有跟着dict2变化
print(dict1)  #{'k3': {'偶像': '景女神', '人生格言': ['景女神是最棒的', '我们都是最棒的']}, 'k1': 'wu', 'k2': 123}
print(dict2)  #{'k3': {'偶像': '景女神', '人生格言': '景女神，加油！'}, 'k1': 'wu', 'k2': 123}

附图：

函数

• 函数是面向过程编程，也叫函数式编程
• 当程序运行时，解释器从上往下解释，遇定义函数时先读取到内存，但不执行
• 执行 --函数名（）
• 语法结构：

def function_name(args):
    功能块
    return 返回值

• return后面是返回值，不写return，默认返回None，返回值是可以用变量接收的
• 在函数中，执行了return，函数后面的代码就不执行了

　　为了理解更透彻，让我们先看一个例子：

def add(x,y):
    z = x + y
    return z

def main():
    a = 12
    b = 13
    c = add(a,b)
    print(c)

main()
print('End！')

　　首先这个例子中定义两个函数，分别为add和main两个函数，add函数有两个形式参数x和y，而main函数无形参也无返回值，在执行main函数的过程中又去调用了add函数

　　发送邮件实例

复制代码

import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
msg['To'] = formataddr(["走人",'424662508@qq.com'])
msg['Subject'] = "主题"

server = smtplib.SMTP("smtp.126.com", 25)
server.login("wptawy@126.com", "邮箱密码")
server.sendmail('wptawy@126.com', ['424662508@qq.com',], msg.as_string())
server.quit()

　　局部变量和全局变量

• 局部变量，从字面上的意思理解就是肯定是生活在某个局部地方的，好！那在这里，定义在函数体内的变量叫做局部变量
• 全局变量，定义在函数体外的变量叫做全局变量
• 局部变量只可被本函数使用，全局变量可以被所有的语句访问使用
• 由于局部变量定义在函数体内，故多个函数可以在各自函数体内使用相同的变量名作为自己的变量

　　看例子，我会找茬

def f1():
    x = 12
    print(x)

def f2():
    y = 13
    print(y)

def f3():
    print(x)
    print(y)

def main():
    f1()
    f2()
    f3()

main()
print('End!')

　　是不是发现了错误呢？这就是函数内部调用其他的函数里的局部变量的错误

• 全局变量没有定义在任何函数体内，如果在某个函数里修改某个全局变量，必须用global声明一下这个变量是全局的才能修改

def printlocalx():
    x = 12
    print('f1 local x =',x)

def printlocaly():
    y = 13
    print('f2 local y =',y)

def readglobal():
    print('f3 read global x =',x)
    print('f3 read global y =',y)

def modifyglobal():
    global x
    print('f4 write x = -1')
    x = -1

def main():
    printlocalx()
    printlocaly()
    readglobal()
    modifyglobal()

x = 200
y = 100
main()
print('after modified global x =',x)
print('End')

结果为：
    f1 local x = 12
    f2 local y = 13
    f3 read global x = 200
    f3 read global y = 100
    f4 write x = -1
    after modified global x = -1
    End

• 为了规范起见，全局变量建议用大写，局部变量用小写

　　形参和实参

• 在定义函数时的变量称作函数的形参，作为外部值传入函数的接口
• 函数调用时的变量称作实参

def multi(x,y):    #定义时的x，y就是形参
    z = x * y
    return z

def main():
    a = 12
    b = 13
    c = multi(a,b)  #调用时的a，b就是实参
    print(c) 

main()
print('End')

　　

　　位置参数和关键词参数

• 按照函数定义时的位置顺序传入值的方式称作位置参数传入
• 按照函数定义时的关键词对应关系传入值的方式称作关键词参数传入，这个也是老师说的指定参数

#梯形面积公式
def trapezoid_area(base_up,base_down,height):
    return 1/2*(base_up+base_down)*height
print(trapezoid_area(1,2,3))   #这种传入参数的方式被称作位置参数传入
result = trapezoid_area(base_up=1,base_down=2,height=3)
#这种传入参数的方式称为关键词参数传入
print(result)

　　默认参数

• 默认参数就是在函数定义时给某个参数设定默认值，默认参数必须在普通参数之后
• 默认参数在不给其传值时，使用默认值，给值就是修改默认值

def trapezoid_area(base_up,base_down,height=3):
    return 1/2*(base_up+base_down)*height
result1 = trapezoid_area(1,2)   #传入两个参数也可，也可修改三参，即默认参数
print(result1)

　　你不知道的小秘密，你常用的print居然是一个既熟悉又陌生的人儿

print('   *','  ***',' *****','   |',sep='\n')

　　sep为print函数的默认参数，默认值为空格，传入的\n为换行

　　动态参数

• def func(*args) 接受多个参数，内部自动构造元组

def f1(*a):
    print(a,type(a))

f1(123)  #结果为(123,) <class 'tuple'>

#多传几个
f1(11,22,33)  #结果为(11, 22, 33) <class 'tuple'>

　　你看，在定义函数的时候给参数前加了*，然后调用函数时输出的结果为元组，那如果传了列表呢？

def f1(*a):
    print(a,type(a))

li = [11,22,33]
f1(li)  #结果为([11, 22, 33],) <class 'tuple'>

　　结果是把列表当整体作为元素的元素了，那如果我们就是想要把列表的每个元素作为构造元组的元素呢？

def f1(*a):
    print(a,type(a))

li = [11,22,33]
f1(*li)  #结果为(11, 22, 33) <class 'tuple'>

　　其实只要在执行函数时传入的参数前加*就可以了

• def func(**kwargs) 接收多个参数，内部自动构造字典

def f2(**b):
    print(b,type(b))

f2(a1 = 123)  #结果为{'a1': 123} <class 'dict'>

　　好，如果要给其传入字典，而且也是要把每个键值对用于构造的字典的键值对，应该怎么做呢？相信很多人都想到了在前面加**吧？

def f2(**b):
    print(b,type(b))

dict1 = {'k1':'景女神','k2':'景女神是最棒的'}
f2(**dict1)  #结果为{'k2': '景女神是最棒的', 'k1': '景女神'} <class 'dict'>

　　另外，告诉你，如果传入字典，你不加**，是会报错的

• def func(*args，**kwargs)：接受多个参数，既可以自动构造元组，又可以自动构造字典，而且一个*的必须在两个*的前面

def f3(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))

f3(11,22,33,k1=123,k2=456)
结果为：
    (11, 22, 33) <class 'tuple'>
    {'k1': 123, 'k2': 456} <class 'dict'>

　　你看程序能自动识别构造元素和字典，这样就可以实现给函数传入多个参数了

欢迎大家对我的博客内容提出质疑和提问！谢谢

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                  笔者：拍省先生