区块链技术博客
www.b2bchain.cn

深入浅出Python——Python基础语法全解的讲解

这篇文章主要介绍了深入浅出Python——Python基础语法全解的讲解,通过具体代码讲解7917并且分析了深入浅出Python——Python基础语法全解的讲解的详细步骤与相关技巧,需要的朋友可以参考下

本文实例讲述了深入浅出Python——Python基础语法全解的讲解。分享给大家供大家参考文章查询地址https://www.b2bchain.cn/7917.html。具体如下:

前言:

  1. Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
  2. 本博文主要涉及Python基础入门、流程控制(条件语句、循环语句)、数据序列等知识。
  3. 本博文若存在任何知识错误,请读者第一时间在评论区指出,方便我修正内容!
  4. 获取更多内容,请关注博主,在主页进行阅读,感谢您的支持!

文章目录

    • 一、Python简介
      • 1. 了解Python
      • 2. Python介绍
      • 3. Python特点
      • 4. Python发展历史
      • 5. Python版本
    • 二、Python解释器
      • 1. 解释器的作用
      • 2. 解释器的安装
    • 三、PyCharm安装与使用
      • 1. PyCharm的作用
      • 2. PyCharm安装与使用
    • 四、注释
      • 1. 注释的作用
      • 2. 注释的分类及语法
    • 五、变量
      • 1. 变量的作用
      • 2. 定义变量
        • 2.1 标识符
        • 2.2 命名习惯
        • 2.3 使用变量
        • 2.4 认识bug
        • 2.5 Debug工具
    • 六、数据类型
    • 七、输出
      • 1. 格式化输出
      • 2. 内置函数format
      • 3. f-格式化字符串
      • 4. 体验格式化字符串
      • 5. 补充知识
      • 6. 转义字符
      • 7. 结束符
    • 八、输入
      • 1. 输入的语法
      • 2. 输入的特点
    • 九、转换数据类型
      • 1. 转换数据类型的作用
      • 2. 转换数据类型的函数
      • 3. 体验转换数据类型
    • 十、运算符
      • 1. 运算符的分类
      • 2. 算数运算符
      • 3. 赋值运算符
      • 4. 复合赋值运算符
      • 5. 比较运算符
      • 6. 逻辑运算符
      • 7. 补充知识
    • 十一、条件语句
      • 1. 了解条件语句
      • 2. if语法
        • 2.1 体验if语句
        • 2.2 简单版:网吧上网
        • 2.3 进阶版:网吧上网
      • 3. if…else…
        • 3.1 实用版:网吧上网
      • 4. 多重判断
        • 4.1 实例:工龄判断
      • 5. if嵌套
        • 5.1 实例:坐公交
        • 5.2 if嵌套执行流程
      • 6. 应用:猜拳游戏
        • 6.1 初始版:猜拳游戏
        • 6.2 进阶版:猜拳游戏
      • 7. 三目运算符
    • 十二、循环简介
      • 1. 循环的作用
      • 2. 循环的分类
      • 3. while的语法
      • 4. while循环快速体验
      • 5. while的应用
        • 5.1 应用一:计算1-100累加和
        • 5.2 应用二:计算1-100偶数累加和
      • 6. break和continue
        • 6.1 理解
        • 6.2 break实例
        • 6.3 continue实例
      • 7. while循环嵌套
        • 7.1 语法
        • 7.2 执行过程
        • 7.3 while循环嵌套应用
      • 8. for循环
        • 8.1 语法
        • 8.2 快速体验
        • 8.3 break
        • 8.4 continue
    • 十三、else
      • 1. while…else
        • 1.1 语法
        • 1.2 示例
        • 1.3 退出循环的方式
      • 2. for…else
        • 2.1 语法
        • 2.2 示例
        • 2.3 退出循环的方式
    • 十四、字符串
      • 1. 认识字符串
      • 2. 字符串特征
      • 3. 字符串输出
      • 4. 字符串输入
      • 5. 下标
        • 5.1 概念
        • 5.2 快速体验
      • 6. 切片
        • 6.1 语法
        • 6.2 示例
      • 7. 常用操作方法
        • 7.1 查找
        • 7.2 修改
        • 7.3 判断
    • 十五、列表
      • 1. 列表的格式
      • 2. 列表的常用操作
        • 2.1 查找
        • 2.2 判断是否存在
        • 2.2 增加
        • 2.3 删除
        • 2.4 修改
        • 2.5 复制
      • 3. 列表的循环遍历
        • 3.1 while
        • 3.2 for
      • 4. 列表嵌套
    • 十六、元组
      • 1. 定义元组
      • 2. 元组的常见操作
      • 3. 元组的注意事项
    • 十七、字典
      • 1. 创建字典的语法
      • 2. 字典常见操作
        • 2.1 增
        • 2.2 删
        • 2.3 改
        • 2.4 查
      • 3. 字典的循环遍历
        • 3.1 遍历字典的key
        • 3.2 遍历字典的value
        • 3.3 遍历字典的元素
        • 3.4 遍历字典的键值对
    • 十八、集合
      • 1. 创建集合
      • 2. 集合常见操作方法
        • 2.1 增加数据
        • 2.2 删除数据
        • 2.3 查找数据
    • 十九、公共操作
      • 1. 运算符
        • 1.1 +
        • 1.2 *
        • 1.3 in或not in
      • 2. 公共方法
        • 2.1 len()
        • 2.2 del()
        • 2.3 max()
        • 2.4 min()
        • 2.5 range()
        • 2.6 enumerate()
      • 3. 容器类型转换
        • 3.1 tuple()
        • 3.2 list()
        • 3.3 set()
    • 二十、推导式
      • 1. 列表推导式
        • 1.1 快速体验
        • 1.2 带if的列表推导式
        • 1.3 多个for循环实现列表推导式
      • 2. 字典推导式
        • 2.1 快速体验
      • 3. 集合推导式

一、Python简介

1. 了解Python

Python是一种解释型(这意味着开发过程中没有了编译这个环节)、面向对象(支持面向对象的风格或代码封装在对象的编程技术)、动态数据类型的交互式(可在命令行中通过Python提示符及直接代码执行程序)高级程序设计语言。
深入浅出Python——Python基础语法全解

2. Python介绍

Python是时下最流行、最火爆的编程语言,具体原因:

  • 简单、易学,适应人群广泛
    深入浅出Python——Python基础语法全解
  • 免费、开源
  • 应用领域广泛
    深入浅出Python——Python基础语法全解

备注:以下知名框架均是Python语言开发。

  1. Google开源机器学习框架:TensorFlow
  2. 开源社区主推学习框架:Scikit-learn
  3. 百度开源深度学习框架:Paddle

3. Python特点

  1. 易于学习:Python有相对较少的关键字,结构简单,和一个明确定义的语法,学习起来更加简单。
  2. 易于阅读:Python代码定义的更清晰。
  3. 易于维护:Python的成功在于它的源代码是相当容易维护的。
  4. 一个广泛的标准库:Python的最大的优势之一是丰富的库,跨平台的,在UNIX,Windows和Macintosh兼容很好。
  5. 互动模式:互动模式的支持,您可以从终端输入执行代码并获得结果的语言,互动的测试和调试代码片断。
  6. 可移植:基于其开放源代码的特性,Python已经被移植(也就是使其工作)到许多平台。
  7. 可扩展:如果你需要一段运行很快的关键代码,或者是想要编写一些不愿开放的算法,你可以使用C或C++完成那部分程序,然后从你的Python程序中调用。
  8. 数据库:Python提供所有主要的商业数据库的接口。
  9. GUI编程:Python支持GUI可以创建和移植到许多系统调用。
  10. 可嵌入: 你可以将Python嵌入到C/C++程序,让你的程序的用户获得”脚本化”的能力。

4. Python发展历史

Python发展历史:https://baike.baidu.com/item/Python/407313?fr=aladdin

5. Python版本

  • Python 2.X
  • Python 3.X

二、Python解释器

1. 解释器的作用

  • Python解释器作用:运行文件

  • Python解释器种类

    1. CPython,C语言开发的解释器[官方],应用广泛的解释器。
    2. IPython,基于CPython的一种交互式解释器。
    3. 其他解释器
      • PyPy,基于Python语言开发的解释器。
      • Jython,运行在Java平台的解释器,直接把Python代码编译成Java字节码执行。
      • IronPython,运行在微软.Net平台上的Python解释器,可以直接把Python代码编译成.Net的字节码。

2. 解释器的安装

Python解释器的安装:https://blog.csdn.net/weixin_43495473/article/details/103559812

三、PyCharm安装与使用

1. PyCharm的作用

PyCharm是一种Python IDE(集成开发环境),带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具,内部集成的功能如下:

  • Project管理
  • 智能提示
  • 语法高亮
  • 代码跳转
  • 调试代码
  • 解释代码(解释器)
  • 框架和库

2. PyCharm安装与使用

PyCharm的安装:https://blog.csdn.net/weixin_43495473/article/details/103560198

四、注释

1. 注释的作用

通过用自己熟悉的语言,在程序中对某些代码进行标注说明,这就是注释的作用,能够大大增强程序的可读性。

2. 注释的分类及语法

注释分为两类:单行注释多行注释

  • 单行注释

只能注释一行内容,语法如下:

# 注释内容 
  • 多行注释

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

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

快捷键: ctrl + /

注意:解释器不执行任何的注释内容。

五、变量

1. 变量的作用

变量,简单来说,其实就是计算机内存中的一块储存空间,用来存储CPU需要使用的数据。 而这个储存空间需要一个名字,这个名字的统称就叫变量。
深入浅出Python——Python基础语法全解
作用:

  1. 用来临时保存数据
  2. 便于项目的后期升级维护
  3. 节约内存

2. 定义变量

变量名 =

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

2.1 标识符

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

  • 由数字、字母、下划线组成
  • 不能数字开头
  • 不能使用内置关键字
  • 严格区分大小写

深入浅出Python——Python基础语法全解

2.2 命名习惯

  • 见名知义。
  • 大驼峰:即每个单词首字母都大写,例如:MyName
  • 小驼峰:第二个(含)以后的单词首字母大写,例如:myName
  • 下划线:例如:my_name

2.3 使用变量

my_name = "张三" print(my_name)  myAge = 23 print(myAge) 

2.4 认识bug

所谓bug,就是程序中的错误。如果程序有错误,需要程序员排查问题,纠正错误。

2.5 Debug工具

Debug工具是PyCharm IDE中集成的用来调试程序的工具,在这里程序员可以查看程序的执行细节和流程或者调解bug。

Debug工具使用步骤:

  1. 打断点
  2. Debug调试

六、数据类型

在 Python 里为了应对不同的业务需求,也把数据分为不同的类型。

深入浅出Python——Python基础语法全解

检测数据类型的方法:type(变量名或者数值)

a = 1 print(type(a))  # <class 'int'> -- 整型  b = 1.1 print(type(b))  # <class 'float'> -- 浮点型  c = True print(type(c))  # <class 'bool'> -- 布尔型  d = "12345" print(type(d))  # <class 'str'> -- 字符串  e = [10, 20, 30] print(type(e))  # <class 'list'> -- 列表  f = (10, 20, 30) print(type(f))  # <class 'tuple'> -- 元组  h = {10, 20, 30} print(type(h))  # <class 'set'> -- 集合  g = {"name": "张三", "age": 20} print(type(g))  # <class 'dict'> -- 字典 

思考:

  1. 为什么Python会提出这么多种的数据类型?

有限的内存, 无限的变量, 合理的使用内存

  1. Python中,程序员定义变量需要关心变量的类型吗?
  • Python弱类型语言
  • 程序员不需要关心变量的类型, 只需要把数据书写正确即可,python会通过自动推到出您变量的类型。

七、输出

作用:程序输出内容给用户。

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

1. 格式化输出

格式符号 转换
%s 字符串
%d 有符号的十进制整数
%f 浮点数
%c 字符
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数(小写ox)
%X 十六进制整数(大写OX)
%e 科学计数法(小写’e’)
%E 科学计数法(大写’E’)
%g %f和%e的简写
%G %f和%E的简写
  • %06d,表示输出的整数显示位数,不足以0补全,超出当前位数则原样输出。
  • %.2f,表示小数点后显示的小数位数。

2. 内置函数format

format()用于字符串格式化,功能非常强大,格式是str.format(),format函数可以接受不限个参数,位置可以不按顺序。

3. f-格式化字符串

f-string是格式化字符串的一种很好的新方法。与其他格式化方式相比,它不仅更易读,更简洁,不易出错,而且速度更快!格式为:f'{表达式}'

4. 体验格式化字符串

name = "张三" age = 23 weight = 75.5 student_id = 1  # 我的名字是张三 print('我的名字是%s' % name)  # 我的学号是0001 print('我的学号是%04d' % student_id)  # 我的体重是75.50公斤 print('我的体重是%.2f公斤' % weight)  # 我的名字是张三,今年23岁了 print('我的名字是%s,今年%d岁了' % (name, age))  # 我的名字是张三,明年24岁了 print('我的名字是%s,明年%d岁了' % (name, age + 1))  # 我的名字是张三,明年24岁了 print('我的名字是{0}, 明年{1}岁了'.format(name, age+1))  # 我的名字是李思,今年18岁了 print('我的名字是{0}, 今年{1}岁了'.format("李思", 18))  # 我的名字是张三,明年24岁了 print(f'我的名字是{name}, 明年{age + 1}岁了') 

深入浅出Python——Python基础语法全解

5. 补充知识

字符串输出的本质其实就是拼接字符串,那么我们都用%s完全也是可以的。很多时候,我们不用区分整型、浮点型等,直接用%s输出就可以了。

print('我的名字是%s,今年%s岁了,我的体重是%s公斤' % (name, age ,weight)) 

深入浅出Python——Python基础语法全解

6. 转义字符

  • n:换行。
  • t:制表符,一个tab键(4个空格)的距离。

7. 结束符

# print会默认换行输出 print('输出的内容', end="n") 

在Python中,print(), 默认自带end="n"这个换行结束符,所以导致每两个print直接会换行展示,用户可以按需求更改结束符。

# 改变Python换行输出 print('内容', end=" ") print('内容', end="···") 

八、输入

在Python中,程序接收用户输入的数据的功能即是输入。
深入浅出Python——Python基础语法全解

1. 输入的语法

input("提示信息") 

2. 输入的特点

  • 当程序执行到input,等待用户输入,输入完成之后才继续向下执行。
  • 在Python中,input接收用户输入后,一般存储到变量,方便使用。
  • 在Python中,input会把接收到的任意用户输入的数据都当做字符串处理。
password = input('请输入您的密码:')  print(f'您输入的密码是{password}') # <class 'str'> print(type(password)) 

深入浅出Python——Python基础语法全解

九、转换数据类型

1. 转换数据类型的作用

问:input()接收用户输入的数据都是字符串类型,如果用户输入1,想得到整型该如何操作?

答:转换数据类型即可,即将字符串类型转换成整型。

2. 转换数据类型的函数

函数 说明
int(x [,base ]) 将x转换为一个整数
float(x ) 将x转换为一个浮点数
complex(real [,imag ]) 创建一个复数,real为实部,imag为虚部
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个Unicode字符
ord(x ) 将一个字符转换为它的ASCII整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
bin(x ) 将一个整数转换为一个二进制字符串

3. 体验转换数据类型

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

# 1. 接收用户输入 num = input('请输入您的幸运数字:')  # 2. 打印结果 print(f"您的幸运数字是{num}")   # 3. 检测接收到的用户输入的数据类型 -- str类型 print(type(num))  # 4. 转换数据类型为整型 -- int类型 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))) 

十、运算符

1. 运算符的分类

  • 算数运算符
  • 赋值运算符
  • 复合赋值运算符
  • 比较运算符
  • 逻辑运算符

2. 算数运算符

运算符 描述 实例
+ 1 + 1 输出结果为 2
1-1 输出结果为 0
* 2 * 2 输出结果为 4
/ 10 / 2 输出结果为 5
// 整除 9 // 4 输出结果为2
% 取余 9 % 4 输出结果为 1
** 指数 2 ** 4 输出结果为 16,即 2 * 2 * 2 * 2
() 小括号 小括号用来提高运算优先级,即 (1 + 2) * 3 输出结果为 9

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

3. 赋值运算符

运算符 描述 实例
= 赋值 =右侧的结果赋值给等号左侧的变量
  1. 单个变量赋值
num = 1 print(num) 
  1. 多个变量赋值
num1, float1, str1 = 10, 0.5, 'hello world' print(num1) print(float1) print(str1) 
  1. 多变量赋相同值
a = b = 10 print(a) print(b) 

4. 复合赋值运算符

运算符 描述 实例
+= 加法赋值运算符 c += a 等价于 c = c + a
-= 减法赋值运算符 c -= a 等价于 c = c- a
*= 乘法赋值运算符 c *= a 等价于 c = c * a
/= 除法赋值运算符 c /= a 等价于 c = c / a
//= 整除赋值运算符 c //= a 等价于 c = c // a
%= 取余赋值运算符 c %= a 等价于 c = c % a
**= 幂赋值运算符 c ** = a 等价于 c = c ** a
a = 100 a += 1 # 输出101  a = a + 1,最终a = 100 + 1 print(a)  b = 2 b *= 3 # 输出6  b = b * 3,最终b = 2 * 3 print(b)  c = 10 c += 1 + 2 # 输出13, 先算运算符右侧1 + 2 = 3, c += 3 , 推导出c = 10 + 3 print(c) 

5. 比较运算符

比较运算符也叫关系运算符, 通常用来判断。

运算符 描述 实例
== 判断相等。如果两个操作数的结果相等,则条件结果为真(True),否则条件结果为假(False) 如a=3,b=3,则(a == b) 为 True
!= 不等于 。如果两个操作数的结果不相等,则条件为真(True),否则条件结果为假(False) 如a=3,b=3,则(a == b) 为 True如a=1,b=3,则(a != b) 为 True
> 运算符左侧操作数结果是否大于右侧操作数结果,如果大于,则条件为真,否则为假 如a=7,b=3,则(a > b) 为 True
< 运算符左侧操作数结果是否小于右侧操作数结果,如果小于,则条件为真,否则为假 如a=7,b=3,则(a < b) 为 False
>= 运算符左侧操作数结果是否大于等于右侧操作数结果,如果大于,则条件为真,否则为假 如a=7,b=3,则(a < b) 为 False如a=3,b=3,则(a >= b) 为 True
<= 运算符左侧操作数结果是否小于等于右侧操作数结果,如果小于,则条件为真,否则为假 如a=3,b=3,则(a <= b) 为 True
a = 7 b = 5 print(a == b)  # False print(a != b)  # True print(a < b)   # False print(a > b)   # True print(a <= b)  # False print(a >= b)  # True 

6. 逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔”与”:如果 x 为 False,x and y 返回 False,否则它返回 y 的值。 True and False, 返回 False。
or x or y 布尔”或”:如果 x 是 True,它返回 True,否则它返回 y 的值。 False or True, 返回 True。
not not x 布尔”非”:如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 not True 返回 False, not False 返回 True
a = 1 b = 2 c = 3 print((a < b) and (b < c))  # True print((a > b) and (b < c))  # False print((a > b) or (b < c))   # True print(not (a > b))          # True 

7. 补充知识

数字之间的逻辑运算

a = 0 b = 1 c = 2  # and运算符,只要有一个值为0,则结果为0,否则结果为最后一个非0数字 print(a and b)  # 0 print(b and a)  # 0 print(a and c)  # 0 print(c and a)  # 0 print(b and c)  # 2 print(c and b)  # 1  # or运算符,只有所有值为0结果才为0,否则结果为第一个非0数字 print(a or b)  # 1 print(a or c)  # 2 print(b or c)  # 1 

十一、条件语句

1. 了解条件语句

Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。

2. if语法

if 条件:     条件成立执行的代码1     条件成立执行的代码2     ...... 

2.1 体验if语句

if True:     print('条件成立执行的代码1')     print('条件成立执行的代码2')  # 下方的代码没有缩进到if语句块,所以和if条件无关 print('我是无论条件是否成立都要执行的代码') 

深入浅出Python——Python基础语法全解

2.2 简单版:网吧上网

需求分析:如果用户年龄大于等于18岁,即成年,输出”已经成年,可以上网”。

age = 20 if age >= 18:     print('已经成年,可以上网')  print('系统关闭') 

2.3 进阶版:网吧上网

新增需求:用户可以输出自己的年龄,然后系统进行判断是否成年,成年则输出”您的年龄是’用户输入的年龄’,已经成年,可以上网”。

# input接受用户输入的数据是字符串类型,条件是age和整型18做判断,所以这里要int转换数据类型 age = int(input('请输入您的年龄:'))  if age >= 18:     print(f'您的年龄是{age},已经成年,可以上网')   print('系统关闭') 

3. if…else…

作用:条件成立执行if下方的代码; 条件不成立执行else下方的代码。

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

思考:网吧上网的实例,如果成年,允许上网,如果不成年呢?是不是应该回复用户不能上网?

3.1 实用版:网吧上网

age = int(input('请输入您的年龄:'))  if age >= 18:     print(f'您的年龄是{age},已经成年,可以上网') else:     print(f'您的年龄是{age},未成年,请自行回家写作业')  print('系统关闭') 

注意:如果条件成立执行了某些代码,那么其他的情况的代码将不会执行。

4. 多重判断

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

多重判断也可以和else配合使用。一般else放在整个if语句的最后,表示以上条件都不成立的时候执行的代码。

思考:中国合法工作年龄为18-60岁,即如果年龄小于18的情况为童工,不合法;如果年龄在18-60岁之间为合法工龄;大于60岁为法定退休年龄。

4.1 实例:工龄判断

age = int(input('请输入您的年龄:')) if age < 18:     print(f'您的年龄是{age},童工一枚') elif (age >= 18) and (age <= 60):     print(f'您的年龄是{age},合法工龄') elif age > 60:     print(f'您的年龄是{age},可以退休') 

拓展:age >= 18 and age <= 60可以化简为18 <= age <= 60

5. if嵌套

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

注意:条件2的if也是出于条件1的缩进关系内部。

思考:坐公交:如果有钱可以上车,没钱不能上车;上车后如果有空座,则可以坐下;如果没空座,就要站着。怎么书写程序?

5.1 实例:坐公交

  1. 判断是否能上车
""" 	1. 如果有钱,则可以上车     2. 上车后,如果有空座,可以坐下     上车后,如果没有空座,则站着等空座位 	如果没钱,不能上车 """ # 假设用 money = 1 表示有钱, money = 0表示没有钱 money = 1 if money == 1:     print('土豪,不差钱,顺利上车') else:     print('没钱,不能上车,追着公交车跑') 
  1. 判断是否能坐下
""" 	1. 如果有钱,则可以上车     2. 上车后,如果有空座,可以坐下     上车后,如果没有空座,则站着等空座位 	如果没钱,不能上车 """ # 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座,seat = 0 表示没有空座 money = 1 seat = 0 if money == 1:     print('土豪,不差钱,顺利上车')     if seat == 1:         print('有空座,可以坐下')     else:         print('没有空座,站等') else:     print('没钱,不能上车,追着公交车跑') 

5.2 if嵌套执行流程

深入浅出Python——Python基础语法全解

6. 应用:猜拳游戏

需求分析:

  • 参与游戏的角色

    • 玩家
      • 手动出拳
    • 电脑
      • 随机出拳
  • 判断输赢

    • 玩家获胜
    玩家 电脑
    石头 剪刀
    剪刀
    石头
    • 平局
      • 玩家出拳 和 电脑出拳相同
    • 电脑获胜

随机做法:

  1. 导出random模块
import 模块名 
  1. 使用random模块中的随机整数功能
random.randint(开始,结束) 

6.1 初始版:猜拳游戏

""" 提示:0-石头,1-剪刀,2-布 3. 出拳 玩家输入出拳 电脑随机出拳  4. 判断输赢 玩家获胜 平局 电脑获胜 """  # 导入random模块 import random  # 计算电脑出拳的随机数字 computer = random.randint(0, 2) print(computer)  player = int(input('请出拳:0-石头,1-剪刀,2-布:'))  # 玩家胜利 p0:c1 或 p1:c2 或 p2:c0 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('电脑获胜') 

6.2 进阶版:猜拳游戏

""" 石头剪刀布游戏 玩家VS电脑 站在玩家的角度,分析胜利、失败、平局 0-石头,1-剪刀,2-布 """ # 导入随机数模块 import random  import sys  print("-----欢迎来到人机对战小游戏-----") name = input("请输入您的游戏名:") while True:     stats = input("欢迎“%s”来到本游戏,开始游戏输入Y,退出游戏输入N,请您输入:" % name)     if stats == "Y" or stats == "y":         print("游戏开始……")         print("石头输入0、剪刀输入1、布输入2")         break     elif stats == "N" or stats == "n":         print("游戏结束……")         sys.exit(0)     else:         print("请按照要求重新输入!") print("-------------加载中-------------")   def Game(user, comp):     if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0):         print("机器输入%d,您赢了!" % comp)     elif user == comp:         print("机器输入%d,平局了!" % comp)     else:         print("机器输入%d,您输了!" % comp)     res = input("重新游戏请输入X,退出游戏按任意键")     if res == "X" or res == "x":         return     else:         sys.exit(0)   while True:     user = int(input("请您出拳,输入相应数字!"))     if user == 0 or user == 1 or user == 2:         comp = random.randint(0, 2)         Game(user, comp)     else:         print("输入数字有误,请确认后,重新输入!")  

7. 三目运算符

三目运算符也叫三元运算符。

语法如下:

1 if 条件 else2 

快速体验:

a = 1 b = 2  c = a if a > b else b print(c) 

十二、循环简介

1. 循环的作用

让代码更高效的重复执行。

2. 循环的分类

在Python中,循环分为whilefor两种,最终实现效果相同。

3. while的语法

while 条件:     条件成立重复执行的代码1     条件成立重复执行的代码2     ...... 

4. while循环快速体验

需求:复现重复执行10次print('Hello World')

分析:初始值是0次,终点是10次,重复做的事情输出“Hello World”。

# 循环的计数器 i = 0 while i < 10:     print('Hello World')     i += 1  print('任务结束') 

5. while的应用

5.1 应用一:计算1-100累加和

分析:1-100的累加和,即1 + 2 + 3 + 4 +….,即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。

i = 1 result = 0 while i <= 100:     result += i     i += 1  # 输出5050 print(result) 

注意:为了验证程序的准确性,可以先改小数值,验证结果正确后,再改成1-100做累加。

5.2 应用二:计算1-100偶数累加和

分析:1-100的偶数和,即 2 + 4 + 6 + 8…,得到偶数的方法如下:

  • 偶数即是和2取余结果为0的数字,可以加入条件语句判断是否为偶数,为偶数则累加
  • 初始值为0 / 2 , 计数器每次累加2

方法一:条件判断和2取余数则累加

# 方法一:条件判断和2取余数为0则累加计算 i = 1 result = 0 while i <= 100:     if i % 2 == 0:         result += i     i += 1  # 输出2550 print(result) 

方法二:计数器控制

# 方法二:计数器控制增量为2 i = 0 result = 0 while i <= 100:     result += i     i += 2  # 输出2550 print(result) 

6. break和continue

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

6.1 理解

举例:一共吃5个苹果,吃完第一个,吃第二个…,这里”吃苹果”的动作是不是重复执行?

情况一:如果吃的过程中,吃完第三个吃饱了,则不需要再吃第4个和第五个苹果,即是吃苹果的动作停止,这里就是break控制循环流程,即终止此循环

情况二:如果吃的过程中,吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了,开始吃第四个苹果,这里就是continue控制循环流程,即退出当前一次循环继而执行下一次循环代码

6.2 break实例

i = 1 while i <= 5:     if i == 4:         print(f'吃饱了不吃了')         break     print(f'吃了第{i}个苹果')     i += 1 

深入浅出Python——Python基础语法全解

6.3 continue实例

i = 1 while i <= 5:     if i == 3:         print(f'大虫子,第{i}个不吃了')         # 在continue之前一定要修改计数器,否则会陷入死循环         i += 1         continue     print(f'吃了第{i}个苹果')     i += 1 

深入浅出Python——Python基础语法全解

7. while循环嵌套

7.1 语法

while 条件1:     条件1成立执行的代码     ......     while 条件2:         条件2成立执行的代码         ...... 

总结:所谓while循环嵌套,就是一个while里面嵌套一个while的写法,每个while和之前的基础语法是相同的。

7.2 执行过程

当内部循环执行完成之后,再执行下一次外部循环的条件判断。
深入浅出Python——Python基础语法全解

7.3 while循环嵌套应用

应用一:打印星号(正方形)

# 重复打印5行星星 j = 0 while j <= 4:     # 一行星星的打印     i = 0     while i <= 4:         # 一行内的星星不能换行,取消print默认结束符n         print('*', end='')         i += 1     # 每行结束要换行,这里借助一个空的print,利用print默认结束符换行     print()     j += 1 

深入浅出Python——Python基础语法全解
应用二:打印星号(三角形)

# 重复打印5行星星 # j表示行号 j = 0 while j <= 4:     # 一行星星的打印     i = 0     # i表示每行里面星星的个数,这个数字要和行号相等所以i要和j联动     while i <= j:         print('*', end='')         i += 1     print()     j += 1 

深入浅出Python——Python基础语法全解
应用二:九九乘法表

# 重复打印9行表达式 j = 1 while j <= 9:     # 打印一行里面的表达式 a * b = a*b     i = 1     while i <= j:         print(f'{i}*{j}={j*i}', end='t')         i += 1     print()     j += 1 

深入浅出Python——Python基础语法全解

8. for循环

8.1 语法

for 临时变量 in 序列:     重复执行的代码1     重复执行的代码2     ...... 

8.2 快速体验

str1 = 'Hello World' for i in str1:     print(i) 

深入浅出Python——Python基础语法全解

8.3 break

str1 = 'Hello World' for i in str1:     if i == 'e':         print('遇到e不打印')         break     print(i) 

深入浅出Python——Python基础语法全解

8.4 continue

str1 = 'Hello World' for i in str1:     if i == 'e':         print('遇到e不打印')         continue     print(i) 

深入浅出Python——Python基础语法全解

十三、else

循环可以和else配合使用,else下方缩进的代码指的是当循环正常结束之后要执行的代码

1. while…else

1.1 语法

while 条件:     条件成立重复执行的代码 else:     循环正常结束之后要执行的代码 

1.2 示例

i = 1 while i <= 5:     print('Hello World')     i += 1 else:     print('执行完毕') 

深入浅出Python——Python基础语法全解

1.3 退出循环的方式

  1. break终止循环
i = 1 while i <= 5:     if i == 3:         print("提前结束")         break     print('Hello World')     i += 1 else:     print('执行完毕') 

深入浅出Python——Python基础语法全解

所谓else指的是循环正常结束之后要执行的代码,即如果是break终止循环的情况,else下方缩进的代码将不执行。

  1. continue控制循环
i = 1 while i <= 5:     if i == 3:         print("打断一下")         i += 1         continue     print('Hello World')     i += 1 else:     print('执行完毕') 

深入浅出Python——Python基础语法全解

因为continue是退出当前一次循环,继续下一次循环,所以该循环在continue控制下是可以正常结束的,当循环结束后,则执行了else缩进的代码。

2. for…else

2.1 语法

for 临时变量 in 序列:     重复执行的代码     ... else:     循环正常结束之后要执行的代码 

所谓else指的是循环正常结束之后要执行的代码,即如果是break终止循环的情况,else下方缩进的代码将不执行。

2.2 示例

str1 = 'Hello World' for i in str1:     print(i) else:     print('循环正常结束之后执行的代码') 

深入浅出Python——Python基础语法全解

2.3 退出循环的方式

  1. break终止循环
str1 = 'Hello World' for i in str1:     if i == 'e':         print('遇到e不打印')         break     print(i) else:     print('循环正常结束之后执行的代码') 

深入浅出Python——Python基础语法全解

没有执行else缩进的代码。

  1. continue控制循环
str1 = 'Hello World' for i in str1:     if i == 'e':         print('遇到e不打印')         continue     print(i) else:     print('循环正常结束之后执行的代码') 

深入浅出Python——Python基础语法全解

因为continue是退出当前一次循环,继续下一次循环,所以该循环在continue控制下是可以正常结束的,当循环结束后,则执行了else缩进的代码。

十四、字符串

1. 认识字符串

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单,只要为变量分配一个值即可。

a = 'hello world' b = "abcdefg" print(type(a)) print(type(b)) 

注意:控制台显示结果为<class 'str'>, 即数据类型为str(字符串)。

2. 字符串特征

  • 一对引号字符串
name1 = 'Tom' name2 = "Rose" 
  • 三引号字符串
name3 = ''' Tom ''' name4 = """ Rose """ a = ''' i am Tom,          nice to meet you! '''  b = """ i am Rose,          nice to meet you! """ 

注意:三引号形式的字符串支持换行。

思考:如果创建一个字符串I'm Tom?

c = "I'm Tom" d = 'I'm Tom' 

3. 字符串输出

print('hello world')  name = 'Tom' print('我的名字是%s' % name) print(f'我的名字是{name}') 

4. 字符串输入

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

name = input('请输入您的名字:') print(f'您输入的名字是{name}') print(type(name))  password = input('请输入您的密码:') print(f'您输入的密码是{password}') print(type(password)) 

深入浅出Python——Python基础语法全解

5. 下标

5.1 概念

“下标”又叫“索引”,就是编号。比如火车座位号,座位号的作用:按照编号快速找到对应的座位。同理,下标的作用即是通过下标快速找到对应的数据。

5.2 快速体验

需求:字符串name = "abcdef",取到不同下标对应的数据。

  • 代码
name = "abcdef"  print(name[1]) print(name[0]) print(name[2]) 
  • 输出结果
    深入浅出Python——Python基础语法全解

注意:下标从0开始。
深入浅出Python——Python基础语法全解

6. 切片

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

6.1 语法

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

注意:

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

6.2 示例

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 

7. 常用操作方法

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

7.1 查找

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。

  • find():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则返回-1。
  1. 语法
字符串序列.find(子串, 开始位置下标, 结束位置下标) 

注意:开始和结束位置下标可以省略,表示在整个字符串序列中查找。

  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.find('and'))  # 12 print(mystr.find('and', 15, 30))  # 22 print(mystr.find('ands'))  # -1 
  • index():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则报异常。
  1. 语法
字符串序列.index(子串, 开始位置下标, 结束位置下标) 

注意:开始和结束位置下标可以省略,表示在整个字符串序列中查找。

  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.index('and'))  # 12 print(mystr.index('and', 15, 30))  # 22 print(mystr.index('ands'))  # 报错 
  • rfind(): 和find()功能相同,但查找方向为右侧开始。
  • rindex():和index()功能相同,但查找方向为右侧开始。
  • count():返回某个子串在字符串中出现的次数。
  1. 语法
字符串序列.count(子串, 开始位置下标, 结束位置下标) 

注意:开始和结束位置下标可以省略,表示在整个字符串序列中查找。

  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.count('and'))  # 3 print(mystr.count('ands'))  # 0 print(mystr.count('and', 0, 20))  # 1 

7.2 修改

所谓修改字符串,指的就是通过函数的形式修改字符串中的数据。

  • replace():替换字符串。
  1. 语法
字符串序列.replace(旧子串, 新子串, 替换次数) 

注意:替换次数如果查出子串出现次数,则替换次数为该子串出现次数。

  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.replace('and', 'he')) # 结果:hello world he buran he list he Python print(mystr.replace('and', 'he', 10)) # 结果:hello world he buran he list he Python print(mystr) # 结果:hello world and buran and list and Python 

注意:数据按照是否能直接修改分为可变类型不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串,属于不能直接修改数据的类型即是不可变类型。

  • split():按照指定字符分割字符串。
  1. 语法
字符串序列.split(分割字符, num) 

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

  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.split('and')) # 结果:['hello world ', ' buran ', ' list ', ' Python'] print(mystr.split('and', 2)) # 结果:['hello world ', ' buran ', ' list and Python'] print(mystr.split(' ')) # 结果:['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python'] print(mystr.split(' ', 2)) # 结果:['hello', 'world', 'and buran and list and Python'] 

注意:如果分割字符是原有字符串中的子串,分割后则丢失该子串。

  • join():用一个字符或子串合并字符串,即是将多个字符串合并为一个新的字符串。
  1. 语法
字符或子串.join(多字符串组成的序列) 
  1. 快速体验
list1 = ['hello', 'buran', 'list'] t1 = ('aa', 'b', 'cc', 'ddd')  print('_'.join(list1)) # hello_buran_list print('...'.join(t1)) # 结果:aa...b...cc...ddd 
  • capitalize():将字符串第一个字符转换成大写。
mystr = "hello world and buran and list and Python"  print(mystr.capitalize()) # 结果:Hello world and buran and list and python 

注意:capitalize()函数转换后,只字符串第一个字符大写,其他的字符全都小写。

  • title():将字符串每个单词首字母转换成大写。
mystr = "hello world and buran and list and Python"  print(mystr.title()) # 结果:Hello World And Buran And List And Python 
  • lower():将字符串中大写转小写。
mystr = "hello world and buran and list and Python"  print(mystr.lower()) # 结果:hello world and buran and list and python 
  • upper():将字符串中小写转大写。
mystr = "hello world and buran and list and Python"  print(mystr.upper()) # 结果:HELLO WORLD AND BURAN AND LIST AND PYTHON 
  • lstrip():删除字符串左侧空白字符。
  • rstrip():删除字符串右侧空白字符。
  • strip():删除字符串两侧空白字符。
  • ljust():返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串。
  • rjust():返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串,语法和ljust()相同。
  • center():返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串,语法和ljust()相同。

7.3 判断

所谓判断即是判断真假,返回的结果是布尔型数据类型:True 或 False。

  • startswith():检查字符串是否是以指定子串开头,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。
  1. 语法
字符串序列.startswith(子串, 开始位置下标, 结束位置下标) 
  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.startswith('hello')) # 结果:True print(mystr.startswith('hello', 5, 20)) # 结果:False 
  • endswith()::检查字符串是否是以指定子串结尾,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。
  1. 语法
字符串序列.endswith(子串, 开始位置下标, 结束位置下标) 
  1. 快速体验
mystr = "hello world and buran and list and Python"  print(mystr.endswith('Python')) # 结果:True print(mystr.endswith('python')) # 结果:False print(mystr.endswith('Python', 2, 20)) # 结果:False 
  • isalpha():如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。
mystr1 = 'hello' mystr2 = 'hello12345'  print(mystr1.isalpha()) # 结果:True print(mystr2.isalpha()) # 结果:False 
  • isdigit():如果字符串只包含数字则返回 True 否则返回 False。
mystr1 = 'aaa12345' mystr2 = '12345'  print(mystr1.isdigit()) # 结果: False print(mystr2.isdigit()) # 结果:False 
  • isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。
mystr1 = 'aaa12345' mystr2 = '12345-'  print(mystr1.isalnum()) # 结果:True print(mystr2.isalnum()) # 结果:False 
  • isspace():如果字符串中只包含空白,则返回 True,否则返回 False。
mystr1 = '1 2 3 4 5' mystr2 = '     '  print(mystr1.isspace()) # 结果:False print(mystr2.isspace()) # 结果:True 

十五、列表

1. 列表的格式

[数据1, 数据2, 数据3, 数据4......] 

列表可以一次性有序存储多个不同类型的数据。

2. 列表的常用操作

列表的作用是一次性存储多个数据,程序员可以对这些数据进行的操作有:增、删、改、查。

2.1 查找

  1. 下标
name_list = ['Tom', 'Lily', 'Rose']  print(name_list[0])  # Tom print(name_list[1])  # Lily print(name_list[2])  # Rose 
  1. 函数
  • index():返回指定数据所在位置的下标 。
列表序列.index(数据, 开始位置下标, 结束位置下标) 
name_list = ['Tom', 'Lily', 'Rose']  print(name_list.index('Lily', 0, 2))  # 1 

注意:如果查找的数据不存在则报错。

  • count():统计指定数据在当前列表中出现的次数。
name_list = ['Tom', 'Lily', 'Rose']  print(name_list.count('Lily'))  # 1 
  • len():访问列表长度,即列表中数据的个数。
name_list = ['Tom', 'Lily', 'Rose']  print(len(name_list))  # 3 

2.2 判断是否存在

  • in:判断指定数据在某个列表序列,如果在返回True,否则返回False。
name_list = ['Tom', 'Lily', 'Rose']  # 结果:True print('Lily' in name_list)  # 结果:False print('Lilys' in name_list) 
  • not in:判断指定数据不在某个列表序列,如果不在返回True,否则返回False。
name_list = ['Tom', 'Lily', 'Rose']  # 结果:False print('Lily' not in name_list)  # 结果:True print('Lilys' not in name_list) 

2.2 增加

作用:增加指定数据到列表中。

  • append():列表结尾追加数据。
列表序列.append(数据) 
name_list = ['Tom', 'Lily', 'Rose']  name_list.append('xiaoming')  # 结果:['Tom', 'Lily', 'Rose', 'xiaoming'] print(name_list) 

列表追加数据的时候,直接在原列表里面追加了指定数据,即修改了原列表,故列表为可变类型数据。

注意点:如果append()追加的数据是一个序列,则追加整个序列到列表。

name_list = ['Tom', 'Lily', 'Rose']  name_list.append(['xiaoming', 'xiaohong'])  # 结果:['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']] print(name_list) 
  • extend():列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表。
列表序列.extend(数据) 

单个数据:

name_list = ['Tom', 'Lily', 'Rose']  name_list.extend('xiaoming')  # 结果:['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g'] print(name_list) 

序列数据:

name_list = ['Tom', 'Lily', 'Rose']  name_list.extend(['xiaoming', 'xiaohong'])  # 结果:['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong'] print(name_list) 
  • insert():指定位置新增数据。
列表序列.insert(位置下标, 数据) 
name_list = ['Tom', 'Lily', 'Rose']  name_list.insert(1, 'xiaoming')  # 结果:['Tom', 'xiaoming', 'Lily', 'Rose'] print(name_list) 

2.3 删除

  • del
del 目标 # del(目标) 

删除列表:

name_list = ['Tom', 'Lily', 'Rose']  # 结果:报错提示:name 'name_list' is not defined del name_list print(name_list) 

删除指定数据:

name_list = ['Tom', 'Lily', 'Rose']  del name_list[0]  # 结果:['Lily', 'Rose'] print(name_list) 
  • pop():删除指定下标的数据(默认为最后一个),并返回该数据。
列表序列.pop(下标) 
name_list = ['Tom', 'Lily', 'Rose']  del_name = name_list.pop(1)  # 结果:Lily print(del_name)  # 结果:['Tom', 'Rose'] print(name_list) 
  • remove():移除列表中某个数据的第一个匹配项。
列表序列.remove(数据) 
name_list = ['Tom', 'Lily', 'Rose']  name_list.remove('Rose')  # 结果:['Tom', 'Lily'] print(name_list) 
  • clear():清空列表
name_list = ['Tom', 'Lily', 'Rose']  name_list.clear() print(name_list) # 结果: [] 

2.4 修改

  • 修改指定下标数据
name_list = ['Tom', 'Lily', 'Rose']  name_list[0] = 'aaa'  # 结果:['aaa', 'Lily', 'Rose'] print(name_list) 
  • 逆置:reverse()
num_list = [1, 5, 2, 3, 6, 8]  num_list.reverse()  # 结果:[8, 6, 3, 2, 5, 1] print(num_list) 
  • 排序:sort()
列表序列.sort( key=None, reverse=False) 
num_list = [1, 5, 2, 3, 6, 8]  num_list.sort()  # 结果:[1, 2, 3, 5, 6, 8] print(num_list) 

注意:reverse表示排序规则,reverse = True 降序, reverse = False 升序(默认)

2.5 复制

  • 函数:copy()
name_list = ['Tom', 'Lily', 'Rose']  name_li2 = name_list.copy()  # 结果:['Tom', 'Lily', 'Rose'] print(name_li2) 

3. 列表的循环遍历

需求:依次打印列表中的各个数据。

3.1 while

name_list = ['Tom', 'Lily', 'Rose']  i = 0 while i < len(name_list):     print(name_list[i])     i += 1 

3.2 for

name_list = ['Tom', 'Lily', 'Rose']  for i in name_list:     print(i) 

4. 列表嵌套

所谓列表嵌套指的就是一个列表里面包含了其他的子列表。

应用场景:要存储班级一、二、三三个班级学生姓名,且每个班级的学生姓名在一个列表。

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']] 

思考: 如何查找到数据”李四”?

# 第一步:按下标查找到李四所在的列表 print(name_list[2])  # 第二步:从李四所在的列表里面,再按下标找到数据李四 print(name_list[2][1]) 

十六、元组

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

1. 定义元组

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

# 多个数据元组 t1 = (10, 20, 30)  # 单个数据元组 t2 = (10,) 

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

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

2. 元组的常见操作

元组数据不支持修改,只支持查找,具体如下:

  • 按下标查找数据
tuple1 = ('aa', 'bb', 'cc', 'bb') print(tuple1[0])  # aa 
  • index():查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb') print(tuple1.index('aa'))  # 0 
  • count():统计某个数据在当前元组出现的次数。
tuple1 = ('aa', 'bb', 'cc', 'bb') print(tuple1.count('bb'))  # 2 
  • len():统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb') print(len(tuple1))  # 4 

3. 元组的注意事项

元组内的直接数据如果修改则立即报错。

tuple1 = ('aa', 'bb', 'cc', 'bb') tuple1[0] = 'aaa' 

但是如果元组里面有列表,修改列表里面的数据则是支持的,故自觉很重要。

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30) print(tuple2[2])  # 访问到列表  # 结果:(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30) tuple2[2][0] = 'aaaaa' print(tuple2) 

十七、字典

字典里面的数据是以“键值对”形式出现,字典数据和数据顺序没有关系,即字典不支持下标,后期无论数据如何变化,只需要按照对应的键的名字查找数据即可。

1. 创建字典的语法

字典特点:

  • 符号为大括号
  • 数据为键值对形式出现
  • 各个键值对之间用逗号隔开
# 有数据字典 dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}  # 空字典 dict2 = {}  dict3 = dict() 

注意:一般称冒号前面的为键(key),简称k;冒号后面的为值(value),简称v。

2. 字典常见操作

2.1 增

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

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

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}  dict1['name'] = 'Rose' # 结果:{'name': 'Rose', 'age': 20, 'gender': '男'} print(dict1)  dict1['id'] = 110  # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110} print(dict1) 

注意:字典为可变类型。

2.2 删

  • del() / del:删除字典或删除字典中指定键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}  del dict1['gender'] # 结果:{'name': 'Tom', 'age': 20} print(dict1) 
  • clear():清空字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}  dict1.clear() print(dict1)  # {} 

2.3 改

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

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

2.4 查

  1. key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1['name'])  # Tom print(dict1['id'])  # 报错 

如果当前查找的key存在,则返回对应的值;否则则报错。

  1. 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 
  1. keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.keys())  # dict_keys(['name', 'age', 'gender']) 
  1. values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.values())  # dict_values(['Tom', 20, '男']) 
  1. items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')]) 

3. 字典的循环遍历

3.1 遍历字典的key

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

3.2 遍历字典的value

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

3.3 遍历字典的元素

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

3.4 遍历字典的键值对

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

十八、集合

集合具有确定性,无序性和去重性。

1. 创建集合

创建集合使用{}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 

特点:

  1. 集合可以去掉重复数据;
  2. 集合数据是无序的,故不支持下标。

2. 集合常见操作方法

2.1 增加数据

  • add()
s1 = {10, 20} s1.add(100) s1.add(10) print(s1)  # {100, 10, 20} 

因为集合有去重功能,所以,当向集合内追加的数据是当前集合已有数据的话,则不进行任何操作。

  • update(), 追加的数据是序列。
s1 = {10, 20} # s1.update(100)  # 报错 s1.update([100, 200]) s1.update('abc') print(s1)   # {'a', 100, 200, 10, 'b', 'c', 20} 

2.2 删除数据

  • remove(),删除集合中的指定数据,如果数据不存在则报错。
s1 = {10, 20}  s1.remove(10) print(s1)  s1.remove(10)  # 报错 print(s1) 
  • discard(),删除集合中的指定数据,如果数据不存在也不会报错。
s1 = {10, 20}  s1.discard(10) print(s1)  s1.discard(10) print(s1) 
  • pop(),随机删除集合中的某个数据,并返回这个数据。
s1 = {10, 20, 30, 40, 50}  del_num = s1.pop() print(del_num) print(s1) 

2.3 查找数据

  • in:判断数据在集合序列
  • not in:判断数据不在集合序列
s1 = {10, 20, 30, 40, 50}  print(10 in s1) print(10 not in s1) 

十九、公共操作

1. 运算符

运算符 描述 支持的容器类型
+ 合并 字符串、列表、元组
* 复制 字符串、列表、元组
in 元素是否存在 字符串、列表、元组、字典
not in 元素是否不存在 字符串、列表、元组、字典

1.1 +

# 1. 字符串  str1 = 'aa' str2 = 'bb' str3 = str1 + str2 print(str3)  # aabb   # 2. 列表  list1 = [1, 2] list2 = [10, 20] list3 = list1 + list2 print(list3)  # [1, 2, 10, 20]  # 3. 元组  t1 = (1, 2) t2 = (10, 20) t3 = t1 + t2 print(t3)  # (10, 20, 100, 200) 

1.2 *

# 1. 字符串 print('-' * 10)  # ----------  # 2. 列表 list1 = ['hello'] print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']  # 3. 元组 t1 = ('world',) print(t1 * 4)  # ('world', 'world', 'world', 'world') 

1.3 in或not in

# 1. 字符串 print('a' in 'abcd')  # True print('a' not in 'abcd')  # False  # 2. 列表 list1 = ['a', 'b', 'c', 'd'] print('a' in list1)  # True print('a' not in list1)  # False  # 3. 元组 t1 = ('a', 'b', 'c', 'd') print('aa' in t1)  # False print('aa' not in t1)  # True 

2. 公共方法

函数 描述
len() 计算容器中元素个数
del 或 del() 删除
max() 返回容器中元素最大值
min() 返回容器中元素最小值
range(start, end, step) 生成从start到end的数字,步长为 step,供for循环使用
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

2.1 len()

# 1. 字符串 str1 = 'abcdefg' print(len(str1))  # 7  # 2. 列表 list1 = [10, 20, 30, 40] print(len(list1))  # 4  # 3. 元组 t1 = (10, 20, 30, 40, 50) print(len(t1))  # 5  # 4. 集合 s1 = {10, 20, 30} print(len(s1))  # 3  # 5. 字典 dict1 = {'name': 'Rose', 'age': 18} print(len(dict1))  # 2 

2.2 del()

# 1. 字符串 str1 = 'abcdefg' del str1 print(str1)  # 2. 列表 list1 = [10, 20, 30, 40] del(list1[0]) print(list1)  # [20, 30, 40] 

2.3 max()

# 1. 字符串 str1 = 'abcdefg' print(max(str1))  # g  # 2. 列表 list1 = [10, 20, 30, 40] print(max(list1))  # 40 

2.4 min()

# 1. 字符串 str1 = 'abcdefg' print(min(str1))  # a  # 2. 列表 list1 = [10, 20, 30, 40] print(min(list1))  # 10 

2.5 range()

# 1 2 3 4 5 6 7 8 9 for i in range(1, 10, 1):     print(i)  # 1 3 5 7 9 for i in range(1, 10, 2):     print(i)  # 0 1 2 3 4 5 6 7 8 9 for i in range(10):     print(i) 

注意:range()生成的序列不包含end数字。

2.6 enumerate()

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

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

list1 = ['a', 'b', 'c', 'd', 'e']  for i in enumerate(list1):     print(i)  for index, char in enumerate(list1, start=1):     print(f'下标是{index}, 对应的字符是{char}') 

深入浅出Python——Python基础语法全解

3. 容器类型转换

3.1 tuple()

作用:将某个序列转换成元组。

list1 = [10, 20, 30, 40, 50, 20] s1 = {100, 200, 300, 400, 500}  print(tuple(list1)) print(tuple(s1)) 

3.2 list()

作用:将某个序列转换成列表。

t1 = ('a', 'b', 'c', 'd', 'e') s1 = {100, 200, 300, 400, 500}  print(list(t1)) print(list(s1)) 

3.3 set()

作用:将某个序列转换成集合。

list1 = [10, 20, 30, 40, 50, 20] t1 = ('a', 'b', 'c', 'd', 'e')  print(set(list1)) print(set(t1)) 

注意:

  1. 集合可以快速完成列表去重。
  2. 集合不支持下标。

二十、推导式

1. 列表推导式

作用:用一个表达式创建一个有规律的列表或控制一个有规律列表。

列表推导式又叫列表生成式。

1.1 快速体验

需求:创建一个0-10的列表。

  • while循环实现
# 1. 准备一个空列表 list1 = []  # 2. 书写循环,依次追加数字到空列表list1中 i = 0 while i < 10:     list1.append(i)     i += 1  print(list1) 
  • for循环实现
list1 = [] for i in range(10):     list1.append(i)  print(list1) 
  • 列表推导式实现
list1 = [i for i in range(10)] print(list1) 

1.2 带if的列表推导式

需求:创建0-10的偶数列表

  • 方法一:range()步长实现
list1 = [i for i in range(0, 10, 2)] print(list1) 
  • 方法二:if实现
list1 = [i for i in range(10) if i % 2 == 0] print(list1) 

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

需求:创建列表如下:

[(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) 

2. 字典推导式

字典推导式作用:快速合并列表为字典或提取字典中目标数据。

2.1 快速体验

  1. 创建一个字典:字典key是1-5数字,value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5)} print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16} 
  1. 将两个列表合并为一个字典
list1 = ['name', 'age', 'gender'] list2 = ['Tom', 20, 'man']  dict1 = {list1[i]: list2[i] for i in range(len(list1))} print(dict1) 
  1. 提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}  # 需求:提取上述电脑数量大于等于200的字典数据 count1 = {key: value for key, value in counts.items() if value >= 200} print(count1)  # {'MBP': 268, 'DELL': 201} 

3. 集合推导式

需求:创建一个集合,数据为下方列表的2次方。

list1 = [1, 1, 2] 

代码如下:

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

注意:集合有数据去重功能。

补充:接下来的Python高级语法:函数、文件操作、面向对象、模块、包、异常等知识,我将陆续更新在自己的博客之中。如果本博文的知识能帮助到您的Python学习,本博主实属荣幸。更多后续知识,请关注博主,方便您第一时间查看,谢谢!

深入浅出Python——Python基础语法全解

本文地址https://www.b2bchain.cn/7917.html

赞(0) 打赏
部分文章转自网络,侵权联系删除b2bchain区块链学习技术社区 » 深入浅出Python——Python基础语法全解的讲解
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

b2b链

联系我们联系我们