python常见脚本

python常见脚本

1.插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序；首先将第一个作为已经排好序的，然后每次从后的取出插入到前面并排序；

• 时间复杂度：O(n²)
• 空间复杂度：O(1)
• 稳定性：稳定

def insert_sort(ilist):
    for i in range(len(ilist)):
        for j in range(i):
            if ilist[i] < ilist[j]:
                ilist.insert(j, ilist.pop(i))
                break
    return ilist
 
ilist = insert_sort([4,5,6,7,3,2,6,9,8])
print ilist

2.希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

• 时间复杂度：O(n)
• 空间复杂度：O(n√n)
• 稳定性：不稳定

def shell_sort(slist):
    gap = len(slist)
    while gap > 1:
        gap = gap // 2
        for i in range(gap, len(slist)):
            for j in range(i % gap, i, gap):
                if slist[i] < slist[j]:
                    slist[i], slist[j] = slist[j], slist[i]
    return slist
 
slist = shell_sort([4,5,6,7,3,2,6,9,8])
print slist

3.冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

• 时间复杂度：O(n²)
• 空间复杂度：O(1)
• 稳定性：稳定

list01 = [1,89,546,54,2,58,98]

def sortport():
    for i in range(len(list01)-1):
        for j in range(len(list01)-1-i):
            if list01[j] > list01[j+1]:
                list01[j],list01[j+1] = list01[j+1],list01[j]
    return list01

l = sortport()
print(l)

4.快速排序：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

• 时间复杂度：O(nlog₂n)
• 空间复杂度：O(nlog₂n)
• 稳定性：不稳定

def quick_sort(qlist):
    if qlist == []:
        return []
    else:
        qfirst = qlist[0]
        qless = quick_sort([l for l in qlist[1:] if l < qfirst])
        qmore = quick_sort([m for m in qlist[1:] if m >= qfirst])
        return qless + [qfirst] + qmore
 
qlist = quick_sort([4,5,6,7,3,2,6,9,8])
print qlist

5.选择排序：

第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕

• 时间复杂度：O(n²)
• 空间复杂度：O(1)
• 稳定性：不稳定

def select_sort(slist):
    for i in range(len(slist)):
        x = i
        for j in range(i, len(slist)):
            if slist[j] < slist[x]:
                x = j
        slist[i], slist[x] = slist[x], slist[i]
    return slist
 
slist = select_sort([4,5,6,7,3,2,6,9,8])
print slist

6.计算x的n次方的方法

def power(x,n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

7.计算aa + bb + c*c + ……

def clas(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

8.计算阶乘 n!

#第一种方法
def fac(n):
    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))
       
#第二种方法
def factorial(n):
    result = 1
    for i in range(1,n):
        result *= i
    return result
#第三种方法
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

9.列出当前目录下的所有文件和目录名

[d for d in os.listdir('.')]

10.把一个list中所有的字符串变成小写：

l = ['Hello','World','IBM','Apple']
a = [s.lower() for s in l]
print(a)

11.有一本100页的书,可以一天看一页,也可以一天看两页,总共有多少种看法?

def read_book(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return read_book(n-1) + read_book(n-2)

a = read_book(10)
print(a)

12.输出某个路径下的所有文件和文件夹的路径

import os

def print_dir():
    filepath = input("请输入一个路径：")
    if filepath == "":
        print("请输入正确路径")
    else:
        for i in os.listdir(filepath):   #获取目录中的文件及子目录列表
            print(os.path.join(filepath,i)) #把路径组合起来

print(print_dir())

13.输出某个路径及其子目录下的所有文件路径

import os

def show_dir(filepath):
    for i in os.listdir(filepath):
        path = (os.path.join(filepath,i))
        print(path)
        if os.path.isdir(path):   #isdir()判断是否是目录
            show_dir(path)        #如果是目录，使用递归方法

filepath = "C:\Program File\Internet Explorer"
show_dir(filepath)

14.输出某个路径及其子目录下所有以.html为后缀的文件

import os

def print_dir(filepath):
    for i in os.listdir(filepath):
        path = os.path.join(filepath,i)
        if os.path.isdir(path):
            print_dir(path)
        if path.endswith(".html"):
            print(path)

filepath = "E:\PycharmProjects"
print_dir(filepath)

15.把原字典的键值对颠倒并生产新的字典

dict01 = {"A":"a","B":"b","C":"c"}
dict02 = {y:x for x,y in dict01.items()}
print(dict02)

#{'a': 'A', 'b': 'B', 'c': 'C'}

16.打印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        #print('{}x{}={}\t'.format(j,i,i*j),end='')   #两种都可以
        print('%dx%d=%d\t'%(i,j,i*j),end='')
    print()

17.替换列表中所有的3为3a

num = ["harden","lampard",3,34,45,56,76,78,3,3,3]
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)

18.打印每个名字

l = ["James","Meng","Xin"]
for i in range(len(l)):
    print("Hello ,%s"%l[i])

19.合并去重

list01 = [2,3,8,4,9,5,6]
list02 = [5,6,10,17,11,2]
list03 = list01 + list02
print(list03)
print(set(list03))
print(list(set(list03)))

20.随机生成验证码的两种方式

#第一种方法
import random

list01 = []
for i in range(65,91):
    list01.append(chr(i)) #通过for循环遍历assi追加到空列表中
for j in range(97,123):
    list01.append(chr(j))
for k in range(48,58):
    list01.append(chr(k))

ma = random.sample(list01,6)
print(ma)                       #获取到的为列表
ma = ''.join(ma)           #将列表转化为字符串
print(ma)

#第二种方法
import random,string

str01 = "0123456789"
str02 = string.ascii_letters   #string.ascii_letters 包含所有字母(大写或小写)的字符串
str03 = str01 + str02
ma1 = random.sample(str03,6)
ma2 = ''.join(ma1)
print(ma2)

21.猜数字游戏

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输入的数字与电脑随机数%d一样"%(i,b))

22.计算平方根

num = float(input("请输入一个数字："))
num_sqrt = num ** 0.5
print('%0.2f 的平方根为 %0.2f'%(num,num_sqrt))

23.判断字符串是否只由数字组成

#第一种方法
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

c = is_number("455")
print(c)
#第二种方法
print("chri".isdigit())  # 检测字符串是否只由字符串组成
print("000".isnumber())  # 检测字符串是否只由字符串组成，这种方法只针对unicode对象

24.判断奇偶数

#第一种方法
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

25.判断闰年

#第一种方法
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

year = int(input("请输入年份："))
check_year=calendar.isleap(year)
if check_year == True:
    print ("%d是闰年"% year)
else:
    print ("%d是平年"% year)

26.获取最大值

#第一种方法
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))

#第三种方法(不适用内置函数)
def getMax(arr):
    for i in range(0, len(arr)):
        for j in range(i + 1, len(arr)):
            first = int(arr[i])
            second = int(arr[j])
            if first < second:
                arr[i] = arr[j]
                arr[j] = first
    print(arr[0])

arr = [19, 29, 30, 48]
getMax(arr)

27.斐波那契数列

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13；特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。

# 判断输入的值是否合法
if nterms <= 0:
  print("请输入一个正整数。")
elif nterms == 1:
  print("斐波那契数列：")
  print(n1)
else:
  print("斐波那契数列：")
  print(n1, ",", n2, end=" , ")
  while count < nterms:
    nth = n1 + n2
    print(n1+n2, end=" , ")
    # 更新值
    n1 = n2
    n2 = nth
    count += 1

28.十进制转二进制、八进制、十六进制

# 获取输入十进制数
dec = int(input("输入数字："))

print("十进制数为：", dec)
print("转换为二进制为：", bin(dec))
print("转换为八进制为：", oct(dec))
print("转换为十六进制为：", hex(dec))

29.最大公约数

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 = i

  return hcf

# 用户输入两个数字
num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))

print(num1, "和", num2, "的最大公约数为", hcf(num1, num2))

30.最小公倍数

# 定义函数
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))

31.简单计算器

# 定义函数
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("非法输入")

32.生成日历

# 引入日历模块
import calendar

# 输入指定年月
yy = int(input("输入年份: "))
mm = int(input("输入月份: "))

# 显示日历
print(calendar.month(yy, mm))

33.文件IO

# 写文件
with open("test.txt", "wt") as out_file:
    out_file.write("该文本会写入到文件中\n看到我了吧！")

# Read a file
with open("test.txt", "rt") as in_file:
    text = in_file.read()

print(text)

34.字符串判断

# 测试实例一
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、\n、\r

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())

35.字符串大小写转换

str = "https://www.cnblogs.com/ailiailan/"
print(str.upper())          # 把所有字符中的小写字母转换成大写字母
print(str.lower())          # 把所有字符中的大写字母转换成小写字母
print(str.capitalize())     # 把第一个字母转化为大写字母，其余小写
print(str.title())          # 把每个单词的第一个字母转化为大写，其余小写

36.计算每个月天数

import calendar
monthRange = calendar.monthrange(2016,9)
print(monthRange)

37.获取昨天的日期

# 引入 datetime 模块
import datetime
def getYesterday(): 
    today=datetime.date.today() 
    oneday=datetime.timedelta(days=1) 
    yesterday=today-oneday  
    return yesterday
 
# 输出
print(getYesterday())

38.列表去重

#方法一
def delList(L):
    L1 = [ ]
    for i in L:
        if i not in L1:
            L1.append(i)
    return L1
print(delList(L1))

#方法二：去重
L1=list（set（L））

#a = [2,2,2,2,6,84,5,9]
#print(delList(a))
#a2 = list(set(a))
#print(a2)

39.列表插入

l = [1,2,3]
l.insert(0,4)         #在列表的索引处插入  
print(l)

40.列表元素替换

x = "hello world "
y = x.replace("hello","hi")
print(y)                                               # 结果为：hi world

41.a=1,b=2,不用中间变量交换 a 和 b 的值?

#方法一:
a = a+b
b = a-b
a = a-b
#方法二:
a = a^b
b =b^a
a = a^b
#方法三:
a,b = b,a

42.下面这段代码的输出结果将是什么?请解释?

class Parent(object):
    x=1
class Child1(Parent):
    pass
class Child2(Parent):
    pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print( Parent.x, Child1.x, Child2.x)
Parent.x = 3
print( Parent.x, Child1.x, Child2.x)

#结果为:
1 1 1        #继承自父类的类属性 x,所以都一样,指向同一块内存地址。
1 2 1        #更改 Child1,Child1 的 x 指向了新的内存地址。
3 2 3        #更改 Parent,Parent 的 x 指向了新的内存地址。

43.阅读下面的代码,写出 A0,A1 至 An 的最终值。

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))          
A1 = range(10)                                                                
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]                  #[]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]
#结果为：
A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}
A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A2 = []
A3 = [1, 3, 2, 5, 4]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36],[7, 49],[8, 64] [9,81]]

44.考虑以下 Python 代码,如果运行结束,命令行中的运行结果是什么?

l = []
for i in range(10):
    l.append({'num':i})
print (l)

#结果为：
 [{'num':0},{'num':1},{'num':2},{'num':3},{'num':4},{'num':5},{'num':6},{'num':7},{'num':8},{'num':9}]

再考虑以下代码,运行结束后的结果是什么?

l = []
a = {'num':0}
for i in range(10):
    a['num'] = i
    l.append(a)
print(l)

#结果为：
 [{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9}]

45.返回文件及其子文件路径

def print_directory_contents(sPath):
 """
这个函数接收文件夹的名称作为输入参数
返回该文件夹中文件的路径
以及其包含文件夹中文件的路径
"""
# ------------代码如下--------------------
    import os
    for sChild in os.listdir(sPath):
        sChildPath = os.path.join(sPath, sChild)
        if os.path.isdir(sChildPath):
            print_directory_contents(sChildPath)
        else:
            print(sChildPath)

46.输入某年某月某日,判断这一天是这一年的第几天?(可以用 Python 标准库)

import datetime
def dayofyear():
    year = input("请输入年份:")
    month = input("请输入月份:")
    day = input("请输入天:")
    date1 = datetime.date(year=int(year),month=int(month),day=int(day))
    date2 = datetime.date(year=int(year),month=1,day=1)
    return (date1 - date2 + 1).days

47.打乱一个排好序的 list 对象 alist?

import random
alist = [1,2,3,4,5,98,56]
random.shuffle(alist)
print(alist)

48.Python 是如何进行类型转换的?

int(x,base=10)                #x字符串或数字，base进制数，默认十进制 浮点转为整数
float                                                          #整数转换为浮点型
complex(1,2)                                        #转换为复数
str(10)                                                     #将对象转换为字符串
repe()                                                      #将对象转换为表达式字符串
repr(dict)                                              #将对象转换为表达式字符串
eval(str)                                #用来计算在字符串中有效的python表达式，返回一个对象
tuple(listi)                                           #将列表转化为元组
list()                                                      #将元组转换为列表
set                                                         #转换集合

49.按 alist 中元素的 age 由大到小排序

alist =[{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
def sort_by_age(list1):
    return sorted(alist,key=lambda x:x['age'],reverse=True)

re = sort_by_age(alist)
print(re)

50.写一个列表生成式,产生一个公差为 11 的等差数列?

print([x*11 for x in range(10)])

51.给定两个列表,怎么找出他们相同的元素和不同的元素?

1. list1 = [1,2,3]
2. list2 = [3,4,5]
3. set1 = set(list1)
4. set2 = set(list2)
5. print(set1&set2)
6. print(set1^set2)

52.请写出一段 Python 代码实现删除一个 list 里面的重复元素?

比较容易记忆的是用内置的 set:

l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
print(l2)

如果想要保持他们原来的排序:
用 list 类的 sort 方法:

l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index)
print (l2)

也可以这样写:

l1 = ['b','c','d','b','c','a','a']
l2 = sorted(set(l1),key=l1.index)
print (l2)

也可以用遍历:

l1 = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
        print (l2)

53.获取 1~100 被 6 整除的偶数?

def A():
    alist = []
    for i in range(1,100):
        if i % 6 == 0:
            alist.append(i)
    print(alist)

A()

54.将以下 3 个函数按照执行效率高低排序

def f1(lIn):
    l1 = sorted(lIn)
    l2 = [i for i in l1 if i<0.5]
    return [i*i for i in l2]

def f2(lIn):
    l1 = [i for i in l1 if i<0.5]
    l2 = sorted(l1)
    return [i*i for i in l2]

def f3(lIn):
    l1 = [i*i for i in lIn]
    l2 = sorted(l1)
    return [i for i in l1 if i<(0.5*0.5)]

按执行效率从高到低排列:f2、f1 和 f3。要证明这个答案是正确的,你应该知道如何分析自己代码的性能。Python
中有一个很好的程序分析包,可以满足这个需求。

import random
import cProfile
lIn = [random.random() for i in range(100000)]
cProfile.run('f1(lIn)')
cProfile.run('f2(lIn)')
cProfile.run('f3(lIn)')

55.请尝试用“一行代码”实现将 1-N 的整数列表以 3 为单位分组,比如 1-100 分组后为?

print([[x for x in range(1,100)][i:i+3] for i in range(0,len(list_a),3)])

56.给定一个 int list a,满足 a[i + 1]>=a[i],给定 int key找出 list a 中第一个大于等于 key 的元素的 index,无满足要求的元素则返回-1

def findindex(int_list,int_key):
    int_list = sorted(int_list)
    for i in range(len(int_list)):
        if int_list[i] == int_key:
            return i
    return -1
if __name__ == "__main__":
    lista = [12,3,4,5,8,6]
    index = findindex(lista,5)
    print(index)

57.字典转换为字符串

a = {"name":"jack","age":30}
#现在需要生成字符串：name=jack|age=30
#请用一行代码实现：
s = '|'.join([str(x)+'='+str(a[x]) for x in a])

58.请将这两个list合并，去重并按照升序排列

list1 = [2, 3, 8, 4, 9, 5, 6]
list2 = [5, 6, 10, 17, 11, 2]
list_new = list1 + list2
list = []
for x in list_new:
	if x not in list:
		list.append(x)
list.sort()
print(list)

59.写一段程序，判断字符串内左右括号是否配对

class SStack():
    def __init__(self):
        self.__elem = []
    def is_empty(self):
        return self.__elem == []
    def top(self):
        return self.__elem[-1]
    def push(self,elem):
        self.__elem.append(elem)
    def pop(self):
        return self.__elem.pop()

def kuohao(text):
    kinds = "()[]{}" #用来定义出现的括号，因为待匹配的字符中含有其他的字符，我们值检查括号是否匹配，而且是只有出现括号后再进行匹配
    zuo = "([{"   #定义左括号，如果是左括号就入栈
    dict0 = {")":"(","]":"[","}":"{"} #匹配字典，这个字典定义了匹配规则，如果字典的键值对匹配就可以认定括号是匹配的
    def pipei(text):     #将等待匹配的文本输入，这个函数的目标是从文本中过滤出括号
        i,text_len = 0,len(text) #扫描指针用来记录匹配位置
        while True:
            while  i< text_len and text[i] not in kinds: #用来寻找到括号
                i += 1
            if i >= text_len: #如果字符串中没有包含括号则结束
                return
            yield text[i],i  #返回括号字符和字符对应的下标
            i += 1

    st = SStack()
    for text0,i in pipei(text):#获取得到的符号进行匹配,因为pipei（）是一个含有yield函数，所以是一个生成器，调用它会产生一个可迭代的对象
        if text0 in zuo: #如果是左括号就让它入栈
            #print(text0)
            st.push(text0)
        elif st.pop() != dict0[text0]:#如果是右括号，就弹出栈顶元素进行匹配检查
            print("本次不匹配")
            return False #遇到不匹配的，就直接退出函数，结束匹配
    print("所有的括号都已经匹配完毕，匹配成功！") #如果函数还能够执行到这里说明所有的括号都是匹配的
    return True
#kuohao("({{[]}})")
kuohao("[{}]")

60.将一个正整数分解质因数。例如输入90，打印90=233*5.

n = num = int(input('请输入一个数字：'))  # 用num保留初始值
f = []  # 存放质因数的列表

for j in range(int(num / 2) + 1):  # 判断次数仅需该数字的一半多1次
    for i in range(2, n):
        t = n % i  # i不能是n本身
        if t == 0:  # 若能整除
            f.append(i)  # 则表示i是质因数
            # 除以质因数后的n重新进入判断，注意应用两个除号，使n保持整数	
            n = n // i
            break  # 找到1个质因数后马上break，防止非质数却可以整除的数字进入质因数列表

if len(f) == 0:  # 若一个质因数也没有
    print('该数字没有任何质因数。')
else:  # 若至少有一个质因数
    f.append(n)  # 此时n已被某个质因数整除过，最后一个n也是其中一个质因数
    f.sort()  # 排下序
    print('%d=%d' % (num, f[0]), end='')
    for i in range(1, len(f)):
        print('*%d' % f[i], end='')

61.实现一个函数，在给定数组中寻找第2 大的数。

def fn():
	a=[1,3,5,7,9]
	return sorted(a[1])

62.求二叉树深度

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution(object):
    def isBalanced(self, root):
        if root==None:
            return 0
        leftheight=self.isBalanced(root.left)
        rightheight=self.isBalanced(root.right)
        if leftheight>=rightheight:
            return leftheight+1
        else:
            return rightheight+1
input_3=TreeNode(3)
input_4=TreeNode(4)
input_5 = TreeNode(5)
input_5.left=input_3
input_5.right=input_4
input_18 = TreeNode(18)
input_all = TreeNode(2)
input_all.left = input_5
input_all.right = input_18
slu_ = Solution()
print (input_all)
t = slu_.isBalanced(input_all)
print (t)

63.求两个字符串的最长公共子串

def initindexs(char, string):
    index = []
    length = len(string)
    for i in range(length):
        if char == string[i]:
            index.append(i + 1)  # 保存相同字符坐标+1的位置
    return index

def Substring(str1, str2):
    str1_len = len(str1)
    str2_len = len(str2)
    length = 0
    longest = 0
    startposition = 0
    start = 0
    for i in range(str1_len):
        start = i
        index = initindexs(str1[i], str2)
        index_len = len(index)
        for j in range(index_len):
            end = i + 1
            while end < str1_len and index[j] < str2_len and str1[end] == str2[index[j]]:  # 保证下标不会超出列表范围
                end += 1
                index[j] += 1
            length = end - start
            if length > longest:
                longest = length
                startposition = start

    return startposition, longest

str1 = "pmcdcdfe"
str2 = 'aoccddcdfe'
Substring(str1, str2)
(start, longest) = Substring(str1, str2)
print(start, longest)
for i in range(longest):
    print(str1[start + i], end=' ')

64.如何快速计算两个list的交集、并集

#简单的方法：
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [2, 5, 8, 11, 0]
# 交集（intersection）
intersection = [v for v in a if v in b]
# 并集（ union）
union = b.extend([v for v in a])

#高效的方法：
# 交集（intersection）
intersection = list(set(a).intersection(set(b)))
# 并集（union）
union = list(set(a).union(set(b)))

65.翻转一个字符串s = “abcdef”

string = 'abcdef'
#第一种方法
def string_reverse1(string):
    return string[::-1]
#第二种方法
def string_reverse2(string):
    t = list(string)
    l = len(t)
    for i,j in zip(range(l-1,0,-1),range(1/2)):
        t[i],t[j] = t[j],t[i]
    return "".join(t)
#第三种方法
def string_reverse3(string):
    if len(string) <= 1:
        return string
    return string_reverse3(string[1:] + string[0])
#第四种方法
from collections import deque
def string_reverse4(string):
    d = deque()
    d.extendleft(string)
    return ''.join(d)
#第五种方法
def string_reverse5(string):
    # return ''.join(string[len(string) - i] for i in range(1,len(string) + 1))
    return  ''.join(string[i] for i in range(len(string) -1 ,-1,-1))

print(string_reverse1(string))   #fedcba
print(string_reverse1(string))   #fedcba
print(string_reverse1(string))   #fedcba
print(string_reverse1(string))   #fedcba
print(string_reverse1(string))   #fedcba

66.判断一个字符串是否为回文字符串（将字符串反转之后，得到的字符串同原字符串，称为回文字符串

s = input("请输入文字: ")
# 反转字符串s
r = s[::-1]
if s == r:
    print(s, "是回文")
else:
    print(s, "不是回文")