[Python知识库]Python汇总学习篇

1.画一个正放形

import turtle
turtle.pensize(4)
turtle.pencolor('black')
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.mainloop()

2.将华氏温度转换成摄氏温度

#将华氏温度转换成摄氏温度
f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8                        #100.0华氏度 = 37.8摄氏度
print('%.1f华氏度 = %.1f摄氏度' % (f, c))  

3. 字符a与97的转换，97与字符a的转换

#转换 字符a与97的转换，97与字符a的转换
print(ord("a"))   #97
print(chr(97))    #"a"

4. 闰年判断

#闰年判断
year = int(input('请输入年份: '))
is_leap = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(is_leap)

5. 用户名和密码验证

#用户名和密码验证
username = input('请输入用户名: ')
password = input('请输入口令: ')
#用户名是admin且密码是123456则身份验证成功否则身份验证失败
if username == 'admin' and password == '123456':
    print('身份验证成功!')
else:
    print('身份验证失败!')

6. if语法并且输出结果显示格式为带2位小数的浮点数

#if语法并且输出结果显示格式为带2位小数的浮点数
x = float(input("请输入x:"))
if x>1:
    y = 3*x-5
elif -1<=x<=1:
    y=x+2
elif x<-1:
    y=5*x+3
print("f(x)=%.2f" % y)

7. 英寸和厘米之间的转换

#英寸和厘米之间的转换
value = float(input('请输入长度: '))
unit = input('请输入单位: ')
if unit == 'in' or unit == '英寸':
    print('%f英寸 = %f厘米' % (value, value * 2.54))
elif unit == 'cm' or unit == '厘米':
    print('%f厘米 = %f英寸' % (value, value / 2.54))
else:
    print('请输入有效的单位')

8. 从1加到100

#从1加到100
#range(1, 101)：可以用来产生1到100范围的整数，相当于前面是闭区间后面是开区间。
#range(1, 101, 2)：可以用来产生1到100的奇数，其中2是步长，即每次数值递增的值。
#range(100, 0, -2)：可以用来产生100到1的偶数，其中-2是步长，即每次数字递减的值
sum=0
for i in range(1,101):
    sum+=i
print(sum)

9.产生1到100的随机数

#产生1到100的随机数
import random
answer = random.randint(1, 100)

10.判断一个数是不是素数

#判断一个数是不是素数
from math import sqrt
num = int(input('请输入一个正整数: '))
end = int(sqrt(num))
is_prime = True
for x in range(2, end + 1):
    if num % x == 0:
        is_prime = False
        break
if is_prime and num != 1:
    print('%d是素数' % num)
else:
    print('%d不是素数' % num)

11.生成9*9乘法表

#生成9*9乘法表
for i in range(1,10):
    for j in range(1,10):
        print("%d*%d=%d"%(i,j,i*j),end="\t")
    print()
row = 1
while row<=9:
    col =1
    while col<=row:
        print("%d*%d=%d\t"%(col,row,col*row),end="")  #\t是制表符，保留有4个空格
        col+=1
    print("")
    row+=1

12.字符串操作函数

s1 = 'hello ' * 3
print(s1) #输出： hello hello hello 
s2 = 'world'
s1 += s2
print(s1) #输出： hello hello hello world
print('ll' in s1) #输出： True
print('good' in s1) #输出： False

12.1字符串切片

str2 = 'abc123456'
#从字符串中取出指定位置的字符(下标运算)
print(str2[2]) #输出： c
#字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5]) #输出： c12
print(str2[2:]) #输出： c123456
print(str2[2::2]) #输出： c246
print(str2[::2]) #输出： ac246
print(str2[::-1]) #输出： 654321cba
print(str2[-3:-1]) #输出： 45
#检查字符串是否由数字构成
print(str2.isdigit())  #输出： False
#检查字符串是否以字母构成
print(str2.isalpha())  #输出： False
#检查字符串是否以数字和字母构成
print(str2.isalnum())  #输出： True

12.2字符串函数

str1 = 'hello, world!'
#w在字符串中出现的次数
num = str1.count("w")
print(num) #输出：1
#通过内置函数len计算字符串的长度
print(len(str1)) #输出： 13
#获得字符串首字母大写的拷贝
print(str1.capitalize()) #输出： Hello, world!
#获得字符串每个单词首字母大写的拷贝
print(str1.title()) #输出： Hello, World!
#全部转换为小写
print(str1.lower())  #输出:hello, world!
#获得字符串变大写后的拷贝
print(str1.upper())   #输出： HELLO, WORLD!
#从字符串中查找子串所在位置
print(str1.find('or')) #输出： 8
print(str1.find('shit')) #输出： -1
#与find类似但找不到子串时会引发异常
print(str1.index('or')) #输出： print(str1.index('shit'))
#检查字符串是否以指定的字符串开头
print(str1.startswith('He')) #输出： False
print(str1.startswith('hel')) #输出： True
#检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) #输出： True
#将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*')) #输出:******************hello, world!*******************
#将字符串以指定的宽度靠右放置左侧填充指定的字符 
print(str1.rjust(50, ' ')) #输出：                                     hello, world!

#","分割abc
print(",".join("abc")) #输出: a,b,c
#":"分割abc
print(":".join(["a","b","c"])) #输出: a:b:c

str3 = '  jackfrued@126.com '
print(str3)
#获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())
#用"@"进行拆分成一list
print(str3.split("@")) #输出:['  jackfrued', '126.com ']
#替换replace,将com替换为cn
print(str3.replace("com","cn")) #输出:jackfrued@126.cn
#str3是否包含com
print(str3.__contains__("com")) #输出:True

12.3正则表达式

#导入正则表达式功能块
import re
#找到字符串中匹配的数字，以列表的形式返回
#前面填写的是正则表达
#匹配数字
print(re.findall("\d","nihao123Tianxia")) #输出:['1', '2', '3']

#匹配a-z的字符串
print(re.findall("[a-z]","nihao123Tianxia")) #输出:['n', 'i', 'h', 'a', 'o', 'i', 'a', 'n', 'x', 'i', 'a']

#匹配字符串m
print(re.findall("m","nihao123Tianxia")) #输出:[]

#输出0-9的数字
print(re.findall("[0-9]","nihao123Tianxia")) #输出:['1', '2', '3']

#输出小写的a-z和大写的A-Z
print(re.findall("[a-zA-z]","nihao123Tianxia")) #输出：['n', 'i', 'h', 'a', 'o', 'T', 'i', 'a', 'n', 'x', 'i', 'a']

#输出除了0-9以外的
print(re.findall("[^0-9]","nihao123Tianxia"))#输出:['n', 'i', 'h', 'a', 'o', 'T', 'i', 'a', 'n', 'x', 'i', 'a']

#输出x开头z结尾，中间是c或w
print(re.findall("x[cw]z","xyz,xcz,xwz")) #输出:['xcz', 'xwz']

#输出x开头z结尾，中间不是c或w
print(re.findall("x[^cw]z","xyz,xcz,xwz")) #输出:['xyz']

#显示所有的非数字
print(re.findall("\D","nihao123Tianxia")) #输出:['n', 'i', 'h', 'a', 'o', 'T', 'i', 'a', 'n', 'x', 'i', 'a']

#显示所有的特殊字符(\n \t $ 空格都是特殊字符，但下划线不是特殊字符)
print(re.findall("\W","nihao123\nTian\txia")) #输出:['\n', '\t']

#显示所有的非特殊字符(\n \t $,空格都是特殊字符，但下划线不是特殊字符)
print(re.findall("\w","nihao123\nTian\txia")) #输出:['n', 'i', 'h', 'a', 'o', '1', '2', '3', 'T', 'i', 'a', 'n', 'x', 'i', 'a']

#显示所有的制表符(\n \t $,空格都是特殊字符，但下划线不是特殊字符)
print(re.findall("\s","nihao123\nTian\txia")) #输出:['\n', '\t']

#显示所有的非制表符(\n \t $,空格都是特殊字符，但下划线不是特殊字符)
print(re.findall("\S","nihao123\nTian\txia")) #输出:['n', 'i', 'h', 'a', 'o', '1', '2', '3', 'T', 'i', 'a', 'n', 'x', 'i', 'a']

#输出小写a-z和大写A-Z之间字符串长度最短是3个字符，最长是5个字符的字符串
print(re.findall("[a-zA-Z]{3,5}","EXCEL 12345world789ppt87lr")) #输出:['EXCEL', 'world', 'ppt']

#输出小写a-z和大写A-Z之间字符串长度只找2个字符长度的字符串
print(re.findall("[a-zA-Z]{2}","EXCEL 12345world789ppt87lr")) #输出:['EX', 'CE', 'wo', 'rl', 'pp', 'lr']

#模糊查询输出excel相似的字符串，区分大小写的
print(re.findall("excel*","excel 12345world789exce87excellllm")) #输出:['excel', 'exce', 'excellll']

#模糊查询输出excel相似的字符串，至少要匹配一次完整的才可以
print(re.findall("excel+","excel 12345world789exce87excellllm")) #输出:['excel', 'excellll']

#把字符串里面的所有的excel都提取出来
print(re.findall("(excel)","excel 12345world789exce87excellllm")) #输出:['excel', 'excel']

#2个excel也就是excelexcel这样的出现了1次
print(re.findall("(excel){2}","excelexcel 123excel45world789exce87excellllm")) #输出:['excel']

#从第一个字符开始匹配11位的数字字符串，^表示从开始来匹配,第1位必须是数字才可以匹配
print(re.findall("^\d{11}","138111158888b")) #输出:['13811115888']

#从最后一位开始匹配11位数字，最后一位必须是数字才可以匹配，$表示从最后一位开始匹配
print(re.findall("\d{11}$","138111158888")) #输出:['38111158888']

#从开始第1个字符到最后1个字符之间只有11个数字的才可以匹配上，且开始和结尾必须是数字
print(re.findall("^\d{11}$","13811115888")) #输出:['13811115888']

#将abcxyz这样连接的字符 拆分开形成组
print(re.findall("(abc)(xyz)","mjqabcxyzjjjabcxyzmmm")) #输出:[('abc', 'xyz'), ('abc', 'xyz')]

#匹配字符串JJJ,不区分大小写（re.I忽略大小写的语句，以上内容都可以增加这一句）
print(re.findall("JJJ","mjqabcxyzjjjabcxyzmmm",re.I)) #输出:['jjj']

#匹配字符串JJJ以及提取后面2个字符合并输出,不区分大小写（re.I忽略大小写的语句，以上内容都可以增加这一句）
print(re.findall("JJJ.{2}","mjqabcxyzjjjabcxyzmmm",re.I)) #输出:['jjjab']

#匹配字符串JJJ以及提取后面2个字符合并输出,不区分大小写（re.I忽略大小写的语句，以上内容都可以增加这一句） 如果把re.I后增加re.S，那么换行符也可以提取出来
print(re.findall("JJJ.{2}","mjqabcxyzjjjabcxyzmmm",re.I|re.S)) #输出:['jjjab']

#b和h之间的所有字符全部输出出来
print(re.findall("b(.*)h","c57892bkj874163hu")) #输出:['kj874163']

#从第5个字符开始匹配，第6个字符开始结束，第一个匹配的数字是1
print(re.search("\d","nihao123Tianxia")) #输出:<re.Match object; span=(5, 6), match='1'> 
print(re.search("m","nihao123Tianxia")) #输出：None

import  re
a = "c57892bkj874163hu"
#第一个匹配上的结果是数字的。内容是5
print(re.search("\d",a).group()) #输出：5

import  re
a = "c57892bkj874163hu"
#第一个匹配上的结果是数字的。从第1个字符开始，第2个字符结束，匹配上了数字
print(re.search("\d",a).span()) #输出：(1, 2)

import  re
a = "123abc456789"
r = re.search("([0-9]*)([a-z]*)([0-9]*)",a)
#分为数字，字符，数字。这样依次输出
print(r.group()) #输出:123abc456789
print(r.group(0)) #输出:123abc456789
print(r.group(1)) #输出:123
print(r.group(2)) #输出:abc
print(r.group(3)) #输出:456789


#用数字进行分割去除数字，以列表的方式返回
print(re.split("\d","nihao13Tian2xia")) #输出：['nihao', '', 'Tian', 'xia']
#用"*"替换所有数字

print(re.sub("\d","*","nihao123Tianxia")) #输出：nihao***Tianxia
#用"*"替换数字2次
print(re.sub("\d","*","nihao123Tianxia",2)) #输出：nihao**3Tianxia

import  re
a = "abcFBIabcFBIKJGI"
def nihao(形参):
    return "胡启行"
#用"胡启行"替换FBI一次
print(re.sub("FBI",nihao,a,1)) #输出:abc胡启行abcFBIKJGI

import  re
a = "abcFBIabcFBIKJGI"
def nihao(形参):
    分段获取 = 形参.group()
    return "$" + 分段获取 + "$"
#在字符串"FBI"的前面和后面都增加上"$"
print(re.sub("FBI",nihao,a)) #输出:abc$FBI$abc$FBI$KJGI

import  re
a = "c57892bkj874163hu"
def nihao(形参):
    分段获取 = 形参.group()
    if int(分段获取) >= 5:
        return "9"
    else:
        return "0"
#在字符串里面大于等于5的部分替换位数字9，小于5的部分替换为0
print(re.sub("[0-9]",nihao,a)) #输出:c99990bkj990090hu

12.4遍历字符串

str1 = 'hello, world!'
#遍历字符串
for char in str1:
    print(char) #输出:h e l l o , w o r l d !

a, b = 5, 10
print('%d * %d = %d' % (a, b, a * b)) #输出：5 * 10 = 50
print('{0} * {1} = {2}'.format(a, b, a * b)) #输出：5 * 10 = 50
print(f'{a} * {b} = {a * b}') #输出：5 * 10 = 50

13.list列表

list1 = [1, 3, 5, 7, 100]
list2 = ['hello'] * 3 #hello字符串输出3遍
#计算数据3在列表中出现的次数
print(list1.count(3)) #输出:1
#计算列表长
print(len(list1)) #输出：5
print(list2) #输出：['hello', 'hello', 'hello']
#下标(索引)运算
print(list1[0]) #输出：1
print(list1[4]) #输出：100
print(list1[5]) #输出：错误超过下标范围
print(list1[-1]) #输出：100
print(list1[-3]) #输出：5
#更改list值
list1[2] = 300
print(list1) #输出：[1, 3, 300, 7, 100]
#通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index]) #输出：1 3 300 7 100
#通过for循环遍历列表元素
for elem in list1:
    print(elem)  #输出：1 3 300 7 100
#通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
    print(index, elem)
#输出：
0 1
1 3
2 300
3 7
4 100

#在末尾添加元素
list1.append(200)
print(list1) #输出:[1, 3, 300, 7, 100, 200]
#在索引1位置插入数值400
list1.insert(1, 400)
print(list1) #输出:[1, 400, 3, 300, 7, 100, 200]
#合并两个列表
list1.extend([1000,2000])
print(list1) #输出:[1, 400, 3, 300, 7, 100, 200, 1000, 2000]
#先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list1:
	list1.remove(3)
print(list1) #输出:[1, 400, 300, 7, 100, 200, 1000, 2000]
#从指定的位置删除索引为0元素
list1.pop(0)
print(list1) #输出:[400, 300, 7, 100, 200, 1000, 2000]
#删除列表最后一个元素
list1.pop(len(list1)-1)
print(list1) #输出:[400, 300, 7, 100, 200, 1000]
#清空列表
list1.clear()
print(list1) #输出:[]

13.1list列表切片

#列表切片
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
#列表切片包括索引1,2,3
fruits1 = fruits[1:4]
print(fruits1) #输出：['apple', 'strawberry', 'waxberry']
#可以通过完整切片操作来复制列表
fruits2 = fruits[:]
print(fruits2) #输出：['grape', 'apple', 'strawberry', 'waxberry']
#列表切片包括索引-2,-3
fruits3 = fruits[-3:-1]
print(fruits3) #输出：['apple', 'strawberry']
#倒序输出列表
fruits4 = fruits[::-1]
print(fruits4) #输出：['waxberry', 'strawberry', 'apple', 'grape']

13.2list列表排序

#列表排序
list1 = [9, 3, 578, 7, 100]
#升序排列
list2 = sorted(list1) 
print(list2) #输出:[3, 7, 9, 100, 578]
#升序排列
list1.sort()
print(list1) #输出：[3, 7, 9, 100, 578]
#降序排列
list3 = sorted(list1, reverse=True)
print(list3) #输出:[578, 100, 9, 7, 3]
#倒序排列
list1.reverse()
print(list1) #输出：[100, 7, 578, 3, 9]


fruits = ['grape', 'apple', 'strawberry', 'waxberry']
#通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(fruits, key=len)
print(list4) #输出:['grape', 'apple', 'waxberry', 'strawberry']

13.2list列表遍历，输出1-999的数据的平方值

#输出1-9的列表
f = [x for x in range(1, 10)]
print(f) #输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]
#字母和数字交叉组合，可以直接组成一副牌的写法
f = [x + y for x in 'AB' for y in '123']
print(f) #输出:['A1', 'A2', 'A3', 'B1', 'B2', 'B3']

import sys
#输出1-999的数据的平方值
f = [x ** 2 for x in range(1, 1000)]
# 查看对象占用内存的字节数
print(sys.getsizeof(f))  
print(f) #输出：[1, 4, 9, 16, 25, 36..998001]

14.元组

#创建空元组
tuple = ()
#定义元组
t = ('骆昊', 38, True, '四川成都')
#获取元素的索引值
print(t.index("四川成都")) #输出:3
#统计计数
print(t.count("四川成都")) #输出：1
#获取索引0的元素
print(t[0]) #输出：骆昊

#遍历元组中的值
for member in t:
    print(member) #输出：骆昊 38 True 四川成都
    
#重新给元组赋值
t = ('王大锤', 20, True, '云南昆明')
print(t)  #输出：('王大锤', 20, True, '云南昆明')

#将元组转换成列表
person = list(t)
print(person) #输出：['王大锤', 20, True, '云南昆明']
#列表是可以修改它的元素的
person[0] = '李小龙'
print(person) #输出：['李小龙', 20, True, '云南昆明']

#将列表转换成元组
t1 = tuple(person)
print(t1) #输出：('李小龙', 20, True, '云南昆明')

15.集合增加元素

15.1集合增加元素

#创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1)            #输出：{1, 2, 3}
print('Length =', len(set1))  #输出：Length = 3
#set1集合增加4元素
set1.add(4)
#set1集合增加5元素
set1.add(5)
print(set1) #输出：{1, 2, 3, 4, 5}

15.2集合去除元素，生成集合

#生成1-9的集合
set2 = set(range(1, 10))
#set2集合增加11，12元素
set2.update([11, 12])
#set2集合去除元素5
set2.discard(5)
print(set2)  #输出：{1, 2, 3, 4, 6, 7, 8, 9, 11, 12}
#如果4在set2集合里，就去除4
if 4 in set2:
    set2.remove(4)
print(set2)   #输出：{1, 2, 3, 6, 7, 8, 9, 11, 12}

#创建集合的推导式语法(推导式也可以用于推导集合)
set3 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set3)  #输出:1到99中间被3或5整除的数字

set4 = {1, 2, 3, 3, 3, 2}
print(set4.pop())   #输出：1

15.3集合交集并集等操作

set1 = {-3,-2,-1,0,1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1 & set2)   #输出交集：{1, 2, 3}
print(set1.intersection(set2)) #输出交集：：{1, 2, 3}
print(set1 | set2) #输出并集：{0, 1, 2, 3, 4, 5, 6, -1, -3, -2}
print(set1.union(set2)) #输出并集：{0, 1, 2, 3, 4, 5, 6, -1, -3, -2}
print(set1 - set2) #输出set1不同set2的元素：{0, -3, -1, -2}
print(set1.difference(set2)) #输出set1不同set2的元素：{0, -3, -1, -2}
print(set1 ^ set2) #输出除开相同部分的元素并集：{0, 4, 5, 6, -2, -3, -1}
print(set1.symmetric_difference(set2)) #输出除开相同部分的元素并集：{0, 4, 5, 6, -2, -3, -1}

16.字典

#创建字典的语法
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
#对字典中所有键值对进行遍历
for key in scores:
    print(f'{key}: {scores[key]}')
#输出：
骆昊: 95
白元芳: 78
狄仁杰: 82

#更新字典中的元素
scores['白元芳'] = 65

#创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)
print(items1) #输出:{'one': 1, 'two': 2, 'three': 3, 'four': 4}

#通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))
print(items2) #输出:{'a': '1', 'b': '2', 'c': '3'}

#创建字典的推导式语法 x:x**2
items3 = {num: num ** 2 for num in range(1, 10)}
print(items3) #输出:{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

#通过键可以获取字典中对应的值
print(scores['骆昊']) #输出:95
#增加两组数据
scores.update(冷面=67, 方启鹤=85) #输出：{'骆昊': 95, '白元芳': 65, '狄仁杰': 82, '冷面': 67, '方启鹤': 85}

if '狄仁杰' in scores:
    print(scores['狄仁杰']) #输出:82

print(scores.get('狄仁杰')) #输出:82

#删除字典中的元素
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
#删除字典中的最后一个元素
scores.popitem()
print(scores) #输出：{'骆昊': 95, '白元芳': 78}

#创建字典的语法
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
#删除字典中狄仁杰
scores.pop('狄仁杰')
print(scores) #输出:{'骆昊': 95, '白元芳': 78}
#清空字典
scores.clear() 
print(scores) #输出:{}

#创建字典的语法
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
#获取字典中的key列表
key = scores.keys()
print(key) #输出：dict_keys(['骆昊', '白元芳', '狄仁杰'])
#获取字典中的value列表
value = scores.values()
print(value) #输出：dict_values([95, 78, 82])
#获取字典元组列表
tup = scores.items()
print(tup) #输出：dict_items([('骆昊', 95), ('白元芳', 78), ('狄仁杰', 82)])

17.日期类

import datetime
import time
#一.date(日期)

#生成日期
#输出当前日期
print(datetime.date.today()) #输出:2021-05-18
#设定日期
print(datetime.date(2022,5,18)) #输出:2022-05-18
#输出当前日期，time.time()：时间戳
print(datetime.date.fromtimestamp(time.time())) #输出:2021-05-18
#输出最小日期
print(datetime.date.min) #输出:0001-01-01
#输出最大日期
print(datetime.date.max) #输出:9999-12-31
#输出date类最小日期间隔时间
print(datetime.date.resolution) #输出:1 day, 0:00:00


#输出当前日期的年月日
d = datetime.date.fromtimestamp(time.time())
print(d.year) #输出:2021
print(d.month) #输出:5
print(d.day) #输出:18
#把年份替换为2022年
print(d.replace(year=2022)) #输出：2022-05-18
#计算从0001-01-01到现在的天数
print(d.toordinal()) #输出：737928
print(d.weekday()) #输出:1 表示星期二，0表示星期一
print(d.isoweekday()) #输出:2 表示星期二，0表示星期天
#标准的日期格式返回
print(d.isoformat()) #输出：2021-05-18
#格式化输出日期
print(d.strftime("%Y年%m月%d日")) #输出：2021年05月18日
"""
{}表示占位符 =表示要填充为=号，^表示将后面的内容datetime.time居中对齐,
50表示要填充50个等号，如果有：<表示左对齐，>表示右对齐
"""
#居中对齐
print("{:=^50s}".format("datetime.time")) #输出:==================datetime.time===================
#左对齐
print("{:=<50s}".format("datetime.time"))#输出:datetime.time=====================================
#右对齐
print("{:=>50s}".format("datetime.time"))#输出:=====================================datetime.time

18.时间类

import datetime
import time
#2.time(时间)

#生成时间
t = datetime.time(15,10,45,888888)
#时分秒微秒
print(t) #输出:15:10:45.888888
#输出一天当中最小时间
print(datetime.time.min) #输出:00:00:00
#输出一天当中最大时间
print(datetime.time.max) #输出:23:59:59.999999
#输出时间的最小时间间隔
print(datetime.time.resolution)#输出:0:00:00.000001
#输出时分秒微妙
print(t.hour) #输出:15
print(t.minute) #输出:10
print(t.second) #输出:45
print(t.microsecond) #输出:888888
#输出标准时间格式
print(t.isoformat()) #输出:15:10:45.888888
#输出格式化时间
print(t.strftime("%H时%M分%S秒  %f微妙")) #输出:15时10分45秒  888888微妙

import datetime
import time
#三.datetime(日期时间)

#生成日期时间
dt = datetime.datetime(2020,8,20,13,22,34,888888)
print(dt) #输出:2020-08-20 13:22:34.888888
#输出当前日期和时间
print(datetime.datetime.today()) #输出:2021-05-18 22:44:26.001138
#输出当前时区的日期时间
print(datetime.datetime.utcnow()) #输出:2021-05-18 14:45:53.670359
#时间戳
print(datetime.datetime.fromtimestamp(time.time())) #输出:2021-05-18 22:47:04.850939
#生成UTC时间，和标准时间相差8个小时
print(datetime.datetime.utcfromtimestamp(time.time()))#输出:2021-05-18 14:48:18.936326
#字符串格式变成日期格式
print(datetime.datetime.strptime("2020-06-23 23:15:36","%Y-%m-%d %H:%M:%S")) #输出:2020-06-23 23:15:36

#组合成日期时间
#输出当前日期的年月日
d = datetime.date.fromtimestamp(time.time())
#生成时间
t = datetime.time(15,10,45,888888)
print(datetime.datetime.combine(d,t)) #输出:2021-05-18 15:10:45.888888
#输出日期时间的年月日时分秒微妙的数值
print(dt.year) #输出:2020
print(dt.month) #输出:8
print(dt.day) #输出:20
print(dt.hour) #输出:13
print(dt.minute) #输出:22
print(dt.second) #输出:34
print(dt.microsecond) #输出:888888
#将秒改成57，日期改成30
print(dt.replace(second=57,day=30)) #输出:2020-08-30 13:22:57.888888
#输出datetime结构化对象
print(dt.timetuple()) #输出:time.struct_time(tm_year=2020, tm_mon=8, tm_mday=20, tm_hour=13, tm_min=22, tm_sec=34, tm_wday=3, tm_yday=233, tm_isdst=-1)
#时间戳微妙
print(dt.timestamp()) #输出：1597900954.888888
#格式化输出日期字符串
print(dt.strftime("%Y年%m月%d日 %H时%M分%S秒 %f微妙")) #输出：2020年08月20日 13时22分34秒 888888微妙
#将结构化对象转换成datetime  fromtimestamp:转换datetime格式 time.mktime:转换时间戳 time.localtime():结构化时间对象
print(datetime.datetime.fromtimestamp(time.mktime(time.localtime()))) #输出：2021-05-18 23:08:39

import datetime
#4.timedelta(时间差)

#生成时间差
#10天后,5点
td = datetime.timedelta(days=10,hours=5)
print(td) #输出:10 days, 5:00:00
#6天前16点，（往前推5天，再往前8个小时）
td = datetime.timedelta(days=-5,hours=-8)
print(td) #输出:-6 days, 16:00:00
#75个小时就是3天后又3个小时
td = datetime.timedelta(hours=75)
print(td) #输出:3 days, 3:00:00
#2周后
td = datetime.timedelta(weeks=2)
print(td) #输出:14 days, 0:00:00

19.xlrd库,openpyxl库

19.1读取excel

pip install xlrd==1.2.0

#读取excel
import xlrd
book = xlrd.open_workbook("income.xlsx")
print(f"包含表单数量 {book.nsheets}")   #输出：包含表单数量 3
print(f"表单的名分别为: {book.sheet_names()}") #输出：表单的名分别为: ['2018', '2017', '2016']

#表单索引从0开始，获取第一个表单对象
book.sheet_by_index(0)
#获取名为2018的表单对象
book.sheet_by_name('2018')
#获取所有的表单对象，放入一个列表返回
book.sheets()

import xlrd
book = xlrd.open_workbook("income.xlsx")
#表单索引从0开始，获取第一个表单对象
sheet = book.sheet_by_index(0)
print(f"表单名：{sheet.name} ") #输出:表单名：2018 
print(f"表单索引：{sheet.number}") #输出:表单索引：0
print(f"表单行数：{sheet.nrows}") #输出: 表单行数：13
print(f"表单列数：{sheet.ncols}") #输出: 表单列数：2
#行号、列号都是从0开始计算
print(f"单元格A1内容是: {sheet.cell_value(rowx=0, colx=0)}") #输出:单元格A1内容是: 月份
print(f"第一行内容是: {sheet.row_values(rowx=0)}") #输出:第一行内容是: ['月份', '收入']
print(f"第一列内容是: {sheet.col_values(colx=0)}")  #输出:第一列内容是: ['月份', 1.0, 2.0, '3*', 4.0, 5.0, 6.0, '7*', 8.0, 9.0, 10.0, 11.0, 12.0]

#收入在第2列,求出收入的相加总和
incomes = sheet.col_values(colx=1,start_rowx=1)
print(f"2018年总收入为: {sum(incomes)}") #输出：2018年总收入为: 361302.0

import xlrd
book = xlrd.open_workbook("income.xlsx")
#表单索引从0开始，获取第一个表单对象
sheet = book.sheet_by_index(0)
#计算第一列单元格末尾包含"*"字符，第二列的数字输入之和
#定义包含星号的月份收入
toSubstract = 0
#月份在第1列，获取第一列的值
monthes = sheet.col_values(colx=0)
#遍历第一列的值
for row,month in enumerate(monthes):
    #如果第一列是str类型，并且以*结束
    if type(month) is str and month.endswith('*'):
        #获取这个以*结尾的行的，所在第2列的值
        income = sheet.cell_value(row,1)
        print(month,income) #输出：3* 30105.0   7* 30109.0
        toSubstract += income
print("带*月份的收入总和是:%2.f" % toSubstract) #输出：带*月份的收入总和是:60214

#计算一共有三张sheet表，第二列所有的收入之和，除去第一列内容结尾包含"*"字符的收入除外
import xlrd
#一共有三张sheet表
#打开工作簿
book = xlrd.open_workbook("income.xlsx")

#得到所有sheet对象，以list列表返回sheet对象
book1 =book.sheets()
#三张表的总收入之和
incomes = 0
#第0张表的第一列带"*"字符的总收入之和
toSubstract = 0
#第1张表的第一列带"*"字符的总收入之和
toSubstract1 = 0
#第2张表的第一列带"*"字符的总收入之和
toSubstract2 = 0
for i in range(0,3):
    #三张表的所有总输入之和,从第2行第2列开始
    incomes += sum(book1[i].col_values(colx=1,start_rowx=1))
print(f"三张表的所有收入之和{incomes}") #输出:三张表的所有收入之和842394.0
#第0张表的第一列带"*"字符的总收入之和
monthes = book1[0].col_values(colx=0)
for row,month in enumerate(monthes):
    if type(month) is str and month.endswith('*'):
        income = book1[0].cell_value(row,1)
        toSubstract += income
print(f"第0张表结尾带*字符的收入之和{toSubstract}") #输出:第0张表结尾带*字符的收入之和60214.0
#第1张表的第一列带"*"字符的总收入之和
monthes1 = book1[1].col_values(colx=0)
for row,month in enumerate(monthes1):
    if type(month) is str and month.endswith('*'):
        income = book1[1].cell_value(row,1)
        toSubstract1 += income
print(f"第1张表结尾带*字符的收入之和{toSubstract1}") #输出:第1张表结尾带*字符的收入之和20774.0
#第2张表的第一列带"*"字符的总收入之和
monthes2 = book1[2].col_values(colx=0)
for row,month in enumerate(monthes2):
    if type(month) is str and month.endswith('*'):
        income = book1[2].cell_value(row,1)
        toSubstract2 += income
print(f"第2张表结尾带*字符的收入之和{toSubstract2}") #输出:第2张表结尾带*字符的收入之和19374.0
print(f"三张表总共第一列结尾除去*的收入之和是{incomes-toSubstract-toSubstract1-toSubstract2}")
#输出:三张表总共第一列结尾除去*的收入之和是742032.0

19.2写入excel

#安装openpyxl 
pip install openpyxl 


#写入excel
import openpyxl
#创建一个Excel workbook 对象
book = openpyxl.Workbook()
#创建时，会自动产生一个sheet，通过active获取
sh = book.active
#修改当前 sheet 标题为 工资表
sh.title = '工资表'
#增加一个名为 '年龄表' 的sheet，放在最后
sh1 = book.create_sheet('年龄表-最后')
#增加一个 sheet，放在最前
sh2 = book.create_sheet('年龄表-最前',0)
#增加一个 sheet，指定为第2个表单
sh3 = book.create_sheet('年龄表2',1)
#根据名称获取某个sheet对象
sh = book['工资表']
#给第一个单元格A1写入内容
sh['A1'] = '你好'
#根据行号列号第2行第2列单元格写入内容：白月黑羽， # 注意和 xlrd 不同，是从 1 开始
sh.cell(2,2).value = '白月黑羽'
#保存文件
book.save('信息.xlsx')

#获取A1单元格内容
print(sh['A1'].value) #输出：你好
#获取第2行第2列的内容
print(sh.cell(2, 2).value) #输出：白月黑羽

import openpyxl
name2Age = {
    '张飞' :  38,
    '赵云' :  27,
    '许褚' :  36,
    '典韦' :  38,
    '关羽' :  39,
    '黄忠' :  49,
    '徐晃' :  43,
    '马超' :  23,
}

#创建一个Excel workbook 对象
book = openpyxl.Workbook()
#创建时，会自动产生一个sheet，通过active获取
sh = book.active
#标题命名为"年龄表"
sh.title = '年龄表'
#写标题栏
sh['A1'] =  '姓名'
sh['B1'] =  '年龄'
#写入内容,从第2行开始
row = 2
#遍历name2Age
for name,age in name2Age.items():
     #第2行，第1列值是name
    sh.cell(row, 1).value = name
    #第2行，第2列值是age
    sh.cell(row, 2).value = age
    #行自动加1
    row += 1
#保存文件
book.save('信息.xlsx')

import openpyxl
name2Age = [
    ['张飞' ,  38 ] ,
    ['赵云' ,  27 ] ,
    ['许褚' ,  36 ] ,
    ['典韦' ,  38 ] ,
    ['关羽' ,  39 ] ,
    ['黄忠' ,  49 ] ,
    ['徐晃' ,  43 ] ,
    ['马超' ,  23 ]
]
#创建一个Excel workbook 对象
book = openpyxl.Workbook()
#创建时，会自动产生一个sheet，通过active获取
sh = book.active
#标题命名为"年龄表"
sh.title = '年龄表'
#写标题栏
sh['A1'] =  '姓名'
sh['B1'] =  '年龄'
#遍历name2Age
for row in name2Age:
    # 添加到下一行的数据
    sh.append(row)
#保存文件
book.save('信息1.xlsx')

#修改excel中的内容：
import openpyxl
#加载 excel 文件
wb = openpyxl.load_workbook('income.xlsx')
#得到表名称为"2017"的sheet对象
sheet = wb['2017']
#修改A1单元格内容为"修改一下"
sheet['A1'] = '修改一下'

#插入行、插入列
#在第2行的位置插入1行空白
sheet.insert_rows(2)
#在第3行的位置插入3行空白
sheet.insert_rows(3,3)
#在第2列的位置插入1列空白
sheet.insert_cols(2)
#在第2列的位置插入3列空白
sheet.insert_cols(2,3)

#删除行、删除列
#在第2行的位置删除1行
sheet.delete_rows(2)
#在第3行的位置删除3行
sheet.delete_rows(3,3)
#在第2列的位置删除1列
sheet.delete_cols(2)
#在第3列的位置删除3列
sheet.delete_cols(3,3)
#指定不同的文件名，可以另存为别的文件income-1.xlsx
wb.save('income-1.xlsx')

19.3文字 颜色、字体、大小修改

#文字 颜色、字体、大小修改
import openpyxl
#导入Font对象 和 colors 颜色常量
from openpyxl.styles import Font,colors

#加载 excel 文件
wb = openpyxl.load_workbook('income.xlsx')
#得到表名称为"2018"的sheet对象
sheet = wb['2018']

#指定单元格字体颜色，
sheet['A1'].font = Font(color="981818", #指定颜色为红色
                        size=15,    # 设定文字大小
                        bold=True,  # 设定为粗体
                        italic=True # 设定为斜体
                        )


#指定第3行所有文字颜色为红色
font = Font(color="981818")
for y in range(1, 100): # 第 1 到 100 列
    sheet.cell(row=3, column=y).font = font

#指定第2列所有文字加粗
font = Font(bold=True)
for x in range(1, 100): # 第 1 到 100 行
    sheet.cell(row=x, column=2).font = font

#指定不同的文件名，可以另存为别的文件income-1.xlsx
wb.save('income-1.xlsx')

#背景色修改
import openpyxl
#导入Font对象 和 colors 颜色常量
from openpyxl.styles import PatternFill
#导入加载图片功能
from openpyxl.drawing.image import Image

#加载 excel 文件
wb = openpyxl.load_workbook('income.xlsx')
#得到表名称为"2018"的sheet对象
sheet = wb['2018']

#指定A1单元格背景色红色
sheet['A1'].fill = PatternFill("solid", "E39191")
#指定第2行背景颜色
fill = PatternFill("solid", "E39191")
for y in range(1, 100): # 第 1 到 100 列
    sheet.cell(row=2, column=y).fill = fill

#在第1行，第4列的位置插入图片
sheet.add_image(Image('2.jpg'), 'D1')


#指定不同的文件名，可以另存为别的文件income-1.xlsx
wb.save('income-1.xlsx')

19.4COM接口修改excel内容

#Excel COM接口修改excel内容
第一步：安装   pip install pywin32

import win32com.client

excel = win32com.client.Dispatch("Excel.Application")
#可以让excel 可见
excel.Visible = True 
#这里填写要修改的Excel文件的绝对路径
workbook = excel.Workbooks.Open(r"C:\Users\Administrator\PycharmProjects\days\income.xlsx")
#得到 2017表单对象
sheet = workbook.Sheets('2017')
#修改表单第1行第1列单元格内容
sheet.Cells(1,1).Value="你好"
#保存内容
workbook.Save()
#关闭该Excel文件
workbook.Close()
#excel进程退出
excel.Quit()
#释放相关资源
sheet = None
book = None
excel.Quit()
excel = None

20.最大公约数和最小公倍数,x大于y就交换x和y的值,两个数中较的数开始做递减的循环

#最大公约数和最小公倍数
x = int(input('x = '))
y = int(input('y = '))

#如果x大于y就交换x和y的值
if x > y:
    # 通过下面的操作将y的值赋给x, 将x的值赋给y
    x, y = y, x
#从两个数中较的数开始做递减的循环
for factor in range(x, 0, -1):
    if x % factor == 0 and y % factor == 0:
        print('%d和%d的最大公约数是%d' % (x, y, factor))
        print('%d和%d的最小公倍数是%d' % (x, y, x * y // factor))
        break

#以后可以调用下面的函数直接求出结果
def gcd(x, y):
    """求最大公约数"""
    (x, y) = (y, x) if x > y else (x, y)
    for factor in range(x, 0, -1):
        if x % factor == 0 and y % factor == 0:
            return factor

def lcm(x, y):
    """求最小公倍数"""
    return x * y // gcd(x, y)

21.找出1~9999之间的所有完美数

#找出1~9999之间的所有完美数
import math
for num in range(1, 10000):
    result = 0
    for factor in range(1, int(math.sqrt(num)) + 1):
        if num % factor == 0:
            result += factor
            if factor > 1 and num // factor != factor:
                result += num // factor
    if result == num:
        print(num)

21.判断素数和回文数

#判断素数和回文数
for num in range(2, 100):
    is_prime = True
    for factor in range(2, int(math.sqrt(num)) + 1):
        if num % factor == 0:
            is_prime = False
            break
    if is_prime:
        print(num, end=' ')


#实现判断一个数是不是素数的函数
def is_prime(num):
    """判断一个数是不是素数"""
    for factor in range(2, int(num ** 0.5) + 1):
        if num % factor == 0:
            return False
    return True if num != 1 else False


#写一个程序判断输入的正整数是不是回文素数
if __name__ == '__main__':
    num = int(input('请输入正整数: '))
    if is_palindrome(num) and is_prime(num):
        print('%d是回文素数' % num)

22.输出斐波那契数列的前20个数,更新跑马灯

#输出斐波那契数列的前20个数 1 1 2 3 5 8 13 21 ...
a = 0
b = 1
for _ in range(20):
    a, b = b, a + b
    print(a, end=' ')

def is_palindrome(num):
    """判断一个数是不是回文数"""
    temp = num
    total = 0
    while temp > 0:
        total = total * 10 + temp % 10
        temp //= 10
    return total == num

#更新跑马灯
import os
import time
def main():
    content = '北京欢迎你为你开天辟地…………'
    while True:
        # 清理屏幕上的输出
        os.system('cls')  # os.system('clear')
        print(content)
        # 休眠200毫秒
        time.sleep(0.2)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()

23.产生指定长度的验证码

#产生指定长度的验证码
import random
def generate_code(code_len=4):
    """
    生成指定长度的验证码
    :param code_len: 验证码的长度(默认4个字符)
    :return: 由大小写英文字母和数字构成的随机验证码
    """
    all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    last_pos = len(all_chars) - 1
    code = ''
    for _ in range(code_len):
        index = random.randint(0, last_pos)
        code += all_chars[index]
    return code

24.设计一个函数返回给定文件名的后缀名

#设计一个函数返回给定文件名的后缀名
def get_suffix(filename, has_dot=False):
    """
    获取文件名的后缀名
    :param filename: 文件名
    :param has_dot: 返回的后缀名是否需要带点
    :return: 文件的后缀名
    """
    pos = filename.rfind('.')
    if 0 < pos < len(filename) - 1:
        index = pos if has_dot else pos + 1
        return filename[index:]
    else:
        return ''

25.设计一个函数返回传入的列表中最大和第二大的元素的值

#设计一个函数返回传入的列表中最大和第二大的元素的值
def max2(x):
    m1, m2 = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0])
    for index in range(2, len(x)):
        if x[index] > m1:
            m2 = m1
            m1 = x[index]
        elif x[index] > m2:
            m2 = x[index]
    return m1, m2

26.计算指定的年月日是这一年的第几天

#计算指定的年月日是这一年的第几天
def is_leap_year(year):
    """
    判断指定的年份是不是闰年

    :param year: 年份
    :return: 闰年返回True平年返回False
    """
    return year % 4 == 0 and year % 100 != 0 or year % 400 == 0


def which_day(year, month, date):
    """
    计算传入的日期是这一年的第几天

    :param year: 年
    :param month: 月
    :param date: 日
    :return: 第几天
    """
    days_of_month = [
        [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
        [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    ][is_leap_year(year)]
    total = 0
    for index in range(month - 1):
        total += days_of_month[index]
    return total + date


def main():
    print(which_day(1980, 11, 28))
    print(which_day(1981, 12, 31))
    print(which_day(2018, 1, 1))
    print(which_day(2016, 3, 1))


if __name__ == '__main__':
    main()

27.打印杨辉三角

#打印杨辉三角
def main():
    num = int(input('Number of rows: '))
    yh = [[]] * num
    for row in range(len(yh)):
        yh[row] = [None] * (row + 1)
        for col in range(len(yh[row])):
            if col == 0 or col == row:
                yh[row][col] = 1
            else:
                yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]
            print(yh[row][col], end='\t')
        print()


if __name__ == '__main__':
    main()

28.双色球选号

#双色球选号
from random import randrange, randint, sample
def display(balls):
    """
    输出列表中的双色球号码
    """
    for index, ball in enumerate(balls):
        if index == len(balls) - 1:
            print('|', end=' ')
        print('%02d' % ball, end=' ')
    print()


def random_select():
    """
    随机选择一组号码
    """
    red_balls = [x for x in range(1, 34)]
    selected_balls = []
    selected_balls = sample(red_balls, 6)
    selected_balls.sort()
    selected_balls.append(randint(1, 16))
    return selected_balls


def main():
    n = int(input('机选几注: '))
    for _ in range(n):
        display(random_select())


if __name__ == '__main__':
    main()

29.定义类及使用类

#定义类及使用类
class Student(object):
    def __init__(self, name, age):
        self.age = age
        self.name = name
        sex = "男"

    def Study(self, course_name):
        print(f"{self.age}岁的{self.name}正在学习{course_name}")

    def watch(self):
        if self.age < 18:
            print("%s正在看熊出没" %(self.name))
        else:
            print("%s正在看岛国片" %(self.name))


xue = Student("小刚",5)
xue.watch()
xue.Study("英语")

29.1类的继承学习

#类的继承学习
class Person(object):
    """人"""

限定Person对象只能绑定_name, _age和_gender属性

    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        print('%s正在愉快的玩耍.' % self._name)

    def watch_av(self):
        if self._age >= 18:
            print('%s正在观看爱情动作片.' % self._name)
        else:
            print('%s只能观看《熊出没》.' % self._name)

class Student(Person):
    """学生"""

    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self._grade = grade

    @property
    def grade(self):
        return self._grade

    @grade.setter
    def grade(self, grade):
        self._grade = grade

    def study(self, course):
        print('%s的%s正在学习%s.' % (self._grade, self._name, course))

class Teacher(Person):
    """老师"""

    def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, title):
        self._title = title

    def teach(self, course):
        print('%s%s正在讲%s.' % (self._name, self._title, course))

def main():
    stu = Student('王大锤', 15, '初三')
    stu.study('数学')
    stu.watch_av()
    t = Teacher('骆昊', 38, '砖家')
    t.teach('Python程序设计')
    t.watch_av()


if __name__ == '__main__':
    main()

29.2抽象方法多态

#抽象方法多态
Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过`abc`模块的`ABCMeta`元类和`abstractmethod`包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）
from abc import ABCMeta, abstractmethod
class Pet(object, metaclass=ABCMeta):
    """宠物"""

    def __init__(self, nickname):
        self._nickname = nickname

    @abstractmethod
    def make_voice(self):
        """发出声音"""
        pass


class Dog(Pet):
    """狗"""

    def make_voice(self):
        print('%s: 汪汪汪...' % self._nickname)


class Cat(Pet):
    """猫"""

    def make_voice(self):
        print('%s: 喵...喵...' % self._nickname)


def main():
    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
    for pet in pets:
        pet.make_voice()


if __name__ == '__main__':
    main()

29.3案例:奥特曼打小怪兽

#案例1：奥特曼打小怪兽
from abc import ABCMeta, abstractmethod
from random import randint, randrange


class Fighter(object, metaclass=ABCMeta):
    """战斗者"""

    # 通过__slots__魔法限定对象可以绑定的成员变量
    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        """
        self._name = name
        self._hp = hp

    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    @property
    def alive(self):
        return self._hp > 0

    @abstractmethod
    def attack(self, other):
        """攻击

        :param other: 被攻击的对象
        """
        pass


class Ultraman(Fighter):
    """奥特曼"""

    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        :param mp: 魔法值
        """
        super().__init__(name, hp)
        self._mp = mp

    def attack(self, other):
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
        """究极必杀技(打掉对方至少50点或四分之三的血)

        :param other: 被攻击的对象

        :return: 使用成功返回True否则返回False
        """
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            other.hp -= injury
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        """魔法攻击

        :param others: 被攻击的群体

        :return: 使用魔法成功返回True否则返回False
        """
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        """恢复魔法值"""
        incr_point = randint(1, 10)
        self._mp += incr_point
        return incr_point

    def __str__(self):
        return '~~~%s奥特曼~~~\n' % self._name + \
            '生命值: %d\n' % self._hp + \
            '魔法值: %d\n' % self._mp


class Monster(Fighter):
    """小怪兽"""

    __slots__ = ('_name', '_hp')

    def attack(self, other):
        other.hp -= randint(10, 20)

    def __str__(self):
        return '~~~%s小怪兽~~~\n' % self._name + \
            '生命值: %d\n' % self._hp


def is_any_alive(monsters):
    """判断有没有小怪兽是活着的"""
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False


def select_alive_one(monsters):
    """选中一只活着的小怪兽"""
    monsters_len = len(monsters)
    while True:
        index = randrange(monsters_len)
        monster = monsters[index]
        if monster.alive > 0:
            return monster


def display_info(ultraman, monsters):
    """显示奥特曼和小怪兽的信息"""
    print(ultraman)
    for monster in monsters:
        print(monster, end='')


def main():
    u = Ultraman('骆昊', 1000, 120)
    m1 = Monster('狄仁杰', 250)
    m2 = Monster('白元芳', 500)
    m3 = Monster('王大锤', 750)
    ms = [m1, m2, m3]
    fight_round = 1
    while u.alive and is_any_alive(ms):
        print('========第%02d回合========' % fight_round)
        m = select_alive_one(ms)  # 选中一只小怪兽
        skill = randint(1, 10)   # 通过随机数选择使用哪种技能
        if skill <= 6:  # 60%的概率使用普通攻击
            print('%s使用普通攻击打了%s.' % (u.name, m.name))
            u.attack(m)
            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
            if u.magic_attack(ms):
                print('%s使用了魔法攻击.' % u.name)
            else:
                print('%s使用魔法失败.' % u.name)
        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
            if u.huge_attack(m):
                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
            else:
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
            print('%s回击了%s.' % (m.name, u.name))
            m.attack(u)
        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
        fight_round += 1
    print('\n========战斗结束!========\n')
    if u.alive > 0:
        print('%s奥特曼胜利!' % u.name)
    else:
        print('小怪兽胜利!')


if __name__ == '__main__':
    main()

#案例2：扑克游戏
import random


class Card(object):
    """一张牌"""

    def __init__(self, suite, face):
        self._suite = suite
        self._face = face

    @property
    def face(self):
        return self._face

    @property
    def suite(self):
        return self._suite

    def __str__(self):
        if self._face == 1:
            face_str = 'A'
        elif self._face == 11:
            face_str = 'J'
        elif self._face == 12:
            face_str = 'Q'
        elif self._face == 13:
            face_str = 'K'
        else:
            face_str = str(self._face)
        return '%s%s' % (self._suite, face_str)
    
    def __repr__(self):
        return self.__str__()


class Poker(object):
    """一副牌"""

    def __init__(self):
        self._cards = [Card(suite, face) 
                       for suite in '????'
                       for face in range(1, 14)]
        self._current = 0

    @property
    def cards(self):
        return self._cards

    def shuffle(self):
        """洗牌(随机乱序)"""
        self._current = 0
        random.shuffle(self._cards)

    @property
    def next(self):
        """发牌"""
        card = self._cards[self._current]
        self._current += 1
        return card

    @property
    def has_next(self):
        """还有没有牌"""
        return self._current < len(self._cards)


class Player(object):
    """玩家"""

    def __init__(self, name):
        self._name = name
        self._cards_on_hand = []

    @property
    def name(self):
        return self._name

    @property
    def cards_on_hand(self):
        return self._cards_on_hand

    def get(self, card):
        """摸牌"""
        self._cards_on_hand.append(card)

    def arrange(self, card_key):
        """玩家整理手上的牌"""
        self._cards_on_hand.sort(key=card_key)


```python
#排序规则-先根据花色再根据点数排序

def get_key(card):
    return (card.suite, card.face)


def main():
    p = Poker()
    p.shuffle()
    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
    for _ in range(13):
        for player in players:
            player.get(p.next)
    for player in players:
        print(player.name + ':', end=' ')
        player.arrange(get_key)
        print(player.cards_on_hand)


if __name__ == '__main__':
    main()

29.4案例:工资结算系统

#案例3：工资结算系统
"""
某公司有三种类型的员工 分别是部门经理、程序员和销售员
需要设计一个工资结算系统 根据提供的员工信息来计算月薪
部门经理的月薪是每月固定15000元
程序员的月薪按本月工作时间计算 每小时150元
销售员的月薪是1200元的底薪加上销售额5%的提成
"""
from abc import ABCMeta, abstractmethod


class Employee(object, metaclass=ABCMeta):
    """员工"""

    def __init__(self, name):
        """
        初始化方法

        :param name: 姓名
        """
        self._name = name

    @property
    def name(self):
        return self._name

    @abstractmethod
    def get_salary(self):
        """
        获得月薪

        :return: 月薪
        """
        pass


class Manager(Employee):
    """部门经理"""

    def get_salary(self):
        return 15000.0


class Programmer(Employee):
    """程序员"""

    def __init__(self, name, working_hour=0):
        super().__init__(name)
        self._working_hour = working_hour

    @property
    def working_hour(self):
        return self._working_hour

    @working_hour.setter
    def working_hour(self, working_hour):
        self._working_hour = working_hour if working_hour > 0 else 0

    def get_salary(self):
        return 150.0 * self._working_hour


class Salesman(Employee):
    """销售员"""

    def __init__(self, name, sales=0):
        super().__init__(name)
        self._sales = sales

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, sales):
        self._sales = sales if sales > 0 else 0

    def get_salary(self):
        return 1200.0 + self._sales * 0.05


def main():
    emps = [
        Manager('刘备'), Programmer('诸葛亮'),
        Manager('曹操'), Salesman('荀彧'),
        Salesman('吕布'), Programmer('张辽'),
        Programmer('赵云')
    ]
    for emp in emps:
        if isinstance(emp, Programmer):
            emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
        elif isinstance(emp, Salesman):
            emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
        # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
        print('%s本月工资为: ￥%s元' %
              (emp.name, emp.get_salary()))


if __name__ == '__main__':
    main()

29.5案例:幸运的基督徒

"""
《幸运的基督徒》
有15个基督徒和15个非基督徒在海上遇险，为了能让一部分人活下来不得不将其中15个人扔到海里面去，有个人想了个办法就是大家围成一个圈，由某个人开始从1报数，报到9的人就扔到海里面，他后面的人接着从1开始报数，报到9的人继续扔到海里面，直到扔掉15个人。由于上帝的保佑，15个基督徒都幸免于难，问这些人最开始是怎么站的，哪些位置是基督徒哪些位置是非基督徒。
"""
def main():
    persons = [True] * 30
    counter, index, number = 0, 0, 0
    while counter < 15:
        if persons[index]:
            number += 1
            if number == 9:
                persons[index] = False
                counter += 1
                number = 0
        index += 1
        index %= 30
    for person in persons:
        print('基' if person else '非', end='')


if __name__ == '__main__':
    main()

29.6案例:井子棋游戏

#井子棋游戏
import os


def print_board(board):
    print(board['TL'] + '|' + board['TM'] + '|' + board['TR'])
    print('-+-+-')
    print(board['ML'] + '|' + board['MM'] + '|' + board['MR'])
    print('-+-+-')
    print(board['BL'] + '|' + board['BM'] + '|' + board['BR'])


def main():
    init_board = {
        'TL': ' ', 'TM': ' ', 'TR': ' ',
        'ML': ' ', 'MM': ' ', 'MR': ' ',
        'BL': ' ', 'BM': ' ', 'BR': ' '
    }
    begin = True
    while begin:
        curr_board = init_board.copy()
        begin = False
        turn = 'x'
        counter = 0
        os.system('clear')
        print_board(curr_board)
        while counter < 9:
            move = input('轮到%s走棋, 请输入位置: ' % turn)
            if curr_board[move] == ' ':
                counter += 1
                curr_board[move] = turn
                if turn == 'x':
                    turn = 'o'
                else:
                    turn = 'x'
            os.system('clear')
            print_board(curr_board)
        choice = input('再玩一局?(yes|no)')
        begin = choice == 'yes'


if __name__ == '__main__':
    main()

30.python的注释,计算1.01的365次方,input函数实现键盘输入

#这是python的单行注释

"""
这是Python的多行注释
"""

#全局变量的定义,加上前缀g_，或者在函数外定义的变量
g_num

#元组可以这样写
a,b = b,a
#计算1.01的365次方
print(1.01**365) #输出：37.78343433288728

#input函数实现键盘输入
a = input("请输入密码：")
print(a) 

%s #字符串
%d #有符号十进制整数
%f #浮点数  %.02f 表示小数点后只显示两位小数
%% #输出%

#向控制台输出内容结束之后，不会换行
print("*",end="")
#单纯的换行
print("")

print("*",end="---")
#单纯的换行
print("*")
#最终输出结果：*---*

31.if else语句结构

#if else语句结构
age = 16
if age >=18:
    print("你已经成年")
else:
    print("你还没成年")

#if not 语句
is_employee = True;
if not is_employee:
    print("非本公司人员")

#if elif是同时判断多个条件，每个条件都是平级的
holiday_name = "生日"
if holiday_name == "情人节":
    print("买玫瑰")
elif holiday_name == "平安夜":
    print("吃苹果")
elif holiday_name == "生日":
    print("买蛋糕")
else:
    print("每天都是节日呀")

#多层if条件判断
a = 16
holiday_name = "生日"
if holiday_name == "生日":
    if a >=18:
        print("买玫瑰")
    else:
        print("吃苹果")

32.while循环

#while循环
i = 1
while i <=5:
    print("hello,Python")
    i = i + 1;
print("循环结束后的 i = %d" % i) #输出：5遍hello,Python

33.for循环判断

#for循环判断
for num in [1,2,3]:
    print(num) #输出：1 2
    if num == 2:
        break
else:
    print("你好")

34.生成随机数

import random
#生成随机数
a = random.randint(12,20)
print(a) #随机生成 12 <= a <= 20的整数

35.定义函数和调用函数

#定义函数和调用函数
def sum(num1,num2):
    """对两个数字求和"""
    result = num1 + num2
    print("%d + %d = %d" % (num1,num2,result)) #输出：10 + 20 = 30

if __name__ == '__main__':
    sum(10,20)


#打印横线模块.py文件里面的编写内容
def dayin():
    print("-"*50)

#test.py文件里面的编写内容
"""
打印横线模块.py 是自己创建的文件
"""
#导入模块
import 打印横线模块
#调用自己创建的模块的函数dayin()
打印横线模块.dayin() #输出:--------------------------------------------------

36.多值参数 *args 变量的函数，可以接收元组 **kwargs键值对参数，可以接收字典

#多值参数 *args 变量的函数，可以接收元组  **kwargs键值对参数，可以接收字典
def demo(num,*args,**kwargs):
    print(num) #输出:1
    print(args) #输出:(2, 3, 4)
    print(kwargs) #输出:{'name': '小明', 'age': 18, 'gender': True}
if __name__ == '__main__':
    demo(1,2,3,4,name="小明",age=18,gender=True)

#下面的也是一样的
def demo(num,*nums,**person):
    print(num) #输出:1
    print(nums) #输出:(2, 3, 4)
    print(person) #输出:{'name': '小明', 'age': 18, 'gender': True}
if __name__ == '__main__':
    demo(1,2,3,4,name="小明",age=18,gender=True)

37.函数递归，处理不确定的循环条件的时候格外有用

#函数递归，处理不确定的循环条件的时候格外有用
"""
计算1+2+3+.....+num
"""
def sum_numbers(num):
    #1.出口
    if num ==1:
        return 1
    #2.数字的累加num+(1+2+...+num-1)
    temp = sum_numbers(num-1)
    return num + temp

result = sum_numbers(100)
print(result) #输出:5050

38.numpy

38.1生成数组,设置指定的数据类型，输出0-10的数据，步长为2,调整数据类型

import numpy as np
import random

#生成数组
t1 = np.array([1,2,3,4])
print(t1,type(t1),t1.dtype) #输出:[1 2 3 4] <class 'numpy.ndarray'> int32
#设置指定的数据类型
t1 = np.array(range(1,4),dtype=float)
print(t1,t1.dtype) #输出:[1. 2. 3.] float64
t1 = np.array(range(1,4),dtype="float32")
print(t1,t1.dtype) #输出:[1. 2. 3.] float32
t1 = np.array([1,0,1,1,0],dtype=bool)
print(t1)#输出:[ True False  True  True False]
t1 = np.array(range(10))
print(t1) #输出:[0 1 2 3 4 5 6 7 8 9]
t1 = np.arange(10)
print(t1) #输出:[0 1 2 3 4 5 6 7 8 9]
#输出0-10的数据，步长为2
t1 = np.arange(0,10,2)
print(t1) #输出:[0 2 4 6 8]

#调整数据类型
t2 = t1.astype("int8")
print(t2,t2.dtype) #输出:[0 2 4 6 8] int8

#numpy中的小数
#产生3个0-1随机数
t1 = np.array([random.random() for i in range(3)])
print(t1,t1.dtype) #输出:[0.08668437 0.33664667 0.43439296] float64
#将t1取小数点后两位
t1 = np.round(t1,2)
print(t1,t1.dtype) #输出:[0.35 0.02 0.6 ] float64

38.2一二三维数组,更改数组形状,在不知道t5元素个数的情况下，将其变成1维数组,数组的计算函数

import numpy as np

#一维数组
t1 = np.arange(12)
print(t1) #输出:[ 0  1  2  3  4  5  6  7  8  9 10 11]
#1个数字表示是1维数组，12表示有12个数据
print(t1.shape) #输出:(12,)

#二维数组
t2 = np.array([[1,2,3],[4,5,6]])
print(t2)
"""
#输出:
[[1 2 3]
 [4 5 6]]
"""
#2表示2行，3表示3列，2行3列二维
print(t2.shape)  #输出:(2, 3)

#三维数组
t3 = np.array([[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]])
print(t3)
"""
#输出:
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]]
"""
#1表示1个块，4表示4行，3表示3列  1个块4行3列
print(t3.shape) #输出:(1, 4, 3)

#更改数组形状
#1维数组转换成2维数组
#因为t1有12个数据，变成二维的时候3*4=12刚好就可以变成3行4列的
t4 = t1.reshape((3,4))
print(t4)
print(t4.shape) #输出:(3, 4)
"""
#输出:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
"""
#1维数组转换成3维数组,2块2行3列 2×2×3=12才可以
t5 = t1.reshape((2,2,3))
print(t5)
"""
#输出:
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
"""
#3维数组转换成2维数组, 6*2=12才可以
t6 = t5.reshape((6,2))
print(t6)
"""
#输出:
[[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 6  7]
 [ 8  9]
 [10 11]]
"""
#3维数组转换成1维数组 2*2*3=12
t7 = t5.reshape(12)
print(t7) #输出:[ 0  1  2  3  4  5  6  7  8  9 10 11]

#在不知道t5元素个数的情况下，将其变成1维数组
t8 = t5.flatten()
print(t8) #输出:[ 0  1  2  3  4  5  6  7  8  9 10 11]
#将t5的所有元素加上2
print(t5+2)
"""
#输出:
[[[ 2  3  4]
  [ 5  6  7]]

 [[ 8  9 10]
  [11 12 13]]]
"""
#两个数组相加是对应位置的元素相加
t6 = np.arange(0,3)
print(t5-t6)
"""
#输出:
[[[0 0 0]
  [3 3 3]]

 [[6 6 6]
  [9 9 9]]]
"""

import numpy as np

#数组的计算函数
"""
常用的计算函数:
求和:t.sum(axis=None) axis参数可以是：0，1，2
均值:t.mean(a,axis=None) 受离群点的影响较大
中值:np.median(t,axis=None)
最大值:t.max(axis=None)
最小值:t.min(axis=None)
极值:np.ptp(t,axis=None) 最大值和最小值只差
标准差:t.std(axis=None)
"""
t1 = np.arange(0,12).reshape(3,4)
print(t1)
"""
#输出:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
"""
#数组所有元素相加
t2 = np.sum(t1)
print(t2) #输出:66
#计算x行轴上的和,竖着相加0+4+8=12
print(np.sum(t1,axis=0)) #输出:[12 15 18 21]
#计算y行轴上的和,横着相加0+1+2+3=6
print(np.sum(t1,axis=1))  #输出:[ 6 22 38]

#求均值
#求所有的数据均值
print(np.mean(t1)) #输出:5.5
#求竖向相加的均值
print(np.mean(t1,axis=0)) #输出：[4. 5. 6. 7.]
#求横向相加的均值
print(np.mean(t1,axis=1)) #输出：[1.5 5.5 9.5]

#求中值
print(np.median(t1)) #输出：5.5
#求每一列中的中值
print(np.median(t1,axis=0)) #输出：[4. 5. 6. 7.]
#求每一行中的中值
print(np.median(t1,axis=1)) #输出：[1.5 5.5 9.5]

#求最大值
print(np.max(t1)) #输出：11
#求每一列中的最大值
print(np.max(t1,axis=0)) #输出：[ 8  9 10 11]
#求每一行中的最大值
print(np.max(t1,axis=1)) #输出：[ 3  7 11]

#求最小值
print(np.min(t1)) #输出：0
#求每一列中的最小值
print(np.min(t1,axis=0)) #输出：[0 1 2 3]
#求每一行中的最小值
print(np.min(t1,axis=1)) #输出：[0 4 8]

#求极值（最大值和最小值之差）
print(np.ptp(t1)) #输出：11
#求每一列中的极值（最大值和最小值之差）
print(np.ptp(t1,axis=0)) #输出：[8 8 8 8]
#求每一行中的极值（最大值和最小值之差）
print(np.ptp(t1,axis=1)) #输出：[3 3 3]

38.3读取csv文件,进行转置方法

#coding = utf-8
import numpy as np
"""
sj.csv:CSV文件路劲
delimiter：CSV文件数据中间都是通过","逗号来分割的，所以就填写数据分割的符号
dtype：加载的数据以什么类型显示，正常情况不设置的话是float类型，数据以科学计数法显示，改成int可以正常显示
unpack：是否转置，True表示要转置，False表示不进行转置显示
还有几个没有展示的参数：
frame：可以是.gz或bz2压缩文件
skiprows：跳过前x行，一般跳过第一行表头
usecols： 读取指定的列，索引，元祖类型
"""
t1 = np.loadtxt("sj.csv",delimiter =",",dtype="int",unpack=False)
print(t1)
"""
#输出:
[[ 12  78  45]
 [450 784 451]
 [412   3   7]]

"""
#进行转置方法1：transpose()
print(t1.transpose())
"""
#输出:
[[ 12 450 412]
 [ 78 784   3]
 [ 45 451   7]]
"""
#进行转置方法2：T
print(t1.T)
"""
#输出:
[[ 12 450 412]
 [ 78 784   3]
 [ 45 451   7]]
"""
#进行转置方法3：交换轴，x轴和y轴进行交换本来是（0，1），交换后(1,0)
print(t1.swapaxes(1,0))
"""
#输出:
[[ 12 450 412]
 [ 78 784   3]
 [ 45 451   7]]
"""

38.4读取csv文件取不连续的行，列

CSV内容如下:
[[ 12  78  45]
 [450 784 451]
 [412   3   7]]
"""
#取行
#取第3行
print(t1[2]) #输出:[412   3   7]
#连续取多行，从第2行开始往后的所有行数都取
print(t1[1:])
"""
输出:
[[450 784 451]
 [412   3   7]]
"""
#取不连续的行,第1行和第3行，注意是：[[]]
print(t1[[0,2]])
"""
输出:
[[ 12  78  45]
 [412   3   7]]
"""

#取列
#取第一列
print(t1[:,0]) #输出:[ 12 450 412]
#取连续的多列,取第2列往后的所有列
print(t1[:,1:])
"""
输出:
[[ 78  45]
 [784 451]
 [  3   7]]
"""
#取不连续的多列,取第1列和第3列
print(t1[:,[0,2]])
"""
#输出:
[[ 12  45]
 [450 451]
 [412   7]]
"""
#取行和列交叉的值,取第2行和第3列交叉的值
print(t1[1,2]) #输出:451
#取多行和多列交叉的值,行值：0:2，列值:0:3
print(t1[0:2,0:3])
"""
#输出:
[[ 12  78  45]
 [450 784 451]]
"""
#取多个不相邻的点,1行和1列的值，3行和2列的值
print(t1[[0,2],[0,1]]) #输出：[12  3]
#取多个不相邻的点,1行和1列的值，3行和2列的值,2行1列的值
print(t1[[0,2,1],[0,1,0]]) #输出：[ 12   3 450]