python四

三元运算

 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(["发件人姓名", '13632610XXXX@139.com'])
     msg['To'] = formataddr(["自已", '43125471@qq.com'])
     msg['Subject'] = "邮件标题 "

     server = smtplib.SMTP("smtp.139.com", 25)
     server.login("1363261XXXX@139.com", "你登陆邮箱的密码")
     server.sendmail('1363261XXX@139.com', [n, ], msg.as_string())
     server.quit()

mail("43125471@qq.com")将实参传入到形参中，一般情况一一对应的

如果改变顺序则要

 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)