python_入门初级

入门_初级

类型和表达式部分

你好，世界！

1 #coding=utf-8

2

3print "你好，世界。"

 乘方

1print 2**10

变量

1 var= 1

2print var

3

4var  = "段光伟"

5print var

注：这里的var = xxxx不叫变量赋值，而叫变量绑定，python维护了一个符号表（变量名）以及符合对应的值，这个对应关系就叫做绑定，一个符号可以绑定任意类型的值。

获取用户输入

1#获取用户输入

2 x = input("x:")

3 y = input("y:")

4

5print x*y

注：input接受的是Python代码，输入中可以访问当前执行环境中的变量，如果想获取原始输入需要使用 raw_input。

函数定义

1def say_b():

2    print"b"

强类型

Javascript和Php是弱类型的，Python和Ruby是强类型的。弱类型允许不安全的类型转换，强类型则不允许。

1#1 + “1” 这行代码在Python中会报错。

2print 1 + int("1")

3print str(1) + "1"

 字符串

1#字符串

2print ''''    段

3            光

4            伟'''

5print r'C:\log.txt'

6print 'C:\\log.txt'

序列

这里先介绍三种序列：列表、元祖和字符串。

序列通用操作

 1 seq ="0123456789"

 2print seq[0] #从0开始编码。

 3print seq[-1] #支持倒着数数，-1代表倒数第一。

 4print seq[1:5] #支持分片操作，seq[start:end]，start会包含在结果中，end不会包含在结果中。

 5print seq[7:] #seq[start:end]中的end可以省略。

 6print seq[-3:] #分片也支持负数。

 7print seq[:3] #seq[start:end]中的start也可以省略。

 8print seq[:] #全部省略会复制整个序列。

 9print seq[::2] #支持步长。

10print seq[::-2] #支持负步长。

11print seq[9:1:-1] #支持负步长。

12print [1, 2, 3] + [4, 5, 6] # 序列支持相加，这解释了为啥字符串可以相加。

13print [1, 2, 3] * 3 #序列支持相乘，这解释了为啥字符串可以相称。

14print [None] * 10 #生成一个空序列。

15print 1 in [1, 2, 3]#成员判断。

 可变的列表

 1 data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

 2

 3 data[0] ="a" #修改元素。

 4print data

 5 data[0] = 0

 6

 7del data[10] #删除元素。

 8print data

 9

10del data[8:] #分片删除。

11print data

12

13 data[8:] = [8, 9, 10]#分片赋值

14print data

不可变的元祖

1print (1, 2) #元祖以小括号形式声明。

2print (1,) #一个元素的元祖。

字符串格式化

1 print"% 10s" % "----"

2

3 print'''

4 %(title)s

5 %(body)s

6''' % {"title": "标题", "body": "内容"}

字典

1 print {"title":"title", "body":"body"}

2 print dict(title ="title", body = "body")

3 print dict([("title","title"), ("body","body")])

1 dic = {"title":"title", "body":"body"};

2 print dic["title"]

3 del dic["title"]

4 print dic

print 语句

1print 'a', 'b' #print可以接受多个参数，参数的输出之间以空格相隔。

2print 'a', #如果逗号之后没有参数，则不会换行。

3print 'b'

序列解包

1 x, y, z = 1, 2, 3

2print x, y, z

3 (x, y, z) = (1, 2, 3)

4print x, y, z

5 (x, y, z) = [1, 2, 3]

6print x, y, z

bool值

 1#下面的输入全部返回False。

 2print(bool(None))

 3print(bool(()))

 4print(bool([]))

 5print(bool({}))

 6print(bool(""))

 7print(bool(0))

 8

 9#虽然这些值在条件运算中会当做False，但是本身不等于False。

10print(True and "")

11print(not "")

12print(False == "")

13print(False == 0) #0除外，bool类型的内部表示就是int类型。

bool运算

1print(0 < 1 < 10)

2print(0 < 1 and 1 < 10)

3print(not(0 > 1 > 10))

4print(not(0 > 1 or 1 > 10))

语句块

:开始语句快，缩进的所有内容都是一个语句块。

1if(10 > 1):

2    print("10 > 1")

3else:

4    print("不可能发生")

三元运算符

1print("10 > 1" if 10 > 1 else "不可能发生")

相等比较

1#== 和 is的差别，==比较的是内容，is比较的是引用。

2 x = [1, 2, 3]

3 y = x

4 z = [1, 2, 3]

5print(x == y)

6print(x == z)

7print(x is y)

8print(x is z)

循环

 1 #for循环类似C#的foreach，注意for后面是没有括号的，python真是能简洁就尽量简洁。

 2for x in range(1,10):

 3     print(x)

 4

 5for key in {"x":"xxx"}:

 6     print(key)

 7

 8for key, value in {"x":"xxx"}.items():

 9     print(key, value)

10

11for x, y, z in [["a",1, "A"],["b",2, "B"]]:

12    print(x, y, z)

 

 1#带索引的遍历

 2for index, value in enumerate(range(0, 10)):

 3    print(index, value)

 4

 5#好用的zip方法

 6for x, y in zip(range(1, 10), range(1, 10)):

 7    print(x, y)

 8

 9#循环中的的else子句

10from math import sqrt

11for item in range(99, 1, -1):

12    root = sqrt(item)

13    if(root == int(root)):

14        print(item)

15        break

16else:

17    print("没有执行break语句。")

pass、exec和eval

1#pass、exec、eval

2if(1 == 1):

3    pass

4

5exec('print(x)', {"x":"abc"})

6print(eval('x*2', {"x": 5}))

函数部分

形参和实参之间是按值传递的，当然有些类型的值是引用（对象、列表和字典等）。

 1# 基本函数定义。

 2def func():

 3    print("func")

 4

 5 func()

 6

 7# 带返回值的函数。

 8def func_with_return():

 9    return ("func_with_return")

10

11print(func_with_return())

12

13# 带多个返回值的函数。

14def func_with_muti_return():

15    return ("func_with_muti_return","func_with_muti_return")

16

17print(func_with_muti_return())

18

19# 位置参数

20def func_with_parameters(x, y):

21    print(x, y)

22

23 func_with_parameters(1, 2)

24

25# 收集多余的位置参数

26def func_with_collection_rest_parameters(x,y, *rest):

27    print(x, y)

28    print(rest)

29

30 func_with_collection_rest_parameters(1,2, 3, 4, 5)

31

32#命名参数

33def func_with_named_parameters(x, y, z):

34    print(x, y, z)

35

36 func_with_named_parameters(z = 1, y = 2,x = 3)

37

38#默认值参数

39def func_with_default_value_parameters(x, y,z = 3):

40    print(x, y, z)

41

42 func_with_default_value_parameters(y = 2,x = 1)

43

44#收集命名参数

45deffunc_with_collection_rest_naned_parameters(*args, **named_agrs):

46    print(args)

47    print(named_agrs)

48

49 func_with_collection_rest_naned_parameters(1,2, 3, x = 4, y = 5, z = 6)

50

51#集合扁平化

52func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4,"y": 4, "z": 6})#这会导致args[0]指向第一个实参，args[1]指向第二个实参。

53 func_with_collection_rest_naned_parameters(*[1,2, 3], **{"x": 4,"y": 4, "z": 6})#这里的执行相当于func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z= 6)。

作用域

 1# coding=utf-8

 2

 3# 只有函数执行才会开启一个作用域。

 4if(2 > 1):

 5     x = 1

 6

 7print(x) # 会输出1。

 8

 9

10# 使用vars()函数可以访问当前作用域包含的变量。

11 x = 1

12print(vars()["x"])

13

14# 使用globals()函数可以访问全局作用域。

15 x = 1

16

17def func():

18    print(globals()["x"])

19

20 func()

21

22# 使用locals()函数可以访问局部作用域。

23def func():

24    x = 2

25    print(locals()["x"])

26

27 func()

28

29# 每个函数定义时都会记住所在的作用域。

30# 函数执行的时候会开启一个新的作用域，函数内变量访问的规则是：先访问当前作用域，如果没有就访问函数定义时的作用域，递归直到全局作用域。

31 x = 1

32

33def func():

34    y = 2

35    print(x, y)# 输出1 2

36

37 func()

38

39

40# 变量赋值始终访问的是当前作用域。

41 x = 1

42

43def func():

44    x = 2

45    y = 2

46    print(x, y)# 输出2 2

47

48 func()

49print(x) #输出 1

50

51# 局部变量会覆盖隐藏全局变量，想访问全局变量可以采用global关键字或globals()函数。

52 x = 1

53

54def func():

55    global x

56    x = 2

57    y = 2

58    print(x, y)# 输出2 2

59

60 func()

61print(x) #输出 2

 

 1# python支持闭包

 2def func(x):

 3    def inner_func(y):

 4        print(x + y)

 5

 6    return inner_func

 7

 8 inner_func = func(10)

 9 inner_func(1)

10 inner_func(2)

1#函数作为对象

2def func(fn, arg):

3    fn(arg)

4

5 func(print,"hello")

6 func(lambda arg :print(arg), "hello")

模块

几个模块相关的规则：

• 一个文件代表一个模块。
•  可以用import module导入模块，也可以用form module import member导入模块的成员。
• 如果导入的是module，必须使用module.member进行访问；如果导入的member，可以直接访问member。
• 导入的module或member都会变成当前module的member。

b.py

1 #coding=utf-8

2

3print __name__

4

5 defsay_b():

6     print "b"

a.py

1 #coding=utf-8

2

3import b

4 fromb import *

5

6print __name__

7

8 defsay_a():

9     print "a"

test.py

1 #coding=utf-8

2

3import a

4

5print __name__

6

7a.say_a();

8 a.say_b();

9a.b.say_b()

输出

1 b

2 a

3__main__

4 a

5 b

6 b

异常管理

 1# coding=utf-8

 2

 3# 自定义异常

 4class HappyException(Exception):

 5    pass

 6

 7# 引发和捕获异常

 8try:

 9     raise HappyException

10except:

11    print("HappyException")

12

13try:

14    raise HappyException()

15except:

16    print("HappyException")

17

18# 捕获多种异常

19try:

20    raise HappyException

21except (HappyException, TypeError):

22    print("HappyException")

23

24# 重新引发异常

25try:

26    try:

27        raise HappyException

28    except (HappyException, TypeError):

29        raise

30except:

31    print("HappyException")

32

33#访问异常实例

34try:

35    raise HappyException("都是我的错")

36except (HappyException, TypeError), e:

37    print(e)

38

39#按类型捕获

40try:

41    raise HappyException

42except HappyException:

43    print("HappyException")

44except TypeError:

45    print("TypeError")

46

47#全面捕获

48try:

49    raise HappyException

50except:

51    print("HappyException")

52

53#没有异常的else

54try:

55    pass

56except:

57    print("HappyException")

58else:

59    print("没有异常")

60

61#总会执行的final

62try:

63    pass

64except:

65    print("HappyException")

66else:

67    print("没有异常")

68finally:

69    print("总会执行")

面向对象

先上一张图

几个规则：

1. 一切都是对象，python中一切都是对象，每个对象都包含一个__class__属性以标记其所属类型。
2. 每个对象（记得一切都是对象啊）都包含一个__dict__属性以存储所有属性和方法。
3. 每个类型都包含一个__bases__属性以标记其父类。
4. 属性和方法的访问规则：依次搜索instance、子类、父类、父类的父类、直到object的__dict__，如果找到就返回。
5. 属性和方法的设置规则：直接设置instance.__dict__。
6. 以上属性和方法访问或设置规则没有考虑“魔法方法”，下文会解释。

 示例

 1# coding=utf-8

 2

 3__metaclass__ = type

 4

 5# 类型定义

 6# 实例方法必的第一个参数代表类型实例，类似其他语言的this。

 7class Animal:

 8     name ="未知" # 属性定义。

 9

10    def__init__(self,name): #构造方法定义。

11        self.name = name

12

13    def getName(self):# 实例方法定义。

14        return self.name

15

16    def setName(self, value):

17        self.name = value

18

19print(Animal.name) # 未知

20print(Animal.__dict__["name"])# 未知

21

22 animal = Animal("狗狗")

23print(animal.name) # 狗狗

24print(animal.__dict__["name"])# 狗狗

25print(Animal.name) # 未知

26print(Animal.__dict__["name"])# 未知

27print(animal.__class__.name)# 未知

28print(animal.__class__.__dict__["name"])# 未知

 

1# 类型定义中的代码会执行，是一个独立的作用域。

2class TestClass:

3    print("类型定义中")#类型定义中

绑定方法和未绑定方法

 

 1class TestClass:

 2    def method(self):

 3        print("测试方法")

 4

 5 test = TestClass()

 6print(TestClass.method) #<unbound method TestClass.method>

 7print(test.method) #<bound method TestClass.method of<__main__.TestClass object at 0x021B46D0>>

 8

 9 TestClass.method(test)#测试方法

10 test.method()#测试方法

绑定方法已经绑定了对象示例，调用的时刻不用也不能传入self参数了。

注：使用对象访问实例方法为何会返回绑定方法？这个还得等到学完“魔法方法”才能解释，内部其实是拦截对方法成员的访问，返回了一个Callable对象。

私有成员

1# 私有成员

2class TestClass:

3    __private_property = 1

4

5    def__private_method():

6        pass

7

8print(TestClass.__dict__)# {'__module__': '__main__', '_TestClass__private_method': <function__private_method at 0x0212B970>, '_TestClass__private_property': 1

难怪访问不了了，名称已经被修改了，增加了访问的难度而已。

多重继承

 1#多重继承

 2class Base1:

 3    pass

 4

 5class Base2:

 6    pass

 7

 8class Child(Base2, Base1):

 9    pass

10

11 child = Child()

12print(isinstance(child, Child)) # True

13print(isinstance(child, Base2)) # True

14print(isinstance(child, Base1)) # True

如果继承的多个类型之间有重名的成员，左侧的基类优先级要高，上例子Base2会胜出。

接口那里去了，鸭子类型比接口更好用。

 1class TestClass1:

 2    def say(self):

 3        print("我是鸭子1")

 4

 5class TestClass2:

 6    def say(self):

 7        print("我是鸭子2")

 8

 9def duck_say(duck):

10    duck.say()

11

12 duck_say(TestClass1())# 我是鸭子1

13 duck_say(TestClass2())# 我是鸭子2

调用父类

 1# 调用父类

 2class Base:

 3    def say(self):

 4        print("Base")

 5

 6class Child(Base):

 7    def say(self):

 8         Base.say(self)

 9         super(Child, self).say()

10        print("Child")

11

12 child = Child()

13 child.say()

魔法方法

对象构造相关：__new__、__init__、__del__。

 1from os.path import join

 2

 3class FileObject:

 4    '''Wrapper for file objects to make sure thefile gets closed on deletion.'''

 5

 6    def __init__(self, filepath='~', filename='sample.txt'):

 7        # open a file filename in filepath in readand write mode

 8         self.file =open(join(filepath, filename),'r+')

 9

10    def__del__(self):

11        self.file.close()

12        del self.file

运算符重载：所有运算符都能重载。

 1class Word(str):

 2    '''Class for words, defining comparisonbased on word length.'''

 3

 4    def __new__(cls, word):

 5        # Note that we have to use __new__. This isbecause str is an immutable

 6        # type, so we have to initialize it early (atcreation)

 7        if ' ' in word:

 8            print "Value contains spaces. Truncating to first space."

 9             word =word[:word.index('')] # Word is now all chars before first space

10        return str.__new__(cls, word)

11

12    def__gt__(self, other):

13        return len(self) > len(other)

14

15    def__lt__(self, other):

16        return len(self) < len(other)

17

18    def__ge__(self, other):

19        return len(self) >= len(other)

20

21    def__le__(self, other):

22        return len(self) <= len(other)

23

24print(Word("duan") > Word("wei"))

属性访问。

 1class AccessCounter:

 2    '''A class that contains a value andimplements an access counter.

 3    The counter increments each time the valueis changed.'''

 4

 5    def __init__(self, value):

 6         super(AccessCounter, self).__setattr__('counter', 0)

 7         super(AccessCounter, self).__setattr__('value',value)

 8

 9    def __setattr__(self, name, value):

10        if name =='value':

11             super(AccessCounter, self).__setattr__('counter',self.counter + 1)

12        # Make thisunconditional.

13        # If you want toprevent other attributes to be set, raise AttributeError(name)

14        super(AccessCounter, self).__setattr__(name,value)

15

16    def__delattr__(self,name):

17        if name =='value':

18             super(AccessCounter, self).__setattr__('counter',self.counter + 1)

19        super(AccessCounter, self).__delattr__(name)

集合实现。

 1class FunctionalList:

 2    '''A class wrapping a list with some extrafunctional magic, like head,

 3    tail, init, last, drop, and take.'''

 4

 5    def __init__(self, values=None):

 6        if values is None:

 7             self.values = []

 8        else:

 9             self.values = values

10

11    def__len__(self):

12        return len(self.values)

13

14    def__getitem__(self,key):

15        # if key is ofinvalid type or value, the list values will raise the error

16        return self.values[key]

17

18    def__setitem__(self,key, value):

19        self.values[key] = value

20

21    def__delitem__(self,key):

22        del self.values[key]

23

24    def__iter__(self):

25        return iter(self.values)

26

27    def__reversed__(self):

28        return FunctionalList(reversed(self.values))

29

30    def append(self, value):

31        self.values.append(value)

32    def head(self):

33        # get the firstelement

34        return self.values[0]

35    def tail(self):

36        # get all elementsafter the first

37        return self.values[1:]

38    def init(self):

39        # get elements upto the last

40        return self.values[:-1]

41    def last(self):

42        # get last element

43        return self.values[-1]

44    def drop(self, n):

45        # get all elementsexcept first n

46        return self.values[n:]

47    def take(self, n):

48        # get first nelements

49        return self.values[:n]

可调用对象，像方法一样调用对象。

 1class Entity:

 2    '''Class to represent an entity. Callable toupdate the entity's position.'''

 3

 4    def __init__(self, size, x, y):

 5         self.x, self.y = x, y

 6         self.size = size

 7

 8    def __call__(self, x, y):

 9        '''Change the position of the entity.'''

10        self.x, self.y = x, y

11        print(x, y)

12

13 entity = Entity(5, 1, 1)

14 entity(2, 2)

资源管理

 1class Closer:

 2    def __enter__(self):

 3        return self

 4

 5    def __exit__(self, exception_type, exception_val,trace):

 6        print("清理完成")

 7        return True;

 8

 9 with Closer() as closer:

10    pass

对象描述符。

 1class Meter(object):

 2    '''Descriptor for a meter.'''

 3

 4    def __init__(self, value=0.0):

 5         self.value = float(value)

 6    def __get__(self, instance, owner):

 7        return self.value

 8    def __set__(self, instance, value):

 9         self.value = float(value)

10

11class Foot(object):

12    '''Descriptor fora foot.'''

13

14    def__get__(self,instance, owner):

15        return instance.meter * 3.2808

16    def__set__(self,instance, value):

17        instance.meter = float(value) / 3.2808

18

19class Distance(object):

20    '''Class torepresent distance holding two descriptors for feet and

21    meters.'''

22    meter = Meter()

23    foot = Foot()

Mixin（也叫掺入）

掺入模块：playable.py

1# coding=utf-8

2

3def paly(self):

4    print("游戏中...")

掺入目标模块：test.py

1# coding=utf-8

2

3class Animal:

4    from playableimport paly

5

6 animal = Animal()

7 animal.paly()# 游戏中...

Open Class（打开类型，从新定义成员）

 1#coding:utf-8

 2

 3class TestClass:

 4    def method1(self):

 5        print("方法1")

 6

 7def method2(self):

 8    print("方法2")

 9

10 TestClass.method2 = method2

11

12 test = TestClass()

13 test.method1()# 方法1

14 test.method2()# 方法2

Meta Programming（元编程）

1 TestClass = type("TestClass", (object,), {

2    "say":lambda self : print("你好啊")

3 })

4

5 test = TestClass()

6 test.say()

 

 1def getter(name):

 2    def getterMethod(self):

 3        return self.__getattribute__(name)

 4    return getterMethod

 5

 6def setter(name):

 7    def setterMethod(self, value):

 8         self.__setattr__(name, value)

 9    return setterMethod   

10

11class TestClass:

12    getName = getter("name")

13    setName = setter("name")

14

15 test = TestClass()

16 test.setName("段光伟")

17print(test.getName())