目录

demo1-输入输出

demo2-布尔变量

demo3-变量

demo4-字符串格式化

demo5-列表

demo6-元组

demo7-条件判断 

demo8-for循环 

demo9-字典与集合

demo10-可变对象与不可变对象

demo11-内置函数

demo12-定义函数与isinstance

demo13-默认参数

demo14-默认参数必须指向不可变对象

demo15-可变参数

demo16-关键字参数与命名关键字参数

demo17-函数参数顺序

demo18-random常见函数

demo19-切片

demo20-可迭代对象Iterable

demo21-列表生成式

demo22-生成器

demo23-迭代器

demo24-map与reduce函数

demo25-filter函数

demo26-sorted函数

demo27-匿名函数lambda

demo28-类和实例

demo29-数据封装

demo30-访问限制

demo31-继承与多态

---

demo1-输入输出

#demo-1#输入输出#print函数参数#转义字符#正数 浮点数 字符串name = input("Please enter your name:")print("hello,",name)print("2**10 =",2**10) #注意：print函数的逗号默认为一个空格，这是因为sep参数默认为空格print("2**10=",2**10,sep="")#因此可以将sep参数设置为""print(2**5) #正数print(3.1415926)#浮点数：IEEE754 浮点数的存储不精确print("hello world") #打印字符串:字符串可以用单引号也可以用双引号，每个pritn后默认换行print("hello ",end="") #注意：可以将end参数设置为""，这样就不会换行print("world")print("i'm ok")#""中含有'print('i" ok')#''中含有“print("i\' \"ok\"") #既有单引号与双引号 则使用转义字符\print('\\\t\\')print(r'\\\t\\')#r表示原生字符串，不转义，可以对比输出结果 Please enter your name:dddhello, ddd2**10 = 10242**10=1024323.1415926hello worldhello worldi'm oki" oki' "ok"\\\\\t\\

demo2-布尔变量

#demo-2#Bool变量#注意大小写#布尔值可以用and or not运算#if语句TrueFalseprint(3>2)print(3<2)print("----and----")print(True and True)print(False and True)print(True and False)print(False and False)print("----or----")print(True or True)print(False or True)print(True or False)print(False or False)print("----not----")print(not True)print(not False)#布尔值常用if结合使用#if首先判断条件为True或者Fasle，然后执行相应语句print("*"*20)#字符串还可以这样，使用*重复打印age = 22if age>0:print("Positive")elif age<0:print("negative ")else:print("zeros")print("*"*20) TrueFalse----and----TrueFalseFalseFalse----or----TrueTrueTrueFalse----not----FalseTrue********************Positive********************

demo3-变量

#demo-3#变量#变量名由大小写字母、数字和_组成，不能以数字开头#变量赋值：对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向#除法"""getVar可以由int变为float，这是因为Python是动态语言，变量本身类型不固定例如C或C++,变量声明或初始化时需要首先指定变量类型，且类型不可变"""getVar = 5 #驼峰命名法 # =为赋值，相当于在内存中创建了一个getVar的变量与5，并将getVar变量指向5print(getVar)getVar = 3.1415print(getVar)#两种写法均为将getVar加上5后再重新赋给getVargetVar = getVar + 5 getVar += 5print(getVar)#把一个变量a赋值给另一个变量b，实际上是把变量b指向变量a所指向的数据print("！！！重要！！！")tempA = "tempValue" #此时tempA指向tempValuetempB = tempA #此时tempB也指向tempValueprint(tempA,tempB)tempA = "hello world" #此时tempA指向hello world，但tempB仍然指向tempValueprint(tempA,tempB)print("\n*****除法*****")print(10/3) #精确的除法print(10//3)#地板除 向下取floor，只取整数部分print(10%3) #mod求模得余数 53.141513.1415！！！重要！！！tempValue tempValuehello world tempValue*****除法*****3.333333333333333531

demo4-字符串格式化

#demo-4#字符串格式化#爬虫中结构化的URL中常用urlList = ["https://www.renrendai.com/loan-{}.html".format(i) for i in range(5)]for eachList in urlList:print(eachList)testStr = "my name is {},my age is {}".format("zsl",999)print(testStr)#使用索引testStr = "my name is {1},my age is {0}".format("zsl",999)print(testStr) https://www.renrendai.com/loan-0.htmlhttps://www.renrendai.com/loan-1.htmlhttps://www.renrendai.com/loan-2.htmlhttps://www.renrendai.com/loan-3.htmlhttps://www.renrendai.com/loan-4.htmlmy name is zsl,my age is 999my name is 999,my age is zsl

demo5-列表

#demo-5#列表list-有序集合print("*****创建列表*****")test = [10,3.1415,"a",["C","C++"],{"key":"value",}] #Python中的列表可以是不同类型scoresList = [60,80,100]print(test)print(test[3][1]) #取列表中的列表print(scoresList)print("*****列表长度*****")print(len(scoresList)) #列表长度print("*****正向索引*****")print(scoresList[0])#正向索引/从0开始print(scoresList[1])print(scoresList[2])print("*****反向索引*****")print(scoresList[-1])#反向索引:-1代表最后一个print(scoresList[-2])#-2代表倒数第二个print(scoresList[-3])#PS：若越界则报错print("*****append追加*****")print(scoresList)scoresList.append(120)print(scoresList)print("*****insert插入*****")print(scoresList)scoresList.insert(0,0)#在索引为0处插入0print(scoresList)scoresList.insert(3,999)#在索引为0处插入0print(scoresList)print("*****pop删除*****")print(scoresList)scoresList.pop()#默认弹出最尾部元素print(scoresList)scoresList.pop(3) #弹出索引为0的元素print(scoresList)print("*****替换列表元素*****")print(scoresList)scoresList[0] = 9999print(scoresList) *****创建列表*****[10, 3.1415, 'a', ['C', 'C++'], {'key': 'value'}]C++[60, 80, 100]*****列表长度*****3*****正向索引*****6080100*****反向索引*****1008060*****append追加*****[60, 80, 100][60, 80, 100, 120]*****insert插入*****[60, 80, 100, 120][0, 60, 80, 100, 120][0, 60, 80, 999, 100, 120]*****pop删除*****[0, 60, 80, 999, 100, 120][0, 60, 80, 999, 100][0, 60, 80, 100]*****替换列表元素*****[0, 60, 80, 100][9999, 60, 80, 100]

demo6-元组

#demo-6#tuple元组#tuple与list非常相似，但tuple一旦初始化后无法修改scoresTuple = (60,80,100)print(scoresTuple)#初始化后无法修改，也无insert append pop等方法#scoresTuple[0]=999 #T会报错ypeError: 'tuple' object does not support item assignment#定义只有一个元素的tupleoneTuple = (1)print(oneTuple,type(oneTuple))oneTuple = (1,) #需要加个， 因为（）既可以生成tuple，也可以认为是表达式的小括号，有ambiguousprint(oneTuple,type(oneTuple))print("****有趣的例子*****")testTuple = (1,2,[3,4])print(testTuple)testTuple[2][0] = 666testTuple[2][1] = 999print(testTuple) #实质变的不是tuple，tuple始终指向两个整数一个列表，变的只是tuple中列表元素所指向的值# testTuple[2] = [666,999] #这样则会报错，因为这是修改tuple所指向的元素，而tuple在初始化后就不能修改所指向的值 (60, 80, 100)1 <class 'int'>(1,) <class 'tuple'>****有趣的例子*****(1, 2, [3, 4])(1, 2, [666, 999])

demo7-条件判断 

#demo-7#条件判断#if语句从上往下执行，如果有个判断语句为True，则执行相应语句#往后的elif与else则忽略#例如下面的if中，num也满足大于0，但不会输出statement2#所以注意if语句中各个判断条件的顺序或者具体判断内容num = 10if num > 5:print("statement1")elif num > 0:print("statement2")else:print("else")boolValue = 4>3if boolValue: #关键是只要判断内容是True则会执行print("test") statement1test

demo8-for循环 

#demo-8#for循环print("*****打印列表的每个值*****")scoresLists = [0,60,80,100]for eachScore in scoresLists:print(eachScore)print("*****求列表数字总和*****")scoresLists = [0,60,80,100]scoresSum = 0for eachScore in scoresLists:scoresSum += eachScoreprint(scoresSum)print("*****求1-100和*****")mySum = 0for each in range(1,101): #range(start,end)-左开右闭即[start,end)mySum += eachprint(mySum)print("*****for循环常见用法-enumerate：既要每个元素的值也要每个元素对应的索引*****")for index,each in enumerate(range(1,21,3)): #range(start,end,step) 其中step为步长print(index,each)print("*****for循环常见用法-zip：同时遍历两个可迭代对象*****")for x,y in zip([1,2,3],[4,5,6]): #print(x,y)#break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用”print("*****continue:计算1-100的偶数和*****")mySum = 0for each in range(1,101):if each % 2 != 0:#计算偶数和，则遇到奇数时continue进入下一次循环continuemySum += each #只有偶数情况时才会执行该语句print(mySum)print("*****break*****")mySum = 0for each in range(1,101):if each % 2 != 0:break #第一次碰见奇数时就break结束循环，因此mySum仍为0mySum += each print(mySum) *****打印列表的每个值*****06080100*****求列表数字总和*****240*****求1-100和*****5050*****for循环常见用法-enumerate：既要每个元素的值也要每个元素对应的索引*****0 11 42 73 104 135 166 19*****for循环常见用法-zip：同时遍历两个可迭代对象*****1 42 53 6*****continue:计算1-100的偶数和*****2550*****break*****0

demo9-字典与集合

#demo-9#字典dict与集合set#dict key:value 键值对 mapscoresDict = {"tom":100,"david":80,"green":60}print(scoresDict)scoresDict["selly"] = 99print(scoresDict)print("*****判断key是否在字典里*****")print("selly" in scoresDict)print("test" in scoresDict)print(scoresDict.get("test",999))print(scoresDict.get("selly",999))#get函数若存在key，则放回value,否则返回自己设置的值print("*****删除key*****")print(scoresDict)scoresDict.pop("tom")print(scoresDict)#set无序集合print("*"*50)# mySet = set(1,3,4,4,4,4,5,5) #TypeError: set expected at most 1 arguments, got 8mySet = set([1,3,4,4,4,4,5,5,6,7,8,8,8,9]) #使用列表List创建集合print(mySet)print("*****使用add与remove*****")print(mySet)mySet.add(999)print(mySet)mySet.remove(999)print(mySet)print("*****集合交、并、差操作*****")aSet = set([1,2,3,4])bSet = set([3,4,5,6])print(aSet & bSet)print(aSet | bSet)print(aSet-bSet)print(bSet-aSet) {'tom': 100, 'david': 80, 'green': 60}{'tom': 100, 'david': 80, 'green': 60, 'selly': 99}*****判断key是否在字典里*****TrueFalse99999*****删除key*****{'tom': 100, 'david': 80, 'green': 60, 'selly': 99}{'david': 80, 'green': 60, 'selly': 99}**************************************************{1, 3, 4, 5, 6, 7, 8, 9}*****使用add与remove*****{1, 3, 4, 5, 6, 7, 8, 9}{1, 3, 4, 5, 6, 7, 8, 9, 999}{1, 3, 4, 5, 6, 7, 8, 9}*****集合交、并、差操作*****{3, 4}{1, 2, 3, 4, 5, 6}{1, 2}{5, 6}

demo10-可变对象与不可变对象

#demo-10#不可变对象 ！！重要#可变对象testList = [9,10,6,4,5]print(testList)testList.sort()print(testList)#不可变对象:对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。#相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。testStr = "hello world"print(testStr)testAnotherStr = testStr.replace("l","L")print(testStr)print(testAnotherStr) [9, 10, 6, 4, 5][4, 5, 6, 9, 10]hello worldhello worldheLLo worLd

demo11-内置函数

#demo-11#内置函数+函数别名# abs?# help(abs)print(abs(-111))print(max(1,2,3,4,5,5,3,1,2,4,5,78,))print(min(1,2,3,4,5,5,3,1,2,4,5,78,))#类型转换print(int("123"),type(int("123")))print(int(12.3))print(str(123),type(str(123)))#函数名是指向一个函数对象的引用myAbs = abs #myAbs相当于函数abs的别名print(myAbs(-123))print(hex(65535)) 111781123 <class 'int'>12123 <class 'str'>1230xffff

demo12-定义函数与isinstance

#demo-12#定义函数+isinstancedef myAbs(x):if not isinstance(x,(float,int)):raise TypeError('bad Type') if x>= 0:return xelse:return -xprint(myAbs(5))print(myAbs(0))print(myAbs(-5))# print(myAbs(-5,2))#TypeError: myAbs() takes 1 positional argument but 2 were given# print(myAbs("test"))#isinstance的用法print(isinstance(123,int))print(isinstance(123,float))print(isinstance("hello wolrd",str))#函数返回多个值import randomdef getRandomPosition():return random.randint(1,10),random.randint(1,10) #其实是返回一个tupleprint(getRandomPosition()[0],getRandomPosition()[1],type(getRandomPosition()))#求解一元二次方程import mathdef quadratic(a,b,c):return (-b+math.sqrt(b**2-4*a*c))/(2*a),(-b-math.sqrt(b**2-4*a*c))/(2*a)print(quadratic(3,9,2)) 505TrueFalseTrue5 10 <class 'tuple'>(-0.24169426078820835, -2.758305739211792)

demo13-默认参数

#demo-13#函数参数-默认参数#x**ndef powN(x,n=2): #必选参数在前，默认参数在后/因为在后面才可省略if n == 0:return 1sum = 1for each in range(1,n+1):sum *= xreturn sumprint(powN(5,5),5**5)print(powN(8,3),8**3)print(powN(8)) #若无实际参数，则形式参数n默认为2def enroll(name,gender,age=6,city="fuzhou"):print("name:",name,sep="")print("gender:",gender,sep="")print("age:",age,sep="")print("city:",city,sep="")print("*"*20)enroll("xiaoming","F")print("*"*20)enroll("xiaoming","F",9)print("*"*20)enroll("xiaoming","F",9,"beijing")print("*"*20)enroll("xiaoming","F",city="beijing") #可以不按顺序提供默认参数，此时需要把参数名写上print("*"*20)enroll("xiaoming","F",city="xiamen",age=15) 3125 3125512 51264********************name:xiaominggender:Fage:6city:fuzhou********************name:xiaominggender:Fage:9city:fuzhou********************name:xiaominggender:Fage:9city:beijing********************name:xiaominggender:Fage:6city:beijing********************name:xiaominggender:Fage:15city:xiamen

demo14-默认参数必须指向不可变对象

#demo-14#默认参数必须指向不可变对象def add_end(L=[]):L.append('END')return LtempList = [1,2,3]add_end(tempList)add_end()print(tempList)#ython函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]#每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了add_end()add_end()add_end()print(add_end())#改进def add_end(L=None):if L is None:L = []L.append("END")return Ladd_end()add_end()add_end()print(add_end()) [1, 2, 3, 'END']['END', 'END', 'END', 'END', 'END']['END']

demo15-可变参数

#demo-15#可变参数#计算a2 + b2 + c2 + ……#定义可变参数仅在参数前加*#在函数内部，可变参数为一个tuple元组def calc(*numbers):sum = 0for n in numbers:sum = sum + n * nreturn sumprint(calc(1,2,3,4))tempList = [1,2,3,4]print(calc(tempList[2],tempList[3]))print(calc(*tempList)) #若原本存在列表，则在其前面加*即可把列表或者元组的元组变为可变参数传入 302530

demo16-关键字参数与命名关键字参数

#demo-16#关键字参数与命名关键字参数#关键字参数def person(name, age, **kw):print('name:', name, 'age:', age, 'other:', kw)person("Tom",20)person("Tom",20,city="fuzhou",gender="F")myDict = {"city":"xiamen","tel":13000000000,"gender":"F"}person("Tom",20,**myDict)print("*"*50)#和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数#此时命名关键字参数则必须存在，且命名关键字参数必须传入参数名def person(name, age, *, city, job):print(name, age, city, job)person("Tom",20,city="fuzhou",job="none")#如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*def person(name, age, *args, city, job):print(name, age, args, city, job)person("Tom",25,*[1,2,3,4],city="fuzhou",job="none")#命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。def person(name, age, *, city='Beijing', job):print(name, age, city, job)person("Tom",20,job="none")# name: Tom age: 20 other: {}name: Tom age: 20 other: {'city': 'fuzhou', 'gender': 'F'}name: Tom age: 20 other: {'city': 'xiamen', 'tel': 13000000000, 'gender': 'F'}**************************************************Tom 20 fuzhou noneTom 25 (1, 2, 3, 4) fuzhou noneTom 20 Beijing none

demo17-函数参数顺序

#demo-17#参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数#注意是先命名关键字参数后关键字参数，因为命名关键字参数需要指定参数名，而关键字参数抛在最后即可#可变参数在中间，因为前面是位置参数或默认参数，按位置进行解析，后面为关键字参数需要指定key，中间剩余的则为可变参数#arg为可变参数；kw为关键字参数def f1(a, b, c=0, *args, **kw):print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)f1(100,200)f1(1,2,3,*[1,2,3,4,5])f1(1,2,3,*[1,2,3,4,5],city="fuzhou",gender="F",job="None")#无可变参数，d为命名关键字参数，kw为关键字参数；注：关键字参数在命名关键字参数后面，大杂烩def f2(a, b, c=0, *, d, **kw):print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)f2(1,2,3,d="dddd",city="fuzhou",gender="F",job="None") #d为命名关键字参数，必须指定该参数值，否则报错f2(1,2,3,d="dddd") a = 100 b = 200 c = 0 args = () kw = {}a = 1 b = 2 c = 3 args = (1, 2, 3, 4, 5) kw = {}a = 1 b = 2 c = 3 args = (1, 2, 3, 4, 5) kw = {'city': 'fuzhou', 'gender': 'F', 'job': 'None'}a = 1 b = 2 c = 3 d = dddd kw = {'city': 'fuzhou', 'gender': 'F', 'job': 'None'}a = 1 b = 2 c = 3 d = dddd kw = {}

demo18-random常见函数

#demo-18#random常见函数import randomprint( random.randint(1,10) ) # 产生 1 到 10 的一个整数型随机数 [1,10]print( random.random() ) # 产生 0 到 1 之间的随机浮点数[0,1)print( random.uniform(1.1,5.4) ) # 产生 1.1 到 5.4 之间的随机浮点数，区间可以不是整数print( random.choice('tomorrow') ) # 从序列中随机选取一个元素print( random.choice([1,2,3]) ) # 从序列中随机选取一个元素print( random.randrange(1,100,2) ) # 生成从1到100的间隔为2的随机整数a=[1,3,5,6,7] # 将序列a中的元素顺序打乱random.shuffle(a)print(a)# random.uniform? 10.56323315247442932.7294567751257137r23[5, 7, 6, 1, 3]

demo19-切片

#demo-19#切片slicetestList = ["fujian","anhui","shanghai","beijing","shenzhen"]print(testList[:3]) #左闭右开print(testList[1:3])print(testList[-2:-1]) #反向print(testList[-2:])testList = list(range(1,101))print(testList)print(testList[:10]) #前10个print(testList[-10:]) #后10个print(testList[:10:2]) #前10个,步长为2print(testList[::5]) #间隔5个取一个#重要；注意对比#引用与复制print("*"*50)testList = ["fujian","anhui","shanghai","beijing","shenzhen"]tempList = testList #tempList与testList均指向同一个list[]print(tempList)testList.append("test")print(tempList)print("*"*50)testList = ["fujian","anhui","shanghai","beijing","shenzhen"]tempList = testList[:] #拷贝；重新复制print(tempList)testList.append("test")print(tempList)print("*"*50)print("hello world"[::2]) #字符串也可以当作一个list进行切片处理 ['fujian', 'anhui', 'shanghai']['anhui', 'shanghai']['beijing']['beijing', 'shenzhen'][1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100][1, 2, 3, 4, 5, 6, 7, 8, 9, 10][91, 92, 93, 94, 95, 96, 97, 98, 99, 100][1, 3, 5, 7, 9][1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]**************************************************['fujian', 'anhui', 'shanghai', 'beijing', 'shenzhen']['fujian', 'anhui', 'shanghai', 'beijing', 'shenzhen', 'test']**************************************************['fujian', 'anhui', 'shanghai', 'beijing', 'shenzhen']['fujian', 'anhui', 'shanghai', 'beijing', 'shenzhen']**************************************************hlowrd

demo20-可迭代对象Iterable

#demo-20#可迭代对象myDict = {'a': 1, 'b': 2, 'c': 3}for key in myDict:#默认迭代keyprint(key,myDict[key])for value in myDict.values():#迭代valueprint(value)for key,value in myDict.items(): #迭代键值对print(key,value)for each in list(range(1,5)):print(each)for eachChar in "hello":print(eachChar)print("*****判断是否为可迭代对象*****")from collections.abc import Iterableprint(isinstance([1,2,23],Iterable))print(isinstance(5,Iterable))print("*****enumerate*****")for index,value in enumerate(["a","b","c"]):print(index,value) a 1b 2c 3123a 1b 2c 31234hello*****判断是否为可迭代对象*****TrueFalse*****enumerate*****0 a1 b2 c

demo21-列表生成式

#demo-21#列表生成式List Comprehensionsprint([i*i for i in range(1,11)])print([i*i for i in range(1,11) if i % 2 == 0]) #只有偶数 print([x + y for x in [1,2,3] for y in [4,5,6]]) #注意该种用法L = ['Hello', 'World', 'TEST', 'XYZ']print([each.lower() for each in L])print( [x if x % 2 == 0 else -x for x in range(1, 11)])L = ['Hello', 'World',999, 'TEST', 'XYZ']print([each.lower() for each in L if isinstance(each,str)]) [1, 4, 9, 16, 25, 36, 49, 64, 81, 100][4, 16, 36, 64, 100][5, 6, 7, 6, 7, 8, 7, 8, 9]['hello', 'world', 'test', 'xyz'][-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]['hello', 'world', 'test', 'xyz']

demo22-生成器

#demo-22#生成器#若列表元素规模大，则一次占用过多内存#因此可以使用生成器generator，在循环的过程中计算元素值L = [x * x for x in range(10)]print(L,type(L))g = (x * x for x in range(10)) #把[]替换为（）即为generator生成器print(g,type(g))for each in g:#遍历生成器print(each)#斐波拉契数列#如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator函数#1 1 2 3 5 8def fib(n):i,left,right = 0,0,1 while(i<n):yield(right)left,right = right,left+righti += 1for each in fib(10):print(each)#调用generator函数会创建一个generator对象，多次调用generator函数会创建多个相互独立的generator。print(next(fib(5)))print(next(fib(5)))print(next(fib(5))) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'><generator object <genexpr> at 0x000001E22B2B5BC8> <class 'generator'>014916253649648111235813213455111

demo23-迭代器

#demo-23#迭代器#可以直接用于for循环：#①生成器generator 与 带yield的generator function#②集合数据类型：list tuple dict set strprint("*****判断是否为可迭代对象Iterable*****")from collections.abc import Iterableprint(isinstance([],Iterable))print(isinstance("",Iterable))print(isinstance((),Iterable))print(isinstance({},Iterable))print(isinstance(5,Iterable))#生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator#可以使用iter()函数将Iterable变为Iteratorprint("*****判断是否为迭代器对象Iterator*****")from collections.abc import Iteratorprint(isinstance([],Iterator))print(isinstance(iter([]),Iterator)) #使用iter函数变为迭代器print(isinstance("",Iterator))print(isinstance((),Iterator))print(isinstance({},Iterator))print(isinstance(5,Iterator))print(isinstance(fib(10),Iterator))#Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误#可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据#所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。#Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的 *****判断是否为可迭代对象Iterable*****TrueTrueTrueTrueFalse*****判断是否为迭代器对象Iterator*****FalseTrueFalseFalseFalseFalseTrue

demo24-map与reduce函数

#demo-24#高阶函数之map与reduce#一个函数就可以接收另一个函数作为参数#变量可以指向函数myAbs = abs #函数名是指向函数的变量print(myAbs(-10))#高阶函数def add(x,y,f): #接收另一个函数作为参数return f(x)+f(y)print(add(-5,-8,abs))#map函数#map函数接收两个参数，一个是函数，另一个是Iterable#map将函数依次作用到可迭代对象的每个元素上#并把结果作为新的Iterator返回def mySqure(x):return x**2print(list(map(mySqure,[1,2,3,4]))) #将iterator转换为list;把函数mySqure作为参数传入mapprint(list(map(str,[1,2,3,4])))print(list(map(lambda x:x.lower(),['adam', 'LISA', 'barT'])))print(list(map(str.lower,['adam', 'LISA', 'barT']))) #str.lower#reduce函数#reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)#把结果和序列的下一个元素进行运算from functools import reducedef fn(x,y):return 10 * x + yprint(reduce(fn,[1,3,5,7,9])) 1013[1, 4, 9, 16]['1', '2', '3', '4']['adam', 'lisa', 'bart']['adam', 'lisa', 'bart']13579

demo25-filter函数

#demo-25#filter函数：用于过滤序列#和map()类似，filter()也接收一个函数和一个序列。#和map()不同的是，filter()把传入的函数依次作用于每个元素#然后根据返回值是True还是False决定保留还是丢弃该元素。def is_odd(x):return x % 2 == 1#注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，#所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。print(list(filter(is_odd,list(range(1,12)))))#回数def is_palindrome(x):if str(x) == str(x)[::-1]: #[::-1]倒序return Trueprint(list(filter(is_palindrome,list(range(1,1000))))) [1, 3, 5, 7, 9, 11][1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]

demo26-sorted函数

#demo-26#sorted:key参数接收函数作为排列依据tempList = [36, 5, -12, 9, -21]print(tempList)print(sorted(tempList)) #不改变原始列表print(tempList)tempList.sort() #排列原始列表print(tempList)tempList = [36, 5, -12, 9, -21]print(sorted(tempList,key=abs)) #key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序print(sorted(tempList,key=abs,reverse=True)) #反向 [36, 5, -12, 9, -21][-21, -12, 5, 9, 36][36, 5, -12, 9, -21][-21, -12, 5, 9, 36][5, 9, -12, -21, 36][36, -21, -12, 9, 5] 

demo27-匿名函数lambda

#demo-27#匿名函数lambda#无需显式定义函数，使用匿名函数更为方便print(list(map(lambda x:x.lower(),['adam', 'LISA', 'barT'])))def mySqure(x):return x**2print(list(map(mySqure,[1,2,3,4])))print(list(map(lambda x:x**2,[1,2,3,4])))def is_odd(x):return x % 2 == 1print(list(filter(is_odd,list(range(1,12)))))print(list(filter(lambda x:x%2==1,list(range(1,12)))))#匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数f = lambda x:x**2print(f(5)) ['adam', 'lisa', 'bart'][1, 4, 9, 16][1, 4, 9, 16][1, 3, 5, 7, 9, 11][1, 3, 5, 7, 9, 11]25

demo28-类和实例

#demo-28#类和实例class Student(object): #定义类->相当于模板pass std1 = Student() #类的实例化->对象std2 = Student()print(std1)print(std2) #每个实例有不同的内存地址print(Student)std1.socre = 99 #可以自由的给实例绑定变量print(std1.socre)#类起到模板作用，可以设置初始化实例时必须的参数class StudentV1(object):def __init__(self,name,age): #self指向对象本身self.name = nameself.age = age# std1 = StudentV1() #报错：TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'std1 = StudentV1("Tom",6)print(std1.name,std1.age) #打印对象属性；但该种方法不好，直接访问了数据； <__main__.Student object at 0x000001E22B27D648><__main__.Student object at 0x000001E22B24D6C8><class '__main__.Student'>99Tom 6

demo29-数据封装

#demo-29#数据封装#对对象属性或数据的访问应该通过调用类的方法进行#从而实现对数据的封装，避免从外部访问对象的数据class StudentV2(object):def __init__(self,name,age): #self指向对象本身self.name = nameself.age = agedef printScore(self):print(self.name,self.age)def isAdult(self):if self.age >= 18:print("Adult")else:print("hhh")std1 = StudentV2("Tom",6)std1.printScore() #通过method方法访问对象内部数据std1.isAdult() Tom 6hhh

demo30-访问限制

#demo-30#访问限制class StudentV2(object):def __init__(self,name,age): #self指向对象本身self.name = nameself.age = agedef printScore(self):print(self.name,self.age)def isAdult(self):if self.age >= 18:print("Adult")else:print("hhh")std1 = StudentV2("Tom",6)std1.isAdult()std1.age = 20 #外部可以直接操作对象内部的数据std1.isAdult()#可以在实例变量名前加上__（两个下划线），从而将变量变为私有变量#数据封装， 此时数据只能内部访问，无法外部访问#__varName__以双下划线开头与结尾的是特殊变量，因此不使用该种命名方式class StudentV3(object):def __init__(self,name,age): #self指向对象本身self.__name = nameself.__age = agedef printScore(self):print(self.__name,self.__age)def isAdult(self):if self.__age >= 18:print("Adult")else:print("hhh")def getScore(self):return self.__agedef setScore(self,age): #采用数据封装的方式，内部方法可以对传入的参数进行更多的操作if 0 <= age and age<=100: #0 <= score and <=100self.__age = ageelse:raise ValueError("value error")std1 = StudentV3("Tom",6)# print(std1.__age) #'StudentV3' object has no attribute '__age' #此时从外部无法访问__agestd1.printScore()print(std1.getScore())std1.setScore(20)print(std1.getScore())#从外部其实也可以直接方法私有变量 : _ClassName__VarNameprint(std1._StudentV3__age) #Python解释器对外把__name变量改成了_Student__namestd1.__age = 999 #所以这种方法只是增加了一个__age变量，但并非更改了类内属性__ageprint(std1.getScore(),std1.__age) #可以发现类内属性_age并未改成999，因为此时该变量全称变为_StudentV3__age hhhAdultTom 66202020 999

demo31-继承与多态

#demo-31#继承与多态#多态：为不同数据类型的实体提供统一的接口class Animal(object):def run(self):print('Animal is running...')class Dog(Animal): #继承于Animal类def eat(self):print('Eating meat...')def run(self):print('dog is running...')class Cat(Animal):def run(self):print('cat is running...')dog = Dog()dog.run() #当子类与父类存在同样的方法时，子类会覆盖父类的方法->多态dog.eat()cat = Cat()cat.run()#既是子类也是父类print(isinstance(dog,Animal))print(isinstance(dog,Dog))def run_twice(animal):animal.run()animal.run()run_twice(Animal())run_twice(Dog())run_twice(Cat()) dog is running...Eating meat...cat is running...TrueTrueAnimal is running...Animal is running...dog is running...dog is running...cat is running...cat is running...