Python基础语法回顾（python基本语法总结）

由于一年多没有接触python，现在恶补了下python基础语法，为以后的深度学习打下基础。现总结如下,希望对大家有所帮助。

Table of Contents

1  Python入门

1.1  环境搭建

1.2  注释

1.3  变量

1.4  输入输出

1.5  数据类型

1.6  运算符

2  流程控制

2.1  条件语句

2.2  循环

2.3  while嵌套以及他的应用

3  数据序列

3.1  字符串

3.2  列表

3.3  元组

3.4  字典

3.5  集合

3.6  公共方法

3.7  推导式

4  函数

4.1  函数定义

4.2  具体例子

4.3  函数说明文档

4.4  嵌套使用

4.5  变量作用域

4.6  函数的返回值、参数

4.7  lambda表达式

4.8  map、filter、reduce

5  文件操作

6  面向对象

6.1  类和对象

6.2  继承

6.3  面向对象高级

7  模块、包、异常

Python基础学习路线流程图

Python入门

环境搭建

python

pycharm

anaconda

PyCharm是一种Python的集成开发环境，带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具

Anaconda（官方网站）就是可以便捷获取包且对包能够进行管理，同时对环境可以统一管理的发行版本。Anaconda包含了conda、Python在内的超过180个科学包及其依赖项。

注释

注释分为两类：==单行注释== 和 ==多行注释==。

单行注释

只能注释一行内容，语法如下：

# 注释内容

多行注释

可以注释多行内容，一般用在注释一段代码的情况， 语法如下：

""" 第一行注释 第二行注释 第三行注释 """ ''' 注释1 注释2 注释3 '''

快捷键： ==ctrl + /==

变量

定义变量

变量名 = 值

变量名自定义，要满足==标识符==命名规则。

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：

由数字、字母、下划线组成

不能数字开头

不能使用内置关键字

严格区分大小写

False None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield

my_name = '北山啦' print(my_name)

北山啦

输入输出

输入

在Python中，程序接收用户输入的数据的功能即是输入。

语法：

input(“提示信息”)

当程序执行到input，等待用户输入，输入完成之后才继续向下执行。

在Python中，input接收用户输入后，一般存储到变量，方便使用。

在Python中，input会把接收到的任意用户输入的数据都当做字符串处理。

address = input('请输入您的CSDN博客地址：')

请输入您的CSDN博客地址：https://beishan.blog.csdn.net/

print(f'您输入的密码是{address}') # print(type(address))

您输入的密码是https://beishan.blog.csdn.net/

输出

格式化输出

格式化符号

f-字符串

print的结束符

print('hello Python') age = 18 print(age) # 需求：输出“今年我的年龄是18岁”

age = 20 name = '北山啦' student_id = '01830115' print('我的名字是%s' % name, end='\n') print('我的学号是%s' % student_id) print(f'我的名字是{name},今年{age+1}岁了')

我的名字是北山啦 我的学号是01830115 我的名字是北山啦,今年21岁了

%06d,表示输出的整数显示位数，不足以0补全，超出当前位数则按原样输出

%.2f，表示小数点后显示的小数位数

weight = 74.22 print(f"{weight}") print("{:.3f}".format(weight))

74.22 74.220

stu_id = 1 print("{:03d}".format(stu_id))

001

所谓的格式化输出即按照一定的格式输出内容。

==格式化符号==

格式化符号

%s：格式化输出字符串

%d：格式化输出整数

%f：格式化输出浮点数

f-字符串

f’{表达式}’

转义字符

\n：换行

\t：制表符，一个tab键的举例

print结束符end

数据类型

我们可以使用type()函数，来查看数据类型

num1 = 1 num2 = 1.1 print(type(num1)) print(type(num2)) print(type('北山啦')) print(type(True))

转换数据类型

==转换数据类型的函数==

==一些例子==

需求：input接收用户输入，用户输入“1”，将这个数据1转换成整型。

num = input('请输入您的幸运数字：') print(f"您的幸运数字是{num}") print(type(num)) print(type(int(num))) # 1. float() -- 转换成浮点型 num1 = 1 print(float(num1)) print(type(float(num1))) # 2. str() -- 转换成字符串类型 num2 = 10 print(type(str(num2))) # 3. tuple() -- 将一个序列转换成元组 list1 = [10, 20, 30] print(tuple(list1)) print(type(tuple(list1))) # 4. list() -- 将一个序列转换成列表 t1 = (100, 200, 300) print(list(t1)) print(type(list(t1))) # 5. eval() -- 将字符串中的数据转换成Python表达式原本类型 str1 = '10' str2 = '[1, 2, 3]' str3 = '(1000, 2000, 3000)' print(type(eval(str1))) print(type(eval(str2))) print(type(eval(str3)))

请输入您的幸运数字：20 您的幸运数字是20 1.0 (10, 20, 30) [100, 200, 300]

运算符

算数运算符

赋值运算符

符合赋值运算符

比较运算符

逻辑运算符

算数运算符

算数运算的优先级

混合运算优先级顺序：()高于 ** 高于 * / // % 高于 + -

赋值运算符

=

复合赋值运算符

+=

-=

优先级

先算复合赋值运算符右侧的表达式

再算复合赋值运算的算数运算

最后算赋值运算

比较运算符

判断相等： ==

大于等于： >=

小于等于：<=

不等于： !=

逻辑运算符

与： and，都真才真

或：or，一真则真，都假才假

非：not，取反

流程控制

条件语句

python中的条件判断共三种：

if语句语法

if 条件: 条件成立执行的代码

if…else…

if 条件: 条件成立执行的代码 else: 条件不成立执行的代码

多重判断

if 条件1: 条件1成立执行的代码 elif 条件2: 条件2成立执行的代码 else: 以上条件都不成立执行的代码

age = int(input('请输入他的年龄：\n')) if age < 18: print(f"你输入的年龄是{age},童工") elif 18 <= age <= 60: print("你输入的年龄是{},合法".format(age)) elif age > 60: print("你输入的年龄是%d,退休" % age)

请输入他的年龄： 20 你输入的年龄是20,合法

让我们直接用一个猜拳小游戏，来熟悉if条件语句吧

""" 提示：0-石头，1-剪刀，2-布 1. 出拳 玩家输入出拳 电脑随机出拳,使用random库随机生成0，1，2 """ import random computer = random.randint(0, 2) # print(computer) player = int(input('请出拳：0-石头，1-剪刀，2-布：')) if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0): print('玩家获胜') elif player == computer: print('平局') else: print('电脑获胜')

请出拳：0-石头，1-剪刀，2-布：2 电脑获胜

循环

本章节将向大家介绍Python的循环语句，程序在一般情况下是按顺序执行的。

编程语言提供了各种控制结构，允许更复杂的执行路径。

循环语句允许我们执行一个语句或语句组多次，下面是在大多数编程语言中的循环语句的一般形式：

while循环

while 条件:

条件成立执行代码

具体例子：

# 输出5遍博客名 t = 0 while(t < 5): print("北山啦") t += 1

北山啦 北山啦 北山啦 北山啦 北山啦

# 1-100累加 i = 1 sum = 0 while i <= 100: sum += i i += 1 print(sum)

5050

1-100的偶数累加和

i = 1 sum = 0 while i <= 100: if i % 2 == 0: sum += i i += 1 print(sum)

2550

i = 0 sum = 0 while i <= 100: sum += i i += 2 print(sum)

2550

==break和continue==

break和continue是循环中满足一定条件退出循环的两种不同方式。

break控制循环流程，即终止此循环

continue控制循环流程，即退出当前一次循环而执行下一次循环代码

具体例子如下

# 循环吃5个苹果，吃完了第3个吃饱了，第4和第5个不吃了 i = 1 while i <= 5: if i == 4: break print(f"吃了第{i}个苹果") i += 1

吃了第1个苹果 吃了第2个苹果 吃了第3个苹果

i = 1 while i <= 5: if i == 3: print("吃出了一个大虫子，这个苹果不吃了") # 如果使用continue，在continue之前一定要修改计数器，否则进入死循环 i += 1 continue print(f"吃了第{i}个苹果") i += 1

吃了第1个苹果 吃了第2个苹果 吃出了一个大虫子，这个苹果不吃了 吃了第4个苹果 吃了第5个苹果

while嵌套以及他的应用

while嵌套的简单应用

j = 0 while j < 3: i = 0 while i < 3: print("CSDN") i += 1 j += 1 print("北山啦")

CSDN CSDN CSDN 北山啦 CSDN CSDN CSDN 北山啦 CSDN CSDN CSDN 北山啦

一行输出5个星号，重复打印5行

j = 0 while j < 5: i = 0 while i < 5: print("*", end='') i += 1 print() j += 1

***** ***** ***** ***** *****

打印三角形

j = 0 while j < 5: i = 0 while i <= j: print("*", end='') i += 1 print() j += 1

* ** *** **** *****

九九乘法表

# 九九乘法表 for i in range(1, 10): for j in range(1, i+1): print(f'{j}*{i}={i*j}\t', end='') print()

1x1=1 1x2=2 2x2=4 1x3=3 2x3=6 3x3=9 1x4=4 2x4=8 3x4=12 4x4=16 1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

# 九九乘法表 i = 1 while i <= 9: j = 1 while(j <= i): print('{}*{}= {}'.format(j, i, i*j), end='\t') j += 1 print('') i += 1

1*1= 1 1*2= 2 2*2= 4 1*3= 3 2*3= 6 3*3= 9 1*4= 4 2*4= 8 3*4= 12 4*4= 16 1*5= 5 2*5= 10 3*5= 15 4*5= 20 5*5= 25 1*6= 6 2*6= 12 3*6= 18 4*6= 24 5*6= 30 6*6= 36 1*7= 7 2*7= 14 3*7= 21 4*7= 28 5*7= 35 6*7= 42 7*7= 49 1*8= 8 2*8= 16 3*8= 24 4*8= 32 5*8= 40 6*8= 48 7*8= 56 8*8= 64 1*9= 9 2*9= 18 3*9= 27 4*9= 36 5*9= 45 6*9= 54 7*9= 63 8*9= 72 9*9= 81

使用列表推导式

print('\n'.join( ['\t'.join([f"{j}*{i}={i*j}" for j in range(1, i + 1)]) for i in range(1, 10)]))

1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

for循环

语法：

for 临时变量 in 序列:

重复执行的代码1 重复执行的代码2 ......

str1 = 'CSDN北山啦' for i in str1: print(i)

C S D N 北 山 啦

for…else 之break和continue

# break str2 = 'https://beishan.blog.csdn.net/' for i in str2: if i == ':': break print(i) else: print("循环正常结束执行的else代码")

h t t p s

# continue str2 = 'https://beishan.blog.csdn.net/' for i in str2: if i == ':': continue print(i) else: print("循环正常结束执行的else代码")

h t t p s / / b e i s h a n . b l o g . c s d n . n e t / 循环正常结束执行的else代码

数据序列

我们可以使用==type()==函数来查看数据类型

字符串

字符串是Python中最常见的数据类型，我们一般使用引号来创建字符串。

可以使用单引号，也可以使用三引号

a = 'https://beishan.blog.csdn.net/' print(type(a)) b = """原创:CSDN北山啦""" print(type(b)) c = "I'm 北山啦" print(c) print(type(c))

I'm 北山啦

在Python中，使用input()接收用户输入。在Python中，使用print()接收用户输入。

==切片==

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

语法

序列[开始位置下标:结束位置下标:步长]

注意

1. 不包含结束位置下标对应的数据， 正负整数均可； 2. 步长是选取间隔，正负整数均可，默认步长为1。

name = "abcdefg" print(name[2:5:1]) # cde print(name[2:5]) # cde print(name[:5]) # abcde print(name[1:]) # bcdefg print(name[:]) # abcdefg print(name[::2]) # aceg print(name[:-1]) # abcdef, 负1表示倒数第一个数据 print(name[-4:-1]) # def print(name[::-1]) # gfedcba

cde cde abcde bcdefg abcdefg aceg abcdef def gfedcba

==字符串常用操作==

字符串的常用操作方法有查找、修改和判断三大类。

查找:find()、index()、count()

find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。

count()：返回某个子串在字符串中出现的次数

修改:replace()、split()、join()

split()：按照指定字符分割字符串。

字符串序列.split(分割字符, num)

注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

字符或子串.join(多字符串组成的序列)

capitalize()：将字符串第一个字符转换成大写。

title()：将字符串每个单词首字母转换成大写。

lower()：将字符串中大写转小写。

upper()：将字符串中小写转大写。

strip()：删除字符串两侧空白字符。lstrip()、rstrip()

center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。

判断:startswith()、endwith()、isalpha()、isdigit()

这样的函数有很多，需要用的时候自己百度即可，熟悉最常见的例如:join()、split()即可。

列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

name_list = ['欢迎', '关注', '北山啦'] print(name_list[0]) print(name_list[1]) print(name_list[2])

欢迎 关注 北山啦

==常见的函数==

index()、count()、len()

name_list = ['欢迎', '关注', '北山啦'] print(name_list.index('北山啦')) print(name_list.count('北山啦'))c print(len(name_list))

2 1 3

==判断是否存在==

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['欢迎', '关注', '北山啦'] print('欢迎' in name_list) print('Lilys' in name_list)

True False

print('北山' not in name_list) print('Lilys' not in name_list)

True True

常用操作方法

index()

len()

append()

extend()

insert()

del()

pop()

clear()

remove()

同时列表也有reverse()、sort()这样的函数

import random teachers = ['zhangzk', 'dfbdaf', 'dfad', 'dfa', 'etw', 'dfa', 'dgdag'] offices = [[], [], []] for name in teachers: num = random.randint(0, 2) offices[num].append(name) print(offices)

[['dfbdaf', 'dfa'], ['zhangzk', 'dfa', 'dgdag'], ['dfad', 'etw']]

[i for j in offices for i in j]

['dfbdaf', 'dfa', 'zhangzk', 'dfa', 'dgdag', 'dfad', 'etw']

for name in offices: for i in name: print(i, end=' ')

etw dgdag dfad dfa zhangzk dfbdaf dfa

元组

一个元组可以存储多个数据，元组内的数据是不能修改的

元组特点：定义元组使用==小括号==，且==逗号==隔开各个数据，数据可以是不同的数据类型。

t1 = (10, 20, 30) t2 = (10,) print(type(t1)) print(type(t2))

如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

t2 = (10,) print(type(t2)) # tuple t3 = (20) print(type(t3)) # int t4 = ('hello') print(type(t4)) # str

常用方法和list类似:index()、len()、count()

字典

字典特点：

符号为大括号

数据为键值对形式出现

各个键值对之间用逗号隔开

创建字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} # 有数据的字典 dict2 = {} # 创建空字典 dict3 = dict() # 创建空字典 print(type(dict1))

字典的常见操作

增加

如果key存在则修改这个key对应的值；如果key不存在则新增此键值对

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'} dict1['name'] = 'Rose' print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男'}

dict1['id'] = 110 print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}

删除

del、clear

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'} # del(dict1) del dict1['gender'] print(dict1)

{'name': '北山啦', 'age': 20}

dict1.clear() print(dict1) # 清空字典

{}

修改

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'} dict1['age'] = 22 print(dict1)

{'name': '北山啦', 'age': 22, 'gender': '男'}

查找

如果查找的key存在，则返回对应的值，否则报错

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'} print(dict1['name']) print(dict1['id'])

北山啦 --------------------------------------------------------------------------- KeyError Traceback (most recent call last) C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_1196/2064109912.py in 1 dict1 = {'name':'北山啦','age':20,'gender':'男'} 2 print(dict1['name']) ----> 3 print(dict1['id']) KeyError: 'id'

字典当中常用的函数

get()

语法

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

快速体验

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.get('name')) # Tom print(dict1.get('id', 110)) # 110 print(dict1.get('id')) # None

keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])

values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.values()) # dict_values(['Tom', 20, '男'])

items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

==字典当中的循环遍历==

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'} for key in dict1.keys(): print(key)

name age gender

for value in dict1.values(): print(value)

北山啦 20 男

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} for item in dict1.items(): print(item)

('name', 'Tom') ('age', 20) ('gender', '男')

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} for key, value in dict1.items(): print(f'{key}:{value}')

name:Tom age:20 gender:男

集合

创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。

集合的特点：

集合可以去掉重复数据；

集合数据是无序的，故不支持下标

s1 = {10, 20, 30, 40, 50} print(s1) s2 = {10, 30, 20, 10, 30, 40, 30, 50} print(s2) s3 = set('abcdefg') print(s3) s4 = set() print(type(s4)) # set s5 = {} print(type(s5)) # dict

{50, 20, 40, 10, 30} {50, 20, 40, 10, 30} {'a', 'd', 'b', 'e', 'f', 'g', 'c'}

常见操作

增加数据

add() #追加单一的数据

update() #追加序列

删除数据

remove()

discard()

s1 = {10, 20, 30, 40, 50} s1.add(100) # 集合是可变的类型 print(s1)

{50, 20, 100, 40, 10, 30}

s1.update([30, 40, 50, 60, 70]) s1 # 集合可以去掉重复数据

{10, 20, 30, 40, 50, 60, 70}

s1.remove(10)

s1

{20, 30, 40, 50, 60, 70}

s1.discard(10) # 没有该数据不会报错，remove会报错 s1

{20, 30, 40, 50, 60, 70}

公共方法

运算符

in / not in

公共方法

len()

del()

range()

enumerate()

数据类型转换

tuple()

list()

set()

利用相应的函数即可实现数据类型转化

语法

enumerate(可遍历对象, start=0)

注意：start参数用来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e'] for i in enumerate(list1, 1): print(i)

(1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e')

for index, char in enumerate(list1, start=1): print(f'下标是{index}, 对应的字符是{char}')

下标是1, 对应的字符是a 下标是2, 对应的字符是b 下标是3, 对应的字符是c 下标是4, 对应的字符是d 下标是5, 对应的字符是e

推导式

列表推导式

字典推导式

集合推导式

==列表推导式==

# while实现 list1 = [] i = 0 while i < 10: list1.append(i) i += 1 print(list1)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# for循环实现 list1 = [] for i in range(10): list1.append(i) print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list1 = [i for i in range(10)] print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带if的列表推导式

# 创建0-10的偶数列表 list1 = [i for i in range(0, 11, 2)] print(list1)

[0, 2, 4, 6, 8, 10]

list1 = [i for i in range(0, 11) if i % 2 == 0] print(list1)

[0, 2, 4, 6, 8, 10]

多个for循环实现列表推导式

list1 = [] for i in range(1, 3): for j in range(3): list1.append((i, j)) print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

list1 = [(i, j) for i in range(1, 3) for j in range(3)] print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

列表推导式解包

a = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] b = [x for b in a for x in b] print(b)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

==字典推导式==

快速合并列表为字典或者体取字典中目标数据

dict1 = {i: i**2 for i in range(1, 5)} print(dict1)

{1: 1, 2: 4, 3: 9, 4: 16}

合并列表为字典

list1 = ['name', 'age', 'gender'] list2 = ['beishan', 20, 'man']

dict1 = {list1[i]: list2[i] for i in range(len(list1))} print(dict1)

{'name': 'beishan', 'age': 20, 'gender': 'man'}

提取字典中目标数据

counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99} count1 = {key: value for key, value in counts.items() if value >= 200} print(count1)

{'MBP': 268, 'DELL': 201}

==集合推导式==

list1 = [1, 1, 2] set1 = {i**2 for i in list1} print(set1)

{1, 4}

到这里就结束了，如果对你有帮助，欢迎关注评论，你的对我很重要

Python 数据结构

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。