if语句来实现分支结构，主要有五种语法结构
#第一种if2+3==5:print("True")TrueIn[28]:#第二种if"小甲鱼"=="小姐姐":print("小甲鱼是小姐姐")else:print("小甲鱼不是小姐姐")小甲鱼不是小姐姐In[29]:#第三种score=input("请输入你的分数：")score=int(score)if0<=score<60:print("D")elif60<=score<80:print("C")elif80<=score<90:print("B")elif90<=score<100:print("A")elifscore==100:print("S")请输入你的分数：95AIn[30]:#第四种score=input("请输入你的分数：")score=int(score)if0<=score<60:print("D")elif60<=score<80:print("C")elif80<=score<90:print("B")elif90<=score<100:print("A")elifscore==100:print("S")else:print("请输入一个合法的分数")请输入你的分数：101请输入一个合法的分数In[31]:#第五种#第五种比较炫酷，语法格式为：条件成立时执行的语句ifconditionselse条件不成立时执行的语句age=16print("未满18岁禁止访问")ifage<18elseprint("欢迎~")未满18岁禁止访问除此之外，条件语句if也支持嵌套
#循环里面的else语句，当循环语句不再为真时，就执行else语句里面的内容i=1whilei<5:print("循环里i的值为",i)ifi==2:breaki+=1else:print("循环外i的值为",i)#这里不会执行else里面的内容，因为跳出循环时，条件仍为真循环里i的值为1循环里i的值为2In[34]:i=1whilei<5:print("循环里i的值为",i)i+=1else:print("循环外i的值为",i)#当循环语句不再为真时，就执行else语句里面的内容循环里i的值为1循环里i的值为2循环里i的值为3循环里i的值为4循环外i的值为5else实质性的作用是：可以非常容易的检测循环的退出状况
x="python"y="python"xisyOut[57]:TrueIn[58]:x=[1,2,3]y=[1,2,3]xisyOut[58]:False之所以会出现上面这种情况，是因为python对于不同对象的存储机制是不同的
x=[1,2,3]y=x#以后对x操作，y也会产生同样的变化，这就是引用，x和y都指向同一个对象浅拷贝：
#前面说到浅拷贝：列表的copy()方法或者切片操作x=[1,2,3]y=x.copy()#等价于y=x[:]#这时x与y是独立的，copy()方法拷贝的是整个列表对象，而不仅仅是对象的引用#但是仅仅是在一维列表的时候不会出现问题，当出现嵌套列表时浅拷贝的问题就出现了#浅拷贝还有第三种实现方式：调用copy模块的copy()函数#以上代码还等价于：#importcopy#y=copy.copy(x)In[69]:importcopyx=[[1,2,3],[4,5,6],[7,8,9]]y=copy.copy(x)x[1][1]=0#此时y会随着x的改变而改变，这是因为浅拷贝只是拷贝了外层对象，如果包含嵌套对象，那么拷贝的只是其引用深拷贝：
#1.startswith(prefix,start,end)方法，用于判断prefix指定的子字符串是否出现在原字符串的起始位置#start，end用于指定开始和结束匹配的位置x="我爱python"print(x.startswith("我"))#2.endswith(suffix,start,end)方法，用于判断suffix指定的子字符串是否出现在原字符串的结束位置print(x.endswith("python"))#除此之外，这两个方法的第一个参数还支持以元组的方式传入，表示多个待匹配参数x="她爱python"ifx.startswith(("你","我","她")):print("匹配成功")TrueTrue匹配成功判断字符串构成的方法
#1.isdecimal()方法#2.isdigit()方法e="22"可以判断为True#3.isnumeric()方法#以上三个方法都是判断字符串是否由数字构成，只是有的时候尺度不同，isnumeric()方法尺度很大a="12345"b="一二三四五"c="ⅠⅡⅢⅣⅤ"d="壹贰叁肆伍"e="22"print(a.isnumeric())print(b.isnumeric())print(c.isnumeric())print(d.isnumeric())print(e.isnumeric())TrueTrueTrueTrueTrue一个集大成者
#isalnum()方法，只要isalpha()、isdecimal()、isdigit()和isnumeric()方法任意一个返回True，它就返回True判断一个字符串是否为一个合法的python标识符，以及判断是否为python的关键字
1.align有四个可选参数，<强制字符串在可用空间内左对齐，>强制字符串在可用空间内右对齐，^强制字符串在可用空间内居中，=强制将填充放置在符号之后数字之前（这适合以"+00000520"的形式打印字符串）
2.width前面的0表示为数字类型启用感知正负号的0填充效果，当format后面的参数是字符串的时候会报错
3.fill用于指定填充符号
4.符号类型sign，这个选项仅对数字类型有效，有三个值：'+'在正数前添加正号，负数前添加负号；'-'只在负数前添加负号，默认行为；'空格'在正数前添加空格，负数前添加负号
5.grouping_option千分位分割符，仅对数字类型有效
6..precision精度，对于不同类型的参数，它的效果是不一样的。如果是f类型的浮点数，是限定小数位后显示多少数位；如果是g类型的浮点数，是限定小数点前后一共显示多少位数；对于非数字类型，限定最大字段的大小；对于整型数据，不允许使用这个选项
7.type类型，b将参数以二进制形式输出；c将参数以Unicode字符形式输出；d将参数以十进制形式输出；o将参数以八进制形式输出；x和X将参数以十六进制形式输出；n跟d类似不同之处在于它会使用当前语言环境设置的分隔符插入到适合的位置；none跟d一样；e和E将参数以科学计数法的形式输出；f和F将参数以定点表示法的形式输出（默认为6精度）；g和G小数以f形式输出、大数以e形式输出；%将参数以%形式输出（默认精度为6个小数位）
8.#选项作用：参数以二进制、八进制、十六进制输出时，它会自动追加一共前缀
#1.都可以通过索引获取元素#2.第一个元素的索引下标都为0#3.都可以通过切片来获取一个范围#4.都有许多共同的运算符共同运算符：+和*，加号表示拼接，乘号表示重复
拓展一下：1.id()用于查看一个对象的id值，内存中每一个对象都有一个唯一的标识符叫id，对象都有三个部分组成：id、类型和值2.is和isnot运算符，判断两个对象是否为同一个id。3.in和notin运算符，判断的是包含问题，判断某个元素是否包含着某个序列内。4.del语句用于删除一个指定的对象、还可以删除可变序列中的指定元素
2.min()、max()函数，返回最小或者最大值，有一个default参数，当传入一个空对象时，返回default指定的值，而不是报错
4.sum(start)函数，求和。start参数指定求和计算的初始值
x=[1,2,3,4,5]print(sum(x,start=10))255.sorted()函数，注意区别列表的sort()方法！此外sorted()函数还支持两个参数，key(可以指定key为一个函数的名称，进而指定排序的方法)，reverse(默认为False，执行从小到大)
x=[1,2,5,8,0]reversed(x)Out[59]:
8.enumerate()函数用于返回一个枚举对象，它的功能是将可迭代对象中的每一个元素及从0开始的序号，共同构成一个二元组的列表。注意得到的是一个枚举对象，要通过list()函数转化一下。还有一个start参数的值用于指定序号开始的值。
mapped=map(ord,"FishC")list(mapped)Out[69]:[70,105,115,104,67]In[71]:#如果指定的函数需要多个参数，我们只需对应的修改后面提供的可迭代对象的数量即可mapped=map(pow,[1,2,3],[1,2,3])list(mapped)Out[71]:[1,4,27]In[72]:#如果后面提供的几个可迭代对象的长度不一致，会以短的为准mapped=map(pow,[1,2,3,4],[1,2,3,4,5])list(mapped)Out[72]:[1,4,27,256]11.filter()函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的函数，以迭代器的形式返回
经典的字典的创建方式是：dict={键1:值1,键2:值2...}
后续通过指定一个不存在于字典中的键，就可以创建新的键值对了
由上可知，集合是不能嵌套的，因为集合也是一个可变的容器，它是不可哈希的。但是如果硬要实现集合的嵌套，只能使用frozenset了。
写一个最简单的函数
同样的也有限制只能使用关键字参数的语法，那就是*，星号左侧既可以是位置参数也可以是关键字参数，星号右侧只能是关键字参数
deffunc(*args,a,b):print(args,a,b)#func(1,2,3,4,5)会报错，说参数不足，实际上这5个参数都被收集参数吃掉了，所以才参数不足#正确的做法func(1,2,3,a=4,b=5)(1,2,3)45知识拓展1：上面星号分割参数列表的本质
#星号左侧既可以是位置参数也可以是关键字参数，星号右侧只能是关键字参数deffunc(a,*,b,c):print(a,b,c)#本质上说，这个*是一个匿名的收集参数知识拓展2：除了将参数打包成元组，收集参数其实还可以将参数打包成字典，做法就是使用两个连续的星号。对于这种情况在传递参数的时候就必须要使用关键字参数了。
2.全局作用域，定义在函数外部的变量，函数内部可以访问到。但是如果函数内部出现一个同名的局部变量就会发生覆盖，导致两个变量的id不一样，函数内部修改这个局部变量，函数外部的全局变量不发生改变。
#示例如下：x=880deffunc():x=520print(id(x))func()print(x)print(id(x))27105285730408802710528570352In[2]:x=880deffunc():print(id(x))func()print(id(x))27105285733922710528573392global语句允许在函数内部修改全局变量的值，示例如下：
x=880deffunc():globalxx=520print(x)func()print(x)#尽管有global语句，但是也不提倡经常使用，因为在函数中去肆意修改全局变量的值有时候会造成难以排查的bug5205203.嵌套函数
deffunA():x=880deffunB():print(x)funB()funA()880如何做到不通过funA()而调用到funB()函数呢？答案如下：
deffunA():x=880deffunB():print(x)returnfunB#注意将函数作为返回值或者参数的时候是不需要小括号的，只有函数定义或调用的时候才需要小括号funny=funA()funny()#这两行代码等价于funA()()880这就是闭包，闭包可以做很多事情，比如：利用闭包可以做函数加工厂，示例如下：
defpower(exp):defexp_of(base):returnbase**expreturnexp_ofsquare=power(2)cube=power(3)print(square(10))print(cube(5))100125闭包配合nonlocal语句还能实现角色移动的小游戏，示例如下：
我们利用内层函数能够记住外层函数作用域这个特性，并且使用nonlocal语句，让它可以修改外层函数作用域里面的变量，就可以实现一个带记忆功能的函数。
importtimedeftime_master(func):defcall_func():print("开始运行程序")start=time.time()func()print("结束运行程序")end=time.time()print(f"程序运行了{(end-start):.2f}秒")returncall_func#装饰器的语法糖#它的作用是在调用myfunc()的时候并不是直接调用myfunc()，而是把myfunc作为参数传入装饰器中，将返回的结果赋值给myfunc@time_masterdefmyfunc():time.sleep(2)print("hello")myfunc()开始运行程序hello结束运行程序程序运行了2.00秒In[23]:#上面是装饰器的语法糖，下面写出它的本质importtimedeftime_master(func):defcall_func():print("开始运行程序")start=time.time()func()print("结束运行程序")end=time.time()print(f"程序运行了{(end-start):.2f}秒")returncall_funcdefmyfunc():time.sleep(2)print("hello")myfunc=time_master(myfunc)myfunc()开始运行程序hello结束运行程序程序运行了2.01秒多个装饰器可以用在同一个函数上
defadd(func):definner():x=func()returnx+1returninnerdefcube(func):definner():x=func()returnx*x*xreturninnerdefsquare(func):definner():x=func()returnx*xreturninner@add@cube@square#顺序是从下到上deftest():return2print(test())65In[26]:#上面例子的本质是：defadd(func):definner():x=func()returnx+1returninnerdefcube(func):definner():x=func()returnx*x*xreturninnerdefsquare(func):definner():x=func()returnx*xreturninnerdeftest():return2test=square(test)test=cube(test)test=add(test)print(test())65进阶知识：如何给装饰器传递参数？
与没有参数的装饰器相比，有参数的装饰器只是多了一次参数的调用
冒号左边是传入的参数，冒号右边是返回值的表达式
#利用lambda来写传统的求平方函数square=lambdax:x*xsquare(6)Out[29]:36与传统方式定义的函数不同的是，lambda是一个表达式，可以放在传统函数不可能存在的地方，比如列表里面。
y=[lambdax:x*x,2,3]y[0](y[1])Out[30]:4In[31]:mapped=map(lambdax:ord(x),"FishC")list(mapped)Out[31]:[70,105,115,104,67]一般来说，lambda表达式通常用于实现一些简单的功能，而要想定制功能复杂的函数还得依靠传统方式。
下面给出递归函数的几个实例：
#递归函数实现求一个数的阶乘deffactRecur(n):ifn==1:return1else:returnn*factRecur(n-1)factRecur(5)Out[5]:120In[6]:#递归函数求斐波那契数列的第n项deffibRecur(n):ifn==1orn==2:return1else:returnfibRecur(n-1)+fibRecur(n-2)fibRecur(12)Out[6]:144我们发现：递归的实现逻辑跟文字描述是非常类似的。递归的实现方式非常优雅、实现逻辑非常简单，但要注意退出递归的条件，防止出现无限递归的现象。
另外：每一次调用递归函数，它并不会立刻返回而是等到最底层的那个函数返回，它才会一层一层往上走，这个过程是十分耗费资源的。递归的好处就在于它有着更加简单的实现逻辑，写代码可以偷懒，但是效率不如迭代。
下面举几个其他高阶函数的例子（它们都来自functools模块）：
1.reduce()函数
#reduce()函数，时代的眼泪，python3之后functools模块收留了它importfunctoolsdefadd(x,y):returnx+yfunctools.reduce(add,[1,2,3,4,5])#第一个参数是一个函数名，第二个参数是一个可迭代对象#它做的事是，把可迭代对象的每一个元素依次传入参数指定的这个函数，最终返回累计结果Out[25]:15In[26]:#它做的事相当于add(add(add(add(1,2),3),4),5)Out[26]:15In[27]:functools.reduce(lambdax,y:x*y,range(1,6))Out[27]:1202.偏函数
#与闭包类似square=functools.partial(pow,exp=2)square(5)Out[29]:25In[30]:cube=functools.partial(pow,exp=3)cube(5)Out[30]:1253.@wraps装饰器
所谓python对象序列化就是将python对象转换为二进制字节流的过程。主要用了dump和load两个函数。示例如下：
#raiseValueError("值不正确！")，直接抛出一个ValueError类型的异常#注意不能用raise去生成一个不存在的异常2.assert语句产生异常
#注意assert语句只能引发AssertionError类型的异常#通常用于代码调试s="FishC"asserts=="FishC"#asserts!="FishC"#如果assert后面这个条件成立的话，啥事不会发生，否则抛出一个AssertionError类型的异常产生异常有什么用呢？其实用异常可以产生goto语句的效果，在多个嵌套循环的语句里一下跳出来。
classC:a=1b=2defsay_hello(self):print("hello")c=C()#实例化一个对象出来In[77]:c.aOut[77]:1In[78]:c.say_hello()helloIn[79]:c.d=4#可以动态的去添加属性print(c.d)4self是什么？为什么将一个函数放到类里面，就必须要加上一个参数self呢？如果没有加这个self会发生什么呢？
classC:defget_self(self):print(self)c=C()c.get_self()<__main__.Cobjectat0x0000020E26634430>In[81]:print(c)<__main__.Cobjectat0x0000020E26634430>如果没有加self在调用的时候，会报一个错误，说函数定义的时候没有参数，但是调用的时候却硬塞了一个给它。通过上面的代码，可以知道，这个硬塞给它的参数就是self，这个self其实就是类C的实例化对象c，这样我们就知道传递给方法的就是实例对象本身。
self的意义是：同一个类可以生成无数个对象，当我们调用类里面的一个方法时，python要通过这个self知道是哪一个对象在调用它，所以类中的每一个方法，默认的第一个参数都是self。
self使得实例对象与类里面的方法进行了绑定，类的实例对象有千千万，但是这些对象却是共享类里面的方法。所以当我们在调用c.get_self()的时候，其实际上的含义是调用类C的get_self()方法，并把实例对象c作为参数传递。
#相当于C.get_self(c)实例对象的方法是共享的，但是属性却是自己的。可以通过__dict__内省的方法查看属性。
isinstance(b,B)Out[85]:TrueIn[86]:isinstance(b,A)#子类实例化对象，也是属于其父类的Out[86]:True2.判断一个类是否为另一个类的子类，使用issubclass()函数
classC:def__init__(self,x,y):self.x=xself.y=ydefadd(self):returnself.x+self.ydefmul(self):returnself.x*self.yclassD(C):def__init__(self,x,y,z):C.__init__(self,x,y)#直接调用类C的构造函数，这种直接通过类名调用类里面的方法称为调用未绑定的父类方法self.z=zdefadd(self):returnself.x+self.y+self.zdefmul(self):returnself.x*self.y*self.zd=D(3,4,5)print(d.add())print(d.mul())1260In[9]:#这种直接通过类名调用类里面的方法称为调用未绑定的父类方法#这种方式有时候可能会出现钻石继承#示例如下：classA:def__init__(self):print("哈喽，我是A")classB1(A):def__init__(self):A.__init__(self)print("哈喽，我是B1")classB2(A):def__init__(self):A.__init__(self)print("哈喽，我是B2")classC(B1,B2):def__init__(self):B1.__init__(self)B2.__init__(self)print("哈喽，我是C")c=C()哈喽，我是A哈喽，我是B1哈喽，我是A哈喽，我是B2哈喽，我是C解决的办法是super()函数，super()函数能够在父类中搜索指定的方法，并自动绑定号self参数
拓展知识：什么是MRO顺序？M-method、R-resolution、O-order，方法解析顺序
c._C__xOut[38]:250In[39]:#方法也是同样道理classD:def__func(self):print("Ilovepython.")d=D()#d.__func()是不能调用到其方法的d._D__func()Ilovepython.在对象诞生之后，不能通过动态添加属性的方式添加一个私有变量，名字改编是发生在类实例化对象的时候。
python为了对象的灵活性有时候会牺牲大量的存储空间，比如动态添加属性这个特性。动态添加属性，背后的实现原理是字典，就是我们熟悉的__dict__属性。
拓展知识：继承自父类的slots属性是不会在子类中生效的。
对象诞生时调用的第一个方法是new，它的参数是一个类，先调用new产生一个实例，再将实例传给init。
classC:def__init__(self):print("我来了")def__del__(self):print("我走了")c=C()delc我来了我走了In[53]:#要注意的是，并不是调用del一定会触发del魔法方法，调用del方法一定是对象被销毁的时候#python是垃圾回收机制，当检测到一个对象没有任何引用的时候就销毁对象c=C()d=cdelc我来了In[54]:deld#这才真正的销毁了对象我走了拓展知识：烧脑子环节，利用del魔法方法实现对象的重生，有两种方法可以实现：1.全局变量；2.闭包