不进行换行输出：
复制代码隐藏代码print(r'hello\nworld')注意事项：最后一个字符不能是反斜杠\，但是是两个\\可以。
复制代码隐藏代码010000011024byte=1kB；1024kB=1MB；
1024MB=1GB；1024GB=1TB.
二进制0，1→ASCII→GB2312→GB18030→Unicode→UTF-8
复制代码隐藏代码#汉字“乘”与进制数的转换print(chr(0b100111001011000))#0b代表二进制print(ord('乘'))#得到'乘'所代表的十进制数2.标识符和保留字有一些单词被赋予了特定的意义，这些单词在用户给任何对象起名字的时候不允许使用。
复制代码隐藏代码importkeywordprint(keyword.kwlist)#查看所有的保留字标识符是指变量、函数、类、模块和其他对象的名字。
其规则是：
变量是内存中一个带标签的盒子。下例中，name表示变量名，=是复制运算符，玛丽亚是值。
复制代码隐藏代码name='玛丽亚'print(name)print('标识',id(name))print('类型',type(name))print('值',name)变量由三部分组成：
当多次复制后，变量名会指向新的空间，旧的空间称为内存垃圾。
复制代码隐藏代码name='玛丽亚'print(name)name='楚留冰'print(name)4.常用的数据类型常用的数据类型：
其中present是变量，=是赋值运算符，将输入函数的结果赋值给变量present，input函数是一个输入函数，需要输入回答。
复制代码隐藏代码#输入函数inputpresent=input('大圣想要什么礼物呢？')print(present,type(present))#要求从键盘录入两个整数，计算两个整数的和a=input('请输入一个加数：')a=int(a)b=input('请输入另一个加数：')b=int(b)print(type(a),type(b))print(a+b)#对str类型的两个量进行连接,对int类型的两个量进行计算2.Python中的运算符算术运算符（标准算术运算符，取余运算符，幂运算符）
复制代码隐藏代码print(1+1)#加法运算print(1-1)#减法运算print(2*4)#乘法运算print(11/2)#除法运算print(11//2)#整除运算print(11%2)#取余运算print(2**3)#幂运算，2的3次方#一正一负整除运算向下取整print(9//4)#2print(-9//-4)#2print(9//-4)#-3print(-9//4)#-3#一正一负取余运算公式:余数=被除数-除数*商print(9%-4)#9-(-4)*(-3)=-3print(-9%4)#-9-4*(-3)=3赋值运算符=
复制代码隐藏代码#赋值运算符i=3+4print(i)#运算顺序从右到左a=b=c=20#链式赋值print(a,id(a))print(b,id(b))print(c,id(c))print('---支持参数赋值---')a=20a+=30#相当于a=a+30print(a)a-=10print(a)a*=2print(a)#int类型print(type(a))a/=3print(a)print(type(a))#floata//=2print(a)print(type(a))a%=3print(a)print('---解包赋值---')a,b,c=20,30,40print(a,b,c)print('---交换两个变量的值---'')a,b=10,20print('交换之前：',a,b)a,b=b,a#交换print('交换之后：',a,b)3.比较运算符比较运算符对变量或表达式的结果进行大小、真假等比较。
复制代码隐藏代码a,b=10,20print('a>b吗？',a>b)#Falseprint('a
复制代码隐藏代码#布尔运算符a,b=1,2print('----and----')print(a==1andb==2)#TrueandTrue-->Trueprint(a==1andb<2)#TrueandFalse-->Falseprint(a!=1andb==2)#FalseandTrue-->Falseprint(a!=1andb!=2)#FalseandFalse-->Falseprint('----or----')print(a==1orb==2)print(a==1orb<2)print(a!=1orb==2)print(a!=1orb!=2)print('----not-----')f=Truef2=Falseprint(notf)print(notf2)print('----in与notin------')s='helloworld'print('w'ins)print('k'ins)print('w'notins)print('k'notins)5.位运算符位运算符将数据转换成二进制进行计算。
*,/,//,%+,-<<,>>&|>,<,>=,<=,==,!=andor=
算术→位→比较（TrueFalse）→布尔→赋值=
任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。
程序从上到下顺序地执行代码，中间没有任何地判断和跳转，直到程序结束。
复制代码隐藏代码'''把大象装冰箱一共分几步'''print('-------程序开始--------')print('1.把冰箱门打开')print('2.把大象放到冰箱里')print('3.把冰箱门关上')print('------程序结束---------')3.对象的布尔值Python一切皆对象，所有对象都有一个布尔值，获取对象地布尔值使用内置函数bool()
以下对象地布尔值为False
复制代码隐藏代码#测试对象地布尔值print('----------布尔值均为False---------')print(bool(False))print(bool(0))print(bool(0,0))print(bool(None))print(bool(''))print(bool(""))print(bool([]))#空列表print(bool(list()))#空列表print(bool(()))#空元组print(bool(tuple()))#空元组print(bool({}))#空字典print(bool(dict()))#空字典print(bool(set()))#空集合print('------------布尔值为True-------------')print(bool(18))print(bool(True))print(bool('helloworld'))4.选择结构程序根据判断条件地布尔值选择性地执行部分代码，明确地让计算机知道在什么条件下该去做什么。
运算规则：如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为False。
复制代码隐藏代码'''从键盘录入两个整数，比较两个整数的大小'''num_a=int(input('请输入第一个整数：'))num_b=int(input('请输入第二个整数：'))#比较大小ifnum_a>=num_b:print(num_a,'大于等于',num_b)else:print(num_a,'小于',num_b)print('---------使用条件表达式进行比较-------------')print((str(num_a)+'大于等于'+str(num_b))ifnum_a>=num_belsestr(num_a)+'小于'+str(num_b))5.pass空语句语句什么都不做，只是一个占位符，用在语法上需要语句的地方。
复制代码隐藏代码#pass语句answer=input(‘您是会员吗？y/n’)ifanswer=='y':passelse:pass六、转圈圈1.range()函数的使用range()函数用于生成一个整数序列，其返回值是一个迭代器对象。
创建range对象的三种方式：
复制代码隐藏代码#range的三种创建方式'''第一种创建方式，只有一个参数'''r=range(10)#[0123456789]默认从0开始，步长为1print(r)print(list(r))#用于查看range对象中的整数序列--list是列表函数'''第二种创建方式，括号里给了两个参数'''r=range(1,10)#指定了起始值和终止值，区间左闭右开[1,10)print(list(r))'''第三种创建方式，括号里给出三个参数'''r=range(1,10,2)print(list(r))'''判断指定的整数在序列中是否存在in，notin'''print(10inr)print(9inr)print(10notinr)print(9notinr)print(range(1,20,1))print(range(1,101,1))#未使用时，上下两个所占内存一样2.循环结构循环时反复作同一件事情的情况，用于次数不固定的循环，初始条件不成立，一次都不执行。
复制代码隐藏代码a=1#判断条件表达式ifa<10:#if改为while重新运行，结果是123456789print(a)a+=1#if与while的区别是：if判断一次，条件True执行一行；while是判断N+1次，条件是True执行N次四步循环法：
复制代码隐藏代码#计算0到4的累加和sum=0#用于存储累加和'''初始化变量为0'''a=0'''条件判断'''whilea<5:'''条件执行体（循环体）'''sum+=a'''改变变量'''a+=1print('和为',sum)复制代码隐藏代码'''计算1到100之间的偶数和'''sum=0#用于存储偶数和a=1#初始化变量whilea<=100#条件判断#条件执行体（求和）ifa%2==0:#ifnotbool(a%2):意味着0的布尔值为Falsesum+=aa+=1print('1到100的偶数和',sum)（2）for-in循环语法结构为：for自定义的变量in可迭代对象循环体
复制代码隐藏代码foritemin'Python'#第一次取出来的是P，赋值给item，输出print(item)#range()产生一个整数序列，也是一个可迭代对象foriinrange(10)print(i)#如果在循环体中不需要使用自定义变量，可将自定义变量写为_for_inrange(5)print('人生苦短，我用Python')'''使用for循环计算1到100之间的偶数和'''sum=0foriteminrange(1,101):ifitem%2==0:sum+=itemprint('1到100之间的偶数和为：',sum)复制代码隐藏代码'''输出100到999之间的水仙花数举例153=3*3*3+5*5*51*1*1'''foriteminrange(100,1000):ge=item%10shi=item//10%10bai=item//100print(bai,shi,ge)ifge**3+shi**3+bai**3==item:print(item)（3）break、continue与else语句break语句用于结束循环结构，通常与分支结构if一起使用
复制代码隐藏代码'''从键盘录入密码，最多录入三次，如果正确就结束循环'''foriteminrange(3):pwd=input('请输入四位数密码：')ifpwd=='8888'；print('密码正确')breakelse:print('密码不正确')复制代码隐藏代码a=0whilea<3:pwd=input('请输入四位数密码：')#条件执行体ifpwd=='8888':print('密码正确')breakelse:print('密码不正确')a+=1#改变变量continue语句用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用
复制代码隐藏代码'''要求输出1到50之间所有5的倍数：和5的余数为0的数什么样的数不是5的倍数？与5的余数不是0的数'''foriteminrange(1,51):ifitem%5==0:print(item)print('----------使用continue----------')foriteminrange(1,51):ifitem%5!=0:continueprint(item)else语句与其他语句配合使用。与if配合使用，if条件表达式不成立时执行else；与for和while配合使用时，没有碰到break时执行else。
复制代码隐藏代码foriteminrange(3):pwd=input('请输入密码：')ifpwd=='8888':print('密码正确')breakelse:print('密码不正确')else:print('对不起，三次密码均输入错误。')复制代码隐藏代码a=0whilea<3；ifpwd=='8888':print('密码正确')breakelse:print('密码不正确')'''改变变量'''a+=1else:print('对不起，三次密码均输入错误')3.嵌套循环嵌套循环时循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行。
复制代码隐藏代码'''流程控制语句break与continue在二重循环中的使用'''foriinrange(5):#外层循环执行5次forjinrange(1，11):ifj%2==0:break#continueprint(j)#print(j,end='\t')#print()七、一字排开为什么需要列表？
什么是字典？Python内置的数据结构之一，与列表一样是一个可变序列；以键值对的方式存储数据，字典是一个无序的序列。
字典的实现原理：字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python中的字典是根据key查找Value所在的位置。
复制代码隐藏代码'''key的判断'''scores={'张三':100,'李四':98,'王五':45}print('张三'inscores)print('张三'notinscores)delscores['张三']#删除指定的key-value对#scores.clear()#清空字典元素print(scores)scores['陈六']=98#新增元素print(scores)scores['陈六']=100#修改元素print(scores)获取字典视图的三个方法：keys、values、items
复制代码隐藏代码scores={'张三':100,'李四':98,'王五':45}#获取所有的keykeys=scores.keys()print(keys)print(type(keys))print(list(keys))#将所有的key组成的视图转成列表#获取所有的Valuevalues=scores.values()print(values)print(type(values))print(list(values))#获取所有的key-value对items=scores.items()print(items)print(list(items))#转换之后的列表元素为元组复制代码隐藏代码#字典元素的遍历scores={'张三':100,'李四':98,'王五':45}foriteminscores:print(item,scores[item],scores.get(item))4.字典的特点复制代码隐藏代码d={'name':'张三','name':'李四'}print(d)d={'name':'张三','nikename':'张三'}print(d)5.字典生成式内置函数zip():用于将可迭代对象作为参数，将对象中对应地元素打包成一个元组，然后返回由这些元组组成的列表
不可变序列与可变序列:
复制代码隐藏代码'''集合的数学操作'''#交集s1={10,20,30,40}s2={20,30,40,50,60}print(s1.intersection(s2))print(s1&s2)print(s1)print(s2)#并集print(s1.union(s2))print(s1|s2)print(s1)print(s2)#差集print(s1.difference(s2))print(s1-s2)print(s1)print(s2)#对称差集print(s1.symmetric_difference(s2))print(s1^s2)（4）集合生成式复制代码隐藏代码'''列表生成式'''lst=[i*iforiinrange(10)]print(lst)'''集合生成式'''s={i*iforiinrange(10)}print(s)3.列表、字典、元组、集合总结数据结构是否可变是否重复是否有序定义符号列表(list)可变可重复有序[]元组(tuple)不可变可重复有序()字典(dict)可变key不可重复，value可重复无序{key:value}集合(set)可变不可重复无序{}十、一串连一串1.字符串的驻留机制字符串：在Python中是基本数据类型，是一个不可变的字符序列。
字符串的驻留机制：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。
复制代码隐藏代码'''字符串的驻留机制'''a='Python'b="Python"c='''Python'''print(a,id(a))print(b,id(b))print(c,id(c))驻留机制的几种情况（交互模式）：
复制代码隐藏代码s1=''s2=''s1iss2s1='%'s2='%'s1iss2s1='abc%'s2='abc%'s1==s2s1iss2id(s1)id(s2)s1='abcx's2='abcx's1iss2id(s1)id(s2)a='abc'b='ab'+'c'c=''.join(['ab','c'])aisbaiscctype(c)atype(a)a=-5b=-5aisba=-6b=-6aisbimportsysa='abc%'b='abc%'aisba=sys.intern(b)aisbsys中的intern方法强制2个字符串指向同一个对象
PyCharm对字符串进行了优化处理
字符串驻留机制的优缺点：
indexrindexfindrfind
复制代码隐藏代码s='hello,hello'#index查找子串第一次出现的位置，如果查找子串不存在，抛出ValueErrorprint(s,index('lo'))#3#查找子串第一次出现的位置，如果查找子串不存在，则返回-1print(s,find('lo'))#3#查找子串最后一次出现的位置，如果查找子串不存在，抛出ValueErrorprint(s,rindex('lo'))#9#查找子串最后一次出现的位置，如果查找子串不存在，则返回-1print(s,rfind('lo'))#9#print(s,index('k'))#ValueErrorprint(s,find('k'))#-1#print(s,rindex('k'))print(s,rfind('k'))-11-10-9-8-7-6-5-4-3-2-1hello,hello012345678910（2）字符串的大小写转换操作upperlowerswapcasecaplitalizetitle
复制代码隐藏代码'''字符串中的转换'''s='hello,python'a=s.upper()#全部转换大写，产生一个新的字符串对象print(a,id(a))print(s,id(s))b=s.lower()#全部转换小写，产生一个新的字符串对象print(b,id(b))print(s,id(s))print(b==s)print(biss)#Falses2='hello,Python'print(s2,swapcase())#字符串所有大写转换为小写，所有小写转换为大写print(s2,capitalize())#把第一个字母转换为大写，其余字母转换为小写print(s2,title())#把每个单词的第一个字母转换为大写，把每个单词的剩余字母转换为小写（3）字符串内容对齐操作centerljustrjustzfill
复制代码隐藏代码s='hello,Python'#居中对齐，第一个参数指定宽度，第二个参数指定填充符，默认空格。若设置宽度小于实际宽度，返回原字符串print(s,center(20,'*'))#左对齐，第一个参数指定宽度，第二个参数指定填充符print(s.ljust(20,'*'))print(s.ljust(10))print(s.ljust(20))#右对齐print(s.rjust(20,'*'))print(s.rjust(20))print(s.rjust(10))#右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串宽度print(s.zfill(20))print(s.zfill(10))print('-8910'.zfill(8))#减号后开始添0（4）字符串的劈分操作splitrsplit
复制代码隐藏代码s='helloworldPython''''split从字符串的左边开始劈分，默认的劈分字符是空格字符，返回的值都是一个列表'''lst=s.split()print(lst)s1='hello|world|Python'print(s1.split(sep='|'))#通过参数sep指定劈分符print(s1.split(sep='|',maxsplit=1))#通过maxsplit指定劈分字符串时最大劈分次数，经过最大次劈分后，剩余子串会单独作为一部分'''rsplit从字符串的右边开始劈分，默认的劈分符是空格字符串，返回的值都是一个列表'''print(s.rsplit())print(s.resplit(sep='|'))print(s.rsplit(sep='|',maxsplit=1))（5）判断字符串的操作isidentifierisspaceisalphaisdecimalisnumericisalnum
复制代码隐藏代码#判断指定的字符串是不是合法的标识符s='hello,python'print('1.',s.isidentifier())print('2.','hello'.isidentifier())print('3.','张三_'.isidentifier())print('4.','张三_123'.isidentifier())#判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）print('5.','\t'.isspace())#判断指定的字符串是否全部由字母组成print('6.','abc'.isalpha())print('7.','张三'.isalpha())print('8.','张三1'.isalpha())#判断指定的字符串是否全部由十进制数字组成print('9.','123'.isdecimal())print('10.','123四'.isdecimal())print('11.','ⅠⅡⅢ'.isdecimal())#判断指定的字符串是否全部由数字组成print('12.','123'.isnumeric())print('13.','123四'.isnumeric())print('14.','ⅠⅡⅢ'.isnumeric())#判断指定的字符串是否全部由字母和数字组成print('15.','abc1'.isalnum())print('16.','张三123'.isalnum())print('17.','abc!'.isalnum())（6）字符串操作的其他方法repalcejoin
复制代码隐藏代码#replace第一个参数指定被替换子串，第二个参数指定替换子串，第三个参数指定最大替换次数s='hello,Python'print(s.replace('Python','Java'))s1='hello,Python,Python,Python'print(s1.replace('Python','Java',2))#join将列表或元组中的字符串合并为一个字符串lst=['hello','java','Python']print('|'.join(lst))print(''.join(lst))t=('hello','java','Python')print(''.join(t))print('*'.join('Python'))3.字符串的比较<>=<<===!=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。
比较原理：两个字符进行比较时，比较的是其ordinalvalue（原始值），调用内置函数ord就可以得到指定字符的ordinalvalue。与内置函数对应的是内置函数chr，调用内置函数chr时可以使指定的ordinalvalue得到其对应的字符。
复制代码隐藏代码print('apple'>'apple')#Trueprint('apple'>'banana')#97>98,Flaseprint(ord('a'),ord('b'))print(ord('杨'))print(chr(97),chr(98))print(chr(26472))'''is与==的区别==比较的是valueis比较的是id'''a=b='Python'c='Python'print(a==b)print(b==c)print(aisb)print(aisc)print(id(a))print(id(b))print(id(c))4.字符串的切片操作复制代码隐藏代码s='hello,Python's1=s[:5]#没有指定起始位置，从0开始s2=s[6:]#没有指定结束位置，直到最后一个为止s3='!'newstr=s1+s3+s2print(s1)print(s2)print(newstr)print(id(s))print(id(s1))print(id(s2))print(id(s3))print(id(newstr))print('---------切片[start:end:step]------')print(s[1:5:1])#从1开始截到5，不包括5，步长为1print(s[::2])#默认从0开始，直到最后一个元素，索引间隔为2print(s[::-1])#默认从最后一个元素开始，直到第一个元素结束，因为步长为-1print(s[-6::1])#截取Python字符串5.格式化字符串为什么需要格式化字符串？按照一定格式输出字符串。
两种方式：%作占位符；{}作占位符。
复制代码隐藏代码'''格式化字符串'''#使用%占位符name='张三'age=20print('我叫%s，今年%d岁'%(name,age))#使用{}占位符print('我叫{0}，今年{1}岁'.format(name,age))#f-string（Python3.x以上版本）print('f我叫{name}，今年{age}岁')#宽度和精度print('%d'%99)print('%10d'%99)#10代表宽度print('%.3f'%3.1415926)#.3保留三位小数print('%10.3f'%3.1415926)#宽度为10，小数点后三位print('{0}'.format(3.1415926))print('{0:.3}'.format(3.1415926))#.3表示一共是3位数print('{0:.3f}'.format(3.1415926))#.3f表示3位小数print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度，一共是10位数，3位小数6.字符串的编码转换编码与解码的方式：
复制代码隐藏代码s='天涯共此时'#编码print(s.encode(encoding='GBK'))#GBK编码格式中，一个中文占两个字节print(s.encode(encoding='UTF-8'))#UTF-8中，一个中文占三个字节#解码byte=s.encode(encoding='GBK')#编码print(byte.decode(encoding='GBK'))#解码byte代表的就是一个二进制数据（字节类型的数据）byte=s.encode(encoding='UTF-8')#编码print(byte.decode(encoding='UTF-8'))十一、水晶球不调不动1.函数的创建和调用什么是函数？函数就是执行特定任务和完成特定功能的一段代码。
为什么需要函数？复用代码；隐藏实现细节；提高可维护性；提高可读性便于调试。
函数的创建def函数名（[输入参数]）：函数体[returnxxx]
函数的调用函数名([实际参数])
复制代码隐藏代码defcalc(a,b):#a,b称为形式参数，简称形参，形参位置在函数的定义处c=a+breturnc'''位置实参传递'''result=calc(10,20)#10，20实际参数，简称实参，位置在函数的调用处print(result)'''关键字实参传递'''res=calc(b=10,a=20)print(res)2.函数调用的参数传递复制代码隐藏代码deffun(arg1,arg2):print('arg1',arg1)print('arg2',arg2)arg1=100arg2.append(10)print('arg1',arg1)print('arg2',arg2)#returnn1=11n2=[22,33,44]print('n1',n1)print('n2',n2)fun(n1,n2)print('n1',n1)print('n2',n2)'''在函数的调用过程中，进行参数的传递，如果是不可变对象，在函数体的修改不会影响实参的值，arg1修改为100，不会影响n1的值如果是可变对象，在函数体内的修改会影响实参的值，arg2的修改.append(10)，会影响到n2的值'''函数的返回值：函数返回多个值时，结果为元组。
复制代码隐藏代码print(bool(0))#False零的布尔值为Falseprint(bool(1))#True非零整数布尔值为Truedeffun(num):odd=[]#村奇数even=[]#存偶数foriinnum:ifi%2:odd.append(i)else:even.append(i)returnodd,even#函数的调用lst=[10,29,34,23,44,53,55]print(fun(lst))'''函数的返回值1.如果函数没有返回值（函数执行完毕后，不需要给调用处提供数据）return可以不写2.函数的返回值，如果是1个，直接返回类型3.函数的返回值，如果是多个，返回结果为元组'''deffun1():print('hello')#returnfun1()deffun2():return'hello'res=fun2()print(res)deffun3():return'hello','world'print(fun3())'''函数在定义时，是否需要返回值，视情况而定'''3.函数的参数定义（1）函数定义默认值参数函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参。
复制代码隐藏代码deffun(a,b=10):#b默认值参数print(a,b)#函数的调用fun(100)fun(20,30)#defprint(self,*args,sep='',end='\n',file=None):print('hello')print('world')print('hello',end='\t')print('world')（2）个数可变的位置参数定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数；使用*定义个数可变的位置形参；结果为一个元组。
复制代码隐藏代码deffun(*args):#函数定义时可变的位置参数print(args)print(args[0])fun(10)fun(10,30)fun(30,405,50)（3）个数可变的关键字形参定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参；使用**定义个数可变的关键字形参；结果为一个字典。
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数.
递归函数的组成部分：
递归调用条件与递归终止条件.
递归的调用过程：
每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间.
递归的优缺点：
优点是思路和代码简单；缺点是占用内存多，效率低下.
Debug：排除程序bug
Bug的常见类型：
复制代码隐藏代码try:a=int(input('请输入第一个整数：'))b=int(input('请输入第二个整数：'))result=a/bexceptBaseExceptionase:print('出错了',e)else:print('计算结果为：',result)finally:print('谢谢您的使用')（4）traceback模块使用traceback模块打印异常处理信息，存储log日志。
类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质。
对象：不同数据类型属于不同的类，像100、99、520都是int类之下包含的相似的不同个例，这些个例专业术语称为实例或者对象。
复制代码隐藏代码classStudent:pass'''Student类名由一个或多个单词组成，每个单词的首字母大写，其余小写'''#Python中一切皆对象，Student是对象吗？内存由开空间吗？print(id(Student))print(type(Student))print(Student)类的组成：
复制代码隐藏代码classStudent:native_pace='吉林'#直接写在类里的变量，称为类属性def__init__(self,name,age):self.name=name#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性self.age=age#实例方法defeat(self):print('学生在吃饭...')#静态方法@staticmethoddefmethod():print('我使用了staticmethod进行修饰，所以我是静态方法')#类方法@classmethoddefcm(cls):print('我是类方法，因为我使用了classmethod进行修饰')'''在类之外定义的称为函数，在类之内定义的称为方法defdrink();#函数print('喝水')'''（2）对象的创建对象的创建又称为类的实例化：实例名=类名（）
复制代码隐藏代码classStudent:def__init__(self,name,age):self.name=nameself.age=agedefeat(self):print(self.name+'在吃饭')stu1=Student('张三',20)stu2=Student('李四',30)print(id(stu1))print(id(stu2))print('---------只给李四添加一个性别---------------')stu2.gender='女'print(stu1.name,stu1.age)#如果添加stu1.gender会抛出AttributeErrorprint(stu2.name,stu2.age,stu2.gender)print('-------------------------')stu1.eat()stu2.eat()defshow():print('定义在类之外地，称为函数')stu1.show=showstu1.show#stu2.show因为stu2并没有绑定show方法十四、接着找对象面向对象的三大特征：
复制代码隐藏代码classCar:def__init__(self,brand):self.brand=branddefstart(self):print('汽车已启动...')car=Car('宝马X5')car.start()print(car,brand)复制代码隐藏代码classStudent:def__init__(self,name,age):self.name=nameself.__age=age#年龄age不希望在类的外部被使用，所以加了两个“_”defshow(self):print(self.name,self.__age)stu=Student('张三',20)stu.show()#在类的外部使用name与ageprint(stu.name)#print(stu.__age)print(dir(stu))print(stu._Student__age)#在类的外部可以通过_Student__age进行访问2.继承继承的特点：如果一个类没有继承任何类，则默认继承object；Python支持多继承；定义子类时，必须在其构造函数中调用父类的构造函数。
复制代码隐藏代码classAnimal(object):defeat(self):print('动物会吃')classDog(Animal):defeat(self):print('狗吃骨头...')classCat(Animal):defeat(self):print('猫吃鱼...')classPerson:defeat(self):print('人吃五谷杂粮')#定义一个函数deffun(obj):obj.eat()#开始调用函数fun(Cat())fun(Dog())fun(Animal())print('-----------------------')fun(Person())静态语言和动态语言关于多态的区别：
浅拷贝：Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝。因此，源对象与拷贝对象会引用同一个子对象。
深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。
模块（modules）：
复制代码隐藏代码deffun():passdeffun2():passclassStudent:native_place='吉林'#类属性defeat(self):pass@classmethoddefcm(cls):pass@staticmethoddefsm():passa=10b=20print(a,b)2.自定义模块导入模块
import模块名称[as别名]
from模块名称import函数/变量/类
复制代码隐藏代码importmathprint(id(math))print(type(math))print(dir(math))frommathimportpifrommathimportpowprint(pi)print(pow(2,3))复制代码隐藏代码#自定义模块defadd(a,b):returna+bdefdiv(a,b):returna/b#如何导入自定义模块'''pycharm右键MarkDirectoryasSourcesRoot'''3.以主程序的形式执行在每个模块的定义中都包括一个记录模块名称的变量_name_，程序可以检查该变量，以确定他们在哪个模块执行，如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶端模块中执行。顶端模块的_name_变量的值为_main_
复制代码隐藏代码defadd(a,b):returna+bif__name__=='__main__':print(add(10,20))#只有当点击运行calc2模块时才会执行运算复制代码隐藏代码importcalc2print(calc2.add(100,200))4.Python中的包包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下。
作用：代码规范；避免模块名称冲突
包与目录的区别：包含__int__.py文件的目录叫作包；目录里通常不包含__int__.py文件
Python操作文件→打开或新建文件夹→读写文件→关闭资源
学生管理系统应具备的功能：
七大模块：
VIP部落购物天堂，淘客圣地，教育培训，资源下载，网站源码，网站模板，网站插件。