python经常使用功能（算法）整理
上
一、冒泡排序
方法一：html
lis = [23,34,23,45,67,222,33,78,98,43,2,3,76,-34,-23]
def sortport():
for i in range(len(lis)-1):
for j in range(len(lis)-1-i):
if lis[j] > lis[j+1]:
lis[j],lis[j+1] = lis[j+1],lis[j]
return lis
print(sortport())复制代码
方法二：python
list = [1,4,1,34,23,54,34]
def maopao(list):
for i in range(len(list)):
for j in range(len(list)-1):
if list[i] > list [j]:
list[j], list[i] = list[i], list[j] #从大到小
print(list)复制代码
二、编程用sort进行排序，而后从最后一个元素开始判断，去除重复数字
方法一：git
a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]
a.sort()
last=a[-1]
for i in range(len(a)-2,-1,-1):
if last==a[i]:
del a[i]
else:
last=a[i]
print(a)复制代码
方法二：能够从前面的元素开始判断去除重复的数字算法
a = [11, 11, 22, 22, 33, 44, 55, 66, 88, 99]
for i in range(len(a)):
for j in range(i + 1 , len(a) - 1):
if a[i] == a[j]:
del a[j]
j -= 1
print(a)复制代码
三、打印九九乘法表
一行代码实现编程
print('\n'.join([' '.join(['%s*%s=%-2s' % (y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))复制代码
for 循环api
for i in range(1, 10):
for j in range(1, i+1):
print('{}x{}={}\t'.format(j, i, i*j),end='')
# print('%d x %d = %d \t'%(i, j, i*j),end='')
print()
# 经过指定end参数的值，能够取消在末尾输出回车符，实现不换行。复制代码
Python2.6 开始，新增了一种格式化字符串的函数
str.format()，它加强了字符串格式化的功能。
基本语法是经过 {} 和 : 来代替之前的 % 。
format 函数能够接受不限个参数，位置能够不按顺序。
for i in range(1,10):
for j in range(1,i+1):
string = '%d*%d=%d'%(j,i,j*i)
print('%-7s'%string,end="")
print('')
# %-7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串右侧补空格复制代码
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%-2d "%(i,j,i*j),end=" ")
print()复制代码
首先，引入一个场宽的概念。在C语言中场宽表明格式化输出字符的宽度。bash
例如：能够在"%"和字母之间插进数字表示最大场宽。
%3d 表示输出3位整型数,不够3位右对齐。
%9.2f 表示输出场宽为9的浮点数,其中小数位为2,整数位为6,小数点占一位,不够9位右对齐。 （注意：小数点前的数字必须大于小数点后的数字。小数点前的数值规定了打印的数字的总宽度。若是忽略了（如：.2f），则意味着总宽度无限制。）
%8s 表示输出8个字符的字符串,不够8个字符右对齐。
while循环app
n = 1
while n <= 9:
m = 1
while m<= 9:
print("%d*%d=%2d "%(n,m,n*m), end="")
m += 1
print()
n += 1复制代码
四、计算阶乘
方法一：dom
def fac():
num = int(input("请输入一个数字："))
factorial = 1
# 查看数字是不是负数，0 或者 正数
if num < 0:
print("抱歉，负数没有阶乘")
elif num == 0:
print("0 的阶乘为 1")
else:
for i in range(1, num + 1):
factorial = factorial * i
print("%d 的 阶乘为 %d" % (num, factorial))
fac()复制代码
方法二：
ide
def factorial(n):
result = n
for i in range(1, n):
result *= i
return result
print(factorial(5))复制代码
方法三：
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print(fact(5))复制代码
五、计算x的n次方的方法
def power(x,n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print(power(2,3))复制代码
六、计算a*a + b*b + c*c + ……
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
print(calc(*[1,2,3]))复制代码
七、将list中字符串变成小写
L = ['Hello','World','IBM','Apple']
L2 = []
for s in L:
L2.append(s.lower())
print(L2)复制代码
八、把原字典的键值对颠倒并生产新的字典
dict1 = {"A":"a","B":"b","C":"c"}
dict2 = {y:x for x,y in dict1.items()}
print(dict2)复制代码
九、替换列表中全部的3为3a
num = ["harden","hampard",3,23,45,23,55,3,3,3,3,4356,546]
# print(num.count(3))
# print(num.index(3))
for i in range(num.count(3)): #获取3出现的次数
ele_index = num.index(3) #获取首次3出现的坐标
num[ele_index] = "3a" #修改3为3a
print(num)复制代码
十、打印每一个名字
L = ["James","Meng","Xin"]
for i in range(len(L)):
print("Hellow,%s"%L[i])
复制代码
善于使用 range() ，会使问题变得简单
十一、合并去重
list1 = [1,2,3,23,65,3,3,9,8]
list2 = [1,2,3,45,65,3,3,87,45]
list3 = list1 + list2
print(list3) #不去重进行两个列表的组合
print(set(list3)) #去重，类型为set须要转化为list
print(list(set(list3)))复制代码
十二、随机生成验证码
方法一：
import random
list1 = []
# chr() 用一个范围在 range（256）内的（就是0～255）整数做参数，返回一个对应的字符。
for i in range(65,91):
list1.append(chr(i)) #经过for循环遍历ASCII追加到空列表中
for j in range(97,123):
list1.append(chr(j))
for k in range(48,58):
list1.append(chr(k))
ma = random.sample(list1,6)
print(ma) #获取到的为空列表
ma = ''.join(ma) #将列表转化为字符串print(ma)复制代码
方法二：
import random,string
str1 = "0123456789"
str2 = string.ascii_letters
str3 = str1 + str2
ma1 = random.sample(str3,6)
ma1 = ''.join(ma1)
print(ma1)复制代码
1三、计算平方根
num = float(input('请输入一个数字: '))
num_sqrt = num ** 0.5
print(' %0.2f 的平方根为 %0.2f'%(num,num_sqrt))复制代码
1四、判断字符串是否只由数字组成
def is_number(s):
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
# print(is_number('12w3'))
chri = "123w"
print(chri.isdigit()) #检测字符串是否只由数字组成
print(chri.isnumeric()) #检测字符串是否只由数字组成,这种方法只针对unicode对象复制代码
1五、判断奇偶数
方法一：
num = int(input("请输入一个数字: "))
if (num % 2) == 0:
print("{0} 是偶数".format(num))
else:
print("{0} 是奇数".format(num))复制代码
方法二：
while True:
try:
num = int(input('请输入一个整数: ')) #判断输入是否为整数
except ValueError: #不是纯数字须要从新输入
print("输入的不是整数!")
continue
if num % 2 == 0:
print("偶数")
else:
print("奇数")
break复制代码
1六、判断闰年
方法一：
year = int(input("输入一个年份: "))
if (year % 4) == 0:
if (year % 100) == 0:
if (year % 400) == 0:
print("{0} 是闰年".format(year)) #整百年能被400整除是闰年
else:
print("{0} 不是闰年".format(year))
else:
print("{0} 是闰年".format(year)) #非整百年能被4整除为闰年
else:
print("{0} 不是闰年".format(year))复制代码
方法二：
year = int(input("输入一个年份: "))
if (year % 4) == 0 and (year % 100) != 0 or (year % 400) == 0:
print("{0} 是闰年".format(year))
else:
print("{0} 不是闰年".format(year))复制代码
方法三：
import calendar #日历模块
print(calendar.month(2018, 6))
year = int(input("请输入年份："))
check_year = calendar.isleap(year)
if check_year == True:
print("%d是闰年"% year)
else:
print("%d是平年"% year)复制代码
1七、获取最大值
方法一：
# 获取最大值N = int(input("输入须要对比大小数字的个数："))
print("请输入须要对比的数字：")
num = []
for i in range(1,N+1):
temp = int(input("请输入第%d个数字：" % i))
num.append(temp)print('您输入的数字为：',num)
print('最大值为：',max(num))复制代码
方法二：
N = int(input("输入须要对比大小数字的个数：\n"))
num = [ int(input('请输入第 %d 个对比数字：\n'%i))for i in range(1,N+1) ]
print('您输入的数字为：',num)
print('最大值为：',max(num))复制代码
1八、斐波那契数列
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：一、一、二、三、五、八、1三、2一、3四、……在数学上，斐波纳契数列以以下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）
斐波那契数列，难点在于算法，还有若是变成生成器，generator，就要用for循环去遍历可迭代的generator
方法一：
不少种解法，我是按照分割的方式，每次取列表后两项，而后相加。
def six():
l = [0,1]
for i in range(10):
arr = l[-2:]
l.append(arr[0]+arr[1])
return(l)
print(six())复制代码
方法二：递归法
def fib_recur(n):
assert n >= 0, "n > 0"
if n <= 1:
return n
return fib_recur(n-1) + fib_recur(n-2)
for i in range(1, 20):
print(fib_recur(i), end=' ')复制代码
写法最简洁，可是效率最低，会出现大量的重复计算，时间复杂度O（1.618^n）,并且最深度1000
方法三：递推法
def fib_loop(n):
a, b = 0, 1
for i in range(n + 1):
a, b = b, a + b
return a
for i in range(20):
print(fib_loop(i), end=' ')复制代码
递推法，就是递增法，时间复杂度是 O(n)，呈线性增加，若是数据量巨大，速度会越拖越慢
方法四：矩阵
### 1
import numpy
def fib_matrix(n):
res = pow((numpy.matrix([[1, 1], [1, 0]])), n) * numpy.matrix([[1], [0]])
return res[0][0]
for i in range(10):
print(int(fib_matrix(i)), end=', ')
### 2
# 使用矩阵计算斐波那契数列
def Fibonacci_Matrix_tool(n):
Matrix = numpy.matrix("1 1;1 0")
# 返回是matrix类型
return pow(Matrix, n) # pow函数速度快于 使用双星好 **
def Fibonacci_Matrix(n):
result_list = []
for i in range(0, n):
result_list.append(numpy.array(Fibonacci_Matrix_tool(i))[0][0])
return result_list
# 调用
Fibonacci_Matrix(10)复制代码
由于幂运算可使用二分加速，因此矩阵法的时间复杂度为 O(log n)
用科学计算包numpy来实现矩阵法 O(log n)
方法五：生成器
def fib_loop_while(max):
a, b = 0, 1
while max > 0:
a, b = b, a + b
max -= 1
yield a
for i in fib_loop_while(10):
print(i,end=',')复制代码
带有yield的函数都被当作生成器，生成器是可迭代对象，且具有__iter__ 和 __next__方法， 能够遍历获取元素
python要求迭代器自己也是可迭代的，因此咱们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，因此迭代器的__iter__方法返回自身便可
方法六：类实现内部魔法方法
class Fibonacci(object):
"""斐波那契数列迭代器"""
def __init__(self, n):
""" :param n:int 指 生成数列的个数 """
self.n = n
# 保存当前生成到的数据列的第几个数据，生成器中性质，记录位置，下一个位置的数据
self.current = 0
# 两个初始值
self.a = 0
self.b = 1
def __next__(self):
"""当使用next()函数调用时，就会获取下一个数"""
if self.current < self.n:
self.a, self.b = self.b, self.a + self.b
self.current += 1
return self.a
else:
raise StopIteration
def __iter__(self):
"""迭代器的__iter__ 返回自身便可"""
return self
if __name__ == '__main__':
fib = Fibonacci(15)
for num in fib:
print(num,end=',')
# for循环的本质是经过不断调用next()函数实现的
for x in [1, 2, 3, 4, 5]:
pass
# 至关于
# 首先获取可迭代对象
it = iter([1, 2, 3, 4, 5])
# while next
while True:
try:
next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break复制代码
1九、十进制转二进制、八进制、十六进制
# 获取输入十进制数
dec = int(input("输入数字："))
print("十进制数为：", dec)
print("转化二进制为：", bin(dec))
print("转化八进制为：", oct(dec))
print("转化十六进制为：", hex(dec))复制代码
20、简单计算器
# 定义函数
def add(x, y):
""" 相加 """
return x + y
def subtract(x, y):
""" 相减 """
return x - y
def multiply(x, y):
""" 相乘 """
return x * y
def divide(x, y):
""" 相除 """
return x / y
# 用户输入print("选择运算：")
print("一、相加")
print("二、相减")
print("三、相乘")
print("四、相除")
choice = input("输入你的选择(1/2/3/4):")
num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))
if choice == "1":
print(num1, "+", num2, "=", add(num1, num2))
elif choice == "2":
print(num1, "-", num2, "=", subtract(num1, num2))
elif choice == "3":
print(num1, "*", num2, "=", multiply(num1, num2))
elif choice == "4":
if num2 != 0:
print(num1, "/", num2, "=", divide(num1, num2))
else:
print("分母不能为0")
else:
print("非法输入")复制代码
2一、生成日历
# 引入日历模块
import calendar
# 输入指定年月
yy = int(input("输入年份："))
mm = int(input("输入月份："))
# 显示日历
print(calendar.month(yy, mm))复制代码
2二、字符串判断
#测试实例一
print("测试实例一")
str = "runoob.com"print(str.isalnum())
#判断全部字符都是数字或者字母
print(str.isalpha()) #判断有所字符都是字母
print(str.isdigit()) #判断有所字符都是数字
print(str.islower()) #判断有所字符都是小写
print(str.isupper()) #判断有所字符都是大写
print(str.istitle()) #判断有所单词都是首字母大写，像标题
print(str.isspace()) #判断有所字符都是空白字符、\t、\r、\n
print("-------------------------")
print("测试实例二")
str = "Bake corN"
print(str.isalnum())
print(str.isalpha())
print(str.isdigit())
print(str.islower())
print(str.isupper())
print(str.istitle())
print(str.isspace()) 复制代码
2三、字符串大小写转换
str = "https://juejin.im/user/"
print(str.upper()) # 把全部字符中的小写字母转化成大写字母
print(str.lower()) # 把全部字符中的大写字母转化小写字母
print(str.capitalize()) # 把第一个字母转化成大写字母，其他小写
print(str.title()) # 把每一个单词的第一个字母转化为大写，其他为小写复制代码
2四、计算每月的天数
import calendar
monthRange = calendar.monthrange(2019,11)
print(monthRange)复制代码
2五、获取昨天的日期
# 引入 datetime 模块
import datetimedef getYesterday():
today = datetime.date.today()
oneday = datetime.timedelta(days=1)
yesterday = today - oneday
return yesterday
print(getYesterday())复制代码
2六、趣味天然数
掌握使用自定义函数实现水仙花数和彻底数
水仙花数（narcissistic number)中的narcissistic本意是“自我陶醉，自赏的，自恋的”。在希腊神话中，貌美青年那喀索斯(narcissus)爱上了本身在水中的倒影，他死后化做水仙花，此花即因之命名。因此，水仙花数也称为自恋数，自幂数，本名为超彻底数字不变数（pluperfect digital invariant, PPDl)
水仙花数，在咱们认识的大概认知，数学概念的自幕数是这样解释的。
自幂数是指一个 n 位数，它的每一个位上的数字的 n 次幂之和等于它自己。
n为1时，自幂数称为独身数。显然，0,1,2,3，4,5,6,7,8,9都是自幂数。
n为2时，没有自幂数。
n为3时，自幂数称为水仙花数，有4个：153，370，371，407；
n为4时，自幂数称为四叶玫瑰数，共有3个：1634，8208，9474；
n为5时，自幂数称为五角星数，共有3个：54748，92727，93084；
n为6时，自幂数称为六合数， 只有1个：548834；
n为7时，自幂数称为北斗七星数， 共有4个：1741725，4210818，9800817，9926315；
n为8时，自幂数称为八仙数， 共有3个：24678050，24678051，88593477；
n为9时，自幂数称为九九重阳数，共有4个：146511208，472335975，534494836，912985153；
n为10时，自幂数称为十全十美数，只有1个：4679307774。复制代码
话很少说，来代码：
#若是一个 3 位数等于其各位数字的立方和，则称这个数为水仙花数。
#例如：153 = 1^3 + 5^3 + 3^3，所以 153 就是一个水仙花数。
#方法1：
def flower1(a,b): # 限制范围
for i in range(a,b):
sum = 0 #用来存放各个位数的立方和
temp = i
while temp:
sum += (temp%10) ** 3 #累加
temp //= 10 # // 取整除 - 向下取接近除数的整数
if sum == i:
print(i)flower1(10,1000) # 153 370 371 407复制代码
还能够先定义一个求幂次方和的函数
import math# 定义一个函数求取列表中的幂次方和
def pow3(list):
sum = 0
for i in list:
sum += math.pow(int(i),3)
return sum复制代码
# 方法2 依次求取各个位数 def flower():
for i in range(100,1000):
a = i // 1000 # 取最高位
b = i //100 % 10 # 取百位
c = i //10 % 10 # 取十位
d = i % 10 # 取末位
list = [a,b,c,d]
if pow3(list) == i:
print('100-1000之内的水仙花数有:%d'%i)
flower()
#100-1000之内的水仙花数有:153
#100-1000之内的水仙花数有:370
#100-1000之内的水仙花数有:371
#100-1000之内的水仙花数有:407复制代码
# 方法3： 数值转为list def flower2():
for i in range(100, 1000):
list1 = list(str(i))
if pow3(list1) == i:
print('100-1000之内的水仙花数有:%d'%i)
flower2()
#100-1000之内的水仙花数有:153
#100-1000之内的水仙花数有:370
#100-1000之内的水仙花数有:371
#100-1000之内的水仙花数有:407复制代码
2七、彻底数
若是一个数刚好等于它的因子之和，则称该数为“彻底数” 。各个小于它的约数（真约数,列出某数的约数，去掉该数自己，剩下的就是它的真约数）的和等于它自己的天然数叫作彻底数（Perfect number），又称完美数或完备数。
例如：第一个彻底数是6，它有约数一、二、三、6，除去它自己6外，其他3个数相加，1+2+3=6。第二个彻底数是28，它有约数一、二、四、七、1四、28，除去它自己28外，其他5个数相加，1+2+4+7+14=28那么问题来了：如何用python去求出下一个（大于28的）彻底数？（求出1000之内全部的彻底数）
方法一
# coding:utf-8
a=range(1,1001)
b=range(1,1001)
result=[]
for i in a:
tmp=[]
for k in b:
if k<i:
if not i%k:
tmp.append(k)
else:
continue
else:
break
count=0
for m in tmp:
count=count+m
if count==i:
result.append(i)
else:
continue
print result复制代码
上面的方法中，求tmp这个list中元素的和时，咱们也能够经过sum函数实现，具体以下：
方法二
# coding:utf-8
a=range(1,1001)
b=range(1,1001)
result=[]
for i in a:
tmp=[]
for k in b:
if k<i:
if not i%k:
tmp.append(k)
else:
continue
else:
break
count=sum(tmp)
if count==i:
result.append(i)
else:
continue
print result复制代码
#方法三
#方法三是直接经过遍历出list a中的元素后，生成一个小于次元素的list，而后取余
#对于range(1,0) 个人解释是：range的理解应该是range是先用咱们指定的条件生成一个列表，
而后用for循环取出来（此句出自python核心编程第八章），range(1,0),start=1,stop=0,step=1,
这样的条件生成的#的列表实际是上空的，即为False复制代码
a=range(1,1001)
perfect=[]
for i in a:
tmp=[]
for k in range(1,i):
if not i%k:
tmp.append(k)
count=sum(tmp)
if count==i:
perfect.append(i)
print perfect复制代码
方法四（史上最简单的方式了）
for i in range(1,1000):
s=0
for k in range(1,i):
if i%k==0:
s=s+k
if i==s:
print i复制代码
2八、最大公约数和最小公倍数
掌握结合python循环求解最大公约数
def hcf(x, y):
'''该函数返回两个数的最大公约数'''
# 获取最小值
if x > y:
smaller = y
else:
smaller = x
for i in range(1, smaller + 1):
if ((x % i == 0) and (y % i == 0)):
hcf = 1
return hcf
# 用户输入两个数字
num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))
print(num1, "和", num2, "的最大公约数为", hcf(num1, num2))复制代码
最小公倍数
# 定义函数
def lcm(x, y):
#获取最大的数
if x > y:
greater = x
else:
greater = y
while(True):
if ((greater % x == 0) and (greater % y == 0)):
lcm = greater
break
greater += 1
return lcm
# 获取用户输入
num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))
print(num1, "和", num2, "的最小公倍数为", lcm(num1, num2)) 复制代码
2九、浮屠增级
掌握使用枚举解决浮屠增级问题
30、千钱百鸡
掌握使用枚举法解决千钱百鸡问题
百钱百鸡：我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
译文：公鸡一只5元，母鸡一只3元，小鸡3只1元。如何用100元买100只鸡。其中公鸡，母鸡，小鸡的数量各是多少
穷举法
分析：公鸡最多买：20只，母鸡最多买：33只。设：公鸡x只，母鸡y只，小鸡z只
则 0<x<20, 0<y<33, z=100-x-y
for x in range(0,20):
for y in range(0,33):
z=100-x-y
if 5*x+3*y+z/3 == 100:
print('公鸡：%s 母鸡：%s 小鸡：%s'%(x, y, z))复制代码
随机数法
分析：公鸡最多买：20只，母鸡最多买：33只。设：公鸡x只，母鸡y只，小鸡z只
import random
while True:
x = random.randrange(0,20)
y = random.randrange(0,33)
z = random.randrange(0,100)
if 5*x+3*y+z/3 == 100 and x+y+z == 100:
print('公鸡:',x)
print('母鸡:',y)
print('小鸡:',z)复制代码
3一、猜数字的小游戏
# python实现猜数字游戏，主要用于练习for循环和if else。
# 需求以下：# 一、随机生成一个1-100之间的数。
# 二、7次猜数字的机会，若是没有猜正确，游戏结束。
# 三、输入字母q，则退出游戏。
import random
num = random.randint(1,100)
guess_chances = 7
print('您只有7次猜数字的机会哦！')
for i in range(1,guess_chances + 1):
print('这是第'+ str(i) + '次猜数字')
guess = input('请输入数字：')
if guess.isdigit():
guess = int(guess)
if guess < num:
print('您输入的数字过小了，您还有' + str(guess_chances - i)+'次机会，请从新输入：')
elif guess > num:
print('您输入的数字太大了，您还有' + str(guess_chances - i)+'次机会，请从新输入：')
elif guess == num:
print('恭喜您猜对了')
break
elif guess == 'q':
print('退出游戏！')
break
else:
print('输入的内容必须为整数，请从新输入：')
while (guess_chances - i) == 0:
print('您输入已经超过7次，游戏结束！')
break复制代码
随机数字小游戏
import random
i = 1
a = random.randint(0,100)
b = int(input('请输入0-100中的一个数字\n而后查看是否与电脑同样:'))
while a != b:
if a > b:
print('你第%d次输入的数字小于电脑随机数字'%i)
b = int(input('请再次输入数字:'))
else:
print('你第%d次输入的数字大于电脑随机数字'%i)
b = int(input('请再次输入数字:'))
i += 1
else:
print('恭喜你,你第%d次输入b的数字与电脑的随机数字%d同样'%(i,b))复制代码
3二、打印图形
三角形
for i in range(10):
for j in range(1,i):
print("*",end="")
print()
for i in range(10):
for j in range(10-i):
print("*",end="")
print()复制代码
正方形
for i in range(5):
for j in range(10):
print("*",end="")
print()复制代码
正三角形
for i in range(1,6):
for j in range(1,6-i):
print(" ",end="")
for k in range(1,i+1):
print("* ",end="")
print("")复制代码
3三、请编写1-100全部数的和。
#for循环
sum = 0
for i in range(1,101):
sum += i
print(sum)
#while循环
n = 1
sum = 0while n < 101:
sum += n
n += 1
print(sum)复制代码
3四、编写代码，实现求100-200里面全部的素数
sum = 0
for i in range(100,200):
flag = True
for j in range(2,i):
if i % j == 0:
flag = False
break
if(flag):
print(i,"是素数")
sum += 1
print("一共",sum,"个素数")复制代码
3五、汉诺塔（）
ta1 = [i for i in range(10,0,-1)]
ta2 = []
ta3 = []
n = len(ta1)
def move(n, ta1,ta2,ta3):
if n == 1:
ta3.append(ta1.pop())
else:
move(n - 1,ta1,ta3,ta2)
ta3.append(ta1.pop())
move(n-1,ta2,ta1,ta3)
move(n,ta1,ta2,ta3)
print(ta1)
print(ta3)复制代码
3六、字符串，列表，字典，综合实战1
列出1到20的数字，如果3的倍数就用apple代替，如果5的倍数就用orange代替，#若既是3的
倍数又是5的倍数就用appleorange代替。注意：只能用2行代码搞定
咱们最常常想到的应该是这种方法：
for i in range(1,21):
if (i%3==0 and i%5!=0):
i = 'apple'
elif (i%5==0 and i%3!=0):
i = 'orange'
elif (i%3==0 and i%5==0):
i = 'appleorange'
print(i,end=',')复制代码
经典的写法：
for i in range(1,21):
print('apple'[i%3*5::]+'orange'[i%5*6::] or i,end=" , ")复制代码
深刻解析:
-
其实算法很简单，就是i对3和5取模，可是能2行搞定，精妙之处在于利用了字符串切片的一个特性
-
好比apple[5::],结果为空,为何，由于下标5的位置不存在，因此为空，那么apple[i%3*5],意味着i在1,2,3,4的时候取3的模,结果是1,2,0,1,而后用一个很巧妙的方法*5(5实际上是apple的长度)，作了一个偏移
-
这样在3的整数的时候下面0*5=0，也就是从0开始取apple,而1,2,4的时候取3模是1,2,1,再乘以5就越界了因此取的apple为空.
-
同理orange也是这样的，取5的模，而后*6(6是orange的长度)偏移
-
最后用了一个or i ，先来讲一下or, Python 对or 的判断是,print A or B ,若A为true,则结果为True,若A是false再判断B,B是true，则结果是True
-
print 'apple'[i%3*5::]+'orange'[i%5*6::] or i，表示当apple和orange偏移越界了就都为空的时候，就取i的值,是1,2,4,7...
3七、字符串，列表，字典，综合实战2
好比说我有一串字符串人名:names=' Kunpen Ji, Li XIAO, Caron Li, Donl SHI, Ji ZHAO, Fia YUAN Y, Weue DING, Xiu XU, Haiying WANG, Hai LIN, Jey JIANG, Joson WANG E, Aiyang ZHANG, Hay MENG, Jak ZHANG E, Chang Zhang, Coro ZHANG',我但愿能作到下面3点
问题1：排序,按照名字A-Z排序
问题2：找出里面姓”ZHANG”有几个
问题3：找出名字里面最长的人
首先咱们要作的对字符串进行分割去掉','而后就变成了一个长的列表，而后对列表进行排序，第一个问题就解决了.
for index,n in enumerate(sorted(names.split(','))):
print(index+1,n)复制代码
分析问题2:
接下来，咱们须要找出姓"ZHANG",由于名字里面有英文名字和中文名字，有的后面还跟E/Y，因此咱们先定义一个函数，把分割后的新的名字列表，取出每个名字，而后解析，翻转，用推导列表造成一个新的名字列表，而后再用字符串里的.startswith("ZHANG")取出符合的名字
def _change(text):
new_s1=text.split()[0:2]
reverse_s1=new_s1[::-1]
return ' '.join(reverse_s1)
new_names_lists=[_change(name) for name in names.split(',')]
names_with_ZHANG=[name for name in new_names_lists if name.startswith('ZHANG')]
print(names_with_ZHANG)
>>['ZHANG Aiyang', 'ZHANG Jak', 'ZHANG Coro']复制代码
分析问题3：
接下来，咱们只要把名字和名字的长度，造成一个新的字典,名字:名字长度，而后就能够很是容易取到最大的人名了.
names_dict={name:len(name) for name in sorted(names.split(',')) }
print(max(zip(names_dict.values(),names_dict.keys())))
>>(13, ' Joson WANG E')复制代码
下
一、turtle库的使用
Turtle，也叫海龟渲染器，使用Turtle库画图也叫海龟做图。Turtle库是Python语言中一个很流行的绘制图像的函数库。海龟渲染器，和各类三维软件都有着良好的结合。功能强大，使用方便。该渲染器的特点在于其渲染速度能够优海龟渲染器，和各类三维软件都有着良好的结合。
（1）画圆
（circle() 有三个参数：radius必须，extent--角度 与step--图形(无关紧要)） 复制代码
一、radius -- 任意大小圆
import turtle
t = turtle.Turtle()
t.circle(x) 复制代码
二、radius extent --- 任意大小圆得部分
# 半圆
import turtle
t = turtle.Turtle()
t.circle(100,180) 复制代码
三、
radius extent steps # 可实现多边形的绘制
import turtle
t = turtle.Turtle()
t.circle(100,180,3) 复制代码
四、
radius step #三角形
import turtle
t = turtle.Turtle()
t.circle(100,steps=3) 复制代码
五、实心圆
t.hot() 复制代码
（2）画笔的转换（shape()函数的使用）可填写以下图形：
一、海龟 turtle
二、等边三角形 triangle 等腰三角形 arrow
三、正方形 square
四、实心圆 circle
（3）画笔的绘制状态
一、pendown()
二、penup()
三、pensize() #可直接写数字
（4）画笔的运动状态
一、t.forward() / t.fd()箭头方向前进
二、t.backward() / t.bd() ------后退
三、t.left() / t.right()
四、t.goto() / t.setpos() ----移到某一位置
五、t.setx() / t.sety() ---- 改变x坐标或者Y坐标
六、t.home() ---- 回到初始位置
七、t.position() / t.pos() print(t.pos)---返回当前箭头坐标
（4）画笔的隐藏与显示
一、隐藏 hideturtle() / ht()
二、显示 showturtle() / st()
（5）颜色
一、turtle.begin_fill()：在填充图形前访问这个方法
二、turtle.end_fill()：在最后调用begin_fill以前填充绘制的图形
三、turtle.color(c)：设置笔的颜色
四、turtle.fillcolor(c)：设置笔填充颜色
一、在begin_fill()和end_fill()之间设置的turtle.color(c)和turtle.fillcolor(c)均可以做为填充色 二、将turtle.color(c)提到前面，不写begin_fill()和end_fill()，则就不会实现填充
三、将turtle.color(c)提到前面，并在begin_fill()和end_fill()之间设置turtle.fillcolor(c)，那么图形的边框和内部填充颜色分别对应于color和fillcolor
四、在begin_fill()和end_fill()之间设置不一样的turtle.color(c)和turtle.fillcolor(c)，则以排序在后面的为准去填充图形
补充：
（1）
input # 输入的数字为字符串
import turtle
num = int(input(""))
t = turtle.Turtle()
t.circle(num) 复制代码
（2）
random
print( random.randint(1,10) ) # 产生 1 到 10 的一个整数型随机数
print( random.random() ) # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) ) # 产生 1.1 到 5.4 之间的随机浮点数，区间能够不是整数
print( random.choice('tomorrow') ) # 从序列中随机选取一个元素
print( random.randrange(1,100,2) ) # 生成从1到100的间隔为2的随机整数
turtle、input、random可相互结合演示 复制代码
扩展：
1.forward() | fd():向前移动指定的距离。参数：一个数字（integer or float)）。
turtle.forward(25)复制代码
2.backward() | bk() | back():向后移动指定的距离。参数：一个数字（integer or float)）。
turtle.backward(30)复制代码
3.right() | rt():以角度单位向右转动。参数：一个数字（integer or float)）。单位默认为度数，能够经过degrees()和radians()进行设置。
turtle.right(45)复制代码
4.left() | lt():以角度单位向左转动。参数：一个数字（integer or float)）。单位默认为度数，能够经过degrees()和radians()进行设置。
turtle.left(45) 复制代码
5.goto() | steps() | setposition()：移动到绝对位置，若是笔落下，画线，不改变方向。参数：x-一个数字或一对数字。y-一个数字或None。
turtle.setpos(60,30)#60.00，30.00）复制代码
6.setx():设置第一个坐标的值即X方向。参数：一个数字（integer or float)）。
turtle.setx(10)#（10.00，0.00）复制代码
7.sety():设置第二个坐标的值即Y方向。参数：一个数字（integer or float)）。
turtle.sety(10)#（0.00，10.00）复制代码
8.setheading() | seth(): 将方向设置为to_angle.就是东西南北方向。具体以下：标准模式：0 - 东 90 - 北 180 - 西 270 - 南 标志模式 0- 北 90- 东 180- 南 270 - 西
turtle.setheading(90)复制代码
9.home() : 移动到原点 - 坐标（0，0）：并将其标题设置为其起始方向（取决于模式）。
turtle.home()# （0.00，0.00）复制代码
10.circle()：绘制一个给定半径的圆。参数：radius-一个数字（半径，若是值为正则逆时针，负数为顺时针），extent-一个数字（）steps- 执行的步数。
turtle.circle(120,180,5)复制代码
11.dot() ：用颜色画出一个直径大小的圆点。参数：size-一个大于1的整数，可None。默认用的是pensize+4和2*pensize的最大值，color-颜色值
turtle.dot(20, "blue")复制代码
12.stamp():将当前位置上的形状复制到画布上返回stamp_id.能够调用，能够删除。
turtle.stamp()复制代码
13.clearstamp():删除stamp()返回来的值。参数：stampid。
14.clearstamps():删除所有stamp()的值。参数：stampid。
15.undo():撤销最后的动做。
16.speed():将速度设置为0..10范围内整数。若是没有参数，则返回当前速度。若是大于10或
者小于0.5，则速度设置为0 。
- 最快”：0 ：直接成图，没有动画效果
- “快”：10：大概一秒
- “正常”：6：
- “慢”：3
- “最慢”：1
17:position() | pos(): 返回当前的位置。
turtle.pos()
# （0.00，0.00）复制代码
18.towards(): 返回当前位置同指定位置之间的角度。参数：x-一个数字或一对数字或一个实
例的向量,y-若是x是数字，则为数字，不然为None。
turtle.goto(10,10)
tw = turtle.towards(0,0)
print(tw)
# 225复制代码
19.xcor():返回x坐标。 ycor():返回y坐标。
20.heading(): 返回当前的方向值。
21.distance():返回x，y两个点的直线距离
22.degrees():设置一整圈的度数。默认是360度。
23.radians():将角度测量单位设置为弧度。至关于 degrees(2*math.pi)
24.pendown() | pd() | down():放下笔，移动的时候绘图。
25.penup() | pu() | up():将提起笔，移动时无图。
26.pensize():设置线条的粗细。参数：width-一个正数
27.pen():使用键值对设置笔的属性：
“shown”: True/False
“pendown”: True/False
“pencolor”: 颜色字符串或者颜色值
“fillcolor”: 颜色字符串或者颜色值
“pensize”: 正数 “speed”: 速度范围为0..10的数字
“resizemode”: “auto” or “user” or “noresize”
“stretchfactor”: (positive number, positive number)
“outline”: 正数
“tilt”: 正数
28.isdown()：若是笔中止返回True，反之False
29.pencolor():设置笔的颜色。
30.fillcolor():笔的填充色。
31.color():同时设置pencolor和fillcolor
32.filling():返回fillstate状态，若是填充则返回True，反之False。
33.begin_fill():在绘制要填充的形状前调用。固然在调用完还须要end_fill()。
34.reset():重置，将屏幕中的图纸删除，从新居中并将全部变量设置为默认值。
35.clear():删除图纸。对属性不作操做。
36.write():写文本。参数：arg-要写入的对象。move-是否移动。align-对齐方式：left，right，center。font-字体。fontname，fontsize，fonttype。
37.ideturtle() | ht() :删隐藏乌龟的形状，在作复杂绘图的时候隐藏的时候有利于提升绘图速度。
38.showturtle() | st():显示乌龟的形状。
39.isvisible():乌龟是否可见。
若是可见返回True，反之则False。 40.shape():设置乌龟的图形形状，取值:“arrow”, “turtle”, “circle”, “square”, “triangle”, “classic” 41.isvisible():乌龟是否可见。若是可见返回True，反之则False。
42.resizemode():参数：rmode取值："auto"，"user","noresize".
43.shapesize() | turtlesize() : 返回笔的属性。
44.shearfactor(): 设置或者返回但钱的剪切因子。
45.tilt():旋转由turtle shape角度从当前的倾斜角度。
46.settiltangle():不管当前的倾斜角度如何，旋转乌龟指向 angle 指定的方向。参数：angle -数字。已弃用
47.tiltangle():设置或者返回当前的倾斜角度。参数：angle - 数字
48.shapetransform():设置或返回乌龟的形状的当前转换矩阵。
49.get_shapepoly():返回当前形状的坐标。
50.onclick():鼠标点击事件。
参数：fun-一个带有两个参数的函数，这些参数将与画布上单击点的坐标一个调用。num-鼠标按钮的数量，默认为1(左键)。add- True的时候将添加新的绑定。不然替换之前的绑定。
51.onrelease():鼠标释放事件。参数同点击事件。
52.ondrag():鼠标移动事件。参数同点击事件。
53.begin_poly(): 开始记录多边形的顶点。
54.end_poly():中止记录多边形的顶点。
55.get_poly():返回最后记录的多边形。
56.clone():建立并返回具备相同位置等等属性的乌龟克隆。
57.getturtle() | getpen() :获取trutle对象自己。
58.getscreen()：返回正在绘制的对象。
59.setundobuffer(): 设置或禁用中断器。
参数： size-整数。若是大小是None，则禁用缓冲区。 60.undobufferentries():返回undobuffer中的条目数。
61.bgcolor():设置或者返回当前的TurtleScreen的背景颜色。
62.bgpic():设置背景图片。参数： picname-文件名。
62.delay(): 设置或返回以毫秒为单位的绘制延迟，延迟越大，绘图越慢。
63.ontimer():定时器。
64.mainloop() | done() :开始循环 。
65.textinput() | numinput():弹出一个输入字符串和数字的窗口。
66.mode(): 三种方式：“standard”, “logo” or “world”
案例：时钟
# coding=utf-8
import turtle
from datetime import *
# 抬起画笔，向前运动一段距离放下
def Skip(step):
turtle.penup()
turtle.forward(step)
turtle.pendown()
def mkHand(name, length):
# 注册Turtle形状，创建表针Turtle
turtle.reset()
Skip(-length * 0.1)
# 开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。
turtle.begin_poly()
turtle.forward(length * 1.1)
# 中止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。
turtle.end_poly()
# 返回最后记录的多边形。
handForm = turtle.get_poly()
turtle.register_shape(name, handForm)
def Init():
global secHand, minHand, hurHand, printer
# 重置Turtle指向北
turtle.mode("logo")
# 创建三个表针Turtle并初始化
mkHand("secHand", 135)
mkHand("minHand", 125)
mkHand("hurHand", 90)
secHand = turtle.Turtle()
secHand.shape("secHand")
minHand = turtle.Turtle()
minHand.shape("minHand")
hurHand = turtle.Turtle()
hurHand.shape("hurHand")
for hand in secHand, minHand, hurHand:
hand.shapesize(1, 1, 3)
hand.speed(0)
# 创建输出文字Turtle
printer = turtle.Turtle()
# 隐藏画笔的turtle形状
printer.hideturtle()
printer.penup()
def SetupClock(radius):
# 创建表的外框
turtle.reset()
turtle.pensize(7)
turtle.pencolor("#ff5500")
turtle.fillcolor("green")
for i in range(60):
Skip(radius)
if i % 5 == 0:
turtle.forward(20)
Skip(-radius - 20)
Skip(radius + 20)
if i == 0:
turtle.write(int(12), align="center", font=("Courier", 14, "bold"))
elif i == 30:
Skip(25)
turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
Skip(-25)
elif (i == 25 or i == 35):
Skip(20)
turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
Skip(-20)
else:
turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
Skip(-radius - 20)
else:
turtle.dot(5)
Skip(-radius)
turtle.right(6)
def Week(t):
week = ["星期一", "星期二", "星期三",
"星期四", "星期五", "星期六", "星期日"]
return week[t.weekday()]
def Date(t):
y = t.year
m = t.month
d = t.day
return "%s-%d-%d" % (y, m, d)
def Tick():
# 绘制表针的动态显示
t = datetime.today()
second = t.second + t.microsecond * 0.000001
minute = t.minute + second / 60.0
hour = t.hour + minute / 60.0
secHand.setheading(6 * second)
minHand.setheading(6 * minute)
hurHand.setheading(30 * hour)
turtle.tracer(False)
printer.forward(65)
printer.write(Week(t), align="center",
font=("Courier", 14, "bold"))
printer.back(130)
printer.write(Date(t), align="center",
font=("Courier", 14, "bold"))
printer.home()
turtle.tracer(True)
# 100ms后继续调用tick
turtle.ontimer(Tick, 100)
def main():
# 打开/关闭龟动画，并为更新图纸设置延迟。
turtle.tracer(False)
Init()
SetupClock(160)
turtle.tracer(True)
Tick()
turtle.mainloop()
if __name__ == "__main__":
main()复制代码
相关文章
- 1. Mac经常使用功能整理
- 2. POI经常使用功能整理
- 3. MySQL经常使用功能整理
- 4. java经常使用算法整理
- 5. 经常使用位运算整理
- 6. Spark RDD经常使用算子整理
- 7. ThinkPHP5经常使用功能和语法
- 8. nodejs经常使用语法及功能
- 9. CSS3经常使用功能的写法
- 10. CSS3 经常使用功能的写法
- 更多相关文章...
- • 使用Redis和Lua的原子性实现抢红包功能 - 红包项目实战
- • PHP imageantialias - 是否使用抗锯齿（antialias）功能 - PHP参考手册
- • 使用Rxjava计算圆周率
- • Java Agent入门实战（三）-JVM Attach原理与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 跳槽面试的几个实用小技巧，不妨看看！
- 2. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 3. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 4. 如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 5. Mac OS非兼容Windows软件运行解决方案——“以VMware & Microsoft Access为例“
- 6. 封装 pyinstaller -F -i b.ico excel.py
- 7. 数据库作业三ER图待完善
- 8. nvm安装使用低版本node.js(非命令安装)
- 9. 如何快速转换图片格式
- 10. 将表格内容分条转换为若干文档
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Mac经常使用功能整理
- 2. POI经常使用功能整理
- 3. MySQL经常使用功能整理
- 4. java经常使用算法整理
- 5. 经常使用位运算整理
- 6. Spark RDD经常使用算子整理
- 7. ThinkPHP5经常使用功能和语法
- 8. nodejs经常使用语法及功能
- 9. CSS3经常使用功能的写法
- 10. CSS3 经常使用功能的写法