1. 命名和循环

1.1 命名规则

项目：以数字加名称表示

101_python基础

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

1py_01_python基础.py

1.2 格式化输出

以%表示

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

1.3 循环

格式

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

1.4 break 和 continue

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

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

2. 循环打印九九乘法表

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

2.1 思路

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

2.2 代码

1row = 1
2while row <= 9:
3    col = 1 
4    while col <= row:
5        print("%d * %d = %d" % (row, col, row*col), end="\t") 
6        col += 1 
7    print("") 
8    row += 1

2.3 注意

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

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

2.4 结果

11 * 1 = 1
22 * 1 = 2 2 * 2 = 4
33 * 1 = 3 3 * 2 = 6  3 * 3 = 9
44 * 1 = 4 4 * 2 = 8  4 * 3 = 12 4 * 4 = 16
55 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
66 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
77 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
88 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
99 * 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\t # 输出文本时垂直方向保持对齐
2\n # 换行
3\" # 输出双引号

3. 函数

3.1 格式

1def 函数名():
2
3	封装代码
4
5	......

注意

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

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

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

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

3.2 函数注释

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

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

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

3.3 函数参数

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

示例

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

形参和实参

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

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

3.4 函数的返回值

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

示例

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

注意

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

3.5 函数的嵌套调用

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

打印多条分割线

 1def print_line(char, times):
 2    """打印分割线"""
 3    print(char * times)
 4
 5
 6def print_lines(char, times):
 7    """打印多行分割线
 8
 9    :param char:分割线使用的分割字符
10    :param times:分割线重复次数
11    """
12    row = 0
13    while row < 5:
14        print_line(char, times)
15        row += 1
16
17
18print_lines("-", 50)

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

4. 高级变量类型

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

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

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

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

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

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

4.1 列表

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

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

• 列表的索引从 0 开始

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

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

• 取值：变量[索引]

列表常用方法

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

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

• 使用 del 关键字同样可以删除列表中的元素
• 本质是将变量从内存中删除
• 如果使用 del 关键字将变量从内存中删除，后续代码不能使用这个变量
• 使用 len 关键字可以计算列表总的元素个数

循环遍历

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

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

使用场景

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

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

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

4.2 元组

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

元组常用操作

• .index

• .count

循环遍历

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

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

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

应用场景

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

元组和列表转换

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

1list(元组)

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

1tuple(列表)

4.3 字典

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

和列表的区别

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

1xiaoming = {"name": "小明",
2            "age": 18,
3            "gender": True,
4            "height": 1.75,
5            "weight": 75.5}
6print(xiaoming)

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

基本使用

 1dict.keys() # 所有 key 列表
 2dict.values() # 所有 value 列表
 3dict.items() # 所有(key, value)元组列表
 4
 5dict[key] # 从字典中取值，key 不存在会报错
 6dict.get(key) # 可以从字典中取值，key 不存在会报错
 7
 8del dict[key] # 删除指定键值对，key 不存在会报错
 9dict.pop(key) # 删除指定键值对，key 不存在会报错
10dict.popitem() # 随机删除一个键值对
11dict.cleat # 清空字典
12
13dict[key] = value # 如果 key 存在修改数据，不存在新建键值对
14dict.setdefault(key, value) # 如果 key 存在修改数据，不存在新建键值对
15dict.update(dict2) # 将字典2合并到字典，如果被合并的字典包含已存在的键                      值对，会覆盖原有的键值对

循环遍历

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

应用场景

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

4.4 字符串

• 表示文本的数据类型
• Python 中可以用一对双引号或者一对单引号定义字符串

• 大多数编程语言使用双引号定义字符串
• Python 中如果字符串内部需要使用双引号，定义字符串用单引号

• 可以使用索引获得一个字符串中中指定位置的字符，索引从 0 开始
• 也可以使用 for 循环遍历字符串中每一个字符

常用操作

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

字符串方法

判断类型

• decimal digit numeric 三个方法中
  • decimal 方法只包含数字
  • digit 还可包含 unicode 字符，如带括号的 1 （1）
  • numeric 方法还会包含中文数字，如：一
• 一般使用 decimal 方法

查找和替换

• find 方法和 index 方法都可以查找指定字符串是否包含在字符串中，如果指定字符串不存在
  • find 方法返回 -1
  • index 方法会报错
• replace 方法执行完成后会返回新的字符串，但不会修改原有字符串

大小写转换

文本对齐

去除空白字符

拆分和连接

4.5 公共方法

Python 内置函数

• 字符串比较符合以下规则：“0”<“A”<“a”
• 两个字典不能比较大小

切片

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

运算符

• in 在对字典操作时，判断的是字典的键
• in 和 not in 被称为成员运算符

完整的 for 循环语法

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

• 循环体内部使用 break 关键字 else 以下的代码不会被执行

应用场景

• 在迭代遍历嵌套数据类型时，例如，一个列表包含多个字典
• 需求：判断某一个字典中是否存在指定的值
  • 如果存在，提示并且退出循环
  • 如果不存在，循环整体结束后，得到统一的提示

 1students = [
 2    {"name": "阿土"},
 3    {"name": "小美"},
 4]
 5
 6# 在学员列表中搜索指定名字
 7
 8find_name = "张三"
 9for stu_dict in students:
10    print(stu_dict)
11    if stu_dict["name"] == find_name:
12        print("找到了 %s" % find_name)
13        break
14else:
15    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. 有参数，有返回值

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

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

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

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

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

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

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

 1a = 6
 2b = 100
 3# 1. 使用其他变量
 4# c = a
 5# a = b
 6# b = c
 7   
 8# 2. 不使用其他变量
 9# a = a + b
10# b = a - b
11# a = a - b
12   
13# 3. Python 专有
14# a, b = (b, a)
15# 元组小括号可省略
16a, b = b, a
17print(a)
18print(b)

函数的参数

不可变和可变参数

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

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

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

 1def demo(num, num_list):
 2    print("函数内部的代码")
 3
 4    # 在函数内部，针对参数使用赋值语句,不会修改外部实参变量
 5    num = 100
 6    num_list = [1, 2, 3]
 7
 8    print(num)
 9    print(num_list)
10    print("函数执行完成")
11
12gl_num = 99
13gl_list = [4, 5, 6]
14demo(gl_num, gl_list)
15print(gl_num)

• 如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部数据

1def demo(num_list):
2    print("函数内部代码")
3    num_list.append(9)
4    print(num_list)
5    print("函数执行完成")
6
7gl_list = [1, 2, 3]
8demo(gl_list)
9print(gl_list)

问题：– +=

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

缺省参数

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

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

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

多值参数

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

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

 1def sum_nums(*args):
 2    num = 0
 3    # 循环遍历
 4    for n in args:
 5        num += n
 6    return num
 7
 8
 9result = sum_nums(1, 2, 3, 4, 5)
10print(result)

元组和字典的拆包

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

5.4递归

递归：函数调用自身

递归的特点

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

代码特点

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

案例–计算数字累加

1. 定义一个函数 sum_numbers
2. 能够接受一个 num 的整体参数
3. 计算 1 + 2 ... num 的结果

 1def sum_numbers(num):
 2
 3    # 1. 出口
 4    if num == 1:
 5        return 1
 6    # 2. 数字累加 num + (num - 1)
 7    # 假设 sum_numbers 能处理 1到 num -1 的累加
 8    temp =sum_numbers(num - 1)
 9    return num + temp
10
11
12result = sum_numbers(100)
13print(result)

最后修改于 2020-08-10