python笔记整理 day2

列表可以转成字典：但是前提:列表中元素都要成对出现
dict1=dict([('name','lucy'),('age',10)])
print(dict1)
操作：
1、添加元素：
字典名[key]=value
注意：key是唯一的，所以在添加的时候如果出现同名的key，后面key对应的value就替换原来的
2、修改value值
字典名[key]=value
关键看键值：如果字典中不存在键 就是添加
          如果字典中存在键  就是修改
3、字典删除
pop(key):根据key值实现删除，删除的是键值对，返回的值是key对应的value值
clear（）：清空字典
popitem():返回值（key，value）从后向前删除  返回的是元组
4、遍历和查询
list.index() list.count() in
获取：
dict.get(key):根据key获取value值
dict[key]:根据key获取value值
区别：get(key)里面的key如果不存在，则返回默认值None，同时get()可以设置默认值get(key,default)
     dic[key]会报错
如果直接用for  in直接遍历字典，只能取出字典key值
获取字典中所有的values值：字典.values()就是将所有值存放到了一个列表中
for v in book.values():
    print(v)
获取字典中所有key：字典.keys()
for k in book.keys():
    print(k)
获取字典中所有key和value的值  字典.items()
for k,v in book.items:
    print(k,v)
update  实现两个字典的合并
book={'书名':'三体','价格':90,'作者':'毛不易','出版社':'清华大学出版社'}
book.update({'年龄':'23'})
print(book)


books=[]
while True:
    if len(books)==3:
        break
    name=input('输入想要添加的书名：')
    for book in books:
        if name==book.get('name'):
            print('书名重复')
            break
    else:
        author = input('输入作者名字：')
        price = input('输入书的价格：')
        books.append({'书名': name, '价格': price, '作者': author})


集合：set
特点：没有重复，没有顺序(没有下标)
符号：{} {元素，元素，元素}只有元素就是集合
        {key:value,key:value}键值对存在就是字典
空集合的声明：set1=set()
添加元素：add()只能添加一个元素  update()两个集合合并
移除元素：remove（元素）  discard（元素） del set   set.clear()  set.pop() 随机删除集合中的任意元素

s='jifenskdnfleo21094389'
import random
code_list=set()
while True:
    code=''
    for i in range(4):
        n=random.choice(s)
        code=code+n
    code_list.add(code)
    if len(code_list)==5:
        break
print(code_list)


集合：交集intersection & 并集union  | 差集difference  -


dict——》list 只能转变键值  字典的键值不可以重复
list——》dict 只有特殊情况下可以转变
list=[('a',b),('m',n)]

+支持字符串  列表  元组
*用在列表上相当于将列表复制了几份  支持字符串  列表  元组
列表推导式:最终得到的是一个列表
print('tt') if 5>3 else print('nn')
格式1：[i for i in 可迭代的]先执行循环
格式2：[i for i in 可迭代的 if条件]先执行循环在执行判断
格式3：既有if又有else [结果1 if条件1 else结果2 for i in 可迭代]

list=['ji','90','ko','89','kitte']
list1=[word.title() if word.startswith('k') else word.upper() for word in list ]
list=[for i in range(3) for j in range(2)]
练习：请写出一段python代码实现一个list里面的元素，比如[1,2,...100]变成[[1,2,3],[4,5,6]...]
找出里面名字里含有两个e的放到新列表中name=[['Tom','Billy','Jefferson','Andrew','Wesley','Joe','Steven'],['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]
name=[['Tom',''
for i in range(1,99,3):
    if i % 3 != 0:
        list2.append([i, i + 1, i + 2])
print(list2)
name0=[]
name=[['Tom','Billy','Jefferson','Andrew','Wesley','Joe','Steven'],['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]

for na in name:
    for i in na:
       if i.count('e')==2:
        name0.append(i)
print(name0)

函数：复用
函数的格式：def 函数名（[参数，....]):
            代码(封装重复内容）
函数名：get_name()  search()
参数：1、无参数 def 函数名():
     2、有参数 def 函数名(参数1，参数2):
带有多个参数的函数：
默认值参数：在定义函数的时候，有一个或者多个参数已经赋值
def 函数名（参数1，参数2，参数3，参数4=值）
在调用函数的时候，默认值参数可以赋值，也可以不赋值
注意：在定义函数的时候，普通参数要位于默认值参数的前面
     默认参数的顺序是固定的，调用时可以使用关键字进行赋值
def get_sum(a,b):
    # isinstane(变量，类型)用来判断这个变量是否是这个类型  返回值为bool
    if isinstance(a,int) and isinstance(b,int):
        print(a+b)
    else:
        print('类型不一致')
get_sum(1,'io')
可变参数：*args **kwargs...
拆包和装包
函数装包
def 函数(*args):----->此时会出现装包操作
    pass
函数(1,2,3)
拆包：
list，tuple，set
调用的时候：函数(*list)  函数(*tuple)   函数(*set)
def get_sum(*a):
    # 返回值是一个元组
    s=0
    for i in a:
        s=s+i
    print(s)
a={1,2,23,67}
get_sum(*a)
关键字参数：
在函数调用的时候必须传递关键字参数，才可以将其转换成key：value的键值对  存放形式是字典
book={'name':'红楼梦','author':'曹雪芹','price':3}
def show_book(**book):装包
    # book={'name':'红楼梦','author':'曹雪芹','price':3}
    for k,v in book.items():
        print(k,v)
show_book(**book)  拆包
# name 红楼梦
# author 曹雪芹
# price 3
可变参数：既使用可变参数又使用关键字参数

参数：外界向里面传值
返回值：里面的内容向外界传送
def 函数名（参数):
  ....
  ....
  return 结果
当函数调用时，通过return向外返回值
注意：只要函数有返回值，就需要在外面进行接收
return后面的返回值可以是一个或多个  如果是多个，系统自动将多个值封装到一个元组中，将元组整体返回
def get_max_min(list):
    return max(list),min(list)
# （max，min）
list=[2,45,3,25,66,742,1]
result=get_max_min(list)
print(result)
#(742, 1)
练习：验证是否登录：islogin():
自定义一个判断用户是否登录功能islogin，参数username，password
函数体：判断用户输入的用户名和密码是否正确，如果正确则返回True，否则返回false
借书：borrow_book
参数是：书名
函数体：
判断是否登录，如果登录则可以借书
如果没有登录则提示：还没有登录不能借书
def add_good(goodname,islogin):
    if islogin:
        if goodname:
           print('登录成功，{}添加成功'.format(goodname))
        else:
            print('没有输入商品')
    else:
        print('没有登录')
        choice=input('是否重新登录，请输入yes或者no')
        if choice=='yes':
            flag=True
            while flag:
                username=input('输入用户名：')
                password=input('输入密码：')
                login(username,password)
                result=login(username,password)
                if result==False:
                    choice1=input('是否重新登录，请输入yes或者no')
                    if choice1=='yes':
                        pass
                    else:
                       flag=False
                       print('退出系统')
                else:
                    break

        else:
            print('退出系统')
def login(username,password):
    if username=='admin' and password=='1234':
        islogin=True
        print('登录成功')
        return islogin

    else:
        islogin=False
        print('登录失败')
        return islogin

islogin=login('admin','134')
add_good('香肠',islogin)
全局变量和局部变量：（针对函数）
声明在函数外面的称为全局变量
声明在函数内部的称为局部变量
函数内部如果需要对全局变量进行修改 需要使用global关键字
def test3():
    # 改变全局a的值
    global a
    a = a - 1
可变与不可变变量：
不可变：当改变变量的值时，地址发生了改变
       类型：字符串 int  float 元组 bool
可变类型：里面的内同发生了改变，但是地址没有发生改变
       类型：list dict set
可变类型：允许改变类型       可变类型不需要添加global
不可变类型：不允许改变类型   只有不可变类型需要添加global


a=100
print(id(a))
# 2822810588624
a=90
print(id(a))
# 2822810588304
函数的注释：
def 函数名(参数1....):
   基本注释  ’注释内容‘
   高级注释 ''' '''
   函数说明
    :param username:用户名
    :param password:密码
'''
闭包：函数只是一段可执行代码，编译后就固化了，每个函数在内存中只有一份实例，得到函数的入口点就可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数
     有了嵌套函数这种结构，便会产生闭包问题
def outer():
    a = 100
    def inner():
        b = 10
        # b += a
        # 内部函数可以使用外部函数的变量
        # a += b
        nonlocal a
        # 如果想修改外部函数的变量，需要在内部函数中添加：nonlocal
        a += b
        # 内部函数不可以修改外部函数的变量
        print('我是内部')
    result = locals()
    # locals()表示查看函数中的局部变量，以字典的形式返回
    print(a)
    inner()
outer()
'''
闭包：
1、嵌套函数
2、内部函数引用了外部函数的变量
3、返回值是内部函数
'''
def outer(n):
    a=10
    def inner():
        b=a+n
        print('内部函数：',b)
    return inner
r=outer(5)
# <function outer.<locals>.inner at 0x000001C7A26C5CA0>
print(r)
r()
# 内部函数： 15
'''
:return可以返回一个或多个值
return a
return a,b   (a,b)
return 也表示结束函数的调用   return后面的语句不会执行
'''