上
1、冒泡排序
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())复制代码
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)复制代码
2、编程用sort进行排序，然后从最后一个元素开始判断，去除重复数字
方法一：
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)复制代码
3、打印九九乘法表
for 循环
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参数的值，可以取消在末尾输出回车符，实现不换行。复制代码
for i in range(10):
for j in range(i+1):
print("%d*%d=%2d "%(i,j,i*j),end="")
print()复制代码
while循环
n = 1
while n <= 9:
m = 1
while m<= 9:
print("%d*%d=%2d "%(n,m,n*m), end="")
m += 1
print()
n += 1复制代码
4、计算阶乘
方法一：
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()复制代码
方法二：
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))复制代码
5、计算x的n次方的方法
def power(x,n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print(power(2,3))复制代码
6、计算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]))复制代码
7、将list中字符串变成小写
L = ['Hello','World','IBM','Apple']
L2 = []
for s in L:
L2.append(s.lower())
print(L2)复制代码
8、把原字典的键值对颠倒并生产新的字典
dict1 = {"A":"a","B":"b","C":"c"}
dict2 = {y:x for x,y in dict1.items()}
print(dict2)复制代码
9、替换列表中所有的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)复制代码
10、打印每个名字
L = ["James","Meng","Xin"]
for i in range(len(L)):
print("Hellow,%s"%L[i])
复制代码
善于使用 range() ，会使问题变得简单
11、合并去重
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)))复制代码
12、随机生成验证码
方法一：
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)复制代码
13、计算平方根
num = float(input('请输入一个数字: '))
num_sqrt = num ** 0.5
print(' %0.2f 的平方根为 %0.2f'%(num,num_sqrt))复制代码
14、判断字符串是否只由数字组成
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对象复制代码
15、判断奇偶数
方法一：
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复制代码
16、判断闰年
方法一：
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)复制代码
17、获取最大值
方法一：
# 获取最大值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))复制代码
18、斐波那契数列
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）
斐波那契数列，难点在于算法，还有如果变成生成器，generator，就要用for循环去遍历可迭代的generator
方法一：递归法
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复制代码
19、十进制转二进制、八进制、十六进制
# 获取输入十进制数
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("1、相加")
print("2、相减")
print("3、相乘")
print("4、相除")
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("非法输入")复制代码
21、生成日历
# 引入日历模块
import calendar
# 输入指定年月
yy = int(input("输入年份："))
mm = int(input("输入月份："))
# 显示日历
print(calendar.month(yy, mm))复制代码
22、字符串判断
#测试实例一
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()) 复制代码
23、字符串大小写转换
str = "https://juejin.im/user/"
print(str.upper()) # 把所有字符中的小写字母转化成大写字母
print(str.lower()) # 把所有字符中的大写字母转化小写字母
print(str.capitalize()) # 把第一个字母转化成大写字母，其余小写
print(str.title()) # 把每个单词的第一个字母转化为大写，其余为小写复制代码
24、计算每个月的天数
import calendar
monthRange = calendar.monthrange(2019,11)
print(monthRange)复制代码
25、获取昨天的日期
# 引入 datetime 模块
import datetimedef getYesterday():
today = datetime.date.today()
oneday = datetime.timedelta(days=1)
yesterday = today - oneday
return yesterday
print(getYesterday())复制代码
26、趣味自然数
掌握使用自定义函数实现水仙花数和完全数
水仙花数（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复制代码
27、完全数
如果一个数恰好等于它的因子之和，则称该数为“完全数” 。各个小于它的约数（真约数,列出某数的约数，去掉该数本身，剩下的就是它的真约数）的和等于它本身的自然数叫做完全数（Perfect number），又称完美数或完备数。
例如：
第一个完全数是6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。
第二个完全数是28，它有约数1、2、4、7、14、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
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
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复制代码
28、最大公约数和最小公倍数
掌握结合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)) 复制代码
29、浮屠增级
掌握使用枚举解决浮屠增级问题
30、千钱百鸡
掌握使用枚举法解决千钱百鸡问题
31、猜数字的小游戏
# python实现猜数字游戏，主要用于练习for循环和if else。
# 需求如下：# 1、随机生成一个1-100之间的数。
# 2、7次猜数字的机会，如果没有猜正确，游戏结束。
# 3、输入字母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))复制代码
32、打印图形
三角形
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("")复制代码
33、请编写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)复制代码
34、编写代码，实现求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,"个素数")复制代码
35、汉诺塔（）
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)复制代码
36、列出1到20的数字，若是3的倍数就用apple代替，若是5的倍数就用orange代替，若既是3的倍数又是5的倍数就用appleorange代替。注意：只能用2行代码搞定
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...
37、比如说我有一串字符串人名:names=' Kunpen Ji, Li XIAO, Caron Li,
比如说我有一串字符串人名: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')复制代码
下
1、turtle库的使用
Turtle，也叫海龟渲染器，使用Turtle库画图也叫海龟作图。Turtle库是Python语言中一个很流行的绘制图像的函数库。海龟渲染器，和各种三维软件都有着良好的结合。功能强大，使用方便。该渲染器的特色在于其渲染速度可以优海龟渲染器，和各种三维软件都有着良好的结合。
（1）画圆
（circle() 有三个参数：radius必须，extent--角度 与step--图形(可有可无)） 复制代码
1、radius -- 任意大小圆
import turtle
t = turtle.Turtle()
t.circle(x) 复制代码
2、radius extent --- 任意大小圆得部分
# 半圆
import turtle
t = turtle.Turtle()
t.circle(100,180) 复制代码
3、
radius extent steps # 可实现多边形的绘制
import turtle
t = turtle.Turtle()
t.circle(100,180,3) 复制代码
4、
radius step #三角形
import turtle
t = turtle.Turtle()
t.circle(100,steps=3) 复制代码
5、实心圆
t.hot() 复制代码
（2）画笔的转换（shape()函数的使用）可填写如下图形：
1、海龟 turtle
2、等边三角形 triangle 等腰三角形 arrow
3、正方形 square
4、实心圆 circle
（3）画笔的绘制状态
1、pendown()
2、penup()
3、pensize() #可直接写数字
（4）画笔的运动状态
1、t.forward() / t.fd()箭头方向前进
2、t.backward() / t.bd() ------后退
3、t.left() / t.right()
4、t.goto() / t.setpos() ----移到某一位置
5、t.setx() / t.sety() ---- 改变x坐标或者Y坐标
6、t.home() ---- 回到初始位置
7、t.position() / t.pos() print(t.pos)---返回当前箭头坐标
（4）画笔的隐藏与显示
1、隐藏 hideturtle() / ht()
2、显示 showturtle() / st()
（5）颜色
1、turtle.begin_fill()：在填充图形前访问这个方法
2、turtle.end_fill()：在最后调用begin_fill之前填充绘制的图形
3、turtle.color(c)：设置笔的颜色
4、turtle.fillcolor(c)：设置笔填充颜色
1、在begin_fill()和end_fill()之间设置的turtle.color(c)和turtle.fillcolor(c)都可以作为填充色 2、将turtle.color(c)提到前面，不写begin_fill()和end_fill()，则就不会实现填充
3、将turtle.color(c)提到前面，并在begin_fill()和end_fill()之间设置turtle.fillcolor(c)，那么图形的边框和内部填充颜色分别对应于color和fillcolor
4、在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()复制代码
194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
