python基础知识
你好世界！！！
# coding=utf-8 print('你好 世界！')
乘方
print(2**5)
变量
#定义变量 name = ‘小明’ print(name) #变量多次赋值 name = '小红' print(name) # 多次赋值后会指向一个新的空间 name = '小刚' print(name)
注意：= 是赋值 == 是条件判断
二进制与字符编码
print(chr(0b100111001011000)) #二进制要加上0b否则计算机不认识 print(ord('乘')) # 20056 是一个十进制
转义字符和原字符
# 转义字符 print('hello\nworld')# 转义功能的首字符 \n表示换行 print('hello\tworld')# \t 表示空格 站位4个字符 print('helloooo\tworld') print('hello\rworld')# \r 覆盖前面的 print('hello\bworld')# \b 退格键会把前面一个字符占了 print('http:\\\www.baidu.com') # \ 要被转一个 print('老师说：\'大家好\'') # 原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在原字符串之前加上r，或R print(r'hello\neorld') # 注意事项，最后一个字符不能是反斜杠 # print(r'hello\neorld\') print(r'hello\neorld\\')
range()函数
# range() 的三种创建方式 '''第一种方式，只有一个参数（小括号中只给了一个数）''' r=range(10) #[0,1,2,3,4,5,6,7,8,9]默认值从0开始默认相差1称为步长 print(r) #range(0, 10) print(list(r)) #用于查看range对象中的整数序列 -->list列表的意思 '''第二种方式，给了两个参数（小括号中给了两个数）''' r=range(1,10) #指定了起始值，从1开始 到10结束（不包含10），默认步长为1 print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9] '''第三种创建方式，给了三个参数（小括号中给了三个数）''' r=range(1,10,2) #2指定了一个步长 print(list(r)) #[1, 3, 5, 7, 9] '''判断指定的整数，在序列中是否存在 in，not in''' print(10 in r) #False 10不在这个整数当中 print(9 in r) #True 9在这个整数当中 print(10 not in r)#True 10不在这个整数当中 print(9 not in r)#False 9在这个整数当中
if分支结构
单分支结构 money = 1000 #余额 s = int(input("请输入金额")) #取款金额 # 判断余额是否充足 if money >= s: money = money-s print('取款成功余额为',money) 双分支结构 # 从键盘录入一个整数判断是技术还是偶数 num = int(input('请输入一个整数')) # 条件判断 if num%2 == 0: print(num,'是偶数') else: print(num,'是奇数') 多分支结构 # 从键盘录入一个整数 成绩 # 90-100 A # 80-89 B # 70-79 C # 60-69 D # 0-59 E # 小于0或大于100 非法数据 （不是成绩的有效范围） score = int(input('请输入一个成绩：')) # 判断 if score> = 90 and score <= 100: print(score,'成绩为A') elif score >= 80 and score <= 89: print(score,'成绩为B') elif score >= 70 and score <= 79: print(score,'成绩为C') elif score >= 60 and score <= 69: print(score,'成绩为D') elif score >= 0 and score <= 59: print(score,'成绩为E') elif score < 0 and score > 100: print(score,'输入错误') 嵌套if的使用 # 会员 >=200 八折 # >=100 九折 # 不打折 # 非会员 >=200 9.5折 # 不打折 answer=input("你是会员吗？y/n ") # 外层判断是否是会员 if answer == 'y': print('会员') answer1 = int(input('请输入金额: ')) if answer1 >= 200: print('打八折',answer1*0.8) elif answer1 >= 100: print('打九折',answer1*0.9) else: print('输入错误') else: print('非会员') answer2 = int(input('请输入金额')) if answer2 >= 200: print('打八折', answer2 * 0.95) else: print('输入错误') 条件表达式 # 从键盘录入两个整数，比较两个整数的大小 num_a = int(input('请输入第一个整数：')) num_b = int(input('请输入第二个整数：')) # 比较大小 print('使用条件表达式进入比较') print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))
for循环
for in 循环 for item in 'python': #第一次取出来的是P，将P赋值item，将item的值输出 print(item) # range() 产生一个整数序列--> 也是一个可迭代对象 for i in range(10): print(i) 二重循环中的break与continue # 流程控制语句break与continue在二重循环中的使用 for i in range(5): for j in range(1,11): if j%2 == 0: # break continue print(j,end='\t') print() for in 练习_100到999之间的水仙花数 #举例： #153 = 3*3*3+5*5*5+1*1*1 for irem in range(100,1000): ge = irem%10 #个位 shi = irem//10%10 #十位 bai = irem//100 #百位 # 判断 if ge**3+shi**3+bai**3==irem: print(irem) 嵌套循环 for i in range(1,10): for j in range(1,i+1): print(i,'*',j,'=',i*j,end='\t') print()
while循环
# 选择结构的if与循环结构while的区别 # if是判断一次，条件为True执行一次 # while是判断N+1次，条件为True执行N次 a = 1 # 判断条件表达式 while a < 10: # 执行条件运算符 print(a) a += 1 # 计算0到4之间的累加和 # 4步循环法 # 1.初始化变量 # 2.条件判断 # 3.条件执行体（循环体） # 4.改变变量 # 总结 初始化的变量与条件判断的变量与改变的变量为同一个 sum = 0 #存储 '''初始化变量为0''' a = 0 '''条件判断''' while a < 5: '''条件执行体（循环体）''' sum += a '''改变变量''' a += 1 print('和为',sum) '''计算1到100之间的偶数和''' sum = 0#用于存储偶数 '''初始化变量''' a = 0 '''条件判断''' while a <= 100: '''条件执行（求和）''' # 条件判断是否为偶数 if not bool(a%2): #a%2==0: sum += a # 改变变量 a += 1 print('1~100的偶数和',sum)
else pass continue break 控制流程语句
else语句 a = 0 while a < 3: pwd = input("请输入密码：") if pwd == '8888': print('密码正确') break else: print('密码不正确') a += 1 else: print('对不起，三次密码均输入错误') # pass语句，什么都不做，只是一个占位符，用到需要写语句的地方 answer = input('你是会员吗？y/s ') # 判断是否是会员 if answer == 'y': pass else: pass 控制流程语句break a = 0 while a < 3: # 条件执行体（循环体） pwd = input("请输入密码：") if pwd == '8888': print('密码正确') break else: print('密码不正确') '''该变变量''' a += 1 控制流程语句continue print('----------使用 continue-----------') #相当于跳过5的倍数 for item in range(1,51): if item%5 == 0: continue print(item)
break 和 continue语句的区别 break直接结束程序 continue跳出当前循环代码继续下面的代码
数据类型
常用的数据类型 # 整数类型 int 98 # 浮点数类型 float 3.145 # 布尔类型 bool True,False # 字符串类型 str '我用python学习' 字符串类型 # 字符串类型被称为不可变的字符序列 # 可以用单引号双引号三引号 来定义字符串 str1 = '人数苦短我用python' str2 = "人数苦短我用python" str3 = '''人数苦短我用python''' str4 = '''人数苦短 我用python''' print(str1,type(str1)) print(str2,type(str2)) print(str3,type(str3)) print(str4,type(str4)) 布尔类型 # 用来标识真假的值 # True表示真 False表示假 # 可以用转化为整数 # true = 1 # false = 0 f1 = True f2 = False print(f1,type(f1)) print(f2,type(f2)) # 布尔类型可以转换成整数计算 print(f1+1) #2 1+1的结果为2 true表示为1 print(f2+1) #1 0+1的结果为1 false表示为0 整数类型 # 可以表示，正数，负数，0 n1 = 90 n2 = -20 n3 = 0 print(n1,type(n1)) print(n2,type(n2)) print(n3,type(n3)) #整数可以表示为二进制，十进制，八进制，十六进制 print('十进制',118) print('二进制',0b10101111) #二进制以0b开头 范围0~9 print('八进制',0o176) #八进制以0o开头 范围0~7 print('十六进制',0x1EAF) #十六进制以0x开头 1~9 A~F a = 3.1415926 print(a,type(a)) n1 = 1.1 n2 = 2.2 n3 = 2.1 print(n1+n2) #因为以二进制的方式去存储所以浮点数计算时不精确 print(n1+n3) # 解决方案 from decimal import Decimal print(Decimal('1.1')+Decimal('2.2'))
type 查看数据类型
数据类型转换
print('----------float()函数 将他们转换为float函数类型-------') s1 = '125.95' f1 = '76' ff = True s3 = 'hello' i = 98 print(type(s1),type(f1),type(ff),type(s3),type(i)) print(float(s1),type(float(s1))) print(float(f1),type(float(f1))) print(float(ff),type(float(ff))) # print(float(s3),type(float(s3)))# 字符串中的数据如果是非数字串，则不能被转换 类型转换str()函数与int()函数 name = '张三' age = 20 print(type(name),type(age))# 说明name与age的数据类型不相同 # print('我叫'+name+'今年'+age+'岁')# 当将str类型与int类型进行连接时，报错，解决方案，类型转换 print('我叫'+name+'今年'+str(age)+'岁')# 将int类型通过str() 函数转换为字符类型 print('------------str()将其他类型转成为str类型-------') a = 10 b = 198.7 c = False print(type(a),type(b),type(c)) print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c))) print('------------int()将其它的类型转int类型-------') s1 = '125' f1 = 85.77 s2 = '52.25' ff = True s3 = 'hello' print(type(s1),type(f1),type(s2),type(ff),type(s3)) print(int(s1),type(int(s1)))# 将str转成int类型，字符串为 数字串 print(int(f1),type(int(f1)))# float转成int类型，截取整数类型 往小取 # print(int(s2),type(int(s2))) 将str转成int类型，报错，因为字符串为小数串 print(int(ff),type(int(ff)))# 布尔类型True为1 所以转换为1的int类型 # print(int(s3),type(int(s3))) 字符里不是数字不能转，必须为数字串（整数）
字符串
字符串 # 在python中字符串是基本数据类型，是一个不可变的字符序列 # # 什么叫做字符串驻留机制呢 # 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻 # 留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建 # 相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的 # 变量 # 字符串的驻留机制 a = 'Python' b = 'Python' c = '''Python''' print(a,id(a)) print(b,id(b)) print(c,id(c)) # 驻留机制的机制情况（交互模式） # 字符串的长度为0或1时 # 符合标识符的字符串 # 字符串只在编译是进行驻留，而是运行时 # [-5,256]之间的整数数字 # sys中的intern方法强制2个字符串指向同一个对象 # pycharm对字符串进行了优化处理 # 字符串的驻留机制的优缺点 # 当需要值相同的字符串时，可以直接从字符串池里拿出来避免频繁 # 的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是 # 会比较印象性能的 # 在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join() # 方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象效率要比'+'效率高
格式占位符的两种方式 % 作用占用符 %s 字符串 %i或%d 整数 %f 浮点数 name = '小明' age = 17 tiz = 70.8 print('我的名字叫：%s，今年%d岁了，体重%f'%(name,age,tiz)) # {}作占位符 print('我的名字叫：{0}，今年{1}岁了，体重是{2}，我真的叫{0}'.format(name,age,tiz,name)) # f-string print(f'我叫{name}，今年{age}岁，体重是{tiz}斤') print('%10d' % 99) #10表示的是宽度 print('%.3f' % 3.1415926) # .3 表示保存小数点后3位 # 同时表示宽度和精度 print('%10.3f' % 3.1415926) #一共总宽度为10，小数点后 3位 print('{0:.3}'.format(3.1415926)) # .3 表示一共是3位数 print('{0:.3f}'.format(3.1415926)) # .3表示是3位小数 print('{:10.3f}'.format(3.1415926)) #同时设置宽度和精度，一共是10位，3位是小数 字符串的比较 运算符>,>=,<,<=,==,!= 比较原理：两个字符进行比较时，比较的是其ordinal value（原始值），调用内置函数ord可以 得到指定字符的 的ordinal value 与内置函数ordinal对应的是内置函数chr，调用内置函数chr时指定ordinal value 可以得到其对应的字符 print('apple'>'app') # true print('apple'>'banana') #false 相当于97>98 >false print(ord('a'),ord('b')) print(ord('韩')) print(chr(97),chr(98)) #相当于AIIS值 print(chr(38889)) '''==与is的区别 ==比较的是value is 比较的是id是否相等''' a=b='python' c='python' print(a == b) #true print(b == c) #true print(a is b) #比较的是内存地址 print(a is c) #比较的是内存地址 print(id(a)) print(id(b)) print(id(c))
字符串的大小写转换
# upper() 把字符串中所有字符都转成大写字母 # lower() 把字符串中所有字符都转成小写字母 # swapcase() 把字符串中所有大写字母转换成小写字母，把所有小写字母都转换成大小字母 # capitalize() 把第一个字符都转换为大写，把其余字符都转换为小写 # title() 把每个单词的第一个字符转换为大写，把每个单词剩余字符转换为小写 # 字符串中的大小写转换的方法 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(b is s) #False 地址不相等 没有驻留 s2 = 'hello,Python' print(s2.swapcase()) print(s2.capitalize()) print(s2.title())
字符串的劈分
# 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
# split() 以通过参数sep指定劈分字符串是的劈分符
# 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
#
# 从字符串的右边开始劈分，默认劈分字符是空格字符串，返回的值都是一个列表
# rsplit() 以通过参数sep指定劈分字符串是的劈分符
# 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分之后，剩余的子串会单独做为一部分
s = 'hello world Python'
lst = s.split()
print(lst)
s1 = 'hello|world|Python'
print(s1.split(sep = '|'))
print(s1.split(sep = '|',maxsplit = 1))
print('------------------------------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep = '|',maxsplit = 1))
字符串切片操作
# 字符串是不可变类型
# 不具备增，删，改等操作
# 切片操作将产生新的对象
s = 'hello,python'
s1 = s[:5] #由于没有指定起始位置，所以从0开始切
s2 = s[6:] #由于没有结束位置，所以切到字符串的最后一个元素
s3 = '!'
newsstr = s1+s3+s2
print(s1)
print(s2)
print(newsstr)
print('-------------------------------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newsstr))
print('--------------切片[start:end:step]--------------------')
print(s[1:5:1]) #从1开始截到5（不包括5）步长为1
print(s[::2]) #默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1]) #默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1]) #从索引为-6开始，到字符串的最后一个元素结束，步长为1
字符串查询操作
# index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError # rindex() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError # find() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1 # rfind() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1 # 字符串的查询操作 s = 'hello,hello' print(s.index('lo')) #3 print(s.find('lo')) #3 print(s.rindex('lo')) #9 print(s.rfind('lo')) #9 #print(s.index('k')) ValueError: substring not found print(s.rfind('k')) #-1 #print(s.rindex('k')) ValueError: substring not found print(s.rfind('k')) #-1
字符串其他操作方法 # 字符串的替换 replace() 第一个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发 # 生变化，调用该方法时可以通过第三个参数指定最大替换次数 # 字符串的合并 join() 将列表或元组的字符串合并成一个字符串 s = 'hello,python' print(s.replace('python','java')) s1 = 'hello,python,python,python' print(s1.replace('python','java',2)) lst = ['hello','java','python'] print('|'.join(lst)) print(''.join(lst)) t = ('hello','java','python') print(''.join(t)) print('*'.join('python'))
字符串内容对齐操作 # center() 居中对齐 # ljust() 左对齐 # rjust() 右对齐 # zfill() 右对齐 s = 'hello,Python' '''居中对齐''' print(s.center(20,'*')) print(s.center(20)) '''左对齐''' print(s.ljust(20,"*")) print(s.ljust(20)) '''右对齐''' print(s.rjust(20,'*')) print(s.rjust(20)) '''右对齐,使用0进行填充''' print(s.zfill(20)) print('-8910'.zfill(20))
判断字符串的方法 # isidentifier() 判断指定的字符串是不是合法的标识符 # isspace() 判断指定的字符串是否全部由空白字符串组成（回车，换行，水平制表符） # isalpha 判断指定的字符串是否全部由字母组成 # 判断字符串的方法 # isdecimal() 判断指定字符串是否全部由十进制的数组组成 # isnumeric() 判断指定的字符串是否全部由数字组成 # isalnum() 判断指定字符串是否全部由字母和数字组成 s = 'hello,python' print('---------isidentifier() 判断指定的字符串是不是合法的标识符----------------') print('1.',s.isidentifier()) #合法标识符是字母数字下划线 里面的','不是 false print('2.','hello'.isidentifier()) #true print('3.','张三'.isidentifier()) #true print('4.','张三_123'.isidentifier()) #true print('---------isspace() 判断指定的字符串是否全部由空白字符串组成---------------') print('5.','\t'.isspace()) #true print('--------- isalpha 判断指定的字符串是否全部由字母组成-----------') print('6.','abc'.isalpha()) #true print('7.','张三'.isalpha()) #true print('8.','张三1'.isalpha()) #false print('--------- isdecimal() 判断指定字符串是否全部由十进制的数组组成-----------') print('9.','123'.isdecimal()) #true print('10.','123四'.isdecimal()) #false print('--------- isnumeric() 判断指定的字符串是否全部由数字组成-----------') print('11.','123'.isnumeric()) #true print('12.','123四'.isnumeric()) #true print('--------- isalnum() 判断指定字符串是否全部由字母和数字组成-----------') print('13.','abc1'.isalnum()) #true print('14.','张三123'.isalnum()) #true print('15.','abc!'.isalnum()) #false print('-----------------字符串判断-----------------') s = 'hanxiaojungege!@#123' a = 0 b = 0 c = 0 for i in s: if i.isalpha(): a = a+1 elif i.isnumeric(): b = b+1 else: c = c+1 print('字母有：',a,'数字',b,'其它字符',c) 字符串的编码转换
s = '天涯共此时'
# 编码
print(s.encode(encoding='GBK')) #GBK这种编码中 一共中文占两个字符 b是二进制的意思
print(s.encode(encoding='UTF-8')) #在UTF-8这种编辑格式中，一共中文占三个字节
# 解码
# byte代表的是一共二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK') #编码
print(byte.decode(encoding='GBK')) #解码
byte=s.encode(encoding='UTF-8') #编码
print(byte.decode(encoding='UTF-8')) #解码 总结 index(),rindex() 查询的方法 find(),rfind() 大小写转换 upper(),lower() 内容对齐 center() 字符 驻留的几种情况 字符串的劈分 split() 串的 驻留的优点 字符串判断 isdecimal() 驻留 强制驻留的方法 字符串的替换 replace() 字符串的合并 join() 常用方法 字符串的比较 >,<,>=,<=,==,!= 编码：print(s.encode(encoding='GBK')) print(s.encode(encoding='UTF-8')) 字符编码 解码：byte=s.encode(encoding='GBK') print(byte.decode(encoding='GBK')) （先编码才能解码）
id 查看元素内存地址
字典
字典的创建方式 '''使用{}创建字典''' scores = {'张三':100,'小米':98,'小明':45} print(scores) print(type(scores)) '''第二种创建方式dict()''' scores = dict(name = 'jack',age = 20) print(scores) '''空字典''' d = {} print(d) 字典的特点
# 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复 # 字典中的元素是无序的 # 字典中的key必须是不可变对象 # 字典也可以根据需要动态地伸缩 # 字典会浪费较大的内存，是一种所以空间转时间的数据结构 d = {'name':'张三','name':'小米'} # key不允许重复 重复值会被覆盖 print(d) d = {'name':'小米','nikename':'小米'} # 字典中的value元素是可以重复的 print(d) lst = [10,20,30] lst.insert(2,100) print(lst)
字典生成式 # 内置函数zip() # 用于将可迭代的对象作用参数，将对象中对应的元打包成一个元组，然后返回由这些元组组成的列表 items = ['Fruits','Books','Others'] prices = ['小军',78,85] d = { items:prices for items ,prices in zip(items,prices) } print(d) 字典元素的遍历
scores = {'张三':100,'小米':98,'小明':45}
# 字典元素的遍历 for item in scores: print(item,scores[item],scores.get(item)) 字典元素的增_删_改操作
'''key判断''' scores = {'张三':100,'小米':98,'小明':45} print('张三' in scores) print('张三' not in scores) del scores['张三'] #删除指定的key—value对 #scores.clear() #清空字典的元素 print(scores) scores['小军']=98 #新增元素 print(scores) scores['小米']=100 #修改元素 print(scores)
元素中的获取 score s= {'张三':100,'小米':98,'小明':45} '''第一次方式使用[]''' print(scores['张三']) #print(scores['小军']) KeyError: '小军' '''第二种方式，使用get()方法''' print(scores.get('张三')) print(scores.get('陈留')) #None print(scores.get('马奇',99)) #99是在查找'马奇'所对应的value不存在时，提供的一个默认值
获取字典的视图操作 scores = {'张三':100,'小米':98,'小明':45} # 获取所有的key keys = scores.keys() print(keys) print(type(keys)) print(list(keys)) #将所有的key组成的视图转成列表 # 获取所有的value value=scores.values() print(value) print(type(value)) print(list(value)) # 获取所有的key—value对 items=scores.items() print(items) print(list(items)) # 转换之后列表元素是由元组组成
知识总结 # 使用{}花括号 # 字典的创建 内置函数dict() # 字典生成式 # 字典名[key] # 获取value 字典名.get(key) # 常用操作 删除key-value对 del字典名[key] # 新增/修改 字典名[key]=value # in /not in
元组
元组的创建方式
# 元组 # python内置的数据结构之一，是一个不可变序列 # 不可变序列与可变序列 # 不变可变序：字符串，元组 # 不可变序列：没有增，删，改的操作 # 可变序列：列表，字典 # 可变序列：可以对序列执行增，删，改操作，对象地址不发生更改 '''可变序列 列表，字典''' print('--------可变序列 列表，字典----------') lst = [10,20,30] print(id(lst)) lst.append(40) print(id(lst)) '''不可变序列，字符串，元组''' print('--------不可变序列，字符串，元组----------') s = 'hello' print(id(s)) s = s+'world' print(id(s)) print(s) # 元组的创建方式 小括号（） print('--------元组的创建方式 第一种使用()----------') t = ('python','hello',52) print(t) print(type(t)) print('--------省略了小括号----------') t2 = 'python','world',98 print(t2) print(type(t2)) print('--------只有一个值的时候必须加上逗号----------') t3 = ('python',) #如果元组中只有一个元素 逗号不能省 print(type(t3)) print('--------第二种使用内置函数tuple()----------') t1 = tuple(('python','world',95)) print(t1) print(type(t1)) print('--------空列表的创建方式----------') print('--------空字典的创建方式----------') lst = [] lst1 = list() d = {} d2 = dict() print('--------空元组---------') t4 = () t5 = tuple() print('空列表',lst,lst1) print('空字典',d,d2) print('空元组',t4,t5)
元组的遍历 # 元组是可迭代对象，所以可以使用for……in进行遍历 '''元组的遍历''' t = ('python','world',98) '''第一种获取元组的方式，使用索引''' print(t[0]) print(t[1]) print(t[2]) # print(t[3]) IndexError: tuple index out of range '''遍历元组''' for item in t: print(item)
为什么要将元组设计成不可变序列 # 为什么要将元组设计成不可变序列 # 在多任务环境下，同时操作对象时不需要加锁 # 因此，在程序中尽量使用不可变序列 # 注意事项：元组中储存的是对象的引用 # a如果元组中对象本身是不可对象，则不能再引用其他对象 # b如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变 t = (10,[20,30],9) print(t) print(type(t)) print(t[0],type(t[0]),id(t[0])) print(t[1],type(t[1]),id(t[1])) print(t[2],type(t[2]),id(t[2])) print('----------尝试将t[1]修改为100---------') print(id(100)) # t[1] = 100 我们的元组是不允许修改元素的 '''由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不要''' t[1].append(100) print(t,id(t[1]))
列表
为什么需要列表 a = 10 #变量存储的是一个对象的引用 lst = ['hello','world',98] print(id(lst)) print(type(lst)) print(lst) 列表的创建 '''创建列表的第一种方式，使用[]''' lst = ['helllo','world',98] '''创建列表的第二种方式，使用内置函数list（）''' lst2 = list(['hello','world',98]) print(lst2) # 列表的特点 # 列表元素按顺序有序排列 # 索引映射唯一个数据 # 列表可以存储重复数据 # 任意数据类型混存 # 根据需要动态分配和回收内存 列表的生成式 lst = [i*i for i in range(1,10)] print(lst) '''列表中的元素的值为2,4,6,8,10''' lst2 = [i*2 for i in range(1,6)] print(lst2) 列表元素添加操作 # append()向列表的末尾添加一个元素 lst = [10,20,30] print('添加元素之前：',lst,id(lst)) lst.append(1000) print('添加元素之后：',lst,id(lst)) # extend()在列表的末尾至少添加一个元素 lst2 = ['hello','world'] # lst.append(lst2) #将lst2做为一个元素添加到列表末尾 lst.extend(lst2) # 向列表的末尾一次性添加多个元素 print(lst) # 在任意位置上添加元素 lst.insert(5,90) print(lst) lst3 = [True,False,'heelo'] # 在任意的位置上添加N多个元素 lst[1:] = lst3 print(lst) 列表元素的排序 # 常见的两种方式 # 调用sort()方法，列表中的所有元素默认按照从大到小的顺序进行排序，可以指定reverse = True，进行降序排序 # 调用内置函数sored()，可以指定reverse = True，进行降序排序，是产生新的列表对象 原列表不发生改变 lst = [1,5,8,6,3,4] print('排序前的列表',lst,id(lst)) #开始排序，调用列表对象的sort方法，升序排序 lst.sort() print('排序后的列表',lst,id(lst)) #指定的关键字参数，将列表中的元素进行降序排序 lst.sort(reverse = True) #reverse=True 表示降序排序，reverse = False就是升序排序 print(lst) lst.sort(reverse = False) print(lst) print('---------------使用内置函数sorted()对列表进行排序，将生产一个新的列表对象-------------') lst = [1,5,8,6,3,4] print('原列表',lst,id(lst)) # 开始排序 new_list = sorted(lst) print(lst) print(new_list) # 指定关键字参数，实现列表元素的降序操作 desc_list = sorted(lst,reverse = True) print(desc_list) desc_list = sorted(lst,reverse = False) print(desc_list) lst = [10,20,30,40,50,60,30] lst.remove(30) #从列表中移除一个元素，如果有重复元素只移动第一个元素 print(lst) #lst.remove(100) ValueError: list.remove(x): x not in list #pop()根据索引移除元素 lst.pop(1) print(lst) #lst.pop(5)IndexError: pop index out of range 如果不存在会抛出异常 lst.pop() #如果不指定参数（索引），会删除列表中的最后一个元素 print(lst) print('--------------切片操作-删除至少一个元素，将产生一个新的列表对象--------') new_list = lst[1:3] print('原列表',lst) print('切片后的列表',new_list) '''不产生新的列表对象，而是删除列表中的内容''' lst[1:3] = [] print(lst) '''清除列表中所有的元素''' lst.clear() print(lst) '''del语句将列表对象删除''' del lst # print(lst) NameError: name 'lst' is not defined 删除了没有定义 列表的判断 #判断 print('p' in 'python') #True print('k' not in 'python') #True lst = [10,20,'python','hello'] print(10 in lst) #True print(100 in lst) #False print(10 not in lst) #False 列表的遍历 # 列表元素的遍历 for item in lst: print(item) 获取列表中的指定元素 lst = ['hello','world',98,'world'] #获取索引为2的元素 print(lst[2]) # 获取索引为-3的元素 print(lst[-3]) # 获取索引为10的元素 print(lst[10]) #程序抛异常 列表中的切片操作 lst = [1,2,3,4,5,6,7,8,9] # start = 1,stop = 6,step = 1 # print(lst[1:6:1]) print('原列表',id(lst)) lst2 = lst[1:6:1] print('切片的片段：',lst2) print(lst[1:6])#默认步长为1 print(lst[:5]) print(lst[1:]) print('------------step步长为负数的情况---------------') print('原列表：',lst) print(lst[::-1]) #start = 7,stop 省略 step = -1 print(lst[7::-1]) #start = 6,stop = 0 step = -2 print(lst[6:0:-2]) 获取列表中位置的指定索引 lst = ['hello','world',98] print(lst.index('hello')) #如果列表中有相同元素只返回列表中相同元素的第一个元素的索引 # print(lst.index('hell等等lo')) ValueError: 'helllo' is not in list 列表元素中的删除操作 lst = [10,20,30,40,50,60,30] lst.remove(30) #从列表中移除一个元素，如果有重复元素只移动第一个元素 print(lst) #lst.remove(100) ValueError: list.remove(x): x not in list #pop()根据索引移除元素 lst.pop(1) print(lst) #lst.pop(5)IndexError: pop index out of range 如果不存在会抛出异常 lst.pop() #如果不指定参数（索引），会删除列表中的最后一个元素 print(lst) print('--------------切片操作-删除至少一个元素，将产生一个新的列表对象--------') new_list=lst[1:3] print('原列表',lst) print('切片后的列表',new_list) '''不产生新的列表对象，而是删除列表中的内容''' lst[1:3]=[] print(lst) '''清除列表中所有的元素''' lst.clear() print(lst) '''del语句将列表对象删除''' del lst # print(lst) NameError: name 'lst' is not defined 删除了没有定义
集合
集合的概述与创建
# 集合
# python语言提供的内置数据结构
# 与列表，字典一样都属于可变类型的序列
# 集合是没有value的字典 # 集合的创建方式
'''第一种创建方式使用{}'''
s = {'python','hello',90,1,5,6} #集合中的元素不允许重复 会自动排序
print(s)
'''第二种创建方式使用内置函数set()'''
s1 = set(range(6))
print(s1,type(s1))
s2 = set([1,5,4,8,3,6,9])
print(s2,type(s2))
s3 = set((1,2,3,6,5,65)) #集合中的元素是无序的
print(s3,type(s3))
s4 = set('python')
print(s4,type(s4))
s5 = set({12,55,6,82,35})
print(s5,type(s5))
# 定义一个空集合
s6 = {} #dict字典类型 不可以直接使用
print(type(s6))
s7 = set()
print(type(s7))
集合的数学操作 # 集合的数学操作 # （1）交集 s1 = {10,20,30,40} s2 = {20,30,40,50,60} print(s1.intersection(s2)) print(s1 & s2) #intersection() 与 & 等价，交集操作 print(s1) print(s2) # (2)并集操作 print(s1.union(s2)) print(s1 | s2) #union() 与 | 等价，并集操作 print(s1) print(s2) #（3）差集操作 s1和s2比 s1里面s2没有的就是差集 print(s1.difference(s2)) print(s1-s2) #difference() 与 - 等价，差集操作 # （4）对称差集 s1和s2比 s1和s2都没有的就是对称差集 print(s1.symmetric_difference(s2)) print(s1 ^ s2) #symmetric_difference() 与 ^ 等价，对称差集操作 集合的相关操作
# 集合元素的判断操作 # in或not in # 集合元素的新增操作 # 调用add()方法，一次添加一个元素 # 调用update()方法至少添加一个元素 # 集合元素的删除操作 # 调用remover()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError # 调用discard()方法，一次删除一个指定的元素，如果指定的元组不存在抛出异常 # 调用pop()方法，一次只删除一个任意元素 # 调用clear()方法，清空集合 s = {20,30,40,50,60,70} print('---------集合元素的判断操作----------') print(20 in s) #True print(11 in s) #False print(20 not in s) #False print(100 not in s) #True print('---------集合元素的新增操作----------') s.add(80) #add一次添加一个元素 print(s) s.update({200,44,500,822}) #至少添加一个元素 print(s) print('---------集合删除操作') s.remove(200) print(s) # s.remove(500) KeyError: 500 # s.discard(800) 删除元素不存在不会抛出异常 # print(s) s.pop() #删除任意元素 不能在括号里面指定参数不然会抛出异常 s.pop() print(s) s.clear() #清空集合 print(s)
集合间的关系 # 集合间的关系 # 两个集合是否相等 # 可以使用运算符==或!=进行判断 # 一个集合是否是另一个集合的子集 # 可以调用方法issubset进行判断 # B是A的子集 # 一个集合是否是另一个集合的超集 # 可以调用方法issuperset进行判断 # A是B的超集 # 两个集合是否没有交集 # 可以调用方法isdisjoint进行判断 # 两个集合是否相等（元素相同，就相同） s={10,20,30,40} s2={30,40,20,10,} print(s==s2) #True print(s!=s2) #False '''一个集合是否是另一个集合的子集''' s1={10,20,30,40,50,60} s2={10,20,30,40} s3={10,20,90} print(s2.issubset(s1)) #True print(s3.issubset(s1)) #False '''一个集合是否是另一个集合的超集''' print(s1.issuperset(s2)) #True print(s1.issuperset(s3)) #False '''两个集合是否含有交集''' print(s2.isdisjoint(s3)) #False 有交集为False s4={100,200,300} print(s2.isdisjoint(s4)) #True 没有交集True
集合生成式
# 列表生成式 lst = [i*i for i in range(10)] print(lst) # 集合生成式 s = {i*i for i in range(10)} print(s) # 元组生成式 应为元组里面的值不能被改变 所以输出<generator object <genexpr> at 0x0000020D3ED08990> # s = (i*i for i in range(6)) # print(s) # 列表，字典，元组，集合总结 # 数据结构 是否可变 是否重复 是否有序 定义符号 # 列表（list） 可变 可重复 有序 [] # 元组（tuple） 不可变 可重复 有序 () # 字典(dict) 可变 key不可重复 无序 {key:value} # value可重复 # 集合（set） 可变 不可重复 无序 {} # 使用（）小括号 # 元 创建元组 内置函数tuple() # 组 元组的遍历 for……in # 不可变序列 # 使用{}花括号 # 创建集合 内置函数set() # 集合生成式 # 集合的遍历 for……in # add() # 集合 新增 # update() # # remover() # 删除 discard() # pop() # clear() # 可变序列
基础函数总结
i.isdigit() #判断是否是数字组成 i.isalpha() #判断是否有字母组成 append() #是追加一个值 在元组（） 字典{} 中是无法使用的 range() #函数(起始位置 终止位置 步长) range(1,11,2) #取奇数 range(0,11,2) #取偶数 len() #获取遍历对象的长度 max() #取最大值 min() #取最小值 import random #随机函数 print(random.randint(1,100))#从1~100中随机输出数字 sort() #从小到大 reverse() #从大到小 index() #获取元素下标 import time #时间日期模块 print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) 列表 list() 元组 tuple() 字典 dict() 集合 set() 获取数据类型 type() 数据地址 id() 计算字符串长度 join() AIIS值 chr()
异常处理机制pycharm的调试模式
traceback 模块打印异常信息
import traceback try: print('-----------------') print(1/0) except: traceback.print_exc()
常见的异常类型 # ZeroDivsionError 除（或取模）零（所有的数据类型） # IndexError 序列中没有此索引（index） # KeyError 映射中没有这个键 # NameError 未声明/初始化对象（没有属性） # SyntaxError python语法错误 # ValueError 传入无效的参数 # （1）数学运算异常 #print(10/0) ZeroDivisionError lst=[11,22,33,44] # print(lst[4]) IndexError 索引从0开始 dic={'name':'张三','age':17} #print(dic['gender']) KeyError # print(num) NameError num没有被定义 # int a=20 SyntaxError 语法错误 # a=int('hello') ValueError 无效参数 异常处理机制（1）
# Bug的常见类型 # 被动掉坑问题的解决方案 # python提供了异常处理机制，可以在异常出血是即使捕获，然后内部‘消化’让程序继续运行 try: n1=int(input('请输入第一个整数：')) n2 = int(input('请输入第一个整数：')) result=n1/n2 print('结果为：',result) except ZeroDivisionError: print('异常处理机制 数字以0停止或没输入') except ValueError: print('异常处理机制 数字以字母停止') print('程序结束')
异常处理机制（2）
# try……except……else……finally结构 # finally快无论是否发生异常都会被执行，能常用来释放try块中申请的资源 try: a=int(input('请输入第一个整数：')) b=int(input('请输入第二个整数：')) result=a/b except BaseException as e: print('出错了',e) else: print('计算结果为：',result) finally: print('无论是否产生异常，总会被执行的代码') print('程序结束')
模块
什么是模块 模块化的编程好处
# 模块 # 模块的英文为Modules # 函数与模块的关系 # 一个模块中可以包含N多个函数 # 在Python中一个扩展名为.py的文件就是一个模块 # 使用模块的好处 # 方便其它程序和脚本的导入并使用 # 避免函数名和变量名冲突 # 提高代码的可维护性 # 提高代码可重用性 def fun(): pass def fun2(): pass class Student: native_place = '吉林' #类属性 def eat(self,name,age): self.name = name self.age = age @classmethod def cm(cls): pass @staticmethod def sm(): pass a = 10 b = 20 print(a+b) 模块的导入两种方式 import pageagel.module_A as ma #ma是pageagel.module_A 这个模块的别名 as是给这个模块取名为ma from pageagel import module_A
自定义模块的使用
# 自定义模块 # 新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同 # 导入模块 # import 模块名称 [as 别名] # from 模块名称 import 函数/变量/类
自定义一个为mokuai1的模块名.py def add(a,b): return a + b def div(a,b): return a / b
# 在 导入自定义mokuai1 中导入 mokuai1 并且使用 import mokuai1 #如果报错 右击模块 点击目录标记为 点击蓝色的Sources Root print(mokuai1.add(10,20)) #相加 print(mokuai1.div(2,8)) #想除 print("----------------------------") from mokuai1 import add print(add(2,5)) 模块导入的使用 import math #关于数学运算 print(id(math)) print(type(math)) print(math) print(math.pi) print("----------------------------------") print(dir(math)) print(math.pow(2,8)) #相当于2的8次方 print(math.ceil(8.0001)) #小数取整数 往大取 输出结果 9 print(math.floor(9.9999)) #小数取整数 往小取 输出结果 9 print("----------------------------------") from math import pi #指定调用math中的pi方法 print(pi) print(pow(4,2)) print("----------------------------------")
schedule模块循环调动 import schedule import time def job(): print('gege！！！') print(time.localtime(time.time())) schedule.every(3).seconds.do(job) #每三秒钟去执行以下job()函数 while True: schedule.run_pending() #去启动schedule time.sleep(1) #准备缓存的时间 没隔3秒去输出并且休眠1秒
函数
函数的创建和调用 # 创建函数 def calc(a,b): c = a+b return c # 调用函数 result = calc(10,20) print(result) 函数调用的参数传递 # 位置实参 # 根据形参对应的位置进行实参传递 # 关键字实参 # 根据形参名称进行实参传递 # 创建函数 def calc(a,b): #a b称为形式参数，简称形参，形参的位置是在函数的定义处 c = a+b return c # 调用函数 result = calc(10,20) #20 30称为实际参数的值，简称实 参，实参的位置是函数的调用处 print(result) res = calc(b = 10,a = 20) # =左侧的变量的名称称为 关键字参数 print(res) 函数的参数传递内存分析 '''在函数调用过程中，进行参数的传递 如果是不可变对象，在函数体的修改不会影响实参的值 arg1的修改为100，不会影响到n1的值 如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改，append(10)，会影响到n2的值 ''' 函数的参数定义_个数可变的位置参数_关键字形参 # 函数的参数定义 # 个数可变的位置参数 # 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数 # 使用*定义个数可变的的位置形参 # 结果为一个元组 def fun(*args): #函数定义时的 可变的位置参数 print(args) #print(args[0]) fun(10) fun(10,30) fun(30,405,50) # 个数可变的关键字形参 # 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参 # 使用**定义个数可变的关键字形参 # 结果为一个字典 def fun(**args): print(args) fun(a = 10) fun(a = 20,b = 30,c = 40) print('hello','python','java') '''def fun2(*args,*a): pass 以上代码，程序会报错，个数可变的位置参数，只能是1个 def fun2(**args,**args): pass 以上代码，程序会报错，个数可变的位置参数，只能是1个 ''' def fun2(*args1,**args2): pass '''def fun3(**args1,*arg2): pass 在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参 要求，个数可变的位置形参，放在个数可变的关键字形参之前 ''' 函数的返回值 # 函数的返回值 # 函数返回多个值时，结果为元组 def fun(num): odd = [] #存奇数 even = [] #存偶数 for i in num: if i%2: odd.append(i) else: even.append(i) return odd,even #函数的调用 lst = [10,29,34,23,44,53,55] print(fun(lst)) '''函数的返回值 （1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写 （2）函数的返回值，如果是1个，直接返回原值类型 （3）函数的返回值，如果是多个，返回的结果为元组''' def fun1(): print('hello') # return fun1() def fun2(): return 'hello' res = fun2() print(res) def fun3(): return 'hello','world' print(fun3()) '''函数在定义时是否需要返回值，视情况而定'''
函数变量的作用域 def fun(a,b): c = a+b #c 就称为局部变量，因为c是在函数体内进行定义的变量，a b为函数的形参，作用范围也是 #函数内部，相当于局部变量 print(c) # print(c) 报错 因为a,c超出了起作用的范围（超出了作用域） # print(a) name = '韩老师' print(name) def fun2(): print(name) #全局变量 #调用函数 fun2() def fun3(): global age #函数内部定义的变量，局部变量，局部变量使用了global声明，这个局部变量会变成全局变量 age = 17 print(age) fun3() print(age) 函数定义默认值参数 # 函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参 def fun(a,b = 10): #b称为默认值参数 print(a,b) #函数的调用 fun(100) fun(20,30) print('hello',end='\t') print('world') def fun1(a = 10): print(a) fun1()
递归函数 # 什么是递归函数 # 如果在一个函数的函数体内调用了该函数本身，这个函数就被称为递归函数 # 递归的组成部分 # 递归调用与递归终止条件 # 递归的调用过程 # 每递归用一次函数，都会在栈内存分配一个栈帧 # 每执行完一次函数，都会释放相应的空间 # 递归的优缺点 # 缺点：占用内存多，效率多 # 优点：思路和代码简单 def fac(n): if n == 1: return 1 else: res = n*fac(n-1) return res print(fac(6)) 斐波那契数列 def fid(n): if n == 1: return 1 elif n == 2: return 1 else: return fid(n-1)+fid(n-2) # 斐波那契数列第6位上的数字 print(fid(6))
面向对象
object类 # object类是所有类的父亲，因此所有类都有object类的属性和方法 # 内置函数dir()可以查看指定对象所有属性 # object有一个_str_()方法，用于返回一个对于“对象的描述”，对应 # 内置函数str()经常用于print()方法，帮我们查看对象的信息， # 所以我们经常会对_str_()进行重写 class Student: #没有定义类 会默认定义object类 pass stu = Student() print(dir(stu)) #查看内置函数dir()对象属性 print(stu) #<__main__.Student object at 0x00000133D9A0D828> 输出对象的内存地址 # __str__()方法 class Trudent: def __init__(self,name,age): self.name = name self.age = age def __str__(self): return '我的名字是{0}，今年{1}岁'.format(self.name,self.age) Ag = Trudent('小※※',25) print(Ag) #会默认调用__str__()方法 print(type(Ag)) 多态 # 多态 # 多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型， # 依然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调 # 用哪个对象的方法 class Xiaomi(object): def eat(self): print('小米品牌') class Shouji(Xiaomi): def eat(self): print('红米K40pro') class Diannao(Xiaomi): def eat(self): print('红米') class Moren: def eat(self): print("性价比王") # 定义一个函数 def fun(obj): obj.eat() # 开始调用函数 fun(Xiaomi()) fun(Shouji()) fun(Diannao()) print('---------------------------') fun(Moren()) 封装 # 面向对象的三大特征 # 封装：提高程序的安全性 # 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在 # 类对象的外部调用的方法。这样，无需关系方法内部的具体实现细节，从而隔离了复 # 杂度 class Car: def __init__(self,brand): self.brand = brand def start(self): print('汽车已启动……') car = Car('红旗H9') car.start() print(car.brand) # 在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被 # 访问，前边使用两个“_” class Student: #类对象 def __init__(self,name,age): self.name = name self.__age = age #年龄不希望在类的外婆被使用，所以加了两个_ def show(self): print(self.name,self.__age) stu = Student('小军',17) stu.show() # 在内的外部使用name与age print(stu.name) # print(stu.__age)当程序遇到两个_的时候计算机就知道 这个属性不希望在内的外部被使用 # 非要使用 print(dir(stu)) print(stu._Student__age) #在类的外部可以通过_Student__age进行访问 # 多态：提高程序的可扩展性和可维护性 继承 # 语法格式 # class 子类类名(父类1，父类2): # pass # 如果一个类没有继承任何类，则默认继承object # python支持多继承 # 定义子类时，必须在其构造数中调用父类的构造函数 # 继承：提高代码的复用性 class Person(object): #Person继承object类 def __init__(self,name,age): self.name = name self.age = age def info(self): print(self.name,self.age) class Student(Person): def __init__(self,name,age,stu_no): super().__init__(name,age) self.stu_no = stu_no class Teacher(Person): def __init__(self,name,age,teachofyear): super().__init__(name,age) self.teachofyear = teachofyear stu=Stu dent('小米',20,'1001') teacher = Teacher('李老师',20,1) stu.info() teacher.info() # 多次继承 class A(object): def __init__(self,name,age): self.name = name self.age = age def fun(self): print(self.name,self.age) class B(object): def __init__(self,name,age): self.name = name self.age = age def fun(self): print(self.name,self.age) class C(A,B): def __init__(self,name,age): super().__init__(name,age) name1 = B('小明',17) name2 = C('小军',17) name1.fun() name2.fun() _new_与_init_演示创建过程 class Person(object): def __new__(cls, *args, **kwargs): print("__new__被调用执行了，cls的id值为{0}".format(id(cls))) obj = super().__new__(cls) print('创建的对象的id为：{0}'.format(id(obj))) return obj def __init__(self, name, age): print('__init__被调用了，self的id值为：{0}'.format(id(self))) self.name = name self.age = age print('object这个类对象的id为：{0}'.format(id(object))) print('Person这个类对象的id为：{0}'.format(id(Person))) p1 = Person('张三',20) print('p1这个Person类的实例对象的id为：{0}'.format(id(p1))) 方法重写 # 如果子类对继承自父类的某个属性的方法不满意，可以在子类中对其（方法体）进行重写编写 # 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法 class Person(object): #Person继承object类 def __init__(self,name,age): self.name = name self.age = age def info(self): print(self.name,self.age) class Student(Person): def __init__(self,name,age,stu_no): super().__init__(name,age) self.stu_no = stu_no def info(self): super().info() print("成绩：",self.stu_no) class Teacher(Person): def __init__(self,name,age,teachofyear): super().__init__(name,age) self.teachofyear = teachofyear def info(self): super().info() print("教龄：",self.teachofyear) stu = Student('同学：小米','年龄：20',85) teacher = Teacher('老师：米老师','年龄：25',12) stu.info() print('------------------------------') teacher.info() 特殊属性 # 特殊属性 _dict_ 获取类对象或实例对象所绑定的所有属性和方法的字典 # _len_ 通过重写_len_()方法，让内置函数len()的参数可以是自定义类型 # _add_ 通过重写_add_()方法，可使用自定义对象具有“+”功能 # 特殊方法 # _new_ 用于创建对象 # _init_ 对创建的对象进行初始化 class A: pass class B: pass class C(A,B): def __init__(self,name,age): self.name=name self.age=age class D(A): pass # 创建C类的对象 x = C('Jack',20) #x是C类型的实例对象 print(x.__dict__) #实例对象的属性字典 print(C.__dict__) print("--------------------------") print(x.__class__) #<class '__main__.C'> 输出了对象所属的类 print(C.__bases__) #(<class '__main__.A'>, <class '__main__.B'>) C类的父类型的元素 print(C.__base__) #<class '__main__.A'> 输出类元素的第一个类 print(C.__mro__) #查看类的层次结构 print(A.__subclasses__()) #子类的列表 特殊方法 a = 20 b = 100 c = a + b #两个整数类型的对象的相加操作 d = a.__add__(b) print(c) print(d) class Student: def __init__(self,name): self.name=name def __add__(self, other): return self.name + other.name def __len__(self): return len(self.name) stu1 = Student('小明') stu2 = Student('小红') s = stu1 + stu2 #实现了两个对象的加法运算（因为在Student类中 编写_add_()特殊的方法） print(s) s = stu1.__add__(stu2) print(s) print('-----------------------------') lst = [11,22,33,44] print(len(lst)) #len 是内置函数 计算列表的长度 print(lst.__len__()) #_len_() 特殊方法对应内置函数 len() print(len(stu1),len(stu2)) 类的赋值与浅拷贝 深拷贝 a = 20 b = 100 c = a + b #两个整数类型的对象的相加操作 d = a.__add__(b) print(c) print(d) class Student: def __init__(self,name): self.name=name def __add__(self, other): return self.name + other.name def __len__(self): return len(self.name) stu1 = Student('小韩') stu2 = Student('小军') s = stu1 + stu2 #实现了两个对象的加法运算（因为在Student类中 编写_add_()特殊的方法） print(s) s = stu1.__add__(stu2) print(s) print('-----------------------------') lst = [11,22,33,44] print(len(lst)) #len 是内置函数 计算列表的长度 print(lst.__len__()) #_len_() 特殊方法对应内置函数 len() print(len(stu1),len(stu2))
类和对象
类和对象的创建 #class Student: #Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写 # pass #Python中一切皆对象Student是对象吗？内存有开空间吗？ #print(id(Student)) #1292798748888 #print(type(Student)) #<class 'type'> #print(Student) <class '__main__.Student'> class Student: native_pace = '田小姐' #直接写在类里的变量，称为类属性 def __init__(self,name,age): self.name=name #self.name 称为实体属性，进行了 一个赋值的操作 将局部变量的name赋值给实体属性 self.age=age # 实例方法 def eat(self): print('田小姐说早起的……') # 静态方法 @staticmethod def method(): print('我使用了staticmethod进行修饰，所以我是静态方法') # 类方法 @classmethod def cm(cls): print('我的类方法，因为我是使用了classmethod进行修饰') #在类之外定义的称为函数，在类之内定义的称为方法 def drink(): print('早') # 创建Student类的对象 stul=Student('张三',20) # print(id(stul)) # print(type(stul)) # print(stul) # print('-----------------------') # print(id(Student)) #Student是类的名称 # print(type(Student)) # print(Student) stul.eat() #对象吗.方法名() print(stul.name) print(stul.age) print('------------------------------') Student.eat(stul) #47行和42行代码功能相同，都是调用Student中的eat方法 #类名.方法名(类的对象)-->实际上就是方法定义处的self Student.method() Student.cm() drink() 类属性 类方法 静态方法 # 类属性：类中方法外的变量称为类属性，被该类的所有的对象共享 # 类方法：使用@classmethod修饰的方法，使用类名直接访问的方法 # 静态方法：使用@staicmethod修饰的主法，使用类名直接访问的方法 class Student: native_pace='米姐姐' #直接写在类里的变量，称为类属性 def __init__(self,name,age): self.name = name #self.name 称为实体属性，进行了 一个赋值的操作 将局部变量的name赋值给实体属性 self.age=age # 实例方法 def eat(self): print('米姐姐说早起的鸟儿有虫吃') # 静态方法 @staticmethod def method(): print('我使用了staticmethod进行修饰，所以我是静态方法') # 类方法 @classmethod def cm(cls): print('我的类方法，因为我是使用了classmethod进行修饰') # 类属性的使用方式 print(Student.native_pace) stul=Student('小明',17) stu2=Student('小红',19) print(stul.native_pace) print(stu2.native_pace) Student.native_pace='哄老师' print(stul.native_pace) print(stu2.native_pace) print('------------------类方法的使用方式---------------') Student.cm() print('------------------静态方法的使用方式---------------') Student.method() 动态绑定属性和方法 class Student: def __init__(self,name,age): self.name = name self.age = age def eat(self): print(self.name+'在吃饭') stu1 = Student('张三',20) stu2 = Student('小军',17) print(id(stu1)) print(id(stu2)) print('----------------为sru2动态绑定性别属性------------') stu2.gender = '狗' print(stu1.name,stu1.age) print(stu2.name,stu2.age,stu2.gender) print('-----------------------') stu2.eat() stu1.eat() def show(): print('定义在内之外的，称函数') stu1.show = show #动态绑定方法 stu1.show() # stu2.show() 因为stu2并没有绑定show方法
编码格式 文件with 目录 等操作
编码格式 #encoding = gbk # 修改编码格式 print('你好，Python') # 在python中默认的编码格式是UTF-8的格式 # 不同的编码格式决定占用磁盘大小内存 encoding='utf-8' #UTF-8可以改变 文件打开模式 # 文件的类型 # 按文件中数据的组织形式，文件分为以下两大类 # 文本文件：存储的是普通“字符”文本，默认为uniconder字符集，可以使用记事本程序打开 # 二进制文件：把数据内容用“字节”进行储存，无法用记事本打开，必须使用专用的软件打开 # 打开模式 # r：以只读模式打开文件，文件的指针会放在文件的开头 # w：以只写模式打开文件，如果文件不存在则创建，如果文件存在，覆盖原有内容，文件指针放在文件的开头 # a：以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾 # b：以二进制方式打开文件，不能单独使用，需要与共它模式一起使用，rb，或者wd # +：以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+ 文件对象的常用方法 # 文件对象的常用方法 # read([size]) 从文件中读取size个字节或字符的内容返回。若省略[size], # 则读取到文件末尾，即一次读取文件所有内容 # readliine() 从文本文件中读取一行内容 # radlines() 把文本文件中每一行都作为独立的字符串对象，并将这些对象 # 放入列表返回 # write(str) 将字符串str内容写入文件 # writelines(s_list) 将字符串列表s_list写入文本文件，不添加换行符 # 把文件指针移动到新的位置，offset表示相当于whence的位置： # offset：为正往结束方向移动，为负往开始方向移动 # seek(offset[,whencel]) whence 不同的值代表不同的含义 # 0：从文件头开始计算（默认值） # 1：从当前位置开始计算 # 2：从文件尾开始计算 # tell() 返回文件指针的当前位置 # flush() 把缓冲区的内容写入文件，单不关闭文件 # close() 把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源 with print(type(open('a.text','r'))) with open('a.text','r') as file: print(file.read()) #不用手动关闭 避免造成资源浪费 # with 文件的复制 with open('内涵 .png','rb') as src_file: with open('内涵3 .png','wb') as target_file: target_file.write(src_file.read()) os模块操作 # os模块操作目录相关函数 # getcwd() 返回当前的工作目录 # listdir(path) 返回指定路径下的文件和目录信息 # mkdir(path[,mode]) 创建目录 # makedirs(path1/path2……[,mode]) 创建多级目录 # rmdir(path) 删除目录 # removedirs(path1/path2……) 删除多级目录 # chdir(path) 将path设置为当前工作目录 os.path模块 # abspath(path) 用于获取文件或目录的绝对路径 # exists(path) 用于判断文件或目录是否存在，如果存在返回true否则返回false # joib(path,name) 将目录与目录或文件名拼接起来 # splitext() 分离文件名和扩展名 # basename(path) 从一个目录中提取文件名 # dirname(path) 从一个路径中提供文件路径，不包括文件名 # isdir(path) 用于判断是否为路径
浙公网安备 33010602011771号