1.python語言有哪些特點
python是一門面向物件的解釋性語言
解釋型，開源，簡單，易學，免費
可擴充套件性，豐富的庫，可移植性，面向物件
規範的程式碼（十分嚴格）

2.列舉你所知道的排序演算法，並用python語言實現一個排序
部落格https://blog.csdn.net/mxz19901102/article/details/80087596
插入排序
希爾排序
氣泡排序
快速排序
選擇排序
堆排序
基數排序
歸併排序
3.python中的可變引數和關鍵字引數
可變引數：在Python函式中，可以定義可變引數。顧名思義，可變引數就是傳入的引數個數是可變的，可以是1個、2個到任意個，還可以是0個。定義可變引數和定義普通引數相比，僅僅在引數前面加了一個*號，例如def cul(nums)。
關鍵字引數：可變引數允許你傳入0個或任意個引數，這些可變引數在函式呼叫時自動組裝為一個tuple。而關鍵字引數允許你傳入0個或任意個含引數名的引數，這些關鍵字引數在函式內部自動組裝為一個dict。在引數前加2個

第四題

def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print(l)
f(2)#[0, 1]
f(3,[3,2,1])#列表內元素可重複 [3,2,1]+0 [0,1,,1,2,3,4]
f(3)#[0,1,,4]

5.下面這些是什麼意思:@classmethod,@staticmethod,@property
連結https://www.cnblogs.com/wangyongsong/p/6750454.html
什麼是特性property，property是一種特殊的屬性，訪問它時會執行一段功能（函式）然後返回值
為什麼要用property
將一個類的函式定義成特性以後，

import math
class Circle:
    def __init__(self,radius): #圓的半徑radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #計算面積

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #計算周長

c=Circle(10)
print(c.radius)
print(c.area) #可以向訪問資料屬性一樣去訪問area,會觸發一個函式的執行,動態計算出一個值
print(c.perimeter) #同上
'''
輸出結果:
314.1592653589793
62.83185307179586
'''
 

6.程式設計：輸入一個字串，輸出該字串中字元的所有組合
例如:輸入字串"1 2 3" 則輸出為1,2,3,12,13,23,123，不考慮順序，所以12,21的等價

7.談談你所知道的python web框架
Django flask web.py Tornado web2.py

8.python程式設計實現斐波那數列
斐波那契數列指的是這樣一個數列 0, 1, 1, 2, 3, 5, 8, 13,特別指出：第0項是0，第1項是第一個1。從第三項開始，每一項都等於前兩項之和。
Python 實現斐波那契數列程式碼如下：

	# 獲取使用者輸入資料

nterms = int(input(“你需要幾項？”))

第一和第二項
n1 = 0
n2 = 1
count = 2

判斷輸入的值是否合法

if nterms <= 0:
   print("請輸入一個正整數。")
elif nterms == 1:
   print("斐波那契數列：")
   print(n1)
else:
   print("斐波那契數列：")
   print(n1,",",n2,end=" , ")
   while count < nterms:
       nth = n1 + n2
       print(nth,end=" , ")
       # 更新值
       n1 = n2
       n2 = nth
       count += 1

a=0
b=1
while b < 1000:
    print(b)
    a, b = b, a+b

遞迴方式實現斐波那契數列 前n項:

# 遞迴方式實現 生成前20項

lis =[]
for i in range(20):

if i ==0 or i ==1:#第1,2項 都為1

lis.append(1)

else:

lis.append(lis[i-2]+lis[i-1])#從第3項開始每項值為前兩項值之和

print(lis)

簡述left join 和right join

left join(左聯接) 返回包括左表中的所有記錄和右表中聯結欄位相等的記錄
right join(右聯接) 返回包括右表中的所有記錄和左表中聯結欄位相等的記錄
inner join(等值連線) 只返回兩個表中聯結欄位相等的行

給定一個無序的整數陣列a[],其中有n個整數 請寫程式找到其中的中位數
1.取前len(nums)/2個元素建立小頂堆。可以知道堆頂元素是前len(nums)/2個元素中最小的。

2.從第len(nums)/2+1個元素開始，依次將其與堆頂元素比較。若比對頂元素大，則替換之，並調整堆。

3.陣列剩下的所有元素比較完後，可以輸出中位數。陣列長度為奇數時，輸出堆頂元素即可。陣列長度為偶數時，輸出堆頂元素與它的孩子結點中較小的那個的均值。

	#coding:utf-8
 
def heap_adjust(parent,heap):   #更新結點後進行調整
    child=2*parent+1
    while len(heap)>child:
        if child+1<len(heap):
            if heap[child+1]<heap[child]:
                child+=1
        if heap[parent]<=heap[child]:
            break
        heap[parent],heap[child]=heap[child],heap[parent]
        parent,child=child,child*2+1
 
def find(nums):
    heapnum=len(nums)//2
    heap=nums[:heapnum+1]
    for i in range(len(heap)//2-1,-1,-1):   #前n/2個元素建堆
        heap_adjust(i,heap)
    for j in range(heapnum+1,len(nums)):
        if nums[j]>heap[0]:
            heap[0]=nums[j]
            heap_adjust(0,heap)
    #奇數時是最中間的數，偶數時是最中間兩數的均值
    return heap[0] if len(nums)%2==1 else float(heap[0]+min(heap[1],heap[2]))/2

python給定一個有序的整數陣列a[],其中有n個整數,請寫程式找到其中是否包含值等於
給定一個無序的整數陣列a[],其中有n個整數，自己實現一個排序演算法(不能呼叫系統排序函式)，輸出排序後結果

思路:冒泡法排序

封裝一個工具,操作redis,不管什麼埠來的,給一個鍵,返回值,封裝成一個工具

import redis

class MyRedis():
    def __init__(self,ip,password,port=6379,db=1):#建構函式
        try:
            self.r = redis.Redis(host=ip,password=password,port=port,db=db)  #連線redis固定方法,這裡的值必須固定寫死
        except Exception as e:
            print('redis連線失敗，錯誤資訊%s'%e)
    def str_get(self,k):
        res = self.r.get(k)   #會從伺服器傳對應的值過來，效能慢
        if res:
            return res.decode()   #從redis裡面拿到的是bytes型別的資料，需要轉換一下

    def str_set(self,k,v,time=None): #time預設失效時間
        self.r.set(k,v,time)

    def delete(self,k):
        tag = self.r.exists(k)
        #判斷這個key是否存在,相對於get到這個key他只是傳回一個存在火災不存在的資訊，
        # 而不用將整個k值傳過來（如果k裡面存的東西比較多，那麼傳輸很耗時）
        if tag:
            self.r.delete(k)
        else:
            print('這個key不存在')

    def hash_get(self,name,k):  #雜湊型別儲存的是多層字典（巢狀字典）
        res = self.r.hget(name,k)
        if res:
            return res.decode()  #因為get不到值得話也不會報錯所以需要判斷一下

    def hash_set(self,name,k,v): #雜湊型別的是多層
        self.r.hset(name,k,v)   #set也不會報錯

    def hash_getall(self,name):
        res = self.r.hgetall(name)   #得到的是字典型別的，裡面的k,v都是bytes型別的
        data={}
        if res:
            for k,v in res.items(): #迴圈取出字典裡面的k,v，在進行decode
                k = k.decode()
                v = v.decode()
                data[k]=v
        return data

    def hash_del(self,name,k):
        res = self.r.hdel(name,k)
        if res:
            print('刪除成功')
            return 1
        else:
            print('刪除失敗，該key不存在')
            return 0

    @property   #屬性方法，
                # 使用的時候和變數一個用法就好比例項，A=MyRedis(), A.clean_redis使用，
                # 如果不加這個@property,使用時A=MyRedis(), A.clean_redis()   後面需要加這個函式的括號
    def clean_redis(self):
        self.r.flushdb()   #清空 redis
        print('清空redis成功！')
        return 0



a = MyRedis('118.0000','HK0000*')

print(a.str_get('duan'))

以上答案來自網路，如果侵權聯絡刪除