首页  思维导图  详情

Python导图

2017-12-04 14:14:04   36  举报





AI智能生成

Python思维导图, Python基础知识

作者其他创作

大纲/内容

常用类型

特点

字符串不能修改

列表可以嵌套任何东西

字典是无序的（用key来寻找）

字典也可以嵌套很多层

基本操作

转成字典

str(dict)

tuple(dict.key()), tuple(dict.values())

元组

str(tup)

list(tup)

列表

str(nums)

tuple(nums)

字符串

tuple(eval(str))

list(eval(str))

eval(str_dic)

判断某个元素是否在里面

isIn= 1 in list_1

集合数据类型

列表

列表生成式

a=[1,2,3] #固定列表

[ i*2 for i in range(10)] #动态生成列表

元组

字符串

字典

无序

集合

去重复

关系测试

交集，差集，并集，反向（对称）差集

项目相关

软件目录规范

常用模块

标准库

time

struct_time-asctime-> Tue Dec 5 10:57:26 2017

Timestamp-ctime-> Tue Dec 5 10:57:26 2017

random

sys

shutil

shelve

configparser

hashlib

类相关

类创建以及调用

创建方式

普通方式

class Foo(object):    def func(self):       print("Hello world")

特殊方式

def func(self):    print 'hello wupeiqi' Foo = type('Foo',(object,), {'func': func})

#type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员

调用顺序

__new__ --> __init__ --> __call__

参考链接

http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python

变量

类变量

特点

共用属性

节省内存

实例变量

方法

静态方法

静态方法里不能访问类或实例中的任何属性

语法

@staticmethod def eat():    print("%S is eating" %("ddd"))

类方法

类方法只能访问类变量，不能访问实例变量

语法

@classmethod #类方法只能访问类变量 def eat(self):    print("%s is eating" %(self.name))

实例方法

必须是类的实例来进行方法的绑定

属性方法

方法->静态属性

调用一个对象的属性 直接使用

语法

class Flight(object):    def __init__(self, name):       self.flight_name = name        def checking_status(self):       print("checking flight %s status " %(self.flight_name))       return @property def flight_status(self):    status = self.checking_status()    if status == 0:       print("flight got cancelled...")    elif status == 1:       print("flight is arrived...")    elif status == 2:       print("flight has departured already...")    else:       print("cannot confirm the flight status...,please check later") @flight_status.setter #修改 def flight_status(self, status):    status_dic = {       0: "canceled",       1: "arrived",       2: "departured"    }    print("Has changed the flight status to ", status_dic.get(status)) @flight_status.deleter #删除 def flight_status(self):    print("status got removed...") f = Flight("CA980") f.flight_status f.flight_status = 2 #触发@flight_status.setter del f.flight_status #触发@flight_status.deleter

特殊成员方法

__doc__

__module__

__class__

__call__

__dict__

__str__

__getitem__、__setitem__、__delitem__

其他特性

反射

字符串->对象属性/方法

语法

hasattr

判断一个对象里是否有对应的字符串的方法

getattr

根据字符串获取obj对象里的对应的方法的内存地址

setattr

setattr(obj, 'y', z) => x.y = z

delattr

delattr(obj, name)

断言

动态导入模块

import day7.lib.aa as a objc = a.C() print(objc)

modname = "day7.lib.aa" mod = __import__(modname) # 导入到day7层级 cls_c = mod.lib.aa.C print(mod.lib.aa) print(mod.lib.aa.C) objc = cls_c() print(objc)

# 官方建议 import importlib aa = importlib.import_module("day7.lib.aa") objc = aa.C() print(objc)

面向对象特点

封装

继承

2种方式

class People：经典类

class People(object): # 新式类

多继承顺序问题

只会走一个父类的构造函数

继承策略

Python3.x

新式类：广度优先

经典类：广度优先

Python2.x

新式类：深度优先

经典类：深度优先

多态

接口重用

实例

len()

sorted()

单例模式

基础概念

编程语言

特点

解释型

需要解释器才能运行，要解释并运行源代码，机器上需要安装解释器程序

可移植

面向对象，对象的类，实现继承关系

交互式

开源

便于理解和使用

解释过程

1.以单词为单位逐行扫描代码

2.组织成逻辑结构的树状结构

3.转化为字节码

4.由python虚拟机执行

图示

万物皆对象

不可变对象

自动复制

种类

Strings，tuples，numbers

示例

>>> id(x) 4418510432

>>> x *= 4 >>> id(x) 4418511296 //其实地址发生了变化

可变对象

对象引用

种类

list

dict

数据结构

标量

整数

浮点数

序列

列表

主要方法

字符串

多个单个字符合并而来的

字符串如果包含特殊字符，\n,\t 默认会转义 如果需要不经转义，字符串前面加r

>>> s = r'E:\note\Python.doc' >>> s 'E:\\note\\Python.doc' >>> print(s) E:\note\Python.doc

主要方法

元组

不可变性

unicode字符串

字节数组

缓冲区

xrange对象

映射

字典

特点

无序

通过键值存储数据，内部实现基于二叉树（Binary Tree）

效率比列表差很多

特殊数据结构

集合

特点

既不是序列也不是映射类型，更不是标量

唯一的

不可变的对象

无序

运算

常用操作符

算术操作符

赋值操作符

比较操作符

逻辑操作符

操作符优先级

变量

命名规则

字母，数字或下划线

第一个不能使数字

不能以关键字命名

种类

常量

变量

局部变量

全局变量

编码规则

ASCII

1bytes->255

gb2312

gbk

gb18030

Unicode

2bytes

UTF编码

UTF-8

en->1byte

zh->3bytes

utf-32

4bytes

UTF-16

2bytes

转码规则

先decode

变成unicode

再encdoe

注释

单行注释-># xxxx

多行注释->'''xxx'''

输出格式方式

info = ''' Name: %s Age: %d ''' % (name, name, age) print(info)

info2 = ''' Name: {_name} Age: {_age} '''.format(_name=name, _age=age) print(info2)

info3 = ''' Name: {0} Age: {1} '''.format(name,age) print(info3)

Python3

bytes类型

文本总是unicode，由str类型表示

二进制数据，由bytes类型表示

作用域

一个变量的作用域总是由在代码被赋值的地方所决定的

本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

常规语法

基本语法

ifelse判断

强制缩进

示例

if _username == username and _password == password: print("Welcome user {name} login...".format(name=username)) else: print("Invalid username or password!")

while语句

可以用break，跳出循环

for循环

自定义步长

for i in range(0,10,2): print("loop ", i)

示例

for i in range(3):    print(i)

可以通过else，当for迭代循环列表后或while循环条件变为假时， 循环并非通过break语句终止时，便会执行这个else语句

range()函数

for i in range(5): for i in range(len(L)):

异常

语法

try:    # 主代码块    pass except KeyError,e:    # 异常时，执行该块    pass else:    # 主代码块执行完，执行该块    pass finally:    # 无论异常与否，最终执行该块 pass

#2.7

except(ValueError, KeyError), e

#3.x

except(ValueError, KeyError) as e

自定义异常

class MyException(Exception):    def __init__(self, msg):       self.message = msg try:    raise MyException("我的异常") except MyException as e:    print(e)

with语句

示例

with open("xx.xx", 'rb') as f:    xxx

文件的读取

readline()和readlines()

常见格式

txt格式

csv格式

json格式

dumps方法

loads方法

其他语法

生成器（generator）

特点

只有在调用的时候才会生成相应的数据

只记录当前位置

只有一个__next___方法

可以用作于for循环

示例

迭代器（Iterable）

集合

list，tuple，dict，set，str

generator

包括生成器和带yield和generator func

判断方法

isinstance() 判断一个对象是否是Iterable对象

函数

语法及特性

特性

可扩展性

一致性

易维护

语法

返回值

参数

def func(name) #一般参数

def func(*args) #接受n个位置参数

def func(*args, **kwargs) #把n个关键字参数，转换成字典的方式

局部变量

种类

递归

匿名函数

高阶函数

概念

一个函数可以接受另一个函数作为参数

示例

def add(x, y, f):    return f(x) +f(y) def f(x):    return abs(x) ret = add(-10, 20, f) print(ret) # output: 30

内置函数

装饰器

概念

1.不能修改被装饰得函数的源代码 2.不能修改被装饰的函数的调用方式

装饰器的作用就是为已经存在的对象添加额外的功能

必要知识

函数即“变量”

高阶函数

嵌套函数

高阶函数+嵌套函数

*args and **kwargs

*args-不确定函数里要传递多少个参数时候

**kwargs-允许你使用没有实现定义的参数名字

*args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面

文件相关

基本操作

打开文件方式

f=open("xxx.txt", "r", encoding="utf-8") // 需要手动关闭文件

with open("xxx.txt", "r", encoding="utf-8") as f:

+模式

r+: 往后追加

w+: 写的模式打开文件（覆盖，写完后读）

a+: 追加写读

二进制模式

rb，wb，ab（二进制格式）

其他方法

seek

tell

truncate

flush

实时性较高

 编码风格

分号

不要用分号作为你的行结束符， 也不要利用分号在同一行放两个指令。

每行长度为80字符

遇到文本示例

x = ('This will build a very long long '       'long long long long long long string')

圆括号

 不能用情况

return语句

在条件判断语句中

在元组（tuple）周围

可以使用情况

暗示两行是连在一起的

用来括起长表达式中的子表达式

示例

if foo: while x: if x and y: if not x: if (x < 3) and (not y): return foo for x, y in dict.items(): x, (y, z) = funcThatReturnsNestedTuples()

缩进

示例

# 与起始定界符对齐： foo = longFunctionName(var_one, var_two,                                    var_three, var_four)

# 4空格悬挂缩进，而且首行空着： foo = longFunctionName(       var_one, var_two, var_three,       var_four)

空格

示例

spam(ham[1], {eggs: 2}, [])

def Complex(real, imag=0.0): return Magic(r=real, i=imag)

Python解释器

#!/usr/bin/python2.5

版本和许可声明

#!/usr/bin/python2.5 # # Copyright [current year] the Melange authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License.

模块头及作者信息

"""用一行文字概述模块或脚本，用句号结尾。 留一个空行。本 __doc__ string 的其他部分应该包括模块或脚本的全面描述。作为可选项，还可以包括导出的类和函数的简要描述。  ClassFoo: 一行概述。  functionBar(): 一行概述。 """ __authors__ = [    # 请按照姓氏字母顺序排列：    '"John Smith" <johnsmith@example.com>',    '"Joe Paranoid" <joeisgone@example.com>', # 应提供电子邮件地址 ]

函数和方法

示例

def fetchRows(table, keys):  """取出表中的多行内容。  Args:  table: 打开的表。 Table 类的实例。  keys: 字符串序列，表示要从表中取出的行的键值。    Returns:  一个字典，映射指定键值与取出的表中对应行的数据：  {'Serak': ('Rigel VII', 'Preparer'),  'Zim': ('Irk', 'Invader'),  'Lrrr': ('Omicron Persei 8', 'Emperor')}  如果 keys 参数中的键值没有出现在字典里，就表示对应行在表中没找到。  Raises:  IOError: 访问 table.Table 对象时发生的错误。  """  pass

__doc__ string 应该包括函数能做什么、 输入数据的具体描述（“Args:”） 输出数据的具体描述（“Returns:”、“Raises:”、或者“Yields:”）

类

示例

class SampleClass(object):  """这里是类的概述。  详细的描述信息……  详细的描述信息……  Attributes:  likes_spam: 布尔型，表示我们是否喜欢垃圾邮件。  eggs: 整数，数我们下了多少蛋。  """  def __init__(self, likes_spam=False):  """拿点什么来初始化 SampleClass 。  Args:  likes_spam: 初始化指标，表示 SampleClass 实例是否喜欢垃圾邮件（默认是 False）。  """  self.likes_spam = likes_spam  self.eggs = 0  def publicMethod(self):  """执行一些操作。"""  pass

应该明确的从object基类继承

字符串

应该用 % 运算符来格式化字符串，即使所有的参数都是字符串 也可以使用+

多行字符串

使用 """ 而不是 '''

示例

x = a + b x = '%s, %s!' % (imperative, expletive) x = 'name: %s; score: %d' % (name, n)

注意

避免在循环中用 + 或 += 来连续拼接字符串。 因为字符串是不变型，这会毫无必要地建立很多临时对象， 从而二次方级别的运算量而不是线性运算时间。 相反，应该把每个子串放到 list 里面，然后在循环结束的时候用 ''.join() 拼接这个列表。

items = ['<table>'] for last_name, first_name in employee_list:  items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name)) items.append('</table>') employee_table = ''.join(items)

TODO style

示例

# TODO(someuser): 这里应该用 "*" 来做级联操作。 # TODO(anotheruser) 用 relations 来修改这儿。

# Fix by November 2008

import分组及顺序

示例

import sys import os

分组顺序

import 标准库 import 第三方库 import Google App Engine 相关库 import Django 框架相关库 import SoC framework 相关库 import 基于 SoC 框架的模块 import 应用程序特有的内容

示例

import a_standard import b_standard import a_third_party import b_third_party from a_soc import f from a_soc import g import a_soc import b_soc

命名

避免以下情况

使用单个字符命名，除非是计数器或迭代器

在任何包或模块的名字里面使用减号

__double_leading_and_trailing_underscore__ 在变量开头和结尾都使用两个下划线 （在 Python 内部有特殊含义）

示例

Packages

公开

lower_with_under

Modules

公开

lower_with_under

内部

_lower_with_under

Classes

公开

CapWords

内部

_CapWords

Exceptions

公开

CapWords

Functions

公开

firstLowerCapWords

内部

_firstLowerCapWords()

Global/Class Constants

公开

CAPS_WITH_UNDER

内部

_CAPS_WITH_UNDER

Global/Class Variables

公开

lower_with_under

内部

_lower_with_under

Instance Variables

公开

lower_with_under

内部

_lower_with_under (protected) or  __lower_with_under (private)

Method Names *

公开

firstLowerCapWords()

 内部

_firstLowerCapWords() (protected) or __firstLowerCapWords() (private)

Function/Method Parameters

公开

lower_with_under

Local Variables

公开

lower_with_under

程序入口

所有的 Python 源代码文件都应该是可导入的

你的代码应该总是在执行你的主程序之前检查if __name__ == '__main__': 这样就不会在模块被导入时执行主程序。

大写 main() 是故意要和命名约定的其他部分不一致，也就是说建议写成 Main()

特性

自省

运行时候能够获得对象的类型

type(),dir(),getattr(),hasattr(),isinstance()

推导式comprehensions （又称解析式）

列表推导式

基本格式

variable = [out_exp_res for out_exp in input_list if out_exp == 2]  out_exp_res:　　列表生成元素表达式，可以是有返回值的函数。  for out_exp in input_list：　　迭代input_list将out_exp传入out_exp_res表达式中。  if out_exp == 2：　　根据条件过滤哪些值可以。

示例

multiples = [i for i in range(30) if i % 3 is 0] print(multiples) # Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

def squared(x):  return x*x multiples = [squared(i) for i in range(30) if i % 3 is 0] print multiples # Output: [0, 9, 36, 81, 144, 225, 324, 441, 576, 729]

使用()生成generator

将俩表推导式的[]改成()即可得到生成器

multiples = (i for i in range(30) if i % 3 is 0) print(type(multiples)) print(multiples.__next__()) #0 print(multiples.__next__()) #3 # Output: <type 'generator'>

字典推导式

基本格式

字典推导和列表推导的使用方法是类似的，只不中括号该改成大括号

示例

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3} mcase_frequency = {  k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)  for k in mcase.keys()  if k.lower() in ['a','b'] } print mcase_frequency # Output: {'a': 17, 'b': 34}

mcase = {'a': 10, 'b': 34} mcase_frequency = {v: k for k, v in mcase.items()} print mcase_frequency # Output: {10: 'a', 34: 'b'}

集合推导式

跟列表推导式也是类似的。唯一的区别在于它使用大括号{}

示例

squared = {x**2 for x in [1, 1, 2]} print(squared) # Output: set([1, 4])

命名规则

1. object # 公用方法

2. __object__ # 内建方法，用户不要这样定义

特殊方法专用的标识

3. __object # 全私有，全保护

只有类对象自己能访问,连子类对象也不能访问到这个数据

4. _object # 半保护

只有类对象和子类对象自己能访问

不能通过from xxx import *导入

示例

class Foo():  def __init__(self):  pass    def public_method(self):  print('This is public method')    def __fullprivate_method(self):  print('This is fullprivate_method')    def _halfprivate_method(self):  print('This is halfprivate_method')   f = Foo() f.public_method() # OK f.__fullprivate_method() # Error occur f._halfprivate_method() # OK f._Foo__fullprivate_method() # OK

_object和__object的作用域限制的本模块内

示例

class A(object):  def __init__(self):  self.__private()  self.public()  def __private(self):  print('A.__private()')  def public(self):  print('A.public()') class B(A):  def __private(self):  print('B.__private()')  def public(self):  print('B.public()') b = B() #output: #A.__private() #B.public()

私有变量矫直 private name mangling

print('\n'.join(dir(A))) _A__private #__private消失了 __init__ public

2点注意

因为矫直会使标识符变长，当超过255的时候，Python会切断 ，要注意因此引起的命名冲突。

当类名全部以下划线命名的时候，Python就不再执行矫直

class ____(object):  def __init__(self):  self.__method()  def __method(self):  print '____.__method()'   print '\n'.join(dir(____)) #__method 没有被矫直

__new__vs__init__区别

__new__是一个静态方法

__init__是一个实例方法

GIL线程全局锁

为了保证线程安全而采取的独立线程运行的限制, 说白了就是一个核只能在同一时间运行一个线程.

解决办法