Python基础与深入(一)

发表于 | 更新于 | 分类于 | 阅读次数：

1.Python语言特性

  • Python是一种解释型语言。这就是说，与C语言和C的衍生语言不同，Python代码在运行之前不需要编译。
  • Python是动态类型语言，指的是你在声明变量时，不需要说明变量的类型。
  • Python非常适合面向对象的编程（OOP），因为它支持通过组合（composition）与继承（inheritance）的方式定义类（class）。
  • Python中没有访问说明符（access specifier，类似C++中的public和private），这么设计的依据是“大家都是成年人了”。

在Python语言中，函数是第一类对象（first-class objects）。这指的是它们可以被指定给变量，函数既能返回函数类型，也可以接受函数作为输入。类（class）也是第一类对象。
Python代码编写快，但是运行速度比编译语言通常要慢。好在Python允许加入基于C语言编写的扩展，因此我们能够优化代码，消除瓶颈，这点通常是可以实现的。numpy就是一个很好地例子，它的运行速度真的非常快，因为很多算术运算其实并不是通过Python实现的。

Python用途非常广泛——网络应用，自动化，科学建模，大数据应用，等等。它也常被用作“胶水语言”，帮助其他语言和组件改善运行状况。
Python让困难的事情变得容易，因此程序员可以专注于算法和数据结构的设计，而不用处理底层的细节。

2.Python的命名空间

在Python中，所有的名字都存在于一个空间中，它们在该空间中存在和被操作——这就是命名空间。

它就好像一个盒子，每一个变量名字都对应装着一个对象。当查询变量的时候，会从该盒子里面寻找相应的对象。

3.Python异常处理的用法和作用

[参考廖雪峰](https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143191375461417a222c54b7e4d65b258f491c093a515000]

Python异常处理结构try…except…except…[else…][finally…)

  • 执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。

  • 如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

  • try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行

  • 如果存在finally语句，最后总是会执行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    try:
        print('try...')
        r = 10 / int('2')
        print('result:', r)
    except ValueError as e:
        print('ValueError:', e)
    except ZeroDivisionError as e:
        print('ZeroDivisionError:', e)
    else:
        print('no error!')
    finally:
        print('finally...')
    print('END')

4.Python的函数参数传递

看两个例子:

1
2
3
4
5
a = 1
def fun(a):
    a = 2
fun(a)
print a  # 1
1
2
3
4
5
a = []
def fun(a):
    a.append(1)
fun(a)
print a  # [1]

所有的变量都可以理解是内存中一个对象的“引用”

通过id来看引用a的内存地址可以比较理解：

1
2
3
4
5
6
7
8
a = 1
def fun(a):
    print "func_in",id(a)   # func_in 41322472
    a = 2
    print "re-point",id(a), id(2)   # re-point 41322448 41322448
print "func_out",id(a), id(1)  # func_out 41322472 41322472
fun(a)
print a  # 1

注：具体的值在不同电脑上运行时可能不同。

可以看到，在执行完a = 2之后，a引用中保存的值，即内存地址发生变化，由原来1对象的所在的地址变成了2这个实体对象的内存地址。

而第2个例子a引用保存的内存值就不会发生变化：

1
2
3
4
5
6
7
a = []
def fun(a):
    print "func_in",id(a)  # func_in 53629256
    a.append(1)
print "func_out",id(a)     # func_out 53629256
fun(a)
print a  # [1]

这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可变”（mutable）与“不可变”（immutable）对象。在python中，string, tuple, 和number是不可更改的对象，而 list, dict, set 等则是可以修改的对象。(这就是这个问题的重点)

当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改.

如果还不明白的话,这里有更好的解释: http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference

5.Python的List和Dict的实现原理

推荐:
列表
字典

  • 字典按照键值对的形式进行存储，时间复杂度为O(1)
  • 字典的底层是通过哈希表实现的，使用开放地址法解决冲突。所以其查找的时间复杂度会是O(1)，哈希函数求哈希值(哈希函数就是一个多对一的映射)

6.函数的参数用法和注意事项

(参考廖雪峰课程)[https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431752945034eb82ac80a3e64b9bb4929b16eeed1eb9000]
函数参数分为位置参数、默认参数、可变参数、关键字参数、命名关键字参数（定义和调用必须按顺序传入）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
numbers=[1,2,3,4,5]
def sum(*args):
    sum=0
    for i in args:
        sum = sum+i*i
    return sum
sum(*numbers)

dict1={'a':1,'b':2}
def f(**kwargs):
    for k,v in kwargs.items():
        print('{0}:{1}'.format(k,v))
f(**dict1)

# 如果需要约束传入的关键字参数的名称，可以用命名关键字参数
# 命名关键字参数必须传入参数名，这和位置参数不同。
def person(name, age, *, city, job):
    print(name, age, city, job)

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

# 命名关键字参数可以有缺省值，从而简化调用：
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

7.可变对象和不可变对象

  • python所有数字类型(布尔树,整数,浮点数,复数)均为不可变对象,
  • 可变对象:file,dict,set,list,bytesarray,range
  • 不可变对象:boolean,int,float,complex,tuple,str,bytes,frozenset
  • 有序sequence:str,list,tuple,OrderedDict,
  • 无序:dict,set,
  • 不可重复:set,tuple
  • 可变对象(mutable object)has no hash value
  • 不可变对象可哈希,hashable

8.def是运行时执行语句,并且是赋值语句

类和对象均为第一类对象，调用的时候才会运行

9.Python是否能以可变对象做函数默认参数

不可以,字典,集合,列表等可变对象不适合作为函数默认值
要不然第二次调用时,一次调用的默认参数的值会影响二次调用.

1
2
3
4
5
6
7
def f(l=[]):
    for i in range(3):
        l.append(i)
    return l
f(l=[2]),---- l=[2,0,1,2]
f(),     ---- l=[0,1,2]
f(),     ---- l=[0,1,2,0,1,2]

10.@staticmethod和@classmethod

Python其实有3个方法,即静态方法(staticmethod),类方法(classmethod)和实例方法,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def foo(x):
    print "executing foo(%s)"%(x)

class A(object):
    def foo(self,x):
        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):
        print "executing static_foo(%s)"%x

a=A()

这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定,对于一般的函数来说我们可以这么调用foo(x),这个函数就是最常用的,它的工作跟任何东西(类,实例)无关.对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x),为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)(其实是foo(a, x)).类方法一样,只不过它传递的是类而不是实例,A.class_foo(x).注意这里的self和cls可以替换别的参数,但是python的约定是这俩,还是不要改的好.

对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)或者A.static_foo(x)来调用.

\ 实例方法 类方法 静态方法
a = A() a.foo(x) a.class_foo(x) a.static_foo(x)
A 不可用 A.class_foo(x) A.static_foo(x)

更多关于这个问题:

  1. http://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python
  2. https://realpython.com/blog/python/instance-class-and-static-methods-demystified/
坚持原创技术分享，您的支持将鼓励我继续创作！