Python基础语法

最新推荐文章于 2024-10-18 22:54:57 发布

原创最新推荐文章于 2024-10-18 22:54:57 发布 · 427 阅读

0 ·

CC 4.0 BY-SA版权

Python学习专栏收录该内容

3 篇文章

订阅专栏

Python基础语法

01 变量的基本使用
02 注释
03 运算符
04 判断语句（if）
- 4.1 elif 语句
- 4.2 if 的嵌套
05 循环
06 函数基础
07 高级变量类型
08 随机数的处理
09 小技巧

01 变量的基本使用

1.1 变量的定义

在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
等号（=）用来给变量赋值 python 变量名 = 值
- = 左边是一个变量名
- = 右边是存储在变量中的值
变量定义之后，后续就可以直接使用了
在内存中创建一个变量，会包括：
○变量的名称
○变量保存的数据
○ 变量存储数据的类型
○变量的地址（标示）
注意：利用单步调试可以确认变量中保存数据的类型

1.2 变量的命名

1.2.1 标识符和关键字

标识符

标示符就是程序员定义的变量名、函数名
名字需要有见名知义的效果
标识符的命名规则
○标示符可以由字母、下划线和数字组成
○不能以数字开头
○不能与关键字重名
注意 Python 中的标识符是区分大小写的

关键字

关键字就是在Python内部已经使用的标识符
关键字具有特殊的功能和含义
开发者不允许定义和关键字相同的名字的标示符
通过以下命令可以查看 Python 中的关键字
import keyword
print(keyword.kwlist)

1.2.2 变量的命名规则

命名规则可以被视为一种惯例，并无绝对与强制目的是为了增加代码的识别和可读性
在定义变量时，为了保证代码格式，= 的左右应该各保留一个空格
在 Python 中，如果变量名需要由二个或多个单词组成时，可以按照以下方式命名
- 每个单词都使用小写字母
- 单词与单词之间使用 _下划线 连接
  例如：first_name、last_name、qq_number、qq_password
驼峰命名法：当变量名是由二个或多个单词组成时，还可以利用驼峰命名法来命名
- 小驼峰式命名法：第一个单词以小写字母开始，后续单词的首字母大写
  例如：firstName、lastName
- 大驼峰式命名法：每一个单词的首字母都采用大写字母
  例如：FirstName、LastName、CamelCase

1.3 变量的类型

在 Python 中定义变量是不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为数字型和非数字型
- 数字型
  ○整型 (int)
  ○浮点型（float）
  ○布尔型（bool）
  - 真 True 非 0 数 —— 非零即真
  - 假 False 0
  ○复数型 (complex) ：主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
- 非数字型
  ○字符串
  ○列表
  ○元组
  ○字典
提示：在 Python 2.x 中，整数根据保存数值的长度还分为： int（整数）long（长整数）
使用 type 函数可以查看一个变量的类型type(name)

1.4 字符串中的转义字符

\t 在控制台输出一个制表符，协助在输出文本时垂直方向保持对齐
\n 在控制台输出一个换行符
制表符的功能是在不使用表格的情况下在垂直方向按列对齐文本

转义字符	描述
\	反斜杠符号
’	单引号
"	双引号
\n	换行
\t	横向制表符
\r	回车

在这里插入图片描述

1.5 不同类型变量之间的计算

① 数字型变量之间可以直接计算

在 Python 中，两个数字型变量是可以直接进行算数运算的
如果变量是 bool 型，在计算时
○True 对应的数字是 1
○False 对应的数字是 0

② 字符串变量之间使用 + 拼接字符串
在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

③ 字符串变量可以和整数使用 * 重复拼接相同的字符串

④ 数字型变量和字符串之间不能进行其他计算

1.6 变量的输入

所谓输入，就是用代码获取用户通过键盘输入的信息
在 Python 中，如果要获取用户在键盘上的输入信息，需要使用到 input 函数
字符串变量 = input("提示信息：")
注意：用户输入的任何内容 Python 都认为是一个字符串

类型转换函数

函数	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数

在这里插入图片描述

1.7 print函数

在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行
如果不希望末尾增加换行，可以在 print 函数输出内容的后面增加 , end=""
其中 "" 中间可以指定 print 函数输出内容之后，继续希望显示的内容

1.8 变量的格式化输出

在 Python 中可以使用 print 函数将信息输出到控制台
如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符
% 被称为格式化操作符，专门用于处理字符串中的格式
○包含 % 的字符串，被称为格式化字符串
○% 和不同的字符连用，不同类型的数据需要使用不同的格式化字符

格式化字符	含义
%s	字符串
%d	有符号十进制整数，`%06d` 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，`%.2f` 表示小数点后只显示两位，四舍五入
%%	输出 %

语法格式如下：
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))

在这里插入图片描述

1.9 变量进阶

1.9.1 变量的引用

变量和数据都是保存在内存中的
在 Python 中函数的参数传递以及返回值都是靠引用传递的

引用的概念

在 Python 中

变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址
变量中记录数据的地址，就叫做引用
使用 id() 函数可以查看变量中保存数据所在的内存地址
注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用
- 变量不再对之前的数据引用
- 变量改为对新赋值的数据引用

函数的参数和返回值的传递

在Python中，函数的实参/返回值都是是靠引用来传递来的
在这里插入图片描述

1.9.2 可变和不可变类型

不可变类型，内存中的数据不允许被修改：
- 数字类型 int, bool, float, complex, long(2.x)
- 字符串 str
- 元组 tuple
可变类型，内存中的数据可以被修改：
- 列表 list
- 字典 dict
可变类型的数据变化，是通过方法来实现的，通过方法来改变数据不会使内存地址发生变化
如果给一个可变类型的变量，赋值了一个新的数据，引用会修改，地址会变化
注意：字典的 key 只能使用不可变类型的数据

哈希(hash)

Python 中内置有一个名字叫做 hash(o) 的函数
- 接收一个不可变类型的数据作为参数
- 返回结果是一个整数
哈希是一种算法，其作用就是提取数据的特征码（指纹）
- 相同的内容得到相同的结果
- 不同的内容得到不同的结果
在 Python 中，设置字典的键值对时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查
- 键值对的 key 必须是不可变类型数据
- 键值对的 value 可以是任意类型的数据

1.9.3 局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数内部使用
全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量

局部变量

局部变量是在函数内部定义的变量，只能在函数内部使用
函数执行结束后，函数内部的局部变量，会被系统回收
不同的函数，可以定义相同的名字的局部变量，但是彼此之间不会产生影响
局部变量的作用：在函数内部使用，临时保存函数内部需要使用的数据
局部变量的生命周期
- 所谓生命周期就是变量从被创建到被系统回收的过程
- 局部变量在函数执行时才会被创建
- 函数执行结束后局部变量被系统回收
- 局部变量在生命周期内，可以用来存储函数内部临时使用到的数据

全局变量

全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
注意：函数执行时，需要处理变量时会：
- 首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
- 如果没有，查找函数外部是否存在指定名称的全局变量，如果有，直接使用
- 如果还没有，程序报错！

1) 函数不能直接修改全局变量的引用

全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量
在函数内部，可以通过全局变量的引用获取对应的数据
但是，不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值
注意：只是在函数内部定义了一个局部变量而已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值

在这里插入图片描述
2) 在函数内部修改全局变量的值

如果在函数中需要修改全局变量，需要使用 global 进行声明

3) 全局变量定义的位置
为了保证所有的函数都能够正确使用到全局变量，应该将全局变量定义在其他函数的上方
注意：由于全局变量，是在调用函数之后才定义的，在执行函数时，变量还没有定义，所以程序会报错！
代码结构示意图如下

4) 全局变量命名的建议
为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求，例如：全局变量名前应该增加 g_ 或者 gl_ 的前缀

02 注释

2.1 单行注释

以 # 开头，# 右边的所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用
为了保证代码的可读性，# 后面建议先添加一个空格，然后再编写相应的说明文字
在程序开发时，同样可以使用 # 在代码的后面（旁边）增加说明性的文字，需要注意的是，为了保证代码的可读性，注释和代码之间至少要有两个空格

2.2 多行注释

若编写的注释信息很多，一行无法显示，就可以使用多行注释
要在 Python 程序中使用多行注释，可以用一对连续的三个引号(单引号和双引号都可以)""" """或''' '''
注释快捷键，选中多行，按ctrl+/

在这里插入图片描述

2.3 代码规范

注释不是越多越好，对于一目了然的代码，不需要添加注释
对于复杂的操作，应该在操作开始前写上若干行注释
对于不是一目了然的代码，应在其行尾添加注释（为了提高可读性，注释应该至少离开代码 2 个空格）
绝不要描述代码，假设阅读代码的人比你更懂 Python，他只是不知道你的代码要做什么
官方代码规范

03 运算符

3.1 算数运算符

算数运算符是运算符的一种
是完成基本的算术运算使用的符号，用来处理四则运算

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4（向下取整)
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
算数运算符的优先级
- 先乘除后加减
- 同级运算符是从左至右计算
- 可以使用 () 调整计算的优先级
- 以下表格的算数优先级由高到最低顺序排列

运算符	描述
**	幂 (最高优先级)
* / % //	乘、除、取余数、取整除
+ -	加法、减法

3.2 比较（关系）运算符

运算符	描述
==	检查两个操作数的值是否相等，如果是，则条件成立，返回 True
!=	检查两个操作数的值是否不相等，如果是，则条件成立，返回 True
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立，返回 True
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立，返回 True
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立，返回 True
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立，返回 True

Python 2.x 中判断不等于还可以使用 <> 运算符
!= 在 Python 2.x 中同样可以用来判断不等于
所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。

3.3 赋值运算符

在 Python 中，使用 = 可以给变量赋值
在算术运算时，为了简化代码的编写，Python 还提供了一系列的与算术运算符对应的赋值运算符
注意：赋值运算符中间不能使用空格

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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

3.4 逻辑运算符

运算符	逻辑表达式	描述
and	x and y	布尔"与" - 只有 x 和 y 的值都为 True，才会返回 True
or	x or y	布尔"或" - 只要 x 或者 y 有一个值为 True，就返回 True，只有 x 和 y 的值都为 False，才会返回 False
not	not x	布尔"非" - 如果 x 为 True，返回 False，如果 x 为 False，返回 True

① and
条件1 and 条件2

与／并且
两个条件同时满足，返回 True
只要有一个不满足，就返回 False

条件 1	条件 2	条件1 and 条件2
成立	成立	成立
成立	不成立	不成立
不成立	成立	不成立
不成立	不成立	不成立

② or
条件1 or 条件2

或／或者
两个条件只要有一个满足，返回 True
两个条件都不满足，返回 False

条件 1	条件 2	条件1 or 条件2
成立	成立	成立
成立	不成立	成立
不成立	成立	成立
不成立	不成立	不成立

③ not
not 条件

非／不是

条件	not 条件
成立	不成立
不成立	成立

3.5 位运算符

运算符	描述
`&`	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
`\|`	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
`^`	按位异或运算符：当两对应的二进位相异时，结果为1
`~`	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1
`<<`	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0
`>>`	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

3.6 成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	x 在 y 序列中 , 如果 x 在 y 序列中返回 True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

3.7 身份运算符

运算符	描述	实例
`is`	`is` 是判断两个标识符是不是引用自一个对象	`x is y`, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
`is not`	`is not` 是判断两个标识符是不是引用自不同对象	`x is not y` ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False

id() 函数用于获取对象内存地址

3.8 运算符优先级

运算符	描述
`**`	指数 (最高优先级)
`~` `+` `-`	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
`*` `/` `%` `//`	乘，除，取模和取整除
`+` `-`	加法减法
`>>` `<<`	右移，左移运算符
`&`	位 ‘AND’
`^ \|`	位运算符
`<=` `<` `>` `>=`	比较运算符
`<` `>` `==` `!=`	等于运算符
`=` `%=` `/=` `//=` `-=` `+=` `=` `*=`	赋值运算符
`is` `is not`	身份运算符
`in` `not in`	成员运算符
`and` `or not`	逻辑运算符

04 判断语句（if）

在 Python 中，if 语句就是用来进行判断的，格式如下：

 if 要判断的条件:
     条件成立时，要做的事情
 else: 
     条件不成立时，要做的事情

注意：

代码的缩进为一个tab键，或者 4 个空格 —— 建议使用空格
在 Python 开发中，Tab和空格不要混用！
if 和 else 语句以及各自的缩进部分共同是一个完整的代码块
在程序开发中，通常在判断条件时，会需要同时判断多个条件
只有多个条件都满足，才能够执行后续代码，这个时候需要使用到逻辑运算符
逻辑运算符可以把多个条件按照逻辑进行连接，变成更复杂的条件
Python 中的逻辑运算符包括：与 and／或 or／非 not 三种

4.1 elif 语句

判断条件时，如果希望再增加一些条件，条件不同，需要执行的代码也不同时，就可以使用 elif
语法格式如下：

if 条件1: 
    条件1满足执行的代码 
elif 条件2: 
    条件2满足时，执行的代码 
elif 条件3: 
    条件3满足时，执行的代码
else: 
    以上条件都不满足时，执行的代码

注意：

elif 和 else 都必须和 if 联合使用，而不能单独使用
可以将 if、elif 和 else 以及各自缩进的代码，看成一个完整的代码块

4.2 if 的嵌套

如果希望在条件成立的执行语句中再增加条件判断，就可以使用 if 的嵌套
if 的嵌套的应用场景就是：在之前条件满足的前提下，再增加额外的判断
if 的嵌套的语法格式，除了缩进之外和之前的没有区别
语法格式如下：

if 条件 1 
    条件1需要执行的代码
    ...
if 条件1基础上的条件2:
    条件2满足时，执行的代码
         ……    
 # 条件2不满足的处理
else:
    条件2不满足时，执行的代码
 # 条件1不满足时执行的处理
else:
    条件1不满足时执行的代码

在这里插入图片描述

05 循环

在程序开发中，一共有三种流程方式：
- 顺序 —— 从上向下，顺序执行代码
- 分支 —— 根据条件判断，决定执行代码的分支
- 循环 —— 让特定代码重复执行

在这里插入图片描述

5.1 while

循环的作用就是让指定的代码重复的执行
while循环最常用的应用场景就是让执行的代码按照指定的次数重复执行
while语句的基本语法

# 初始条件设置---通常是重复执行的计数器
i = 1
while 条件(判断计数器是否达到目标次数):
   条件满足时执行的代码
   ...
   处理条件(计数器+1)

注意： while 语句以及缩进部分是一个 完整的代码块
死循环： 由于程序员的原因，忘记在循环内部修改循环的判断条件，导致循环持续执行，程序无法终止！
Python中计数方法习惯从0开始

5.2 循环计算

在程序开发中，通常会遇到利用循环重复计算的需求遇到这种需求，可以：
- 在 while 上方定义一个变量，用于存放最终计算结果
- 在循环体内部，每次循环都用最新的计算结果，更新之前定义的变量需求

5.3 循环体内部使用的关键字

break 和 continue 是专门在循环中使用的关键字
break 某一条件满足时，退出循环，不再执行后续重复的代码
continue 某一条件满足时，不执行后续重复的代码，进入下一次循环
break 和 continue 只针对当前所在循环有效

break

在循环过程中，如果某一个条件满足后，不再希望循环继续执行，可以使用 break 退出循环

continue

在循环过程中，如果某一个条件满足后，不希望执行循环代码，但是又不希望退出循环，可以使用 continue
也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行

在这里插入图片描述

5.4 while 循环嵌套

while 嵌套就是：while 里面还有 while

while 条件 1: 
    条件满足时，做的事情1 
    条件满足时，做的事情2 
    条件满足时，做的事情3 
    ...(省略)...
    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...
        处理条件 2

    处理条件 1

在这里插入图片描述

06 函数基础

所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用
函数的使用包含两个步骤：
- 1、定义函数 —— 封装独立的功能
- 2、调用函数 —— 享受封装的成果
函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用

6.1 函数的定义

定义函数的格式如下：

 def 函数名():
	函数封装的代码
	……

def 是英文 define 的缩写
函数名称应该能够表达函数封装代码的功能，方便后续的调用
函数名称的命名应该符合标识符的命名规则
- 可以由字母、下划线和数字组成
- 不能以数字开头
- 不能与关键字重名

6.2 函数的调用

定义好函数之后，这表示这个函数封装了一段代码而已，如果不主动调用函数，函数是不会主动执行的
定义函数要在调用函数前，否则会报错，有严格的顺序要求，否则会提示函数未定义
调用函数很简单的，通过 函数名() 即可完成对函数的调用

6.3 关键字、函数和方法的区别

关键字是 Python 内置的、具有特殊意义的标识符，关键字后面不需要使用括号
函数封装了独立功能，可以直接调用，函数需要死记硬背
方法和函数类似，同样是封装了独立的功能
方法需要通过对象来调用，表示针对这个对象要做的操作，在变量后面输入 .，然后选择针对这个变量要执行的操作，记忆起来比函数要简单很多
对象.方法名(参数)

6.4 函数的文档注释

在开发中，如果希望给函数添加注释，应该在定义函数的下方，使用连续的三对引号 在连续的三对引号之间编写对函数的说明文字
在函数调用位置，使用快捷键 CTRL + Q 可以查看函数的说明信息
-注意：因为函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留两个空行

6.5 函数的参数

6.5.1 函数参数的使用

在函数名的后面的小括号内部填写参数
多个参数之间使用 , 分隔

6.5.2 形参和实参

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

6.6 函数的返回值

在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用 return 关键字可以返回结果调用函数一方，可以使用变量来接收函数的返回结果
注意：return 表示返回，后续的代码都不会被执行

6.7 函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是函数嵌套调用
如果函数 test2 中，调用了另外一个函数 test1
- 那么执行到调用 test1 函数时，会先把函数 test1 中的任务都执行完
- 才会回到 test2 中调用函数 test1 的位置，继续执行后续的代码

6.8 给函数增加文档注释

定义完函数后用多行注释可以给函数的具体参数和返回值进行注释

6.9 使用模块中的函数

模块是 Python 程序架构的一个核心概念
模块就好比是工具包，要想使用这个工具包中的工具，就需要通过 import 导入这个模块 每一个以扩展名 py 结尾的 Python源代码文件都是一个模块
在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具
可以在一个 Python 文件中定义变量或者函数，然后在另外一个文件中使用 import 导入这个模块，导入之后，就可以使用模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数
模块名也是一个标识符
- 标示符可以由 字母、下划线和数字组成不能以数字开头
- 不能与关键字重名
注意：如果在给 Python 文件起名时，以数字开头是无法在 PyCharm 中通过导入这个模块的

在这里插入图片描述

6.10 Pyc文件

Python在解释源程序时是分成两个步骤的
- 首先处理源代码，编译生成一个二进制字节码
- 再对字节码进行处理，才会生成 CPU 能够识别的机器码
有了模块的字节码文件之后，下一次运行程序时，如果在上次保存字节码之后 没有修改过源代码，Python 将会加载 .pyc文件并跳过编译这个步骤
当 Python 重编译时，它会自动检查源文件和字节码文件的时间戳
如果你又修改了源代码，下次程序运行时，字节码将自动重新创建

6.11 函数进阶

6.11.1 函数参数和返回值的作用

函数根据有没有参数以及有没有返回值，可以相互组合，一共有 4 种组合形式
- 1.无参数，无返回值
- 2.无参数，有返回值
- 3.有参数，无返回值
- 4.有参数，有返回值

在这里插入图片描述

定义函数时，是否接收参数，或者是否返回结果，是根据实际的功能需求来决定的！
- 1.如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
- 2.如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值

无参数，无返回值

此类函数，不接收参数，也没有返回值，应用场景如下：

只是单纯地做一件事情，例如显示菜单
在函数内部针对全局变量进行操作，例如：新建名片，最终结果记录在全局变量中

注意：

如果全局变量的数据类型是一个可变类型，在函数内部可以使用方法修改全局变量的内容 —— 变量的引用不会改变
在函数内部，使用赋值语句才会修改变量的引用

无参数，有返回值

此类函数，不接收参数，但是有返回值，应用场景如下：

采集数据，例如温度计，返回结果就是当前的温度，而不需要传递任何的参数

有参数，无返回值

此类函数，接收参数，没有返回值，应用场景如下：

函数内部的代码保持不变，针对不同的参数处理不同的数据，例如名片管理系统针对找到的名片做修改、删除操作

有参数，有返回值

此类函数，接收参数，同时有返回值，应用场景如下：

函数内部的代码保持不变，针对不同的参数处理不同的数据，并且返回期望的处理结果，例如名片管理系统使用字典默认值和提示信息提示用户输入内容
- 如果输入，返回输入内容
- 如果没有输入，返回字典默认值

6.11.2 函数的返回值进阶

在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用 return 关键字可以返回结果
调用函数一方，可以使用变量来接收函数的返回结果
在 Python 中，可以将一个元组使用赋值语句同时赋值给多个变量
注意：变量的数量需要和元组中的元素数量保持一致
如果一个函数返回的是元组，括号可以省略
交换两个变量的值

在这里插入图片描述

6.11.3 函数的参数进阶

不可变和可变的参数

无论传递的参数是可变还是不可变 ，只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

在这里插入图片描述

如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部的数据
在 python 中，列表变量调用 += 本质上是在执行列表变量的 extend 方法，不会修改变量的引用

缺省参数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做 缺省参数
调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
指定函数的缺省参数:在参数后使用赋值语句，可以指定参数的缺省值

提示

缺省参数，需要使用最常见的值作为默认值！
如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！

缺省参数的注意事项：

1) 缺省参数的定义位置

必须保证带有默认值的缺省参数在参数列表末尾
所以，以下定义是错误的！ python
def print_info(name, gender=True, title):

2) 调用带有多个缺省参数的函数

在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！

在这里插入图片描述

多值参数

定义支持多值参数的函数

有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数
python 中有两种多值参数：
- 参数名前增加一个 * 可以接收元组
- 参数名前增加两个 * 可以接收字典
一般在给多值参数命名时，习惯使用以下两个名字
- *args —— 存放 元组参数，前面有一个 *
- **kwargs —— 存放字典参数，前面有两个 *
args是arguments` 的缩写，有变量的含义
kw 是 keyword 的缩写，kwargs 可以记忆键值对参数

元组和字典的拆包（知道）

在调用带有多值参数的函数时，如果希望：
- 将一个元组变量，直接传递给 args
- 将一个字典变量，直接传递给 kwargs
就可以使用拆包，简化参数的传递，拆包的方式是：
- 在元组变量前，增加 *
- 在字典变量前，增加 * *

在这里插入图片描述

6.11.4 函数的递归

递归函数的特点

函数调用自身的编程技巧称为递归
特点
- 一个函数内部调用自己
- 函数内部可以调用其他函数，当然在函数内部也可以调用自己
代码特点
- 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
- 当参数满足一个条件时，函数不再执行。这个非常重要，通常被称为递归的出口，否则会出现死循环！
提示：递归是一个编程技巧，在处理 不确定的循环条件时，格外的有用，例如：遍历整个文件目录的结构

07 高级变量类型

Python 中数据类型可以分为数字型和非数字型
数字型
- 整型 (int)
- 浮点型（float）
- 布尔型（bool）
  - 真 True 非 0 数 —— 非零即真
  - 假 False 0
- 复数型 (complex)：主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
非数字型
- 字符串
- 列表
- 元组
- 字典
在 Python 中，所有非数字型变量 都支持以下特点：

1.都是一个序列 sequence，也可以理解为容器
2.取值 []
3.遍历 for in
4.计算长度、最大/最小值、比较、删除
5.链接 + 和重复 *
6切片

7.1 列表（类似数组）

7.1.1 列表的定义

List（列表）是Python 中使用最频繁 的数据类型，在其他语言中通常叫做数组
专门用于存储一串信息
列表用 [] 定义，数据之间使用 , 分隔
列表的 索引从 0 开始
索引就是数据在列中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果超出索引范围，程序会报错

7.1.2 列表的常用操作

在 ipython3 中定义一个列表，例如：name_list = []
输入 name_list. 按下 TAB 键，ipython 会提示列表能够使用的方法如下：

序号	分类	关键字 / 函数 / 方法	说明
1	增加	列表.insert(索引, 数据)	在指定位置插入数据
		列表.append(数据)	在末尾追加数据
		列表.extend(列表2)	将列表2 的数据追加到列表
2	修改	列表[索引] = 数据	修改指定索引的数据
3	删除	del 列表[索引]	删除指定索引的数据
		列表.remove[数据]	删除第一个出现的指定数据
		列表.pop	删除末尾数据
		列表.pop(索引)	删除指定索引数据
		列表.clear	清空列表
4	统计	len(列表)	列表长度
		列表.count(数据)	数据在列表中出现的次数
5	排序	列表.sort()	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse()	逆序、反转

方法演示
① 取值

② 取索引

③ 修改

④ 增加

⑤ 删除
使用关键字del(delete)删除列表元素
del 关键字本质上是用来将一个变量从内存中删除的
如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了
在日常开发中，要从列表删除数据，建议使用列表提供的方法

在这里插入图片描述

⑥ 统计

⑦ 排序

7.1.3 列表的循环遍历

遍历就是从头到尾依次从列表中获取数据
在循环体内部针对每一个元素，执行相同的操作
在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历
使用 for 就能够实现迭代遍历

for 循环内部使用的变量 in 列表：
	循环内部针对列表元素进行操作

在这里插入图片描述

尽管 Python 的列表中可以存储不同类型的数据
但是在开发中，更多的应用场景是
- 列表存储相同类型的数据
- 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

7.2 元组

7.2.1 元组的定义

Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
- 元组表示多个元素组成的序列
- 元组在 Python 开发中，有特定的应用场景
用于存储一串信息，数据之间使用 , 分隔，通常保存不同类型数据
元组用 () 定义
元组的索引从 0 开始
索引就是数据在元组中的位置编号

7.2.2 元组的常用操作

① 定义元组
在这里插入图片描述
② 取值

③ 取索引

④ 统计计数

7.2.3 元组的循环遍历

取值就是从元组中获取存储在指定位置的数据
遍历就是从头到尾依次从元组中获取数据

for 循环内部使用的变量 in 元组：
  循环内部针对元组元素进行操作

在这里插入图片描述

在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典以及字符串
提示：在实际开发中，除非能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多
但是在开发中，元组的应用场景是：
- 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
- 格式字符串，格式化字符串后面的 () 本质上就是一个元组
- 让列表不可以被修改，以保护数据安全

7.2.4 元组和列表之间的转换

使用 list 函数可以把元组转换成列表
list(元组)
使用 tuple 函数可以把列表转换成元组
tuple(列表)

7.3 字典

7.3.1 字典的定义

dictionary（字典）是除列表以外 Python 之中最灵活的数据类型
字典同样可以用来存储多个数据，通常用于存储描述一个物体的相关信息
和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合
字典用 {} 定义
字典使用键值对存储数据，键值对之间使用 , 分隔
- 键 key 是索引
- 值 value 是数据
- 键和值之间使用 : 分隔
- 键必须是唯一的
- 值可以取任何数据类型，但键只能使用字符串、数字或元组

在这里插入图片描述

7.3.2 字典的常用操作

① 定义字典
在这里插入图片描述
② 取值

③ 增加/修改

④ 删除

⑤ 统计键值对数量

⑥ 合并字典

⑦ 清空字典

7.3.3 字典的循环遍历

遍历就是依次从字典中获取所有键值对

for 循环内部使用的key的变量 in 字典：
	循环内部针对字典元素进行操作

提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多
在开发中，更多的应用场景是：
- 使用多个键值对，存储描述一个物体的相关信息 —— 描述更复杂的数据信息
- 将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

7.4 字符串

7.4.1 字符串的定义

字符串就是一串字符，是编程语言中表示文本的数据类型
在 Python 中可以使用一对双引号 " 或者一对单引号 ' 定义一个字符串
虽然可以使用 \" 或者 \' 做字符串的转义，但是在实际开发中：
- 如果字符串内部需要使用 "，可以使用 ' 定义字符串
- 如果字符串内部需要使用 '，可以使用 " 定义字符串
可以使用索引获取一个字符串中指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历字符串中每一个字符
大多数编程语言都是用 " 来定义字符串

string = "Hello Python"
for c in string:
	print(c)

在这里插入图片描述

7.4.2 字符串的常用操作

在这里插入图片描述
1) 判断类型 - 9

方法	说明
string.isspace()	如果 string 中只包含空白字符(空格、\t制表符、\r回车、\n换行都属于空白字符)，则返回 True
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
string.isdigit()	如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

在这里插入图片描述

2) 查找和替换 - 7

方法	说明
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(oldstr, newstr, num=string.count(old))	把 string 中的 oldstr 替换成 newstr，如果 num 指定，则替换不超过 num 次

在这里插入图片描述

3) 大小写转换 - 5

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

4) 文本对齐 - 3

方法	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

在这里插入图片描述

5) 去除空白字符 - 3

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

在这里插入图片描述
6) 拆分和连接 - 5

方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格，返回一个列表
string.splitlines()	按照行(’\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq （列表）中所有的元素（的字符串表示）合并为一个新的字符串

在这里插入图片描述

7.4.3 字符串的切片

切片方法适用于字符串、列表、元组
- 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
- 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据

字符串[开始索引:结束索引:步长]

注意：

指定的区间属于左闭右开型 [开始索引, 结束索引) => 开始索引 <= 范围 < 结束索引。从起始位开始，到结束位的前一位结束（不包含结束位本身)
从头开始，开始索引数字可以省略，冒号不能省略
到末尾结束，结束索引数字可以省略，冒号不能省略
步长默认为 1，如果连续切片，数字和冒号都可以省略
索引的顺序和倒序
在 Python 中不仅支持顺序索引，同时还支持倒序索引
所谓倒序索引就是从右向左计算索引
最右边的索引值是 -1，依次递减

7.5 公共方法

Python 内置函数

Python 包含了以下内置函数：

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函数,可以利用比较运算符比较

注意：字符串比较符合以下规则： "0" < "A" < "a"

7.6 切片

描述	Python 表达式	结果	支持的数据类型
切片	“0123456789”[::-2]	“97531”	字符串、列表、元组

切片使用索引值来限定范围，从一个大的字符串中切出****小的字符串
列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
字典是一个无序的集合，是使用键值对保存数据，不能切片

7.7 运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[“Hi!”] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 3) < (2, 2, 3)	True	元素比较	字符串、列表、元组

在这里插入图片描述

注意：

in 在对字典操作时，判断的是字典的键
in 和 not in 被称为成员运算符
成员运算符:成员运算符用于测试序列中是否包含指定的成员

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	3 in (1, 2, 3) 返回 True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	3 not in (1, 2, 3) 返回 False

注意：在对字典操作时，判断的是字典的键

7.8 完整的 for 循环语法

在 Python 中完整的 for 循环的语法如下：

for 变量 in 集合:
	循环体代码
else: 
	没有通过 break 退出循环，循环结束后，会执行的代码

注意：只有for循环体遍历完成集合之后，才会执行else的代码，若for循环中使用break退出循环，则不会执行else的代码
应用场景
- 在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典
- 需求：要判断某一个字典中是否存在指定的值
  - 如果存在，提示并且退出循环
  - 如果不存在，在循环整体结束 后，希望得到一个统一的提示

08 随机数的处理

在 Python 中，要使用随机数，首先需要导入随机数的模块 —— “工具包”
import random
导入模块后，可以直接在模块名称后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b