python 笔记（一）——基本语法

# -*- 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 修改数据类型