python

Python基础课思维导图，包括数据类型、函数、控制流、问题排查、创建类与函数、模块等的相关知识点，有需要的同学，可以收藏下哟。

python

打印输出

print("Hello world!")

.py

python的程序

注释

#

#“I ”

不打印

除字符外，所有关键字、括号，逗号等均为英文状态下

缩进

四个空格

每行字符不超过80个

变量和数据类型

变量

命名

只能包含字母、数字和下划线

字母开头

下划线开头

不能包含空格

不要使用关键字和函数名

简短、具有描述性

慎用小写字母'l'、大写字母'O'

使用

运行错误提示

traceback

名称错误

使用变量前忘记赋值

变量名书写错误

数据类型

字符串string

一些列字符

用引号括起的都是

单引号''

'this is a apple'

双引号""

"this is a apple"

单双引号可以同时使用

massge=‘you Know“si”’

print(massge)

you know“s”

编辑字符串

修改大小写

首字母大写

.title()

print（massge.title()）

You Know "S"

每一个字符的首字母都大写

全部大写

.upper()

print(massge.upper())

YOU KNOW "S"

全部小写

.lower()

合并（拼接）

+

a="1"

b= "2"

print(a+" "+b)

""中间有个空格

1 2

制表符/换行符

制表符\t

print("today\n\tI know")

换行符\n

print("1 love\n2 love\nall over")

删除空白

.strip()

rstrip()

lstrip()

暂时性删除，后续调用依然存在

massge=" I lee "

print(massge.strip())

使用str（）

能将其他类型数据转换成字符串

数字

整数

+

print(3+3)

-

print(5-2)

*

print(2*2)

/

**

平方

%

求模

返回值为余数

浮点数

带小数点的数

3.123

3.

整数*浮点数

浮点数

...

列表

[]

用逗号隔开不同的元素

["a","b","c","D"]

访问列表

列表的索引是从0开始的

Numbers=["a","b","c","D"]

print(Numers[0])

a

print(Numbers[2])

c

编辑列表

修改

使用索引直接替换

Nums=["a","b"]

Nums[0]="c"

Nums=["c","b"]

添加

.append("添加内容")

在列表末尾添加

Nums=["a"]

Nums.append("c")

Nums=["a","c"]

可以用来空列表的一一添加

Nums=[]

Nums.append("a")

Nums=["a"]

插入

.insert(索引号，“插入内容(值)”)

Nums=["a","c"]

Nums.insert(1,"b")

Nums=["a","b","c"]

删除

del

任意位置

前提是知道索引

Nums=["a","c"]

del Nums[0]

Nums=["c"]

del为小写

.pop()

末尾

并且可以继续使用删掉的元素

Nums=["a","c"]

Num=Nums.pop()

print(Nums)

["a"]

print(Num)

c

任意位置

前提是知道索引

Nums=["a","c"]

Num=Nums.pop(0)

print(Nums)

["c"]

print(Num)

a

.remove()

根据值删除元素

Nums=["a","c"]

Nums.remove("a")

print(Nums)

["c"]

可以继续使用删除的值

Nums=["a","c"]

Num="a"

Nums.remove(Num)

print(Nums)

["c"]

print(Num)

a

使用索引避免出错

可以倒着使用索引值

Nums=["1","2","3"]

print(Nums[-1])

3

正向从0开始

反向从-1开始

组织列表

永久性排序

.sort()

Nums=["1","3","3","5","2"]

Nums.sort()

顺序

Nums=["1","2","3","3","5"]

反序

Nums.sort(reverse=True)

Nums=["5","3","3","2","1"]

是通过ACSII码的顺序排列先后

0～9

a～z

A～Z

...

临时性排序

sorted()

保留原列表的顺序

创建新列表的顺序

Nums=["1","3","3","5","2"]

Nums1=sorted(Nums)

print(Nums)

Nums=["1","3","3","5","2"]

print(Num)

Nums=["1","2","3","3","5"]

同样支持反序reverse=True

倒着打印列表

.reverse()

Nums=["1","3","3","5","2"]

Nums.reverse()

Nums=["2","5","3","3","1"]

确定列表的长度

len()

Nums=["1","3","3","5","2"]

len(Nums)

5

操作列表

遍历列表

for...in...

for num in Nums:

print(num)

会依次打印列表中的值

1

3

3

5

2

属于for内部代码，需缩进

注意尾部的冒号":"

内部代码中可以包含任意数量的代码

后续只有缩进的代码属于for...in循环，不缩进的制执行一次

常见错误

忘记缩进

不必要的缩进

遗漏冒号

创建数字列表

range(起始数字，末尾数字)

for num in range(1,5)：

1

2

3

4

由“起始数字”至“末尾数字-1”

制定增量步长，默认为1

range(起始数字，末尾数字，增量步长)

list(range(1,5,2)

["1","3"]

如果想打印5，不想打印7

list(range(1,6,2))

["1","3"]

list(range(1,7,2))

["1","3","5"]

数字列表

list()

Nums=list(range(1,5))

print(Nums)

["1","2","3","4"]

处理数字列表

最小值min()

最大值max()

总和sum()

列表解析

Nums=[value**2 for value in range(1,4)]

["1","4","9"]

切片

提取已有列表的一部分创建新的列表

相当于子集

Nums=["1","2","3","4"]

Nums1=["1"]

Nums2=["1","2"]

Nums3=["1","2","3","4"]

Nums=["1","2","3","4"]

列表名[起始索引:结束索引+1]

Nums2=Nums[0:2]

中间是冒号

Nums2=["1","2"]

列表名[:结束索引+1]

从第一值开始

Nums2=Nums[:2]

Nums2=["1","2"]

列表名[起始索引:]

提取至最后一个值

Nums3=Nums[0:]

Nums3=["1","2","3","4"]

列表名[:]

相当于复制列表

Nums3=[:]

Nums3=["1","2","3","4"]

可以使用“负索引值”

Nums4=[-3:-1]

Nums=["2","3"]

Nums5=[-3:]

Nums5=["2","3","4"]

在for...in中使用切片

Nums=["1","2","3","4"]

for Num in Nums[0:3]:

1

2

3

元组

小括号括起()

不可更改元组内的值

可以遍历

if语句

核心值

True

执行

False

不执行

检查是否相等

==

判断前后值是否一样

区分大小写

Car==Car

Car!=CAR

如果只是检查值，不关心大小写，可以使用.upper()/.lower()

Car.lower()==CAR.lower()

!=

<

>

≤

≥

检查多个判定条件

and

同时满足and前后的条件

True

仅满足一个

False

都不满足

False

or

满足or前后任意一个即可

True

都满足

True

都不满足

False

一次性判定

仅仅输判定函数，不是循环语句

检查特定值是否包含在

in

A="Car"

if "a" in A：

print("T")

T

else:

print("F")

not in

布尔表达式

返回值

True

False

if

缩进

满足if的判定条件，执行if内部代码，否则跳过

使用检查多次判定

if...if...if...

if...else

缩进

满足if的判定条件，执行if内部代码，否则else内部代码

if...elif...else

对判断条件依次判定

满足

进入内部，不在执行其他判定

不满足

判定下一个

都不满足

全部跳过

可以省略else

if...elif

在列表中的使用

列表名作为判定条件时

至少1个元素

True

0个元素

False

字典

大括号{}

是一系列的“键—值”对

每个键都有一个值关联

可以使用键访问值

值

数字

字符串

列表

字典

A={"color":"red","size":20}

键与值间用“:”隔开

键与键间用“,”隔开

任意数量的键-值对

访问

Name["键名"]

A["color"]

red

添加

Name["键名"]="值"

A["type"]="free"

A={"color":"red","size":20,"type":"free"}

顺序不固定

字典不关心顺序

创建空字典

B={}

再依次添加键—值对

修改

Name["键名"]="值"

A["color"]="green"

A={"color":"green","size":20}

删除

del

必须指定字典名、键

del A["color"]

A={"size":20}

永久的删除

由类似对象组成的字典

遍历字典

键—值对

for key,value in A_name:

key,value可以是任何名称

返回值顺序随机

键

.key()

for k in A_name.keys():

color

size

按顺序排列遍历后的键名

使用sorted()

for k in sorted(A_name.key()):

color

size

值

.value

for k in A_name.values():

red

20

可能重复，避免重复使用集合set()

set()类似列表，但内部元素唯一性

Age={"xiaoming":8,"xiaohong":5,"lihua":8}

for k in A_name.values():

8

5

8

for k in set(A_name.values()):

8

5

嵌套

列表的中嵌套字典

A={}

B={}

C={}

D_list=[A,B,C]

字典中嵌套列表

Dic={"N":"N1","M":["M1","M2"],"P":"P1"}

一个键关联多个值时

使用列表

字典中嵌套字典

子主题

用户输入

input()

massge=input("请告诉我你想说的话：")

print(massge)

会弹出输入框

用户输入内容

提示超过一行

可以将一部分存储在临时变量中

输入内容的转换

数字转换成整数

int()

数字转换成字符串

str()

数字转换成浮点数

float()

while循环

循环不断地进行，直到条件不满足

可以选择何时退出循环

定义当那个“值”，作为退出条件

Nums=[]

A=0

while A<6:

当A=6时，退出循环

0-1

1-2

2-3

3-4

4-5

5-6

退出

注意末尾的冒号

A+=1

Nums.append(A)

print(Nums)

["1","2","3","4","5","6"]

标志

在标志位True时继续运行

任何程序导致标志位False时都停止运行

A=true

while A:

if B=C：

A=false

else：

...

break

见到break，即刻停止

A=true

while A:

if B=C：

break

else：

...

继续continue

返回循环开头，并根据条件测试结果决定是否继续执行循环

A=0

while A<10:

A+=1

if A%2==0：

#如果A是偶数，返回循环开头

#如果A是奇数，打印

continue

print(A)

1

3

5

7

9

处理列表和字典

避免无限循环

函数

def

定义

def 函数名():

名字使用描述性名称

小写字母和下划线

形参、实参

def 函数名(形参1,形参2,...)

可以定义形参的默认值

def 函数名(形参1，形参2="A")

调用时形参2可以不用赋值实参

如果形参2不是A，可以重新赋予

函数名(实参1，实参2="A1")

位置实参

实参与形参位置一一对应

函数名(实参1,实参2,...)

顺序很重要

好的顺序

def discribe_pet(pet_type,pet_name):

print("\nI have a "+pet_type+".")

print("Its name is "+pet_name)

discribe_pet("dog","二蛋")

I have a dog.

Its name is 二蛋

不好的

def discribe_pet(pet_type,pet_name):

print("\nI have a "+pet_type+".")

print("Its name is "+pet_name)

discribe_pet("二蛋","dog")

I have a 二蛋.

Its name is dog

任意数量的实参

形参使用*

创建一个空的元组

所有收到的值都收录到这个元组中

def make_pizza(*topping):

print(topping)

make_pizza("辣椒")

("辣椒")

make_pizza("辣椒","咖喱","奶油")

("辣椒","咖喱","奶油")

如果接受不同类型的实参，任意形参*放在最后

def make_pizza(size,*topping):

关键字实参

不用考虑顺序

函数名(形参名1=实参名1，形参名2=实参名2，...)

def discribe_pet(pet_type,pet_name):

print("\nI have a "+pet_type+".")

print("Its name is "+pet_name)

discribe_pet(pet_name="二蛋",pet_type="dog")

I have a dog.

Its name is 二蛋

任意数量的关键字实参

**

创建空字典{}

将收到的‘键-值’实参收录到空字典中

可以混合使用几种参数

实参变为可选的

在形参位置上使用空字符串

def 函数名(形参1，形参2="")

def get_formatted_name(first_name,last_name,middle_name=""):

if middle_name:

full_name=first_name+" "+middle_name+" "+last_name

else:

full_name=first_name+" "+last_name

return full_name.title()

massge=get_formatted_name("Juck","yang")

massge1=get_formatted_name("蛋","狗","欧")

print(massge)

Juck Yang

print(massge1)

蛋狗欧

python将空字符串解读为True

调用

函数名()

def user_name():

print("小明")

user_name()

返回值

return

返回1个值

返回1组值

返回任何类型的值

列表

字典

字符串

需要提供一个变量，用于存储返回的值

def get_formatted_name(first_name,last_name):

full_name=first_name+" "+last_name

return full_name.title()

massge=get_formatted_name("Juck","yang")

print(massge)

Juck Yang

结合使用函数和while循环

def get_formatted_name(first_name,last_name):

full_name=first_name+" "+last_name

return full_name.title()

while ture:

print("任何时候输入‘quit'，都退出")

F_name=input("first_name:")

if F_name=="quit":

break

L_name=input("last_name:")

if L_name=="quit":

break

massge=get_formatted_name(F_name,L_name)

print(massge)

传递列表

实参换成列表

修改列表

禁止修改列表

提供切片，而非原列表

在主程序中导入模块

import

扩展名

.py

name.py

import module_name

使用as定义模块别名

import module_name as new

导入模块中的函数

模块名

函数名

中间用.分开

import module_name.function_name()

导入特定的函数

from module_name import function_name

任意数量的

函数名中间用逗号隔开

from module_name import function_name1,function_name2,function_name3

使用as定义别名

from module_name import function_name as new_name

导入所有函数

*

from module_name import *

类