#加减乘除取余
+、-、*、/、%

# 幂运算
print(2**5)
# 整除
print(10//3)
#返回浮点数x的四舍五入值
print(round(x))
# 绝对值
print(abs(-2))
# 获取商和余数,返回一个元组(3,1)
print(divmod(10,3))
# 舍去小数部分不论多大
print(int(2.8))

int(x [,base ])
float(x )
# 创建一个复数
complex(real [,imag ])

#将对象 x 转换为表达式字符串 
repr(x )

#用来计算在字符串中的有效Python表达式,并返回一个对象  
eval(str )

str(x )
tuple(s ) 
list(s ) 

#一些字符串方法
str1 = "abcd"
#全部小写
print(str1.lower())
#全部大写
print(str1.upper())
#返回a出现的次数
print(str1.count("a"))
#替换a为b
print(str1.replace("a","b"))
#让字符串以宽度10居中周围以~填充
print(str1.center(10,"~"))
#去掉左右包含abd中的字符,=> c
print(str1.strip("abd"))
#str1的长度
print(len(str1))

str2="a,b,c,d"
#返回列表，根据分隔为逗号
print(str2.split(","))
#为1234除了最后一个4以外每个元素增加一个逗号(可以是其他字符串)
#1,2,3,4
print(",".join("1234"))
#逆转字符串[M:N:K],以K为步长对字符取切片
print("\n"+str2[::-1])

#输入
input_str=input("请输入:")

#转换进制和编码

#整数的16进制小写形式
hex(10)
#8进制
oct(10)
#逗号起一个空格作用
print(hex(10),oct(10))
#将Unicode转为对应字符 
#python使用Unicode编码
print("Unicode 49："+str(chr(49)))
#将1（单字符）的Unicode值
print("1 Unicode："+str(ord("1")))

#输出格式化

#槽号+引导符号是冒号+填充2边的符号+<左对齐，右对齐>，^居中，+槽的宽度
print("format()的格式控制 {0:=^10}{1:*>10}".format("0号","1号"))
#逗号为数字的千位分隔符,点加精度限制浮点数或字符串的最大输出长度,还有输出类型
#（进制）类型有 b,c,d,o,x,X,///数字的表示类型e,E,f,%
print("{0:,}{1:.2f}{2:b}".format(123456789,2.2221,10))

#输出12星座的字符
for i in range(12):
    print(chr(9800+i),end=" ")

myls=[]
#添加
for i in range(5):
    myls.append(i)

print(myls)
#反转列表
myls.reverse()
#生成一个新列表，赋值原列表中所有元素
myls_copy = myls.copy()
print(myls)
print(myls_copy)
#修改元素
myls[1]="1"
print(myls)

#删除一个元素
del myls[1]
print(myls)
#删除1到3下标的元素
del myls[1:4]
#del ls[0:3:2]#删除ls 0到3以步长为2的切片元素，就是对应的[0],[2]
print(myls)
print(0 in myls)
#将列表中出现的第一个元素0删除，
#如果没有该元素则ValueError异常,只删除第一个出现的
myls.remove(0)
#在lb中第0位置取出元素并删除该元素
myls.pop(0)

#插入，2是下标,在指定下标插入一个新元素，原本的元素后移
myls.insert(2,9)
print(myls)
#在后面添加新元素
myls.append(0)
print(myls)

#只能返回第一个出现的下标
print(myls.index(0))
#0出现的总次数
print(myls.count(0))
#长度
print(len(myls))
#最大值
print(max(myls))
#清空列表
myls.clear()
print(myls)

tuple1=()
#不使用()
mytuple=1,2,3,4,5
print(mytuple)
tuple1+=(1,2,3,4)
#元组套元组
mytuple_tuple=(1,2,3,mytuple)
print(mytuple_tuple)
#由于这个元组里的最后一个元素还是一个元组可以再使用[-1]读取他的最后一个元素
print(mytuple_tuple[-1][-1])

tuple2=(1,2,3,4,5)
#并不改变本来的元组，而是生成一个新的元组逆序
print(tuple2[::-1])
print(tuple1[1])

#删除整个元组
del tuple1
#最大
print(max(tuple2))
#统计次数
print(tuple2.count(1))
#长度
print(len(tuple2))
#下标
print(tuple2.index(3))
#转换
list1=[1,2,3,4,5]
#将列表转换为元组
tuple3=tuple(list1)
#用切片的方式更新元组，生成新的元组副本
#元组中只包含一个元素时，需要在元素后面添加逗号,防止被当作括号运算.
tuple3=tuple3[:2]+(8,)+tuple3[2:]
print(tuple3)

list2 = list(tuple3)
print(list2)

A ={"p","y",123}
B =set("pypy123")#将其他变量类型变为集合类型，如这里字符串变为集合
print(B)
print(A-B)#在A中出现，但是B中不出现的
print(A&B)#A,B同时存在的元素
print(A|B)#A,B所有元素
print(A^B)#A，B除去同时存在的元素
try:
    A.add('t')#如果t不在A中，将t加入A
    C=A.copy()#返回一个A的副本
    print(C)
    print(len(A))#返回A的元素个数
    print('t' in A)#判断A中元素t,t在A则返回True ,否则False
    A.discard('t')#移出A中的t元素，如果t不在A中不报错
    print('t' not in A)#判断A中元素t,t不在A则返回True ,否则False
    A.remove('t')#移出A中的t元素，如果t不在A中，产生KeyError异常
except KeyError:
    print("KeyError")
try:
    while True:
        print(A.pop(),end="")#A中取出元素，元素为空时会产生一个异常
except:
    print("\n")
#数据去重主要
ls=[123,123,456,789]
st=set(ls)
ls=list(st)
print(ls)#利用列表转集合再集合转列表实现去重

mydict={
    1:"one",
    2:"two",
    3:"three"
}
#删除键1对应的数据值
del mydict[1]
print(mydict)
print(len(mydict))
#判断1是否在字典里
print(1 in mydict)
#返回所有的键信息
print(mydict.keys())
#返回所有的值信息，可以遍历但是不能当作list操作
print(mydict.values())
#返回所有键值对信息
print(mydict.items())
#键 1 存在则返回相应的值，否则返回 不存在<或者其他设置值>
print(mydict.get(1,"不存在"))
#键 2 存在则取出并删除，否则返回不存在
print(mydict.pop(2,"不存在"))
print(mydict)
#取出最后一个键值对返回并删除，以元组形式返回
print(mydict.popitem())
mydict.clear()#删除所有键值对
print(mydict)

#打开
open(file, 
     mode='r', 
     buffering=-1, 
     encoding=None, 
     errors=None, 
     newline=None, 
     closefd=True, 
     opener=None)

myfile=open(r"C:\Users\霁\Desktop\mytest\mypython\my_IO.txt",
            "w",
            encoding="utf-8")
#操作
#向文件写入一个字符串或字节流
myfile.write("123456789\n")
#关闭
myfile.close()

#再次打开
myfile=open(r"C:\Users\霁\Desktop\mytest\mypython\my_IO.txt",
            "a+",
            encoding="utf-8")
#读入一行内容，如果给出参数，读入该行前size长度
print(myfile.readline(size=-1))
myfile.read(size=-1)

#一次读入统一处理,遍历文本的第一种方法
str1=myfile.read()
#读入全部内容，如果给出参数，读入前size=3长度字符或2进制
print(str1)

ls=["中国","北京","上海"]
#a+从文件尾加入内容
#将一个元素全为字符串的列表写入文件，拼接后写入
myfile.writelines(ls)

#myfile.seek(offset) offset=0/1/2  
# 0为文件开头 1为当前位置 2为文件结尾

#写完回到文件头，这样下一行读出来的就不是空值了
myfile.seek(0)
#读入文件所有行，每行为元素形成列表返回，给出参数，读入前hint行
print(myfile.readlines())

myfile.close()

##方法2 按数量读入，逐步处理
# myfile2=open(r"C:\Users\霁\Desktop\mytest\mypython\my_IO.txt","r",encoding="utf-8")
# txt=myfile2.read(2)
# while txt !="":
#     <#对txt处理>
#     txt=myfile2.read(2)#按2个字符进行依次操作
# myfile2.close()


##方法3 逐行操作
# txt2=open("fname","r",encoding="utf-8")
# for line in txt2.readlines():  或者 for line in txt2:
#     print(line)                       #分行读入，逐行处理
# txt2.close()

#lambda函数 定义匿名函数
#<函数名> =lambda <参数>:<表达式>等价于def <函数名>(<参数>)：<函数体> return <返回值>
f=lambda x,y:x+y
print(f(1,2))

#可选参数如m，要放在必选参数后面  
#计算  n!//m 
def mydef(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m
print("不选参数m：{}".format(mydef(2)))
print("选择m：{}".format(mydef(2,2)))
#不确定参数
#计算 n! *其他参数
def mydef2(n,*b):
    s=1
    for i in range(1,n+1):
        s*=i
    for item in b:
        s*=item
    return s
print("b：{}".format(mydef2(2,2)))
print("b：{}".format(mydef2(3,1)))#3!*1
print("b：{}".format(mydef2(3,1,2)))#3!*1*2
print("b：{}".format(mydef2(3,1,2,3)))#3!*1*2*3
#函数可以直接用位置传参数，也可以直接使用参数赋值，如：mydef(m=10,n=5)==mydef(5,10)
#函数可以返回0个或者多个结果，可以有返回值也可以没有
def mydef3(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m,n,m,s
a,b,c,d=mydef3(2)
print(mydef3(2))#元祖类型返回
print(a,b,c,d)#可以将多个返回值分别赋予abcd
#global 用于将局部变量声明成全局变量
#局部变量为组合数据类型且未创建，等同于全局变量 
ls=["1","2"]
def func(a):
    ls=[]#被创建后可以变成局部变量
    ls.append(a)#此处ls未被创建，等同于全局变量，所以是在1，2的基础上+上字符a
    return ls
print(ls,func("c"))#返回的全局和局部

# 哈姆雷特统计

# 获取文本内容
def getText():
    txt=open(
        r"C:\Users\霁\Desktop\mytest\mypython\Hamlet.txt",
        "r",
        encoding="utf-8").read()
    txt = txt.lower()
    # 替换特殊字符
    for ch in '!"@#$%&()+-*/,.:;<=>?[\\]^_‘{|}~':
        txt = txt.replace(ch," ")
    return txt

# 保存文本
hamletTxt = getText()
# 分隔出单词
words = hamletTxt.split()
counts = {}
for word in words:
    #是0则+1=1所以相当于加了一对键值对
    counts[word]=counts.get(word,0)+1
    
#一个元组对应的一个列表项
items=list(counts.items())

#使用匿名函数进行获取多元列表里的第二项
items.sort(key=lambda x:x[1],reverse=True)
#默认从小到大，使用reverse=True让其返回从大到小，
#前面的key=lambda x:x[1]则是让其排序使用count值进行排序，
#即选择多元列表里的第2个，如：[(li,2)]选取2

for i in range(10):
    #将排序好的列表项的键值对分别赋值打印
    word,count = items[i]
    print("{0:<20} {1:>5}".format(word,count))