l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

find_num = int(input('请输入一个数字：'))

start = 0

end = len(l) - 1

while True:

    middle = (start + end) // 2

    if find_num == l[middle]:

        print('找到了！索引是：', middle)

        break

    elif find_num > l[middle]:

        start = middle + 1

    elif find_num < l[middle]:

        end = middle - 1

    if start > end:

        print('没找到!', find_num)

        break

#一个有序数列类似[1,2,3,3,4,4,5,5,5,6,7,8,8]

#输入5 用二分法 输出 5 的起始下标和 末尾下标

def searchRange(nums, target):

    if len(nums) == 0:

        return [-1,-1]

    elif target < nums[0] or target > nums[-1]:

        return [-1,-1]

    else:

        l, r = 0, len(nums) - 1

        while l <= r:

            mid = (l + r) // 2

            if target > nums[mid]:

                l = mid + 1

            elif target < nums[mid]:

                r = mid - 1

            elif target == nums[mid]:

                l = r = mid

                while l-1 >= 0 and nums[l-1] == target:

                    l -= 1

                while r+1 <= len(nums)-1 and nums[r+1] == target:

                    r += 1

                return [l,r]

    return [-1,-1]

nums = [1,3,4,6,8,8,9,10]

a = searchRange(nums,8)

print(a)

'''

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”。

'''

import random

# 步骤2：创建一个空列表，用于存放待排序随机数据集

data = [random.randint(0, 100) for i in range(10)]

print('待排序的随机数列: {0}'.format(data))

# 步骤3：使用嵌套循环实现冒泡排序

# 外层循环控制排序的次数

for i in range(10):

    # 内层循环控制每次对比的次数

    for j in range(len(data)-1-i):

        # 如果前项值大于后项值则对位交换，将大的在列表中后移1位

        if data[j] > data[j+1]:

            temp = data[j]

            data[j] = data[j+1]

            data[j+1] = temp

            pass

# 步骤4：输出排序后的结果

print('排序后的有序序列: {0}'.format(data))

#交换排序.冒泡排序

L = [1, 3, 2, 32, 5, 4]

def Bubble_sort(L):

    for i in range(len(L)):

        for j in range(i+1,len(L)):

            if L[i]>L[j]:

                # temp = L[j]

                # L[j] = L[i]

                # L[i] = temp

                L[i], L[j] = L[j], L[i]#交换顺序

    print (L)

Bubble_sort(L)

ids = [1,2,3,3,4,2,3,4,5,6,1,6,4,3,2,3,]

news_ids = []

for id in ids:

    if id not in news_ids:

        news_ids.append(id)

print (news_ids)

#python 列表去重(数组)的几种方法 - 朝阳的向日葵 - 博客园  https://www.cnblogs.com/zknublx/p/6042295.html

ids = list(set(ids))

print(ids)  #一句话列表去重

#lambda 一句话列表去重

a=(lambda x,y:x if y in x else x + [y], [[],] + ids)

print(a)

l=[1,2,[3,4,[5,6],[7,8],9],10]

l1=[]

#递归函数实现：

def getitem(l):

    for item in l:

        if isinstance(item,list):

            getitem(item)

        else:

            print(item)

            l1.append(item)

getitem(l)

print(l1)

#python利用递归函数输出嵌套列表的每个元素 - lincappu - 博客园  https://www.cnblogs.com/lincappu/p/8146055.html

a=[1,2,3,3,3,3,7,7,8,8,10]

print(a)

news_ids = []

for id in a:

    if id not in news_ids:

        news_ids.append(id)

print (news_ids)

for i in news_ids:

    if a.count(i) >= 1:

        print('%s 出现了%d 次!'%(i, a.count(i)))

#纯手写

a=[0,1,2,3,4,5,6,7,8,9,10]

b=[]

print(a[::-1]) #逆输出

#手写代码

count=len(a)

for i in range(len(a),0,-1):

    count-=1

    b.append(a[count])

print(b)

str='mynameisbobiamfromchina嘿嘿嘿嘿'

str=','.join(str) #以逗号分隔字符串

print(str)

li=str.split(',')

print(li) #变成列表了

#统计每一个字符出现的次数:

for i in set(li):

    if li.count(i) >= 1:

        print('%s 出现了%d 次!'%(i, li.count(i)))

print('*'*50)

#方式二

from collections import Counter

res = Counter(li)

print(res)

dic=b'{"name":"ltf","school":"tyut"}'

str(dic, encoding="utf-8")

print(dic)

dicBytes = dic.decode('utf-8')

print(dicBytes)

print(eval(dicBytes)) #字符串转换为字典

print(eval(dicBytes).keys())

#修改key

dict = {'a':'ltf','b':'fjf'}

dict.update({'':dict.pop("a")})

dict.update({'':dict.pop("b")})

print(dict)

#coding:utf-8

#author:徐卜灵

#交换排序.快速排序

# 虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：

# import sys

# sys.setrecursionlimit(150000)

L = [6, 3, 2, 32, 5, 4]

def Fast_sort(L, left,right):

    if left >= right:

        return L

    key = L[left]

    low = left

    high = right

    while left < right:

        # if L[right] > key:

        #     right-=1

        # else:

        #     L[left] = L[right]

        # if L[left] <= key:

        #     left += 1

        # else:

        #     L[right] = L[left]

        # L[left] = key

        while left < right and L[right] >= key:

            right -= 1

        L[left] = L[right]

        while left < right and L[left] <= key:

            left += 1

        L[right] = L[left]

    L[left] = key

    Fast_sort(L, low, left - 1)

    Fast_sort(L,left + 1,high)

    return L

print (Fast_sort(L,0,5))

#1.高质量代码

def quick_sort(lists, left, right):

    # 快速排序

    if left >= right:

        return lists

    key = lists[left]

    low = left

    high = right

    while left < right:

        while left < right and lists[right] >= key:

            right -= 1

        lists[left] = lists[right]

        while left < right and lists[left] <= key:

            left += 1

        lists[right] = lists[left]

    lists[left] = key

    quick_sort(lists, low, left - 1)

    quick_sort(lists, left + 1, high)

    return lists

print (quick_sort(L,0,5))

#2.高质量代码

# # 设置最低位和最高位

# def quickSort(nums, low, high):

#     # 设置一个比较基准key

#     key = nums[low]

#     while low<high:

#         # 如果最高位的数 大于等于 key则向前走

#         while low<high and nums[high] >= key:

#             high -= 1

#         # 如果最低位的数 小于等于 key则向后走

#         while low<high and nums[low] <= key:

#             low += 1

#         # 交换值

#         nums[low], nums[high] = nums[high], nums[low]

#

#     #最后low=high, 此时交换key和high位上的值, 使小于key的值在key左边, 大的在key右边

#     nums[nums.index(key)], nums[low] = nums[low], nums[nums.index(key)]

#     # 返回最低位的位置

#     return low

#

#

# # 进行重复操作

# def interval(nums, low, high):

#     if low<high:

#         # 进行排序并得到最低位位置以循环操作

#         key_index = quickSort(nums, low, high)

#         interval(nums, low, key_index)

#         interval(nums, key_index+1, high)

#

#

# nums = [64,3,9,2,4,7,0,12,45,]

# interval(nums, 0, len(nums)-1)

# print nums

#

for i in range(10):

    for j in range(0, 10 - i):

        print(end=" ")

    for k in range(10 - i, 10):

        print("*", end=" ")

    print("")

for l in range(10):

    for m in range(l):

        print(" ",end="")

    for n in range(10-l):

        print("*",end=" ")

    print("")

num=[1,2,3,4,5,6,7,8,9,0]

cn=['壹','贰','叁','肆','伍','陆','柒','捌','玖','零']

dw=['元','十','百','千','万','十','百','千']

n=str(input('请输入数字:'))

c=len(n)-1

# print c

ln=''

c1=0

for i in n:

    nb = int(i) - 1

    if i=='' and c1==0:

        c1=1

        pass

    else:

        if c1==1:

           c1=0

        ln=ln+ cn[nb]+dw[c]

        print(ln)

    c=c-1

print(ln)

# num=input('请输入一个数:')

# a=[]

# li=list(num)

# print(li)

# count=len(li)

# for i in range(len(li),0,-1):

#     count-=1

#     a.append(li[count])

# print(a)

num=input('请输入一个数:')

a=[]

str=''

print(num)

count=len(num)

for i in range(len(num),0,-1):

    count-=1

    a.append(num[count])

b=str.join(a)

print(int(b))

#最简单的方法为数组，其次为循环，最垃圾的为递归，到了40就算好久。。日后再琢磨数组

a=[1,1]

def fn(n):

    count=0

    f0=1

    f1=1

    f2=0

    while count<n:

        count+=1

        f2=f1+f0

        f0=f1

        f1=f2

        a.append(f2)

    print('第%s项的项数为:%s'%(b,f2))

    print('斐波那契数列为:')

    print(a)

b=int(input('请输入项数:'))

fn(b-2)

def merge_sort(a, b):

    ret = []

    i = j = 0

    while len(a) >= i + 1 and len(b) >= j + 1:

        if a[i] <= b[j]:

            ret.append(a[i])

            i += 1

        else:

            ret.append(b[j])

            j += 1

    if len(a) > i:

        ret += a[i:]

    if len(b) > j:

        ret += b[j:]

    return ret

if __name__ == '__main__':

    a = [1,3,4,6,7,78,97,190]

    b = [2,5,6,8,10,12,14,16,18]

    print(merge_sort(a, b))

#如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？

# 这样就不必创建完整的list，从而节省大量的空间。

# 在Python中，这种一边循环一边计算的机制，称为生成器（Generator）

def fib(max):

    n, a, b = 0, 0, 1

    while n < max:

        yield b

        a, b = b, a + b

        n = n + 1

fib(8)

#生成器调用方法，其实是

#装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。

def outer(func):

    def inner(*args,**kwargs):

        print("认证成功！")

        result = func(*args,**kwargs)

        print("日志添加成功")

        return result

    return inner

@outer

def f1(name,age):

    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法

f1("jack",18)

#装饰器调用方法，其实是把函数 f1 当成 outer的参数 

#1.直接插入排序

L = [1, 3, 2, 32, 15, 5, 4]

def Insert_sort(L):

    for i in range(1,len(L)):

        for j in range(0,i):#这里面其实也是从前向后比较

            if L[i]<L[j]:

                L.insert(j,L[i])#在不大于的位置插入L[i],这个时候，列表加长了1位,L[i]插入到指定位置了，但它的值也向后移动了一位

                L.pop(i+1)#把原来L[i]的值删除。

    print(L)

    #空间复杂度为O（1），时间复杂度为O（n*n）

Insert_sort(L)

# print sorted(L)#自带的两种排序

# L.sort()

# print L

L = [6, 3, 2, 32, 5, 4]

def Select_sort(L):

    for i in range(0,len(L)):

        for j in range(i,len(L)):

            if L[i] > L[j]:         #打擂台的形式

                # temp = L[i]

                # L[i] = L[j]

                # L[j] = temp

                L[i],L[j] = L[j],L[i]

    return  L

print (Select_sort(L))

'''

bob_ltf 输出 bobLtf

'''

s='bob_ltf_lsq_fjf'

s1=''

s2=''

arr=s.split('_') #列表

print(arr)

s1=s1.join(arr[1:])

print(s1.capitalize())

s2=s2.join(arr[:1])

s3=s2+s1.capitalize()

print(s3)

'''

输出结果

['bob', 'ltf', 'lsq', 'fjf']

Ltflsqfjf

bobLtflsqfjf

'''