高端快速建站,友联建设集团官方网站,网络游戏开发培训,宝安中心有什么好玩的地方基本数据类型之set set是无序不允许重复的集合set创建#xff1a;s set#xff08;#xff09; 创建空集合 s {11,22,33}转换s set#xff08;可迭代数据#xff09;li [11,22,33,44]
s set(li)
print(s) #结果为{33, 11, 44, 22} 集合元素的添加与清空se {11,22,…基本数据类型之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.differenceset_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_updateset_name2 找到name1中存在name2不存在的元素组成的集合更新给自己 se {11,22,33}
be {33,55}
se.difference_update(be)
print(se) #{11, 22} set_name1.isdisjointset_name2 name1和name2无交集返回Ture有交集就返回False se {11,22,33}
be {33,55}
ret se.isdisjoint(be)
print(ret) #结果为False set_name1.issubsetset_name2 name1是否为name2的子序列set_name1.issupersetset_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_differenceset_name2 把两集合相同的元素剔除用剩下的元素组成新的集合set_name1.symmetric_difference_updateset_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.intersectionset_name2 求两集合的交集 se {11,22,33,44}
be {11,22,77,55}
ret se.intersection(be)
print(ret) #结果为{11, 22} set_name1.unionset_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.updateset_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 23 else 25
print(name) #结果为25
name 12 if 11 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 yreturn zdef main():a 12b 13c 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 formataddrmsg MIMEText(邮件内容, plain, utf-8)
msg[From] formataddr([武沛齐,wptawy126.com])
msg[To] formataddr([走人,424662508qq.com])
msg[Subject] 主题server smtplib.SMTP(smtp.126.com, 25)
server.login(wptawy126.com, 邮箱密码)
server.sendmail(wptawy126.com, [424662508qq.com,], msg.as_string())
server.quit() View Code 局部变量和全局变量 局部变量从字面上的意思理解就是肯定是生活在某个局部地方的好那在这里定义在函数体内的变量叫做局部变量全局变量定义在函数体外的变量叫做全局变量局部变量只可被本函数使用全局变量可以被所有的语句访问使用由于局部变量定义在函数体内故多个函数可以在各自函数体内使用相同的变量名作为自己的变量 看例子我会找茬 def f1():x 12print(x)def f2():y 13print(y)def f3():print(x)print(y)def main():f1()f2()f3()main()
print(End!) 是不是发现了错误呢这就是函数内部调用其他的函数里的局部变量的错误 全局变量没有定义在任何函数体内如果在某个函数里修改某个全局变量必须用global声明一下这个变量是全局的才能修改 def printlocalx():x 12print(f1 local x ,x)def printlocaly():y 13print(f2 local y ,y)def readglobal():print(f3 read global x ,x)print(f3 read global y ,y)def modifyglobal():global xprint(f4 write x -1)x -1def main():printlocalx()printlocaly()readglobal()modifyglobal()x 200
y 100
main()
print(after modified global x ,x)
print(End) 结果为f1 local x 12f2 local y 13f3 read global x 200f3 read global y 100f4 write x -1after modified global x -1End 为了规范起见全局变量建议用大写局部变量用小写 形参和实参 在定义函数时的变量称作函数的形参作为外部值传入函数的接口函数调用时的变量称作实参 def multi(x,y): #定义时的xy就是形参z x * yreturn zdef main():a 12b 13c multi(a,b) #调用时的ab就是实参print(c) main()
print(End) 位置参数和关键词参数 按照函数定义时的位置顺序传入值的方式称作位置参数传入按照函数定义时的关键词对应关系传入值的方式称作关键词参数传入这个也是老师说的指定参数 #梯形面积公式
def trapezoid_area(base_up,base_down,height):return 1/2*(base_upbase_down)*height
print(trapezoid_area(1,2,3)) #这种传入参数的方式被称作位置参数传入
result trapezoid_area(base_up1,base_down2,height3)
#这种传入参数的方式称为关键词参数传入
print(result) 默认参数 默认参数就是在函数定义时给某个参数设定默认值默认参数必须在普通参数之后默认参数在不给其传值时使用默认值给值就是修改默认值 def trapezoid_area(base_up,base_down,height3):return 1/2*(base_upbase_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,k1123,k2456)
结果为(11, 22, 33) class tuple{k1: 123, k2: 456} class dict 你看程序能自动识别构造元素和字典这样就可以实现给函数传入多个参数了 欢迎大家对我的博客内容提出质疑和提问谢谢 笔者拍省先生 转载于:https://www.cnblogs.com/xinsiwei18/p/5517936.html
