python学习笔记

python初学笔记

博客分类：

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中做的笔记，内容也不多，每隔几天花半个小时温习一下，很快就熟悉了。

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()')")

Python代码


# 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)))

Python代码


# 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