1. 命名和循环

1.1 命名规则

项目：以数字加名称表示

1

01_python基础

文件：不能以数字开头，以字母、数字、下划线组合而成

1

py_01_python基础.py

1.2 格式化输出

以%表示

1
2
3

%s #字符串
%d #有符号十进制整数
%f #浮点数

1.3 循环

格式

1
2
3
4

while条件: 
	条件满足做的事情1
	条件满足做的事情2
	...省略...

1.4 break 和 continue

  • break:某一条件满足时，退出循环，不再执行后续代码
  • continue:某一条件满足时，不执行后续重复代码
  • 区别:break 退出整个循环，continue 结束本次循环，开始下次循环

如果使用 continue 需要首先确认是否需要对循环计数修改

2. 循环打印九九乘法表

通过 while 的嵌套实现简单的九九乘法表打印

2.1 思路

首先定义一个变量控制行，初始值为1，确定行的循环条件 再定义一个变量控制列，始值1，确定列的循环条件

2.2 代码

1
2
3
4
5
6
7
8

row = 1
while row <= 9:
    col = 1 
    while col <= row:
        print("%d * %d = %d" % (row, col, row*col), end="\t") 
        col += 1 
    print("") 
    row += 1

2.3 注意

print 函数有一个参数 end ，默认的值为\n，因此 print 输出内容后会默认在文本后增加换行，修改参数值可以添加特定内容

1
2

" , end=""" # 双引号内即为可以更换的特定内容
print("") # 单纯的换行

2.4 结果

1
2
3
4
5
6
7
8
9

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

2.5 转义字符

可以使用转义字符\对打印结果进行规范

1
2
3

\t # 输出文本时垂直方向保持对齐
\n # 换行
\" # 输出双引号

3. 函数

3.1 格式

1
2
3
4
5

def 函数名():

	封装代码

	......

注意

函数名不能以数字开头 不能与关键字重名

定义函数后只表示封装代码定义函数后只表示封装代码

如果不调用函数，函数不会执行

函数调用必须在定义函数之后，否则会报错

3.2 函数注释

  • 函数定义上方保留两个空行（包含注释）

  • 定义函数的下方，连续三个引号内部进行注释

  • 在调用函数的位置，使用ctrl+Q可快速查看

3.3 函数参数

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

示例

1
2
3
4
5

def sum_2_num(num1, num2):
    """两数字求和"""
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2,result))
sum_2_num(1, 2)

形参和实参

  • **形参：**定义函数时，小括号内的参数，用来接收参数，在函数内部作为变量使用

  • **实参：**调用函数时，小括号内的参数，用来把数据传递到函数内部

3.4 函数的返回值

  • 返回值是函数完成工作后，最后给调用者的一个结果
  • 在函数中使用 return 关键字返回结果
  • 调用函数的一方，可以使用变量接收函数的返回结果

示例

1
2
3
4
5
6

def sum_2_num(num1, num2):
    result = num2 + num2
    return result
# 使用变量接收函数调用的结果
sum_result = sum_2_num(10, 20)
print("计算结果：%d" % sum_result)

注意

注意:return 表示返回，后续的代码都不会被执行

3.5 函数的嵌套调用

  • 一个函数里又调用了另一个函数，就是嵌套调用

打印多条分割线

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

def print_line(char, times):
    """打印分割线"""
    print(char * times)


def print_lines(char, times):
    """打印多行分割线

    :param char:分割线使用的分割字符
    :param times:分割线重复次数
    """
    row = 0
    while row < 5:
        print_line(char, times)
        row += 1


print_lines("-", 50)

针对需求变化，要冷静思考，不要轻易更改已经完成的、能够正常执行的函数

4. 高级变量类型

  • 列表
  • 元组
  • 字典
  • 字符串

Python 中数据类型分为数字型和非数字型变量

非数字型变量可进行如下操作：

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

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

  • 关键字
    • 关键字是 Python 内置的具有特殊意义的标识符
    • 关键字不需要使用括号，函数和方法需要
    • Python 中有 33 个关键字
  • 函数
    • 函数封装了独立功能，可以直接调用
    • 函数需要死记硬背
  • 方法
    • 方法和函数类似，同样是封装了独立功能
    • 对象.方法名(参数)
    • 方法需要对象来调用，表示针对这个对象的操作

4.1 列表

  • List 是Python 中使用最频繁的，其他语言中通常叫数组

  • 用 [ ]定义，数据间用 ,分割

  • 列表的索引从 0 开始

    • 索引就是列表中的位置序号，又被称为下标

    从列表取值超出索引范围会报错

  • 取值：变量[索引]

列表常用方法

定义空的列表，如 name_list = []

输入 name_list. 按下 TAB 键，可以看到可用的方法

常用方法用途
索引.index取值和索引
增加.append列表末尾增加数据
.insert指定索引增加数据
.extend把另一个列表完整内容追加都列表末尾
删除.remove删除列表指定的出现的第一个数据
.pop默认删除列表最后一个元素
.clear清空列表
统计.count计算列表某一元素出现的次数
排序.sort升序/降序
.reverse逆序（反转）列表
  • 使用 del 关键字同样可以删除列表中的元素
  • 本质是将变量从内存中删除
  • 如果使用 del 关键字将变量从内存中删除，后续代码不能使用这个变量
  • 使用 len 关键字可以计算列表总的元素个数

循环遍历

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

for 循环内部使用的变量 in 列表:
    code

使用场景

  • 列表存储相同类型的数据

  • 通过迭代遍历，在循环体内部对每一个元素执行相同的操作

    Python 列表中可以存储不同类型的数据

4.2 元组

  • Tuple 与列表类似，不同之处在于元组的元素不能修改
    • 多个元素组成的序列
    • 在 Python 开发中，有特殊的应用场景
  • 用于存储一串信息，数据间用, 分隔
  • 元组用 () 定义，索引从 0 开始
  • 创建空元组: empty_tuple = ()
  • 当元组中只有一个元素时，需要在元素后加入,

元组常用操作

  • .index

  • .count

循环遍历

1
2

for 循环内部使用的变量 in 元组:
    code

  • 在 Python 中，可以使用 for 遍历所有非数字类型变量：列表、元组、字典、字符串

  • 在实际开发中，除非能够确认元组数据中的数据类型，否则针对元组的循环遍历需求并不是很多

应用场景

  • 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
  • 格式字符串，格式化字符串后的() 本质就是一个元组
  • 让列表不可被修改，保护数据安全

元组和列表转换

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

1

list(元组)

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

1

tuple(列表)

4.3 字典

  • dictionary 是除列表以外 Python 中最灵活的数据类型
  • 字典同样可以用来存储多个数据
    • 通常用于描述一个物体的相关信息

和列表的区别

  • 列表是有序的对象集合
  • 字典是无序的对象集合
  • 字典用 {} 定义
  • 字典使用 键值 存储数据，键值对儿之间用 ,隔开
    • 键 key 是索引
    • 值 value 是数据
    • 键和值之间使用 : 分隔
    • 键必须是唯一的
  • 值可以取任何数据类型，但键只能使用字符串、数字或元组
1
2
3
4
5
6

xiaoming = {"name": "小明",
            "age": 18,
            "gender": True,
            "height": 1.75,
            "weight": 75.5}
print(xiaoming)

使用 print 函数输出顺序和定义顺序通常不一样

基本使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

dict.keys() # 所有 key 列表
dict.values() # 所有 value 列表
dict.items() # 所有(key, value)元组列表

dict[key] # 从字典中取值，key 不存在会报错
dict.get(key) # 可以从字典中取值，key 不存在会报错

del dict[key] # 删除指定键值对，key 不存在会报错
dict.pop(key) # 删除指定键值对，key 不存在会报错
dict.popitem() # 随机删除一个键值对
dict.cleat # 清空字典

dict[key] = value # 如果 key 存在修改数据，不存在新建键值对
dict.setdefault(key, value) # 如果 key 存在修改数据，不存在新建键值对
dict.update(dict2) # 将字典2合并到字典，如果被合并的字典包含已存在的键                      值对，会覆盖原有的键值对

循环遍历

1
2
3

# k 是每一次循环中获取到的键值对的 key
for k in dict:
    code

应用场景

  • 使用多个键值对，存储描述一个物体的相关信息
  • 将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

4.4 字符串

  • 表示文本的数据类型
  • Python 中可以用一对双引号或者一对单引号定义字符串
  • 大多数编程语言使用双引号定义字符串
  • Python 中如果字符串内部需要使用双引号，定义字符串用单引号
  • 可以使用索引获得一个字符串中中指定位置的字符，索引从 0 开始
  • 也可以使用 for 循环遍历字符串中每一个字符

常用操作

  • len 函数
  • .count 方法
  • .index 方法

字符串方法

判断类型
方法说明
string.isspace()如果 string 中只包含空格，返回 True
string.isalnum()如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()如果 string 只包含数字则返回 True，全角数字
string.isdigit()如果 string 只包含数字则返回 True，全角数字、（1）、\u00b2 （unicode 字符）
string.isnumeric()如果 string 只包含数字则返回 True，全角数字、汉字数字
string.istitle()如果 string 是标题化的(每个标题的首字母大写)则返回 True
string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
  • decimal digit numeric 三个方法中
    • decimal 方法只包含数字
    • digit 还可包含 unicode 字符，如带括号的 1 （1）
    • numeric 方法还会包含中文数字，如：一
  • 一般使用 decimal 方法
查找和替换
方法说明
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(old_str, new_str, num=string.count(old))把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次
  • find 方法和 index 方法都可以查找指定字符串是否包含在字符串中，如果指定字符串不存在
    • find 方法返回 -1
    • index 方法会报错
  • replace 方法执行完成后会返回新的字符串，但不会修改原有字符串
大小写转换
方法说明
string.capitalize()把字符串的第一个字符大写
string.title()把字符串的每个单词首字母大写
string.lower()转换 string 中所有大写字符为小写
string.upper()转换 string 中所有小写字母为大写
string.swapcase()翻转 string 中的大小写
文本对齐
方法说明
string.ljust(width)返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)返回一个原字符居中，并使用空格填充至长度 width 的新字符串
去除空白字符
方法说明
string.lstrip()截掉 string 左边（开始）的空白字符
string.rstrip()截掉 string 右边（末尾）的空白字符
string.strip()截掉 string 左右两边的空白字符
拆分和连接
方法说明
string.partition(str)把字符串 string 分成一个 3 元素的元组（str 前面，str str 后面）
string.rpartition(str)类似于partition()方法，不过是从右边开始查找
string.split(str="", num)以 str 为分隔符拆分 string ，如果 num 有指定值，则仅分隔 num+1 个子字符串，str 默认包含 \t\n\r和空格
string.splitlines()按照行(\r, \n, \r\n)分隔，返回一个包含各行作为元素的列表
string.join(seq)以 string 作为分隔符，将 seq 中所有元素（的字符串表示）合并作为一个新的字符串

4.5 公共方法

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”
  • 两个字典不能比较大小

切片

  • 字符串[开始索引: 结束索引: 步长]
  • 切片(slice)方法适用于字符串、列表、元组
    • 切片使用索引值限定范围，从一个大的字符串中切出小的字符串
    • 列表和元组是有序的集合，能通过索引值获取对应数据
    • 字典是无序集合，通过键值对保存数据
  • 指定的区间属于左闭右开型
    • [开始索引，结束索引)
    • 从起始开始，到结束位的前一位
  • 从头开始，开始索引数字可以省略，冒号不能省略
  • 到末尾结束，结束索引数字可以省略，冒号不能省略
  • 步长默认为 1 ，如果连续切片，数字和冒号都可以省略

运算符

运算符Python 表达式结果描述支持的数据类型
+[1, 2] + [3, 4][1, 2, 3, 4]合并字符串、列表、元组
*[“Hi!”] * 4[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]重复字符串、列表、元组
in3 in (1, 2, 3)True元素是否存在字符串、列表、元组、字典
not in4 not in (1, 2, 3)True元素是否不存在字符串、列表、元组、字典
> >= == < <=(1, 2, 3) < (2, 2, 3)True元素比较字符串、列表、元组
  • in 在对字典操作时，判断的是字典的键
  • in 和 not in 被称为成员运算符

完整的 for 循环语法

1
2
3
4

for 变量 in 集合:
    循环体代码
else:
    没有通过 break 退出循环，循环结束后，会执行的代码
  • 循环体内部使用 break 关键字 else 以下的代码不会被执行
应用场景
  • 在迭代遍历嵌套数据类型时，例如，一个列表包含多个字典
  • 需求：判断某一个字典中是否存在指定的值
    • 如果存在，提示并且退出循环
    • 如果不存在，循环整体结束后，得到统一的提示
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

students = [
    {"name": "阿土"},
    {"name": "小美"},
]

# 在学员列表中搜索指定名字

find_name = "张三"
for stu_dict in students:
    print(stu_dict)
    if stu_dict["name"] == find_name:
        print("找到了 %s" % find_name)
        break
else:
    print("没有找到%s" % find_name)

5. 语法进阶

5.1 变量的引用

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

引用的概念

Python 中

  • 变量和数据分开存储
  • 数据保存在内存中的一个位置
  • 变量中保存着数据在内存中的地址
  • 变量中记录数据地址的动作就叫引用
  • id() 函数可以查看变量中保存数据的内存地址

如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用

  • 变量不再对之前的数据引用
  • 变量改为对新赋值的数据引用

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

Python 中，函数的实参/返回值都是靠引用传递的

  • 调用函数，本质上是传递的实参/返回值****保存数据的引用，而不是实参保存的数据

  • 如果不定义变量接收函数的返回值，程序不会报错，但是无法获得返回结果

5.2 可变类型不可变类型

  • 不可变类型，内存中的数据不允许被修改
    • 数字类型 int, bool, float, complex
    • 字符串 str
    • 元组 tuple
  • 可变类型，内存中的数据可以被修改
    • 列表 list
    • 字典 dict 字典的 key 只能使用不可变数据类型

5.3 局部变量和全局变量

局部变量

  • 局部变量是在函数内部定义的变量，只能在函数内部使用

  • 函数执行结束后，函数内部的局部变量，会被系统回收

  • 局部变量的生命周期

    • 生命周期是变量从被创建到被系统回收的过程
    • 局部变量在函数执行时才会被创建
    • 局部变量在生命周期内，可以用来存储函数内部临时使用到的数据

全局变量

  • 全局变量是在函数外部定义的变量，所有函数都可以使用
  • 其他开发语言中大多不推荐使用全局变量
  • 不允许在函数内部修改全局变量
  • 在函数内部重新赋值，只是定义了一个局部变量
  • 希望修改全局变量的值 使用 global 声明变量即可
  • 应该把模块中的所有全局变量定义到所有函数上方
  • 全局变量命名前方应加 g_ 或 gl_ 等与局部变量区分
  • 如果局部变量和局部变量名称相同，pycharm 会在局部变量下方显示灰色虚线

5.4 参数和返回值

函数根据有没有参数和有没有返回值可以自由组合，共 4 种

  1. 无参数，无返回值
  2. 无参数，有返回值
  3. 有参数，无返回值
  4. 有参数，有返回值
  • 如果函数内部处理数据不确定，可以将外界数据以参数形式传递给函数
  • 如果希望函数执行完成后，向外界汇报结果，可以增加返回值

函数的返回值-多个返回值

  • 元组可以包含多个数据，因此可以使用元组让函数一次返回多个值

  • 如果函数返回的结果是元组，小括号可以省略

  • 如果函数的返回值类型是元组，需要单独处理元组中的元素可以使用多个变量，一次接收函数的返回结果

    • 注意：使用此方法，变量的个数应该和元组中元素的个数保持一致

问题：交换两个变量的值?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

a = 6
b = 100
# 1. 使用其他变量
# c = a
# a = b
# b = c
   
# 2. 不使用其他变量
# a = a + b
# b = a - b
# a = a - b
   
# 3. Python 专有
# a, b = (b, a)
# 元组小括号可省略
a, b = b, a
print(a)
print(b)

函数的参数

不可变和可变参数

  • 在函数内部，针对参数使用赋值语句不会影响调用函数时传递的实参变量

  • 无论传递的参数是可变还是不可变

  • 在函数内部，针对参数使用赋值语句,不会修改外部实参变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

def demo(num, num_list):
    print("函数内部的代码")

    # 在函数内部，针对参数使用赋值语句,不会修改外部实参变量
    num = 100
    num_list = [1, 2, 3]

    print(num)
    print(num_list)
    print("函数执行完成")

gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print(gl_num)
  • 如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部数据
1
2
3
4
5
6
7
8
9

def demo(num_list):
    print("函数内部代码")
    num_list.append(9)
    print(num_list)
    print("函数执行完成")

gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list)

问题：– +=

在 Python 中，列表变量调用 += 本质上是在执行列表变量的 extend 方法，不会修改变量的引用

缺省参数

  • 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数

  • 带有默认值的缺省参数必须在参数列表末尾

  • 如果有多个缺省值，需要指定参数名

多值参数

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

案例：计算任意多个数字的和

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def sum_nums(*args):
    num = 0
    # 循环遍历
    for n in args:
        num += n
    return num


result = sum_nums(1, 2, 3, 4, 5)
print(result)
元组和字典的拆包
  • 在调用带有多值参数的函数时，如果希望
  • 将一个元组变量，直接传递给 args
  • 将一个字典变量，直接传递给 kwargs
  • 可以使用拆包，简化参数的传递，拆包的方式是：
    • 在元组变量前，增加一个 *
    • 在字典变量前，增加两个 *

5.4递归

递归：函数调用自身

递归的特点

  • 一个函数内部调用自己
    • 函数内部可以调用其他函数，也可以在内部调用自己

代码特点

  1. 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
  2. 当参数满足一个条件时，函数不再执行
    1. 被称为递归的出口，否则会造成死循环

案例–计算数字累加

  1. 定义一个函数 sum_numbers
  2. 能够接受一个 num 的整体参数
  3. 计算 1 + 2 ... num 的结果
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def sum_numbers(num):

    # 1. 出口
    if num == 1:
        return 1
    # 2. 数字累加 num + (num - 1)
    # 假设 sum_numbers 能处理 1到 num -1 的累加
    temp =sum_numbers(num - 1)
    return num + temp


result = sum_numbers(100)
print(result)