学习Python写的基础知识笔记

建议安装pycharm  运行代码快捷键 shift+F10
解释器安装完成之后如何验证是否安装成功
方法一：点击 开始菜单 在里面找到“搜索”菜单，点击输入cmd【命令提示符】找到并打开,输入python。
方法二：按住WIN+R 可以快速打开运行窗口，并在里面输入python，即可看到安装结果
如何退出python的交互式环境
在环境里面输入exit()或者quit()回车退出
声明一个.py文件
可以保存我们的python代码，那么如何执行这个python文件呢
过程：首先打开命令行的提示符，进入到要执行文件的本地目录，然后直接输入python 文件的名字.py【熟悉一些基本的dos操作命令】
捷径：在打开执行文件的资源管理上面的路径输入框敲入cmd命令即可
-------------------------------------------------------------
注释：
提高代码可读性、提高开发效率、尤其对大型项目或团队项目有重要意义
还可以进行代码的调试，将一部分代码注释掉，对问题进行排查。

Python中使用#表示单行注释。单行注释可以作为单独的一行放在被注释代码行之上，也可以放在语句或表达式之后。

当注释内容过多，导致一行无法显示时，就可以使用多行注释。Python中使用三个单引号或三个双引号表示多行注释。
------------------------------------------------------------
Pycharm 优点：
节省时间和精力，目的就是让开发者更加的快捷方便，通过提供的工具和各种性能来帮助开发者组织资源，减少失误，提供捷径
建立统一标准，管理开发工作
------------------------------------------------------------
变量的学习：
1：什么是变量
变量其实就是个盒子，里面可以装各种东西，装了苹果，箱子和其他的东西结合的时候，就是属于苹果。
在python当中，其实变量的概念和初中代数的方程变量是一致的
方程式y=x*3 x就是变量 当x=2 结果就是6 x=10 结果就是30
只不过在计算机中，在写程序的时候，变量不仅仅可以是数字，还可以是其他任意类型
食材+菜谱→厨师--美味的菜肴
变量+逻辑→Python解释器--软件的功能
其实变量就相当于原材料【就是数据了】
变量=存储的数据
顾名思义：变量是一段有名字的连续存储的空间，我们可以通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段存储空间
变量是程序中临时存放数据的场所
变量如何来定义和使用
变量是可以多次赋值的【在程序执行的过程中  值可以改变的量】
变量是用来存储数据的
#定义
a=10
a就是变量的名字 对应一个盒子 里面装的数据就是10
print(a) #使用变量
c=1+4
print(c)  #出来的是5
print(type(a))可以查看a的类型
b=() #元组类型
print(type(b)) 结果出来是tuple 元组类型
c=[] #列表类型
列表和元组都属于序列
#列表属于可变序列，它的元素可以随时修改或者删除，而元组属于不可变序列，其中的元素是不能修改的，除非整体重新赋值。
print(type(c)) 结果出来是list  列表类型
d={} #字典类型
print(type(d)) 结果出来是dict  字典类型
#变量的命名规则
变量必须以字母（a-z,A-Z）或下划线（_）开头
其他字符可以是字母、数字、下划线
变量区分大小写
python关键字不能用作变量名
不能以数字来开头
-------------------------------------------------------------
算数运算符 #  +  -  *  /  %  //
比较运算符 # == ！= > < >= <=  结果是bool类型数据（Ture False)
可以有这种写法 a,b=10,5
#逻辑运算符 and or not
and 有假即假 or 有真即真  not 取反 真假替换
#优先级
（） not and or
赋值运算符
=  +=  -=  *=  /=  %=  **=
-------------------------------------------------------------# 输出 %占位符 常用格式化字符  %s %d %f
name='李华'
classpro='清华附中'
age=7
print('我的名字是:%s 来自[%s],今年%d岁了' %(name,classpro,age))

-----------------------------------------------------------------------------------------------------
格式输出的其他方式 .format()
name='老夫子'
QQ=666666
numbers=15024193635
distress='广州市白云区'
print('======================================')
print('姓名：{} \n年龄:{}'.format(name,23))
print('QQ：{}'.format(QQ))
print('电话号码：{}'.format(numbers))
print('地址：{}'.format(distress))
print('======================================')
------------------------------------------------------------
输入
Python中提供了input方法来获取键盘输入
注意：input接收的键盘输入结果都是str类型的，如果接收数字类型需要将str转成int
#input 获取键盘输入的内容
name=input("请输入您的姓名:")
age=int(input("请输入您的年龄:"))
QQ=input("请输入您的QQ：")
numbers=input("请输入您的电话：")
addr=input("请输入您的地址：")
print('======================================')
print('姓名：%s \n年龄:%d'%(name,age))  #若是用这种输入方式，因为input默认的输入是str类型，age那里因为是%d，所以会报错。解决方法是在age的定义那里价格int(),强制类型转换。
# print('姓名：{} \n年龄:{}'.format(name,age)) 
print('QQ：{}'.format(QQ))
print('电话号码：{}'.format(numbers))
print('地址：{}'.format(addr))
print('======================================')
------------------------------------------------------------
判断语句与循环控制 
------------------------------------------------------------
流程： 就是计算机执行代码的顺序
流程控制：对计算机代码执行的顺序进行有效的管理，只有流程控制才能实现在开发当中的业务逻辑
流程控制的分类：
顺序流程：就是代码一种自上而下的执行结构，也是python默认的流程
选择流程：根据在某一步的判断，有选择的去执行相应的逻辑的一种结构 
    2.1 单分支
        if 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
    2.2 双分支
    if 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
            else :
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......

    2.3    多分支

        if 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
        elif 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
        elif 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
        ......
        else:
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
    条件表达式：比较运算符/逻辑运算符/符合运算符
循环流程：在满足一定的条件下，一直重复的去执行某段代码的逻辑【事情】
    
    while 条件表达式：
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
    for ... in 可迭代集合对象
            一条条的python代码
            一条条的python代码
            一条条的python代码
            .......
------------------------------------------------------------
#单分支
# if 条件表达式： 比较运算符 逻辑运算符 /符合的条件表达式
#     代码指令
#     .....

score1=60
score2=80
if score1<=60: #满足条件就会输出打印的提示
    print("成绩不是太理想，要继续加油哦")
    pass #空语句

print("语句运行结束")

if score2<=60:
    print("成绩不是太理想，要继续加油哦")
    pass  # 空语句

print("\n语句运行结束")
# ---------------------------------------------------
#双分支
# if 条件表达式： 比较运算符 逻辑运算符 /符合的条件表达式
#     代码指令
#else:
#     代码指令

if score1>60: #True
    print("你的成绩及格....")
    pass
else:   #false才会执行
    print("你的成绩不是太理想，要继续加油哦")
    pass
# -------------------------------------------------
# 多分支的选择  [多个]
# if 条件表达式： 比较运算符 逻辑运算符 /符合的条件表达式
#     代码指令
# elif 条件表达式:
#     代码指令
# elif:
#     代码指令
# if ........... is None:
# else:
# 特征：
# 1.只要满足其中一个分支，就会推出本层if语句结构【必定会执行其中一个分支】
# 2.至少有两种情况可以选择
# 3.elif 后面必须的协商条件和语句
# 4.else 是选配，根据实际的情况来填写
score=int(input('请输入你的成绩...'))
if score>90:
       print('您的成绩是A等级')
       pass
elif score>=80:
       print('您的成绩是B等级')
       pass
elif score >= 70:
       print('您的成绩是C等级')
       pass
elif score >= 60:
       print('您的成绩是D等级')
       pass
else:
       print('可以回家养猪了')
print('程序运行结束')
# --------------------------------------------------
# 多分支，多条件的演练
# 猜拳机的小游戏
# 0：石头:1：剪刀 :2：布
import random #直接导入 产生随机数的模块
# 计算机 人
person=int(input('请出拳：[0：石头:1：剪刀 :2：布]'))
computer=random.randint(0,2)
if person==0 and computer==1: #多条件
    print('厉害！ 你赢了')
    pass
elif person==1 and computer==2:
    print("厉害！ 你赢了")
    pass
elif person==2 and computer==0:
    print("厉害！ 你赢了")
    pass
elif person==computer:
    print('不错！平手')
    pass
else:
    print("对不起 你输了")

print("游戏结束！")
------------------------------------------------------------
# if-else的嵌套使用
# 一个场景需要分阶段或者层次，做出不同的处理
# 要执行内部的if语句 一定要外部的if语句满足条件才可以
xuefen=int(input('请输入你的学分'))
grade=int(input('请输入你的成绩'))
if xuefen>10:
    if grade>=80:
        print('您可以升班了...恭喜您')
        pass
    else:
        print('很遗憾，您的成绩不达标')
        pass
    pass
else:
    print('您的表现也太差了吧...')
------------------------------------------------------------
循环的分类
# while 语法结构
# while 条件表达式：
#     代码指令
# 语法特点
# 1.有初始值
# 2.有条件表达式
# 3.变量【循环体内计数变量】的自增或者自减，否则会造成死循环
# 使用条件：循环的次数不确定，是依靠循环条件来结束
# 目的：为了将相似或者相同的代码操作变得更加简洁，使得代码可以重复利用
# for
# while的使用
# 案例 输出1-100之间的数据
index =1  #定义一个变量
while index <=100:
    print(index)
    index+=1
    pass
------------------------------------------------------------
猜拳游戏改进
import random
count=1  #循环第一要素 初始值
while count<=10:    #循环第二要素 条件
    person=int(input('请出拳：【0：石头 1：剪刀 2：布】'))
    computer=random.randint(0,2)
    if person == 0 and computer == 1:  # 多条件
        print('厉害！ 你赢了')
        pass
    elif person == 1 and computer == 2:
        print("厉害！ 你赢了")
        pass
    elif person == 2 and computer == 0:
        print("厉害！ 你赢了")
        pass
    elif person == computer:
        print('不错！平手')
        pass
    else:
        print("对不起 你输了")
        pass

    print("游戏结束！")
    count+=1 #循环第三条件，自增或自减，避免死循环
------------------------------------------------------------
# 打印九九乘法表 循环的嵌套
row =1
while row<=9:
    col=1
    while col<=row:
        print('%d*%d=%d '%(row,col,row*col),end="")  #end是在print后禁止换行
        col+=1
        pass
    print()
    row+=1
    pass
------------------------------------------------------------
# for 循环
# 语法特点：遍历操作，依次的取几何容器中的每个值
# for 临时变量 in 容器:
# 执行代码块
tags='我是一个中国人' #字符串类型本身就是一个字符类型的几何
for item in tags:
    print(item)
    pass
range 此函数可以生产一各数据集合列表
range(起始： 结束： 步长) 步长不能为0
-------------------------------------------------------
sum=0
for data in range(1,101):  #左闭右开
    sum+=data #求累加和
    print(' ',end='')
    print(data,end='')
    pass
print("\nsum=%d"%sum)
print('-----------for的使用--------------------------')
for data in range(50,201):
    if data%2==0:
        print("%d是偶数"%data)
        pass
    else:
        print("%d是基数"%data)
------------------------------------------------------
break 和continue
break 代表中断结束  满足条件直接的结束本层循环
continue:结束本次循环，继续下次循环（当continue的条件满足时，本次循环剩下的语句将不再执行，后面的循环继续）
这两个关键字只能用在循环中
----------break的使用------------------------------------
sum=0
for item in range(1,51):
    if sum>100:
        print('循环执行到%d就退出来了'%item)
        break #退出循环体
    sum+=item
    print("sum=%d" % sum)
    pass
-------------------------------------------------------
for item in 'i love you':
    if(item=='e'):
        break
    print(item)
    pass

-------------------continue的使用------------------------

for item in range(1,100): #求出来基数
    if item%2==0:
        continue
        pass
    print(item)
    pass
-------------------------------------------------------
index=1
while index<=100:
    if index>20:
        break
        pass
    print(index)
    index+=1
    pass
------------------------------------------------------------
while使用：适用于对未知的循环次数  用于判断
for使用:适用于已知的循环次数【可迭代对象遍历】
------------------------------------------------------------
#九九乘法表用for实现
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d "%(i,j,i*j),end="")
        pass
    print() #控制换行
    pass
------------------------------------------------------------
for----else例子
for item in range(1,11):
    print(item,end='')
    print(" ",end='')
    if item>=5:
            break
    pass
else:
    print('就是在上面的循环当中 只要是出现了break 那么else的代码将不再执行')

-----------------操作例子：三次登录不正确就锁定----------------
account='wyw'
pwd='123'
for i in range(3):
    zh=input('请输入账号:')
    pd=input('请输入密码:')
    if account==zh and pwd==pd:
        print('恭喜您登陆成功...')
        break #退出本层循环了
        pass  
    pass
else:
    print('您的账号已经被系统锁定...')
------------------------------------------------------------
# while----else

index=1
while index<=10:
    print(index)
    if index==6:
        break
    index+=1
    pass
else:
    print('只要是出现了break 那么else的代码将不再执行')
------------------------------------------------------------
小结
流程：就是计算机执行代码的顺序
流程控制：对计算机代码执行的顺序进行有效的管理，只有流程控制才能实现在开发当中的业务逻辑
流程控制的分类：
1.顺序流程：就是代码一种自伤而下的执行结构，也是python默认的流程
2.选择流程：根据在某一步的判断，有选择的去执行相应的逻辑的一种结构
3.循环流程：在满足一定的条件下，一直重复的去执行某段代码的逻辑【事情】

while使用：适用于对未知的循环次数 用于判断
for使用：适用于已知的循环次数【可迭代对象遍历】
------------------------------------------------------------
# 猜年龄小游戏，有三点需求
# 1.允许用户最多尝试3次
# 2.每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y，就继续让其猜3次，以此往复，如果回答N或n，就退出程序
# 3.如果猜对了就直接退出
# 目的：演练while的使用和if使用  综合运用
times=0
while times<=3:
    age=int(input('请输入您要猜的年龄'))
    if age==25:
        print('恭喜您猜对了')
        break #猜对直接中断循环
        pass
    elif age>25:
        print('猜大了,请在试试')
        pass
    else:
        print(('猜小了，请再试试'))
        pass
    times+=1
    if times==3:
        choose=input('想不想继续猜呢 Y/N？')
        if choose=='Y'or choose=='y':
            times=0 #重置为初始值
            pass
        elif choose=='N' or choose=='n':
            times==4
            print('游戏结束，欢迎下次光临')
            pass
        else:
            print('请输入正确的标记...谢谢配合')
pass
------------------------------------------------------------
# 小王身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小王计算他的BMI指数，并根据BMI指数：
# 低于18.5过轻
# 18.5-25 正常
# 25-28 过重
# 28-32 肥胖
# 高于32 严重肥胖
# 用if-elif判断并打印结果

height=1.75
weight=80.5

BMI=weight/(height**2)
print('BMI=%d'%BMI)
if BMI<18.5:
    print('小王太轻了，需要多吃点，加强锻炼')
    pass
elif 18.5<=BMI<=25:
    print('标准体重')
    pass

elif 25<=BMI<=28:
    print('有点过重了哦')
    pass
elif 28<=BMI<=32:
    print('体重肥胖...')
    pass
else:
    print('严重肥胖，请加强锻炼')
    pass
------------------------------------------------------------
# # python高级数据类型
# 序列： 在python当中 序列就是一组按照顺序排列的值【数据集合】
# 在python中 存在三种内置的序列类型：
# 字符串、列表、元组
#
# 优点：可以支持索引和切片的操作
# 特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
#
# 切片：【高级特效】可以根据下标来获取序列对象的任意[部分]数据
# 语法结构：[start:end:step] step默认是1
# 下标会越界，但是切片不会

Test='python'
print(type(Test))
print('获取第一个字符%s'%Test[0])
print('获取第二个字符%s'%Test[1])
for item in Test:
    print(item,end='')

name='peter'
print('姓名首字母转换大写%s'%name.capitalize()) #.capitalize() 功能首字母大写

a='        hello               '
b=a.strip() # .strip()  去除字符串中的空格
print(b)
print(a.lstrip()) #删除左边的空格
print(a.rstrip()) #删除右边的空格

# 复制字符串
b=a #在此只是把a对象的内存地址赋给了b
print(b)
print('a的内存地址%d'%id(a))    #id可以查看一个对象的内存地址
print('b的内存地址%d'%id(b))   #a和b内存地址一样，是一个对象

dataStr='I love Python'
# print(dataStr.find('P')) #可以查找目标对象在序列对象中的位置（从0开始），如果没有找到就返回-1
# print(dataStr.index('v')) #监测字符串中是否包含子字符串，返回的是下标值，如果没找到就报异常
print(dataStr.startswith('I'))  #以什么来开头，报True或False
print(dataStr.endswith('n'))    #以什么来结尾，报True或False

print(dataStr.lower()) #转换为小写
print(dataStr.upper()) #转换为大写
# ------------------------------------------------------------
# 切片
strMsg='hello world'
# slice [start:end:step] 左闭右开 start<=value print(strMsg) #输出完整的数据
print(strMsg[0])
print(strMsg[2:5]) #2-5小标之间的数据
print(strMsg[2:])  #第三个字符到最后
print(strMsg[0:3]) #1-3   strMsg[0:3]=strMsg[:3]
print(strMsg[::-1])#倒叙输出  符号表示方向从右往左去遍历
------------------------------------------------------------
# list(列表):python中非常重要的数据结构，是一种有序的数据集合
# 特点：
# 1.支持增删改查
# 2：列表中的数据是可以改变的【数据项可以变化，内存地址不会改变】
# 3：用[] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
# 4：支持索引和切片来进行操作

# li=[] #空列表
# li=[1,2,3,'你好']
# print(len(li)) #len函数可以获取到列表对象的数据个数
# strA='我喜欢python'
# print(len(strA))
# print(type(li))

#查找
# listA=['abcd',785,12.23,'qiuzhi',True]
# print(listA) #输出完整的列表
# print(listA[0])  #输出第一个元素
# print(listA[1:3]) #从第二个开始到第三个元素
# print(listA[2:]) #从第三个元素开始到最后所有的元素
# print(listA[::-1]) #负数从右向左开始输出
# print(listA*3) #输出多次列表中的数据[复制]

# print('------------------------------增加-----------------------------------')
# print('追加之前',listA) #追加操作
# listA.append(['fff','ddd']) #注意这里要添加括号，不然会报错，因为只能加1个
# print("追加之后",listA)
#
# listA.insert(1,'这是我刚插入的数据') #插入操作 需要执行一个位置插入
# print(listA)
#
# rsData=list(range(10)) #强制转换为list对象 rang可以动态生成0到9的序列（容器）
# print(type(rsData))
#
# listA.extend(rsData) #拓展 等于批量增加
# listA.extend([11,22,33,44])  #注意中括号
# print(listA)

# print('------------------------------修改----------------------------------')
# print("修改之前",listA)
# listA[0]='Peter'
# print('修改之后',listA)

listB=list(range(10,51))
print(listB)
print('------------------------------删除----------------------------------')
del listB[0] #删除列表中第一个元素
print(listB)
del listB[1:3] #批量删除多项数据
print(listB)

listB.remove(20) #移除指定元素 参数是具体的数据值
print(listB)

listB.pop() #移除指定的项 不带参数默认最后一项 参数是索引值
print(listB)

print(listB.index(19，20,25))  #index返回的索引下标从0开始 20是从下标20开始查 25是查找长度  19是要查的数字的
------------------------------------------------------------
# 元组：不可变的序列，在创建之后不能做任何的修改
# 1：不可变
# 2：用（）创建元组类型，数据项用逗号来分割
# 3：可以是任何类型
# 4：当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理或字符串
# 5：同样可以支持切片操作

# 元组的创建,不能进行修改
tupleA=() #空元祖
print(id(tupleA))
tupleA=('abcd',89,9.12,'peter',[11,22,33])
print(id(tupleA))  #内存地址改变了
print(type(tupleA))
print(tupleA)
元组的查询
for item in tupleA:
    print(item,end=' ')
print(tupleA[2:4])

print(tupleA[::-1]) #负数表反。数字表步长
print(tupleA[::-2]) #表示反转字符串每隔两个取一次 两个包括自身坐标

print(tupleA[-2:-1:]) #倒着取下标 为-2到-1区间的

print(tupleA[-4:-2:]) #倒着取下标

tupleA[0]='pythonHello' #错误的  不能被修改
tupleA[4][0]=123  #可以对元组中的列表进行修改
print(tupleA)
tupleB=('1',) #当元组中只有一个数据项的时候，必须要在第一个数据项后面加上逗号
print(type(tupleB))
tupleC=tuple(range(10)) #强制类型转换
print(tupleC.count(8)) #可以统计某数据出现多少次
------------------------------------------------------------
字典：也是python中重要的数据类型，字典是由键值对组成的集合，通常使用键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除

特点：
1：不是序列类型，没有下标概念，是一个无序的键值集合，是内置的高级数据类型
2：用{}来表示字典对象，每个键值对用逗号分隔
3：键 必须是不可变的类型 [元组、字符串] 值可以是任意的类型
4：每个键必定是惟一的，如果存在重复的键，后者会覆盖前者
# 如何创建字典
dictA={'pro': '忍术','school':'早稻田大学'}
# 添加字典数据
dictA['name']='naruto' #key:value
dictA['age']=19
dictA['pos']='火影'
#结束添加
# print(type(dictA))
# print(dictA) #输出完整的字典
# print(len(dictA))  #数据项长度
#
# # 查找
# print(dictA['name']) #通过键获取对应的值
# #修改
# dictA['name']='sasuke' #进行修改
# dictA.update({'age':32})  #该方法可以添加或更新
# print(dictA)

# print(dictA.keys()) # 获取所有的键
# print(dictA.values())# 获取所有的键
#
# # print(dictA.items()) #获取所有的键值对
# for item in dictA.items():
#     print(item)
# for key,value in dictA.items():
#     print('%s==%s'%(key,value))

# 删除操作
# del dictA['name']
# dictA.pop('age') #通过指定键进行删除
# print(dictA)

#排序  按照Key排序
print(sorted(dictA.items(),key=lambda d:d[0]))
------------------------------------------------------------
#公用方法 + * in
strA='人生苦短'
strB='我用python'
# list合并
listA=list(range(10)) #range从零开始
listB=list(range(11,20))

#字符串合并
print(listA+listB)
print(strA+strB)

#复制*
print(strA*3)
print(listA*3)

#in 对象是否存在 结果是一个bool值
print('生' in strA)  #True
print(22 in listA)  #False
dictA={'name':'peter'}
print('age' in dictA)
------------------------------------------------------------

函数的学习

------------------------------------------------------------
什么是函数：一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能
为什么要使用函数：代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化
函数定义：
def 函数名():
    函数体[一系列的python语句，表示独立的功能]
函数的调用：
    本质上就是去执行函数定义里面的代码块，在调用函数之前必须先定义
----------------------------------------------- 
print('小张的身高是%f'%1.73)
print('小张的体重是%f'%160)
print('小张的爱好是%s'%'唱歌')
print('小张的专业是%s'%'计算机信息管理')
#处理其他的逻辑信息
#多次去打印出小张的信息
print('小张的身高是%f'%1.73)
print('小张的体重是%f'%160)
print('小张的爱好是%s'%'唱歌')
print('小张的专业是%s'%'计算机信息管理')
-----------------------------------------------
#针对上面的场景，就需要进一步的去优化代码[方案：封装函数]
#函数的定义
def 函数名(参数列表):#参数名0到n个
    #函数代码块

def printInfo():
    '''
    这个函数是用来打印个人信息的 是对小张信息显示的组合
    :return:
    '''
    #函数代码块
    print('小张的身高是%f' % 1.73)
    print('小张的体重是%f' % 160)
    print('小张的爱好是%s' % '唱歌')
    print('小张的专业是%s' % '计算机信息管理')
#     pass
#函数的调用
printInfo() #函数的调用
printInfo() #多次调用
printInfo()
printInfo() #按住ctrl可以看到备注信息

print('我是其他代码块...')
# -------------------------------------------------

#函数参数
#进一步的去完善这样的需求【输出不同人的信息】 方案：通过传入参数来解决
def printInfo(name,height,weight,hobby,pro):
    #函数代码块
    print('%s的身高是%f' % (name,height))
    print('%s的体重是%f' %(name,weight))
    print('%s张的爱好是%s' % (name,hobby))
    print('%s张的专业是%s' % (name,pro))
    pass
# #调用带参数的信息
printInfo('小李',1.82,200,'打游戏','土木')
print('-------------------带参数的调用---------------------')
printInfo('Peter',1.75,160,'写代码','计算机应用')

# 参数的分类：
# 必选参数、默认参数[缺省参数]、可选参数、关键字参数
# 参数：其实就是函数为了实现某项特定的功能，进而为了得到实现功能所需要的数据
# 就是为了得到外部数据的

# 1 必选参数
def sum(a,b): #形式参数:只是意义上的一种参数，在定义的时候是不占内存地址的
    sum=a+b
    print(sum)
    pass
函数调用 在调用的时候必选参数是，必须要赋值的
sum(20,15) #20 15 实际参数：实参，实实在在的参数，是实际占用内存地址的
sum() #不能这样写的
sum(15) #也不能这样

# 2.默认参数【缺省参数】 ！！！始终存在于参数列表中的尾部  b声明了默认值  c就不能缺省默认值
def sum1(a=20,b=30):
    print('默认参数使用=%d'%(a+b))
    pass
# 默认参数的调用
sum1()     #结果50
sum1(10)  #在调用的时候如果未赋值，就会用定义函数时给定的默认值  结果40
sum1(2,56) #结果58

#可变参数（当参数的个数不确定时使用，比较灵活）
def getComputer(*args): #可变长的参数
    '''
    计算累加和
    :param args: 可变长的参数类型
    :return:
    '''
    # print(args)
    result=0
    for item in args:
        result+=item
        pass
    print('result=%d'%result)
    pass

getComputer(1)
getComputer(1,2)
getComputer(1,2,3)  #都输出元组
 
# 关键字可变参数
# ** 来定义
# 在函数体内 参数关键字是一个字典类型 key是一个字符串

def keyFunc(**kwargs):
    print(kwargs)
    pass
# 调用
# keyFunc(1,2,3) 不可以传递的
dictA={'name':'Leo','age':35}  #method 1
keyFunc(**dictA)
keyFunc(name='peter',age=26) #method 2
keyFunc()   #不传也是可以的

def complexFunc(*args,**kwargs):   #args接受的是元组类型数据  kwargs接受的是字典类型数据
    print(args)
    print(kwargs)
    pass
# 组合的使用
complexFunc()
complexFunc(1,2,3,4)
complexFunc(1,2,3,4,name='刘德华')
complexFunc(age=36)
#以上方式调用均可以

def TestMup(**kwargs,*args):  #不符合要求的
    '''
    可选参数必须放到关键字可选参数之前
    可选参数：接受的数据是元组类型
    关键字可选参数：接受的数据是一个字段类型
    :param kwargs:
    :param args:
    :return:
    '''
    pass
------------------------------------------------
# 函数返回值
# 概念：函数执行完以后会返回一个对象，如果在函数的内部有return 就可以返回实际的值，否则返回None
# 类型可以返回任意类型，返回值类型应该取决于return后面的类型
#用途：给调用方返回数据
#在一个函数体内可以出现多个return值，但是肯定只能返回一个return
#如果在一个函数体内 执行了return，意味着函数就退出了,return后面的代码语句将不会执行
def Sum(a,b):
    sum=a+b
    return  sum #将计算的结果返回
    pass

# print(Sum(10,30)) #函数的返回值返回到调用的地方
# #或者可以
# rs=Sum(10,30) #将返回值赋给其他的变量
# print(rs)

# def calComputer_1(num):
#     result=0
#     i=1
#     while i<=num:
#         result+=i
#         i+=1
#         pass
#     return result
#     pass
# #调用函数
# value=calComputer_1(10)
# print(value)
# print(type(value))
# ----------------返回类型由return决定，注意两个函数体的区别------------------------
# def calComputer_2(num):
#     li=[]  #一个空列表
#     result=0
#     i=1
#     while i<=num:
#         result+=i
#         i+=1
#         pass
#     li.append(result)
#     return li  #返回列表   你返回什么类型直接是return决定
#     pass
# #调用函数
# value=calComputer_2(10)
# print(value)
# print(type(value))

def returnTuple():
    '''
    返回元组类型的数据
    :return:
    '''
    # return  1,2,3  #返回为元组类型
    return {'name':'测试'}
    pass
A=returnTuple()
print(type(A))
------------------------------------------------
函数的嵌套

#函数嵌套
def fun1():
    print('---------------------fun1 start-------------------------')
    print('---------------------执行代码省略-------------------------')
    print('---------------------fun1 end-------------------------')
    pass
def fun2():
    print('---------------------fun2 start-------------------------')
   #调用第一个函数
    fun1()
    print('---------------------fun2 end-------------------------')
    pass
fun2() #调用函数2

# 函数的分类：根据函数的返回值和函数的参数
# 有参数无返回值的
# 有参数有返回值的
# 无参数有返回值的
# 无参数无返回值的

# 写函数，接收n个数字 #解读：(不确定，选择可变参数类型)#，求这些参数数字的和
def sumFunc(*args):

    '''
    # 处理接受的数据
    :param args:  可变长的参数 可以接受一个元组
    :return:  计算和
    '''
    result=0
    for item in args:
        result+=item
        pass
    return  result
    pass
# 调用
rs=sumFunc(1,2,3,4)
print('rs={}'.format(rs))  #format 格式化输出
rs=sumFunc(4,5,6,7,8,9,10)
print('rs=%d'%rs)

# # 写函数， 找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表

def process_Func(con):
    '''
    处理列表数据
    :param con:  接受的是一个列表或者元组
    :return:  新的列表对象
    '''
    listNew=[]
    index=1
    for i in con:
        if index%2==1: #判断奇数位
            listNew.append(i)
            pass
        index+=1
        pass
    return listNew
    pass

result1=process_Func([1,2,3,4,5,6,7])
print(result1)

result2=process_Func(tuple(range(10,30)))
print(result2)

# 写函数，检查传入字典的每一个value的长度(#遍历)，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# PS：字典中的value只能是字符串或列表
def dictFunc(**kwargs):
    '''
    处理字典类型的数据
    :param kwargs: 字典
    :return:
    '''
    result={} #空字典
    for key,value in kwargs.items():
        if len(value)>2:
            result[key]=value[:2]  #向字典去添加数据
            pass
        else:
            result[key]=value
            pass
        pass
    return result
    pass

#函数调用
dictObj={'name':'刘星','hobby':['唱','跳','rap'],'pro':'gis'}
print(dictFunc(**dictObj))   #注意这里必须要有** 否则会报错
-----------------------------------------------
# 局部变量 就是在函数内部定义的变量【作用域仅仅局限在函数的内部】
# 不同的函数 可以定义相同的局部变量，但是各自用各自的 不会产生影像
# 局部变量的作用：为了临时的保存数据 需要在函数中定义来进行存储
# def printInfo():
#     name='Peter'
#     pass
# def TestMethod():
#     print(name)
#     pass
# TestMethod()  #不能运行 因为name是局部变量，只属于函数体

# -----------------全局变量--------------------------
# pro的定义就是一各全局变量[变量的作用域不同]
# 当全局变量和局部变量出现重复定义的时候，程序会优先执行使用函数内部定义的变量[地头蛇]
#如果在函数的内部要想对全局变量进行修改的话，必须使用global关键字进行声明
# 以下两个全局变量

pro='计算机信息管理'
name='naruto'
def Class():
    name='luffy' #局部变量
    print('{},{}'.format(name,pro))
    pass
def changeGlobal():
    '''
    要修改全局变量
    :return:
    '''
    global pro #作用是使下面的变量成为全局变量
    pro='市场营销' #局部变量
    pass
changeGlobal() #必须先调用global函数才能修改全局变量
print(pro) #被修改了吗
Class()
-----------------------------------------------
# 引用
# 1.在python中，万物皆对象，在函数调用的时候，实参传递的就是（对象的引用）
# 2.了解了原理之后，就可以更好的去把控在函数内部的处理是否会影响到函数外部数据变化
# 参数传递是通过对象引用来完成

a=1 #不可变类型
def func(x):
    print('x的地址：{}'.format(id(x)))
    x=2
    print('x的值修改之后的地址{}'.format(id(x)))
    print(x)  #值变为2
    pass
#调用函数
print('a的地址:{}'.format(id(a)))  #输出结果相同，对同一个对象的引用     可以看成a 和x都是两个标签，指向（贴在）了'1'存放的地址上
func(a)
print(a)  #值仍为1

# 可变类型

li=[]
def testRenc(parms):

    li.append([1,3,4,52,67])
    print(id(parms))  #地址没变
    print('内部的{}'.format(parms))
    pass

print(id(li))
testRenc(li)
print('外部的变量对象{}'.format(li))  #数据变了
-----------------------------------------------
# 匿名函数
# 语法：
# lambda  参数1、参数2、参数3：表达式
# 特点
# 使用lambda关键字去创建函数
# 没有名字的函数
# 匿名函数冒号后面的表达式有且只有一个，注意：是表达式，而不是语句
# 匿名函数自带return，而这个return的结果就是表达式计算后的结果

def computer(x,y):
    '''
    计算数据和
    :param x:
    :param y:
    :return:
    '''
    return x+y
    pass
print(computer(10,45))   #普通函数

对应的匿名函数
M=lambda  x,y:x+y
# 通过变量去调用匿名函数
print(M(23,19))

result=lambda a,b,c:a*b*c
print(result(12,34,2))

age=25
print('可以参军' if age>18 else '继续上学') #可以替换传统双分支的写法

funcTest=lambda x,y:x if x>y else y
print(funcTest(2,12))

rs=(lambda x,y:x if x>y else y)(16,12)  #直接调用  第一个括号的内容相当于funcTest
print(rs)
varRs=lambda x:(x**2)+890
print(varRs(10))
#缺点
# lambde只能是单个表达式，不是一个代码块，lambde的设计就是为了满足简单函数的场景，
# 仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def来处理
-----------------------------------------------
# 递归函数
# 递归满足的条件
# 自己调用自己
# 必须有一个明确的结束条件
# 优点：逻辑简单、定义简单
# 缺点：容易导致栈溢出，内存资源紧张，甚至内存泄漏
# 求阶乘
# 循环的方法去实现

# def jiecheng(n):
#     result=1
#     for item in range(1,n+1):
#         result*=item
#         pass
#     return result
# print('5的阶乘{}'.format(jiecheng(5)))

# 递归方式去实现

# def diguiJc(n):
#     '''
#     递归实现
#     :param n: 阶乘参数
#     :return:
#     '''
#     if n==1:
#         return 1
#     else:
#         return n*diguiJc(n-1)
#     pass
#
# # 递归调用
# diguiJc(5)
# print('5的阶乘{}'.format(diguiJc(5)))

# 递归案例 模拟实现 树形结构的遍历 (拓展)
import os #引入文件操作模块
def findFile(file_Path):
    listRs=os.listdir(file_Path) #得到该路径下所有的文件夹
    for fileItem in listRs:
        full_path=os.path.join(file_Path,fileItem) #获取完整的文件路径
        if os.path.isdir(full_path):#判断是否是文件夹
           findFile(full_path) #如果是一个文件夹，再次去递归
        else:
            print(fileItem)
            pass
        pass
    else:
        return

# 调用搜索文件夹对象
findFile('D:\\arcgis')
-----------------------------------------------
# 内置函数

# 取绝对值
# print(abs(-34))
# # round  取近似值
# print(round(3.66))
# print(round(3.66,1))  #保留一位
# # pow 求次方
# print(3**3)
# print(pow(3,3))
# 求最大值
print(max([23,123,34,4,5,1,3232,534]))   #给列表
print(max(23,235))

#sum使用
print(sum(range(50),3))  #全部相加完加3

#eval 执行表达式
a,b,c=1,2,3
print('动态执行的函数{}'.format(eval('a*b+c-30')))  #eval可以简单理解为表达式函数，作用是返回传入字符串的表达式的结果
def TestFun():
    print('我执行了吗？')
    pass
eval('TestFun()') #可以调用函数执行
-----------------------------------------------
# 类型转换
# print(bin(10)) #转换二进制    0b开头二进制
# print(hex(23)) #十六进制

#元组转换为列表
tup=(1,2,3,4)  #元组类型，定义后不可修改
li=list(tup) #强制转换
print(li)
li.append([5,6,7,8])
print(li)

tupList=tuple(li)  #又转回元组了

# 字典操作 dict()
#
# dic=dict()
# print(type(dic))
# dic['name']='小明'
# dic['age']=18     #注意，是dic追加，不是dict追加
# print(dic)

# bytes转换  bytes()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<=x<256
print(bytes('我喜欢python',encoding='UTF-8'))
-----------------------------------------------
# 序列操作 str 元组、列表
# all()   结果为bool类型 对象中的元素除了是0、空、FALSE外都算TRUE  所有的元素都为TRUE才为TRUE
# print(all([]))  #空列表  为TRUE
# print(all(()))  #空元组  TRUE
# print(all([1,2,4,False])) #有FALSE出现
# print(all((3,4,0)))  #有0  为FALSE

# any 类似于逻辑运算符 or的判断 ，只要有TRUE的元素，结果就位TRUE
print("--------------any-------------")
print(any((3,4,0)))   为TRUE 
print(any(('',0,False)))  为FALSE
-----------------------------------------------
#enumerate函数  增加索引 用在for循环中
listObj=['a','b','c']
for item in enumerate(listObj):
    print(item)

listObj=['a','b','c']
for index,item in enumerate(listObj,5):  #从5开始
    print(index,item)
    pass

dicObj={}
dicObj['name']='李易峰'
dicObj['hobby']='唱歌'
dicObj['pro']='艺术设计'
print(dicObj)

for item in enumerate(dicObj):
    print(item)
-----------------------------------------------
# set 不支持索引和切片，是一个无序的且不重复的容器，类似于字典 #类似于字典 但是只有key 没有value
#创建集合
set1={123,3,345}

# print(type(set1))
# dic1={}
# print(type(dic1))
set2={2,3,4}
# #添加操作
#
# # set1.add('python')
# # print(set1)
# # #情空操作
# # set1.clear()
# # print(set1)
#
# #差集操作
# # rs=set1.difference(set2)
# # print(rs)
# # print(set1-set2)
#
# #交集操作
# m=set1.intersection(set2)
# print(m)
# print(set1&set2)
#
# #并集操作
# n=set1.union(set2)
# print(n)
# print(set1 | set2)
#
# # pop 就是从集合中拿数据并且同时删除
# print(set1)
# x=set1.pop()
# print(x)
# print(set1)
#
# set1.discard(3) #指定移除的元素
# print(set1)

#update 两个集合
set1.update(set2)
print(set1)
-----------------------------------------------
# 求三组连续自然数的和：求出1到10、20到30和35到45的三个和
# def sumRange(m,n):
#     '''
#     求从m到n的连续自然数的总和
#     :param m: 开始值 int
#     :param n: 结束值 int
#     :return:
#     '''
#     return sum(range(m,n+1))
#     pass
#
# print(sumRange(1,10))
# print(sumRange(20,30))
# print(sumRange(35,45))
# # 100个和尚吃100个馒头，大和尚一人吃3个馒头，小和尚三人吃一个馒头。请问大小和尚各多少人？
# def PersonCount():
#     '''
#     计算各有多少个和尚
#     假设大和尚a  小和尚100-a
#     :return:
#     '''
#     for a in range(1,101):
#         if a*3+(100-a)*(1/3)==100:
#             #100个和尚吃100个馒头
#             return(a,100-a)
#         pass
#     pass
#
# rsObj=PersonCount()
# print('大和尚{}人  小和尚{}人'.format(rsObj[0],rsObj[1]))

# 指定一个列表，列表里含有唯一一个只出现过一次的数字。写程序找出这个“独一无二”的数字
li=[1,3,4,3,3,5,2,4,2,5,2]
set1=set(li)
# print(set1)
for i in set1:
    li.remove(i)
    pass
set2=set(li) #set2中为原来li中有重复的数字集合
for i in set1: #set1中数据全部去重后形成的集合
    if i not in set2:
        print(i)
        pass
    pass
pass

# 方法二：
li=[1,3,4,3,3,5,2,4,2,5,2]
set1=set(li)
# print(set1)
for i in set1:
    li.remove(i)
    pass
set2=set(li) #set2中为原来li中有重复的数字集合
m=set1-set2
print(m)