python常用知识梳理(必看篇)

1

2

a）利用转义字符‘\'

b）利用原始字符‘r' print r'c:\now'

1

2

3

4

5

6

7

8

9

10

11

#hello Python

多行注释，使用三个单引号（或三个双引号），如：

'''hello python

hello world'''

或

"""hello python

hello world"""

另外跨越多行的字符串。也可以使用三个单引号或三个双引号，如：

'''......'''

或者

"""......"""

1

2

a）利用转义字符‘\'

b）使用单引号括起这个字符串。print ('i l"o"ve fis.com')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

if condition:

     条件为真执行的操作

  else:

     条件为假执行的操作

  if condition:

     action

  elif condition:

     action

  else:

    action

python可以有效避免“悬挂else”（if else对应关系出错）

条件表达式（三元操作符）

    small = x if xelse y

1

2

3

4

5

6

7

8

9

10

11

12

13

条件为真执行的操作

for 目标 in 表达式：

循环体

 例：favorite='fishc'

    for i in favorite:

       print(i,end='')

range([start,] stop[,step=1])

生成一个从start参数的值到stop参数值的数字序列

break：终止当前循环体。跳到外层程序

continue:终止本轮循环，开始下一轮循环（if condition true）

1

2

3

4

a）random模块

b）randint(),返回一个随机的整数

import random 或 from random import randint()

secret=random.randint(1,10)

1

2

3

4

5

6

7

8

9

10

11

12

13

a）数值类型:整型、布尔类型、浮点型、e记法（1.5e10）

b）类型转换：

   int()转换为整数

   str()转换为字符串

   float()转换为浮点数

c）获取关于类型的信息：

   type()函数

    a=520

    type(a)

   isinstance()函数

    a=12

    isinstance(a,int) --->返回true

    isinstance(a,str) -->返回false

1

2

3

4

5

6

7

8

9

10

+ - * / % **（幂运算） //(地板除法,结果偏小)

比较操作符 > < >= <=

逻辑操作符 and or not

   优先级：

     幂运算**

     正负号 + -

     算术操作符 * / //

         + -

     比较操作符 < > =

     逻辑擦作福 not and or

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

创建一个普通列表：

   member = ['小甲鱼','小布丁','黑夜']

创建一个混合列表：

   mix=[1,'小甲鱼'，3.12，[1,2,3]]

创建空列表：

   empty=[]

向列表添加元素：

   append(): member.append('福禄娃')-->只能添加一个。末尾添加

   extend(): member.extend(['test','test1'])-->只能以列表形式添加.末尾添加

   insert(): member.insert(1,'牡丹')-->第一位插入牡丹

列表中获取元素：使用索引index。    mix[1]

列表中删除元素：使用remove()。     mix.remove('小甲鱼')

           使用del。         del mix[3]/mix

           使用pop()。        mix.pop()/mix.pop(1)

列表切片：使用slice。 mix[1:4]/mix[1:]/mix[:4]

列表操作符：>,and,+,*,in/not in

列表的小伙伴：dir(list)

          mix.count('小甲鱼')

          mix.index('小甲鱼')

列表逆序：使用reverse。   mix.reverse()

列表排序：使用sort。     mix.sort()

       mix.sort(func,key)

       mix.sort(reverse=True)

1

2

3

4

5

6

和列表的主要不同点：

a）创建和访问一个元组： 大部分用（）/, ；列表用[]

b）元组不可修改数值

c）更新和删除一个元组：temp = temp[:2] + ('test3',) + temp[2:]

  del temp

d）IN/NOT IN，关系操作符，逻辑操作符，乘号操作符，连接操作符

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

str1='i love fishc.com'

a=str1[:6] + '插入的字符串'+str1[6:]

capitalize()： str2.capitalize()

casefold()--->全部小写 str2.casefold()

center(width)-->居中，不足空格填充

count(sub[,start[,end]])-->返回sub在string中出现的次数

endswith(sub[,start[,end]])-->以sub结束？

startswith(prefix[,start[,end]])-->以prefix开头

expandtabs([tabsize=8])-->将tab键转换为空格

find(sub[,start[,end]])-->sub是否在字符串中出现

rfind(sub)...

index(sub[,start[,end]])-->跟sub一样，不过会产生异常

rindex(sub..).....

istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()

join(sub):以字符串做分隔符，分割sub

partion(sub):找到子字符串sub，把字符串分成一个3元组

replace(old,new[,count])

split(sep=none,maxsplit=-1)-->不带参数以空格做分隔符

swapcase()-->字符串大小写翻转

zfill(width)-->返回长度为width的字符串，不够补充空格

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)

"{a} love {b}.{c}".format(a="i",b="fishc",c="com")

"{0} love {b}.{c}".format("i",b="fishc",c="com")

格式化符号含义：

  %c:格式化字符及其ASCII码

  '%c %c %c' % (97,98,99)

  %s:格式化字符串

  %d:格式化整数

  %o:格式化无符号八进制数

  %x:格式化无符号十六进制数 %X:...(大写)

  %f:格式化定点数，可指定小数点后的精度

  %e:用科学技术发格式化定点数===%E

  %g:根据值的大小决定使用%f或%e===%G

格式化操作符辅助命令：

  m.n ：m是显示的最小总宽度，n是小数位精度

  - ：用于左对齐

  + ：在正数面前添加正号

  # ：在八进制面前显示0，在十六进制面前显示0x

  0 ：空格用0填充

字符串转义字符

  \a:发出系统响铃声

  \b、\t、\n

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

列表、元组和字符串的共同点：

  a）都可以通过索引

  b）索引值从零开始

内置方法：

   list（）-->help-->转换为序列

     list()

       a=list()

     list(iterable)

       b='i love fishc.com'

       b=list(b)

   tuple([iterable])-->把一个可迭代对象转换为元组

       b=tuple(b)

   str(obj)-->把obj对象转换为字符串

   len(obj)-->返回obj的长度

   max(序列/元组) / min(序列/元组)

   sum(iterable[,start=0])-->返回序列iterable。。的总和

   sorted(序列/元组)-->排序

   reversed(序列/元组)-->返回一个迭代器对象

   list(reversed(序列/元组))-->返回序列

   enumerate(序列/元组)-->返回一个迭代器对象

   list(enumerate(序列/元组))-->返回数组形式列表

   zip（a,b）-->合并成以元组形式的列表

   list(zip(a,b))

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

26

27

28

29

30

31

32

定义：def Myfunction():

   print('this is my first function')

调用：Myfunction()

函数的参数：

   def Myfunction(name,age):

   print(name+age+'test')

   Myfunction('gncao'，‘age')

函数的返回值:

   return value

形参（parameter）：函数定义时的参数

实参（argument）：实际传递的参数

函数文档：在函数中实现

在函数体中用 '' 或 #

查看函数文档: a） functionname.__doc__ （四个下划线）

          b） help(functionname)

关键字参数：避免参数出乱

   def Myfunction(words,name):

   ......

   Myfunction(words='words123',name='name123')

 默认参数:

   def Myfunction(name='name123',words='words123')

   ......

 收集参数：在参数前面加上*号

  def test(*params):

  print('参数的长度是:',len(params))

  print('第二个参数是:',params[1])

  test(1,'小甲鱼',2,4,5,6,7)

  def test(*params,exp):

  print('参数的长度是:',len(params),exp)

  print('第二个参数是:',params[1])

  test(1,'小甲鱼',23,4,2,5,7,exp=0)

1

2

3

局部：local-->函数内部定义的变量，局部可用

全局：global-->全局可访问

当在函数内部试图修改全局变量时，则会在函数内部新建一个跟 全局变量名相同的局部变量

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

26

27

28

29

30

31

global关键字：

   def myfun():

     global count ->>>全局变量

     count=10

     print(count)

内嵌函数:

   def fun1():

     print('fun1()正在被调用...')

     def fun2():

        print('fun2()正在被调用')

     fun2()

只能通过fun1()访问fun2()

闭包:在一个内部函数中，对外部函数的变量的引用。成内部函数为闭包

   def funx(x):

     def funy(y):

       return x * y

     return funy

调用方式:

   i=funx(8)

   i(5)

   或

   funx(4)(5)

通过关键字nonlocal可以使得内部函数调用外部函数变量。

   def fun1():

     x=5

     def fun2():

       nonlocal x

       x*=x

       return x

   return fun2()

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

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

recursion（）

        def fac(n):

              if n==1:

                    return 1

              else:

                    return n*fac(n-1)

        number=int(input('请输入一个整数:'))

        result=fac(number)

        print('%d 的阶乘是：%d' % (number,result))

迭代方法：

def fab(n):

  n1=1

  n2=1

  n3=1

  if n <1:

    print('输入有错')

    return -1

  while ( n-2>0 ):

    n3=n2+n1

    n1=n2

    n2=n3

    n-=1

  return n3

result=fab(20)

if result != -1:

  print('总共有%d对小兔子诞生：' % result)

递归方法：

def fab(n):

  if n < 1:

    print('error')

    return -1

  if n==1 or n==2:

    return 1

  else:

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

result=fab(20)

print('总共有%d对兔子诞生' % result)

但是递归的效率比较低

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

26

27

28

29

30

31

32

33

34

35

36

映射/序列

例1：

dict1={'李宁':'一切皆有可能','耐克':'just do it','阿迪达斯':'impossible is nothing'}

print('李宁的口号是:',dict1['李宁'])

例2:

dict3=dict((('f',70),('i',105)))

例3:

dict4=dict(小甲鱼='编程改变世界',test='test')

dict4['小甲鱼']='修改小甲鱼对应的value'   -->如果没有该KEY，则会自动添加一个KEY

字典的内建方法:

a）

dict2['key']-->访问字典的元素

b）

fromkeys(s[,v]) -->创建或查询key

dict1.fromkeys((1,2,3))

{1: None, 2: None, 3: None}

dict1.fromkeys((1,2,3),'number')

{1: 'number', 2: 'number', 3: 'number'}

c）

keys()-->dict.keys() -->打印出dict的所有key

values()-->dict.values() -->打印出dict的所有value

items()-->dict.items() -->打印出dict所有(key,value)

get()--> dict.get(key) -->打印key对应的value

dict.get(key,'text')-->打印key对应的value，如果不存在，则打印text

in操作符 --> key in dict2

clear() -->dict.clear() -->清空dict的数据

copy() -->b=a.copy()  -->拷贝字典

id(a)-->查看id

pop(key) --> dict.pop(key) -->弹出key

popitem() -->dict.popitem() -->随机弹出key

setdefault() -->dict.setdefault(key) -->新建key

update()  -->dict.update(dict)  -->更新字典

1

2

3

4

5

6

7

8

9

10

num={1,2,3,4,5}

set()-->set1=set(列表/元组/字符串)

不支持索引

访问集合中的值:

    使用for循环一一查找    

    使用IN 或者 NOT IN

add()-->set1.add(value)

remove()-->set1.remove(value)

不可变集合:

num3=frozenset(元组/列表)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

输入-->处理-->输出

内存--->磁盘

open()打开文件:

open('filename/path',mode='rwxabt+U')

文件对象方法:

f.close() -->关闭文件

f.read(size=-1) -->从文件读取size个字符

f.readline() -->以写入模式打开，如果文件存在，则在末尾添加

f.write(str) -->将str写入文件

f.writelines(seq) ->向文件写入seq序列。seq应该是一个返回字符串序列

f.tell() -->返回当前的位置。书签

f.seek(offset,from) -->在文件中移动文件指针，从from偏移offset字节

for each in f:  ---->浏览整个文件

print(each)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

模块：打包的文件系统

os模块：

常用方法：

os.getcwd():返回工作目录

os.chdir(path):改变工作目录

os.listdir(path=''):列出文件目录

os.mkdir(path):创建目录

os.makedirs(path):创建递归目录

os.remove(path):删除文件

os.removedirs(path):递归删除

os.rename(old,new):文件重命名

os.system(command):运行系统的shell命令

os.curdir:指代当前目录.等价于‘。'

os.pardir:指代上一级目录

os.sep:输出操作系统的路径分隔符

os.linesep:当前平台使用的行终止符

os.name:指出当前使用的操作系统

1

2

3

4

5

6

7

8

9

10

11

存放：pickling

读取:unpickling

首先要导入模块pickle

import pickle

>>> my_list=[1,2,3,'test',[23,43]]

>>> pickle_file=open('my_list.pkl','wb') --》打开一个pickle文件

>>> pickle.dump(my_list,pickle_file) --》把my_list导入到pickle_file

>>>pickle_file.close()

>>> pickle_file=open('my_list.pkl','wb')

>>> my_list2=pickle.load(pickle_file) -->把pickle_file导入到my_list2

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

常见标准异常:

AssertionErron/AttributeError/EOFError/IndexError/KeyError

/NameError/OSError/OverflowError/SyntaxError/TypeError/ZeroDivisionError

捕获异常：

try:

    检测范围

except Exception[as reason]:

    出现异常后的处理代码 print('代码')

except Exception[as reason]；

    出现异常后的处理代码 print('daimai'+ str(reason))    

except (Error1,Error2):

    处理异常的代码

try:

    检测范围

except Exception[as reason]:

    处理异常的代码

finally:

    无论如何都会处理的代码

raise语句抛出异常

raise Exception('指示代码')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

else配合其他语句产生更多的功能

with语句：缩小工作量:

没有使用with前:

try:

  f=open('data.txt','r')

  for each in f:

    print(each)

except OSError as reason:

  print('出错啦:'+str(reason))

finally:

  f.close()

使用with后:

try:

  with open('data.txt','w') as f:

    for each in f:

      print(each)

except OSError as reason:

  print('出错啦:'+str(reason))

1

2

3

4

5

6

7

8

9

导入模块三种方式:

a）import  easygui

easygui.msgbox('test')

b）from easygui import *

msgbox('test')

c）import easygui as g

  g.msgbox('test')

建议不要再IDLE上运行EASYGUI

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

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

关键词class

class Turtle:

    #属性

    color='green'

    weight=10

    #方法:

    def climb(self)

        print('climb tree')

调用:

tt=Turtle() -->创建对象

tt.climb() -->调用方法

oo=面向对象

oo的特征：

1，封装

2，继承

    class mylist(list):

        pass --->表示只继承父类，不做其他任何改动    

    list2=mylist()

3，多态

self-->相当于c++的this指针

>>> class ball:

    def setname(self,name):

        self.name=name

    def kick(self):

        print('i am %s,who kicked me????' % self.name)

a=ball()

a.setname('test')

4，_init_(self) --->构造方法

>>> class ball:

    def __init__(self,name):

        self.name=name

    def kick(self):

        print('i am %s,who kicked me????' % self.name)

b=ball('test')

5,公有和私有

类属性和方法默认都是公有的

name mangling --->名字改编，名字重整

私有变量:在变量名或函数名前加上'__'双下划线     

访问私有变量方法:

1,在类内定义方法，间接访问私有变量

2,._类名__变量名

6，继承

class derivedclassname(basename):

    ....

如果子类中出现和父类相同的方法，则覆盖掉父类的方法

不想覆盖掉父类的方法：

1，调用未绑定的父类方法

     def __init__(self):

        fish.__init__(self)  ----》先调用父类同名的方法

            self.hungry=True

2，使用super函数

     def __init__(self):

            super().__init__()

         self.hungry=True    

7，多重继承

class derivedclass(base1,base2,base3):

    ......

8，拾遗

Mix-in编程机制

类，类对象，实例对象,实例属性（static）

如果属性的名字和方法的名字相同，则属性会覆盖掉方法

绑定:

class bb:

    def printbb():

        print('no zuo no die')

b1=bb()

b1.printbb() ---->会出错误

9，一些相关的BIF：

issubclass(class,classinfo)

1,一个类被认为是自己的子类

2，classinfo可以是类对象组成的元祖，只要class与其中任何一个候选类的子类，则返回TRUE

isinstance(object,classinfo)

检查对象是否属于classinfo类

1，如果第一个参数不是对象，则永远返回fasle

2，如果第二个不是类，则会抛出typeerror的异常

hasattr(object,name) -->测定object中是否有'name‘属性

hasattr(c1,'x')

getattr(object,name[,default]) -->如果有属性返回1，否则返回default

setattr(object,name,value) -->给object中的name属性赋值vlalue

delattr(object,name) -->删除object中的name属性

property(fget=none,fset=none,fdel=none,doc=none)设置属性，设置定义好的属性

获取属性的方法，设置属性的方法，删除属性的方法

class c:

    def __init__(self,size=10):

        self.size=size

    def getsize(self):

        return self.size

    def setsize(self,value):

        self.size=value

    def delsize(self):

        del self.size

    x=property(getsize,setsize,delsize)

c1=c()

c1.x    /  c1.x=19   /c1.size

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

特点：

1，魔法方法总是被双下划线包围，例如__init__

2，魔法方法是面向对象python的一切

3，魔法方法的魔力体现在他们总能够在适当的时候被自动调用

构造方法：

__init__(self[,...]) -->返回值一定是NONE

用在实例初始化

__new__(cls[,...])  --->第一个初始化的方法

当继承一个不可修改属性的类时，则调用此方法修改属性

class capstr(str):

    def __new__(cls,string):

        string=string.upper()

        return str.__new__(cls,string)

析构方法：

__del__(self)  当数据不适用时，调用此方法

只有在调用了该对象的所有实例都消失时才会产生此方法

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

__add__(self,other):定义加法的行为'+'

例子：

>>> class new_int(int):

    def __add__(self,other):

        return int.__sub__(self,other)

    def __sub__(self,other):

        return int.__add__(self,other)

>>> a=new_int(3)

>>> b=new_int(8)

>>> a+b  ---->此时a是self，b是other

-5

__sub__(sub,other):减法

__mul__(sub,other):乘法

truediv/floordiv/mod/divmod/pow/lshift/rshift/and/xor/or

divmod(a,b)返回的值是一个元祖：(a//b,a%b)

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

26

27

28

29

30

31

32

33

34

socket提供较为底层的网络连接及数据传输功能

tcp socket/udp socket/unix socket

整个通信过程三步走：

a）客户端连接服务器：

导入模块：

import socket

创建tcp类型的socket:

c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

建立到指定ip地址、端口的tcp连接

c.connect(('211.121.12.43',80))

在系统上使用netstat命令查看新建的连接:

关闭连接：

c.close()

b）服务器端监听：

import socket

s=socket.socket(socket.AF_INET,socket.sock.SOCK_STREAM)

s.bind(('127.0.0.1',80))

s.listen(1)

while True:

    cs,ca=s.accept() -->创建socket和客户端通信

    cs.sendall('replay')

    cs.close()

c）客户端收发数据:

import socket

c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

c.connect(('211.121.12.43',80))

向服务端发送‘hello'

c.send('hello')

读取服务端回复数据:

c.recv(1024)

c.close()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

导入httplib模块：

import httplib

创建http实例，指定连接主机名和端口：

http=httplib.HTTPConnection('itercast.com',80)

指定要获取的URI:

http.request('GET','/ask') -->get方法获取指定数据，ask表示要访问的页面

输出返回的网页body内容：

print http.getresponse().read()

关闭连接：

http.close()

更简单的urllib库：

导入urllib模块

import urllib

创建一个opener的实例

opener=urllib.build_opener()

打开指定的url

f=opener.open('http://www.baidu.com/ask')

读取返回内容

f.read()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

import MySQLdb

conn=MySQLdb.connect(user='root',passwd='',host='127.0.0.1') --->连接mysql，默认是localhost

创建游标，通过游标发送sql指令

cur=conn.cursor()

conn.select_db('database-name') --》连接数据库,本例用week

cur.execute('insert into userinfo(name,age) value('milo',20)') --》执行sql语句。insert

简单化操作方式:

sqli='insert into userinfo(name,age,gender) value(%s,%s,%s)'

cur.execute(sqli,('a',37,'male'))

cur.executemany(sqli,[('test',34,'male'),('test2',36,'female')])

cur.execute('delete from userinfo where id=20') -->删除数据

cur.execute('select * from userinfo') -->查询数据，但是不能直接显示，使用以下方法可以查看

cur.fetchone()-->在python上显示一行数据

cur.scroll(0,'absolute')-->移动指标,此为绝对方式

cur.fetchmany(15)-->在python上显示15条数据.需要输入数据。必须先查询

cur.fetchmany(cur.execute('select * from userinfo')) -->通过一条命令显示数据

cur.close() -->关闭游标的连接

conn.close()  --->关闭数据库连接