首页 文章 精选 留言 我的

精选列表

搜索[全栈工程师],共10005篇文章
优秀的个人博客,低调大师

Python全栈工程师

ParisGabriel Python 入门基础 print(“hello world”)变量 : 存储信息的,日后被调用、修改操作常量: 固定不变的量,字母大写命名规则:1. 字母数字下划线组成2. 不能以数字开头,不能含有特殊字符和空格3. 不能以保留字命名4. 不能以中文命名5. 定义的变量名应该有意义6. 驼峰式命、 下划线分割单词7. 变量名区分大小写a=1b=2if a<b: print("Yes") print("Yes") print("Yes") print("Yes")else: print("No")a=1b=2 if a>b: print("Yes") elif a==b: print("第三") else: print("any") if 条件1: 自拍elif 条件2: 蹦 else: 跳舞 # 单行注释'''多行注释'''""" 多行注释 """ input() "abc" + "qwe" file.py 文件的扩展名:.py : python的程序文件.txt : 文本文件pdf chm html doc xml xls ppt jpg png gif jpeg bmpavi rmvb MP4 mkv 3gp WMV MP3 flue mid True 真 正确的False 假 错误的 a b = 100c = 1000 if b <= a <= c: print("True") num number num1 = intpu("Num1:")num2 = intpu("Num2:")num3 = intpu("Num3:") 输出三个数字中的最大值/最小值 if num1>num2>num3: #num1最大else: #num1<num2 if num1>num2>num3 #num1最大elif num1>num3>num2 #num1最大elif num2>num1>num3 #num2最大elif num2>num3>num1 #num2最大elif num3>num2>num1 #num3最大else num3>num1>num2 #num3最大 num1 num2 num3 max_num =0if num1>num2: max_num= num1 if max_num > num3: print("Max NUM is",max_num) else: print("Max NUM is",num3)else: max_num = num2 if max_num > num3: print("Max NUM is",max_num) else: print("Max NUM is",num3) num += 1 等价于 num = num + 1num -= 1 等价于 num = num - 1num *= 2 等价于 num = num * 2num /= 2 等价于 num = num / 2num //= 2 等价于 num = num // 2num %= 2 等价于 num = num % 2num **= 2 等价于 num = num ** 2 and 且,并且只有两个条件全部为True(正确)的时候, 结果才会为True(正确) 条件1 and 条件2 5>3 and 6<2 True or 或,或者只要有一个条件为True,则结果为Ture,5>3 or 6<2 真 或 假 not 不,雅蠛蝶 not 5>3 == Falsenot 5<3 == True a>b and (c>d or (not f)) (not (not True)) or (False and (not True)) 条件1 and 条件2条件1 or 条件2 短路原则对于and 如果前面的第一个条件为假,那么这个and前后两个条件组成的表达式 的计算结果就一定为假,第二个条件就不会被计算 对于or 如果前面的第一个条件为真,那么这个or前后两个条件组成的表达式 的计算结果就一定为真,第二个条件就不会被计算 True or True and False 猜年龄 age = 50 user_input_age = int(input("Age is :"))if ....while 循环 while 条件: print("any") print("any") num = 1 while num<10: # 2 print(num) # 2 num+=1 # 3 if num == 9: # 3 breaknum = 1 while num<=100: # num<=100 等价于 True # while num<=100: 等价于 while True: if num%2 == 0: print(num) num += 1num = 1 while num<=100: if num%2 == 1: print(num) num += 1 age = 50 #user_input_age = int(input("Age is :")) flag = True while flag: user_input_age = int(input("Age is :")) if user_input_age == age: print("Yes") flag =False elif user_input_age > age: print("Is bigger") else: print("Is smaller") print("End") break # 终止age = 50 #user_input_age = int(input("Age is :")) #flag = True# break while True: user_input_age = int(input("Age is :")) if user_input_age == age: print("Yes") break elif user_input_age > age: print("Is bigger") else: print("Is smaller") print("End") continue 继续 if a>b and d<f or 5>3 and d == e: ...... while 条件: ....else: .... statement 语句 num = 1while num <= 10: num += 1 if num == 5: break print(num)else: print("This is else statement") while 条件1: ..... while 条件2: .... 1*1=11*2=2 2*2=41*3=3 2*3=6 3*3=9.... #print("hello world.",end="__") # \n \r\n \r#print("hello world.",end="__")#print("hello world.",end="__") num1 = 0 while num1<=5: print(num1,end="_") num2 = 0 while num2<=7: print(num2,end="-") num2+=1 num1+=1 print() # print(end="\n") #0_0-1-2-3-4-5-6-7-#1_0-1-2-3-4-5-6-7- Height 高度width 宽度 height = int(input("Height:")) # 用户输入一个高度width = int(input("width:")) # 用户输入一个宽度 num_height = 1while num_height <=height: num_width = 1 while num_width <= width: print("#", end="") num_width += 1 print() num_height += 1 12345678223456783234567842345678 第一行的时候 8字符 8次循环第二行的时候 8字符 8次循环第三行的时候 8字符 8次循环第四行的时候 8字符 8次循环 width = int(input("width:")) num_width = 1 while num_width<=width: print("#", end="") num_width +=1print() num_width = 1while num_width<=width: print("#", end="") num_width +=1print() num_width = 1while num_width<=width: print("#", end="") num_width +=1print() num_width = 1while num_width<=width: print("#", end="") num_width +=1 #print("#",end="")#print("#",end="")#print("#",end="")#print("#",end="") print() num = 4 while num>0: print("#", end="") num -= 1 print() # @ == #### height = int(input("Height:")) # 用户输入一个高度width = int(input("width:")) # 用户输入一个宽度 #num2 = height num2 = height # 第一步: 赋值while num2 > 0: # 第二步 :num2 == 2 num1 = width # 第三步: 赋值 while num1>0: # 第四部:num1==2 # 第七步:num1 = 1 print("#", end="") # 第五步: 不换行 打印一个# 第八步: 不换行 打印一个# num1 -= 1 #第六步: num1 = 1 第九步: num1 = 0 print() # 第十步 : 只是换行 num2 -= 1 # 第十一步 : num2=1 #### print("1*1=",1) # "1*1=",1 == str(m)+"*"+str(n)+"=",1 m = 2n = 2 print( str(m)+ "*" + str(n) + "=" , m*n )line = 5 # 第一步 : 赋值while line>0: # 第二部 line=5 tmp = line # 第三部 : tmp =5 tmp=4 while tmp>0: # 第四部 : tmp =5 #第七步 tmp=4 #第十部: tmp=3 第十三步 tmp=2 print("*",end="") #第五步 #第八部 #第十一部 #第十四步 tmp = tmp-1 # 第六步 tmp = 4 # 第九步 tmp=3 # 第十二步 tmp=2 第十五步 tmp= 1 print() #print(line) line -= 1first = 1while first<=9: sec = 1 while sec <= first: print( str(sec)+"*"+ str(first) +"="+str(sec * first), end="\t") sec += 1 print() first += 1 今天太晚了明天要上课 明天晚上补图片 代码

优秀的个人博客,低调大师

Python全栈工程师 (exercises)

# 1:给定一个数,判断他是正数,负数,还是0 a = int(input("请输入一该个整数")) if a == 0: print(a, "是0") elif a > 0: print(a, "是正数") else: print(a, "是负数") # 练习2:输入一个季度的数字 输出该季度有那几个月 b = int(input("请输入一个季度:1.春季2.夏季3.秋季4.冬季")) if b > 4: print(b, "不是季节") elif b < 0: print(b, "不是季节") else: if b == 1: print(b, "春季有:一月,二月,三月") elif b == 2: print(b, "夏季有:四月,五月,六月") elif b == 3: print(b, "秋季有:七月,八月,九月") else: print(b, "冬季有:十月,十一月,十二月") # 联系3:输入一个月份 输出这个月份在那个季度 c = int(input("请输入一个月份判断在那个季度")) if c < 0: print(c, "不是月份") elif c > 12: print(c, "不是月份") elif c < 4: print(c, "在春季") elif c < 7: print(c, "在夏季") elif c < 10: print(c, "在秋季") elif c <= 12: print(c, "在冬季") # 练习4:3公里内10元 超出1.9元/公里 超过15公里 每公里加50%回空费 3.15元/公里 # 输入公里 打印车费 d = int(input("请输入行驶公里数:")) if d <= 3: print("车费:10元") elif d > 4: if d < 15: g = (d - 3) * 1.9 + 10 print(d, "公里:", g, "元") else: f = (d - 15) * 3.15 * 1.5 + 12 * 1.9 + 10 print(d, "公里:", f, "元") elif d < 0: print("公里数输入错误") 练习: 1. 一个商店卖西瓜,7元一个,您带20元钱能买到几个西瓜? 剩多少元? 2. 一个学生毕业薪资10000元,每个涨薪 20%,请问十年后这个学生的薪资是多少? 1. 打印如下图形: ******* * * * * ******* 2. 已知矩形的长边长为6cm,短边长为4cm,用表达式求 1) 周长是多少? 2) 面积是多少? 练习: 1. 指定一个圆的半径是r = 9cm 1) 计算圆的周长 2) 计算圆的面积 2. 交量交换练习: 已知有两个变量: a 绑定 10000 b 绑定 20000 问,在不创建任何新数据对象的情况下,如何让a 和 b 交换绑定的对象 a = 10000 b = 20000 .... print(a) # 20000 print(b) # 10000 练习: 1. 中国古代的秤是16两一斤,请问古代对216两是古代的几斤几两,写程序打印出来? 2. 从凌晨 0:0:0 计时,到现在已经过了63320秒, 请问现在是几时,几分,几秒,写程序打印出来 提示: 可以用地板除和求余实现 3. 温度转换: 摄氏温度 = 5.0/9.0*(华氏温度-32) 请问100华氏温度是多少摄氏温度.写程序算出来 思考: 如果知道当前温度是摄氏温度度,能否算出华氏温度是多少? 练习: 将数字3.14 用变量pi绑定 将pi变量转为整数,用变量i绑定 将 pi 变量 与 i变量相减,结果用f变量绑定 1. 判断f是否等于 0.14? 为什么? 2. 删除所有的变量 (用交互模式来实现) 练习: 1. 输入两个整数, 分别用变量x, y绑定 1) 计算这两个数的和,并打印结果 2) 计算这两个数的积,并打印结果 3) 计算x的y次方并打印结果 如: 请输入x: 10 请输入y: 20 打印如下: 10 + 20 = 30 10 * 20 = 200 10 ** 20 = ... 2. 今天是小明20周岁的生日,假设每年有365天,计算它过了多少个星期天,余多少天 3. 分三次输入当前的小时,分钟和秒数,在终端打印时此距离凌晨0:0:0 秒过了多少秒 练习: 任意输入一个数 1) 判断这个数是否大于100 2) 判断这个数是否小于0 3)判断这个数是否在80~100之间 练习: 1. 输入一个季度 1~4的整数.输出这个季度有哪儿几个月,如果输入的不是1~4的整数,则提示用户您输错了 2. 输入一年中的月份(1~12) 输出这个月在哪儿个季度,如果输入的是其它数,则提示您输错了 思考: score = input('请输入学生成绩:') or '0' score = int(score) 请问这个or是在做什么? 练习: 1. 北京出租车计价: 收费标准: 3公里以内收费13元 基本单价: 2.3元/公里 (超出3公里以外) 空驶费:超过15公里后,每公里加收单价的50%的空驶费(即3.45元/公里) 要求: 输入公里数,打印出费用金额(以元为单位四舍五入) 2. 输入一个学生的三科成绩(三个整数): 打印出最高分是多少? 打印出最低分是多少? 打印出平均分是多少? 3. BMI指数(Body Mass Index) 以称身体质量指数 BMI值计算公式: BMI = 体重(公斤) / 身高的平方(米) 例如: 一个人69公斤,身高是173公分 BMI = 69 / 1.73**2 = 23.05 标准表: BMI < 18.5 体重过轻 18.5 <= BMI < 24 体重正常 BMI > 24 体重过重 要求: 输入身高的体重,打印出BMI的值并打印体重状况 思考: 如果一个字符串同时包含如下字符该怎么办? ' " ''' """ 练习: 试求出以下字符串含有多少个字符? '1234abcd' # 8 '5\'4"' # 4 '\"A\x34\U00006041' # 4 '\b\n\td\r' '\\nn\\x41' 练习: 写一个程序,打印一个高度为4行的矩形方框 要求输入一个整形数字,此整数代表矩形的宽度,输出此矩形 如: 请输入矩形宽度: 10 ########## # # # # ########## 请输入矩形宽度: 5 ##### # # # # ##### 练习: 输入一个字符串,打印如下内容: 1. 打印这个字符串的第一个字符 2. 打印这个字符串的最后一个字符 3. 如果这个字符串的长度是奇数,打印中间这个字符 注: 求字符串的长度的函数len(s) 练习: 1. 写一个程序,输入一个字符串,把字符串的第一个字符和最后一个字符去掉后,打印出处理后的字符串 2. 输入任意一个字符串,判断这个字符串是否是回文 回文示例: 上海自来水来自海上 ABCCBA 12321 (回文是指中心对称的文字) 练习: 1. 写一个程序,输入一段字符串,如果字符串不为空,把第一个字符的编码值打印出来 2. 写一个程序,输入一个整数值(0~65535), 打印出这个数值所对应的字符 练习: 1. 输入一个字符串用变量s绑定 1) 判断您输入的字符串有几个空格 2) 将原字符串的左右空白字符去掉, 打印出剩余的字符个数 3)判断您输入的是否是数字 4) 如果是数字,判断这个数字是否大于100 2. 输入三行文字,让这三行文字在一个方框内居中显示 如输入: hello! I'm studing python! I like python 显示如下 +---------------------+ | hello! | | I'm studing python! | | I like python | +---------------------+ 注:请不要输入中文 练习: 输入三行文字,让这三行文字依次以20个字符的宽度右对齐输出 如: 请输入第1行: hello world 请输入第2行: aaa 请输入第3行: ABCDEFG 输出结果如下: hello world aaa ABCDEFG 做完上面的题后思考: 能否以最长的字符串的长度进行右对齐显示(左侧填充空格) 问题: 输入一个整数n, 写程序打印如下: 这是第 1 行 这是第 2 行 这是第 3 行 ... 这是第 n 行 问题: 如何让一条语句重复执行多次? 用: print("这是第", i, '行') 能否实现 练习: 1. 输入一行字符串,将字符串中Unicode编码值最大的一个字符打印出来(不允许用max函数) (提示: while语句内可以嵌入 if 语句进行判断) 2. 打印 从零开始的浮点数,每个数增加 0.5, 打印出10以内的这样的数: 0.0 0.5 1.0 1.5 ... 9.5 练习: 1. 打印 1 ~ 20的整数 2. 打印从10开始 到 0(不包含0)之间的整数 3. 打印 1 ~ 20的整数,打印在一行内 4. 打印 1 ~ 20的整数,每行打印5个,打印四行如: 1 2 3 4 5 6 7 8 9 10 11 12 ..... ..... 提示: while中可以嵌入if语句来换行 5. 输入一个整数n, 打印出一个长方形 n 代表长方形的宽度的字符数和高的行数 例如: 请输入:4 打印: #### # # # # #### 请输入:6 打印: ###### # # # # # # # # ###### 练习: 输入一个数,打印指定宽度的正方形 如: 输入: 5 打印如下正方形: 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 如: 输入: 3 打印如下正方形: 1 2 3 1 2 3 1 2 3 练习: 1. 写程序,计算: 1 + 2 + 3 + 4 + ..... + 99 + 100的和 2. 写程序,任意输入一个数n,计算: 1 + 2 + 3 + 4 + ..... + (n-1) + n的和 问题: 如果在循环过程中不想再继续此循环语句的执行了,怎么办? 练习: 1. 任意输入一些数,当输入负数时结束输入 当输入完成后,打印您输入的这些数的和是多少? 2. 写程序求: Sn = 1 + 1/2 + 1/4 + 1/8 + .... + 1/(2**n) 求当n等同于100时,sn的值是多少? 3. 用while语句实现打印三角形,输入一个整数,表示三角形的宽度和高度,打印出相应的直角三角形: 如: 请输入三角形的宽度: 4 1) 打印如下: * ** *** **** 2) 打印如下: * ** *** **** 3) 打印如下: **** *** ** * 4) 打印如下: **** *** ** * 练习: 任意输入一段字符串 1) 计算您输入的字符'A' 的个数,并打印出来 2) 计算出空格的个数,并打印出来 (要求用for语句,不允许使用, S.count方法) 思考用while语句能否实现上述功能 练习: 用for 语句打印1~20 打印在一行内 练习: 求 100以内有哪儿些整数与自身+1的乘积再对11求余的结果等于8? x * (x+1) % 11 == 8 x附合条件 1. 写程序计算 1 + 3 + 5 + 7 + ...+ 99的和 (要求用for语句和while语句两种方式实现) 2. 用while语句实现打印: 1 3 5 7 9. .... 19 打印在一行内 3. 将上题用for语句来实现 练习: 用for 语句实现下题 : 1. 输入一个数w代表正方形的宽度,打印如下正方形: 如输入:5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 2. 写程序来改写上题: 如输入: 5 打印如下: 1 2 3 4 5 2 3 4 5 6 3 4 5 6 7 4 5 6 7 8 5 6 7 8 9 如输入: 3 打印如下: 1 2 3 2 3 4 3 4 5 练习: 1. 输入一个整数用begin绑定, 再输入一个整数用end绑定 打印从begin开始,到end结束内的全部奇数(不包含end) 2. 将上述练习改写为 用while语句实现 3. 求 1~100 之间所有不被 5, 7, 11 整除的数的和 (可以考虑用continue实现) 练习: 1 输入三行文字,将这三行文字, 保存于一个列表L中,并打印 如: 请输入: abc<回车> 请输入: 123<回车> 请输入: 你好<回车> 生成列表如下: L = ['abc', '123', '你好'] print(L) 打印 练习: 1. 输入任意行文字,存于列表L中,当不输入任何内容直接回车后结束输入 1) 打印L列表中的内容 2) 计算您共输入了几行内容 3) 计算您共输入了多少个字符 2. 输入一个整数(代表树干的高度) 打印出如下一棵树 输入: 2 打印: * *** * * 输入:3 * *** ***** * * * 3. 写一个程序,任意输入一个整数,判断这个数是否是素数(prime) 素数(也叫质数), 是只能被1和自身整除的正整数: 如: 2 3 5 7 11 等 提示: 用排除法: 当判断x是否是素数是,只要让x分别除以: 2, 3, 4, 5, .... x-1, 只要整除了,那x不是素数,否则x是素数 4.算出100~1000以内的水仙化数(Naricissistic Number) 水仙花数是指百位的3次方 加上 十位的3次方 加上 个位的3次方等于原数的数 如: 153 = 1**3 + 5**3 + 3**3 答案: 153, 370, .... 练习: 已知有列表: L = [3, 5] 1) 用索引和切片等操作,将原列表改变为: L = [1, 2, 3, 4, 5, 6] 2) 将列表反转,删除最后一个元素后打印此列表 ... print(L) # [6, 5, 4, 3, 2] 练习: 1. 写程序,让用户输入一些整数,当输入-1时结束输入,将这些数存于列表L中 1) 打印用户共输入了几个数? 2) 打印您输入的数的最大数是多少 3) 打印您输入的数的最小数是多少 4) 打印您输入的这些数的平均值是多少? 练习: 输入多行文字,存入列表中, 每次输入回车后算一行 任意输入多行,当输入回车(即输入空行时结束输入) 1) 按原输入内容在屏幕上输出内容 2) 打印出您共输入了多少行文字 3) 打印出您共输入了多少个字符 练习: 1. 有字符串"hello" 请用此字符串生成: 'h e l l o' 和 'h-e-l-l-o' 答案: s = "hello" a = ' '.join(s) # a = 'h e l l o' b = '-'.join(s) # b = 'h-e-l-l-o' 2. 写一个程序,让用户输入很多正整数,当输入小于零的数时结束输入, 1) 打印这些数中最大的一个数 2) 打印这些数中第二大的一个数 3) 删除最小的一个数 4) 打印剩余数的和 练习: 用列表推导式生成1~100内奇数的列表 结果是: [1, 3, 5, 7, ..... 99] L = [x for x in range(1, 100, 2)] 示例: 生成1~00内的奇数的列表: L = [x for x in range(1, 100) if x % 2 == 1] 练习: 生成一个数值为 1 ~ 9的平方的列表,去掉所有的奇数的平方 L = [x**2 for x in range(1, 10)] # L = [4, 16, 36, 64] 练习: 1. 已知有一个字符串 s = '100,200,300,500,800' 将其转化为整数的列表存于L列表中 L = [100, 200, 300, 500, 800] 2. 生成前40个斐波那契数(Fibonacci) 1 1 2 3 5 8 13 ..... 要求将这些数保存在列表中 打印这些数 3. 有一些数存于列表中: L = [1, 3, 2, 1, 6, 4, 2, ..... 98, 82] 将列表中出现的数字存入到另一个列表L2中 要求: 重复出现多次的数字在L2列表中只保留一份(去重) 写程序,实现以下要求: 1) 将如下数据形成一个字典seasons: '键' '值' 1 '春季有1, 2, 3月' 2 '夏季有4, 5, 6月' 3 '秋季有7, 8, 9月' 4 '冬季有10,11,12月' 2) 让用户输入一个整数,代表一个季度,打印这个季度对应的信息,如果用户输入的信息不在字典内,则打印信息不存在 练习: 输入一段字符串,打印出这个字符串中出现过的字符的出现次数 如: 输入: abcdabcaba 打印: a: 4次 b: 3次 d: 1次 c: 2次 注: 不要求打印的顺序 练习: 有字符串的列表如下: L = ['tarena', 'xiaozhang', 'tyke'] 用上述列表生成如下字典: d = {'tarena': 6, 'xiaozhang': 9, 'tyke':4} 注: 字典的值为键的长度 练习: 1. 已知有两个等长的列表 list1 和 list2 以list1中的元素为键,以list2中的元素为值,生成相应的字典 list1 = [1001, 1002, 1003, 1004] list2 = ['Tom', 'Jerry', 'Spike', 'Tyke'] 生成的字典为: {1001: 'Tom', 1002:'Jerry', .....} 2. 输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典中,然后放入至列表中,每个学生的信息需要手动输入 当输入姓名为空时结束输入: 如: 请输入姓名: xiaozhang 请输入年龄: 20 请输入成绩: 100 请输入姓名: xiaoli 请输入年龄: 18 请输入成绩: 98 请输入姓名: <回车> 结束输入 要求内部存储格式如下: [{'name':'xiaozhang', 'age':20, 'score':100}, {'name':'xiaoli', 'age':18, 'score':98}] 打印所有学生的信息如下: +---------------+----------+----------+ | name | age | score | +---------------+----------+----------+ | xiaozhang | 20 | 100 | | xiaoli | 18 | 98 | +---------------+----------+----------+ 集合练习: 经理有: 曹操,刘备,孙权 技术员有: 曹操,孙权,张飞,关羽 用集合求: 1) 即是经理,也是技术员的有谁? 2) 是经理,但不是技术员的人员都有谁? 3) 是技术员,不是经理的都有谁 4) 张飞是经理吗? 5) 身兼一职的人都有谁? 6) 经理和技术员共有几个人? 练习: 任意输入一些数字,存于列表L中。当输入负数时结束输入 1) 打印这些数的和 2) 打印这些数有多少种(去重) 3) 除重复的数字后,打印这些剩余数字的和 提示,可以用集合去重 练习: 1. 写一个函数myadd, 此函数中的参数列表里有两个参数x, y 此函数的功能是打印 x + y 的和 def myadd(....): .... # 注: .... 部是是我们要填写代码的地方 myadd(100, 200) # 300 print("ABC", "123") # ABC123 2. 写一个函数 mysum, 传入一个参数x代表终止整数, 打印出 1 + 2 + 3 + 4 + ..... + x的和 def mysum(x): .... mysum(100) # 5050 mysum(4) # 10 return 语句 语法: return [表达式] 注: [] 代表可省略 作用: 用于函数中,结束当前函数的执行,返回到调用该函数的地方,同时返回一个对象的引用关系 return 语句说明 1. return 语句后跟的表达式可以省略,省略后相 当于return None 2. 如果函数内没有return 语句,则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句) 示例见: return.py 练习: 1. 写一个函数 mymax, 给函数传递两个参数,返回两个实参中最大的一个 def mymax(a, b): .... v = mymax(100, 200) print('v =', v) # v = 200 print(mymax('ABC', 'abc')) # abc 2. 写一个函数 input_number def input_number(): .... 此函数用来获取用户循环输入的整数,当用户输入负数时结束输入。将用户输入的数字以列表的形式返回,再用内建函数max, min, sum取出户输入的最大值,最小值及和 L = input_number() print(L) # 打印此列表 print("用户输入的最大数是:", max(L)) print("用户输入的最小数是:", min(L)) print("用户输入的数的和是:", sum(L)) 练习: 1. 写一个函数 print_odd, 打印从begin开始,到end结束(不包含end)内的全部的奇数 def print_odd(begin, end): .... print_odd(1, 10) # 打印 1 3 5 7 9d ptint_odd(10, 20) # 打印 11 13 15 17 19 2. 定义两个函数: sum3(a, b, c) 用于返回三个数的和 pow3(x) 用于返回x的三次方 用以上函数计算: 1. 计算1的立方 + 2的立方 + 3的立方的和 即: 1**3 + 2**3 + 3**3的和 2. 计算1 + 2 + 3 的和的立方, 即:(1+2+3)**3 3. 改写之前的学生信息管理程序 改为两个函数: 1. 写一个函数 input_student() 用于返回学生信息的字典的列表(以前格式一样) 2. 写一个函数 output_student(lst) 此函数传入一个列表lst,即字典的列表 此函数把lst的内容以表格形式打印出来 def input_student(): .... def output_student(lst): ... L = input_student() # 获取学生信息的列表 output_student(L) # 把L 以列表的形式打印 练习: 写一个函数minmax(a, b, c) 有三个参数,这回这三个参数中的最小值和最大值, 要求,形成元组,最小值在前,最大值在后,如: def minmax(a, b, c): ... t = minmax(11, 33, 22) print(t) # (11, 33) # <<< 打印元组 xiao, da = minmax(6, 5, 4) print('最小值:', xiao, '最大值:', da) 练习: 写一个函数 myadd, 此函数可以计算两个数的和,也可以计算三个数的和 def myadd(......): .... print(myadd(10, 20)) # 30 print(myadd(100, 200, 300)) # 600 2. 写一个函数,print_odd, 此函数可以传递一个实参,也可以传递两个实参,当传递一个实参时代表结束值 当传递两个实参时,第一个实参代表起始值,第二个实参代表结束值 打印出以此区间内的全部奇数,不包含结束数: print_odd(10) # 1 3 5 7 9 print_odd(11, 20) # 11 13 15 17 19 练习: 写一个函数, mysum可以传入任意个实参的数字,返回所有实参的和 def mysum(*args): ... print(mysum(1, 2, 3, 4)) # 10 print(mysum(10, 20, 30)) # 60 练习: 写一个函数,mymax类似于 内键的函数max 详见: >>> help(max) 仿造 max 写一信mymax函数,功能与max完全相同 (要求不允许调用max函数) print(mymax([6, 8, 3, 5])) # 8 print(mymax(100, 200)) # 200 print(mymax(1, 3, 5, 9, 7)) # 9 思考题: 查看 >>>help(print)猜想print函烽的参数列表 是如何定义的? 练习: 创建一个全局变量 L = [] 写一个函数: def input_number(): .... 此函数每次调用将从键盘读入一些数字追加到列表L中 如: L = [] def input_number(): .... input_number() print(L) # [ .... 这些是您从键盘输入的数..] 练习: 1. 写一个函数isprime(x) 判断x是否为素数。如果是素数,返回True,否则返回False 2. 写一个函数prime_m2n(m, n) 返回从m开始,到n结束(不包含n)范围内的素数,返回这些素数的列表并打印 如: L = prime_m2n(5, 10) print(L) [5, 7] 3. 写一个函数pimes(n) 返回小于n的全部素数的列表,并打印这些素数 如: L = primes(10) print(L) # [2, 3, 5, 7] 1) 打印100 以内的全部素数 2) 打印200 以内的全部素数的和 4. 编写函数 fn(n) 此函数返回下列级数的和: fn(n) = 1/(1*2) + 1/(2*3) + .... + 1/(n*(n-1)) 的和 print(fn(100)) 练习: 写一个计算公式的解释执行器 已知有如下一些函数: def myadd(x, y): return x + y def mysub(x, y): return x - y def mymul(x, y): return x * y 写一个函数,传入字符串,返回相应的函数 def get_op(s): # 此函数根据字符串来返回相应的函数. # 如果传入字符串"加" 则返回myadd函数 # .... '乘',则返回mymul函数 ... 此处自己实现 主程序如下: while True: s = input("请输入计算公式: ")# 10 加 20 L = s.split() a = int(L[0]) b = int(L[2]) fn = get_op(L[1]) print("结果是:", fn(a, b)) # 30 练习: 写一个函数叫hello(name),部分代码如下: count = 0 def hello(name): print('你好', name) ... 此处代码省略,需要同学们自己填写 ... 此处代码需要改变全局变量来记录此函数曾经被调用过多少次. hello('小张') hello('小李') print('hello 函数被调用', count, '次') # 2次 练习: 1. 写一个lambda 表达式,判断这个数的2次方+1是否能被5整除,如果能被整除返回True, 否则返回False 例: fa = lambda x: ..... print(fa(2)) # True print(fa(4)) # False 2. 写一个lambda表达式,求两个变量的最大值 例如: def mymax(x, y): ... mymax = lambda ... print(mymax(100, 200)) # 200 练习: 1. 给出一个整数n,写一个函数myfac来计算n!(n的阶乘) n! = 1 * 2 * 3 * 4 * ..... * n 如: print(myfac(5)) # 120 2. 给出一个整数n,写一个函数计算myfn(n): 1 + 2**2 + 3**3 + .... + n**n的和 如: print(myfn(10)) # ??? 3. 完全数: 1 + 2 + 3 = 6 (6为完全数) 1,2,3都为6的因数(因数是能被一个数x整除的整数为y,则y为x的因数) 1 x 6 = 6 2 x 3 = 6 完全数是指除自身以外的所有因数相加之和等于自身的数 求 4~5个完全数并打印出来 答案: 6 28 496 ...... 4 实现带有界面的学生信息管理系统 程序启动时先弹出操作菜单: +-------------------------+ | 1) 添加学生信息 | | 2) 显示学生信息 | | 3) 删除学生信息 | | 4) 修改学生成绩 | | q) 退出 | +-------------------------+ 请选择: 1 要求 : 每个选择都要有一个函数来实现 练习: 1. 用map函数求: 1**3 + 2**3 + 3 ** 3 + .... 9**3 的和 2. 用map函数求: 1**4 + 2**4 + 3 ** 4 + .... 20**4 的和 提示: sum(map(.....)) 练习: 1. 将 1 ~ 20 的偶数用filter生成可迭代对象后将可迭代对象生成的数放入到列表L中 2. 写一个函数is_prime(x) 判断x是否是素数 用filter函数打印出: 20 ~ 30之间的全部素数 练习: names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 排序的依据为字符串的反序: 'moT' yrreJ ekipS ekyT 结果: ['Spike', 'Tyke', 'Tom', 'Jerry'] 练习: 写函数 mysum(n)用递归方式实现求和 def mysum(n): # 用递归方式求和 ... print(mysum(100)) # 5050 思考题: 已知五位朋友在一起 第五位朋友比第四位朋友大2岁 第四位朋友比第三位朋友大2岁 第三位朋友比第二位朋友大2岁 第二位朋友比第一位朋友大2岁 第一位朋友说它10岁 练习: 1. 已知五位朋友在一起 第五位朋友比第四位朋友大2岁 第四位朋友比第三位朋友大2岁 第三位朋友比第二位朋友大2岁 第二位朋友比第一位朋友大2岁 第一位朋友说它10岁 写程序打印出第五位朋友 和第三位朋友 的年龄 2. 已知有列表: L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20] 1) 写一个函数print_list(lst) 打印出所有元素 print(L) # 打印 3 5 8 10 13 14 .... 2) 写一个函数sum_list(lst) 返回这个列表中所有元素的和 print(sum_list(L)) # 86 注: type(x) 可以返回一个变量的类型 如: >>> type(20) is int # True >>> type([1, 2, 3]) is list # True 3. 改写之前的学生信息管理程序 要求添加四个功能: | 5) 按学生成绩高-低显示学生信息 | | 6) 按学生成绩低-高显示学生信息 | | 7) 按学生年龄高-低显示学生信息 | | 8) 按学生年龄低-高显示学生信息 | 练习: 1. 输入一个圆的半径,打印出这个圆的面积 2. 输入一个圆的面积,打印出这个圆的半径 (要求用math模块内的函数和数据实现) 练习: 写一个程序,输入你的出生日期, 1) 算出你已经出生多少天? 2) 算出你出生的那天是星期几? 练习: 1. 请编写函数fun 其功能是计算下列多项式的和: fn = 1 + 1/1! + 1/2! + 1/3! + 1/4! + .. + 1/n! (建义用数学模块的factorial实现) 求当n 等于100时,fn的值 看一下fn(100)的值是什么 2. 写一个程序,以电子时钟格式: HH:MM:SS格式显示时间 要求每隔一秒变化一次 3 写函数f(n)求下多项式的和 fn = 1/1 - 1/3 + 1/5 - 1/7 + 1/9 .... 1/(2*n-1)的和 求当n取值为1000000时, 1) 打印 f(1000000) 的值 2) 打印 f(1000000) * 4的值,看看是什么 练习: 1. 猜数字游戏 随机生成一个 0~100之间的一个整数,用变量x绑定 让用户输入一个数y,输出猜数字的结果: 1) 如果y大于x则提示: "您猜大了" 2) 如果y小于x则提示: "您猜小了" 3) 如果y等于生成的数x,则提供示用户"恭喜您猜对了 "并退出猜数字 循环重复上述步聚,直到猜对为止。 猜对了,显示用户猜数字的次数,然后退出程序 练习: 1. 写一个闹钟程序,启动时设置定时时间, 到时间后打印一句"时间到...." 然后退出程序 2. 模拟斗地主发牌,扑克牌共54张 黑桃('\u2660'), 梅花('\u2663'), 方块('\u2665'), 红桃('\u2666') A2-10JQK 大王、小王 三个人玩,每人发17张牌,底牌留三张 输入回车, 打印出第1个人的17张牌 输入回车, 打印出第2个人的17张牌 输入回车, 打印出第3个人的17张牌 输入回车, 打印三张底牌 3. 修改学生信息管理程序,将原student_info.py 拆分为模块 要求: 1. 主事件循环放在main.py中 2. show_menu 函数放在menu.py中 3. 与学生操作相关的函数放在 student_info.py中 练习: 写一个函数 get_score() 来获取学生成绩, 要求用户输入 1~100的整数,输果输入出现异常,返此函数返回0, 否则返回用户输入的成绩 示例: def get_score(): ... score = get_score() print("学生的成绩是:", score) python中全部的错误类型: 参见文档: python_base_docs_html/Python全部的异常类型.html 练习: 写一个函数 get_age()用来获取一个人的年龄信息 此函数规定用户只能输入1~140之间的整数,如果用户输入其它的数则直接触发ValueError类型的错误通知 如果用户输入的年龄大于140,则触发 ValueError("年龄超出了正常值") 如果用户输入的年龄小于1,则触发 ValueError("年龄太小...") def get_age(): ... try: age = get_age() print("用户输入的年龄是:", age) except ValueError as err: print('用户输入的不是1~140的整数,获取年龄失败') print("原因是:", err) 练习: 1. 一个球从100米高空落下,每次落地后反弹高度是原高度的一半,再落下, 1) 写程序算出皮球在第10次落地后反弹高度是多高? 2) 打印出球共经过多少米的路程 2. 分解质因数, 输入一个正整数,分解质因数, 如: 输入: 90 则打印: '90=2*3*3*5' (质因数是指最小能被原数整除的素数(不包括1)) 3. 修改原学生信息管理程序,加入异常处理语句,让程序在任何情况下都能够按逻辑正常执行. 例如: 输入成绩和年龄时,如果用户输入非法字符串也不会导致程序崩溃 练习: 有一个集合: s = {'唐僧', '悟空', '八戒', '沙僧'} 用 for语句来遍历所有元素如下: for x in s: print(x) else: print('遍历结束') 请将上面的for语句改写为 用while语句和迭代器实现 练习: 写一个生成器函数 myeven(start, stop) 此函数用来生成从 start开始到stop结束(不包含)区间内的一系列偶数 def myeven(start, stop): .... evens = list(myeven(10, 20)) print(evens) # [10, 12, 14, 16, 18] for x in myeven(21, 30): print(x) # 22, 24, 26, 28 L = [x**2 for x in myeven(3, 10)] print(L) # 16 36 64 练习: 已知有一个列表L L = [2, 3, 5, 7] 用生成器表达式从此列表中拿到数,生成 列表中数据的平方 gen = ...... # 此处用生成器表达式实现 L2 = list(gen) # L2 = [4, 9, 25, 49] 思考: L = [2, 3, 5, 7] L2 = [x ** 2 for x in L] # 列表推导式 it = iter(L2) print(next(it)) # 4 L[1] = 10 print(next(it)) # 9 L = [2, 3, 5, 7] G3 = (x ** 2 for x in L) # 生成器表达式 it = iter(G3) print(next(it)) # 4 L[1] = 10 print(next(it)) # 100 练习: 写一个程序,读入任意行的文字,当输入空行时结束输入 打印带有行号的输入结果: 如: 请输入: hello<回车> 请输入: world<回车> 请输入: tarena<回车> 请输入: <回车> # 直接回车结束输入 输出如下: 第1行: hello 第2行: world 第3行: tarena 练习: 写一个程序,从键盘输入一段字符串存入s变量 1. 将此字符串转为字节串用变量b绑定,并打印出b 2. 打印字符串s的长度和字节串b的长度 3. 将b字节串再转换为字符串用变量s2 绑定,判断 s2 和 s是否相同? 练习: 1. 写一个生成器函数primes生成素数, 此生成器函数为 primes(begin, end) 如: [x for x in primes(10, 20)] 将得到列表 [11, 13, 17, 19] 2. 写一个生成器函数,生成斐波那契数列的前n个数 1 1 2 3 5 8 13 def fibonacci(n): ... yield... 1) 输出前20个数: for x in fibonacci(20): print(x) 2) 打印前40个数的和: print(sum(fibonacci(40))) 3. 写程序打印杨辉三角(只打印6层) 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 练习: 自己写一个文件 'info.txt' 内部存一些文字信息 如: 张三 20 100 李四 21 96 小王 22 98 写程序将这些数据读取出来,打印到终端上 练习: 1. 写程序,循环输入很多个人的姓名,电话号码, 当输入结束后将这些信息存入到文件phonenumber.txt中 (建议先用列表暂存数据,格式自己定义) 2. 写程序,将phonenumber.txt文件中的数据读取出来. 再用以下格式打印出来: 如: 小张 的电话是 13888888888 小李 的电话是 13999999999 练习: 1. 写程序实现复制文件的功能 要求: 1. 要考虑特大文件问题 2. 要关闭文件 3. 要能复制二进制文件 如: 请输入源文件路径名: /home/tarena/xxx.tar.gz 请输入目标文件路径名: ./a.tar.gz 显示: 文件已成功复制 2. 修改学生信息管理程序,要求加入两个功能: 9) 保存信息到文件(si.txt) 10) 从文件中读取数据(si.txt) 练习: 自己写一个'人'类: Human class Human: def set_info(self, name, age, address='未知'): '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性''' ... # << 此处自己实现 def show_info(self): '''显示此人的全部信息''' ... # 此处自己实现 如: h1 = Human() h1.set_info('小张', 20, '北京市朝阳区') h2 = Human() h2.set_info('小李', 18) h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区 h2.show_info() # 小李今年 18 岁,家庭住址:末知 练习: 写一个Student类 1) 为该类添加初始化方法, 实现在创建对象时自动设置 '姓名','年龄', '成绩' 属性 2) 添加set_score方法能修改成绩信息 3) 添加show_info方法打印学生对象的信息 如: class Student: def __init__(...): ... ... s1 = Student('小王', 15, 59) s1.show_info() # 小王 今年 17 岁, 成绩是: 59 s1.set_score(80) s1.show_info() # 小王 今年 17 岁, 成绩是: 80 面向对向的综合示例: 有两个人(Human): 1. 姓名: 张三 年龄: 35 2. 姓名: 李四 年龄: 8 行为: 1. 教别人学东西 teach 2. 赚钱 works 3. 借钱 borrow 事情: 张三 教 李四 学 python 李四 教 张三 学 跳皮筋 张三 上班赚了 1000 元钱 李四 向 张三 借了 200 元钱 打印张三的信息: 35岁 的 张三 有钱 800元, 它学会跳皮筋 打印李四的信息: 8岁 的 李四 有钱 200元, 它学会python 练习: 修改原来的学生信息管理程序,将原来字典来存储学生信息, 现改为用对象来存储学生信息 # file : student.py class Student: def __init__(self, n, a, s): .... L = [] # L.append({...}) 改为对象 L.append(Student('xiaozhang', 20, 100)) (要求类Student 要写在模块 student.py中) 练习: 用类来描述一个学生的信息(可以修改之前写的Student类) class Student: .... 此处自己实现 学生信息有: 姓名, 年龄, 成绩 将一些学生的对象存于列表中,可以任意添加和删除学生信息 1) 打印出学生的个数 2) 打印出所有学生的平均成绩 3) 打印出所有学生的平均年龄 思考: list类里只有一个append向末尾加一个元素的方法,但没有向列表头部添加元素的方法,试想能否为列表在不改变原有类的基础上添加一个insert_head(n) 方法,实现在列表的头部(前部)添加元素 如: class MyList(list): def insert_head(self, n): ... # 需要自己添加代表 myl = MyList(range(3, 6)) print(myl) # [3, 4, 5] myl.insert_head(2) print(myl) # [2, 3, 4, 5] myl.append(6) print(myl) # [2, 3, 4, 5, 6] 练习: 1. 看懂学生管理程序,每一步做的事情及思想 2. 把同学们自己的学生信息管理程序用Student学生对象来存储信息;要求,不要在外部直接操作学生的属性,所有操作行为用方法来代替 练习: 写一个类Bicycle类 ,有 run方法.调用时显示骑行里程km class Bicycle: def run(self, km): print('自行车骑行了', km, '公里') 再写一个类EBicycle(电动自行车类), 在Bicycle类的基础上添加了电池电量 volume 属性, 有两个方法: 1. fill_charge(self, vol) 用来充电, vol为电量 2. run(self, km) 方法每骑行10km消耗电量1度,同时显示当前电量,当电量耗尽时调用 父类的run方法继续骑行 b = EBicycle(5) # 新买的电动有内有5度电 b.run(10) # 电动骑行了10km还剩 4 度电 b.run(100) #电动骑行了40km,还剩0度电,其余60用脚登骑行 b.fill_charge(10) # 又充了10度电 b.run(50) # 骑行了50公里剩5度电 练习: 1. 修改原有的学生信息管理系统, 将学生对象的,全部属性 都变为私有属性,不让外部直接访问来实现封装 2. 写一个列表类MyList实现存储整数列表,写类的定义如下: class MyList: def __init__(self, iterator): self.data = ... 让此类的对象能用for语句进行迭代访问 L = MyList(range(5)) print(L) L2 = [x ** 2 for x in L] print(L2) # [0, 1, 4, 9, 16] 3. 写一个类Fibonacci 实现迭代器协议 ,此类的对象可以作为可迭代对象生成相应的斐波那契数 1 1 2 3 5 class Fibonacci: def __init__(self, n) # n代表数据的个数 ... ... 实现如下操作: for x in Fibonacci(10): print(x) # 1 1 3 5 8 .... L = [x for x in Fibonacii(50)] print(L) F = fibonicci(30) print(sum(F)) 练习: 1. 实现两个自定义的列表相加 class MyList: .... 此处自己实现 L1 = MyList([1, 2, 3]) L2 = MyList(range(4, 7)) L3 = L1 + L2 print(L3) # MyList([1, 2, 3, 4, 5, 6]) L4 = L2 + L1 print(L4) # MyList([4, 5, 6, 1, 2, 3]) L5 = L1 * 2 print(L5) # MyList([1, 2, 3, 1, 2, 3]) 练习: 实现有序集合类 OrderSet() 能实现两个集合的交集 &,全集 |, 补集 - 对称补集 ^, ==/!= , in/ not in 等操作 要求集合内部用 list 存储 class OrderSet: ... s1 = OrderSet([1, 2, 3, 4]) s2 = OrderSet([3, 4, 5]) print(s1 & s2) # OrderSet([3, 4]) print(s1 | s2) # OrderSet([1, 2, 3, 4, 5]) print(s1 ^ s2) # OrderSet([1, 2, 5]) if OrderSet([1, 2, 3]) != OrderSet([3, 4, 5]): print("不相等") if s2 == OrderSet(3, 4, 5): print('s2 == OrderSet(3, 4, 5) is True') if 2 in s1: print("2在 s1中")

优秀的个人博客,低调大师

Python全栈工程师(for、列表)

ParisGabriel Python 入门基础 for:用来遍历可迭代对象的数据元素可迭代对象是指以此获取数据元素的对象可迭代对象包括:字符串 str 列表 list元组 tuple字典 dict语法:for 变量列表 in 可迭代对象: L = ["a", "abc", "中国", 123] for x in L: print(x) else: print("结束") 说明:当循环内部使用break结束循环时,else将不再执行并且else 可以省略range()函数:range(stop) 从零开始,每次生成一个整数后加1操作,直到stop为止(不包含stop)range(star,stop[,step])从star开始每次生成一个整数后移动step,直到stop为止(不包含stop,且step可以是负数)help(range) 查询帮助作用:用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器) for x in range(0, 10, 3): print(x) 说明:range函数带调用返回的对象可用于for语句来进行依次迭代取出其中的函数for嵌套: for x in range(5): for y in range(3): print(x, y, "ABC") continue:用于循环语句中(while、 for )不再执行本次循环内continue之后的语句重新开始一次新的循环 for x in range(10): if x % 2 == 0: continue print(x) 说明:在while中直接跳到真值表达式重新判断在for中直接将可迭代对象内的元素绑定到下一个再次循环 列表 list:列表是一种容器(通常用来储存计算机的数据对象)列表是可以被改变的序列是由一系列特定元素组成的 元素与元素之间可能没有任何关联关系但他们由先后顺序关系空列表创建方式: L=[ ]列表是可迭代对象: 非空列表创建方式: 空列表: L = [] 非空列表: L = [1, 2, 3, 4] L = ["a", "b", "c"] L = [1, 2, ["a", "b", "c", "d"], 3, 4] 列表的构造函数list:list()等于空列表list(iterable)用可迭代对象创建一个列表列表的运算:+ 用于拼接列表+= 用于将右侧的可迭代对象的数据追加到原列表中* 用于生成重复列表*=列表的比较运算:< <= > >= == !=比较规则和字符串完全相同列表的in、notin:判断一个元素是否存在于列表中 如果纯在返true否则falsein 和 nat in 返回值相反 练习:1.用for实现:输入一个数W代表正方形的宽度:如1 2 3 4 51 2 3 4 51 2 3 4 51 2 3 4 51 2 3 4 5 答案: a = int(input("plaese input at will integer:")) for x in range(1, a + 1): for y in range(1, a + 1): print(y, end = " ") print() 改写上上题:1 2 3 4 52 3 4 5 63 4 5 6 74 5 6 7 85 6 7 8 9 第一种:a = int(input("plaese input at will integer:")) for x in range(1, a + 1): for y in range(x, a + x): print("0%2d" % y, end = " ") print() 第二种: a = int(input("plaese input at will integer:")) for x in range(1, a + 1): for y in range(x, a + x): print(y, end = " ") print() 2.输入任意文字,存于列表L中,当不输入任何内容直接回车后结束输入打印L列表中的内容计算你共输入几行内容、和多少个字符 答案: L = [] i = 0 while True: a = input("plaese input at will string:") if a == "": break i += len(a) L += [a] print(''' L = : %s you have entered:%d row %d Entries character ''' % (L, len(L), i)) 3.输入一个整数 (代表树干高度)打印出如下一颗树输入:2****** 输入3 ********* * * * 答案: a = int(input("plaese input at will integer:")) for x in range(1, a * 2, 2): print(("*" * x).center(a * 2)) else: for s in range(1, a * 2, 2): print("*".center(a * 2)) 4.任意输入一个整数 判断这个数是否是素数(prime)素数也叫质数,是只能被1和自身整除的数:如:2 3 5 7 11 等提示:用排除法:判断x是否是素数是,只要让x分别除以:2 3 4 5 ...-1只要整除了 那x不是素数,否则x是素数 答案: a = int(input("plaese input at will integer:")) for x in range(2, a): if a % x == 0: s = "it's not a prime" break else: s = "This is a prime" print(s 5.算出100 ~ 1000以内的水仙花数(naricissistic)水仙花数是指百位的3次方 加上十位的3次方 加上各位的3次方等于原数的数153=1**3+5**3+3**3 153 370 答案: for x in range(100, 1000): if (x // 100) ** 3 + ((x % 100) // 10) ** 3 + (x % 10) ** 3 == x: print(x)

优秀的个人博客,低调大师

Python全栈工程师(编码)

ParisGabriel Python 入门基础 补充: 主流3操作大系统 Windows: Winxp Win7 Win8 Win10 Unix: Solaris(SUN) IOS(Apple移动端) Mac OS Linux :(linux基于Unix 独立出来的系统) 安卓(Android) Ubuntu 16.04(当前教学版本) ReadHat CentOS 回顾: Ctrl + Alt + Enter :虚拟机全屏/退出全屏 Ctrl + Alt :释放鼠标 ctrl + shift + "+" : 终端字体放大 ctrl + "-" : 终端字体缩小 ctrl + d:退出终端 ctrl + l : 清屏 ctrl + c : 终止当前命令的执行 ctrl + s : 隐藏终端输出 ctrl + q : 恢复终端输出 init 0 : 关机 init 6 : 重启 pwd:显示当前的路径位置 ls:查看当前位置有什么内容 ls -l :以列表形式显示 ls -a :显示所有内容(包含隐藏) cd:改变当前的工作路径 cd 绝对路径 :cd /home/tarena/aid1806/ cd 相对路径 cd .. :回退到上一级目录 cd :回到用户主目录 mkdir:创建一个或者多个文件 touch:创建一个或者多个文 tree:显示目录树 rm -r : 递归删除文件夹内所有内容 rm -f : 强制删除,不给任何提示 rm -i : 删除前给提示(y代表yes,n代表no) sudo:用超级用户root的权限执行一条命令 tar -zcvf 压缩包名字.tar.gz 文件夹/文件:打包压缩 tar -zxvf 压缩包名字.tar.gz [-C 路径]:解压缩包 z : gzip对包进行压缩 c : 创建包 create x : 解包 v : 显示操作的文件细节 verbose f : 文件名 file cp:复制文件/文件夹 mv:剪切 / 重命名 练习1: 1、切换到目录:/home/tarena/anaconda3/bin 2、查看当前所在的路径 3、以列表形式列出当前路径中所有内容(包含隐藏文件或者目录) 4、切换到当前路径的上一级目录 5、切换到 /etc 目录,查看 /etc 有哪些内容 6、直接切换到用户主目录 答案: tarena@tedu:~$ cd anaconda3/bin/ tarena@tedu:~/anaconda3/bin$ pwd /home/tarena/anaconda3/bin tarena@tedu:~/anaconda3/bin$ ls -la 总用量 27888 drwxrwxr-x 2 tarena tarena 12288 7月 17 2017 . drwxrwxr-x 20 tarena tarena 4096 7月 17 2017 .. lrwxrwxrwx 1 tarena tarena 8 7月 17 2017 2to3 -> 2to3-3.6 -rwxrwxr-x 1 tarena tarena 110 7月 17 2017 2to3-3.6 -rwxrwxr-x 2 tarena tarena 3802 5月 26 2017 activate -rwxrwxr-x 1 tarena tarena 165 7月 17 2017 anaconda -rwxrwxr-x 1 tarena tarena 167 7月 17 2017 anaconda-navigator -rwxrwxr-x 1 tarena tarena 153 7月 17 2017 anaconda-project -rwxrwxr-x 1 tarena tarena 12003 7月 17 2017 asadmin tarena@tedu:~/anaconda3/bin$ cd .. tarena@tedu:~/anaconda3$ cd etc/ tarena@tedu:~/anaconda3/etc$ ls dbus-1 fish fonts jupyter rc.d tarena@tedu:~/anaconda3/etc$ cd 练习2: 1、在用户主目录下创建目录 mydir1 、mydir2 2、在mydir1下创建文件:file1、file2、file3 3、将mydir1打包压缩为mydir1.tar.gz,放在用户主目录下 4、将mydir1.tar.gz剪切到mydir1目录下 5、将mydir1.tar.gz解压缩,放到mydir2目录下(-C选项) 答案: tarena@tedu:~$ mkdir mydir1 mydir2 tarena@tedu:~$ cd mydir1 tarena@tedu:~/mydir1$ touch file1 file2 file3 tarena@tedu:~/mydir1$ cd .. tarena@tedu:~$ tar -zcvf mydir1.tar.gz mydir1 mydir1/ mydir1/file3 mydir1/file1 mydir1/file2 tarena@tedu:~$ ls anaconda3 mydir2 yang 文档 core my_env 公共的 下载 examples.desktop pycharm-2017.1.5 模板 音乐 mydir1 pycharm-professional-2017.1.5.tar.gz 视频 桌面 mydir1.tar.gz PycharmProjects 图片 tarena@tedu:~$ mv mydir1.tar.gz mydir1 tarena@tedu:~$ cd mydir1 tarena@tedu:~/mydir1$ ls file1 file2 file3 mydir1.tar.gz tarena@tedu:~/mydir1$ tar -zxvf mydir1.tar.gz -C ~/mydir2 mydir1/ mydir1/file3 mydir1/file1 mydir1/file2 tarena@tedu:~/mydir1$ cd ~/mydir2 tarena@tedu:~/mydir2$ ls mydir1 tarena@tedu:~/mydir2$ cd mydir1/ tarena@tedu:~/mydir2/mydir1$ ls file1 file2 file3 tarena@tedu:~/mydir2/mydir1$ 练习3: 1、在用户主目录下创建目录:AI/Python/Linux 2、在Linux下创建文件:linux1 、linux2 3、在Python下创建文件:python1 、python2: 4、切换到AI目录,查看当前所在路径 5、直接切换到用户主目录 答案: tarena@tedu:~$ mkdir -p AI/python/linux tarena@tedu:~$ cd AI/python/linux tarena@tedu:~/AI/python/linux$ touch linux1 linux2 tarena@tedu:~/AI/python/linux$ cd .. tarena@tedu:~/AI/python$ touch python1 python2 tarena@tedu:~/AI/python$ cd ~/AI tarena@tedu:~/AI$ cd 练习4: 1、在用户主目录创建如下结构:PYTHON/Linux/day01 2、在 day01 下创建三个文件:day01.txt day02.txt day03.txt 3、将 day03.txt 删除 4、将 day02.txt 文件时间更新为当前时间 5、在用户主目录下创建 python/Base 6、在Base下创建 day01 day02 day03 三个文件夹 7、在day01下创建一个文件 day01.txt 8、删除 python/Base 文件夹内的全部内容 答案: tarena@tedu:~$ mkdir -p PYTHON/linux/day01 tarena@tedu:~$ cd PYTHON/linux/day01 tarena@tedu:~/PYTHON/linux/day01$ touch day01.txt day02.txt day03.ttx tarena@tedu:~/PYTHON/linux/day01$ rm -rf day03.txt tarena@tedu:~/PYTHON/linux/day01$ touch day02.txt tarena@tedu:~/PYTHON/linux/day01$ mkdir -p ~/python/base tarena@tedu:~/PYTHON/linux/day01$ pwd /home/tarena/PYTHON/linux/day01 tarena@tedu:~/PYTHON/linux/day01$ ls day01.txt day02.txt day03.ttx tarena@tedu:~/PYTHON/linux/day01$ cd ~/python/base tarena@tedu:~/python/base$ mkdir day01 day02 day03 tarena@tedu:~/python/base$ cd day01 tarena@tedu:~/python/base/day01$ touch day01.txt tarena@tedu:~/python/base/day01$ cd tarena@tedu:~$ rm -rf python 一、二进制 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 163841 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0=0 1=1 2=10 3=11 4=100 5=101 6=110 7=111 8=1000 9=1001 .... 127=1111111二进制算法= 2**n-1 幂运算-1 · 十进制整数转二进制数:“除以2取余,逆序排列”(除二取 余法) 89÷2 ……1 44÷2 ……0 22÷2 ……0 11÷2 ……1 5÷2 ……1 2÷2 ……0 十进制整数转八进制数: 000 -> 0 | 004-> 4 | 010=8 001 -> 1 |005 -> 5| 011=9 002 -> 2 |006 -> 6 | 012=10 003 -> 3 |007 -> 7 | 013=11 十进制整数转十六进制数: 0000 -> 0 0100 -> 4 1000 -> 8 1100 -> C 0001 -> 1 0101 -> 5 1001 -> 9 1101 -> D 0010 -> 2 0110 -> 6 1010 -> A 1110 -> E 0011 -> 3 0111 -> 7 1011 -> B 1111 -> F 二、编码 Ascll码 255个字符 Ascll码表每个字符统一占用1个字节 Ascll码表不支持中文 支持中文的第一张表 叫GB2312 1980年 GB3212 支持6700+字 1995年 GBK1.0 支持20000字 2000年 GB18030 支持27000字 unicode :万国码 (支持所有国家的编码) 并且一个字符 统一占用2个字节 由于出于它的效率不高,对于存储和传输来说都很耗资源。为了提高Unicode的编码效率,于是就出现了UTF-8编码 UTF-8 、 UTF-8是 unicode的扩展集 英文占一个字节 东南亚 欧洲国家2个字节 中文3个字节 Assic --> GB2312 --> GBK1.0 --> GB18030 --> unicode --> UTF-8 Unicode是可以向下兼容GB2312、GBK 、GB17030而UTF8 重新划分分类和次序 不再是原来的次序编码 #!-*-coding:utf-8 -*- (声明使用utf8编码)#codig:utf-8(声明使用utf8编码) print u“我爱北京天安门?”(u代表转换Unicode格式)转换编码打印

优秀的个人博客,低调大师

Python全栈工程师(面向对象)

ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 开局一张图 Python人工智能从入门到精通 day16补充: 异常处理 文件操作综合练习示例 src_filename = input("请输入源文件路径名: ") dst_filename = input('请输入目标文件路径名: ') try: src = open(src_filename, 'rb') # 打开源文件用来读数据 try: try: dst = open(dst_filename, 'wb') # 打开目标文件用来写 try: while True: b = src.read(4096) # 4096当前Linux系统内核字节大小 if not b: # 已经再也读不到数据了 break dst.write(b) # 写字节到文件 print("复制成功") finally: dst.close() # 必须关闭文件 except OSError: print("打开写文件失败") finally: src.close() # 必须关闭文件 except OSError: print("复制失败") 面向对象编程: 以函数单位 面向对象编程 Ojbect-Oriented Programing什么是对象: 对象是指现实中的物体或实物 对象有什么属性: 对象有很多属性(名词,形容词) 姓名, 年龄, 性别 对象有很多行为(动作,动词) 吃饭,睡觉,工作面向对象: 把一切都看作对象(实例) 用各种对象之间的关系来描述事务什么是类: 拥有相同属性和行为的对象分为一组, 即为一个类 类是用来描述对象的工具,用类可以创建此类的对象(实例)面向对象示意: 车(类)----> BYD E6(京A:88888)实例(对象) \ \----> BMW X5(京A:66666)实例(对象) 狗(类)----> 小京巴(户籍号:0000001)实例(对象) \ \----> 导盲犬(户籍号:0000002)实例(对象) int(类)----> 100(对象) \ \----> 500(实例、对象)类的创建语句: class 类名(继承列表): ‘类的文档字符串’ 实例方法的定义 类变量的定义 类方法的定义(@classmethod) 静态方法的定义(@staticmethod) 作用: 创建一个类 类用于描述对象的行为和属性 类用于创建此类的一个或多个对象 说明: 类名必须是标识符 类名实质上就是变量, 它绑定一个类示例: # 用class语句 创建一个类 class Dog: ''' 这是文档字符串 描述一些小动物 ''' pass 构造函数 构造函数的调用表达式 语法: 类名([创建传参列表]) 作用: 创建这个类的实例对象,并返回此实例的引用关系 示例: dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定 print(id(dog1)) dog2 = Dog() # 创建另一个实例对象 print(id(dog2)) lst1 = list() # 调用构造函数创建一个列表对象 print(id(lst1)) lst2 = list() # 创建另一个实例对象 print(id(lst2)) 实例说明: 1.实例有自己的作用域和空间名, 可以为该类添加实例变量(也叫属性) 2.实例可以调用类的方法和实例方法 3.实例可以访问类变量和实例变量 实例方法: 语法: class 类名(继承列表) def 实例方法名(self, 参数1, 参数2...): ‘文档字符串’ 语句 作用: 用于描述一个对象的行为, 让此类型的全部对象都拥有相同的行为 说明: 实例方法实质是函数, 是定义类的函数 实例方法至少有一个形参, 第一个形参代表调用方法的实例, 一般命名为“self” 实例方法语法: 实例.实例方法名(调用传参) 或 实例.实例方法名(实参, 调用传参) 示例: # 实例方法的创建和调用 class Dog: ''' 这是文档字符串 描述一些小动物 ''' def eat(self, food): '''此方法用来描述小狗吃的行为''' print("小狗正在吃", food) def slep(self, hour): '''此方法用来描述小狗睡的行为''' print("小狗睡了%d小时" % hour) def play(self, obj): '''此方法用来描述小狗玩的行为''' print("小狗正在玩", obj) dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定 dog1.eat("单身狗粮") dog1.slep(3) dog1.play("球") dog2 = Dog() dog2.eat("提子") # 创建另一个实例对象 dog1.slep(5) dog1.play("MM") ====================== >>> import day17 小狗正在吃 单身狗粮 小狗睡了3小时 小狗正在玩 球 小狗正在吃 提子 小狗睡了5小时 小狗正在玩 MM >>> dir() ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'day17'] >>> dir(day17) ['Dog', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dog1', 'dog2'] >>> help(day17) >>> help(list) ====================== 实例属性 atribute(也叫实例变量) 每个实例对象可以有自己的变量, 称为实例变量(也叫属性) 语法: 实例.属性名 赋值规则: 首次为属性赋值则创建此属性 再次为属性赋值则修改属性的绑定关系 作用: 记录每个对象自身数据 示例: # 属性的方法 class Dog: ''' 这是文档字符串 描述一些小动物 ''' def eat(self, food): '''此方法用来描述小狗吃的行为''' print(self.color, "的", self.kinds, "小狗正在吃", food) # 让调用此方法的对象添加一个last_food属性用来记住吃过的信息(方法内添加属性) self.last_food = food # 方法外添加属性 dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定 dog1.kinds = "京巴" # 为dog1对象添加kinds属性, 绑定为"京巴" dog1.color = "白色" # 为dog1对象添加 color "白色"属性 dog1.color = "原谅色" # 改变dog1对象 color属性 print(dog1.color, "的", dog1.kinds) # 原谅色 的 京巴 dog2 = Dog() # print(dog2.color, "的", dog2.kinds) # 出错 dog2.kinds = "二哈" # 为dog2对象添加kinds属性, 绑定为"二哈" dog2.color = "白色" # 为dog2对象添加 color "白色"属性 dog2.color = "黄色" # 改变dog2对象 color属性 print(dog2.color, "的", dog2.kinds) # 黄色 的 二哈 dog1.eat("单身狗粮") # 原谅色 的 京巴 小狗正在吃 单身狗粮 dog2.eat("爱心蛋糕") # 黄色 的 二哈 小狗正在吃 爱心蛋糕 # 可以在方法(函数)外添加对象属性也可以在方法内添加 通常在方法内(函数) 删除属性:del 例如: class Dog: pass dog1 = Dog() dog1.color = "白色" del dog1.color del 变量名 删除变量del 列表[整数表达式] 删除列表元素del 字典[键] 删除字典中的键del 对象.属性 删除对象的属性 初始化方法: 作用: 对新创建的对象添加属性 语法: def __init__(self[, 形参列表]): 语句块 [ ] 代表可省略 说明: 1.初始化方法名必须为‘__init__’不可改变 2.初始化方法在构造函数创建实例后自动调用,且将实例自身 通过第一个参数self 传入__init__方法 3.构造函数的实参将通过__init__方法的参数列表传入到‘__init__’方法中 4.初始化方法内如果需要return语句返回 则返回None 示例: # 初始化方法 __init__ class Car: '''定义汽车类''' def __init__(self, c, b, m): self.color = c # 颜色 self.brand = b # 品牌 self.model = m # 型号 print('__init__方法被调用') def run(self, speed): print(self.color, "的", self.brand, self.model, "正才以", speed, "公里没小时行驶") a4 = Car("红色", "奥迪", "A4") # 调用构造函数 a4.run(1000) # 红色 的 奥迪 A4 正才以 1000 公里没小时行驶 s3 = Car("蓝色", "TESLA", "Model S") # 调用构造函数 s3.run(6000) # 蓝色 的 TESLA Model S 正才以 6000 公里没小时行驶 析构方法: 语法: class 类名: def __del__(self): ... 说明: 析构方法在对象被销毁时会自动调用 Python建议不要在对象销毁时做任何事情, 因为销毁时间难以确定示例: # 析构方法 class Car: def __init__(self, name): self.name = name print("汽车", name, "被创建") def __del__(self): '''析构方法,对象被销毁时 次方法调用''' print("汽车", self.name, "被销毁") c1 = Car("BYD E6") input("此汽车是伪造! 按回车继续程序...") # 汽车 BYD E6 被创建 # 此汽车是伪造! 按回车继续程序... # 汽车 BYD E6 被销毁 c2 = c1 del c2 input() # 汽车 BYD E6 被创建 预置实例属性: __dict__属性 __dict__属性绑定一个储存此实例自身变量的字典示例: >>> class Dog: ... pass >>> dog1 = Dog() >>> dog1.name = "哈哈" >>> dog1.__dict__ {'name': '哈哈'} >>> dog1.age = 3 >>> dog1.__dict__ {'age': 3, 'name': '哈哈'} >>> del dog1.age >>> dog1.__dict__ {'name': '哈哈'} >>> __class__属性 此属性用于绑定创建一些实例的类 作用: 可以借助于此属性来访问创建此实例的类示例: >>> class Dog: ... pass ... >>> dog1 = Dog() >>> Dog <class '__main__.Dog'> >>> dog1.__class__ <class '__main__.Dog'> >>> type(dog1) <class '__main__.Dog'> >>> type(dog1) is Dog True >>> dog2 = dog1.__class__() # 等同于 dog2 = Dog() >>> dog2.__class__ <class '__main__.Dog'> 面向对象的综合示例: 有两个人: 1. 姓名:张三 年龄:25 2. 姓名:李四 年龄:5 行为: 1.教别人学学东西 teach 2.赚钱 works 3.借钱 borrow 事情: 张三 教 李四 学 Python 李四 教 张三 学 跳皮筋 张三 上班赚了 1000 元钱 李四 向 张三 借了 200 元钱 打印张三的信息:25岁 的 张三 有钱 800元 他学会了跳皮筋 打印李四的信息:5岁 的 李四 有钱 200元 他学会了python class Human: '''描述人的行为和属性 teach(self, other, subject) 学习技能 works(self, money) 赚钱 borrow(self, other, money) 借钱 def print_info(self) 输出信息 ''' def __init__(self, name, age): '''初始化基本信息和属性''' self. name, self.age = name, age # 名字, 年龄 self.money = 0 # 钱数 self.skill = [] # 技能列表 def teach(self, other, subject): '''实例行参对象1 教 实例行参对象2 学 技能的实例方法 self:实例形参1(调用对象自己) other: 实例形参2 (调用目标对象) subject: 技能 ''' other.skill.append(subject) # 行参对象2 追加新技能 print(self.name, "教", other.name, "学", subject) def works(self, money): '''实例行参对象的 赚钱 实例方法 self:实例行参(调用对象自己) money:赚的钱数 ''' self.money = money # 实例形的钱数 print(self.name, "上班赚了", money, "元钱") def borrow(self, other, money): '''实例行参对象1 向 实例行参对象2 借钱 的实例方法 self:实例形参1(调用对象自己) other: 实例行参2 (调用目标对象) monay: 接的钱数 ''' if other.money > money: # 目标对象的钱小于借钱数额 借钱失败 self.money += money # 自己的钱 other.money -= money # 目标对象剩余的钱 print(self.name, "向", other.name, "借了", self.money, "元钱") else: print(self.name, "向", other.name, "借钱失败!") def print_info(self): '''打印输出self的信息实例方法 self:实例行参(调用对象自己) ''' print(self.age, "岁的", self.name, "有钱", self.money, "元 他学会了:", self.skill) zhang3 = Human("张三", 25) li4 = Human("李四", 5) # 张三教李四Python zhang3.teach(li4, "Python") # 李四教张三玩游戏 li4.teach(zhang3, "玩游戏") # 张三上班赚了 1000 元钱 zhang3.works(1000) # 李四向张三借 200 元钱 li4.borrow(zhang3, 200) # 打印李四信息 li4.print_info() # 打印张三信息 zhang3.print_info() # 第一个实例形参一般为调用者自己 # (自动传参自己 不需要填写 直接从第二个形参开始) # __init__()初始化信息函数内的属性为公用属性 # 初始化对象后每个对象都会调用__init__内的属性 # 其他方法(单独属性)另需调用 用于类的函数: isinstance(obj, class_or_tuple) 返回这个对象obj是否是某个类的对象或某些类中的一个类的对象, 如果是则返回True,否则返回False type(obj) 返回对象的类型 >>> a = 100 >>> isinstance(a, int) True >>> isinstance(a, bool) False >>> a = 100.0 >>> isinstance(a, int) False >>> isinstance(a, float) True >>> type(a) <class 'float'> >>> a = 100 >>> type(a) <class 'int'> >>> 练习: 自己写一个'人'类: Human class Human: def set_info(self, name, age, address='未知'): '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性''' ... # << 此处自己实现 def show_info(self): '''显示此人的全部信息''' ... # 此处自己实现 如: h1 = Human() h1.set_info('小张', 20, '北京市朝阳区') h2 = Human() h2.set_info('小李', 18) h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区 h2.show_info() # 小李今年 18 岁,家庭住址:末知 答案: class Human: def set_info(self, name, age, address='未知'): '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性''' self.name = name self.age = age self.address = address def show_info(self): '''显示此人的全部信息''' print(self.name, '今年', self.age, '岁,家庭住址:', self.address) h1 = Human() h1.set_info('小张', 20, '北京市朝阳区') h2 = Human() h2.set_info('小李', 18) h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区 h2.show_info() # 小李今年 18 岁,家庭住址:末知 class Human: def set_info(self, name, age, address='未知'): '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性''' self.name = name self.age = age self.address = address def show_info(self): '''显示此人的全部信息''' print(self.name, '今年', self.age, '岁,家庭住址:', self.address) h1 = Human() # h1.set_info('小张', 20, '北京市朝阳区') Human.set_info(h1, '小张', 20, '北京市朝阳区') h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区 练习: 写一个Student类 1) 为该类添加初始化方法, 实现在创建对象时自动设置 '姓名','年龄', '成绩' 属性 2) 添加set_score方法能修改成绩信息 3) 添加show_info方法打印学生对象的信息 如: class Student: def __init__(...): ... ... s1 = Student('小王', 15, 59) s1.show_info() # 小王 今年 17 岁, 成绩是: 59 s1.set_score(80) s1.show_info() # 小王 今年 17 岁, 成绩是: 80 答案: class Student: def __init__(self, n, a, s): self.name, self.age, self.score = n, a, s def show_info(self): print(self.name, '今年', self.age, '岁, 成绩是:', self.score) def set_score(self, s): assert 0 <= s <= 100, '参数错误' self.score = s s1 = Student('小王', 15, 59) s1.show_info() # 小王 今年 17 岁, 成绩是: 59 s1.set_score(80) # s1.score = 80 s1.show_info() # 小王 今年 17 岁, 成绩是: 80 上面两个练习我写了一份很详细的 明天改 这个先凑合着... 练习: 修改原来的学生信息管理程序,将原来字典来存储学生信息, 现改为用对象来存储学生信息 # file : student.py class Student: def __init__(self, n, a, s): .... L = [] # L.append({...}) 改为对象 L.append(Student('xiaozhang', 20, 100)) (要求类Student 要写在模块 student.py中) 示例: # 假如文件中有这么多学生信息 L = [{"name": "Tom", "age": 15, "score": 98}, {"name": "AL", "age": 16, "score": 95}, {"name": "Lix", "age": 16, "score": 95}, {"name": "Li", "age": 16, "score": 95}, {"name": "ix", "age": 16, "score": 95}, {"name": "ix", "age": 16, "score": 95}, {"name": "Ax", "age": 16, "score": 95}, {"name": "i", "age": 16, "score": 95}, {"name": "x", "age": 16, "score": 95}, {"name": "Lx", "age": 16, "score": 95}, {"name": "ALi", "age": 16, "score": 95}, {"name": "Ka", "age": 16, "score": 95}, {"name": "Kla", "age": 16, "score": 95}, {"name": "KAl", "age": 16, "score": 95}, {"name": "Ala", "age": 16, "score": 95}, {"name": "Al", "age": 16, "score": 95}, {"name": "KAla", "age": 17, "score": 100}] class Student: '''创建学生类用来描述学生基本信息''' def __init__(self, n, a, s): '''初始化学生信息''' self.name, self.age, self.score = n, a, s def student_info(self): '''输出此学生信息''' print("Name:", self.name, "Age:", self.age, "score:", self.score) def student_list(L): '''将文件内学生信息编号存入列表''' L1 = [] for x, y in zip(L, range(1, len(L) + 1)): y = Student(x["name"], x["age"], x["score"]) L1.append(y) return L1 # 也可以用迭代器函数 # def student_list(): # for x in L: # y = Student(x["name"], x["age"], x["score"]) # yield y # 输出所有学生信息 def print_student(L): '''输出有所有学生信息''' for stud in L: stud.student_info() print_student(student_list(L))

优秀的个人博客,低调大师

Python全栈工程师(异常(基础))

ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 Python人工智能从入门到精通 补充:包的相对导入 只对后两种导入方式有用 前两次改进的学生管理系统在20课中 已补充 异常(基础)except: 什么是错误: 是指由于逻辑或语法等导程序无法正常执行的问题 什么是异常: 是程序出错的标识符的一种状态 当异常发时 程序不会再向下执行,而转去调用此函数的地方 待处理此错误并恢复为正常状态 异常的作用: 用作信号, 通知上层调用者有错误产生需要处理try 语句: 两种语法: ry-except语句(接受异常通知) try-finally语句try-except 语法 : try: 可能触发异常的语句 except 错误类型1[as 变量1]: 异常处理语句2 except 错误类型2[as 变量2]: 异常处理语句2 except (错误类型3, 错误类型4,...)[as 变量3]: 异常处理语句3 ...... except: 异常处理语句(其他)(匹配所有类型错误) else: 未发生异常语句(可以没有此语句 没有发成异常时调用) finlly: 最终语句 作用: 尝试捕获异常, 将程序由异常状态转为正常状态并正常执行 说明: 1. as 子句是用于绑定错误对象的变量,可以省略 2. except 子句可以有一个或多个,但至少要有一个 3. else 子句最多只能有一个,也可以省略不写 4. finally 子句最多只能有一个,也可以省略不写 5. else 子句将在try没有出现异常时执行 6. finally子句的语句在任何情况下都会被执行 示例: # 此示例示意用try-except 语句捕获异常并做出相应的处理 def div_apple(n): print("%d个苹果您想分给几个人?" % n) s = input("请输入人数: ") cnt = int(s) # <- 此处可能触发ValueError类型错误 result = n / cnt # <- 此处可能触发ZeroDivisitionError错误 print("每个人分了%d个苹果" % result) try: print("开始分苹果") div_apple(10) # 可能触发异常的调用 print("结束分苹果") except ValueError: print("发生成值错误,已处理并转为正常状态!") except ZeroDivisionError: print("发生了被零除的错误,程序已转为正常状态") print("程序正常执行并完全任务,退出程序") try-finally语法: try: 可能触发异常的语句 finally: 最终语句 说明: 1.finally子句不可以省略 2.一定不存在except子句 作用: 通常try-finally语句来做触发异常时必须要处理的事情 无论异常是否发生, finally子句一定会被执行 注意: try-finally 语句不会改变程序的(正常/异常)状态 示例: # 以下以 煎蛋为例示意 try-finally语句的用法 # 必须要做的事情是,关闭天燃气 def fry_egg(): print("打开天燃气点燃...") try: count = int(input("请输入鸡蛋个数: ")) print("完成煎鸡蛋,共煎了%d个鸡蛋" % count) finally: print("关闭天燃气") fry_egg() raise 语句:(发起异常通知) 作用: 触发一个错误, 让程序进入异常状态 语法: raise 异常类型 或 raise 异常对 实例: def make_exception(): print("函数开始") # 发出一个ValueError类型的错误通知给调用者 # raise ValueError err = ValueError("这是自定义的错误数据") raise err # 用 err触发一个异常通知 print("函数结束") try: make_exception() print("make_exception调用结束!") except ValueError as e: print("接收到ValueError类型的异常通知") print("错误对象是:", e) assert 断言语句: 语法: assert 真值表达式, 错误数据(通常是字符串) 作用: 当真值表达式为False时, 用错误数据创建一个AssertionError 类型的错误, 并进入异常状态 等同于: if 真值表达式 == false raise AssertrtionError(错误数据) 实例: def get_score(): s = int(input("请输入学生成绩: ")) assert 0 <= s <= 100, '成绩超出范围' # if not (0 <= s <= 100): # raise AssertionError('成绩超出范围') return s try: score = get_score() except AssertionError as err: print("错误数据是:", err) print('获取成绩失败') score = 0 print("学生的成绩为:", score) 小结: 异常处理语句(4条): try-except 语句: 用于接受异常通知, 捕获异常 try-finally 语句: 执行必须执行的语句 raise 语句: 发送异常通知, 并进入异常状态 assert 语句: 根据条件选着性的发送 AssertionError类型的异常通知为什么要处理异常机制: 在程序调用层数比较深的时候, 向主调用函数传递错误信息 需要层层return返回 比较麻烦, 用异常处理机制可以较简单的传递错误信息 Python全部的错误类型 错误类型 说明 以下内容必讲 ZeroDivisionError 除(或取模)零 (所有数据类型) ValueError 传入无效的参数 AssertionError 断言语句失败 StopIteration 迭代器没有更多的值 IndexError 序列中没有此索引(index) IndentationError 缩进错误 OSError 输入/输出操作失败 ImportError 导入模块/对象失败 NameError 未声明/初始化对象 (没有属性) AttributeError 对象没有这个属性 GeneratorExit 生成器(generator)发生异常来通知退出 TypeError 对类型无效的操作 KeyboardInterrupt 用户中断执行(通常是输入^C) OverflowError 数值运算超出最大限制 FloatingPointError 浮点计算错误 BaseException 所有异常的基类 SystemExit 解释器请求退出 Exception 常规错误的基类 StandardError 所有的内建标准异常的基类 ArithmeticError 所有数值计算错误的基类 EOFError 没有内建输入,到达EOF 标记 EnvironmentError 操作系统错误的基类 WindowsError 系统调用失败 LookupError 无效数据查询的基类 KeyError 映射中没有这个键 MemoryError 内存溢出错误(对于Python 解释器不是致命的) UnboundLocalError 访问未初始化的本地变量 ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象 RuntimeError 一般的运行时错误 NotImplementedError 尚未实现的方法 SyntaxError Python 语法错误 TabError Tab 和空格混用 SystemError 一般的解释器系统错误 UnicodeError Unicode 相关的错误 UnicodeDecodeError Unicode 解码时的错误 UnicodeEncodeError Unicode 编码时错误 UnicodeTranslateError Unicode 转换时错误 以下为警告类型 Warning 警告的基类 DeprecationWarning 关于被弃用的特征的警告 FutureWarning 关于构造将来语义会有改变的警告 OverflowWarning 旧的关于自动提升为长整型(long)的警告 PendingDeprecationWarning 关于特性将会被废弃的警告 RuntimeWarning 可疑的运行时行为(runtime behavior)的警告 SyntaxWarning 可疑的语法的警告 UserWarning 用户代码生成的警告 详见:help(builtins) 练习: 写一个函数 get_score() 来获取学生成绩, 要求用户输入 1~100的整数,输果输入出现异常,返此函数返回0, 否则返回用户输入的成绩 示例: def get_score(): ... score = get_score() print("学生的成绩是:", score) 练习: 1. 一个球从100米高空落下 ,每次落地后反弹高度是原高度的一半, 在落下 1)写程序算出皮球在第10次落地后反弹高度是多高? 2)打印出球共经过多少米的路程 答案: def ball(n, m): L = [100] while True: if n == 0: print("最后弹起的高度是%s米" % s) break s = m * 0.5 m = s L.append(s + m) n -= 1 return L print("10次共经历了%s米的路程" % sum(ball(10, 100))) 2. 分解质因数, 输入一个整数, 分解质因数 , 如: 输入 90 则打印: “90=2*3*3*5” (质因数是指最小能被原数整除的素数 不包括1) 答案: def m(n): ret = [] while n > 1: for i in range(n): k = i + 2 if n % k == 0: ret.append(k) n = int(n / k) break return ret print(m(90)) 3. 修改原学生信息管理程序,加入异常处理语句,让程序在任何情况下都能够按逻辑正常执行. 例如: 输入成绩和年龄时,如果用户输入非法字符串也不会导致程序崩溃

优秀的个人博客,低调大师

Python全栈工程师(集合、函数)

ParisGabriel 感谢 大家的支持 你们的阅读评价就是我最好的动力 我会坚持把排版内容以及偶尔的错误做的越来越好 每天坚持 一天一篇 点个订阅吧灰常感谢 当个死粉也阔以 Python人工智能从入门到精通 集合 set: 集合是可变的容器 集合内的数据对象都是唯一的(不能重复的) 集合是无序的储存结构。集合中的数据没有先后顺序关系 集合内的元素必须是不可变对象 集合是可迭代对象 集合相当于只有键没有值得字典(键则是集合的数据) (相当于字典和列表的结合 ) 创建集合: s = set() #空集合 s = {3.14,True,(1970.1.1),“hello”} #非空 集合的构造函数: set()创建一个空集合(不能用{} 否则就是字典了) set(iterable)用可迭代对象创建一个新的集合 创建新集合 内容重复会自动去重 例如: 集合的运算: 交集、并集、补集,子集、超集& 生成连个集合的交集: 重复部分 s1 ={1,2,3} s2 ={2,3,4} s3 = s1&s2 #s3 = {2,3} | 生成两个集合的并集: 所有不重复部分 s1 ={1,2,3} s2 ={2,3,4} s3 = s1 | s2 #s3 = {1,2,3,4} - 生成两个集合的补集: 相当于减法 s1 ={1,2,3} s2 ={2,3,4} s3 = s1 - s2 #s3 = {1} ^ 生成两个集合的对称补集: 相当于减法相加 s1 ={1,2,3} s2 ={2,3,4} s3 = s1 ^ s2 # (s1 - s2 | s2 - s1) #{1, 4} > 判断一个集合是另一个集合的超集< 判断一个集合是另一个集合的子集 s1 ={1,2,3} s2 ={2,3} s1 > s2 #true s1 为s2的 超集 s1 < s2 #true s1 为s2的 子集 (包含关系判断)== != 集合相同/不同: s1 ={1,2,3} s2 ={3,2,1} s1 == s2 # true s1 != s2 #false in / not in : 等同于字典的运算 判断某个值是否存在 集合和字典的优点: in/not in 运算符速度相对来说快一些 能用于集合的函数: len(x)、max(x)、min(x)、sum(x)、any(x)、all(x) Python3中常用的集合方法: 方法; 意义: S.add(e) 在集合中添加一个新的元素e;如果元素已经存在,则不添加 S.remove(e) 从集合中删除一个元素,如果元素不存在于集合中,则会产生一个KeyError错误 S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做; S.clear() 清空集合内的所有元素 S.copy() 将集合进行一次浅拷贝 S.pop() 从集合S中删除一个随机元素;如果此集合为空,则引发KeyError异常 S.update(s2) 用 S与s2得到的全集更新变量S S.difference(s2) 用S - s2 运算,返回存在于在S中,但不在s2中的所有元素的集合 S.difference_update(s2) 等同于 S = S - s2 S.intersection(s2) 等同于 S & s2 S.intersection_update(s2) 等同于S = S & s2 S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False S.issuperset(...) 如果S为s2的子集返回True,否则返回False S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2 S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 S S.union(s2) 生成 S 与 s2的全集 集合推导式: 结合推导式是用可迭代对象生成集合的表达式语法: {表达式 for 变量 in 可迭代对象[if 真值表达式]} 之前说过 [ ] 内的代表可以省略例如: L= [1, 2, 5, 6, 3, 5, 9, 4, 5] s = {x for x in L)} (推导式嵌套同列表 、 字典一致) 固定集合 frozenset: 是不可变的、无序的、含有唯一元素的集合 用于固定集合可以作为字典的键,还可以作为集合的值构造函数: frozenset() 创建一个空固定集合 frozenset(iterable)用可迭代对象创建固定集合例如: f = frozenset()# 空固定集合 f = frozenset([ 1, 3, 5, 7]) # f = frozenset({1, 3, 5, 7}) 固定集合运算: & 交集 、 | 并集 、- 补集、^ 对称补集 >、 >= 、< 、<=、 ==、 != in /not in (和集合 set 一致)固定集合方法: 集合的方法取掉所有修改方法 小结: 数据类型: 数值类型: int、float、complex、bool 容器类型: 不可变容器: str、tuple、frozenset、bytes(字节串) 可变容器: list、dict、set、bytearray(字节组) 值: None、false、True运算符: 算数运算符: +、 - 、 * 、 / 、 // 、 % 、 ** 比较运算符: < 、 > 、 <= 、 >= 、 == 、 != in / not in 、 is / is not 布尔运算符: not 、 and 、or +(正号)、 -(负号) &、^ 、| 、 [ ] (索引) 表达式: 1 1+2 max(1,2,3,) x if x > y else y (条件表达式) 三种推导式: 列表、字典、集合推导式(3种)语句: 表达式语句: 所有的语句都可单独写在一行,形成一个语句 例如: print(“hello world”) 1 + 2 赋值语句: a = 100 a = b = c = 100 x, y = 100, 200 a[0] = 100 dict [ "name"] = "tarena" del 语句 while 语句 for 语句 break 语句 continue 语句 pass 语句函数: 内建函数:(系统内置函数) len(x) max(x) min(x) sum(x) any(x) all(x) 构造函数:(用来创建同类型的数据对象) bool(x) int(x)(进制转换可以添加进制参数 be>=2 and <= 36) float(x) complex(x) list(x) tuple(x) str(x) dict(x) set(x) abs(x) round(x) pow(x,y,z = None) bin(x) oct(x) hex(x) chr(x) ord(x) range(star,stop,step) input(x) print(x) help(__builtins__) 之前讲的差不多也就这些了 接下来我们讲函数 okeveryone 在开始之前的我想先说两句 咳咳: 之前比如说101等于5对吧 可能手一哆嗦打成了011 有细心的小伙伴就发发现了 给我评论 你们如果有什么问题 可以随时评论 我看到后 都会回复的 能解决的我有时间都会去解决 比如说哪里不懂啊 逻辑想不通啊 或者比较迷茫的 都是可以的 前面12课说的都是常用的和偶尔用的一些基础的运算以及语法 很多东西一次测扯出来根本听不懂的 学习要循序渐进对吧 后面的东西 我们会做一个实战项目 边做边学 有些可能一辈子用不几次的东西就没说 感兴趣的朋友可以 交互模式下help 查看一下帮助 或者官方的api文档 翻译好的api文档都是可以的 第一课之前的那个文章 我在里面加了api文档地址 有兴趣的可以去下载 这个项目的就是学生信息管理系统 昨天的第二题练习 我们已经做了一个开头了对吧 好了不废话了 进入正题 函数: function 函数是可以重复执行调用的语句块 作用: 1.用于封装语句块,提高代码的重用性 2.定义用户级别的函数def 创建函数语句: def 函数名(形参列表): 语句块 说明: 1. 函数的名字就是语句块的名称 2. 函数名的命名规则与变量名相同(函数名必须是标识符) 3. 函数名是一个变量(不要轻易对其赋值) 4. 函数有自己的空间,在函数外部不可以访问函数内部的变量,但是可以访问外部变量 5. 函数如果不需要传入参数,形参列表可以为空 6. 语句部分不能为空,如果为空需要填充passreturn 创建返回值语句: 用于函数中,结束当前函数的执行,返回调用该函数的地方,同时返回一个对象的引用关系 return[表达式] ([ ] 代表可以省略) 说明: 1. 函数调用是一个表达式 2. 如果函数内部没有return语句,函数调用完毕后返回None对象 3. 如果函数需要返回其它的对象需要用到 return 语句函数的调用: 函数名(实际调用传递参数) (实际调用传递参数,简称实参) 练习:1.任意输入一些数字,存于列表L中。当输入负数时结束输入 1) 打印这些数的和 2) 打印这些数有多少种(去重) 3) 除重复的数字后,打印这些剩余数字的和 提示,可以用集合去重 答案: L = [] while True: a = int(input("please input at will ingeger (input '-1' over):")) if a < 0: break L.append(a) print(sum(L)) s = set(L) print(len(s)) print(sum(s)) 2.经理有: 曹操,刘备,孙权 技术员有: 曹操,孙权,张飞,关羽 用集合求:1) 即是经理,也是技术员的有谁? 2) 是经理,但不是技术员的人员都有谁? 3) 是技术员,不是经理的都有谁 4) 张飞是经理吗? 5) 身兼一职的人都有谁? 6) 经理和技术员共有几个人? 答案: s = {"曹操", "刘备", "孙权"} s1 = {"曹操", "孙权", "张飞", "关羽"} if "张飞" in s: x = "是" else: x = "不是" print(''' 即是经理,也是技术员的有:%s 是经理,但不是技术员的人员有:%s 是技术员,不是经理的有:%s 张飞%s经理 身兼一职的人有:%s 经理和技术员共有:%d个人 ''' % ( s & s1, s - s1, s1 - s, x, s ^ s1, len(s | s1))) 3. 写一个函数myadd, 此函数中的参数列表里有两个参数x, y 此函数的功能是打印 x + y 的和 def myadd(....): .... # 注: .... 部是是我们要填写代码的地方 myadd(100, 200) # 300 print("ABC", "123") # ABC123 4. 写一个函数 mysum, 传入一个参数x代表终止整数, 打印出 1 + 2 + 3 + 4 + ..... + x的和 def mysum(x): .... mysum(100) # 5050 mysum(4) # 10 答案: def mysum(x): s = 0 for i in range(1, x + 1): s += i print(s) mysum(100) mysum(4) 5. 写一个函数 mymax, 给函数传递两个参数,返回两个实参中最大的一个 def mymax(a, b): .... v = mymax(100, 200) print('v =', v) # v = 200 print(mymax('ABC', 'abc')) # abc 答案: def mymax(a, b): if a > b: return a return b x = mymax(100, 200) print(x) 6. 写一个函数 input_number def input_number(): .... 此函数用来获取用户循环输入的整数,当用户输入负数时结束输入。将用户输入的数字以列表的形式返回,再用内建函数max, min, sum取出户输入的最大值,最小值及和 L = input_number() print(L) # 打印此列表 print("用户输入的最大数是:", max(L)) print("用户输入的最小数是:", min(L)) print("用户输入的数的和是:", sum(L)) 答案: def inout_number(): L = [] while True: number = int(input("please inoput (-1:over):")) if number < 0: break L.append(number) return L L = inout_number() print("Top1 ", max(L)) print("lower1 ", min(L)) print("sum ", sum(L)) 7. 写一个函数 print_odd, 打印从begin开始,到end结束(不包含end)内的全部的奇数 def print_odd(begin, end): .... print_odd(1, 10) # 打印 1 3 5 7 9d ptint_odd(10, 20) # 打印 11 13 15 17 19 答案: def myodd(begin, end): for x in range(begin, end): if x % 2 != 0: print(x, end = " ") print() myodd(1, 10) myodd(10, 100) 9. 改写之前的学生信息管理程序 改为两个函数: 1. 写一个函数 input_student() 用于返回学生信息的字典的列表(以前格式一样) 2. 写一个函数 output_student(lst) 此函数传入一个列表lst,即字典的列表 此函数把lst的内容以表格形式打印出来 def input_student(): .... def output_student(lst): ... L = input_student() # 获取学生信息的列表 output_student(L) # 把L 以列表的形式打印 答案: # 创建输入函数:input_student开始 def input_student(): print("--------Student information enty--------") L = [] while True: name = input("please input name:") if name == "": break age = input("please input age:") score = input("please input score:") d = {} d = {"name": name, "age": age, "score": score} L.append(d) return L # 创建输入函数:input_student完成 # 创建输出函数:output_student开始 def output_student(lst): print("-------Student information sheet-------") print("+---------------+----------+----------+") print("| name | age | score |") print("+---------------+----------+----------+") for d in lst: name = d["name"].center(15) age = d["age"].center(10) score = d["score"].center(10) print('''|%s|%s|%s|''' % (name, age, score)) print("+---------------+----------+----------+") # 创建输出函数:output_student完成 output_student(input_student())

优秀的个人博客,低调大师

Python全栈工程师(元组、字典)

ParisGabriel 感谢 大家的支持 你们的阅读评价就是我最好的更新动力 我会坚持吧排版做的越来越好 每天坚持 一天一篇 点个订阅吧灰常感谢 当个死粉也阔以 Python人工智能从入门到精通 函数:tyup(x) 用来返回x对应的数据类型 range(x) 返回可迭代对象sublime编辑器: 中文空格查找方法 空格中间没有小点 行首小黑点 语法不规范 大黑点语法错误 中文空格也会出错元组 tuple: 元组是不可变的序列,同list一样,元组可以存放任意数据类型的容器元组的表示方法: 用小括号()括起来,单个元素括起来后面加 “,”逗号区分单个对象还是元组 元组的小括号可以省略 但元素低于2个 “,” 不能省略元组的构造函数: tuple() 生成一个空元组,等同于() tuple(iterable) 用可迭代对象生成一个元组元组的运算: + += * *= < > <= >= == != in , not in 索引[ ], 切片[ : ] [ : : ] + 拼接元组 * 生成重复元组元祖的比较: 规则与列表规则完全相同 in , not in 规则与列表规则完全相同索引和切片: 索引取值和切片取值的规则与列表相同 元组不支持索引赋值和切片赋值(因为元组是不可变的序列)元组的方法: T.index(v[, begin[, end]]) 返回对应圆的索引下表 T.count(x) 返回对应元素个数序列相关函数:len(x)、max(x)、min(x)、sum(x)、any(x)、all(x) str(x) 创建字符串构造函数: (构造函数一定是他的类型名 返回对应类型) list(inerable) 创建列表 tuple(inerable) 创建元组 reversed(x) 返回反向顺序的可迭代对象 sorted(inerable,key = None,reverse = false) 返回已排列列表 inerable:可迭代对象 (key = None,reverse = false:后面将)例如: t = (4, 5, 8, 3, 2, 1) L = [x for x in reversed(t)] print(L) 容器小结: 字符串str # 不可变序列, 只能存字符 列表 list # 可变序列,可存任意数据 元组 tuple #不可变序列,可以存任意数据字典 dict: 1.字典是一种可变容器,可以储存任意类型数据 2.字典中的每个数据都是用“键”(key)进行索引 ,而不像序列可以用整数下标来进行索引 3.字典中的数据没有先后关系,字典的储存是无序的 4.字典的数据以键(key)- 值(value)对形式进行映射储存 5.字典的键不能重复,只能用不可变类型作为字典的键字典的字面值的表示方法: 字典的表示方式是以{ }括起来的,以冒号开头“:” 分隔键-值对,各键-值对之间用逗号分开创建字典: d = { } #空字典 d = { “Nemo”:“yang”,“age”: 35} #非空字典 键:“Nemo”值:“yang”(一个键值对) 键(只能用不可变类型) 值可以任意类型 字符串str 列表 list 元组 tuple 字典 dict 都是可以任意包含关系的 字典的构造函数dict: dict() 生成一个字的字典 等同于{ } dict(iterable) 用可迭代对象初始化一个字典 dict(** keargs) 用关键字传参形式创建字典 关键字传参:(dict(name = “tarena”,age = 15)) 索引:d [key ] 字典的key:不可变数据类型: bool,int,float,complex,str,tuple,frozeset,bytes可变数据类型有四种: list 列表 dict 字典 set 集合 bytearray 字节数组 字典的基本操作: 键索引 用 [ ] 运算符获取字典内“键”对应的值 也可以修改 字典[ 键 ] = 值 如果键不存在时,创建键,并绑定对应的值 当存在时,修改键绑定的值 del 字典 [ 键 ] (删除元素)字典的成员资格判断 in 运算符: 可以用 in 运算符判断一个键是否存在于字典中,如果存在则返回true 否则返回false not in 与 in 结果相反例如: d = {"name": "Gabriel", "age": 20} if "name" in d: print("name 在字典中 ") print(15 in d) # false 只判断键 不判断值 字典的迭代访问: 字典是可迭代对象,字典只能对键进行迭代访问例如: d = {"name":"tarena", age: 15} for x in d: print(x, d[ x ])内建函数:(内建:代表系统内直接有的函数) len(d) 返回的是键值对个数 max(d) 返回的是键最大值 min(d) 返回的是键最小值 sum(d) 返回的是键得和 any(d) 一个键为true则为true all(d)所有键为true 则为true字典的方法: 函数 说明 D代表字典对象 D.clear() 清空字典 D.pop(key) 移除键,同时返回此键所对应的值 D.copy() 返回字典D的副本,只复制一层(浅拷贝) D.update(D2) 将字典 D2 (合并)到D中,如果键相同,则此键的值取D2的值作为新值 D.get(key, default) 返回键key所对应的值,如果没有此键,则返回default D.keys() 返回可迭代的 dict_keys 集合对象(返回键) D.values() 返回可迭代的 dict_values 值对象(返回值) D.items() 返回可迭代的 dict_items 对象(返回键值对)字典推导式: 是用可迭代对象创建字典的表达式语法: {键表达式:值表达式 for 变量 in 可迭代对象 if 真值表达式} if子句可以省略 d = { x:x ** 2 for x in range(10)}字典VS列表: 1.都是可变对象 2.索引方式不同,列表用整数(下标)索引 ,字典用键(key)索引 3.字典的插入,删除,修改数据的速度可能会快于列表 4.列表的存储是有序的(内存中一般用排列算法),字典的储蓄是无序的(内存中一般用散列算法插入数据) 练习: 1.已知有两个等长的列表 list1 和 list2 以list1中的元素为键,以list2中的元素为值,生成相应的字典 list1 = [1001, 1002, 1003, 1004] list2 = ['Tom', 'Jerry', 'Spike', 'Tyke'] 答案: list1 = [1001, 1002, 1003, 1004] list2 = ['Tom', 'Jerry', 'Spike', 'Tyke'] d = {list1[x]: list2[x] for x in range(len(list1))} print(d) 2. 输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典中,然后放入至列表中,每个学生的信息需要手动输入 当输入姓名为空时结束输入: 如: 请输入姓名: xiaozhang 请输入年龄: 20 请输入成绩: 100 请输入姓名: xiaoli 请输入年龄: 18 请输入成绩: 98 请输入姓名: <回车> 结束输入 要求内部存储格式如下: [{'name':'xiaozhang', 'age':20, 'score':100}, {'name':'xiaoli', 'age':18, 'score':98}] 打印所有学生的信息如下: +---------------+----------+----------+ | name | age | score | +---------------+----------+----------+ | xiaozhang | 20 | 100 | | xiaoli | 18 | 98 | +---------------+----------+----------+ 答案: L = [] while True: n = input("请输入姓名:") if n == '': break a = int(input("请输入年龄:")) s = int(input("请输入成绩:")) d = {} d['name'] = n d['age'] = a d['score'] = s L.append(d) # print(L) print("+---------------+----------+----------+") print("| name | age | score |") print("+---------------+----------+----------+") for d in L: n = d['name'].center(15) a = str(d['age']) ac = a.center(10) s = str(d['score']) sc = s.center(10) line = "|%s|%s|%s|" % (n, ac, sc) print(line) print("+---------------+----------+----------+")

优秀的个人博客,低调大师

Python全栈工程师(列表、拷贝)

ParisGabriel 感谢 大家的支持 你们的阅读评价就是我最好的更新动力 我会坚持吧排版做的越来越好 每天坚持 一天一篇 点个订阅吧灰常感谢 当个死粉也阔以 Python人工智能从入门到精通 列表创建函数: list(可迭代对象)序列有5种: star 字符串 list 列表 tuple 元组 bytes 后面讲 bytearray 后面讲 序列运算符: in 、 not in > >= < <= + * 列表的索引可以增加、删除、修改、列表的元素值切片赋值: 步长不等于1时切片赋值,赋值运算符的右侧的可迭代对象提供的元素 的个数一定要等于切片切出的片数del语句: 用于删除列表的元素 del 列表 [索引] del 列表 [切片]Python3中常用的序列相关函数: len(x) 返回序列的长度 max (x) 返回最大元素 min(x) 返回序列最小元素 sum(x) 返回序列中所有原素的和 any(x) 真值测试,如果列表中有一个值为真返回true all(x) 真值测试,如果列表中所有值为真返回true 列表的方法(method):help(list) [ ]内的参数代表可以省略 方法 意义L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin:为开始索引,end:为结束索引,当 value 不存在时触发ValueError错误L.insert(index, obj) 将某个元素插放到列表中指定的位置 index:索引 obj:要插入的元素L.count(x) 返回列表中元素的个数 x:元素L.remove(x) 从列表中删除第一次出现在列表中的值 x:元素(例如列表内有2个3 删除第一个 依次进行)L.copy() 复制此列表(只复制一层,不会复制深层对象)L.append(x) 向列表中追加单个元素 可以追加可迭代对象元素L.extend(list) 向列表追加另一个列表 L.clear() 清空列表,等同于 L[:] = []L.sort(reverse=False) 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列L.reverse() 列表的反转,用来改变原列表的先后顺序L.pop([index]) 删除索引对应的元素,如果不加索引,默认删除最后元素,同时返回删除元素的引用关系(相当于取出元素不归还,可以用变量来接受)字符串的文本解析方法:S.split(sep=None) 将字符串使用sep作为分隔符分割字符串,返回分隔后的字符串列表,当不给定参数时,用空白字符作为分隔符分隔S.join(iterable) 用可迭代对象中的字符串,返回一个中间用S分隔组合的字符串 S=esp 要插入分割链接的字符 iterable:可迭代对象 潜拷贝和深拷贝: 潜拷贝shallow copy: help(list.copy) 拷贝指在复制过程中,只复制一层变量,不会复制深成变量绑定的对象的复制过程 例如: >>> L = [3.1,3.2] >>> L1 = [1, 2, L] >>> L2 = L1.copy() >>> L1 [1, 2, [3.1, 3.2]] >>> L2 [1, 2, [3.1, 3.2]] >>> L2[2][0] = 3.14 >>> L1 [1, 2, [3.14, 3.2]] >>> L2 [1, 2, [3.14, 3.2]] 深拷贝 deep copy: import copy # 导入copy 模块 例如: L = [3.1, 3.2] L1 = [1, 2, L] L2 = L1.deep copy() L2[2][0] = 3.14 print(L1) #[1, 2, [3.1, 3.2]] print(L2) #1, 2, [3.14, 3.2]] 深拷贝通常只对可变对象进行复制 ,不可变对象通常不会复制(这里深拷贝需要 import copy中的deepcopy 后面讲) 小结: L1 = [1, 2, [3.1, 3.2]] 这里只是纯粹的调用关系 可以通过内存地址查看 L2 = L1 # 不拷贝 同时绑定一个对象 L3 = L1.copy() # 潜拷贝等同于 L3 = L1[:] import copy L4 = copy.deepcopy(L1) #深拷贝 列表推导式 list comprehension: 列表推导式是用可迭代对象生成列表的表达式语法: [表达式 for 变量 in 可迭代对象] 或 [表达式 for 变量 in 可迭代对象 if 真值表达式] 说明: for in 表达式的 if 子句可以省略,省略后将对所有生成的对象进行求值处理 如:生成1~9的平方的列表 L= [x ** 2 for x in range(1,10)]列表推到式的嵌套:语法:L=[表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 ] OK 今天的练习比较多 但是都很简单 争取把每个题都要理解他的原理 不懂得对照上面的参数进行核对一下就可以 想要入门IT就必须多写多练 写的代码也多 你就越熟练 越熟练经验越多 尝试不同的思路去分析 什么时候写的想吐 什么时候才算会了 我们一起加油 练习: 1. 已知有列表: L = [3, 5] 1) 用索引和切片等操作,将原列表改变为: L = [1, 2, 3, 4, 5, 6] 2) 将列表反转,删除最后一个元素后打印此列表 ... print(L) # [6, 5, 4, 3, 2] 答案: L = [3, 5] L[:] = range(1, 7) L[::-1] = range(1, 7)# L[:] = [range(6, 0, -1)] del L[-1] print(L) 2. 1. 写程序,让用户输入一些整数,当输入-1时结束输入,将这些数存于列表L中 1) 打印用户共输入了几个数? 2) 打印您输入的数的最大数是多少 3) 打印您输入的数的最小数是多少 4) 打印您输入的这些数的平均值是多少? 答案: L = [] while True: a = int(input("please input at will integer (input '-1' over):")) if a < 0: break L.append(a) L.sort() print("you input line number", len(L)) print("top1:", L[-1]) print("lower1:", L[0]) print(" average number :", sum(L) / len(L)) 3. 1.已知有一个字符串s = “100, 200, 300, 500, 800”将其转换为整数的列表存于L列表中 答案: s = "100,200,300,500,800" L = s.split(",") print(L) 2.生成前40个婓波那契数(fibonacci)1 1 2 3 5 8 13 .....要求将这些数字保存在列表中打印这些数 答案: L = [1, 1] a = 1 b = 1 while True: a += b b += a L += [a, b] if len(L) > 38: break print(L) 方法二 L = [1, 1] a = 1 b = 0 i = 0 while i < 40: a = a + b b = a - b L.append(b) i += 1 print(L) 4. L= [1, 3, 2, 1, 6, 4, 2, ......98, 82]将列表中出现的重复数字存入另一个列表L2中要求:重复出现多次的数字在L2中只保留一份 (去重) 答案: L = [] while True: a = int(input("please input at will integer (input '-1' over):")) if a < 0: break L.append(a) L2 = [] for x in L: if x not in L2: L2.append(x) print(L) print(L2) 5. 输入多行文字,存入列表中, 每次输入回车后算一行 任意输入多行,当输入回车(即输入空行时结束输入) 1) 按原输入内容在屏幕上输出内容 2) 打印出您共输入了多少行文字 3) 打印出您共输入了多少个字符 答案; L = [] i = 0 while True: a = input("please input at will string direct Enter over:") if a == "": break i += len(a) L.append(a) for x in L: print(x) print("您共输入的行数:", len(L)) print("您共输入的字符:", i) 6. 1. 有字符串"hello" 请用此字符串生成: 'h e l l o' 和 'h-e-l-l-o' 2. 写一个程序,让用户输入很多正整数,当输入小于零的数时结束输入, 1) 打印这些数中最大的一个数 2) 打印这些数中第二大的一个数 3) 删除最小的一个数 4) 打印剩余数的和 答案: s = "heool" L = " ".join(s) print(L) L = "-".join(s) print(L) 7. 用列表推导式生成1~100内奇数的列表 结果是: [1, 3, 5, 7, ..... 99] 答案: L = [x for x in range(1, 100, 2)] print(L) L = [x for x in range(1, 100) if x % 2 != 0] print(L) 8. 生成一个数值为 1 ~ 9的平方的列表,去掉所有的奇数的平方答案: L = [x**2 for x in range(2, 10, 2)] print(L) L = [x**2 for x in range(2, 10) if x % 2 == 0] print(L) Python人工智能从入门到精通 加油!

优秀的个人博客,低调大师

Python全栈工程师(文件操作、编码)

ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 Python人工智能从入门到精通 最近简直要死了 发烧感冒 喉咙痛。。。。、 如何长期保存计算机中数据: 需要文件操作 文件 file: 文件是用于数据存储的单位 文件通常用来长期储存数据 文件中的数据是以字节为单位进行顺序储存的文件的操作流程: 1.打开文件 2.读/写文件 3.关闭文件 注: 任何操作系统, 一个应用程序同时打开文件的数量有最大数限制文件打开函数: open(file, mode=‘rt’) 用于打开一个文件, 返回此文件流对象, 如果打开文件失败, 则会触发osError错误文件的关闭方法: F.colse() #关闭问津, 释放系统资源 示例: # 此示例示意文件的打开和关闭操作 try: f = open('./aaa.txt') # 不存在此文件 # f = open('./myfile.txt') # 不存在此文件 print("打开文件成功") # 此处要进行读/写操作 f.close() # 半闭文件 except OSError: print("文件打开失败") 文件方法: 文件 mode 模式字符的含义 字符 含义 'r' 以只读方式打开(默认) 'w' 以只写方式打开,删除原有文件内容(如果文件不存在,则创建该文件并以只写方式打开) 'x' 创建一个新文件, 并以写模式打开这个文件,如果文件存在则会产生"FileExistsError"错误 'a' 以只写文件打开一个文件,如果有原文件则追加到文件末尾 'b' 用二进制模式打开 't' 文本文件模式打开 (默认) '+' 为更新内容打开一个磁盘文件 (可读可写) 缺省模式是 'rt' 'w+b' 可以实现二进制随机读写,当打开文件时,文件内容将被清零 'r+b' 以二进制读和更新模式打开文件,打开文件时不会清空文件内容 'r+' 以文本模式读和更新模式打开文件,打开文件时不会清空文件内容 python 文件常用方法: 方法 说明 F.close() 关闭文件(关闭后文件不能再读写会发生ValueError错误) F.readline() 读取一行数据, 如果到达文件尾则返回空行 F.readlines(max_chars=-1) 返回每行字符串的列表,max_chars为最大字符(或字节)数 F.writelines(lines) 将字符串的列表或字符串的列表中的内容写入文件 二进制文件操作方法 F.read(size=-1) 从一个文件流中最多读取size个字符(文本文件)或字节(二进制文件),如果不给出参数,则默认读取文件中全部的内容并返回 F.write(text) 写一个字符串到文件流中,返回写入的字符数(文本文件)或字节数(二进制文件) F.tell() 返回当前文件流读写指针的绝对位置(字节为单位) F.seek(offset, whence=0) 改变数据流读写指针的位置,返回新的绝对位置 F.flush() 把写入文件对象的缓存内容写入到磁盘 F.readable() 判断这个文件是否可读,可读返回True,否则返回False F.writable() 判断这个文件是否可写,可写返回True,否则返回False F.seekable() 返回这个文件对象是否支持随机定位 F.truncate(pos = None) 剪掉 自pos位置之后的数据,返回新的文件长度 文本文件操作: 操作模式: ‘t’ 说明: 1.默认文件中储存的都为字节数据, 在读写过程中会自动进行编解码操作 2.文本文件以行位单位进行分割, 在python内部统一用"\n"做为换行符进行分割 3.对文本文件的读写操作需要用字符串(str)进行数据操作 Linux换行符: '\n' Windows 换行符: '\r\n' 新的Mac OS 换行符: '\n' 旧的Macintosh换行符: '\r'(已不用了) 文件流对象是可迭代对象, 迭代过程中将换行符“\n”作为分隔符 f = open('phonenumber.txt') for line in f: print(line) # 打印每一行的数据 标准输入输出文件: sys.stdin 标准输入文件 Ctrl + D 输入文件结束符 sys.stdout 标准输出文件 sys.stderr 标准错误输出文件 标准文件绝对不能关闭 Linux系统内所有的硬件都会映射成文件 关闭文件会导致错误模块:sys 注: 标准文件不需要打开和关闭就可以使用 示例: import sys sys.stdout.write("我是标准输出\n") sys.stderr.write("我是一个错误\n") import sys s = sys.stdin.read() print("s=", s) print("程序结束") 二进制文件操作: 二进制文件操作模式字符:‘b’ 默认文件中存储的是以字节数据为单位, 通常有人为规定的格式 二进制文件操作需要用字节串进行读写 F.read()/F.readline() F.readlines()返回类型 对于文本操作 F.write() 对于二进制文件也需要用字节串进行操作 F.tell: 作用: 返回当前的读写位置(从文件头以字节为单位) F.seek方法: F.seek(偏移量,whence=相对位置) 偏移量 大于0的数代表向文件尾方向移动的字节数 小于0的数代表向文件头方向移动的字节数 相对位置 0代表从文件头开始偏移 1代表从文件当前位置开始偏移 2代表从文件尾开始偏移 (第一个参数必须是负的) 示例: # 此示例示意用seek改变文件的读写位置,用tell来得到读写位置 f = open('myseek.txt', 'rb') b = f.read(2) # b'AB' 读取出来 print(b) # b'AB # 从头开始向后走5个字节 # f.seek(5, 0) # 从当前位置向后走3个字节 # f.seek(3, 1) # 从文件尾向前数15个字节 f.seek(-15, 2) b = f.read(5) print(b) # b'abcde' f.close() 汉字编码(只讲两种) 国标系列: GB18030(二字节或四字节编码27553个字) GBk(二字节编码21003个字) GB2312(二字节编码6763个字) (Windows 常用) 国际标准: Unicode <---> UTF-8 (Ascii 占1字节 汉字占3字节) (Linux Mac OS X / IOS /Android) python编码字符串: ‘gb18030’ ‘gb2312’ ‘gbk’ ‘utf-8’ ‘ascii’ ....以上字符串用于encide和decode中编码注释: 在Python源文件中的第一行或第二行写入如下内容: # -*- codeing:gbk -*- #设置源文件编码格式为gbk 或 # -*- codeing:utf-8 -*- #设置源文件编码格式为utf-8 作用: 告诉解释执行器此文件的编码是什么 练习: 自己写一个文件 'info.txt' 内部存一些文字信息 如: 张三 20 100 李四 21 96 小王 22 98 写程序将这些数据读取出来,打印到终端上 答案: try: f = open("myfile.txt") L = f.readlines() for x in L: s = x.strip() n, a, s = s.split() print("姓名:", n, "年龄:", int(a), "成绩:", int(s)) except: print("打开文件是失败") 练习: 1. 写程序,循环输入很多个人的姓名,电话号码, 当输入结束后将这些信息存入到文件phonenumber.txt中 (建议先用列表暂存数据,格式自己定义) 2. 写程序,将phonenumber.txt文件中的数据读取出来. 再用以下格式打印出来: 如: 小张 的电话是 13888888888 小李 的电话是 13999999999 练习: 1. 写程序实现复制文件的功能 要求: 1. 要考虑特大文件问题 2. 要关闭文件 3. 要能复制二进制文件 如: 请输入源文件路径名: /home/tarena/xxx.tar.gz 请输入目标文件路径名: ./a.tar.gz 显示: 文件已成功复制 答案: def copy_myfile(): try: ypath = input("please inout raw path:") xpath = input("please inout new path:") f1 = open(xpath, "w+b") f = open(ypath, "r+b") for x in f: f1.write(x) f1.close() f.close() print("File copied") except: print("file not inexeistence") copy_myfile() 2. 修改学生信息管理程序,要求加入两个功能: 9) 保存信息到文件(si.txt) L = [{"name": "Tom", "age": 20, "score": 98}, {"name": "Lin", "age": 21, "score": 99}, {"name": "Garin", "age": 19, "score": 100}] def student_file(L): try: f = open("./si.txt", "x") for x in L: f.write(x["name"]) f.write(" ") f.write(str(x["age"])) f.write(" ") f.write(str(x["score"])) f.write("\n") except FileExistsError: f = open("./si.txt", "a") for x in L: f.write(x["name"]) f.write(" ") f.write(str(x["age"])) f.write(" ") f.write(str(x["score"])) f.write("\n") student_file(L) 10) 从文件中读取数据(si.tx def open_student_file(): f = open("./si.txt") L = [] for line in f.readlines(): s = line.strip() n, a, s = s.split() # 拆成列表 student = {"name": n, "age": a, "score": s} L.append(student) f.close() return L 源码: https://pan.baidu.com/s/1vVuH7OwNdn8vqaBKAivniQ异常还没处理...........

优秀的个人博客,低调大师

Python全栈工程师(每周总结:2)

ParisGabriel 感谢 大家的支持 每天坚持 一天一篇 点个订阅吧灰常感谢 当个死粉也阔以 week summer: Python人工智能从入门到精通 字符串 str # 不可变序列,只能存字符 列表 list # 可变的序列,可以存任意数据 元组 tuple # 不可变序列,可以存任意数据 字典dict # 可变无序,可以存任意数据 集合set #可变无序,只能存不可变数据 (可变就是id不变的情况下改变数据) 序列相关函数: len(x), max(x), min(x), sum(x), any(x), all(x) 序列有5种: star 字符串 list 列表 tuple 元组 bytes bytearray 列表 list: L = [ ] L = list() 创建函数 括号内放可迭代对象、可以空 L [ ] 括号内放下标 L [:: ] 第一个参数开始位置,第二个结束、第三个步长(步长决定方向) 列表推导式: [表达式 for 变量 in 可迭代对象](可以嵌套) del L[ ] 删除指定下表索引 列表可以索引下标 、切片 可以增、删、改、查 可以索引赋值、切片赋值(不是顺序切片时赋值一定要个数相等) 潜拷贝 浅拷贝是指在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程 深拷贝 深拷贝通常只对可变对象进行复制,不可变对象通常不会复制 元组 type t = (1, ) 低于连个元素必须用, 号 t = type(x) 同列表一样 元组可以索引和切片和列表一样 但是但是不能赋值 T.index(v[, begin[, end]]) 返回对应元素的索引下标 T.count(x) 返回元组中对应的元素个数字典 dict: d = { } d = {“a”:1} 键值对形式存在 d[ ] 括号里放键 ,字典索引只索引键(key)索引赋值 : 只能修改值 ,存在修改 否者添加 dict() 生成一个字的字典 等同于 {} dict(iterable) 用可迭代对象初始化一个字典 dict(**kwargs) 用关键字传参形式创建一个字典 字典的键(key) 必须为不可变类型 且不能重复不可变类型:bool, int, float, complex, str, tuple, frozenset, bytes(后面再讲) in 在什么什么里面 not in 不在什么什么里面(判断键存在:只判断键) is 是 is not 不是 所有可迭代对象都可以用for 遍历 (字典只访问键)字典推导式 : d = {x : x ** 2 for x in range(10)} {键表达式 : 值表达式 for 变量 in 可迭代对象 if 真值表达式}(可嵌套) 字典 VS 列表 1. 都是可变对象 2. 索引方式不同,列表用整数索引,字典用键索引 3. 字典的插入,删除,修改数据的速度可能会快于列表(重要) 4. 列表的存储是有序的,字典的存储是无序的可变的数据类型有四种: list 列表、dict 字典 set 集合、bytearray 字节数组集合 set: s = set( ) s = set( ) 构造函数 数据不可重复 相当于只有键的字典 集合运算: & 生成两个集合的交集 | 生成两个集合的并集 - 生成两个集合的补集 ^ 生成两个集合的对称补集 > 判断一个集合是另一个集合的超集 < 判断一个集合是另一个集合的子集 (包含关系) == != 集合相同/不同 (与顺序无关)集合推导式:{表达式 for 变量 in 可迭代对象 [if 真值表达式]}(可嵌套)固定集合 frozenset: 固定集合是不可变的,无序的, 含有唯一元素的集合 (可以做字典键也可以做集合的值) frozenset() f = frozenset() 括号内放可迭代对象 相当于集合的全部方法(包括运算符)去掉修改集合的方法 常用字符串方法方法 说明S.isdigit() 判断字符串中的字符是否全为数字S.isalpha() 判断字符串是否全为英文字母S.islower() 判断字符串所有字符是否全为小写英文字母S.isupper() 判断字符串所有字符是否全为大写英文字母S.isspace() 判断字符串是否全为空白字符S.center(width[,fill]) 将原字符串居中,左右默认填充空格 width:所居中字符串的长度 fill:默认填充空格S.count(sub[, start[,end]]) 获取一个字符串中子串的个数 sub:所要获取的字符串 start:起始位置 end:结束位置S.find(sub[, start[,end]]) 获取字符串中子串sub的索引,失败返回-1 start:起始位置 end:结束位置S.strip() 返回去掉左右空白字符的字符串S.lstrip() 返回去掉左侧空白字符的字符串S.rstrip() 返回去掉右侧空白字符的字符串S.upper() 生成将英文转换为大写的字符串S.lower() 生成将英文转换为小写的字符串S.replace(old, new[, count]) 将原字符串的old用new代替,生成一个新的字符串 count:更换的次数S.startswith(prefix[, start[, end]]) 返回S是否是以prefix开头,如果以prefix开头返回True,否则返回False,S.endswith(suffix[, start[, end]]) 返回S是否是以suffix结尾,如果以suffix结尾返回True,否则返回False以下是不常用的 S.title() 生成每个英文单词的首字母大写字符串S.isnumeric() 判断字符串是否全为数字字符文本解析: S.split(sep=None) 拆分字符串 sep是拆分符号 S.join(iterable) S是分隔字符串 扩号内跟可迭代对象 列表的方法 :L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引,end为结束索引,当 value 不存在时触发ValueError错误L.insert(index, obj) 将某个元素插放到列表中指定的位置L.count(x) 返回列表中元素的个数L.remove(x) 从列表中删除第一次出现在列表中的值L.copy() 复制此列表(只复制一层,不会复制深层对象)L.append(x) 向列表中追加单个元素L.extend(lst) 向列表追加另一个列表L.clear() 清空列表,等同于 L[:] = []L.sort(reverse=False) 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列L.reverse() 列表的反转,用来改变原列表的先后顺序L.pop([index]) 删除索引对应的元素,如果不加索引,默认删除最后元素,同时返回删除元素的引用关系 字典的方法 D代表字典对象 D.clear() 清空字典D.pop(key) 移除键,同时返回此键所对应的值D.copy() 返回字典D的副本,只复制一层(浅拷贝)D.update(D2) 将字典 D2 合并到D中,如果键相同,则此键的值取D2的值作为新值D.get(key, default) 返回键key所对应的值,如果没有此键,则返回defaultD.keys() 返回可迭代的 dict_keys 集合对象D.values() 返回可迭代的 dict_values 值对象D.items() 返回可迭代的 dict_items 对象 Python3 集合的方法: 方法 意义S.add(e) 在集合中添加一个新的元素e;如果元素已经存在,则不添加S.remove(e) 从集合中删除一个元素,如果元素不存在于集合中,则会产生一个KeyError错误S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;S.clear() 清空集合内的所有元素S.copy() 将集合进行一次浅拷贝S.pop() 从集合S中删除一个随机元素;如果此集合为空,则引发KeyError异常S.update(s2) 用 S与s2得到的全集更新变量SS.difference(s2) 用S - s2 运算,返回存在于在S中,但不在s2中的所有元素的集合S.difference_update(s2) 等同于 S = S - s2S.intersection(s2) 等同于 S & s2S.intersection_update(s2) 等同于S = S & s2S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回FalseS.issubset(s2) 如果S与s2交集为非空返回True,空则返回FalseS.issuperset(...) 如果S为s2的子集返回True,否则返回FalseS.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 SS.union(s2) 生成 S 与 s2的全集 Python运算符优先级 运算符 描述(), [], {key: value}, {} 元组表达式、列表表达式、字典表达式、集合表达式x[index], x[index:index],x(arguments...), x.attribute 索引,切片,函数调用,属性引用** 指数 (最高优先级)~, +, - 按位翻转, 正号,负号*, /, %, // 乘,除,取模和地板除+, - 加法, 减法>>, << 右移, 左移运算符& 位与(AND)^ 位异或(XOR)| 位或(OR)<=, <, >, >=, ==, !=,is, is not, in, not in 比较,身份测试,成员资格测试not 布尔非and 布尔与or 布尔或if - else 条件表达式lambda lambda表达式 数据类型: 数值类型: int, float, complex, bool容器: 不可变的容器 str, tuple, frozenset, bytes(字节串) 可变的容器 list, dict, set, bytearray(字节数组)值: None, False, True 运算符 算术运算符 + - * / // % ** 比较运算符: < <= > >= == != in / not in is, is not 布尔运算: not, and, or +(正号) -(负号) & | ^ [] (索引,切片,键索引) 表达式: 1 1 + 2 max(1,2,3) # 函数调用是表达式 x if x > y else y, 条件表达式 三种推导式: 列表,字典,集合推导式(三种) 语句: 表达式语句: 所有的表达式都可以单独写在一行,形成一个语句,例: print("hello world") 1 + 2 赋值语句: a = 100 a = b = c = 100 x, y = 100, 200 a[0] = 100 dict['name'] = 'tarena' del 语句 if 语句 while 语句 for 语句 break 语句 continue语句 pass 语句 内建函数: len(x), max(x), min(x), sum(x), any(x), all(x)构造函数(用来创建同类型的数据对象) bool(x), int(x), float(x), complex(x), list(x), tuple(x), str(x), dict(x), set(x), frozenset(x) abs(x) round(x) pow(x, y, z=None) bin(x), oct(x), hex(x) chr(x), ord(x) range(start, stop, step) input(x), print(x) >>> help(__builtins__) 函数: 就是把语句块封装起来 形成一个语句块 利用函数变量直接调用语句块的方式 用户自定义级别的函数是为了提高代码的可用性 重用性 以及逻辑清晰 维护方便 (def 函数名(形参列表):冒号) 形参列表可以为空 函数是一个空间,空间内变量不重复就不会冲突 函数调用: 函数名(实参) return语句 用于返回非None对象语句 函数的参数传递: 传参方式:(2种) 位置传参(包含关系 ) 序列传参 关键字传参(包含关系) 字典关键字传参位置传参: 实参与形参的位置要对应序列传参: 用 * 将序列拆解 然后位置传参关键字传参 将字典用“**”拆解后 实参和形参必须按形参名复制 拆解后键名要在形参中存在必须一致 键名必须是字符串且标识符综合传参: 在能确定形参能唯一匹配到相应实参的情况下 所有传参方式可以任意组合 位置传参(序列传参)一定要在关键字传参(字典关键字传参)的左侧函数的缺省参数: 缺省参数必须从右至左依次存在的命名关键字形参: 语法: def 函数名(*, 命名关键字形参): 语句块 或 ef 函数名(*args, 命名关键字形参): 语句块 (关键字形参 必须用关键字传参) 作用: 收集多余关键字传参双星号字典传参: 语法: def 函数名(**字典形参名): 语句块 作用: 强制所有的参数都参数都必须用关键字传参或字典关键字传参函数的参数说明: 位置形参、星号元组形参、命名关键字形参、双星号字典形参可以混合使用函数自左到右的顺序为: 1.位置形参 2.星号元组形参 3.命名关键字形参 4.双星号字典形参 全局变量:global variable: 函数外,模块内的变量 全局变量所有函数都可以直接访问局部变量:local variable: 函数内的变量 调用时才被创建,在函数调用之后销毁传参的排序规则: 从左到右 1.位置形参 2.星号元组形参 3.命名关键字形参 4.双星号字典形参 函数: globals()/locals() globals()返回当前全局作用域内变量的字典 locals() 返回当前局部作用域内变量的字典 函数名是变量 创建时绑定函数 函数的变量名可以序列交换算法 函数可以作为另一个函数的实参 函数可以作为另一个函数返回值 函数可以嵌套python的4个作用域: 作用域: 英文解释 缩写 局部作用域(函数内) Local(function) L 外部嵌套函数作用域 Enclosing functio loc E 函数定义所在模块(文件)作用域 Global(module) G python内建模块作用域 Builtin(python) B 包含关系(内建>模块>外部嵌套函数>函数内)变量名查找规则: 访问变量时,先查找本地变量,然后是包裹此函数外的函数内部的变量 ,之后是全局变量,最后是内建变量 L ---> E ---> G ---> B 在默认情况下,变量名赋值会创建或者改变当前作用域的变量global语句: 声明一个全局变量nonlocal语句: 外部嵌套函数变量 调用不可修改外部嵌套函数作用域内的变量进行操作lambda表达式: 创建一个匿名函数对象 lambda[ 参数1, 参数...]: 表达式 函数: eval () / exec() 函数 eval(srouce,globals=None, locals=None) 把一个字符串srouce 当成一个表达式来执行,返回表达式结果 eval(source, globals=None, local=None) 把一个字符串 srouce 当成一个表达式来执行,返回表达式执行的结果 exec(source, globals=None, locals=None) 把一个字符串source 当成程序来执行 全部划重点 加粗 加长 加大 溜了 不吹NB了....

优秀的个人博客,低调大师

Python全栈工程师(每周总结:1)

ParisGabriel python今年9月份将被国家纳入计算机二级资格证 先学就是鼻祖 几年后你就是大牛 Python人工智能从入门到精通 week summer: 数字(整型int,浮点数float,复数complex,布尔型bool)字符串str 列表list 等bool(true=1、false=0)None 空值算数运算符:+ - * / // ** % 优先级:(), [], {key: value}, {} 元组表达式、列表表达式、字典表达式、集合表达式x[index], x[index:index],x(arguments...), x.attribute 索引,切片,函数调用,属性引用** 指数 (最高优先级)~, +, - 按位翻转, 正号,负号*, /, %, // 乘,除,取模和地板除+, - 加法, 减法>>, << 右移, 左移运算符& 位与(AND)^ 位异或(XOR)| 位或(OR)<=, <, >, >=, ==, !=, is, is not, in, not in 比较,身份测试,成员资格测试not 布尔非and 布尔与or 布尔或if - else 条件表达式lambda lambda 表达式变量命名:必须以字母或下划线开头(驼峰法则)序列赋值:a,b,c = 100, 200, 300变量交换:a,b = 200,100del 删除变量help(“__main__”) 查看变量 Q退出内存自动管理方式:引用计数is/is not 判断是否为同一个对象id(obj)函数: 返回对象在内纯中的id小整数对象值:-5 ~ 256比较运算符:< <= > >= == != 数值对象的构造函数:float(obj) 字符串转换浮点数 int 转换整数complex(r,i) 创建复数bool(true/false) 创建布尔值bool(obj) 所有0或 空值都会返回falseabs(x) 取x绝对值round(number,ndigits) 四舍五入 ndigits小数点个数(可以是负数:反向取整)help(函数对象) 函数或查看详细帮助“\” 折行符() [ ] {} 隐式折行符 sep 两个值之间的分隔符默认空格print(sep = “”,end = “”){ end行位默认换行符not 布尔非or 布尔或 { 短路运算and 布尔与+ 表达式只有一个数据参加(一元运算符)- 表达式 如:a = 5 ,b = -a ,c = +a转移符:\' 单引号\" 双引号\\ 单反斜杠\n 换行\r 返回光标至行首\t 水平制表符\v 垂直制表符\f 换页\b 倒退\0 空字符,字符值为0\xXX XX为两位16进制表示的自符\uXXXX XXXX为4个16进制的Unicode16字符\UXXXXXXXX 8个16进制表示的Unicode32字符man ASCII 查看帮助文档命令常用ASCII编码:字符 十进制 十六进制 0 48 0x30 A 65 0x41 a 97 0x61len() 返回字符串的个数raw 让转义符无效(原始字符)(r“hello world”)+= *= 与其他符合运算符相同in/not in 判断字符串是存在字符串的比较运算:> >= < <= == != 依次按照编码进行比较,直到最短字符串结束为止s[int] 索引 index Python的字符串是不可以改变字符序列的Python序列都可以用索引来访问序列中的对象Python的序列正向索引是从0开始的最后一个索引为len(s)-1Python序列的反向索引是从-1开始的 -1是最后一个 第一个是 -len(s)切片 slice :s[(开始索引b):(结束索引e):(步长s)] 步长等于偏移量默认1 索引从0开始 顾头不顾尾 步长为负时反向切片(步长决定方向)python3 中常用函数;len (s) 返回序列长度max(s) 返回序列最大值元素min(s) 返回序列最小值元素ord(a) 返回一个字符的Unicode值(10进制)chr(i) 返回一个整数的Unicode字符bin(i) 将整数转换为二进制字符串oct(i) 将整数转换为八进制字符串hex(i) 将整数转换为十六进制字符串常用的字符串方法:文档参见:对象.方法名(方法传参)"abc".isalpha() # 语法是对的123.isalpha() # 语法是错的方法 说明S.isdigit() 判断字符串中的字符是否全为数字S.isalpha() 判断字符串是否全为英文字母S.islower() 判断字符串所有字符是否全为小写英文字母S.isupper() 判断字符串所有字符是否全为大写英文字母S.isspace() 判断字符串是否全为空白字符S.center(width[,fill]) 将原字符串居中,左右默认填充空格 width:所居中字符串的长度 fill:默认填充空格S.count(sub[, start[,end]]) 获取一个字符串中子串的个数 sub:所要获取的字符串 start:起始位置 end:结束位置S.find(sub[, start[,end]]) 获取字符串中子串sub的索引,失败返回-1start:起始位置 end:结束位置S.strip() 返回去掉左右空白字符的字符串S.lstrip() 返回去掉左侧空白字符的字符串S.rstrip() 返回去掉右侧空白字符的字符串S.upper() 生成将英文转换为大写的字符串S.lower() 生成将英文转换为小写的字符串S.replace(old, new[, count]) 将原字符串的old用new代替,生成一个新的字符串 count:更换的次数S.startswith(prefix[, start[, end]]) 返回S是否是以prefix开头,如果以prefix开头返回True,否则返回False,S.endswith(suffix[, start[, end]]) 返回S是否是以suffix结尾,如果以suffix结尾返回True,否则返回False以下是不常用的 S.title() 生成每个英文单词的首字母大写字符串S.isnumeric() 判断字符串是否全为数字字符ASCII 用8个位表示 最高位一定是0Unicode用16位表示 最高位也一定是0占位符和其的类型码:%s 字符串 使用shr(obj)转为字符串%r 字符串 使用repr(obj)转为字符串%c 整数转为字符串,使用chr(i)函数%d 10进制整数%o 8进制整数%x 16进制整数(字符a-f)%X 16进制整数(字符A-F)%e 浮点数(e)如 2.9e+10%E 浮点数(E)如2.9E+10%f %F 浮点数10进制形式%g %G 进制进形式浮点数或指浮点数自动转换%% 等同于一个 % 字符 占位符与类型码之间的格式语法:%[- + 0 宽度.精度]类型码- 左对齐+ 右对齐0 左右空白位置补0宽度:整个数据输出的宽度精度:保留小数点后多少位,默认6位可迭代对象包括:字符串 str 列表 list元组 tuple字典 dictrange()函数: 可迭代对象创建 也叫整数序列生成器 (顾头不顾尾)列表 list:(列表的id是不可变的 除非重新定义)列表是一种容器(通常用来储存计算机的数据对象)列表是可以被改变的序列是由一系列特定元素组成的 元素与元素之间可能没有任何关联关系但他们有先后顺序关系列表的运算:+ 用于拼接列表+= 用于将右侧的可迭代对象的数据追加到原列表中* 用于生成重复列表*= L * = 2 (L = L * 2)列表的比较运算:< <= > >= == !=比较规则和字符串完全相同列表的in、notin:判断一个元素是否存在于列表中 如果纯在返true否则falsein 和 nat in 返回值相反(只能判断列表元素 不能判断元素内字符) week summerkey word: print: print(“hello world”) 输出打印语句 input: input(“plaese input :”) 输入函数 提示可以为空 if : if 1 >2 : print("1>2") elif 1>3: print("1>3") else: print("1<2") if:如果 else:否则 elif:否者如果 (单if不加else:如果真) while: i = 0 while i < 5: print(i) i += 1 else: print("6") i:循环变量 while可以加或不加else 条件不成时立执行else若条件成立 循环结束后将继续执行else for: for x in ramge(10): print(x) else: print(11) x:循环取出可迭代对象的值 for可以加或不加else 条件不成时立执行else若条件成立 循环结束后将继续执行else 死循环: while True; a = int(input()) print("123") if a = “” break 死循环: 无限循环 配合break跳出循环死循环不能加else break 终止循环一般配合if语句使用 终止循环 若循环套用是只会在本循环作用域有效不影响外部循环 若break跳出循环 else将不再执行continue 跳过本次循环一般配合if语句使用 跳过本次循环 若循环套用是只会在本循环作用域有效不影响外部循环 continue 用法需注意 细节不当将形成死循环复合语句的嵌套: for x in range(10) for y in range(5) print(x , y) if x == 10: break else: for x in range(50) print(x) i = 0 while i < 10: peint(i) x = 0 while x < 10: print(x) if i == 10: break else: while i <10: print(i * i) if a > 5: if a < 10: peint(a) else: if a > 0 : print(a) else: print(a) if while for 可以任意嵌套配合使用

优秀的个人博客,低调大师

Python全栈工程师(while、占位符)

ParisGabriel Python 入门基础 UnicodeASCII 用8个位表示文字 ,最高位一定是零,低七位表示数值Unicode是由16个位组成的(65535) 最高位也是0x0000~0xfffhelp(str) 查看所有str函数 字符串的格式化表达式:生成一定格式的字符串格式字符串中以 % 开头的为占位符,占位符的位置将参数值替换语法:格式字符串 % 参数值格式字符串 % (参数值1,参数值2,...)占位符和其的类型码:%s 字符串 使用shr(obj)转为字符串%r 字符串 使用repr(obj)转为字符串%c 整数转为字符串,使用chr(i)函数%d 10进制整数%o 8进制整数%x 16进制整数(字符a-f)%X 16进制整数(字符A-F)%e 浮点数(e)如 2.9e+10%E 浮点数(E)如2.9E+10%f %F 浮点数10进制形式%g %G 进制进形式浮点数或指浮点数自动转换%% 等同于一个 % 字符 占位符与类型码之间的格式语法:%[- + 0 宽度.精度]类型码- 左对齐+ 右对齐0 左右空白位置补0 宽度:整个数据输出的宽度精度:保留小数点后多少位,默认6位"%10d" %123 #" 123""%+10d"%123 #" +123""%-10d"%123 #"123 ""%10s"%"abc" #" abc""%010d"%123 #"0000000123" "%f"%3.14159625358 # "3.141593""%7.2f"%3.14159265358#" 3.14" 循环语句:while:根据一定的条件,重复执行一些相同或相似的内容先判断真值表达式是否成立在执行执行完内容继续返回真值表达式判断是否成立 直到真值表达式为false时 判断是否有else有则执行else的内容没有则循环结束注意事项:要控制真值表达式的值来防止死循环通常用真值表达式内的循环变量来控制真值表达式的值通常在循环语句块内改变循环变量来控制循环次数和变量走向while的嵌套:while语句和其他语句一样,可以嵌套放入任何复合语句当中break:用于循环语句(while、for)中用来终止当前循环(跳出循环)当break语句执行后此循环以后的语句将不再执行break终止循环时 else语句块将不再执行break语句通常和if组合使用break只能终止当前作用域 如循环嵌套时,不会跳出外循环break只能在循环语句(while、for)内使用死循环:死循环是指循环条件一直成立的循环死循环通常用break语句来终止循环死循环的else语句块永远不会执行 练习:1.输入一行字符串,将字符串中Unicode编码值最大的一个字符打印出来(不允许用max函数)提示:while内可以嵌套if 答案: print("Answer to question 1:", "\n") s = input("plaese input at will string:") i = 0 top = s[0] while i < len(s): if ord(top) < ord(s[i]): top = s[i] i += 1 print("you input string in top1:", top, ord(top)) 2.打印 从零开始的浮点数,每个数增加0.5,打印出10以内的这样的数:0.00.51.00.52.0...10 答案: print("Answer to question 2:", "\n") i = 0 while i < 10: i += 0.5 print(i) 3.打印输出1~20在同一行内 结束后换行 答案: s = 0 while s < 20: s += 1 print(s, end = " ") else: print() 4.打印输出1~20在同一行内 打印10行 i = 0 while i < 10: s = 0 while s < 20: s += 1 print(s, end = " ") else: print() i += 1 5.当输入一些数字,输入负数时结束输入当完成输入完后,打印输入的数时多少 答案: s = 0 while True: a = int(input("plaese input at will integer:")) s += a if a < 0: break print(s) 6.Sn = 1/2+1/4+1/8....+1/(2**n)求当n等同于100时Sn的值是多少 答案: Sn = 1 i = 0 while i < 100: i += 1 Sn += 1 / 2 ** i print(Sn) 7.输入一个整数打印出矩形 若输入1则输出1个# 例如: 输入1:# 输入2:#### 输入6:####### ## ## ## ## ####### 答案: s = int(input("plaese input at will integer:")) if s > 1: print("#" * s) i = 2 while i < s: i += 1 print("#" + " " * (s - 2) + "#") print("#" * s) else: print("#") 8.用while语句实现打印三角形,输入一个整数表示三角形的宽度和高度,打印出相应的三角形如:1)**********2)******* ** *3) * *********4)********** 答案: a = int(input("plaese input at will ingeger:")) i = 0 b = a c = a d = a while i < a: i += 1 print("*" * i) print() i = 0 while i < d: print((a - d) * " " + "*" * d) d -= 1 print() i = 0 while i < c: i += 1 print((c - i) * " " + "*" * i) print() i = 0 while i < b: print("*" * b) b -= 1 a = int(input("plaese input at will ingeger:")) i = 0 d = a while i < a: while i < d: print((a - d) * " " + "*" * d) d -= 1 print("*" * (i + 1)) i += 1 print()

优秀的个人博客,低调大师

Python全栈工程师(运算符、if)

ParisGabriel Python 入门基础 比较运算符:< 小于<= 小于等于> 大于>= 大于等于== 等于!= 不等于 语法: 表达式1>表达式2 返回布尔类型 数值对象的构造函数: float(obj) 用字符串或数字转换为浮点数,如果不给出实参,则返回0.0 int(x=0,base=10) 用数字或者字符串转换为整数,如果不给出实参,则返回0.0 bas表示是进制 complex(r=0.0,i=0.0) 用数字创建一个复数 bool(x) 用x创建一个布尔值(true/false) bool(obj)返回假值的情况:None 空值false 假值00.00j所有的数字零‘’ 空字符串[ ] 空列表{ }空词典() 空原组... 函数调用表达式:函数名(传参列表)说明:函数调用表达式时,此表达式一定是会返回一个对象的引用关系如果不需要返回值时,通常返回none对象的引用关系 内建数值型函数:abs(x) 取x的绝对值 round(number,ndigits=0) 对数值进行四舍五入 ,ndigits是小数向右取整的位数,负数表示像左取整 pow(x,y,z=none) 相当于x**y或x**y%z help()查看帮助 help(函数或对象名) help(int) 语句: 语句是由一些表达式组成,通常一条一句可以独立执行来完成一部分事情并形成结果Python建议一条语句写在一行内多条一句子写在一行内需要用“;”分开 print("hello") x = 100 + 200 print(x) print("hello"); x = 100 + 200; print(x) 显示换行:折行符“\”折行符必须一行的末尾,来告诉解释执行器下一行也是本行的语句 隐式折行符:所有的括号的内容换行,成为隐式折行符()、{}、[] 函数的使用:基本输入函数input从标准输入设备上读取一个字符串(末尾的换行符会被删除)返回输入的字符串(仅Python3) 提示字符可以为空 基本输出函数:print将一系列的值一字符串的形式输出到标准输出设备上,默认为终端选项的关键字参数:sep:两个值之间的分隔符,默认为一个空格end:输出完毕后在末尾自动加一个字符串,默认为换行符(\n) 练习:1.输入两个整数,分别用变量x,y绑定1)打印输出计算这两个数的和2)打印输出计算这两个数的积3)打印输出计x的y次方 答案: x = int(input("plwase input integer:")) y = int(input("plwase input integer:")) print(x + y, "\n", x * y, "\n", x ** y) 2.今天是小明的20岁生日,假设每年都有365天,计算他过了多少个星期天,剩余多少天 答案: print((20 * 365) // 7, "星期天 剩余", (20 * 365) % 7, "天") 3.本别输入当前时间的时、分、秒 在终端打印输出当前距离0:0:0过了多少少天 答案: h = int(input("plwase input hour:")) m = int(input("plwase input minute:")) s = int(input("plwase input second:")) print(h * 3600 + m * 60 + s, "second") if语句: 让程序根据条件选着性的执行某条语句或某些语句 语法: a = int(input("plaese input integer:")) if a > 0: print(a, ">0") elif a > 6: print(a, ">6") elif a > 100: print(a, ">100") else: print(a, "<0") elif可以有0个或多个else可以有零个或1个 并且所有语句当中只能执行一个 if的嵌套:if语句本身是由多条子句组成的一条复合语句if语句可以作为语句嵌套到另一个语句内部 条件表达式:表达式1 if 真值表达式 else 表达式2根据真值表达式的取值(true、false)来决定执行表达式1或2,并返回结果 money = int(input("100")) pay = money - 20 if money >= 100 else money pass语句:通常用来填充语法空白又名空语句 布尔运算符:not and or布尔非 not如果为true返回false否则为反布尔或 or优先返回真值见true得true 布尔与 and优先返回假值对象见false得false 正负号运算符:+ 表达式- 表达式这是一个一元运算符(只有一个数据参加运算) 练习:1.北京出租车价格 3公里以内13元基本单价:2.3元/公里(超出3公里以外)回空费:超过15公里 每公里 加收单价的50%的会空费(3.45元/公里)输入公里数 打印费用金额 答案: kilometre = int(input("plaese input kilometre:")) if kilometre < 0: if kilometre > 15: money = (kilometre - 15) * 3.45 + (15 - 3) + 13 print("money:", money, "$") elif 3 < kilometre < 15: money = (kilometre - 3) * 2.3 + 13 print("money:", money, "$") else: print("money:13$") else: print("not'is kilonetre") 2.输入一个学生的三科成绩(3个整数:打印出最高分、最低分、平局分是多少 答案: a = int(input("plaese input english mark:")) b = int(input("plaese input language mark:")) c = int(input("plaese input mathematisc mark:")) if 100 > a > 0 and 100 > b > 0 and 100 > c > 0: if a > b and a > c: print("top score english:", a) elif b > c and b > a: print("top score language:", b) elif c > a and c > b: print("top score mathematisc:", c) if a < b and a < c: print("lowest english:", a) elif b < c and b < a: print("lowest language:", b) elif c < a and c < b: print("lowest mathematisc:", c) print("mean:", (a + b + c)/3) else: print("not'is mark") 3.bmi指数(body、mass、index)以称身体质量指数bmi的计算公式: bmi = 体重(公斤)/身高的平方标准表: bmi< 18.5 体重过轻18.5<=bmi<24 体重正常bmi> 24 体重过重输入公斤体重、身高 打印出 bmi的值 并打印体重状况 答案: z = int(input("plaese input your weigh:")) g = float(input("plaese input your height:")) if z < 0 and g < 0: bim = (z / g) ** 2 if bim < 18.5: print("your bim qing") elif 24 > bim > 18.5: print("your bim normal") else: print("your bim serious") else: print("your inuput error")

优秀的个人博客,低调大师

Python全栈工程师(Linux基本操作)

ParisGabriel Python 入门基础 Linux :Ubuntu操作系统 首先我们说的是Linux操作系统常用的快捷键以及终端命令 一. VMware Workstation 虚拟机 快捷键: Ctrl+Alt+Ent 调节虚拟机内操作系统的全屏以及窗口 Ctrl+Alt 释放虚拟机占用鼠标 二. 终端命令: 命令格式:命令名+选项+参数 1.打开终端: 手动找到终端打开 Alt+F2 打开搜索窗口输入:gnome-terminal Ctrl+Alt+T 打开终端(推荐) 2.终端窗口快捷键 Ctrl+Shift+“+” 放大终端 Ctrl+“-” 缩小终端 Ctrl+L 清屏 Ctrl+d (exit) 退出 关闭 Ctrl+C 终止当前命令的执行 Ctrl+S 隐藏终端输出 Ctrl+Q 恢复终端输出 3.终端命令行 “.” 代表当前目录 “..” 代表上一级目录 “~” 代表用户主目录 “/” 代表根 (最高目录) Windows有 C: D: F: 盘符之分 Linux系统不分盘 / 就是最高盘 最高根目录 相当于Windows的计算机 是以目录树形式的储存 Linux系统划分用户 开机时如果有多个目录可以选择账户 其实这个账户和Windows的分盘也差不多 。 tarena代表用户 home/tarena 就是tarena用户的 主目录 ① sudo命令 获取root权限(获得系统最高权限) 语法:sudo+“Linux终端命令” tarena@tedu:~$ sudo mkdir test [sudo] tarena 的密码: 输入账户密码获得最高权限既可后续操作, pwd 查看当前所在目录 tarena@tedu:~$ pwd /home/tarena ② ls 命令 ls -l 当前目录所有内容详细信息(黑色:文件 蓝色:文件夹 红色:压缩包) ls - “文件名 ” 查看指定文件详细信息 ls -a 查看当前目录所有文件 包括隐藏文件 语法: ls命令可以连着使用 例如 ls -la (后面有点的都是隐藏文件) tarena@tedu:~$ ls -la 总用量 269436 drwxr-xr-x 31 tarena tarena 4096 6月 29 20:14 . drwxr-xr-x 3 root root 4096 7月 17 2017 .. drwxrwxr-x 20 tarena tarena 4096 7月 17 2017 anaconda3 -rw------- 1 tarena tarena 6466 6月 29 20:14 .bash_history -rw-r--r-- 1 tarena tarena 220 7月 17 2017 .bash_logout -rw-r--r-- 1 tarena tarena 4122 1月 26 15:43 .bashrc -rw-r--r-- 1 tarena tarena 3771 7月 17 2017 .bashrc-anaconda3.bak drwx------ 18 tarena tarena 4096 10月 27 2017 .cache drwxrwxr-x 3 tarena tarena 4096 10月 27 2017 .conda drwx------ 26 tarena tarena 4096 6月 29 20:13 .config ③ mkdir touch 命令 mkdir “目录名” 创建目录 mkdir -p 目录1/目录2/目录3 创建多层目录 语法:mkdir 也可以连着用 例如 mkdir a b c d mkdir -p a/b/c/d tarena@tedu:~$ mkdir a b c d tarena@tedu:~$ cd a tarena@tedu:~/a$ mkdir -p a/b/c/d tarena@tedu:~/a$ cd a/b/c/d tarena@tedu:~/a/a/b/c/d$ pwd /home/tarena/a/a/b/c/d tarena@tedu:~/a/a/b/c/d$ touch “文件名” 创建文件 Linux操作系统和Windows是文件性质不一样 Linux文件只是文件 没有后缀(扩展名) 下面 1 1.txt 1.doc 除了文件名不一样 其他的都一样 没有什么txt文件之分 ③rm命令 rm -i “文件名” 确认是否删除文件(y/n) rm -r “目录名” 删除目录 rm -f “文件名/目录名” 强制删除 语法:rm依然可以联合使用 例如 rm -rf (强制并且无提示删除一切文件) tarena@tedu:~$ rm -rf a Linux操作系统是目录树查看命令 ④tree 命令 tree 查看当前目录树 tree“目录名” 查看指定目录目录树 tarena@tedu:~$ ls anaconda3 d pycharm-professional-2017.1.5.tar.gz 视频 音乐 b examples.desktop PycharmProjects 图片 桌面 c my_env 公共的 文档 core pycharm-2017.1.5 模板 下载 tarena@tedu:~$ tree my_env/ my_env/ ├── get_env_details ├── initialize ├── postactivate ├── postdeactivate ├── postmkproject ├── postmkvirtualenv ├── postrmvirtualenv ├── preactivate ├── predeactivate ├── premkproject ├── premkvirtualenv └── prermvirtualenv 0 directories, 12 files ⑤ 压缩包tar命令 压缩 tar -zcvf “文件名”.tar.gz“要压缩的文件名” 解压 tar -zxvf “文件名”.tar.gz -C “要解压到的路径” z:gzip调用打包功能 c:打包 x:解包 v:执行细节 f:使用档案名字 tar zxf tar zcf 也可以不过语法不规范 tar -zxf tar -zcf v可以省略 ⑥压缩包mv命令 mv “文件名” “路径” 剪切到指定文件 mv “文件名” “文件名” 重命名文件 tarena@tedu:~$ mv b.tar.gz b tarena@tedu:~$ cd b tarena@tedu:~/b$ ls b.tar.gz tarena@tedu:~/b$ mv b.tar.gz best.tar.gz tarena@tedu:~/b$ ls best.tar.gz ⑦ 复制 cp 命令 语法: cp “源文件” “路径” ⑧ cd目录命令 cd “目录名” 进入单目录 cd “相对路径” 一次进入多个目录 cd “绝对路径” 跳转到绝对路径 cd .. 跳转到上一级目录 cd 回到用户主目录 ~ 回到用户主目录 init0 关机 init6 重启 Python --version 查看Python2版本 tarena@tedu:~$ python --version Python 2.7.12 Python3 --version 查看Python3版本 tarena@tedu:~$ python3 --version Python 3.5.2 很多命令都是可以混合 组合使用 例如 “.”可以代表当前目录 解压到当前目录 “~”代替用户主目录 输入时用TAB会自动补全文件名 名字前部分相同再按一次会显示有几那个 然后在输入TAb就可以 tarena@tedu:~$ ls 1 core pycharm-professional-2017.1.5.tar.gz 文档 1.doc d PycharmProjects 下载 1.txt examples.desktop 公共的 音乐 anaconda3 examples.desktop.tar.gz 模板 桌面 b my_env 视频 c pycharm-2017.1.5 图片 tarena@tedu:~$ cd b tarena@tedu:~/b$ ls 1.txt best.tar.gz tarena@tedu:~/b$ tar -zxvf best.tar.gz -C ~/d examples.desktop tarena@tedu:~/b$ cd ~/d tarena@tedu:~/d$ ls examples.desktop tarena@tedu:~/d$ cd tarena@tedu:~$ cd b tarena@tedu:~/b$ ls 1.txt best.tar.gz tarena@tedu:~/b$ tar -zxvf best.tar.gz -C . examples.desktop tarena@tedu:~/b$ ls 1.txt best.tar.gz examples.desktop tarena@tedu:~/b$

优秀的个人博客,低调大师

1.全栈工程师Python基础

Python基础¶ Python概述 计算机语言概述 语言: 交流的工具,沟通媒介 计算机语言: 人跟计算机交流工具,翻译官 Python是计算机语言里的一种 Python编程语言 代码: 人类语言,通过代码命令机器,跟机器交流 Python解析器: 就是那个担任翻译官工作的 流程: 写代码 执行: 由翻译官(Python解析器)把命令(Code) 翻译给机器, Python 简史 1989年, Guido van Rossum 2014: 宣布2.7支持到2020 2017: AI 元年, Pyhton崛起 Python特点: 速度问题 Python的应用领域 全能 设计哲学: 平衡发展,样样通,简洁明了 Python 为什么这么火 环境问题 anaconda+pycharm python3.6 环境 学习环境: 直播课: 网易云课堂 讲义+代码: github 教科书: gitbook 工作环境 环境安装: gitbook上有 http://www.cnblogs.com/zhouzhishuai/p/8401103.html 操作系统 windows Linux 我们的标准系统: windows下开虚拟机,虚拟机安装uabntu 软件环境 使用anaconda3+pycharm代替 Python的执行方式 本质上Python是一堆命令的集合 执行过程是逐行执行,遇到问题即刻终止 打印 Hello world jupyter notebook 快捷键: - alt+Enter 切换代码模式 - Shift+# 笔记 或 文本输入 - alt+Enter 也能运行代码

优秀的个人博客,低调大师

Python全栈工程师(多继承、函数重写)

ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 开局一张图 Python人工智能从入门到精通 补充: 对象 -------------------------> 类实例变量(属性) 类变量实例方法 类方法( @classmethond) 静态方法( @staticmethond)(类内普通函数) 继承/派生 单继承: 一个子类只有一个父类 一个父类可以有多个子类 -------------------------------------------------------------------------------------------- 用于类的函数: issublclass(cls, cls_or_tuple) 判断这个类是否继承自其他类, 如果此cls是class 或tuple中的一个派生子类, 返回True 否则返回False示例: class A: pass class B(A): pass class C(B): pass issublclass(C, B) # Trueissublclass(B, C) # Falseissublclass(C, (int, str)) # Falseissublclass(C, (int, B, str)) # True 封装 enclosure 封装是指隐藏类的实现细节,让使用者不关心这些细节 封装的目的是让使用者通过尽可能少的方法(或属性)操作对象私有属性和私有方法: python类中以双下划线(__)开头, 不以双下划线结尾的标识符为私有成员,私有成员或只能用类的方法进行访问和修改 以__开头的实例变量有私有属性 以__开头的方法有私有方法 示例: class A: def __init__(self): self.__p1 = 100 # 私有属性 def show_A(self): print("self.__p1", self.__p1) self.__m1() # 可以调用自己的方法 def __m1(self): # 私有方法 print("__m1(self)方法被调用") a = A() a.show_A() # 100 # print(a.__p1) # 出错 不能在类外部访问a.__p1私有属性 也不能在子类中访问 # a.__m1() # 出错 不能在类外部访问a.__p1私有方法 也不能在子类中访问 class B(A): pass b = B() print(b.__p1) # 出错,子类不能访问父类的私有成员 b.__m1() # 出错 b._A__p1 = 200 # python的假封装可以用此方法访问 print(b.__p1) # 200 多态polymorphic: 什么是多态 就是多种状态 多态是指在继承/派生关系的类中,调用基类对象的方法, 实际能够调用子类的覆盖方法的现象叫多态 状态: 静态(编译时状态)执行速度快 动态(运行时状态)执行速度慢说明: 多态调用方法与对象相关,不与类相关 Python的全部对象只有“运行时状态(动态)” 没有C++语言里的“编译时状态(静态)” 由于Python是解释执行的 是动态 没有静态 是在运行时编译(解释执行) 示例: # Pytgon中的运行时状态 class Shape: def draw(self): print("Shape的 draw 方法被调用") class Point(Shape): def draw(self): print("画车") class Circle(Shape): def draw(self): print("画圈") # python无法实现静态 除非不出现任何覆盖 def my_draw(s): # 其他静态语言 def my_draw(Circle s) 指定调用者 无法进行改变 s.draw() # 此处显示出"动态" s1 = Circle() s2 = Point() my_draw(s1) # 只有在调用时才能能确定调用哪一个 my_draw(s2) 面向对象不是编程而是一种思想面向对象的语言的特征: 继承 封装 多态 多继承:multiple inheritance 多继承是指一个子类继承自两个或两个以上的基类 语法: class 类名(基类名1, 基类名2, ...) 说明: 1.一个子类同时继承自多个父类,父类中的方法可以同时被继承下来 2.如果两个父类中同时有同名方法,而在子类中又没有覆盖此方法时, 调用结果难以确定 (也可以确定 C3算法)示例: class Car: def run(self, speed): print("汽车", speed, "Km/h 的速度行驶") class Plane: def fly(self, height): print("飞机以海拔", height, "米高度飞行") class PlaneCar(Plane, Car): '''同时继承Plane,Car的方法''' p1 = PlaneCar() p1.fly(10000) p1.run(300) 多继承的问题(缺陷): 标识符冲突的问题 要谨慎使用继承示例: # 多继承名字冲突问题 class A: def m(self): print("A.m被调用") class B: def m(self): print("B.m被调用") class AB(A, B): # 优先调用先出现的父类 有先后顺序 pass ab = AB() ab.m() # A.m被调用 class BA(B, A): pass ba = BA() ba.m() # B.m被调用 多继承的MRO(Method Resolution Order): 类的__mro__属性 __mro__ 是一个元组 里面存放类 此属性用来记录方法查找顺序示例: class A: def go(self): print("A") class B(A): def go(self): print("B") class C(A): def go(self): print("C") class D(B, C): def go(self): print("D") super().go() d = D() d.go() # B # 多继承的super调用关系一定是mro元组内的下一个类 和子父类没关系 # 如果没有方法则报错 调用算法(C3算法) # 正常调用也是mro顺序 函数重写: 在自定义类内添加相应的方法,让自定义类创建的实例 能像内建对象一样进行内建函数操作对象转字符串函数: repr(obj) 返回一个能代表此对象的表达式字符串,通常eval(repr(obj))== obj (这个字符串通常给Python解释执行器运行用的) str(obj) 返回的字符串(这个字符串通常给人阅读用的) 对象转字符串函数的重写方法: repr(obj) 函数的重写方法: def __repr__(self): pass str(obj) 函数的重写方法: def __str__(self): pass 说明: 1.str(obj)函数先查找, obj.str()方法 调用此方法并返回结果 2.如果没有obj.__str__方法时,返回obj.__repr__() 方法的结果并返回 3.如果obj.__repr__方法不存在,则调用obj类的__repr__ 实例方法显示:<__main__.XXXX object at 0x7f4b1c36fa90>示例: class MyNumber: def __init__(self, value): '构造函数,初始化MyNumber' self.data = value def __str__(self): '''转换为人能够识别的字符串''' print("__str__方法被调用") return "自定义数字类型对象:%d" % self.data def __repr__(self): '''转换为eval能够识别的字符串''' return 'MyNumber(%d)' % self.data n1 = MyNumber(100) n2 = MyNumber(200) print("repr(n1):--->", repr(n1)) print("strr(n2):--->", str(n2)) print("strr(n2):--->", n2.__str__()) 其他内建函数的重写方法:__abs__ abs(obj) 函数__len__ len(obj) 函数(必须返回整数)__reversed__ reversed(obj) 函数(必须返回可迭代对象)__round__ round(obj) 函数 示例: # 函数重写 class MyNumber: def __init__(self, v): self.data = v def __repr__(self): return 'MyNumber(%d)' % self.data def __abs__(self): '''__abs__函数重写 求绝对值函数''' # return -self.data v = abs(self.data) return MyNumber(v) # 创建一个新的MyNumber对象 def __len__(self): '''__len__函数重写 求长度函数''' # return len(self.data) i = 0 for x in self.data: i += 1 return i i1 = MyNumber(-10) print(i1) i2 = abs(i1) print(i2) i3 = MyNumber("123d5sa") print(len(i3)) 数据转换函数的重写:__complex__ complex(obj) 函数__int__ int(obj) 函数__float__ float(obj) 函数__bool__ bool(obj) 函数 示例: 数据转换构造函数重写 class MyNumber: def __init__(self, v): self.data = v def __repr__(self): return 'MyNumber(%d)' % self.data def __int__(self): # return 999999 # 可以自定义返回规则 return self.data n1 = MyNumber(100) x = int(n1) print(type(x)) # <class 'int'> print(bool(n1)) # True n2 = MyNumber(0) print(bool(n2)) # True # 默认返回 # True 布尔测试函数重写: 格式: __bool__ 作用: 用于bool(obj)函数取值 用于if语句的真值表达式中 说明: 1.当自定义的类内有__bool__(self) 方法时,此方法的返回值为bool(obj)的返回值 2.当不存在__bool__(self),bool(x) 返回__len__(self)方法的返回值是否为零来测试布尔值 3.当不存在__len__方法时,则直接返回True示例: # bool(x)函数重写 class MyList: '''自定义类型的列表,用来保存数据,内部用列表来储存数据''' def __init__(self, iterable): self.data = [x for x in iterable] def __repr__(self): return " MyList(%s)" % self.data def __len__(self): '''返回长度''' print("__bool__方法被调用") return len(self.data) # def __bool__(self): # print("__bool__方法被调用") # return False # 此处定义所有对象返回False def __bool__(self): print("__bool__方法被调用") for x in self.data: if not x: return False return True # 自定义返回规则(这就是函数重写) myl = MyList((1, 2, -3, 4, -5, 5)) print(myl) print(bool(myl)) if myl: print("myl是真值") else: print("myl是假值") 迭代器(高级): 什么是迭代器: 可以通过next(it)函数取值的对象就是迭代器 迭代器协议: 迭代器是指对象能够使用next函数获取下一项数据, 在没有下一项数据时触发一个StopIteration异常来终止迭代的重写 迭代器协议实现方法: __next__(self) 方法来实现迭代协议 语法形式: class MyIterator: def __next__(self): 迭代器协议 return 数据什么是可迭代对象: 是指用iter(obj) 函数返回迭代对象(实例) 可迭代对象内部需要定义__iter__(self)方法来返回迭代器对象 # 此示例示意让自定义的作为可迭代对象能让 for 语句迭代访问 class MyList: '''创建MyList类''' def __init__(self, iterable=()): '''初始化self iterable:可迭代对象 ''' # 用iterable生成列表 self.data = [x for x in iterable] def __repr__(self): '''返回一个MyList字符串''' return 'MyList(%s)' % self.data def __iter__(self): '''此方法必须返回一个迭代器对象 此方法创建一个迭代器对象并返回 ''' return MyListIterator(self.data) class MyListIterator: '''此类用来创建迭代器,此类型的迭代器可以迭代访问 MyList类型的对象''' def __init__(self, lst): self.data = lst self.cur_index = 0 # 初始化迭代器的起始位置 def __next__(self): '''此方法用于实现迭代器协议''' if self.cur_index >= len(self.data): # 如果索引越界就发终止迭代通知 raise StopIteration value = self.data[self.cur_index] # 要返回的值 self.cur_index += 1 return value myl = MyList([0, -1, 2, -3]) print(myl) # it = iter(myl) # print(next(it)) for x in myl: # 迭代访问自定义类型的可迭代对象 print(x) 练习: 写一个类Bicycle类 ,有 run方法.调用时显示骑行里程km class Bicycle: def run(self, km): print('自行车骑行了', km, '公里') 再写一个类EBicycle(电动自行车类), 在Bicycle类的基础上添加了电池电量 volume 属性, 有两个方法: 1. fill_charge(self, vol) 用来充电, vol为电量 2. run(self, km) 方法每骑行10km消耗电量1度,同时显示当前电量,当电量耗尽时调用 父类的run方法继续骑行 b = EBicycle(5) # 新买的电动有内有5度电 b.run(10) # 电动骑行了10km还剩 4 度电 b.run(100) #电动骑行了40km,还剩0度电,其余60用脚登骑行 b.fill_charge(10) # 又充了10度电 b.run(50) # 骑行了50公里剩5度电 答案: class Bycycle: def run(self, km): '''自行车''' print("自行车骑行了", km, "公里") class EBycyle(Bycycle): def __init__(self, volume=0): '''初始化电动车''' self.volume = volume print("新买的电动车有", volume, "度电") def fill_charge(self, vol): '''冲电''' self.volume += vol print("又冲了", vol, "度电") def run(self, km): self.volume -= (km / 10) # 减去使用的电量 x = abs(self.volume) * 10 # 计算超出的公里 if self.volume < 0: # 判断是否超出电量 self.volume = 0 print("电动车骑行了", km, "千米 还剩", self.volume, "度电 其余", x, "千米用脚蹬") else: print("电动车骑行了", km, "千米 还剩", self.volume, "度电") b = EBycyle(10) b.run(10) b.run(100) b.fill_charge(10) b.run(50) # 新买的电动车有 10 度电 # 电动车骑行了 10 千米 还剩 9.0 度电 # 电动车骑行了 100 千米 还剩 0 度电 其余 10.0 千米用脚蹬 # 又冲了 10 度电 # 电动车骑行了 50 千米 还剩 5.0 度电 b = EBycyle(50) b.run(10) b.run(100) b.fill_charge(10) b.run(50) # 新买的电动车有 50 度电 # 电动车骑行了 10 千米 还剩 49.0 度电 # 电动车骑行了 100 千米 还剩 39.0 度电 # 又冲了 10 度电 # 电动车骑行了 50 千米 还剩 44.0 度电 练习: 1. 修改原有的学生信息管理系统, 将学生对象的,全部属性 都变为私有属性,不让外部直接访问来实现封装 源码: https://pan.baidu.com/s/1szQDS5cfzVHLlZrrJcCs8A 2. 写一个列表类MyList实现存储整数列表,写类的定义如下: class MyList: def __init__(self, iterator): self.data = ... 让此类的对象能用for语句进行迭代访问 L = MyList(range(5)) print(L) L2 = [x ** 2 for x in L] print(L2) # [0, 1, 4, 9, 16] 答案: class MyList: def __init__(self, iterable=()): self.lst = [x for x in iterable] def __repr__(self): return "%s" % self.lst def __iter__(self): return MyIterable(self.lst) class MyIterable: def __init__(self, lst): self.lst = lst self.myindex = 0 def __next__(self): if self.myindex >= len(self.lst): raise StopIteration value = self.lst[self.myindex] self.myindex += 1 return value L = MyList(range(5)) print(L) for x in L: print(x) L2 = [x ** 2 for x in L] print(L2) 3. 写一个类Fibonacci 实现迭代器协议 ,此类的对象可以作为可迭代对象生成相应的斐波那契数 1 1 2 3 5 class Fibonacci: def __init__(self, n) # n代表数据的个数 ... ... 实现如下操作: for x in Fibonacci(10): print(x) # 1 1 3 5 8 .... L = [x for x in Fibonacii(50)] print(L) F = fibonicci(30) print(sum(F)) 答案: 直接继承第二题的类 class Fibonicci(MyList): def __init__(self, n): L = [1, 1] for _ in range(n - 2): L.append(L[-1] + L[-2]) self.lst = L for x in Fibonicci(10): print(x) # 1 1 3 5 8 .... L = [x for x in Fibonicci(50)] print(L) F = Fibonicci(30) print(F) print(sum(F))

优秀的个人博客,低调大师

Python全栈工程师(迭代器、字节串)

ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 Python人工智能从入门到精通 迭代器 Iterator: 用<>括号表示的一定是对象 什么是迭代器? 迭代器是访问可迭代对象的工具 迭代器是指用iter(obj) 函数返回的对象(实例) 迭代器可以用next(it) 函数获取可迭代对象的数据 迭代器函数iter和next iter(iterable) 从可迭代对象中返回一个迭代器,iterable 必须是能提供一个迭代器的对象 next(iterator) 从迭代器iterator中获取下一个记录,如果无法获取下一条记录,则触发StopIteration异常说明: 迭代器只能向前取值,不会后退 用iter函数可以返回一个可迭代对象的迭代器作用: 迭代器对象能用next函数获取下一个元素. 示例: L = [2, 3, 5, 7] it = iter(L) # 用L对象返回能访问L的迭代器, it绑定迭代器 next(it) # 2 next(it) # 3 next(it) # 5 next(it) # 7 next(it) # StopIteration 通知(没有数据) it = iter(range(1, 10, 30)) next(it) # 1 next(it) # 4 next(it) # 7 next(it) # StopIteration 用迭代器访问可迭代对象: L = [2, 3, 5, 7] for x in L: print(x) else: print('循环结束') it = iter(L) # 从L中获取一个迭代器 while True: try: x = next(it) print(x) except StopIteration: print("循环结束") break 生成器 Generator (python 2.5及之后)什么是生成器? 生成器是能够动态提供数据的对象,生成器对象也是可迭代对象(实例) 动态就是现用现生成数据 生成器有两种: 1. 生成器函数 2. 生成器表达式 生成器函数的定义 含有yield语句的函数是生成器函数,此函数被调用将返回一个生成器对象 yield 翻译为(产生或生成) yield 语句 语法: yield 表达式 说明: yield 用于 def 函数中,目的是将此函数作用生成器函数使用 yield 用来生成数据,供迭代器的next(it) 函数使用 yield 单步生成数据 在函数内可以一个或多少 实例: # 此示例示意用生成器函数生成一定范围内的自然数 def myinteger(n): i = 0 # 自然数从0开始 while i < n: yield i i += 1 for x in myinteger(3): print(x) 生成器函数说明: 生成器函数的调用将返回一个生成器对象,生成器对象是一个可迭代对象 在生成器函数调用return 会触发一个StopIteration异常生成器表达式: 语法: (表达式 for 变量 in 可迭代对象 [if 真值表达式 ]) 说明: if 子句可以省略 作用: 用推导式的形式创建一个新的生成器 示例: gen = (x ** 2 for x in range(1, 5)) it = iter(gen) next(it) # 1 next(it) # 4 next(it) # 9 next(it) # 16 next(it) # StopIteration迭代工具函数 迭代工具函数的作用是生成一个个性化的可迭代对象 函数:zip(iter1[, iter2[, ...]]) 返回一个zip对象,此对象用于生成元组,此元组的个数由最小的可迭代对象决定 enumerate(iterable[, start]) 生成带索引的枚举对象,返回迭代类型为索引-值对(index-value对),默认索引从零开始,也可以用start指定 示例: numbers = [10086, 10000, 10010, 9558] names = ['中国移动', '中国电信', '中国联通'] for t in zip(numbers, names): print(t) for x, y in zip(numbers, names): print(y, '的客服电话是:', x) x, y = (10086, '中国移动') # 序列赋值 zip函数的实现示例2: def myzip(iter1, iter2): it1 = iter(iter1) # 拿出一个迭代器 it2 = iter(iter2) while True: a = next(it1) b = next(it2) yield (a, b) for t in myzip(numbers, names): #能实现与zip同样的功能 print(t) enumerate 示例: names = ['中国移动', '中国电信', '中国联通'] for t in enumerate(names): print(t) enumerate 实现方法示意: def myenum(iterable): it = iter(iterable) i = 0 while True: a = next(it) yield (i, a) i += 1 字节串和字节数组 字节串bytes (也叫字节序列) 作用: 存储以字节为单位的数据 字节串是不可变的字节序列 字节: 字节是由8个位(bit)组成的数据单位,是计算机进行数据管理的单位 字节是用 0 ~ 255 范围内的整数表示的 创建空字节串的字面值 B = b'' B = b"" B = b'''''' B = b"""""" 创建非空字节串的字面值 B = b'ABCD' B = b"ABCD" B = b'\x41\x42' 字节串的构造函数 bytes bytes() 生成一个空的字节串 等同于 b'' bytes(整数可迭代对象) # 用可迭代对象初始化一个字节串 bytes(整数n) 生成n个值为0的字节串 bytes(字符串, encoding='utf-8') 用字符串转为编码生成一个字节串 示例: b = bytes() # b = b'' b = bytes(range(65, 69)) # b = b'ABCD' b = bytes(5) # b = b'\x00\x00\x00\x00\x00' b = bytes('abc中文') # b=b'ABC\xe4\xb8\xad\xe6\x96\x87' bytes 的运算: + += * *= < <= > >= == != in / not in 索引和切片 len(x) max(x) min(x) sum(x) any(x) all(x) bytes 和 str 的区别: bytes 存储字节( 通常值在 range(0, 256)) str 存储unicode字符( 通常值在0~65535) bytes 与 str 的转换 编码(encode) str ------------> bytes b = s.encode(encoding='utf-8') 解码(decode) bytes ----------> str s = b.decode(encoding='utf-8') 字节数组 bytearray可变的字节序列 字节数组的构造函数: bytearray bytearray() 创建空的字节数组 bytearray(整数) 用可迭代对象初始化一个字节数组 bytearray(整型可迭代对象) 生成n个值为0的字节数组 bytearray(字符串, encoding='utf-8') 用字符串的转换编码生成一个字节数组 bytearray 的运算: + += * *= < <= > >= == != in / not in 索引和切片 (字节数组支持索引和切片的赋值操作,规则同列表的索引和切片赋值规则) 例: ba = bytearray(b'aBCDEfG') ba[0] = 65 ba[-2] = 70 bytearray的方法: BA.clear() 清空 BA.append(n) 追加一个字节(n为0~255的整数) BA.remove(value) 删除第一个出现的字节,如果没有出现,则触发ValueError错误 BA.reverse() 字节顺序反转 BA.decode(encoding='utf-8') # 解码为字符串 BA.find(sub[, start[,end]]) # 查找 sub 练习: 有一个集合: s = {'唐僧', '悟空', '八戒', '沙僧'} 用 for语句来遍历所有元素如下: for x in s: print(x) else: print('遍历结束') 请将上面的for语句改写为 用while语句和迭代器实现 练习: 写一个生成器函数 myeven(start, stop) 此函数用来生成从 start开始到stop结束(不包含)区间内的一系列偶数 def myeven(start, stop): .... evens = list(myeven(10, 20)) print(evens) # [10, 12, 14, 16, 18] for x in myeven(21, 30): print(x) # 22, 24, 26, 28 L = [x**2 for x in myeven(3, 10)] print(L) # 16 36 64 练习: 已知有一个列表L L = [2, 3, 5, 7] 用生成器表达式从此列表中拿到数,生成 列表中数据的平方 gen = ...... # 此处用生成器表达式实现 L2 = list(gen) # L2 = [4, 9, 25, 49] 练习: 写一个程序,读入任意行的文字,当输入空行时结束输入 打印带有行号的输入结果: 如: 请输入: hello<回车> 请输入: world<回车> 请输入: tarena<回车> 请输入: <回车> # 直接回车结束输入 输出如下: 第1行: hello 第2行: world 第3行: tarena 练习: 写一个程序,从键盘输入一段字符串存入s变量 1. 将此字符串转为字节串用变量b绑定,并打印出b 2. 打印字符串s的长度和字节串b的长度 3. 将b字节串再转换为字符串用变量s2 绑定,判断 s2 和 s是否相同? s = input("please input string:") b = s.encode("utf-8") print(s) print(b) print(len(s)) print(len(b)) s2 = b.decode("utf-8") if s2 == s: print("相等") 练习: 1. 写一个生成器函数primes生成素数, 此生成器函数为 primes(begin, end) 如: [x for x in primes(10, 20)] 将得到列表 [11, 13, 17, 19] 答案: def get_ss(x): if x <= 0: return False for i in range(2, x): if x % i == 0: return False return True def primes(begin, end): if begin <= 2or end <= 2: pass for x in range(begin, end): if get_ss(x): yield x L = [x for x in primes(10, 20)] print(L) 2. 写一个生成器函数,生成斐波那契数列的前n个数 1 1 2 3 5 8 13 def fibonacci(n): ... yield... 1) 输出前20个数: for x in fibonacci(20): print(x) 2) 打印前40个数的和: print(sum(fibonacci(40))) 答案: def fibonacci(n): L = [1, 1] for x in range(n): s = L[x] + L[x + 1] L.append(s) return L print(fibonacci(20)) print(sum(fibonacci(40))) 3. 写 程序打印杨辉三角(只打印6层) 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 答案: def yh_sj(): L = [1] while True: yield L L.append(0) L = [L[x - 1] + L[x] for x in range(len(L))] def lst(): i = 0 for x in yh_sj(): print(str(x).center(50)) if i == 10: break i += 1 思考: L = [2, 3, 5, 7] L2 = [x ** 2 for x in L] # 列表推导式 it = iter(L2) print(next(it)) # 4 L[1] = 10 print(next(it)) # 9 L = [2, 3, 5, 7] G3 = (x ** 2 for x in L) # 生成器表达式 it = iter(G3) print(next(it)) # 4 L[1] = 10 print(next(it)) # 100 生成器是动态的现用现去 跟着数据变化所变化

资源下载

更多资源
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册