Python从破门而入到夺门而出

MD版网盘备份：

链接: https://pan.baidu.com/s/1kVJNRSz 密码: agxt

基于《简明Python教程》

一、Python概览

1.使用PyCharm是非常简便快捷的。

• 一些快捷键：
  
  Shift + F10 运行
  
  Shift + F9 调试
  
  Ctrl + Shift + F 全局查找
  
  Ctrl + Shift + R 全局替换
• 其他参考资料：
  
  http://blog.csdn.net/pipisorry/article/details/39909057

2.Python是注重缩进的。最好常备游标卡尺。

二、Python语句

1.读入（带提示）

NAME = int(raw_input('wukefenggao'))

2.输出

print NAME

3.if语句（严格遵循缩进）

一个例子：

number = 42
guess = int(raw_input('Enter'))
if guess == number:
   print '1'
elif guess < number:
   print '2'
else:
    print '3'
print 'Done'

合并起来即if else-if else。缩进决定了无论何种结果都输出'Done'。

缩进代表了每个语句属于哪一块。

4.while语句

格式 while XXX：

条件为真时，重复执行一块语句。（else是可选的从句）

跳出循环使用break语句（终止当前循环）或者continue（开始下一次循环）

Python中没有do…while语句，可以使用如下语句替代：

while True:
#dosomething
if(条件A不符合):
    break

5.for语句

for i in range(a,b) 在a b内递归`

三、函数

####1.定义

def 函数名():

语句

例子：

def test():

print '42!' # block belonging to the function

test() # call the function

2.函数形参和实参

形参：虚拟变量，调用时，实参赋值给形参。
实参：实际参数，具有确定的值。

3.变量的作用域

使用global语句对函数外的变量进行全局定义

例1：

    def func():
       global x
       x = 2
       print 'x is', x
    x = 42
    func()
    print 'Value of x is', x

这一段代码的输出是：

    x is 2
    Value of x is 2

也就是说，由于定义了global，函数体内的‘2’对函数外的x进行了赋值。

例2：

    def func():
       x = 2
       print 'x is', x
    x = 42
    func()
    print 'Value of x is', x

这一段代码的输出是：

     x is 2
     Value of x is 42

由于没有global，x这个值仍然遵循函数体外的全局定义。

函数里如果只使用了全局变量的值，而没有重新赋值，就不需要global

如果有赋值就需要global，如同例1所述。

global可以同时定义多个变量，即 global x,y,z

4.默认参数值

使用

   def mo(ha, times = 1):
    print ha * times

    mo('ha')    #默认的膜蛤
    mo('ha', 5)  #指定膜蛤

未定义时，每次膜蛤默认+1s，然而，指定膜蛤时，因为提供了一个times值，使得续命5次

需要注意，只有在形参表末尾的那些参数可以有默认参数值，需要先声明没有默认值的形参，后声明有默认值的。

5.关键参数

类似于默认参数值，改变的是定义函数时的量。

如

def mo(ha = 3 , times = 2)

6.return语句

7.DocStrings

从函数中得出字符串

例如：

print function.__doc__

8.模块的使用

使用方法：import 模块名

__name__

import mymodule
mymodule.sayhi()
等同于
from mymodule import sayhi, version

1）

import 和from…import不同之处：

• 用法比较：
  
  import：

    import sys
    for i in sys.argv

  from…import

  from syc import argv

• form…import可以直接输入变量（导入特定成员）
  
  优点是方便易懂

• 导入所有sys的模块：from sys import *
  
  （不应该使用此法，在导入时，有可能自定义的命名空间变量和调用的模块中的变量是相同的，这样容易造成命名空间混乱）
  
  Tkinter 可以全盘导入
  
  PS.Tkinter是标准GUI库

2）

重命名模块

import sys as system

3)

为了避免模块名冲突，python使用了Package（包）的概念，即按目录组织模块。

从顶层的包进行目录存放，例如

Package test:
__init__.py
abc.py
xyz.py

通过这个组织方法，

abc.py模块的名称变为Package test.abc

*每个包下必须有 init.py 可以是空的，也可以有代码，而__init__.py本身就是一个模块，这个模块就是Package test

*可以建立多级目录

9.字符串

转义字符串：

|转义字符 | |描述|

|---------- | |-----|

|(在行尾时)| |续行符|

|\| |反斜杠符号|

|\'| |单引号|

|"| |双引号|

|\a| |响铃|

|\b| |退格(Backspace)|

|\e| |转义|

|\000| |空|

|\n| |换行|

|\v| |纵向制表符|

|\t| |横向制表符|

|\r| |回车|

|\f| |换页|

|\oyy| 八进制数，yy代表的字符，例如：\o12代表换行

|\xyy| 十六进制数，yy代表的字符，例如：\x0a代表换行

|\other| 其它的字符以普通格式输出

在某些情况下，使用转义字符会导致误解，如

sourse = ['C:\new']

\n会被误认为换行符，因此可以加上r，表示raw字符，不进行转义。

即

sourse = [r'C:\new']

或不使用 ‘\’

sourse = ‘C:new’

四、数据结构

####1.列表

list是一组有序列表，每个项目之间使用逗号进行连接。

类是具有方法的，append是类的方法，可以使得列表尾添加一个新的项目。

类也是有域的。

shoplist = ['apple','mango','carrot','banana']#可以一次定义多个表 例如  list1, list2 = [123, 'xyz', 'zara'], [456, 'abc']
print 'I have' ,len(shoplist),'items to pruchase'#len(list)用以测量表的长度
print 'These items are:',   #在print后加‘，’可以消除原本的换行符
for item in shoplist:   #for...in...在列表内递归输出列表内容，这里可以直接使用print shoplist 也可以打印出表的内容
    print item,
print '\n I also have to buy rice'
shoplist.append('rice')     #在列表末尾添加一个字符串
print 'My shoppin list is now',shoplist
print 'i will sort my list now'
shoplist.sort()           #列表冲排序
print 'sorted shopping list is',shoplist
print 'The first item i will buy is',shoplist
print 'first will buy is',shoplist[0]      #item[x] 输出表内第x位元素

olditem = shoplist[0]
del shoplist[0]
print 'moha1',olditem
print 'moha2',shoplist

需要研究的问题：

• 1.排序时加上参数
• 2.Python的字典排序问题
• 3.list的各种方法姿势

2.元组

元组类似于列表，但是元组中的元素是不可以改变的，不可以添加删除的。

1）创建 item = (x1,x2)

注意：只有一个元素时，要在元素后添加逗号‘，’

2）连接元组 item3 = item1 + item2

3）删除元组del item

4）无关闭分隔符

无符号对象默认为元组

如 x,y = 1,2

5)使用元组输出

%d %s 以代替输出（对应即可，%s为字符串 %d为数字）

3.字典

1）key & value

2）key是不可以变的；字典是没有特定顺序的。

3）标记方式 d = {key1 :　value1,key2 : value2}

4）用法

print "无可奉告" % d['key']

5）增加和删除字典内容

   d['name'] = 'text'
   del d['name']

4.序列

1）特点：

索引：从序列中抓取特定项目

切片：获取一部分序列

2）用法：

索引： d[x]

切片： d[a:b]

5.参考

名称到对象的绑定。

如果使用 A_List = B_List,则这两个不同的名称指向同一个项目

如果使用 A_List = B_List[:],则列表B中的东西被复制至A中，改变A或B对他们各自的值

都不会相互影响。

6.字符串方法

查看完整用法：

help(str)

部分用法示例：

if name.startswith('String') #查找字符串是否以某个字符开始，大小写匹配
if 'a' in name
if name.find('test') != -1 #查找字符串中是否包含某个字符

五、面向对象编程

面向过程是根据操作数据或语句块来操作程序的 。将数据和功能结合起来，用称作对象的东西包裹起来组织程序的方法，称为面向对象（适用于编写大型程序）。

1.

类创建一个新类型，对象是类的实例

域是属于一个对象或类的变量

类使用关键字class进行创建。

类是抽象的模板

class  Student(object):
    pass

(object)是普遍使用的继承类。

创建实例： 类名+()

2.self

假如你有一个称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。

3.创建一个类

  class Student(object):
    pass  #空白块
p = Student()
print p

输出结果：

<__main__.Student object at 0x028545F0>

可以看到，已经在__main__模块中有一个Person类的实例。并将内存地址输出了。

4.使用对象/类

class Person:
   def sayHi(self):
          print 'hello world'
p = Person()
p.sayHi()

5.__init__方法

class Person:
    def __init__(self,name):
        self.name = name
    def sayHi(self):
            print 'test001', self.name
p = Person('test')
p.sayHi()

__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

def__init__(self,name,score):
    self.name = name
    self.score = score

6.类和对象的方法

class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        print '(Initializing %s)' % self.name
        Person.population += 1

    def __del__(self):
        print '%s says bye.' %self.name
        Person.population -=1

        if Person.population == 0:
            print 'I am the last one.'
        else:
                print 'There are still'
    def howMany(self):
        if Person.population == 1:
                print 'Only person here.'
        else:
                print 'We have %d persons here.' %Person.population
    def sayHi(self):
        print 'Hi, my name is %s' %self.name
swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalan')
kalam.sayHi()
kalam.howMany()

• class定义了一个Person类
• population是类中的变量（使用self赋值）
• __init__使用一个名字初始化Person实例
• 只能使用self变量来参考同一个对象的变量和方法，即属性参考
• __del__在对象消逝时被调用

继承

• 继承可以理解为类之间的 类型和子类型的关系
• 继承意味着代码的重用
• 一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。
• 例如要写一个进行学生档案管理软件来记录学校中的教师和学生情况。教师和学生的共同属性是姓名\年龄\地址。个人专有属性是[教师]的薪水、课程、假期，[学生]的成绩和学费
• 共用同一类型的事物

class SchoolMember:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember : %s)' %self.name

    def tell(self):
        print 'Name:"%s" Age:"%s' %(self.name,self.age),

class Teacher(SchoolMember):
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print 'Name:"%s" Age:"%s" ' %(self.name,self.age)

    def tell(self):
        SchoolMember.tell(self)
        print 'Salary:"%d"' %self.salary

class Student(SchoolMember):
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks  = marks
        print'(Initialized Student: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)

print
members = [t, s]
for member in members:
       member.tell()

输出：

(Initialized SchoolMember : Mrs. Shrividya)
Name:"Mrs. Shrividya" Age:"40"
(Initialized SchoolMember : Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40 Salary:"30000"
Name:"Swaroop" Age:"22 Marks: "75"

六、输入/输出

使用文件

file__test = 'test'
#文件内容存储
f = file('file__test.txt', 'w') #对文件进行写操作
f.write(file__test)# 将文件内容写入
f.close() # 关闭文件(必须的步骤)

• 读模式（'r'）、写模式（'w'）或追加模式（'a'）

f = file('file_test.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while 1:
    line = f.readline()
    if len(line) == 0:  #EOF
        break
    print line,
   f.close()

储存器

持久性存储对象：

pickle模块：

picke

cPickle：使用C语言编写，速度比pickle快

import cPickle as p
shoplistfile = 'shoplist.data'
shoplist = ['a','b','c']

f = file(shoplistfile,'w')
p.dump(shoplist, f)
f.close()

del shoplist

f = file (shoplistfile)
storedlist = p.load(f)
print storedlist

import…as…将模块名称缩写

p.load(f)是pickle模块提供的函数，可以返回对象

del shoplist以查看存储后的效果

异常

当你的程序中出现某些 异常的 状况的时候，异常就发生了（废话）。

处理异常 try..except 与 try..finally

#####try..except

import sys
try:
    s = raw_input('Enter something --> ')
except EOFError:
    print '\nWhy did you do an EOF on me?'
    sys.exit()
except:
    print '\nSome error/exception occurred.'
else：
    print‘Right！’
print 'Done'

匹配： 若报错符合EOFError，则执行此处语句。若无指定，则执行except

连用else：若无异常，则执行else后语句

重点理解try..finally

import time
try:
    f = file('file__test.txt')
    while 1:
        line = f.readline()
        if len(line) == 0:
            break
        print line,
finally:
    f.close()
    print 'Cleaning up...closed the file'

引发异常

class test(Exception):
    def __init__(self,length,atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input ('Enter sth')
    if len(s) < 3:
        raise test(len(s), 3)

except EOFError:
    print '\n aaaa'
except test, x:
    print 'now %d, at least %d' % (x.length, x.atleast)
#强制输出class类型内容
else:
    print 'No exception was raised.

七、其他

- 1 特殊方法

|名称| |说明|

|-----| |----|

|init(self,...) |这个方法在新建对象恰好要被返回使用之前被调用。

|del(self) |恰好在对象要被删除之前调用。

|str(self) |在我们对对象使用print语句或是使用str()的时候调用。

|lt(self,other) |当使用 小于 运算符（<）的时候调用。类似地，对于所有的运算符（+，>等等）都有特殊的方法。

|getitem(self,key) |使用x[key]索引操作符的时候调用。

|len(self) |对序列对象使用内建的len()函数的时候调用。

- 2 在函数中接受元组和列表

*前缀：元组存储
**前缀：字典的键/值对存储

如：

>>> def powersum(power, *args):
...     total = 0
...     for i in args:
...          total += pow(i, power)
...          print i
...     return total
...
>>> powersum(2, 3, 4)
3
4
25

• pow函数:计算n次方
  
  例如pow(2,3) 函数功能为计算2的3次方，即2**3
• 由于指定了*args,使得多余的参数被存储如args中，这里多余的是3和4，存储入args中，则
  
  total = 0+3**2+4**2

3.lambda 形式

lambda语句被用来创建新的函数对象，并且在运行时返回它们(返回特定算式)。

def make_repeater(n):
    return lambda s:s*n

n = int(raw_input('Enter n '))
twice = make_repeater(n)
print twice('word')
print twice(5)

C:\Python27\python.exe E:/PY/1203.py
Enter n 1
word
5

4.exec、eval、assert、repr

• `exec 用于存储语句
• eval用于存储表达式
• assert用于声明条件为真
  
  
  
  **注：pop用于移除元素
• repr用于取得可打印的字符串表达式