# -*- coding: utf-8 -*-
1.Python創建list
L = ['Michael', 100, True]
print L[0]#按照索引訪問list
print L[-1]#倒序訪問list
L.append('Paul') #追加到 list 的末尾
L.insert(0, 'Paul')
L.pop() #刪掉list的最後一個元素
L.pop(2) #刪掉索引是2的元素
L[2] = 'Paul'#替換元素
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
條件過濾
列表生成式的 for 循環後面還可以加上 if 判斷
>>> [x * x for x in range(1, 11) if x % 2 == 0]
對於字符串 'ABC' 和 '123'，可以使用兩層循環，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
利用 3 層for循環的列表生成式，找出對稱的 3 位數。例如，121 就是對稱數，因爲從右到左倒過來還是 121。
print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]
2.創建單元素tuple
t = (1,) 單元素 tuple 要多加一個逗號“,”，這樣就避免了歧義
#“可變”的tuple
t = ('a', 'b', ['A', 'B'])
>>> L = t[2]
>>> L[0] = 'X'
>>> L[1] = 'Y'
3.Python之 for循環
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print (name)
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print (x + y)
4.Python之什麼是dict（key不能重複，無序）
名字稱爲key，對應的成績稱爲value，dict就是通過 key 來查找 value。
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
訪問dict
print d['Adam']
#法1：先判斷一下 key 是否存在，用 in 操作符：
if 'Paul' in d:
print (d['Paul'])
法2：print (d.get('Bart'))
更新dict
d['Paul'] = 72
遍歷dict
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> for key in d:
... print (key)
...
Lisa
Adam
Bart
5.Python中什麼是set
set 持有一系列元素，這一點和 list 很像，但是set的元素沒有重複，而且是無序的，這點和 dict 的 key很像。
s = set(['A', 'B', 'C'])
訪問set
set存儲的是無序集合，所以我們沒法通過索引來訪問，判斷一個元素是否在set中
s = set(['adam','bart'])
print ('adam' in s)
print ('bart' in s)
True
True
months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov'])
x1 = 'Feb'
x2 = 'Sun'
if x1 in months:
print ('x1: ok')
else:
print ('x1: error')
if x2 in months:
print ('x2: ok')
else:
print ('x2: error')
遍歷set
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print (x[0]+':',x[1])
更新set
添加元素時，用set的add()方法
刪除set中的元素時，用set的remove()方法
s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for name in L:
if name in s:
s.remove(name)
else:
s.add(name)
print (s)
6.Python之調用函數
sum()函數接受一個list作爲參數，並返回list所有元素之和
L = []
x = 1
while x <= 100:
L.append(x * x)
x = x + 1
print sum(L)
7.編寫函數
定義一個函數要使用def語句，依次寫出函數名、括號、括號中的參數和冒號:，然後，在縮進塊中編寫函數體，函數的返回值用return語句返回。
def square_of_sum(L):
sum = 0
for x in L:
sum = sum + x * x
return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])
函數之返回多值（Python的函數返回多值其實就是返回一個tuple，但寫起來更方便。）
import math
def quadratic_equation(a, b, c):
t=math.sqrt(b*b-4*a*c)
return (-b+t)/(2*a),(-b-t)/(2*a)
print (quadratic_equation(2, 3, 0))
print (quadratic_equation(1, -6, 5))
遞歸函數（如果一個函數在內部調用自身本身，這個函數就是遞歸函數。）
漢諾塔
def move(n, a, b, c):
if n ==1:
print (a, '-->', c)
return
move(n-1, a, c, b)
print (a, '-->', c)
move(n-1, b, a, c)
move(4, 'A', 'B', 'C')
定義默認參數（默認參數只能定義在必需參數的後面：）
定義默認參數（默認參數只能定義在必需參數的後面：）
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
這樣一來，計算平方就不需要傳入兩個參數了：
>>> power(5)
25
定義可變參數
Python解釋器會把傳入的一組參數組裝成一個tuple傳遞給可變參數
如果想讓一個函數能接受任意個參數，我們就可以定義一個可變參數：
def fn(*args):
print (args)
編寫接受可變參數的 average() 函數。
def average(*args):
sum=0.0
if len(args) == 0:
return sum
for x in args:
sum = sum + x
return sum / len(args)
print (average())
print (average(1, 2))
print (average(1, 2, 2, 3, 4))
8.對list進行切片
（1）L[0:3]表示，從索引0開始取，直到索引3爲止，但不包括索引3。即索引0，1，2，正好是3個元素。
（2）如果第一個索引是0，還可以省略：>>> L[:3]
（3）只用一個 : ，表示從頭到尾：L[:]
（4）切片操作還可以指定第三個參數：L[::2]，第三個參數表示每N個取一個，上面的 L[::2] 會每兩個元素取出一個來，也就是隔一個取一個。
range()函數可以創建一個數列：
>>> range(1, 101)
[1, 2, 3, ..., 100]
請利用切片，取出：
1. 前10個數；
2. 3的倍數；
3. 不大於50的5的倍數。
L = range(1, 101)
print (L[:10])
print (L[2::3])
print (L[4:50:5])
對list進行切片
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:]
['Bart', 'Paul']
>>> L[:-2]
['Adam', 'Lisa']
>>> L[-3:-1]
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart']
對字符串切片
def firstCharUpper(s):
return s[0].upper() + s[1:]
print (firstCharUpper('hello'))
print (firstCharUpper('sunday'))
print (firstCharUpper('september'))
9 索引
布爾索引
ix=day<tau_samples (1)
expected_texts_per_ day[day]= (lambda_1_samples[ix].sum()+lambda_2_samples[~ix].sum())/N (2)
[ix]是滿足（1）式的條件的索引，[~x]則是取反
10 線程
import threading
import time
class Job(threading.Thread):
def __init__(self, *args, **kwargs):
super(Job, self).__init__(*args, **kwargs)
self.__flag = threading.Event() # 用於暫停線程的標識
self.__flag.set() # 設置爲True
self.__running = threading.Event() # 用於停止線程的標識
self.__running.set() # 將running設置爲True
def run(self):
while self.__running.isSet():
self.__flag.wait() # 爲True時立即返回, 爲False時阻塞直到內部的標識位爲True後返回
print(time.time())
time.sleep(1)
def pause(self):
self.__flag.clear() # 設置爲False, 讓線程阻塞
def resume(self):
self.__flag.set() # 設置爲True, 讓線程停止阻塞
def stop(self):
self.__flag.set() # 將線程從暫停狀態恢復, 如何已經暫停的話
self.__running.clear()
a=Job()
a.start()
time.sleep(5)
a.pause()
time.sleep(3)
a.resume()
time.sleep(3)
a.pause()
time.sleep(2)
a.stop()
11.Zip函數
12.特殊函數__call__
__call__
在Python中，函數其實是一個對象：
>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123
由於 f 可以被調用，所以，f 被稱爲可調用對象。
所有的函數都是可調用對象。
一個類實例也可以變成一個可調用對象，只需要實現一個特殊方法__call__()。
我們把 Person 類變成一個可調用對象：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def __call__(self, friend):
print 'My name is %s...' % self.name
print 'My friend is %s...' % friend
現在可以對 Person 實例直接調用：
>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...
單看 p('Tim') 你無法確定 p 是一個函數還是一個類實例，所以，在Python中，函數也是對象，對象和函數的區別並不顯著。
13.sql in語句的參數輸入
3.1編好的的int類型
meter_binding_id=meter_binding_id[0].values.tolist()#獲取綁定設備id
ids=meter_binding_id[0][:-1]#去除最後的‘，’
meters=ms.ExecQuery("select meter_no from pro_meter WHERE id in ({})".format(ids))
3.2當in函數需要輸入多個字符時
arg_list = ','.join(['%s'] * len(meter))#根據meter的長度產生多少個佔位符
cc="select insetTime ,sum(n_value) as 'value' from pro_statistics_hours WHERE meter_no IN (%s) GROUP BY insetTime ORDER BY insetTime asc"%arg_list#組成sql語句
import pymssql
conn=pymssql.connect(host,user,pwd,db)
cur=conn.cursor()
meter=tuple(meter)#將list轉爲tuple類型
cur.execute(cc,meter)
resList=cur.fetchall()#獲取數據庫查詢結果
resList=pd.DataFrame(resList)#轉爲dataframe
conn.close()
14.python中type dtype astype 的用法
1.type 獲取數據類型
2.dtype 數組元素的類型
3.astype 修改數據類型
