导图社区 python

python

Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。本思维导图是python的简单总结，主要是基础语法，参考尚学堂和菜鸟教程。喜欢的小伙伴可以点个赞哦！

编辑于2019-06-07 13:41:07

Gavin

他的近期作品查看更多>>

python

社区模板帮助中心，点此进入>>

Gavin

他的近期作品查看更多>>

相似推荐
大纲

英语词性
- 58.2k
- 6.3k
- 2.3k
- 580
Ethan
互联网9大思维
- 34.2k
- 925
- 2.4k
- 393
MindMaster
组织架构-单商户商城webAPP 思维导图。
- 14.7k
- 3
- 185
- 9
Kacyun
法理
- 25.1k
- 65
- 371
- 52
Dasein
刑法总则
- 34.1k
- 147
- 957
- 159
Dasein
【华政插班生】文学常识-先秦
- 1.3k
- 4
- 70
- 2
Dasein
【华政插班生】文学常识-秦汉
- 840
- 0
- 54
- 10
Dasein
文学常识：魏晋南北朝
- 2.3k
- 3
- 90
- 20
Dasein
【华政插班生】文学常识-隋唐五代
- 2.0k
- 8
- 98
- 6
Dasein
民法分论
- 6.0k
- 37
- 290
- 29
Dasein

python

标准数据类型

Number

int

表示长整型，没有long类型

bool

Ture, False

值是1， 0，可与数字相加

float

complex

String

单双引号相同

三引号表注释

转义 \

r可以不让\转义

截取，拼接

str[start, end, step]

可直接使用+拼接

格式化

format

常用方法

aplit，join

Tuple

定义

可以存放任意类型数据的有序序列，且元素不可修改。

创建方法

()

a = (1, 2, 3, 4)

tuple()

可传入列表，集合，以及可迭代对象

a = [1, 2, 3, 4]; b = tuple(a)

s = (x*2 for x in range(5));a = tuple(s)

常用方法

备注

元组的元素不可修改，可以是可变类型，如list

其实在元组中的元素指向的地址不可修改，但其指向的地址的内容可以修改，如元组里可以包含列表，而列表本身的内容是可修改的。

List

定义

可以存放任意类型数据的有序序列，元素可修改

创建方法

[]

a = [1, 2, 3, 4]

list()

可传入元组，集合，以及可迭代对象

a = (1,2 ,3, 4);b = list(a)

s = (x*2 for x in range(5));a = list(s)

截取，拼接

list[start, end, step]

可直接使用+拼接

常用方法

append

insert，remove，pop，del

extend

把目标列表添加到本列表尾部，不创建新对象

排序

list.sort

random.shuffle(list)

sorted(list)

list[::-1]

reversed(list)

返回迭代器

序列

用来存储一系列的数据

序列就是用来存放多个值得连续的内存空间

序列中存储的都是对象的地址

Set

定义

集合（set）是一个无序可变的不重复元素序列。

创建方法

{}

a = {1, 2, 3, 4}

set()

把列表，元组当作参数传给set()

b = [1,2,3,4];c = set(b)

生成器推导式，把可迭代对象传给set()

a = (x*2 for x in range(5))；b = set(a)

空集合必须用 set()

元素的添加

add()

# 集合元素的添加 a = {1, 2, 3, 4} print(a) a.add(5) print(a)

元素的删除

remove()

# 集合元素的删除 a = {1, 2, 3, 4} print(type(a), a) a.remove(2) print(a)

clear()

集合运算

# 集合的集合相关操作 #并集 a = {1, 2, 3} b = {1, 5, 6} # # c = a|b c = a.union(b) print("并集 | ", end='') print(c) #差集 # a = {1, 2, 3} # b = {1, 5, 6} # # d = a-b d = a.difference(b) print("差集 - ", end='') print(d) # 交集 # a = {1, 2, 3} # b = {1, 5, 6} # # e = a&b e = a.intersection(b) print("交集 & ", end='') print(e) #异或 # a = {1, 2, 3} # b = {1, 5, 6} f = a^b print("异或 ^ ", end='') print(f)

差集 - ，等同于different()

此集合与另一个集合不同的元素

#差集 a = {1, 2, 3} b = {1, 5, 6} # d = a-b d = a.difference(b) print(d)

并集 | , 等同于union()

两个集合所有的元素

#并集 a = {1, 2, 3} b = {1, 5, 6} # c = a|b c = a.union(b) print(c)

交集 &

两个集合相同的元素

# 交集 a = {1, 2, 3} b = {1, 5, 6} # e = a&b e = a.intersection(b) print(e)

异或 ^

两个集合不同的元素

#异或 a = {1, 2, 3} b = {1, 5, 6} f = a^b print(f) #结果：{2, 3, 5, 6}

Dictionary

定义

用 { } 标识，它是一个无序的键(key) : 值(value) 的可变序列

创建方法

{}

a = {'name':'Jack', 'age':19}

dict

dict(name='Jack', age=19)

dict([('name','Jack'),('age',19)])

元素的访问

# #字典元素的访问 # key访问，如果key不存在，会抛出异常 dict_test = {'name':'Jack', 'age':18} print(dict_test['name']) print("key访问：") dict_test['1234'] # 输出结果 # Jack # key访问： # Traceback (most recent call last): # File "D:/data/python/test/test.py", line 50, in <module> # dict_test['1234'] # KeyError: '1234' #字典元素的访问 #get方法：如果键不存在，则返回None，也可以指定返回的对象，推荐使用get print("使用get方法访问------") dict_test = {'name':'Jack', 'age':18} print("get方法访问："+str(dict_test.get('name'))) print("get方法访问："+str(dict_test.get('1234'))) print("get方法访问："+dict_test.get('1234', "字典里没有这个key")) # 输出结果 # 使用get方法访问------ # get方法访问：Jack # get方法访问：None # get方法访问：字典里没有这个key

key访问

dict_test['name']

#字典的元素访问 #key访问：如果key不存在，则会抛出异常 dict_test = {'name':'Jack', 'age':18} print(dict_test['name'])

get()

#字典元素的访问 #get方法：如果键不存在，则返回None，也可以指定返回的对象 dict_test = {'name':'Jack', 'age':18} print("get方法访问："+str(dict_test.get('1234'))) print("get方法访问："+dict_test.get('1234', "字典里没有这个key")) print("key访问：") dict_test['1234']

元素的添加

# #字典元素的添加 # 直接使用key进行添加 dict_test = {'name':'Jack', 'age':18} print(dict_test) dict_test['id'] = 123 print(dict_test) # 输出结果 # {'name': 'Jack', 'age': 18} # {'name': 'Jack', 'age': 18, 'id': 123} #字典元素的添加 # update把新字典中所有的键值对都更新到旧字典上，即新字典覆盖旧字典。 a = {'name':'Jack', 'age':18} print(a) b = {'name':'Bob', 'age':20, 'id':123} print(b) a.update(b) print(a)

dict_test['id'] = 123

#字典元素的添加 #如果键值已存在，则会覆盖旧的键值 dict_test = {'name':'Jack', 'age':18} print(dict_test) dict_test['id'] = 123 print(dict_test)

a = update(b)

#字典元素的添加 # update把新字典中所有的键值对都更新到旧字典上。 a = {'name':'Jack', 'age':18} print(a) b = {'name':'Bob', 'age':20, 'id':123} print(b) a.update(b) print(a)

元素的删除

# # 字典元素的删除 del # 删除指定key的键值对 a = {'name':'Bob', 'age':20, 'id':123} print(a) del(a['name']) print(a) # 输出结果： # {'name': 'Bob', 'age': 20, 'id': 123} # {'age': 20, 'id': 123} # 字典元素的删除 pop # 删除指定key的键值对，并返回该key的值 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) value = a.pop('name') print(type(value), value) print(a) # 输出结果 # {'name': 'Bob', 'age': 20, 'id': 123} # <class 'str'> Bob # {'age': 20, 'id': 123} # 字典元素的删除 # clear 清空字典 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) a.clear() print(a) # 输出结果 # {'name': 'Bob', 'age': 20, 'id': 123} # {} # 字典元素的删除 #popitem() 随机删除并返回该键值对 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) for i in range(len(a)): print(a.popitem()) print(a)

del(a['name'])

# 字典元素的删除 a = {'name':'Bob', 'age':20, 'id':123} print(a) del(a['name']) print(a)

a.pop('name')

# 字典元素的删除 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) value = a.pop('name') print(type(value), value) print(a)

a.clear()

清空字典

a.popitem()

# 字典元素的删除 #popitem() 随机删除并返回该键值对 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) for i in range(len(a)): print(a.popitem()) print(a)

序列解包

#序列解包，可用于元组，列表，字典 #解包字典时，默认是对key进行操作 a = {'name': 'Bob', 'age': 20, 'id': 123} print(a) name, age, id = a print(name,age,id) print(type(name)) print(type(age)) print(type(id)) name, age, id = a.values() print(name,age,id) print(type(name)) print(type(age)) print(type(id)) name, age, id = a.items() print(name,age,id) print(type(name)) print(type(age)) print(type(id))

key

必须使用不可变类型

必须唯一

常用方法

get()

访问字典的元素

items()

列出所有的键值对

keys()

列出所有的键

values()

列出所有的值

len()

使用内置len方法计算字典键值对的个数

clear()

清空字典

可变数据类型

推导式

使用

[表达式 for item in 可迭代对象 if 条件判断]

可以使用两个循环嵌套，具体如下： cells = [(row, col) for row in range(5) for col in range(5)] for cell in cells: print(type(cell), cell) print(type(cells)) print(cells)

列表推导式

a = [x*2 for x in range(10) if x % 2 == 0]

a = [x*2 for x in range(10) if x % 2 == 0] print(type(a)) print(a)

字典推导式

dict_test = {c:my_str.count(c) for c in my_str}

''' this is for testing dict key is the char in the string value is the count of the char in the string ''' my_str = "this is a test for dict, key is the char in the string, value is the count of the char in the string." dict_test = {c:my_str.count(c) for c in my_str} print(type(dict_test)) for item in dict_test.items(): print(item)

数据类型转换

int，float，complex，str，tuple，list，set，dict

repr(x)

将对象 x 转换为表达式字符串

eval(str)

用来计算在字符串中的有效Python表达式,并返回一个对象

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

ord(x)

将一个字符转换为它的整数值

进制转换

hex(x)，oct(x)

运算符

算术运算符

+ - * %

/ 结果去小数

// 取整除，去除小数部分

** 幂运算

比较运算符

== , != , > , < , >=, <=

赋值运算符

=, +=, -=, *=, /=, %=, **=, //==

位运算符

&, |, ~, ^, << , >>

逻辑运算符

and

x and y, x 为 False，返回 False，否则返回 y 的计算值

x or y, x 为 True，返回 x 的值，否则它返回 y 的计算值

not

x not y, x 为 True，返回 False 。 x 为 False，它返回 True

成员运算符

not in

身份运算符

判断id是否相同

is not

常用内置函数

id()

获取对象的地址

type()

不会认为子类是一种父类类型

isinstance()

会认为子类是一种父类类型

range()

迭代器对象

range(start, end, step)

子主题

len()

函数

类

迭代器与生成器

iter() ， next()

实例

子主题

循环

while

for

通常用于可迭代对象的遍历

只要实现了__iter__方法的对象就是可迭代的。 __iter__方法会返回迭代器（iterator）本身。判断是否是可迭代对象的方法： from collections import Iterable isinstance('abc', Iterable) 可迭代对象：元组，列表，字典，集合，字符串，迭代器对象，生成器函数能用for循环的对象都是可迭代对象

for 变量 in 可迭代对象:

for i in [1, 2, 3, 4]:

简单的次数循环

for i in range(101):

zip

多个对象并行迭代

for a, b, c in zip(list1, list2, list3):

list1 = list(x for x in range(0, 10)) list2 = list(x for x in range(10, 20)) list3 = list(x for x in range(20, 30)) print(list1) print(list2) print(list3) for a, b, c in zip(list1, list2, list3): print(a, b, c)

break，continue

else

正常循环结束时执行，如果break跳出不执行

条件控制

if-elif-else

编码规范

空行

函数之间，类的方法之间

基础语法

缩进

标识符

多行连接符 \

引号

单引号，双引号

三引号

注释

单引号 '''

双引号 """

同一行多条语句使用；隔开

print加end参数可控制结尾符

命令行参数

链式赋值

pass

空语句，保持结构的完整性

开发环境

pycharm