PYTHON知识点汇总

2024年1月30日发(作者：)

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出：print 'The quick brown fox', 'jumps over', 'the lazy dog'

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。

如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示。类似的，如果字符串包含"，我们就可以用' '括起来表示：如果字符串既包含'又包含"怎么办？这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用进行转义。

n 表示换行

t 表示一个制表符

表示 字符本身

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r，表示这是一个 raw 字符串，里面的字符就不需要转义了。如，r'(~_~)/ (~_~)/'。如果要表示多行字符串，可以用'''...'''表示

如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释# -*- coding: utf-8 -*-

print u'中文'

在Python中，布尔类型还可以与其他数据类型做 and、or和not运算

直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list

索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。

因此，要打印第一名同学的名字，用 L[0]

添加 list 的 append() 方法或者insert()方法

定位删除()

对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。

缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。if age >= 18:

要避免嵌套结构的 if ... else ...，我们可以用 if ... 多个elif ... else ...的结构，一次写完所有的规则

奇数加和 for a in L:

sum+=a

x += 2

偶数不要if x%2==0:

Continue

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。d={}

(x)可以取到d{}中key后面的value

个数 len(s)

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for name,score in s:

print name,':',score

():()

比较函数cmp(x,y)

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):

print args

可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数

(L[i]) 向r添加

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：

>>> L[0:3]

['Adam', 'Lisa', 'Bart']

只用一个 : ，表示从头到尾：

>>> L[:]

切片操作还可以指定第三个参数：

>>> L[::2]

['Adam', 'Bart']

第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

print L[4::5][-10:] 先获得5的倍数，再取后10个

首字母大写 def firstCharUpper(s):

return s[:1].upper()+s[1:]

range(1,101)

方法是使用 enumerate() 函数：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> for index, name in enumerate(L):

... print index, '-', name

...

0 - Adam

1 - Lisa

2 - Bart

3 - Paul

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

print ()

# [85, 95, 59]

for v in d.(iter)values():

print v

# 85

# 95

# 59

items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }

n=0

sum = 0.0

for k, v in ems():

sum = sum + v

n+=1

print k,':',v

print 'average', ':', sum/n

[x * x for x in range(1, 11)]

变量可以指向函数 f=abs

根号 import math

def add(x, y, f):

return f(x) + f(y)

print add(25, 9, )

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

def format_name(s):

return s[:1].upper()+s[1:].lower()

print map(format_name, ['adam', 'LISA', 'barT'])

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：

reduce(f, [1, 3, 5, 7, 9], 100)

结果将变为125，因为第一轮计算是：

计算初始值和第一个元素：f(100, 1)，结果为101。

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):

return s and len(()) > 0

filter(is_not_empty, ['test', None, '', 'str', ' ', 'END'])

根为整数def is_sqr(x):

return (x)%1==0

升序 def cmp_ignore_case(s1, s2):

if ()>():

return 1

elif ()<():

return -1

else:

return 0

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。

def count():

fs = []

for i in range(1, 4):

def f(i):

def g():

return i*i

return g

(f(i))

return fs

f1, f2, f3 = count()

print f1(), f2(), f3()

通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：

def f(x):

return x * x

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

测试空字符

print filter(lambda s:s and len(()) > 0, ['test', None, '', 'str', ' ', 'END'])

装饰器@new—fn

def performance(f):

def print_time(*args, **kw):

print 'call '+f.__name__+'() in '+me('%Y-%m-%d',ime(()))

return f(*args,**kw)

return print_time

装饰器有decorator的情况下，再打印函数名：

def log(f):

def wrapper(*args, **kw):

print ''

return f(*args, **kw)

return wrapper

@log

def f2(x):

pass

print f2.__name__

def performance(unit):

def fn(f):

@(f)

def wrapper(*args, **kw):

t0 = ()

back = f(*args, **kw)

t1 = ()

t = (t1 - t0) if unit =='s' else (t1 - t0) * 1000

print 'call %s() in %s %s' % (f.__name__, t, unit)

return back

return wrapper

return fn

int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换：

>>> int('12345', base=8)

5349

>>> int('12345', 16)

74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):

return int(x, base)

l就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools

>>> int2 = l(int, base=2)

import functools

sorted_ignore_case = l(sorted, cmp=lambda a,b: cmp((),()))

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

(2, 0.5)

from math import log

利用ImportError错误，我们经常在Python中动态导入模块：

try:

from cStringIO import StringIO

except ImportError:

from StringIO import StringIO

Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

>>> 10 / 3

3.3333333333333335

>>> 10 // 3

3

要在Python 2.7中引入3.x的除法规则，导入__future__的division：

>>> from __future__ import division

>>> print 10 / 3

3.3333333333333335

class A(object)

pass

a1 = A()

a2 = A()

1.判断某个对象是否是类的实例

isinstance(a1, A)

2.判断两个对象是否是否完全一致（意思为： 判断两个变量引用的地址是否相同，如果相同，则两个变量实际引用为同一对象）

用is进行判断

a3 = a1

print a1 is a3

3.判断两个对象中的内容是否相同

用 == 进行判断

print a1 == a2

按照关键词排序

L1 = [p1, p2, p3]

L2 = sorted(L1,key=lambda x:)

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):

def __init__(self, name, gender, birth):

= name

= gender

= birth

__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

解释器内部会将**kw拆分成对应的dict.

setattr()方法接受3个参数：setattr(对象，属性，属性的值)

setattr(self,k,v)相当于self.k = v

ems()历遍字典kw的所有key和value，分别匹配k，v

*args 容纳任意变量的list

*kwargs 容纳任意key，value的dict

class Person(object):

def __init__(self, name, gender, birth, **kw):

=name

=gender

=birth

for k,v in ems():

setattr(self,k,v)

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：

class Person(object):

def __init__(self, name):

= name

self._title = 'Mr'

self.__job = 'Student'

class Person(object):

def __init__(self, name, score):

=name

self.__score=score

p = Person('Bob', 59)

print

try:

print p.__score

except AttributeError:

print 'attributeerror'

class Person(object):

count=0

def __init__(self,name):

=name

+=1

p1 = Person('Bob')

print

p2 = Person('Alice')

print

p3 = Person('Tim')

print

如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：

class Person(object):

def __init__(self, name, gender):

= name

= gender

定义Student类时，只需要把额外的属性加上，例如score：

class Student(Person):

def __init__(self, name, gender, score):

super(Student, self).__init__(name, gender)

= score

一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。

多重继承的继承链就不是一棵树了，它像这样：

class A(object):

def __init__(self, a):

print ''

self.a = a

class B(A):

def __init__(self, a):

super(B, self).__init__(a)

print ''

class C(A):

def __init__(self, a):

super(C, self).__init__(a)

print ''

class D(B, C):

def __init__(self, a):

super(D, self).__init__(a)

print ''

Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。

要创建多进程模式的 TCPServer：

class MyTCPServer(TCPServer, ForkingMixin)

pass

要创建多线程模式的 UDPServer：

class MyUDPServer(UDPServer, ThreadingMixin):

pass

多重 class BStudent(Student,BasketballMixin):

Pass

ClassC(A,B)

返回属性：对于实例变量，dir()返回所有实例属性，包括`__class__`这类有特殊意义的属性。注意到方法`whoAmI`也是 s 的一个属性。首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象。dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了

对 int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序，但是，如果对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()：

class Student(object):

def __init__(self, name, score):

= name

= score

def __str__(self):

return '(%s: %s)' % (, )

__repr__ = __str__

def __cmp__(self, s):

if < :

return -1

elif > :

return 1

else:

return 0

从低到高return cmp(,)

从高到底 return -cmp(,)

如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。

a, b = b, a + b其实就是多个变量的赋值运算，先算=右边，再赋值给左边变量：

0)a=0,b=1

1)a=b=1,b=a+b=1

2)a=b=1,b=a+b=2

3)a=b=2,b=a+b=3

4)a=b=3,b=a+b=5

5)a=b=5,b=a+b=8

6)a=b=8,b=a+b=13

要表示有理数，可以用一个Rational类来表示：

class Rational(object):

def __init__(self, p, q):

self.p = p

self.q = q

求最大公约数

def gcs(a,b,c=1):

if 0==a%2 and 0==b%2:

return gcs(a/2,b/2,c*2);

s = abs(a-b)

m = min(a,b)

if s == m:

return m*c

return gcs(s,m,c)

如果要把 Rational 转为 int，应该使用：

r = Rational(12, 5)

n = int(r)

要让int()函数正常工作，只需要实现特殊方法__int__():

class Rational(object):

def __init__(self, p, q):

self.p = p

self.q = q

def __int__(self):

return self.p // self.q

class Rational(object):

def __init__(self, p, q):

self.p = p

self.q = q

def __int__(self):

return self.p // self.q

def __float__(self):

return self.p*1.0/self.q

print float(Rational(7, 2))

print float(Rational(1, 3))

以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

class Student(object):

def __init__(self, name, score):

= name

self.__score = score

@property

def score(self):

return self.__score

@

def score(self, score):

if score < 0 or score > 100:

raise ValueError('invalid score')

self.__score = score

第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@装饰，@是前一个@property装饰后的副产品。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

class Person(object):

def __init__(self, name, gender):

= name

= gender

def __call__(self, friend):

print 'My name is %s...' %

print 'My friend is %s...' % friend

斐波那契数列：

class Fib(object):

def __call__(self,num):

L=[0,1]

i=2

for i in range(2,num):

(sum(L[-2:]))

return L

f = Fib()

print f(10)

()长度

匹配ma=(r’[A-Z][a-z]’,’Aa’)

ma=(r’[A-Z][a-z]*’,’Aasdfghjkkl’)

Info=l(r’d+’,str1)+

sum([int(x) for x in info])

分割 把imooc和后面分割开，一个：一个空格加| （或）