python 常用知识点总结

一、python中常用运算符

1.1 三种算法运算符

定义：

x/y      除    ---x除以y

x// y    整除---返回商的整数部分

x%y    取模---返回除法的余数

3/2

3//2

9.0/2

9.0//2

9.0%2

1.2、比较运算符

定义:

<>        不等于

>=         大于等于

<=          小于等于

二、continue语句

continue语句跳过本次循环，继续下一轮循环

break 跳出整个循环

例子：

输出1-10之间所有的奇数

for i in range(10):

    if i%2==0:

        continue

    print (i)

 

三、zfill方法

语法：

str.zfill(width)   --------width指定字符串的长度，原字符串右对齐，前面填充0

a="1"

print (a.zfill(2))

print (a.zfill(30))

四、eval()函数与exec函数

4.1 eval()方法

描述：
eval（）函数用来执行一个字符串表达式，并返回表达式的值

例子：

x=9

 eval('4*x')

 eval('pow(2,2)')

 eval('2+2')

 

4.2 exec函数

描述：

执行存储在字符串或文件中的python语句，相比与eval,exec可以执行更复杂的python代码

例子：

#多行语句字符串
exec("""for i in range(5):

    print ("iter time: %d"%i)

""")

#单行语句字符串

exec('print ("hello world")')

 

五、统计列表首字母的出现次数

name_list=['mic','JO','wx','hi','mK']

代码部分：

name_list=['mic','JO','wx','hi','mK']

d={}

for i in name_list:

    d[i]=" ".join(name_list).count(i[0])

print (d)

 

 

六、shuffle函数

描述：

将序列的的所有元素随机排序，需要先导入random，然后才可以使用random.shuffle(list)

代码部分：

import random

a=[1,2,3,4,5]

random.shuffle(a)

a

 

七、如何查看说明性文档

def add(a,b):

    """光荣之路的 add函数"""

    return a+b

 

print (add.__doc__)

help(add)

add(a=2,b=4)

 

八、按值传与按引用传

如果传入的参数对象是可变对象，如：列表、字典，就是按引用传递；

如果传入的参数对象是不可变对象，如：数字、元组、字符串，就是按值传递。

a=2

b=[1,2,3,4]

def change(x,y):

    x=3

    y[0]=4

 

change(a,b)

print (a,b)

九、python  五剑客

lambda map filter reduce  推倒列表

9.1 lambda函数

实例一：

sum=lambda arg1,arg2:arg1+arg2

print ("相加后的值为：",sum(10,20))

实例二：
def fun(n):

    return lambda s:s*n

 

twice=fun(2)

print (twice("hello"))

 

9.2 map函数

语法：

map(function,iterable,…)

参数：

function—函数，有两个参数

iterable—一个或多个序列

返回值

python 2.x返回列表

python 3.x 返回迭代器

 

实例一：
a=["1","2","3","4","5"]

list(map(int,a))

 

实例二：

def square(x):

    return x**2

 

list(map(square,[1,2,3,4,5]))

或者

list(map(lambda x:x**2,[1,2,3,4,5]))

 

list(map(lambda x,y:(x,y),[1,3,5,7,9],[2,4,6,8,10]))

9.3 filter

描述：

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用list()来转换

语法：

filter(function,iterable)

参数:

function –判断函数

iterable—可迭代对象

 

实例一：

过滤出列表中所有的奇数

def is_odd(n):

    return n%2==1

 

tmplist=filter(is_odd,[1,2,3,4,5,6,7,8,9,10])

newlist=list(tmplist)

print (newlist)

实例二：

过滤出1—100中平分根是整数的数

import math

def is_sqr(x):

    return math.sqrt(x)%1==0

 

tmplist=filter(is_sqr,range(1,101))

newlist=list(tmplist)

print (newlist)

 

9.4 reduce函数

描述：

reduce()函数会对参数序列中元素进行累积

函数将一个数据集合（链表、元组等）中的所有数据进行下列操作：用传给reduce中的函数function（有两个参数）先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，最后得到一个结果。

语法：

reduce(function,iterable[, initializer])

参数：

function ---函数，有两个参数

iterable----可迭代对象

initializer---可选，初始参数

返回值：

返回函数计算结果

备注:python3中reduce()函数已经从全局名字空间里移除了，现在放在functools模块里，需要先导入。

实例一：
from functools import reduce

def add(x,y):

    return x+y

 

reduce(add,[1,2,3,4,5])

 

reduce(lambda x,y:x+y,[1,2,3,4,5])

 

9.5 推倒列表

[i for i in range(10)]

[x+1 for x in range(5)]

[x*10 for x in range(5)]

[x+y for x in [1,2,3] for y in [10,20,30]]

 

 

十、递归方法

方法一：

用递归方法实现斐波那契数列

 

def recur_fibo(n):

    递归函数

输出斐波那契数列

    if n<=1:

        return n

    else:

        return recur_fibo(n-1)+recur_fibo(n-2)

 

#获取用户输入

nterms=int(input("你要输出几项? \n"))

 

#检查输入的数字是否正确

if nterms<=0:

    print ("输入正数")

else:

    print ("斐波那契数列：")

    for i in range(nterms):

        print (recur_fibo(i))

 

方法二：
用非递归方法实现斐波那契数列

def fibo(n):

    result=[0,1]

    for i in range(n-2):

        result.append(result[-1]+result[-2])

    print (result)

 

fibo(10)

 

十一、排序sort

11.1 sort用法

描述：sort会改变原有的值

a=[3,2,6,2,10,-1]

a.sort()

a

11.2 sorted用法

描述：sorted不会改变原来的值

a=[4,1,-1,100,50]

b=sorted(a)

b

 

11.3 reverse用法

a.reverse()

a

会改变原来的值

11.4 sort函数

11.4.1练习一：按长度排序

list1=[(1,5,3),(1,3,6,3),(1,1,2,3,5,6),(1,9)]

def L(tup):

    return len(tup)

 

list1.sort(key=L,reverse=True)

print (list1)

 

备注：

reverse=True，表示降序。

 

11.4.2练习二：找出一句话中最长的单词是哪一个

方法一：

s="Today jinti is a fine day"

a=s.split()

def L(tup):

    return len(tup)

a.sort(key=len,reverse=True)

for i in a:

    if len(i)==len(a[0]):

        print (i,len(a[0]))

 

方法二：

s="Today jinti is a fine day"

a=s.split()

def L(tup):

    return len(tup)

 

a.sort(key=L,reverse=True)

for i in a:

    if len(i)==len(a[0]):

        print (i,len(i))

 

 

方法三：
 

s="Today jinti is a fine day"

a=s.split()

def L(tup):

    return len(tup)

 

a.sort(key=L,reverse=True)

 

print filter(lambda x:len(x)==len(a[0]),a)

11.4.3练习三：按照首字母排序,进行单词排序，不区分大小写

s="Today jinti is a fine day"

a=s.split()

def L(tup):

    return tup[0].lower()

 

a.sort(key=L,reverse=True)

print a

 

11.4.4练习四：按照数字之和做排序

方法一：

sentence="11 22 33 44 394"

word_sentence=sentence.split()

def L(tup):

    return sum(map(int,list(tup)))

word_sentence.sort(key=L,reverse=True)

print word_sentence

方法二：
sentence="11 22 33 44 394"

word_list=sentence.split()

def L(tup):

    result=0

    for i in tup:

        result +=int(i)

    return result

word_list.sort(key=L,reverse=True)

print word_list

 

11.4.5练习五：按照绝对值进行大小比较

方法一：

list1=[(-1,5,3),(-5,3,6,3),(1,1,2,3,5,6),(2,9),(-2,10)]

def compare(a,b):

    if abs(a)>abs(b):

        return 1

    elif abs(a)==abs(b):

        return 0

    else:

        return -1

 

def L(tup):

    return tup[0]

list1.sort(cmp=compare,key=L,reverse=True)

print (list1)

方法二：
 

list1=[(-1,5,3),(-5,3,6,3),(1,1,2,3,5,6),(2,9),(-2,10)]

def L(tup):

    return abs(tup[0])

 

list1.sort(key=L,reverse=True)

print (list1)

 

11.4.6练习六：list1=[1,2,3],list2=[4,5,6]合并为[(1,4),(2,5),(3,6)]

代码部分：

方法一：

list1=[1,2,3]

list2=[4,5,6]

result=[]

for i in range(len(list1)):

    x=(list1[i],list2[i])

    result.append(x)

print result

 

方法二：

python2

list1=[1,2,3]

list2=[4,5,6]

print map(lambda x,y:(x,y),list1,list2)

 

python 3

 

list1=[1,2,3]

list2=[4,5,6]

print (list(map(lambda x,y:(x,y),list1,list2)))

方法三：

python 2
zip([1,2,3],[4,5,6])   

 

python3

list(zip([1,2,3],[4,5,6]))

 

十二、推倒列表

[x for x in range(5)]

[x+1 for x in range(5)]

[x*10 for x in range(5)]

[x+y for x in [1,2,3] for y in [10,20,30]]

 

 

十三、迭代器

描述：

迭代器有两个基本方法：iter()和next()

字符串、列表、元组对象有可以用来创建迭代器

13.1实例一

python 2

a=iter(range(10))

type(a)

a.next()

a.next()

 

python 3

a=iter(range(10))

a.__next__()

a.__next__()

a.__next__()

13.2实例二：

list=[1,2,3,4]

it=iter(list)

for x in it:

print (x,)

或者

import sys

list=[1,2,3,4]

it=iter(list)

while True:

    try:

        print (next(it))

    except StopIteration:

        sys.exit()

 

13.3自定义迭代器

class MyRange(object):

    def __init__ (self,n):

        self.idx=0

        self.n=n

       

    def __iter__ (self):

        return self

   

    def next(self):

        if self.idx

            val=self.idx

            self.idx +=1

            return val

        else:

            raise StopIteration()

myRange=MyRange(3)

for i in myRange:

    print i

十四、生成器

生成器是一个返回迭代器的函数，简单说，生成器就是一个迭代器

14.1实例一

a=[1,2,3,4]

b=(x*x for x in range(10))

type(b)

b.__next__()

 

b.__next__()

 

14.2实例二

 

def odd():

    print ('step 1')

    yield 1

    print ('step 2')

    yield 3

    print ('step 3')

    yield 5

o=odd()

print (o.__next__())

print (o.__next__())

print (o.__next__())

 

十五、枚举

描述：

将一个可遍历的数据对象（列表、元组、字符串）组合为一个索引序列。

语法：

enumerate(sequence,[start=0])

参数：

sequence—一个序列、迭代器或其他支出迭代对象。

start-----------下标起始位置

15.1实例一

for i,value in enumerate(['A','B','C']):

print (i,value)

15.2实例二

seasons=['spring','summer','fall','winter']

list(enumerate(seasons))

list(enumerate(seasons,start=1))

 

十六、直接赋值、浅拷贝和深度拷贝

import copy

a=[1,2,3,4,5,['a','b']]

b=a

c=copy.copy(a)

d=copy.deepcopy(a)

a.append(6)

a[5].append("c")

c[5].append("d")

print ("a=",a)

print ("b=",b)

print ("c=",c)

print ("d=",d)

 

备注：

1 copy.copy浅拷贝，只拷贝父对象，不会拷贝对象的内部的子对象【list元素改变 会互相影响】

2 copy.deepcopy深拷贝，拷贝父对象及其子对象【互相不影响】

3 直接赋值：其实就是对象的引用（别名）

 

解析：

1、b = a: 赋值引用，a 和 b 都指向同一个对象。

2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

 

 

十七、堆栈、队列

堆栈原理：先进后出；后进先出

 

队列原理：先进先出

什么情况下使用：一大堆请求，邮箱注册

 

 

 

十、练习

判断一个数是否是素数

算法一：使用2-到本身直接的所有数做除法，没有发送整除，就是质数

算法二：使用2-到它本身平方根之间的所有数做除法，没有发生整除，则就是质数

while 1:

    num=int(input("Please input a number:"))

    for i in range(2,num):

        if num%i==0:

            print ("%d is not prime"%num)

            break

    else:

        print ("%d is a prime"%num)