三元运算
name = "张三" if 1 == 2 else "李四"
print(name)
name1 = "张三" if 1 == 1 else "李四"
print(name1)
运行结果
李四
张三
三元运算就是如果为真取前面的值1，如果为假为后面的值2 值1 if条件 else 值2
set集合主要有交集，并集，（无序不重复）
old_dict ={
"#1":11,
"#2":22,
"#3":100,
}
new_dict = {
"#1":33,
"#4":22,
"#7":100,
}
old_keys= old_dict.keys()
new_keys = new_dict.keys()
old_set_keys=set(old_keys)
new_set_keys=set(new_keys)
remove_set = old_set_keys.difference(new_set_keys)
add_set = new_set_keys.difference(old_set_keys)#求new_set_keys去掉与old_set_keys相同的项，余下的
update_set = old_set_keys.intersection(new_set_keys) #求交集
print(remove_set)
print(add_set)
print(update_set)
for i in remove_set:
old_dict.pop(i)
for j in add_set:
old_dict.update({j:new_dict[j]})
for m in update_set:
old_dict[m]=new_dict[m]
print(old_dict)集合主要用于更新，如上面将old_dict字典与新的new_dict相同的key更新为新的，而与new_dict不同的#2 #3则移除，并将new_dict中没有的#4 #7更新到old_dict中结果如下
{'#1': 33, '#4': 22, '#7': 100}
浅拷贝与深拷贝
对于数字与字符串深浅一样
import copy
n1="123n"
n2=copy.copy(n1)#浅拷贝
n3=copy.deepcopy(n1) #深拷贝
print(id(n1))
print(id(n2))
print(id(n3))
运行结果
18477328
18477328
18477328
内存地址一样的，所以深浅一样
list tuple dict深浅有区别，浅拷最外一层，深拷底层的数据不拷其它的都拷
import copy
n1=[11,22,33,{"k1":"v1"}]
n2=copy.copy(n1)#浅拷贝
n3=copy.deepcopy(n1) #深拷贝
print(id(n1[3]))
print(id(n2[3]))
print(id(n3[3]))
运行结果
16762888
16762888
18553096
import copy
n1=[11,22,33,{"k1":"v1"}]
n2=copy.copy(n1)#浅拷贝
n3=copy.deepcopy(n1) #深拷贝
print(id(n1[3]["k1"]))
print(id(n2[3]["k1"]))
print(id(n3[3]["k1"]))
运行结果
18740648
18740648
18740648
说明最底层的数据元素深浅一样，没有被拷贝
=======================================================
函数
实参与形参
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail(n):#形参n为目的邮箱地址
msg = MIMEText('邮件内容如服务器挂了', 'plain', 'utf-8')
msg['From'] = formataddr(["发件人姓名", '[email protected]'])
msg['To'] = formataddr(["自已", '[email protected]'])
msg['Subject'] = "邮件标题 " server = smtplib.SMTP("smtp.139.com", 25)
server.login("[email protected]", "你登陆邮箱的密码")
server.sendmail('[email protected]', [n, ], msg.as_string())
server.quit()
mail("[email protected]")将实参传入到形参中，一般情况一一对应的
如果改变顺序则要
def f(a,b):
print(a,b)
f(b="",a="")
运行结果是123 456
传多个参数（包括0个参数）
def f(*a):
print(a,type(a))
f(11,22,33)
运行结果 (11, 22, 33) <class 'tuple'>加一个*为一个元组，如果加两个*则是一个字典
def f(**kwargs):
print(kwargs,type(kwargs))
f(k1=123,k2=456)
运行结果{'k1': 123, 'k2': 456} <class 'dict'> 为一个字典
def f(*args,**kwargs):
print(args,type(args))
print(kwargs,type(kwargs))
f(11,22,33,k1=123,k2=456)
运行结果(11, 22, 33) <class 'tuple'>
{'k2': 456, 'k1': 123} <class 'dict'>
加一个*传入的变成元组，**为字典，
def f(*args,**kwargs):
print(args,type(args))
print(kwargs,type(kwargs))
return kwargs
print(kwargs, type(kwargs)) dic=f(k1=123,k2=456)
print(dic)
运行结结果() <class 'tuple'>
{'k2': 456, 'k1': 123} <class 'dict'>
{'k2': 456, 'k1': 123}
说明return语句返回值之后下面的语句不在执行，如果没有返回值则返回none
如果没有指定可以设置默认参数
def f(b,a=3):
print(a,b)
f(1)
运行结果 3 1 其中1传给了b，a 没有传实参，默认参数都要写在后面不能写成def f(a=3,b):
===================================================
局部变量（只在函数中用），全局变量（所有都能用的）
P="lisi"
def func1():
a=123 global P
P=""
print(a) def func2():
a=456
print(a)
print(P)
func1()
func2()
运行结果123
456
0000
全局变量用大写，局部变量用小写，如果想在函数里面改变全局变量，则要加一个global P安装
========================================================================
函数
a定义
b函数名
c 返回值
1 return 返回值 ，没有则为None
2 return语句之后则不在执行
d 参数
1，形参，实参
2 普通参数与实参一般一一对应，如果不对应则要能通过形参=实参
3 默认形参放在所有形参数的尾部
4 动态参数 一个*args为tuple **kargs为dict类型
全局与局部变量
全局大写，哪在局部中要修改global
局部变量小写
====================================================
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368
C=3
def func(arg1,arg2):
global C
C=C+1
if arg1 == 0:
print(arg1,arg2)
arg3 = arg1 + arg2
print(arg3) if C > T:
print(arg3)
return arg3
func(arg2,arg3)
t=input("please input 第几位数：")
T=int(t)
func(0,1)
引用了全局变量，并通过C计数器控制
运行结果please input 第几位数：13
0 1
1
2
3
5
8
13
21
34
55
89
144
144
======================================
写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def func(s):
isdigit_sum = 0
isalpha_sum = 0
isspace_sum = 0
other_sum = 0
for i in s:
# print(i)
if i.isdigit():
isdigit_sum +=1
elif i.isalpha():
isalpha_sum +=1
elif i.isspace():
isspace_sum +=1
else:
other_sum +=1
return {"数字":isdigit_sum,"字母":isalpha_sum,"空格":isspace_sum,"其它":other_sum}
m="ssss234s123 345"
t=func(m)
print(t)
写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容
def func(s):
for i in s: if i==" ":
return True def fun_flag(flag,s):
if flag:
print(s,"有空内容")
else:
print(s,"输入的内容没有空格")
m="mn nnl"
lis=[11,22,33]
ret_m=func(m)
fun_flag(ret_m,m)
ret_lis=func(lis)
fun_flag(ret_lis,lis)
写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
dic = {"k1": "v1v1", "k2": [11,22,33,44]}PS:字典中的value只能是字符串或列表def func(s):
dic1={}
for i in s.keys():
if len(s[i]) > 2:
dic1.update({i:s[i][0:2]}) #新增一个key和value并且value值切片，取前两位
return dic1
dic = {"k1": "v1v1", "k2": [11,22,33,44],"k3":""}
t=func(dic)
print(t)
写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
def func(s):
new_list=[]
for i in range(0,len(s)):
if i % 2 == 1:
new_list.append(s[i])
return new_list
lis=[11,23,33,44,55,66]
print(func(lis))
写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
def func(s):
if len(s) > 2:
new_list=s[0:2]#进行切片
return new_list
s1=[11,22,33,44]
lis1=func(s1)
print(lis1)