[Python知识库]Python入门到放弃

介绍python和库文件管理

python是解释型语言
Python的特点：简单、易学、速度快、免费开源、高层语言、可移植性、解释性、面向对象（也支持面向过程）、可扩展性、可嵌入性、丰富的库、规范的代码

在cmd中退出python，输入exit()或ctrl+Z退出


搜索“国内镜像源”：pip install -i https:…
python:
安装python:
1.python解释器
2.pip包管理器，管理的是扩展的一些库文件。(放在Lib/site-packages)
3.python的标准库：Lib

pip包管理器：
安装一个库文件：pip install 库的名字
默认是去官方国外网站，速度比较慢
临时使用：pip install 库的名字 -i 镜像源网址
永久使用：

Python安装

Python安装简介

Anaconda包是一个集成的包
Pycharm 一个开发工具，

开发环境介绍

交互式编程

cd …:往回走

注释：
1.不让解释器执行注释那句话
2.代码说明

注释的种类
1.单行注释
2.多行注释
‘’‘(块注释：crtl+shift+/)
函数作用
函数的参数
函数返回值
‘’’
#格式化
Python PEP8编码规范

看到波浪线是灰色就是"crtl+Alt+L"
删除某行"ctrl+D",不用做选中了

Python变量命名

变量：‘容器’
弱语言：变量声明的时候对数据类型不是很严格

• 怎么起名？
• 可以赋什么值？
• 有哪些数据类型？

变量名的命名规范:

1. 字母、数字、下划线，其他的特殊符号不行，且不能数字开头
2. 严格区分大小写
3. 不能使用关键字

见名之义

数据类型和类型转换

数据类型

变量的类型：

• 数字
• 布尔类型
• String(字符串)
• List(列表)
• Tuple(元组)
• Dictionary(字典)
• int
• float
• string
• boolean
• 通过type(变量名)输出变量类型
• 三引号：保留格式的字符串
  
• 布尔类型：True False
• 主要用于开发中的判断，比如：是否登录成功
• isLogin=True#真
• isLogin=False#假

类型转换

print('hello')
input('请输入用户名：')#阻塞型语句

str---->>int
强制类型转换
变量的值是：0，‘’(空字符串)

运算符

运算符：

• = 赋值运算符
• 算术运算符：+ - * / % // **
• /:除法
• //：整除
• %：取模去余
• 赋值运算符：=、+=、-=、*=、/=、//=、**=、%=

比较关系运算符

关系运算符结果：

• True
• False

< >= <= == != is
比较的是ASCII码的码值

逻辑运算符

• and or not
• and 与，并且

复习和格式化输出

Pycharm使用
变量

• 格式：变量名=值
• 注释：单行 多行’‘’ ‘’’
• 起名：命名规范
  值：
• 数据类型 int float string bool
  类型转换：
• 所有键盘输入的类型都是字符串类型的
  运算符：
• 算术： + - * / % // **
• 赋值： = += -= …
• 比较： > < >= <= == != 结果：True False
• 逻辑：and or not

输出格式化

name = '蔡徐坤'
age = 26
#我喜欢听26岁的蔡徐坤唱歌
print('我喜欢听'+str(age)+'岁的'+name+'唱歌！')
#字符串如何进行格式化
#符号：
#%s：字符串 string
#%d：整数 digit
#%f: 浮点数 float 
print('我喜欢听%d岁的%s唱歌'%(name,age))

进制转换

• 二进制：0，1
• 八进制：0，1，2，3，4，5，6，7
• 十进制：0~9
• 十六进制：0~9 a~f
• 十进制转二进制：10—>>二进制表示

前缀：

• 0b：二进制
• 0o：八进制
• 0x：十六进制
• 默认十进制

位运算

• 转二进制 bin()
• 转八进制 oct()
• 位运算：& | ^ ~ << >>

二进制的负数表示
原码 0110
反码 1001
补码 反码+1
已知二进制的负数(判断是否是)

运算符优先级

& / ^ ~
<<(左移) >>(右移)

总结：
1.算术运算符
2.赋值运算符 = += -=
3.比较运算符 > < == != …
4.逻辑运算符 and or not
5.位运算 & | ^ ~ << >> -7负数的二进制
6.运算符的优先级（）

条件语句

条件语句：
if
if … else
if … elif … else
条件：
运算符构成
‘’’
if 条件：
条件成立要执行的语句
‘’’

import random
ran=random.randint(1,10)
guess=int(input('请输入你猜的整数：'))
if ran==guess:
    print('恭喜猜对了！')
else:
    print('很遗憾猜错了！')

‘’’
人员管理系统，功能：添加、删除、查询、修改员工信息
‘’’
pass：支撑结构、占位

#里面代码少的情况
a=10
b=30
c=1 if a>b else b
print(a,b,c)

在Python中，转换成为布尔值时，只有0，“”,‘’,None,(),{},[]会被转换成为False，其他都会被转换成为True

while循环结构

方式：
1.while
2.for
while格式：
if 条件
bool类型的条件
while循环结束条件

#初始值
n=1
#结束条件
while n>10:
    print('------------->n=%d'%n)
    n+=1
    ```

```python
'''
产生随机数
可以猜多次，直到猜对为止，如果猜错了适当给出提示
1.统计猜了几次
2.如果1次就中，赶快去买彩票，运气爆棚
  2-5次，猜对了，运气还可以
  6次以上，猜对了，运气一般

'''
import random
ran=random.randint(1,50)
count=0
#循环猜多次
while True:
    guess=int(input('请才一个数字：'))
    count+=1
    if guess==ran:
        if count==1:
            print('1次就中，赶快去买彩票，运气爆棚')
        elif 2<=count<=5:
            print('猜对了，运气还可以！')
        else:
            print('猜对了，运气一般')
        # print('恭喜猜对了！')
        break
    elif guess>ran:
        print('猜大了，再小一点！')
    else:
        print('猜小了，再大一点！')

import random
n=1
#计数
p_count=0
m_count=0
while n<=3:
    ran=random.randint(0,2)
    guess=int(input('请输入：剪刀(0) 石头(1) 布(2)\n'))
    #比较判断
    if (guess==0 and ran==2) or (guess==1 and ran==0) or (guess==2 and ran==1):
        print('我赢了！！！')
        p_count+=1
    elif ran==0 and guess==2 or ran==1 and guess==0 or ran==2 and guess==1:
        print('~~~本轮机器赢了~~~')
        m_count+=1
    else:
        print('本轮平局！')
    #n的变化
    n+=1

if p_count>m_count:
    print('最终人获胜了！')
elif p_count<m_count:
    print('机器最终获胜')
else:
    print('最终平局')

for循环语句

格式：
for 变量名 in range(n):
循环体中的内容
#1~10数字打印
range(n):默认从0开始数值到n-1结束
range(start,stop):[start,stop)
range(start,stop,step):默认从start(包含)开始取值到stop(n-1)结束

#1到50的累加和
sum=0
for i in range(1,51):
    sum+=i
print(sum)

for else结构
for i in range(n)：
循环体
else：
如果上面的for循环0~n-1没有出现中断

for i in range(3):
    #提示输入用户名和密码
    username=input('用户名：')
    password=input('密码：')
    #判断输入的是否正确：admin 1234
    if username=='admin' and password=='1234':
        print('用户登录成功！')
        break
    print('用户名或密码错误')
    
else:
    print('账户被锁定！')

while…else
for…else
注意else的特点：不被中断则执行，否则不执行
‘’’
for i in range(n):#肯定是有固定次数的
pass
while 条件：#1.固定次数的循环 2.不确定的循环
pass
while True:
pass
‘’’
掷骰子

#掷骰子
# 两个：1-6
# 1.玩游戏要有金币，不能玩游戏
# 2.玩游戏赠金币，充值获取金币
# 3.10元的倍数：20个金币
# 4.玩游戏消耗5个金币
# 5.猜大小：猜对 鼓励金币2枚 猜错没有奖励 超出6点以上认为是大，否则是小
#6.游戏结束：1.主动退出 2.没有金币退出
# 7.只要退出则打印金币数，共玩了几局
#金币数
import random
count = 0
coins=0
#计数器
if coins<5:
    #提示充值
    print('金币不足')
    while True:
        money = int(input('请输入金额：'))
        #10的倍数，20个金币
        if money%10==0:
            coins+=money//10*20
            print('充值成功！当前金币有%d个'%coins)
            # 开启游戏之旅
            print('~~~~~~开启游戏之旅~~~~~~')
            answer=input('是否开始游戏(y/n)?')
            while coins>5 and answer=='y':
                # 扣金币
                coins-=5
                #赠送金币
                coins+=1
                #产生两枚随机的骰子数
                ran1=random.randint(1,6)
                ran2=random.randint(1,6)
                #猜大小
                guess=input('洗牌完毕，请猜大小：')
                #判断比较
                if guess=='大' and ran1+ran2>6 or guess=='小' and ran1+ran2<=6:
                    print('恭喜猜对了，你赢了！')
                    coins+=2
                else:
                    print('很遗憾，猜错了哦！')
                #玩的次数
                count+=1
                answer = input('是否继续游戏(y/n)?')
            #打印 次数 金币数
            print('共玩了%d次，剩余金币：%d'%(count,coins))
            break
        else:
            print('不是10的倍数，充值失败！')

跳出语句
break：跳出循环结构
continue：跳过本次循环，继续下一次循环
都是出现在循环中的

#不打印能被3整除
for i in range(10):
     if i%3!=0:
         print(i)

for i in range(10):
    if i%3 == 0:
       continue
    print(i)

遇到continue跳过下方循环不执行

‘’’
循环嵌套：
if 条件：
if 条件：
pass
else：
if 条件：
pass
while循环：
*
**

‘’’

'''
****
****
****
****
'''
n=1
while n<=4:
    print('****')
    n+=1

'''
*
**
***
****
*****
'''
n=1
while n<=4:
    print('*'*n)
    n+=1

'''
*
**
***
****
*****
'''
n=1
while n<=5:#控制行数
    m=0
    while m<n:
        print('*',end='')
        m+=1
    n+=1
    print()

'''
*****
****
***
**
*
'''
n = 1
while n <= 5:
    m = 5
    while m > n:
        print('*', end='')
        m -= 1
    n += 1
    print()

流程控制

条件语句：
if 条件：
pass
else：
pass
嵌套语句
循环语句：
while：1.初始值 2.条件(结束) 3.变量改变
while True：
pass

while True：
…
break

for i in range(n):
while n<=5:#外层控制行数
…
while m<n:
print('‘,end=’ ')#内层控制的是打印
print()

字符串介绍

python中字符串的格式
输入：input
输出：print

s1='hello'
s2=s1
s3='hello'
print(s1,s2,s3)#hello hello hello
print(id(s1),id(s2),id(s3))#相同
print(s1 is s4)#比较的是地址

字符串截取

切片

切片：字符串，列表
格式：字符串变量[start:end)
字符串变量[start:end:step] 默认是从左向右一个一个
1.步长
2.方向 step 正数 从左向右
       step 负数 从右向左

s='ABCDFEG'
print(s1[1:4])
print(s1[-3:])#'EFG',从-3开始到结尾
print(s1[1::2])#BDF
print(s1[::4])#AE
print(s1[6::-2])#能取到值

字符串的常见操作：

• 获取长度：len
• 查找内容：find,index,rfind,rindex
• 判断：startswith,endswith,isalpha,isalnum,isspace
• 计算出现次数：count
• 替换内容：replace
• 切割字符串：split,rsplit,splitlines,partition,rpartition
• 修改大小写:capitalize,title,upper,lower
• 空格处理:ljust,rjust,center,lstrip,rstrip,strip
• 字符串拼接:join
  在Python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

字符串操作

'''
字符串操作
find:从左向右查找，只要遇到一个符合要求的则返回位置，如果没有找到任何符合要求的则返回-1
rfind:从右向左查找
count:统计指定字符的个数
index与find的区别：index也是表示查找，但是如果找不到，会返回报错
'''
path='https://www.baidu.com/img/dong_e70247ce4b0a3e5ba73e8b3b05429d84.gif'
#find,index,rfind,rindex
#1.查找里面的字符串
i=path.find('_')
print(i)
image_name=path[i+1:]
print(image_name)

#2.找到后缀
#rfind:right find
i = path.rfind('.')
zhui=path[i:]
print(zhui)

#3.找到字符串中有几个'.'
#count计算出现次数
n=path.count('.')
print(n)

'''
i=path.index('#$')
print(i)
会报错
'''

'''
 - 判断：startswith,endswith,isalpha,isalnum,isspace
 返回值都是布尔类型(True,False)
'''
s='aedwekfjwfj.gif'
result=s.startswith('ae')#判断是否是以XXX
print(result)
end1=s.endswith('gif')
print(end1)

'''
模拟文件上传，见怕输入上传文件的名称，判断文件名是否大于6位以上，扩展名是否是：：jpg,gif,png格式
如果不是则提示上传失败，如果名字不满足条件，而扩展名满足条件则随机生成一个6位数字组成的文件名，打印成功上传xxxx.png
判断名字
'''
import random
file=input('输入文件全称：')
#判断扩展名
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    #判断文件的名字
    i=file.rfind('.')
    name=file[:i]
    if len(name)<6:
        #重新构建名字
        n=random.randint(100000,999999)
        file=str(n)+file[i:]
    print('成功上传%s文件'%file)
else:
    print('文件格式错误，上传失败！')

#字母和数字的组合
import random
filename=''
s='qwertyuiopasdfghjklzxcvbnm1234567890'
for i in range(6):
    index=random.randint(0,len(s)-1)
    filename+=s[index]
print(filename)

import random
file=input('输入文件全称：')
#判断扩展名
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    #判断文件的名字
    i=file.rfind('.')
    name=file[:i]
    if len(name)<6:
        #重新构建名字
        filename = ''
        s = 'qwertyuiopasdfghjklzxcvbnm1234567890'
        for i in range(6):
            index = random.randint(0, len(s) - 1)
            filename += s[index]
        print(filename)
        file=filename+file[i:]
    print('成功上传%s文件'%file)
else:
    print('文件格式错误，上传失败！')

字符串判断操作

#字母和数字的组合
import random
s='A1234'
result=s.isalpha()#是否全部是字母组成
print(result)

res1=s.isdigit()# 是否全部是数字
print(res1)

res2=s.isspace() #是否有空格
print(res2)

a='HELLO'
ress=a.isupper()
print(ress)

b=a.islower()
print(b)

'''
admin 11111111111 200325
用户名或者手机号码登录+密码，
用户名：全部小写，首字母不能是数字，长度必须6位以上
手机号码：纯数字 长度11
密码必须是6位数字

以上符合条件则进入下层验证
判断用户名+密码 是否是正确，则成功，否则登录失败
'''
flag=True
while flag:
    name=input('用户名/手机号码：')
    #判断
    if (name.islower() and not name[0].isdigit() and len(name)>6) :
        #继续输入密码
        while True:
            password=input('密码：')
            if (name.isdigit() and len(name)==11):
                if (name == 'admin123' or name =='111111111') and password=='200325':
                    print('用户登录成功!')
                    flag=False
                    break
                else:
                    print('用户名或密码有误！')
                    break
            else:
                print('密码必须是6位数字')

    else:
        print('用户名或手机号码格式错误')

'''
替换内容：replace(old,new,count)默认全部替换，也可以通过count指定次数
切割字符串：split,split,splitlines,partition,rpartition
split('分隔符',maxsplit)返回的结果是一个列表,maxplit 最多的分割次数
同理,rsplit
splitlines:按照行分割
修改大小写：capitalize,title,upper,lower

'''

s='阿乐说：阿豹你来唱歌吧！阿豹你来跳舞吧！'
result=s.replace('阿豹','**',)
print(result)

#替换阿乐，阿豹 1.正则表达式 2.for循环(循环+列表)

#切割字符串

a=s.split(' ')
print(a)

ss='''阿乐你来唱歌吧！
阿乐你来跳舞吧！
阿乐你来学习吧！
阿乐你来吃饭吧！
'''
result=ss.splitlines()
print(result)

s='阿乐 阿豹 阿娇'
result=s.partition(' ')
print(result)

s='hello'
result=s.title()
print(result)

result=s.upper()
print(result)

result=s.lower()
print(result)

字符串格式化

'''
空格处理：ljust,rjust,center,添加空格控制字符串的对齐方式
lstrip,rstrip,strip 删除字符串左侧或者右侧的空格
字符串拼接：join

'''
# username=input('用户名：') #admin
# print(len(username))
# s=
s=' admin '
print(len(s))
result=s.strip()#去除左右两侧的空格
print(result)
result=s.lstrip()#去除左侧的空格部分
print(len(result))
result=s.rstrip()#去除右侧的空格部分
aa=s.ljust(30)#左对齐
print(aa)
s='hello'+'world'
print(s)

字符串拼接

变量字段名

'''
格式化：
1.%d %s %f
print('李泽说:%s'%xxxx)
2.format
'''
name='赵丽颖'
age=18
#使用数字填充
result='美女{0}今年{1}岁,我也是{1}岁！'.format(name,age)
print(result)
# 也支持变量名的形式，format的参数必须是关键字参数
result='美女{name}今年{age}岁,我也是{age}岁！'.format(name='赵丽颖',age=18)
print(result)

#n
name='小明'
score_chinese=100
score_math=99
s='{0}本次考试数学分数是：{2},语文分数：{1}，英语分数：{2}'.format(name,score_chinese,score_math)
print(s)

模拟论坛框架搭建

'''
模拟论坛：
'''
msg=input('发表一句话：')
print('-'*50)
print('以下为回复内容：')
while True:
    #输入用户名：
    username=input('用户名：')
    while True:
        #输入回复内容：
        comment=input('评论：')
        comment=comment.strip()
        #验证内容：
        if len(comment.strip())!=0:
            #验证长度是否超出20个字
            if len(comment)<=20:
                #是否存在敏感词汇
                comment=comment.replace('丑陋','**')
                print('\t{}发表的评论是：\n{}'.format(username,comment))
            else:
                print('不能超出20个字！')
        else:
            print('评论内容不能为空！')
    #成功则发出评论，否则重新输入！
    pass

列表的介绍

列表的格式

列表的格式：
定义列的格式[元素1，元素2，元素3，。。。]
容器：存储多个数据
如何定义一个列表：
1.空列表：[]
2.有内容的列表：[‘A’,‘B’,‘C’],[1,2,3,4],[[],[],[]]
数据类型：
int 1,2,3,4,5,6
float:1,9,2,8
str:‘’,
bool:True,False
List

s=0
for i in 'd7f8dje93n3':
    if i.isdigit():
        s+=int(i)
print(s)

字符串：
1.下标：
0~n-1
n~-1
s[-1],s[3]
2.切片：
s[1:-1]
s[1👎2]
s[-1:1:-2]
s[:]
s[1:]
s[:-1]
3.字符串的操作

• len,find,rfind,startwith,endwith,isalpha,isdigit,…
• replace(old,new,count)
• split('') rsplit("")
• strip() lstrip() rstrip()
• count
• join()
• format()
• lower() upper() title()
  4.列表
  定义格式：
  []
  [‘aa’,‘bb’,‘cc’]
  [1,2,3,4]
  [[],[],[],]
  下标和切片

列表的添加

'''
添加 删除 修改 查询
1.添加元素:append 追加 类似排队
合并两个列表：+ 或者 extend
'''
list1=[]
list2=['面包']
list1.append('火腿肠')
print(list1)

list1.append('酸奶')
list1.append('辣条')
print(list1)

list2.append('薯条')
print(list2)

#list1,list2
list1=list1+list2
print(list1)

list1.extend(list2)
print(list1)
'''
数字：n=1+3
字符串：s='aa'+'bb' ---->aabb
列表：list0=[1,2,3]+['a','b']---->[1,2,3,'a','b']
'''
'''
买多件:
商品名称：价格，数量
要用到列表的嵌套
'''
container=[] #存多件商品的容器
flag=True
while flag:
    #添加商品
    name=input('商品名称：')
    price=input('商品价格：')
    number=input('商品数量：')
    goods=[name,price,number]
    #将商品添加到container
    container.append(goods)

    answer=input('是否继续添加？(按q或Q退出)')
    if answer.lower()=='q':
        flag=False
print('*-'*20)
#遍历容器container
print('名称\t价格\t数量\t总价')
for goods in container: #[[],[],[]]
    # print(goods[0],goods[1],goods[2])
    sum=float(goods[1])*int(goods[2])
    print('{}\t{}\t{}\t{}'.format(goods[0],float(goods[1]),int(goods[2]),float(sum)))

列表的删除

删除：pop remove clear

出现错误–>下标超出了索引范围：
IndexError: pop index out of range

'''
删除：pop remove clear
pop(index):根据下标删除列表中的元素，下标在写的时候注意不要超出范围 index out of change
pop():从后往前依次删除，如果删除的元素列表中不存在则提示：x not in list

remove(element):根据元素名称删除,如果列表中存在多个同名元素，只删除遇到的第一个元素，后面的元素不会被删除
关键字in：元素 in 列表：表示元素是否在列表中 返回值:bool

'''
list1=['火腿肠','酸奶','辣条','面包','薯条']
list1.pop(-1)
print(list1)
list1.remove('辣条')
print(list1)
#判断是否存在要删除的元素
if '辣条呀' in list1:
    print('存在')
else:
    print('不存在')
#删除多个元素
#['火腿肠','酸奶','酸奶','面包'] 漏删
for i in list1:
    if i=='酸奶':
        list1.remove(i)
print(list1)

#删除多个元素：不漏删的情况
n=0
while n<len(list1):
    if list1[n]=='酸奶':
        list1.remove('酸奶')
    else:
        n+=1

列表重复元素删除

li=[1,1,1,2,3]
elem=1
result_li=[]
for i in li:
    if i!=elem:
        result_li.append(i)
li=result_li
print(li)

li=[2,1,'酸奶','酸奶',1]
for i in li[::-1]:
    if i=='酸奶':
        li.remove(i)
print(li)

修改：
[1,2,3,4,5,6]
insert(位置，元素)：元素占了位置，其他元素只能向后移动
index(元素)：根据元素找该元素的位置下标，返回值是下标位置
修改元素值：
列表[index]=元素值

list1=[1,2,3,4,5,6]
list1.insert(1,8)#表示的是插队
print(list1)#[1,8,3,4,5,6]

list1[1]=8
print(list1)


clear():清空列表元素

'''
查找：
1.元素 in 列表  返回bool类型
2.列表.index(元素) 返回元素的下标位置，如果没有此元素则报错
3.列表.count() 返回整数
'''
list1=[1,5,4,6,5,9,5]
print(list1.count(5))

python中查找的常用方法为：

• in(存在)，如果存在那么结果为true，否则为false
• not in(不存在)，如果不存在那么结果为true，否则为false

删除元素

列表元素的常用删除方法有:

• del:根据下标进行删除
• pop:删除最后一个元素
• remove:根据元素的值进行删除
  

list1=[1,5,4,6,5,9,5]
# print(list1.count(5))
del list1[3]#删除的是索引
print(list1)

• clear:清空的是所有的内容
• del:清空指针线
  

排序和翻转

生成随机数并保存到列表里面

'''
sort
reverse
'''
#生成8个1-20之间的随机整数，保存到表中，遍历打印
import random
numbers=[]
for i in range(8):
    ran=random.randint(1,20)
    # print(ran)
    numbers.append(ran)
print(numbers)

'''
sort
reverse
'''
#生成8个1-20之间的随机整数，保存到表中，遍历打印
import random
numbers=[]
for i in range(8):
    ran=random.randint(1,20)
    # print(ran)
    numbers.append(ran)
print(numbers)
numbers.reverse()#没有排序，单纯的翻转 True 降序  False 升序 默认
print(numbers)
# numbers.sort()#默认升序,可以通过reverse参数控制升序还是降序，reverse默认是False
# print(numbers)
# numbers.sort(reverse=True)
# print(numbers)

# #生成8个1-20之间的随机整数，保存到表中，遍历打印
import random
numbers=[]
for i in range(8):
    ran=random.randint(1,100)
    # print(ran)
    numbers.append(ran)
# print(numbers)
# numbers.reverse()#没有排序，单纯的翻转 True 降序  False 升序 默认
# print(numbers)
# # numbers.sort()#默认升序,可以通过reverse参数控制升序还是降序，reverse默认是False
# # print(numbers)
# # numbers.sort(reverse=True)
# # print(numbers)
'''
生成8个1-100之间的随机整数，保存到列表中
键盘输入一个1-100之间的整数，将整数插入到排序后的列表中
[1,9,6,8,0]
[0,1,6,8,9]
5
[0,1,5,6,8,9]

'''
num=int(input('请输入一个1-100的整数：'))
numbers.append(num)
numbers.sort()
print(numbers)

列表的循环遍历

1.使用while循环
2.使用for循环
a,b=b,a
冒泡排序：

'''
冒泡排序：手动实现升序操作，外层循环控制的是轮数，内层循环控制的是两两比较
'''
nums=[5,1,7,6,8,2,4,3]
for j in range(0,len(nums)-1):#控制的是轮数
    for i in range(0,len(nums)-1-j):#控制的是两两比较
        if nums[i]>nums[i+1]:
            a=nums[i]
            nums[i]=nums[i+1]
            nums[i+1]=a
print(nums)

元组

元组的元素不能修改

'''
Python的元素与列表类似：不同之处在于元组的元素不能修改(增 删 改)
元组使用小括号()，列表使用方括号[]
定义
list  列表
tuple 元组
名=()
注意事项：如果元组中只有一个元素，必须添加逗号 ('aaa',) (1,) (2.8,)

'''
#下标和切片 字符串，列表，元组 --->注意下标越界
t1=()
print(type(t1))
t2=('aa',)
print(type(t2))
t3=('a','b','c')
print(type(t3))
#切片：分方向，步长
print(t3[::-1])
n=t3.count('a')
print(n)
index=t3.index('a',1) #根据元素获取下标位置，指定起始结束位置
print(index)
l=len(t3)
print(l)

# 方法：
#    count()
#    index()
# 关键字：
#    in, not in
#    for ... in
#    while
#转换：
#list(tuple) 元组转列表
#tuple(list) 列表转元组

字典

字典;{}
元素：键值对 注意：键是唯一的，值是允许重复的
下标 或者 切片 -----> 没有

操作：
1.添加元素：
字典名[key]=value
注意：key是唯一的，所以在添加的时候如果出现同名的key，后面key对应的value则替换原来的
#改变年龄 键 可以添加，删除 但是键是不能修改的，只能键后面的值
2.修改value的值
字典名[key]=value
关键看‘键’：
如果字典中不存在键，则是添加
如果字典中存在键，则是修改

'''
练习:
book={}
书名，价格，作者，出版社
促销：价格折扣 8折
打印最终字典中的内容
'''
book={}
book['书名']='《三体》'
book['价格']=20
book['作者']='刘慈欣'
book['出版社']='***出版社'
#修改价格
book['价格']*=0.8 # book['价格']=book['价格']*0.8
print(book)

删除的时候都是根据key来删除的

'''
字典删除：

'''
book={'书名': '《三体》', '价格': 20, '作者': '刘慈欣', '出版社': '***出版社', '折扣': 0.8}  #表示的是一本书的信息
s='hello'
# book.clear()
# print(book)
#pop删除：根据key实现删除，删除的是键值对，返回值key对应的value
r=book.pop('出版社')

print(r)
print(book)

#popitem():返回值：(key，value) 从后往前删
r=book.popitem()
print(r)
print(book)

del book['价格'] #类似pop(key)
print(book)

删除每一本里面的’出版社’

'''
books = [{},{}]
删除：每一本里面的’出版社‘
最终打印books
'''
books=[
    {'书名':'《三体》','价格':20,'作者':'刘慈欣','出版社':'***出版社'},
    {'书名':'《流浪地球》','价格':18,'作者':'刘慈欣','出版社':'###出版社'}
]
for book in books: #book={}
    # print(book)
    book.pop('出版社')
print(books)

字典遍历和获取

'''
遍历和查询：
list.index() list.count() in

获取
dict.get(key):根据key获取value值
dict[key]:根据key获取value值

区别：
get(key) 里面的key如果不存在则返回None，同时get(key,默认值) 可以设置默认值
dict(key) 报error错误

for v in books.values():
    print(v)
获取字典所有的key:字典.keys()
'''
# 获取字典中所有的value值：字典.values():就是将所有的值存放在列表当中
book={'书名':'《三体》','价格':20,'作者':'刘慈欣'}
#get 根据key得到value，找不到书名的话，返回默认值’红楼梦‘
value=book.get('书名','红楼梦')
print(value)

print(len(book))
list1=[1,4,7,8,9]

for i in list1:
    print(i)

for i in book:
    print(i) #书名 价格 作者

print(book.values())
print(book.keys())
print(list(book.values()))

for v in book.values():
    print(v)

#获取键值对：字典.items()---->[(key,value),(),(),...]
book={'书名':'《三体》','价格':20,'作者':'刘慈欣'}
for k,v in book.items():
    print(k,v)
    print(k)
    print(v)

update实现两个字典的合并

book={'书名':'《三体》','价格':20,'作者':'刘慈欣'}
# for k,v in book.items():
#     print(k,v)
#     print(k)
#     print(v)
#只能做添加键值对元素使用
book.setdefault('出版社','人民教育出版社')#类似于 book[key]=value
print(book)
book.setdefault('出版社','人民出版社')#类似于 book[key]=value
print(book)

dict1={'a':10,'b':20}#将一个字典和另一个字典进行合并
book.update(dict1)
print(book)

# print(dict1+book) #TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
result=book.fromkeys(['a','b'])#创建一个新的字典(cls)表示的是一个类
print(result)

字典的增删改查

查看元素

修改元素

添加元素

删除元素

set的使用

集合(set)是一个无序的不重复元素序列，可以使用大括号{}或者set()函数创建集合。
注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。

#创建格式
parame={value01,value02,...}
#或者
set(value)

'''
集合：
set
特点：没有重复，无序的(没有下标)
符号：{} {元素，元素，元素，...}   --->集合
     {} {key:value,...}       --->字典
定义集合：
'''
set1={'张三'}
print(type(set1))
list1=[1,3,6,8,9,1,2,4,9]
print(set(list1))
set3=set() #空集合
print(type(set3))
print(len(set3))

#添加元素

set3.add('三体')
print(set3)

set3.add('盗墓笔记')
print(set3)

set3.add('红楼梦')
print(set3)

#append  extend insert --->list
#add     update --->set
#list:有序，允许重复
#set:无序，不允许重复
# set1.add(set3)
print(set1)
print(set3)

'''
产生5组(不允许重复)，字母和数字组成4位验证码
最终打印此五组验证码
'''
import random
code_list=set()
s='qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM'
while True:
    code=''
    for i in range(4):
        index=random.randint(0,len(s))
        code+=s[index]
        # r=random.choice(s)
        # code+=r
    #将code添加到set中
    code_list.add(code)
    #判断长度
    if len(code_list)==5:
        break
print(code_list)

集合：交集intersection 并集union 差集difference

set2={1,2,3,4,5}
set3={3,4,5,6,7,8,9}
result=set2.intersection(set3)#交集&
print(result)
result1=set2.union(set3)#并集|
print(result1)
result3=set3.difference(set2) #-差集
print(result3)

总结讲过的类型

list:允许重复，有序 有下标 []
tuple:允许重复，里面的元素不能增加删除修改，只能查看 ()
dict：键值对存在 键：唯一，值：允许重复{}
set：不允许重复，无序 {}

类型的转换
list—>tuple,set(长度有可能发生改变)
tuple—>list,set
set—>list,tuple

dict—>list,tuple,set 但是只是将字典的键放到了[],(),{}
list—>dict
特殊要求：
list=[(‘a’,10),(‘b’,20),(‘c’,30)]
print(dict(list1))

公共方法

内置方法：
print()
input()
type()
id()
len()
bin()
oct()
ord()

del 变量名
in
not in
is

list1=[1,2,3,5,7,9,0]
result=max(list)
print(result)

r1=min(list)

r2=sum(list)

abs:绝对值

t1=(45,12,78,90,10,55)
r3=sorted(t1,reverse=True)#排序
list.sort()
t5=chr(65) #给ASCII码值返回该值对应的字母
t6=ord(‘A’) #给字母返回ASCII值

#符号 + - * & /
#- & / 只能在集合中使用

列表推导式

最终得到的是一个列表
list=[]
for i in range(1,21):
list.append(i)
print(list)

列表推导式的格式1：[i for i in 可迭代的 ]
list1=[i for i in range(1,21)]
print(list1)

list2=[i+2 for i in range(1,20)]
print(list2)

#0~100之间的所有的偶数 存放到列表中
list3=[i for i in range(0,101,2)]
print(list3)

列表推导式的格式2：[i for i in 可迭代的 if 条件]
list5=[i for i in range(0,101) if i%2==0]
print(list5)

list6=['62','hello','100','world','luck','88']
list7=[word for word in list2 if word.isalpha()]
print(list7)
#list2 如果是h开头的则将首字母大写，不是h开头的全部转大写
 #格式3：[结果1 if 条件 else 结果2 for 变量 in 可迭代的]
list8=[word.title() if word.isalpha() and word.startwith('h') else word.upper() for word in list2]
print(list8)

new_list=[]
for i in range(1,10):
     for j in range(1,10):
          new_list.append((i,j))
 print(new_list)

list9=[(i,j) for i in range(1,3) for j in range(1,3)]
print(list9)

#请写出一段Python代码实现分组一个list里面的元素，比如[1,2,3,...,100]变成[[1,2,3],[4,5,6]....]
```bash
a=[x for x in range(1,101)]
b=[a[x:x+3] for x in range(0,len(a),3)]
print(b)

#找出里面名字含有两个'e'的放到新列表中
names=[['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
       ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]
new_names=[j for i in names for j in i if j.count('e')>=2]
print(new_names)

函数定义

图书管理：
借书 —> 查询 书
还书 —> 查询 书
函数：复用

函数的定义和调用

1.定义函数
def 函数名([参数，…]):
代码

函数名：get_name()
search()
代码：
封装重复内容

import random
def generate_code():
    #生成验证码
    s='QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm'
    code=''
    for i in range(4):
        r=random.choice(s)
        code+=r
    print(code)
print(generate_code) #<function generate_code at 0x00000249FE6C52F0> 获取函数地址
#验证函数是否可用？ 调用函数
generate_code()#调用函数：开始执行函数中的代码

调用函数：函数名()

'''
定义一个login函数：
admin 1234
输入用户名和密码，验证是否正确
'''
def login():
    username=input('用户名：')
    password=input('密码：')
    if username=='admin' and password=='1234':
        print('登录成功！')
    else:
        print('登录失败！')
login()

带参数的函数

参数：
    1.无参数
    2.有参数
无参数：
def 函数名():
    pass
有参数：
def 函数名(参数1,参数2,参数3,...):
    pass
    参数  就是在调用函数时向函数中传值作用

有参数会更灵活

'''
带多个参数的函数
def 函数名(参数1，参数2):
    函数体 
'''
def get_sum(a,b):
    s=a+b
    print(s)
get_sum(2,3)
get_sum('hello','world')


def get_sum(a,b):
    if type(a)==type(b):
        s=a+b
        print(s)
    else:
        print('类型不一致！')

#判断是否是整型 isinstance(变量，类型)--->返回值是bool
def get_sum(a,b):
    print('函数中：',a,b)
    if isinstance(a,int) and isinstance(b,int):
        s=a+b
        print(s)
    else:
        print('类型错误！')
get_sum(2,3)

#判断用户是否成功登录
#1.定义函数
def islogin(username,password,isremember=False):
    print('是否记住密码？',isremember)
    if username=='admin' and password =='1234':
        print('登录成功！')
    else:
        print('登陆失败！')
#2.调用函数
islogin('admin','1233')

默认值参数

'''
默认值参数：在定义函数的时候，有一个或多个参数已经赋好值，
def 函数名(参数1，参数2，参数3=值，参数4=值，参数5=值):
    pass
调用特点：
函数名(值1，值2)
注意：
1.在定义函数的时候，普通参数要位于默认值参数的前面
2.默认参数的顺序是固定的
解决方法：
调用时使用关键字参数赋值
'''
def borrow_book(bookname,number=1):
    print('进入借书系统....')
    print('要借阅的书名是：{}，借阅的数量：{}'.format(bookname,number))
borrow_book('红楼')
borrow_book('西游记',2)

参数的数据类型是列表

定义的时候叫默认值，调用的时候叫关键字

'''
library=[书名1，书名2，...]
def add_book(bookname):
    pass
def all_book(library):
    pass
'''
library=['python精髓','MySQL','数据分析','人工智能']
#形参
def add_book(bookname):
    library.append(bookname)
    print('图书添加成功！')
def show_book(books):
    for book in books:
        print(book)
add_book('新概念英语')
show_book(library)

list1=[23,45,77,80,59,10]
def get_list(list_1):
    new_list=[]
    for e in list_1:
        if e>=50:
            new_list.append(e)
    # new_list=[e for e in list_1 if e>=50]
    print(new_list)
get_list(list1)

while if else:确保都能删除到位

list1=[23,45,77,80,59,10]
#获取大于50的元素
# def get_list(list_1):
#     new_list=[]
#     for e in list_1:
#         if e>=50:
#             new_list.append(e)
#     # new_list=[e for e in list_1 if e>=50]
#     print(new_list)
# get_list(list1)
# def remove_from_list(list_1):
#删除小于50的数字
def remove_from_list(list_1):
    n=0
    while n<len(list_1):
        if list_1[n]<50:
            list_1.remove(list_1[n])
        else:
            n+=1
    print(list_1)
remove_from_list(list1)

可变参数

'''
可变参数：
*args：可以理解为是一个容器
**kwargs
拆包和装包
'''
#求和
# def get_sum(a,b):
#     r=a+b
#     print(r)
# get_sum(2,6,9)
# get_sum(2,6,9,10)
def get_sum(*args):
    print(args)#(1,2)是元组
get_sum(1,2)
get_sum(1,2,3,4)

装包

a,*b,c=1,2,3,4,5
print(a)
print(b)
print(c)

def get_sum(*args):
    s=0
    for i in args:
        s+=i
    print('和：',s)
get_sum(1,2)
get_sum(1,2,3,4,5)
get_sum(1,2,3)
get_sum()

def get_sum(*args):
    s=0
    for i in args:
        s+=i
    print('和：',s)
get_sum(1,2)
get_sum(1,2,3,4,5)
get_sum(1,2,3)
get_sum()

拆包

a,b,*c=(1,2,3,4,5,6,7,8)

def get_sum(*args):
    print(args)
    s=0
    for i in args:
        s+=i
    print('和：',s)
# get_sum(1,2)
# get_sum(1,2,3,4,5)
# get_sum(1,2,3)
# get_sum()
# a,b,*c=(1,2,3,4,5,6,7,8)
ran_list=[23,45,12,44,78,39,29]
get_sum(*ran_list)#在调用的时候加*，这时的作用是拆包

拆包和装包：

可变参数 **kwargs

def login(n=3):
    count = 0
    while True:
        username = input("username:")
        password = input("password:")
        if username == 'admin' and password == '1234':
            print("login success")
            break
        else:
            print("login fail")
        count += 1
        if count >= n:
            print('已锁定')
            break
if __name__ == '__main__':
    login(n=3)

可变参数函数调用的时候必须传递关键字参数，才可以将其转换成key:value,装到字典中

'''
可变参数：**kwargs
'''
def show_book(**kwargs):
    print(kwargs)
show_book()
show_book(bookname='西游记')
show_book(bookname='西游记',author='吴承恩',number=5)

# '''
# 可变参数：**kwargs
# '''
def show_book(**kwargs):
    print(kwargs)
    for k,v in kwargs.items():
        print(k,v)
show_book()
show_book(bookname='西游记')
show_book(bookname='西游记',author='吴承恩',number=5)
print('-----------------------------')
book={'bookname':'西游记','author':'吴承恩','number':5}
show_book(**book)#把字典拆成关键字

函数的返回值

参数:外界向里面传值
返回值:里面的内容向外界传送

有返回值的情况在调用时要用变量接住

返回值后面有一个值

'''
参数:外界向里面传值
返回值:里面的内容向外界传送
def 函数名(参数,...):
    ...
    ...
    return xxxx
当函数调用时通过return向外输出返回值
注意：只要函数有返回值，则需要接收
'''
def get_sum(*args):
    total=0
    for i in args:
        total+=i
    #将total返回
    print('内部',total)
    return total
t=get_sum(1,2,3)
print('外侧',t)
x=100
x=x+t
print(x)#这个情况下没有在函数里有print

返回值后面有多个值

return 后面的值可以是一个值，也可以是多个值。
如果是多个值 类似:return a,b,c 会将多个值封装到一个元组中，将元组作为整体返回
(a,b,c)

def get_maxandmin(numbers): #
    #排序：冒泡排序
    for i in range(0,len(numbers)-1):
        for j in range(0,len(numbers)-1-i):
            if numbers[j]>numbers[j+1]:
                numbers[j],numbers[j+1]=numbers[j+1],numbers[j]
    print(numbers)
    min=numbers[0]
    max=numbers[-1]
    return min,max #元组
list1=[23,13,56,33,25,78,95,22]
result=get_maxandmin(list1) #元组
print(result)
a,b=get_maxandmin(list1)
print(type(a))# int整型
print(b)
print(a,b)

list1=[34,11,78,90,100,23,56,88,91]

函数间调用

全局变量和局部变量

'''
全局和局部变量：
声明函数外面的称作全局变量
声明在函数内部的变量，称作局部变量

函数内部可以直接使用全局变量，但是不能直接修改全局变量
如果想修改全局变量，则必须使用关键字:global 变量名
'''
#全局变量
a=100
def test1():
    #局部变量
    a=8
    b=0
    print('a=',a)
    print('b=',b)
def test2():
    b=9
    #局部变量的作用范围仅限函数内部
    print('a=',a)
    print('b=',b)
def test3():
    #改变全局a的值,
    #a=10 声明了一个局部变量a
    global a #我现在要用全局变量a了
    a-=10 #a=a-10
    print('a=',a)
test3()
test1()
test2()

可变和不可变类型

'''
可变与不可变:
不可变：当改变变量的值时，地址发生了改变
     类型：int str float bool tuple
可变类型：里面的内容发生了改变，但是地址没有发生改变
     类型：list dict set
'''
a=100
print(id(a)) #140721760566112
b=90
print(id(b)) #140721760565792
s='abc'
print(id(s)) #2250421635704
s='xyz'
print(id(s)) #2250428347760

t1=(1,2,3)
print(id(t1)) #2250428139704

t1=(1,2,3,4)
print(id(t1)) #2250422211192

l1=[1,2,3]
print(id(l1))

l1.append(4)
print(id(l1))

'''
全局和局部变量：
global关键字的添加:
只有不可变的类型才需要添加global
可变的类型不需要添加global

'''
library=['红楼梦','西游记','水浒传']
def add_book(bookname):
    if bookname not in library:
        library.append(bookname)
        print('添加成功!')
    else:
        print('已经存在此书')
def show_book():
    print('图书馆的书籍如下：')
    for book in library:
        print(book)
show_book()
add_book('三国演义')

停车计费系统

'''
停车计费系统：
进入停车场记录进入时间，如果出去则记录出去时间：出去-进入时间
停车场的数据结构是：
[{‘车牌’:[进入时间，0]},{‘车牌’:[进入时间，出去时间]},....]
15分钟 1块
1小时  4块
停车场变量--->全局变量
def enter():
    #键盘输入车牌
    pass
def go_out():
    #键盘输入车牌
    pass
'''
#没有车辆
import random
car_park=[]#全局变量

def enter():
    print('欢迎进入XXX停车场')
    number=input('输入车牌号码：')
    #构建结构{‘车牌’:[0,5]}
    car={}
    car[number]=[0]#进入时间按0填入
    #添加到car_park
    car_park.append(car)
    print('{}已进场'.format(number))
def go_out():
    number=input('请输入车牌号码:')
    #判断汽车是否进场
    for car in car_park:
        if number in car:
            #记录结束时间
            time=random.randint(0,24)
            time_record=car.get(number)#获取字典的value
            time_record.append(time)
            #计算花费
            total=time*4#花费计算逻辑：一小时4块钱
            print('{}停车{}小时,应缴费：{}'.format(number,time,total))
            break
        else:
            print('此车未进场！')
#进场
enter()
enter()
enter()
enter()
go_out()

函数的注释

函数的注释：
def 函数名(参数1,...):
    基本注释 "注释内容"
    高级注释
    ”“”
       函数的说明：
       参数的说明：
        :param username: 用户名
        :param password: 用户登录密码
       返回值说明:
        :return: 是否登录成功
    “”“
'''
def login(username,password):
    '''
    用户号登录
    :param username: 用户名
    :param password: 用户登录密码
    :return: 是否登录成功
    '''
    if username=='admin' and password=='1234':
        print('登录成功')
        return True
    else:
        print('用户名或者密码有误！')
        return False
login('admin','1234')

函数小结

• 局部变量(函数内侧)的作用，为了临时保存数据需要在函数中定义变量来存储
• 全局变量(函数外侧)
• 当函数内出现局部变量和全局变量相同名字时，函数内部中的变量名=数据 此时理解为定义了一个局部变量，而不是修改全局变量的值
• 如果在函数中出现global全局变量的名字，那么这个函数中即使出现和全局变量名相同的变量名=数据 也理解为对全局变量进行修改，而不是定义局部变量。
• 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

一个函数返回多个数据的方式

默认放到了元组里

缺省参数在*args后面

def sum_nums_3(a,*args,b=22,c=33,**kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
sum_nums_3(100,200,300,400,500,600,700,b=1,c=2,nn=900)

引用和函数参数引用

引用：
1.不是在函数中使用，可以通过sys.getrefcount(a) 引用个数
del 变量 表示删除了一个引用
2.函数的引用：
必须要分清传递的值是可变类型还是不可变类型，
如果是可变，里面发生改变，外层就能看到改变后的内容
如果是不可变，里面发生改变，不会影响外部的变量值

这里面的n是不可变类型

def test(n1):
    #n1 是函数的局部变量
    for i in range(n1):
        print('----->', i)
    n1 += 1
n=9
test(n)
print(n)

这里的list1是可变类型

list1=[1,2,3]
def test1(l):
    if isinstance(l,list):
        for i in l:
            print('+++++>',i)
        l.insert(0,8)
    else:
        print('不是列表类型的')
#调用test1
test1(list1)
print(list1)
#+++++> 1
#+++++> 2
#+++++> 3
#[8, 1, 2, 3]

闭包

函数只是一段可执行代码，编译后就"固化"了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了，函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。

'''
嵌套：内层函数--->外层函数--->全局--->系统builtins
闭包：
'''
def outer():
    a=100
    def inner():
        b=200
        nonlocal a #如果想修改外部函数的变量，需在内部函数中添加:nonlocal
        # b+=a #内部函数可以使用外部函数的变量
        a+=b #内部函数不能修改外部函数的变量
        print('我是内部函数', b)
    # result=locals() #locals() 表示查看函数中的局部变量，以字典的形式返回
    # print(result)
    print(a) #100
    inner()
    # print(inner)  #<function outer.<locals>.inner at 0x00000261A04C5378>
outer()

a=100
def outer():
    a=200
    def inner():
        a=300
        print('内部函数：',a)
    print(a)
    inner()
outer()
print(a)

a=100
def outer():
    a=200
    def inner():
        # a=300
        global a
        a-=50
        print('内部函数：',a)
    print(a)
    inner()
outer()
print(a)

闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数块+引用环境)
如果在一个内部函数里，对再外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为是闭包(closure)

'''
闭包：
1.嵌套函数
2.内部函数引用了外部函数的变量
3.返回值是内部函数
'''
def outer(n):
    a=10
    def inner():
        b=a+n
        print('内部函数：',b)
    return inner
r=outer(5)
print(r)#<function outer.<locals>.inner at 0x00000229A8AF5378>
r()

复习总结

函数：

函数返回值：return

return 可以返回一个和多个值,
return a
return a,b —> (a,b)
return 也表示结束函数的调用.

def abc():
    print('***************')
    for i in range(10):
        if i==6:
            break
        print('---->',i)
    print('**********************')
r=abc()
print(r)

***************
----> 0
----> 1
----> 2
----> 3
----> 4
----> 5
**********************
None

return也表示结束函数的调用

def abc():
    print('***************')
    for i in range(10):
        if i==6:
            return
        print('---->',i)
    print('#####################')
    print('**********************')
r=abc()
print(r)

***************
----> 0
----> 1
----> 2
----> 3
----> 4
----> 5
None

全局和局部变量

1.什么是全局变量？
2.全局变量的位置？
3.全局变量能否在函数中修改？—>全局变量是不可变类型，必须添加global关键字，全局变量是可变类型无需添加
4.查看全局变量使用：globals() —>是一个字典，分成1.系统 2.自定义
局部：
1.什么是局部变量？函数内部的
2.可访问范围仅限函数内部，---->为何仅限内部？ 执行时创建，结束时销毁局部变量
3.查看局部变量:locals() ---->字典
4.内部函数也看成一个局部变量.

可变和不可变：
值和地址之间的关系，
不可变:int str tuple float bool
可变：list dict set

地址的引用：
1.普通的赋值关系
list=[…]
list2=list1
import sys
sys.getrefcount(list1)

2.函数参数
看函数参数类型：可变还是不可变

函数嵌套：

def outer():
    a=100
    def inner():
        ....
    inner()
outer()

闭包：
1.函数嵌套
2.内部函数使用外部函数变量
3.返回值是内部函数

装饰器

def foo():
    print('foo')
def func():
    print('func')
foo=func
foo()
#func

遵循开放封闭原则

• 封闭：已实现的功能代码块
• 开放：对
  

#定义装饰器
def decorater(func):
    def wrapper():
        func()
        print('刷漆')
        print('铺地板')
        print('买家具')
        print('精装修房子')
    print('------------>2')
    return wrapper
@decorater #house=decorater(house)
def house():
    print('毛坯房....')

house()

带参数的装饰器

装饰器的功能：
1.引入日志
2.函数执行时间统计
3.执行函数前预备处理
4.执行函数后清理功能
5.权限校验等场景
6.缓存

'''
 装饰器：
 遵循开放封闭原则，在不改变原函数的情况下，扩展了函数的功能
 定义：
 def xxx(func):
     def xxx(参数,...):
         ....
         func()
         ....
         return yyy
     return xxx
装饰:
@装饰器名 ---->原函数=装饰(原函数)
def 原函数():
    pass

装饰器的功能：
1.引入日志
2.函数执行时间统计
3.执行函数前预备处理
4.执行函数后清理功能
5.权限校验等场景
6.缓存
'''
#定义装饰器
def decorater(func):
    def wrapper():
        func()
        print('刷漆')
        print('铺地板')
        print('买家具')
        print('精装修房子')
    print('------------>2')
    return wrapper
@decorater #house=decorater(house)
def house():
    print('毛坯房....')

house()

带参数的装饰器

有参数的装饰器

'''
带参数的装饰器:
如果原函数有参数则装饰器内部函数也要有参数.
'''
def decorater(func):
    def wrapper(*args,**kwargs):
        #args是一个元组 ('北京沙河北大桥'，1000)
        func(*args,**kwargs)#这行代码的作用是？
        print('刷漆')
        print('铺地板')
        print('买家具')
        print('精装修房子')

    return wrapper
@decorater
def house(address):
    print('房子的地址在:{}是一个毛坯房...'.format(address))

@decorater
def changfang(address,area):
    print('房子的地址在:{},是一个毛坯房,建筑面积是:{}平米'.format(address,area))

@decorater
def hotel(name,address,area=40):
    print('酒店的名字是:{},酒店的地址在:{},是一个毛坯房,单间建筑面积是:{}平米'.format(name,address, area))

hotel('全季大酒店',address='北京国贸')


house('北京四合院') #houSE就是wrapper
print('------------------')
changfang('北京沙河北大桥',1000)

带返回值的装饰器

def outer_check(time):
    print('-------->1')
    def check_time(action):
        print('--------------->3')
        def do_action():
            if time<22:
                return action()
            else:
                return '对不起，您不具有该权限'
        print('-------------->4')
        return do_action
    print('--------------->2')
    return check_time
@outer_check(23)
def play_game():  #outer_check(23)  r=check_time
    return '玩儿游戏'
print(play_game())
#--------------->1
#--------------->2
#--------------->3
#--------------->4

递归函数

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数

def test():
    print('------test----------')
def a():
    print('------aaaa----------')
    #调用a函数
    a()
a()

1-10打印数字

'''
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数
遵循：
1.必须要有出口
2.每次递归向出口靠近
'''
#1-10 打印 数字
def test(i):
    if i==10:
        print('10')
    else:
        print(i)
        i+=1
        test(i)
test(1)

#1-10累加和
def test1(i):
    if i==10:
        return 10
    else:
        return i+test1(i+1)
r=test1(1)
print(r)
#55

def test(a,b):
    print('---->test enter')
    return a+b
    print('---->test out')
def func():
    c=10
    return c+test(5,8)
t=func()
print(t)

阶乘
5!=12345

匿名函数

用lambda关键词能创建小型函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：

lambda 参数列表:运算表达式

'''
匿名函数定义格式:
lambda 参数列表:返回值表达式
'''
def test(a):
    return a+1
# print(test)
result=test(5)
print(result)
r=lambda a:a+1
r1=r(5)
print(r1)

r=lambda x,y:x+y
result=r(1,2)
print(result)

匿名函数的场合之高阶函数

'''
匿名函数的使用场合
匿名函数作为参数使用
'''
def test():
    print('-------test--------')

def func(a,f):
    print('------>',a)
    f()
func(5,test)

print('----------------')
def func1(a,f): #f=lambada x:x**2
    print('+++++++>',a)
    r=f(a)
    print('======>',r)
func1(8,lambda x:x**2)