python初学笔记

通过上班闲暇时间开始学习一门脚本语言--python，很早前就有老同学建议学习一门脚本语言对未开开发会很有帮助，最初考虑选择哪门语言的时候在python和ruby中纠结了一下，最后选择python主要是感觉它的使用用户更广。

 

• 开发环境

我是在windows平台下开发的，python版本官方推荐的是2.7和3.3，我选择了后者，附上下载地址。

事实上，对于新手来说，2.x和3.x确实有一些改变，如果你用2.x的帮助文档在3.x下开发可能会遇到一些麻烦（比如print由命令变成了函数）。

在windows下安装完成后可以在开始菜单看到python目录，打开python(command line)输入：print("hello world")回车，如果没有报错说明安装成功了。

 

• 编辑器

python官方自带了IDLE(Python GUI)编辑器（见上图），当然很多老手都推荐使用这款编辑器，希望新手从0开始，使用这种编辑器没有太多智能提示，很多代码都必须自己编写，这样能提升新手的熟练度。但我觉得这个太麻烦了，所以用了一段时候就放弃了。

随后选择的是python-eclipse插件，在eclipse下开发，这个插件比IDLE更好了一步，但是还是不算完美，要安装pydev可以在eclipse下下载这个插件

最后在ITEye无意看到一个python编辑器的宣传--jetbrains pycharm，下载了社区版试用了一下感觉非常不错，提示健全，反应迅速，一直用到现在。

当然我从老王python也看到一些推荐，因为没试用过就不发表评论了。

 

• 学习文档

对于新手，有一本好的入门书籍无疑会让你学习效率事半功倍，我看的是《python基础教程（第二版）》，里面内容非常丰富，跟着文档边看边练，很快就会了。而ITEye的python群组共享了另外两本python入门电子书《python先入为主》和《简明Python教程》，前者是老王python给新手的，但是内容相当浅显，对我帮助不大，而后者对python的数据结构、语法等都做了一些总结，建议新手在看了《python基础教程》之后再去看《简明python教程》的基础知识复习一下，但是简明教程中的例子大多跑不起来。

 

• 代码笔记

好记性不如烂笔头，下面就是在学习python中做的笔记，内容也不多，每隔几天花半个小时温习一下，很快就熟悉了。

#coding=gbk

#input()用户获取用户输入
name=input('what is your name?')
#print()用于输出数据给用户
print ('My name is '+name+'!')

#repr()和str()都可以转换为字符串
#repr()输出对Python比较友好，而str()的输出对用户比较友好
inta = 111
print('repr='+repr(inta)+'  str='+str(inta))

#通过三个双引号或者单引号可创建换行的长字符串
print("""kaka
xi
laoshi
a""")
#通过\n也可以达到换行的效果
print("hello\nworld")
#原始字符串r 作用是让后面的字符串内容不转义，类似于XML中的CDATA
print(r"C:\nnd"); #注意：原始字符串不能以\结尾，即print(r"C:\nnd\")是错误的

#常规序列，java中成为数组
array1 = ['kakaxi',30]
array2 = ['nanuto',15]
array12 = array1 + array2
print(array12)

#索引，通过索引可以获取指定数据
index = "这是一个索引"
print("第一个字："+index[0])    #从左到右，从0、1、2...
print("最后一个字："+index[-1]) #从右到左，从-1、-2、-3...
#17*['th']表示连续17个'th'，\在最后可以让代码换行
arraya = ['st','nd','rd'] + 17*['th']\
         +['st','nd','rd'] + 7*['th']\
         +['st']
print(arraya)

#分片，可以截取指定的数组片段
numbers = [1,2,3,4,5,6,7,8,9,10]
#1,2默认为数字，则必须转为字符串才能输出repr()
print("取3~6个:"+repr(numbers[3:6]));
print("取最后3个:"+repr(numbers[-3:]));
#[start:end:step]格式前两个是分片，最后一个是步长
#步长为1表示取全部值
print("步长为1:"+repr(numbers[0::1]))
#步长为2表示每隔1个字取值，依次类推
print("步长为2:"+repr(numbers[0::2]))
#步长不能为0但可以为负数可以倒着取值
print("步长为-1:"+repr(numbers[::-1]))
#这种方式可以复制一个新数组
numbersCopy = numbers[:]
numbersCopy = numbersCopy[:3]
#numbersCopy改变了，不影响numbers的值
print(repr(numbersCopy));
print(repr(numbers))

#序列相加 这样会将两个序列合并到一起
array_add = ['a','b','c'] + ['d','e','f']
#序列相乘 用数字x乘以一个序列会生成新的序列，而新序列中原来的序列被重复x次
array_multiply = 5*['demo','test']
#下面是生成一个具有10个空间的空序列,None是内置值，类似于java的null
array_none = [None]*10
array_none[0] = '1'
array_none[1] = 2
#分片赋值，可以理解为在索引1前面添加一个序列
array_none[1:1] = [2,3,4]
#del删除指定序列 del还可以删除其他类型
del array_none[6:]
print('array_none:'+repr(array_none))

#in判断是否有指定数据，返回true，false
inboolean = 'a' in array_add
print(inboolean)

#len()返回序列总共多少个值
print(len(array_add))
#min()返回序列第一个值
print(min(array_add))
#max()返回序列最后一个值
print(max(array_add))

#list()可以将字符串转换为list
print("list()方法："+repr(list('hello')))

lst = [1,2,3]
#在list后面追加对象
lst.append(4)
print("lst.append():"+repr(lst))

lsta = [1,2,3]
lstb = [4,5,6]
lsta.extend(lstb);
#extend()将序列合并到一起，比+性能要高
print("lst.extend():"+repr(lsta));
#返回第一个匹配的序列索引
print("lst.index():"+repr(lsta.index(2)))
#insert()在指定索引位置新增一个数据
lsta.insert(2,'aaa');
#pop()弹出序列最后一位并且返回原值
print("lst.pop()"+repr(lsta.pop()))
#remove()移出列表中第一个匹配项
lsta.remove(1)
#reverse列表反转
lsta.reverse()
#sort列表重新排序
#lsta.sort()

#前面的列表是可变可修改的，下面介绍的元组是不能修改的
tuple1 = (1,2,3)
#一个元组一定要有逗号结束
tuple2 = (1,)
#创建一个具有3个1的元组
tuple3 = 3*(1,)
#tuple()能将指定数据转换成元组
tuple([1,2,3])
tuple('abc')
#元组的索引访问也很简单
print("元组[1]:"+str(tuple1[1]))
#元组可以用于map映射中的key，而序列是不行的

#字符串格式化，类似于java的占位符，可以将元组中的数据依次填入字符串中补充
str1 = '你%s中%s'
#好像只能是元组才能格式
lstStr1 = ('好','国')
print(str1%lstStr1);
#更多格式化参考：http://www.cnblogs.com/JerySpace/archive/2010/12/17/1909621.html

string = 'This is a string!'
#find返回字符串第一个匹配的索引，没有匹配返回-1
print("string.find():"+ repr(string.find('is')) )
#join()是split的逆方法，用于将数组转换为字符串
seq = ['1','2','3','4','5']
sep = '+'
print("join():"+sep.join(seq))
#lower()字符串全部小写 注:lower会返回一个小写的字符串，string值不变
print('replace:'+string.lower())
#replace()全部替换匹配的字符串 注:replace会返回一个被替换的字符串，string值不变
print('replace:'+string.replace('is','kaka'))
#split()分割字符串并转换成list
print('split:'+repr( string.split(' ') ))
#strip()去字符串两头的空格，类似于java的trim
print(string.strip())

#数据结构“字典”，类似于java的map，有key和value之分，每一组值由逗号分隔
map1 = {'kaka':'30','nanuto':'15','sasiki':'15'}
#len()返回字典的总个数
print("len(d):"+str(len(map1)))
#d[key]直接返回指定key的值
print("d[key]:"+map1['kaka'])
#d[key] = value给指定key赋值
map1['kaka'] = 31
#根据key删除指定map
del map1['sasiki']
#判断是否包含指定key
print("str in map:"+str('nanuto' in map1))
#从map中提取指定key到占位符中
print("map格式化："+"kaka's age is %(kaka)s" %map1)

map2 = {'A1':'123','A2':'456','A3':'789'}
#copy一份全新的map对象 deepcopy深度复制
map3 = map2.copy()
#clear清空map
map2.clear();
#get()也是根据key获取指定值，比map[index]好的地方是key不存在不会报错
map2.get('A6')
#items将map分解成一个个对象
map2.items()
#items将map转换成迭代器，依次迭代，比items性能高
#map2.iteritems()
#keys和iterkeys与前面类似，只是迭代map中的key
#values和itervalues迭代获取map的值
#pop(key)根据key删除指定数据
map3.pop('A1');
#update利用一个字典更新另一个字段
map3.update(map2);

#import的几种方式
#import math  调用math.sqrt(4)
#import math as foobar 调用foobar.sqrt(4)
#from somemodule import math 调用somemodule.sqrt(4) 前提：somemodule不能有sqrt方法

stringif = 'abcdefg'
#常规的if...else...
if stringif.startswith("abc"):
    print("stringif.startswith abc")
else:
    print("stringif.startswith !abc")

#if...elif...else...
if 1==1:
    print("1==1")
elif 2==2:
    #pass关键字不执行任何逻辑，开发人员可能未完成该片段代码，可以用pass代替防止编译报错
    pass
else:
    print("else")

#while循环只有满足表达式才会退出
printstr = input("print 'a'")
whileCount = 0
while printstr != "a":
    #输入错误超过3次则跳出循环
    if whileCount == 3:
        #break跳出while循环  continue跳出本次逻辑，执行下一次逻辑
        break
    whileCount += 1
    printstr = input("print 'a'")
print("input right!")

forList = ["a","b","c","d","e"]
#for循环
for for_ in forList:
    print("forList:"+for_)
    
forMap = {"a":"1","b":"2","c":"3"}
#for循环Map 获得的是key
for for_ in forMap:
    print("forMap key:"+for_+" value:"+forMap[for_])

#del只能删除变量名，而变量值是不能(也不需要)被开发删除的
delStr = ["删","除"]
copyDelStr = delStr
del delStr
print("del delStr:"+str(copyDelStr))

#exec方法用于运行字符串类型的python语句
exec("print('exec()')")

 

# coding=gbk

#使用def定义一个新方法
def method1(str):
    return "Your parm is:"+str
print(method1("china"))

#help中传入方法名就能够获得该方法的注释信息
help(method1)

def combine(parameter):
    #使用globals()['全局变量']的形式可以获得全局变量名
    print(parameter + globals()['parameter'])
parameter = ' time'
combine('begin')

def combine_():
    #使用global可以在方法内修改全局变量y的值
    global y
    y = y + 1
y = 1
combine_()
print("y's value:"+str(y))

#python支持方法中嵌套方法，这种行为可以称作“闭包”
def multiplier(factory):
    def multiplyByFactory(number):
        return factory*number
    return multiplyByFactory

double = multiplier(2)  #此时获得的是multiplyByFactory方法
print(repr(double(5)))  #此时获得的是multiplyByFactory执行的返回值

#另一种调用嵌套方法
print(repr(multiplier(2)(5)))

 

# coding=gbk

#使用def定义一个新方法
def method1(str):
    return "Your parm is:"+str
print(method1("china"))

#help中传入方法名就能够获得该方法的注释信息
help(method1)

def combine(parameter):
    #使用globals()['全局变量']的形式可以获得全局变量名
    print(parameter + globals()['parameter'])
parameter = ' time'
combine('begin')

def combine_():
    #使用global可以在方法内修改全局变量y的值
    global y
    y = y + 1
y = 1
combine_()
print("y's value:"+str(y))

#python支持方法中嵌套方法，这种行为可以称作“闭包”
def multiplier(factory):
    def multiplyByFactory(number):
        return factory*number
    return multiplyByFactory

double = multiplier(2)  #此时获得的是multiplyByFactory方法
print(repr(double(5)))  #此时获得的是multiplyByFactory执行的返回值

#另一种调用嵌套方法
print(repr(multiplier(2)(5)))

#创建类
class Person:
    def setName(self,name):
        self.name = name
    def getName(self):
        return self.name
    def printName(self):
        print("Your name is:"+self.name)

kaka = Person()
lami = Person()
kaka.setName("kaka")
lami.name = "lami"
kaka.printName()
lami.printName()

class SecurityClass:
    def publicMethod(self):
        print("This is publicMethod")
        self.__privateMethod()
    def __privateMethod(self):#双下划线表示对外隐藏的方法
        print("This is privateMethod")

security = SecurityClass()
security.publicMethod()

#继承父类，通过Class(父类)的形式即可继承父类
class ChlildClass(SecurityClass):
    def publicMethod(self):
        print("This is  childClass's publicMethod")
chlildClass = ChlildClass()
chlildClass.publicMethod()

#可继承多个父类
class ChildsClass(SecurityClass,Person):
    pass

#issubclass(子类,父类)用于判断子类是否继承父类
print("是否继承父类："+repr(issubclass(ChlildClass,SecurityClass)))
print("是否继承父类："+repr(issubclass(SecurityClass,ChlildClass)))
#通过Class.__bases__可获得该类继承的所有子类
print("基类集合："+repr(ChlildClass.__bases__))
print("判断对象是否有该方法："+repr(hasattr(ChlildClass,'publicMethod')))

#自定义异常
class BusinessException(Exception):
    pass

#try...except...捕获异常
try:
    print(repr(3/0))
except ZeroDivisionError:
    if 1==1:
        print("3/0异常！")
    else:
        raise  #抛出异常

try:
    print(repr(3/0))
except (ZeroDivisionError,Exception):#可以通过园组的形式监听多种异常
        print("3/0异常！")

try:
    print(repr(3/0))
except (ZeroDivisionError,Exception) as e:#通过Exception as e获取异常信息
        print("异常e:"+repr(e))

#except...else...finally...三者可以混用
try:
    print(repr(3/0))
except (ZeroDivisionError,Exception) as e:#通过Exception as e获取异常信息
    print("异常e:"+repr(e))
else:
    print("无异常")
finally:
    print("finally代码块！")

class Demo(SecurityClass):
    #__init__构造方法用于对象创建时使用，__del__析构方法用于对象销毁时调用
    def __init__(self,name='demo'):
        SecurityClass.__init__(self) #可以调用父类的构造方法
        self.name = name

demo = Demo()
print(demo.name)

demo2 = Demo('demo...')
print(demo2.name)

#静态方法
class StaticClass:
    @staticmethod
    def sMethod():
        print("This is static method!")

    @classmethod
    def cMethod(cls):
        print("This is class method!",cls)

StaticClass.sMethod()
StaticClass.cMethod()

nested = [[1,2],[3,4],[5]]
def demoMethod(nested):
    for lst1 in nested:
        for lst2 in lst1:
            yield lst2 #简单生成器，可当做迭代器使用

for number in demoMethod(nested):
    print(number)

#递归生成器，可处理无限层数的列表
def yieldMethod(nested):
    for lst1 in nested:
        for lst2 in yieldMethod(lst1):
            yield lst2

 

__author__ = 'Administrator'
#coding=gbk

#读写文件
source = "C:\\copy\\alibaba.txt"

newWord = '''
大家好

才是真的

好！
'''
#第一种写文件
f = open(source,'w') #w写
f.write(newWord)
f.close()


#第一种读全部内容
f = open(source) #默认只读
try:
    print(f.read())
finally:
    f.close()

#第二种在文件末尾追加
f = open(source,'a')
f.write("你好python!")
f.close()

#第二种一行一行读
print("====第二种====")
f = open(source,'r') #r为只读
while True:
    line = f.readline()
    if not line:
        break
    print(line)#奇怪的是每一行都会换行
f.close()

#注：在大文件下使用readlines(sizehint)比使用read性能要好，原因是前者可以定义缓冲区最大阀值，而后者会占用全部缓冲区.writelines同理!
#更多文件读写，参考http://www.cnblogs.com/allenblogs/archive/2010/09/13/1824842.html

 

__author__ = 'Administrator'
#coding=gbk

import sqlite3
import time

#使用sqlLite进行数据库操作
#sqlLite在高版本python已经成为内置包，所以可以不用引入任何第三方插件使用

#connect传入参数是数据库文件，可以是绝对路径，也可以是相对路径，如果已存在则直接使用，不存在则创建一个新库
conn = sqlite3.connect("testDB.db")
curs = conn.cursor()
conn.commit()
conn.close()

def executeSQL():
    createStr = '''
    CREATE TABLE food(
    id    TEXT PRIMARY KEY,
    name  TEXT,
    price FLOAT
    )
    '''
    conn = sqlite3.connect("testDB.db")
    curs = conn.cursor()

    #①执行表添加操作
    try:
        curs.execute(createStr)
    except sqlite3.OperationalError as e:
        conn.rollback()
        print(repr(e))

    #②执行数据添加操作
    insert = "INSERT INTO food VALUES(?,?,?)"
    values = [time.strftime("%Y%m%d%H%M%S"),'面包',5]
    try:
        curs.execute(insert,values)
        conn.commit()
        print("insert success!")
    except sqlite3.ProgrammingError:
        conn.rollback()
        raise

    #③执行数据查询操作
    query = "SELECT * FROM food"
    curs.execute(query)
    for row in curs.fetchall():
        valueStr = ""
        for value in row:
            #因为price字段是float，所以要str()，如果用repr又是另一种景象，自己尝试
            valueStr = valueStr + str(value) + "  "
        print(valueStr)
    conn.close()

executeSQL()