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="456",a="123")

运行结果是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="0000"
    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":"12"}
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)