- 1MySQL 基本概念 基础用法 增删改查（特殊查询）语法 详细篇
- 2CVPR2021 计算机视觉论文推荐_differentiable multi-granularity human representat
- 3vue3+ts：render极简demo_现成的vue3项目demo下载
- 4OpenHarmony源码解析之电话子系统——通话流程
- 5Spring AI上架，打造专属业务大模型，AI开发再也不是难事！_org.springframework.ai.openai.client.openaiclient
- 6amd显卡测试大风车软件md,知之实验室 篇三：大家好才是真的好！免费显卡升级工具AMD FSR技术研究测试...
- 7让linux脚本输出声音,即使在linux中没有麦克风，声音输出也会出现在声音输入中...
- 8什么是BSS段和c语言程序如何变成可执行的文件_什么样的代码会导致bss段被编译进可执行程序
- 9深度学习时间序列预测：LSTM算法构建时间序列单变量模型预测大气压（ air pressure）+代码实战_机器学习 lstm时间序列实战
- 10linux sed删除d命令使用举例_sed 删除数据并重定向
学习python的编程语言_py十人分五组代码
赞
踩
前言
那么多编程语言，为什么学python
易于学习，是所有编程语言当中最容易学习的
没有最好的语言，只有最合适的语言
第一章 python基础
1. 课程整体介绍
- 课程整体介绍
python编程基础
基于效率的思考、开始编程钱的准备、基于数据类型、逻辑运算符与比较运算符、程序中的循环、字串符进阶、高级数据类型、函数的定义与使用
python语法进阶
闭包与装饰器、python高阶函数、面向对象编程、进程与线程编程
多人协同开发的代码管理
git的基本概念、git的工作流程、git代码拉取与推送、git分支合并与常见问题
本阶段达成的目标
掌握python语言，为后续的自动化测试打好基础、能够独立完成课程中所涉及到的案例、掌握git，并能够掌握多人协同开发的代码管理流程
2. 反复执行的用例如何提升效率
测试流程回归（回顾）
很多测试用例在不同的测试轮次中都需要执行
那么提高效率的办法是：将这些需要反复执行的测试用例，让程序自动的帮我们执行
3. 自动化测试这么厉害可以完全替代我们手工测试吗
当然不可以
原因：
- 自动化测试的优点是可以完成大量重复性的工作
- 自动化测试不具备像手工测试那样的想象力
- 自动化测试代码有时很脆弱，维护也需要大量的精力
- 自动化测试不具备人的经验性，判断力及推理能力
- 人的审美与心理体验是工具不可替代的
①.什么场景适合自动化测试
- 准入测试
- 回归测试
②.什么时间适合自动化测试
- 版本稳定，无频繁的需求变更
4. 标识符
标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。
以下划线开头的标识符有特殊含义，单下划线开头的标识符，如：_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入；双下划线开头的标识符，如：__xx，表示私有成员；双下划线开头和结尾的标识符，如：xx，表示 Python 中内置标识，如：init() 表示类的构造函数。
5. 关键字
| and | exec | not | assert | finally | or |
|---|---|---|---|---|---|
| break | for | pass | class | from | |
| continue | global | raise | def | if | return |
| del | import | try | elif | in | while |
| else | is | with | except | lambda | yield |
上面表中是 Python 中的关键字（保留字），我们在自定义标识符时不能使用关键字。
6. 引号
Python 可以使用引号（‘）、双引号（"）、三引号（’‘’ 或 “”"）来表示字符串，引号的开始与结束须类型相同，三引号可以由多行组成。如下所示：
id = '001'
name = "张三"
skill = '''
唱歌
跳舞'''
skill = """
唱歌
跳舞"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
7. 编码
Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -- coding: UTF-8 -- 进行指定。
Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。
8. 输入输出
Python 输出使用 print()，内容加在括号中即可。如下所示：
print('Hello Python')
- 1
Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。如下所示：
name = input()
print('Hi',name)
- 1
- 2
9. 缩进
Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变。如下所示：
if True:
print(True)
else:
print(False)
- 1
- 2
- 3
- 4
10. 多行
Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示。如下所示：
a = 128
b = 1024
c = 512
d = a + \
b - \
c
- 1
- 2
- 3
- 4
- 5
- 6
如果包含在 []、{}、() 括号中，则不需要使用 \。如下所示：
arr = {
a,
b,
c
}
- 1
- 2
- 3
- 4
- 5
11. 注释
Python 中单行注释使用 #，多行注释使用三个单引号（‘’'）或三个双引号（“”"）。如下所示：
# 我是单行注释
'''
我是多行注释
我是多行注释
'''
"""
我是多行注释
我是多行注释
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
12. 数据类型
整数：可以为任意大小、包含负数
浮点数：就是小数
字符串：以单引号 ‘、双引号"、三引号 ‘’’ 或 “”"括起来的文本
布尔：只有 True、False 两种值
空值：用 None 表示
变量：是可变的
常量：不可变
13. 运算符
13.1 常用运算符
运算符 描述 示例 + 相加 a + b - 相减 a - b * 相乘 a * b / 相除 a / b % 取模 a % b ** 幂 a**b 表示 a 的 b 次幂 // 取整除 9 // 4 结果为 2 == 是否相等 a == b != 是否不等于 a != b > 是否大于 a > b >= 是否大于等于 a >= b <= 是否小于等于 a <= b = 简单的赋值运算符 a = b + c += 加法赋值运算符 a += b 等效于 a = a + b -= 减法赋值运算符 a -= b 等效于 a = a - b *= 乘法赋值运算符 a *= b 等效于 a = a * b /= 除法赋值运算符 a /= b 等效于 a = a / b %= 取模赋值运算符 a %= b 等效于 a = a % b **= 幂赋值运算符 a **= b 等效于 a = a ** b //= 取整除赋值运算符 a //= b 等效于 a = a // b & 与 a & b | 或 a | b ^ 异或 a ^ b ~ 取反 ~a << 左移动 a << 3 >> 右移动 a >> 3 and 布尔类型与 a and b or 布尔类型或 a or b not 布尔类型非 not a is 判断两个标识符是否引用同一个对象 a is b is not 判断两个标识符是否引用不同对象 a is not b
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
13.2 运算符优先级
运算符 描述（由上至下对应优先级由高到低）
** 幂运算
~ + - 取反、正号、负号
* / % // 乘、除、取模、取整除
+ - 加法、减法
>> << 右移、左移
& 与
^ | 异或、或
<= < > >= 比较运算符
== != 是否等于、是否不等于
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not and or 逻辑运算符
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
第二章 开始编程前的准备
1. 测试领域，python能做什么？
- web（UI）自动化测试
- 接口自动化测试
- 测试工具开发
- 测试平台开发
2. 测试领域以外，python能做什么
- 人工智能算法开发
- 大数据
- 数据分析
- 网站开发
- 游戏开发
- 爬虫开发
3. python还有什么其他的优点
- 跨平台
- 免费开源
- 面向对象
- 强扩展性
- 扩展库很丰富
- 动态类型的编程语言
4. pycharm下载与安装
python安装教程
https://blog.csdn.net/weixin_49237144/article/details/122915089?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167322232316800225583532%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167322232316800225583532&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_positive~default-2-122915089-null-null.142v70control,201v4add_ask&utm_term=python%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B&spm=1018.2226.3001.4187
pycharm安装教程(2022)与使用
https://blog.csdn.net/qq_45158642/article/details/127081741?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167325720616800182118023%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167325720616800182118023&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allbaidu_landing_v2~default-1-127081741-null-null.142v70control,201v4add_ask&utm_term=pycharm%20download%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B&spm=1018.2226.3001.4187
5. 第一个python程序（右键点击run）
print("hello world")
- 1
第三章 基本数据类型
1. 变量与关键字
变量：
i = 1
print (i)
j = 2
print (j)
- 1
- 2
- 3
- 4
print打印结果：1、2
关键字：
import keyword
print (keyword.kwlist)
- 1
- 2
print打印结果：
[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
2. 单行打印与多行打印
# 单行打印
s = "hello World,你好，世界！！！"
print(s)
# 多行打印，打印出来的效果是分为多行
# \n 代表回车键
print ("Hello World!! \n你好\n世界！！！")
print("""
hello World!
你好，世界！！
""")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ml9msswI-1675162173279)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/569d3a7949c0430487288c1bd61c92c1~tplv-k3u1fbpfcp-watermark.image?)]
# \叫做转义字符
print (""")
- 1
- 2
print打印结果："
3. python基本数据类型
# python中的数据类型
# 整数数据类型 1、2、3、4
# 字符串：是使用一堆儿单引号或双引号包裹起来的字符
# 浮点数 1.23
# 布尔类型 True False
- 1
- 2
- 3
- 4
- 5
4. python中的算法运算
# 算法运算
first_number = 1
second_number = 2
print(first_number + second_number)
print(first_number - second_number)
print(first_number * second_number)
print(first_number / second_number)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
print打印结果：3、-1、2、0
s1 = "hello"
s2 = "world"
print(s1 + s2)
# 字符串与字符串之间不可以相减，相乘，相除
print(s1 - s2)
print(s1 * s2)
print(s1 / s2)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
print打印结果：字符串与字符串之间不可以相减，相乘，相除
f1 = True
f2 = False
print(f1 + f2)
print(f1 - f2)
print(f1 * f2)
print(f1 / f2)
- 1
- 2
- 3
- 4
- 5
- 6
print打印结果：不能除
5.数据类型转换
i = 1
print(type(i))
j = 1.2
print(type(j))
x = "aa"
print(type(x))
y = True
print(type(y))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
print打印结果：
<type ‘int’>
<type ‘float’>
<type ‘str’>
<type ‘bool’>
# 整数类型可以转换其他的数据类型吗
# 整数类型转换浮点数
ii = float(i)
print(ii)
print(type(ii))
# 整数类型转换布尔值
# 1可以转换True、 0可以转换False
bi = bool(i)
print(bi)
print(type(bi))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
print打印结果：
0.0、
<type ‘float’>、
0、
<type ‘str’>、
False、
<type ‘bool’>、
浮点数转换其他三种
# 转整数 小数点后边的就都不要了
ij = int(j)
print(ij)
print(type(ij))
sj = int(j)
print(sj)
print(type(sj))
# 非0的数字类型，转换成布尔值的时候就会变成True
bj = bool(j)
print(bj)
print(type(bj))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
1、
<type ‘int’>、
1、
<type ‘int’>、
1、
<type ‘int’>、
# 字符串转换其他数据类型 # 字符串如果想要转换成整型，那么它必须看起来就像是一个数字才可以 # ix =int(x) # print(ix) # print(type(ix)) fx =float(x) print(fx) print(type(fx)) # 字符串转换布尔值时，控制为false，有值得时候为true bx = bool(x) print(bx) print(type(bx)) iy = int(y) print(iy) print(type(iy))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
0.0
<type ‘float’>
0
<type ‘str’>
ValueError: could not convert string to float: aa
False
<type ‘bool’>
1
<type ‘int’>
1
<type ‘int’>
False
<type ‘bool’>
Process finished with exit code 1
6 条件语句
在进行逻辑判断时，我们需要用到条件语句，Python 提供了 if、elif、else 来进行逻辑判断。格式如下所示：
if 判断条件1:
执行语句1...
elif
判断条件2:
执行语句2...
elif
判断条件3:
执行语句3...
else:
执行语句4...
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
7 循环语句
当需要多次重复执行时，我们要用到循环语句，Python 提供了 for 循环和 while 循环。
7.1 for 循环
for 循环可以遍历任何序列，比如：字符串。如下所示：
str = 'Python'
for s in str:
print(s)
- 1
- 2
- 3
输出结果：
Python
- 1
7.2 while 循环
while 循环，满足条件时进行循环，不满足条件时退出循环。如下所示：
sum = 0
m = 10
while m > 0:
sum = sum + m
m = m - 1
print(sum)
- 1
- 2
- 3
- 4
- 5
- 6
输出结果：
55
- 1
7.3 break
break 用在 for 循环和 while 循环语句中，用来终止整个循环。如下所示：
str = 'Python'
for s in str:
if s == 'o':
break
print(s)
- 1
- 2
- 3
- 4
- 5
输出结果：
Pyth
- 1
7.4 continue
continue 用在 for 循环和 while 循环语句中，用来终止本次循环。如下所示：
str = 'Python'
for s in str:
if s == 'o':
continue
print(s)
- 1
- 2
- 3
- 4
- 5
输出结果：
Pythn
- 1
8. pass 语句
pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。如下所示：
if True: pass
- 1
9 字符串基本使用
9.1 访问
访问单个字符
s = 'Python'
# 访问第一个字符 P
print(s[0])
- 1
- 2
- 3
访问范围内字符
s = 'Python'
# 访问 yt
print(s[1:3])
# 访问 Pyt
print(s[:3])
# 访问 hon
print(s[3:])
- 1
- 2
- 3
- 4
- 5
- 6
- 7
9.2 单个字符编码
Python 使用了 ord() 函数返回单个字符的编码，chr() 函数把编码转成相应字符。如下所示：
s = 'A'
print(ord(s))
print(chr(65))
- 1
- 2
- 3
输出结果：
65A
- 1
9.3 转义符
之前我们说过可以通过反斜杠 将一行语句分多行显示，其实就是 来转义字符，一些常见的转义字符如下表所示：
| 转义字符 | 描述 |
|---|---|
| `` | 在行尾使用时，用作续行符 |
| \b | 退格（Backspace） |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
9.4 运算符
之前我们已经介绍了大部分运算符，下面再来详细看一下字符串运算符。如下表所示：
| 运算符 | 描述 |
|---|---|
| + | 连接符 |
| * | 重复输出 |
| [] | 通过索引获取字符串中字符 |
| [ : ] | 获取字符串中的一部分 |
| in | 字符串中是否包含指定字符 |
| not in | 字符串中是否不包含指定字符 |
| r/R | 字符串原样输出 |
使用示例如下所示：
s1 = 'Hello'
s2 = 'Python'
print('s1 + s2 -->', s1 + s2)
print('s1 * 2 -->', s1 * 2)
print('s1[0] -->', s1[0])
print('s1[0:2] -->',s1[0:2])
print('"H" in s1 -->','H' in s1)
print('"H" not in s1 -->','H' not in s1)
print('\r -->', R'\r')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
输出结果：
s1 + s2 --> HelloPythons
1 * 2 --> HelloHellos
1[0] --> H
s1[0:2] --> He
"H" in s1 --> True
"H" not in s1 --> False
\r --> \r
- 1
- 2
- 3
- 4
- 5
- 6
- 7
9.5 格式化
当我们需要输出的内容中含有变量时，比如：Hello xxx，xxx 为变量，此时便需要一种格式化字符串的方式，Python 使用 % 格式化字符串，常用占位符如下表所示：
| 占位符 | 描述 |
|---|---|
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数 |
以字符串为例，如下所示：
print('Hello %s' % 'Python')
- 1
输出结果：
Hello Python
- 1
我们也可以使用字符串的 format() 方法进行格式化，先看下示例：
print('{0} {1}'.format('Hello', 'Python'))
- 1
这种方式是用传入的参数依次替换字符串内的占位符{0}、{1} …
13 序列基本使用
13.1 索引
序列索引支持非负数和负数，索引为非负数，从 0 开始，如下所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-09cwR6yk-1675162173280)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/647342088c2745d4b30c224c9520f6f4~tplv-k3u1fbpfcp-zoom-1.image)]
索引为负数由右向左计数，从 -1 开始，如图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIJkUTB6-1675162173281)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/952fb69b1f414001b70ffc27a18f0ff7~tplv-k3u1fbpfcp-zoom-1.image)]
下面通过一个示例作进一步了解，以字符串为例，如下所示：
str = 'Python'
print('str[0] str[-6] =', str[0], str[-6])
print('str[5] str[-1] =', str[5], str[-1])
- 1
- 2
- 3
输出结果：
str[0] str[-6] = P P
str[5] str[-1] = n n
- 1
- 2
从结果来看，我们使用非负数索引与负数索引得到的结果一致。
2.2 切片
切片操作可以访问一定范围内的元素，语法如下所示：
sname[start : end : step]
- sname：表示序列的名称；
- start：开始索引位置（包括该位置），默认为 0；
- end：表示切片的结束索引位置（不包括该位置），默认为序列的长度；
- step：步长。
以字符串为例，如下所示：
str = 'Python'
print(str[:3])
print(str[3:])
print(str[:])
- 1
- 2
- 3
- 4
输出结果：
Python
Python
- 1
- 2
2.3 相加
Python 支持类型相同的序列使用 + 作相加操作，该操作不会去除重复的元素。以字符串为例，如下所示：
str1 = 'Python'
str2 = 'Python'
print('str1 + str2 --> ',str1 + str2)
- 1
- 2
- 3
输出结果：
str1 + str2 --> PythonPython
- 1
2.4 相乘
Python 中，使用数字 n 乘以一个序列会生成新的序列，内容为原来序列被重复 n 次的结果。以字符串为例，如下所示：
str = 'Python'
print('2 * str --> ',2 * str)
- 1
- 2
输出结果：
2 * str --> PythonPython
- 1
2.5 元素是否在序列中
Python 使用 in 关键字检查某元素是否为序列的成员，语法如下：
val in seq
- val：要检查的元素；
- seq：指定的序列。
通过一个例子作进一步了解，以字符串为例，如下所示：
str = 'Python'
print('on'in str)
- 1
- 2
输出结果：
True
- 1
2.6 内置函数
| 函数 | 描述 |
|---|---|
| len() | 计算序列的长度 |
| max() | 找出序列中的最大元素 |
| min() | 找出序列中的最小元素 |
| list() | 将序列转换为列表 |
| str() | 将序列转换为字符串 |
| sum() | 计算元素的和 |
| sorted() | 对元素进行排序 |
| enumerate() | 将序列组合为一个索引序列，多用在 for 循环中 |
简单举几个例子，如下所示：
str = 'dbcae'
print('len -->', len(str))
print('max -->', max(str))
print('sorted -->', sorted(str))
- 1
- 2
- 3
- 4
输出结果：
len --> 5
max --> e
sorted --> ['a', 'b', 'c', 'd', 'e']
- 1
- 2
- 3
14. 列表基本使用
➢ 创建
列表中所有元素都放在一个中括号 [] 中，相邻元素之间用逗号 , 分隔，如下所示：
l = [1024, 0.5, 'Python']
- 1
➢ 访问
通过索引访问列表中的值，还可以使用 : 截取范围内的元素，如下所示：
l = [1024, 0.5, 'Python']
print('l[0] -->', l[0])
print('l[1:] -->', l[1:])
- 1
- 2
- 3
输出结果：
l[0] --> 1024
l[1:] --> [0.5, 'Python']
- 1
- 2
➢ 更新
除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素，如下所示：
l = [1024, 0.5, 'Python']
# 修改列表中第二个元素
l[1] = 5
# 向列表中添加新元素
l.append('Hello')
print('l[1] -->', l[1])
print('l -->', l)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
输出结果：
l[1] --> 5
l --> [1024, 5, 'Python', 'Hello']
- 1
- 2
➢ 删除
使用 del 删除列表中元素，如下所示：
l = [1024, 0.5, 'Python']
# 删除列表中第二个元素del l[1]
print('l -->', l)
- 1
- 2
- 3
输出结果：
l --> [1024, 'Python']
- 1
➢ 常用方法
① count()
统计列表中某个元素出现的次数，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
print("l.count('d') -->", l.count('d'))
- 1
- 2
输出结果：
l.count('d') --> 2
- 1
② index()
查找某个元素在列表中首次出现的位置（即索引），使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
print("l.index('d') -->", l.index('d'))
- 1
- 2
输出结果：
l.index('d') --> 0
- 1
③ remove()
移除列表中某个值的首次匹配项，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
l.remove('d')
print("l -->", l)
- 1
- 2
- 3
输出结果：
l --> ['b', 'a', 'f', 'd']
- 1
④ sort()
对列表中元素进行排序，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
l.sort()
print('l -->', l)
- 1
- 2
- 3
输出结果：
l --> ['a', 'b', 'd', 'd', 'f']
- 1
⑤ copy()
复制列表，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
lc = l.copy()
print('lc -->', lc)
- 1
- 2
- 3
输出结果：
lc --> ['d', 'b', 'a', 'f', 'd']
- 1
15. 元组基本使用
15.1 简介
元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。
15.2 基本使用
➢ 创建
元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示：
t = (1024, 0.5, 'Python')
- 1
➢ 访问
与访问列表中元素类似，如下所示：
t = (1024, 0.5, 'Python')
print('t[0] -->', t[0])
print('t[1:] -->', t[1:])
- 1
- 2
- 3
输出结果：
t[0] --> 1024
t[1:] --> (0.5, 'Python')
- 1
- 2
➢ 修改
元组中元素不能被修改，我们要用重新赋值的方式操作，如下所示：
t = (1024, 0.5, 'Python')
t = (1024, 0.5, 'Python', 'Hello')
print('t -->', t)
- 1
- 2
- 3
输出结果：
t --> (1024, 0.5, 'Python', 'Hello')
- 1
➢ 删除
元组中的元素不能被删除，我们只能删除整个元组，如下所示：
t = (1024, 0.5, 'Python')
del t
print('t -->', t)
- 1
- 2
- 3
输出结果：
NameError: name 't' is not defined
- 1
由于元组实例被删除，所以输出了异常信息。
➢ 常用方法
① len()
计算元组中元素个数，使用如下所示：
t = (1024, 0.5, 'Python')
print('len(t) -->', len(t))
- 1
- 2
输出结果：
len(t) --> 3
- 1
② max() 和 min()
返回元组中元素最大、最小值，使用如下所示：
t = ('d', 'b', 'a', 'f', 'd')
print('max(t) -->', max(t))
print('min(t) -->', min(t))
- 1
- 2
- 3
输出结果：
max(t) --> f
min(t) --> a
- 1
- 2
③ tuple()
将列表转换为元组，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
t = tuple(l)
print('t -->', t)
- 1
- 2
- 3
输出结果：
t --> ('d', 'b', 'a', 'f', 'd')
- 1
- 2
16 字典
字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示：
d = {'name':'小明', 'age':'18'}
# 使用 dict 函数
# 方式一
l = [('name', '小明'), ('age', 18)]
d = dict(l)
# 方式二
d = dict(name='小明', age='18')
# 空字典
d = dict()
d = {}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
字典中的值通过 key 进行访问，如下所示：
>>> d = dict(name='小明', age='18')
>>> d['name']
'小明'
# 使用 get 方法
>>> d.get('name')
'小明'
- 1
- 2
- 3
- 4
- 5
- 6
- 7
修改操作，以修改 age 为例，如下所示：
>>> d = dict(name='小明', age='18')
>>> d['age'] = '20'
>>> d['age']
'20'
- 1
- 2
- 3
- 4
清空集合，如下所示：
>>> d = dict(name='小明', age='18')
>>> d.clear()
>>> d{}
- 1
- 2
- 3
获取字典的长度，如下所示：
>>> d = dict(name='小明', age='18')
>>> len(d)
2
- 1
- 2
- 3
17 集合
集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的。
集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例，如下所示：
s = {'a', 'b', 'c'}
# 使用 set 函数
s = set(['a', 'b', 'c'])
# 空集合
s = set()
- 1
- 2
- 3
- 4
- 5
集合中重复的元素会被自动过滤掉，如下所示：
>>> s = {'a', 'a', 'b', 'c', 'c'}
>>> s
{'a', 'c', 'b'}
- 1
- 2
- 3
添加元素可以使用 add 或 update 方法，如果元素已经存在，则不进行操作，如下所示：
>>> s = {'a', 'b', 'c'}
>>> s.add('d')
>>> s
{'a', 'd', 'c', 'b'}
>>> s.update('e')
>>> s
{'a', 'b', 'e', 'd', 'c'}
# 添加已经存在的元素 a
>>> s.add('a')
>>> s
{'a', 'b', 'e', 'd', 'c'}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
删除元素使用 remove 方法，如下所示：
>>> s = {'a', 'b', 'c'}
>>> s.remove('c')
>>> s
{'a', 'b'}
- 1
- 2
- 3
- 4
清空集合使用 clear 方法，如下所示：
>>> s = {'a', 'b', 'c'}
>>> s.clear()
>>> s
set()
- 1
- 2
- 3
- 4
获取集合的长度，同样使用 len 方法，如下所示：
>>> s = {'a', 'b', 'c'}
>>> len(s)3
- 1
- 2
第四章 逻辑运算与比较运算
1.条件控制逻辑
# 关键字if # 如果*** 成立了，我们就*** 咋样 i = 2 if i == 1： #这里的返回结果是True才会往下执行 # 如果是False就不执行 print（"i的值是1"） print（"if语句结束了"） """ if 条件： 这里是tab键或者是4个空格键，但是在PyCharm我们不用自己写在冒号后边回车就会自动帮助我们把这个内容带出来 """ # 如果*** 成立了，我们就*** 咋样 # 否则 就***咋样 i = 2 if i == 1： #这里的返回结果是True才会往下执行 # 如果是False就不执行 print（"i的值是1--2"） # 注意前边的缩进 else： print（"i的值不是1"）
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
2.逻辑运算符
#coding=utf-8 # 逻辑运算符 # and or not i = 1 j = 3 # and是必须所有的条件都需要成功 if i == 1 and j == 2: print("i的值是1 并且j的值是2") else: print("判断失败了") if i == 1 or j == 2: print("i的值是1 并且j的值是2") else: print("判断失败了") i = 2 if not i == 1: print ("i的值不是1") else: print ("i的值是1") # 如果判断条件非常多，我们就是用（）将优先级划分明确
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
print打印结果：判断失败了、
i的值是1 并且j的值是2、
i的值不是1、
3.BMI指数计算器
#coding=utf-8 # BMI计算公式是：BMI = 体重/(体重*身高） # 1、当测量者的BMI指数小于18.5的时候，认为他的体重过轻 # 2、当测量者的BMI指数大于等于18.5，并且小于24的时候，认为他的体重正常 # 3、当测量者的BMI指数大于等于24，并且小于等于28的时候，认为他的体重过重 # 4、当测量者的BMI指数大于28时，认为他的体重属于肥胖行列 # 首先我们要获取用户输入的体重和身高 weight = input("欢迎使用BMI指数计算器，请输入您的体重(单位为千克)：") height = input("请输入您的身高（单位为米）：") # 由于用户输入之后的内容的数据类型是字符串，我们需要做一个数据类型转换器 weight_float = float(weight) height_float = float(height) # 这里需要计算出BMI指数的结果 bmi = weight_float/(height_float*height_float) # 这时候的变量bmi是一个float数据类型 # 如果接下来我们想要让它跟字符串合并输出，是不是就必须要做一个数据类型转换 # 浮点数转字符串应该用什么函数 str print("您的BMI指数的值是:"+str(bmi)) # 根据结果落在的区间，反馈给用户不同的信息 if bmi < 18.5: print ("您的体重太轻了，回家吃点好吃的吧") elif bmi >= 18.5 and bmi < 24: print ("太棒了，您的BMI指数的值在正常范围内") elif bmi >= 24 and bmi < 28: print ("您的体重偏重，注意饮食，要略微控制一下") elif bmi >28: print ("你真的应该减肥了，都属于肥胖行列了") else: print ("好好想一想，是不是输入有错误了")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
print打印结果：
欢迎使用BMI指数计算器，请输入您的体重(单位为千克)：80
请输入您的身高（单位为米）：1.8
您的BMI指数的值是:24.6913580247
您的体重偏重，注意饮食，要略微控制一下
- 1
- 2
- 3
- 4
- 5
- 6
- 7
第五章 程序中的循环
1. 第一个循环-while
#coding=utf-8 # while 循环 i = 1 while i < 5: # 永远为True print (i) # 这里需要一个控制方向 i = i + 1 print ("计算后此时i的值是：" +str(i)) """ while 条件表达式： 逻辑语句 当条件表达式为True时，循环执行 当条件表达式为False时，循环就停止了 第一种结束的情况时条件判断失败，循环自动结束 """ # break 跳出循环 print ("*"*10) i = 1 while i < 10: print (i) if i == 5: print ("现在i的值是5，我要跳出循环") break print ("i的值还没有到5.需要进行加法运算") i = i + 1 print ("代码执行完毕")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
print打印结果：
1 计算后此时i的值是：2 2 计算后此时i的值是：3 3 计算后此时i的值是：4 4 计算后此时i的值是：5 ********** 1 i的值还没有到5.需要进行加法运算 2 i的值还没有到5.需要进行加法运算 3 i的值还没有到5.需要进行加法运算 4 i的值还没有到5.需要进行加法运算 5 现在i的值是5，我要跳出循环 代码执行完毕
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
2. 赋值运算符
#coding=utf-8 i = 1 print (i) """ + - * / % 取余数 ** 幂运算，平方 // 相除取整数部分 """ i = 1 # i = i + 1 #是把i + 1 的结果再次赋值给i i += 1 print (i) """ i += 1 : i = i + 1 *= 2 : i = i *2 /= 3 : i = i / 3 -= 4 : i = i - 4 %= 2 ： i = i % 2 **= 2 : i = i ** 2 //=3 : i = i // 3 """ i = 5 i -= 2 # i = i - 2 print (i)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
print打印结果：
1
2
3
- 1
- 2
- 3
3. 一起写个计算器
# coding=utf-8 # 简易计算器 # 我们输入第一个数字 result = input("请输入第一个数字:") # 输入一个计算的符号 operator = input("请输入运算符号:") # 输入第二个数字 second_number = input("输入第二个数字:") # 数据类型转换 result = float(result) second_number = float(second_number) # 按照所输入的计算的符号进行结果运算 if operator == "+": result += second_number elif operator == "-": result -= second_number elif operator == "*": result *= second_number elif operator == "/": result /= second_number elif operator == "%": result %= second_number elif operator == "**": result **= second_number elif operator == "//": result //= second_number else: print("没有匹配到正确的运算符") print ("计算的结果:" + str(result)) """ 新需求： 1、我们可以进行多次的运算，不仅仅只支持俩个数字的运算 例如： 1+2+3+4+5 2、如果我们按键盘上的字母q，那么意味着退出运算，运算结束 3、如果我们按键盘上的字母c，那么意味着清除之前的运算，重新开始 """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
4.完善计算器
# coding=utf-8 # 声明一个变量记录是第几次计算 number_of_times = 1 while True: # 判断是不是第一次运算，然后在进行不同方式的计算 if number_of_times == 1: result = input("请输入第一个数字：") operator = input("请输入操作符号：") if operator == "q": print ("计算程序退出") break elif operator == "c": print ("计算器清零，重新计算") result = 0 # 将计算次数也需要重置为1 number_of_times = 1 continue second_number = input("请输入第二个数字") # 数据类型转换 result = float(result) second_number = float(second_number) # 按照所输入的计算的符号进行结果运算 if operator == "+": result += second_number elif operator == "-": result -= second_number elif operator == "*": result *= second_number elif operator == "/": result /= second_number elif operator == "%": result %= second_number elif operator == "**": result **= second_number elif operator == "//": result //= second_number else: print("没有匹配到正确的运算符") print ("计算的结果:" + str(result)) # 把操作次数加上1 number_of_times += 1 else: operator = input("请输入操作符号：") if operator == "q": print ("计算程序退出") break elif operator == "c": print ("计算器清零，重新计算") result = 0 # 将计算次数也需要重置为1 number_of_times = 1 continue second_number = input("请输入数字：") result = float(result) second_number = float(second_number) # 按照所输入的计算的符号进行结果运算 if operator == "+": result += second_number elif operator == "-": result -= second_number elif operator == "*": result *= second_number elif operator == "/": result /= second_number elif operator == "%": result %= second_number elif operator == "**": result **= second_number elif operator == "//": result //= second_number else: print("没有匹配到正确的运算符") print ("当前是第" + str(number_of_times) + "次运算") print ("计算的结果:" + str(result)) # 把操作次数加上1 number_of_times += 1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
第六章 字符串进阶
1. 字符串格式化
# coding=utf-8 # 字符串格式化 # %格式化 i = "python" s = "我来学习%s" % i print (s) """ %s : 这里是一个占位符，后边江会使用一个参数进行替代 这个参数是一个字符串 %d : 这个参数是一个整数类型 %f ：这个参数是一个浮点数类型 """ # 第一题 i = 20 s = "我现在学习软件测试有%d个小时了" % i print (s) i = 25.5 s = "我现在学习软件测试有%f个小时了" % i print (s) # {}.format格式化 # 第二题 r = "我跟着{},学习{}".format("凯学长","软件测试") print (r) r = "{0}跟着{1}，学习{2},{0}学习了{3}小时".format("我" #0 ,"凯学长" #1 ,"软件测试" #2 ,10) #3 print (r) # 第三题 r = "欢迎{student_name}," \ "跟着{teacher_name}," \ "学习{course_name}." .format(course_name="软件测试" , student_name="小强" , teacher_name="凯学长") # 第四题 print (r) print ("请保留小数点后2位{:.2f}.format(3.1415926") print ("请保留小数点后2位，保留符号{:+.2f}".format(3.1415926)) print ("请保留小数点后2位，保留符号{:+.2f}".format(-3.1415926)) print ("不保留小数点{:.0f}".format(3.1415926)) print ("保留3位小数点{:.3f}".format(3.1415926)) print ("百分号显示{:.3f}".format(3.1415926))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
print打印结果：我来学习python
我来学习python
我现在学习软件测试有20个小时了
我现在学习软件测试有25.500000个小时了
我跟着凯学长,学习软件测试
我跟着凯学长，学习软件测试,我学习了10小时
欢迎小强,跟着凯学长,学习软件测试.
请保留小数点后2位{:.2f}.format(3.1415926
请保留小数点后2位，保留符号+3.14
请保留小数点后2位，保留符号-3.14
不保留小数点3
保留3位小数点3.142
百分号显示3.142
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
2. 字符串查找和成员运算
# coding=utf-8
# 字符串查找
s = "我爱凯学长"
# find的意思是我要在字符串s当中寻找“凯”在哪里
print (s.find("凯"))
print (s.find("aa"))
# 如果没有找到，那么find将返回-1
# 如果找到了，就返回其所在的字符串中的位置，位置从0开始
# 字符串的成员运算
# in / not in
# in 必须要完全匹配才会返回True
print ("学习" in "我跟凯学长学习")
print ("学习a" in "我跟凯学长学习")
print ("学习a" not in "我跟凯学长学习")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
print打印结果：6
-1
True
False
True
- 1
- 2
- 3
- 4
- 5
3. 聊天机器人小程序
# coding=utf-8 # 聊天机器人小程序 rebot = "小可爱" while True: user_message = input("我：") if "名字" in user_message: print ("{0}:我叫{0}".format(rebot)) elif user_message.find("学习")>-1: print ("{}:我跟着凯学长学习呀".format(rebot)) elif "老师" in user_message: print ("{}:我真鄙视你，你连凯学长不知道" ",赶紧学习去吧".format(rebot)) elif "水果" in user_message: print ("{}:我喜欢的水果很多呀，比如香蕉，苹果，大鸭梨".format(rebot)) elif "再见" in user_message: print ("{0}:再见，{0}会永远想你的".format(rebot)) break else: print ("{}: 对不起，我没有听懂你说什么".format(rebot))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
第七章 高级数据类型
1. 列表数据类型的声明与访问
# coding=utf-8 #列表数据类型的声明与访问 my_list =[1,2,3,4,5] # 列表中的元素 print (my_list) # 0 1 2 3 角标，索引 位置信息 my_list1 = ["a","b","c","d"] print (my_list1) print (my_list1[0]) print (my_list1[1]) my_list = [[1,2,3,4],["a","b","c","d"]] print (my_list) print (my_list[1]) print (my_list[1][0]) # 0 1 2 3 4 5 6 7 8 my_list = [1,2,3,4,5,"a","b","c","d"] # -9 -8 -7 -6 -5 -4 -3 -2 -1 print (my_list) print (my_list[:]) print (my_list[:2]) # 不包含右边 print (my_list[1:3]) # 包含左边的位置，不包含右边的位置 print (my_list [-1]) # 0 1 2 3 4 5 6 7 8 my_list = [1,2,3,4,5,"a","b","c","d"] # -9 -8 -7 -6 -5 -4 -3 -2 -1 print (my_list [-2]) print (my_list [:-1]) print (my_list [1:-1]) print (my_list[6:-4]) print (my_list[5:-1])
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
print打印结果：[1, 2, 3, 4, 5] ['a', 'b', 'c', 'd'] a b [[1, 2, 3, 4], ['a', 'b', 'c', 'd']] ['a', 'b', 'c', 'd'] a [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd'] [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd'] [1, 2] [2, 3] d c [1, 2, 3, 4, 5, 'a', 'b', 'c'] [2, 3, 4, 5, 'a', 'b', 'c'] [] ['a', 'b', 'c']
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
2. 列表数据类型元素的添加，更新和删除
# coding=utf-8 # 列表的元素的增加，删除和更新 my_list = [1,2,3,4,5,"a","b","c","d"] # 列表元素的添加 my_list.append(10) print (my_list) # 列表元素的更新 my_list[1] = 'h' print (my_list) # 列表元素的删除 # 根据元素的值来删除 my_list.remove("c") print (my_list) # 根据索引值来删除 my_list.pop(1) print (my_list)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
print打印结果：
[1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 10]
[1, 'h', 3, 4, 5, 'a', 'b', 'c', 'd', 10]
[1, 'h', 3, 4, 5, 'a', 'b', 'd', 10]
[1, 3, 4, 5, 'a', 'b', 'd', 10]
- 1
- 2
- 3
- 4
- 5
3 元组数据类型
# coding=utf-8 # 元组数据类型 t = (1,2,3) print (t[1]) # t .append(4) # t[1] = 5 # t.remove(2) # t.pop(1） print (t) """ 列表和元组的区别 列表允许增加，修改和删除操作 元组不允许增加，修改和删除操作 也就是说元组一旦声明了，就不允许更改了 """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
4 字典数据类型的声明与访问
# coding=utf-8 # 字典数据类型的声明与访问 # 下边这个样子的变量叫做字典 d ={ "a":"1", # 冒号前边的部分，我们叫做字典的key 键 "b":"2" # 冒号后边的部分，我们叫做字典的value 键 } # 键值对儿 print (d) print (type(d)) # 单独访问其所有的键 print (d.keys()) # 单独访问其所有的值 print (d.values()) # 我们可以根据字典的建议访问字典的值吗？？ print (d['a'])
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
print打印结果：
{'a': '1', 'b': '2'}
<type 'dict'>
['a', 'b']
['1', '2']
1
- 1
- 2
- 3
- 4
- 5
5 字典数据类型增加、修改和删除操作
# coding=utf-8 # 字典数据类型增加、修改和删除操作 my_dict ={ 1: "a", 2: "b", 3: "c" } dict1 = { 4: "d" } # 添加操作 update my_dict.update(dict1) print (my_dict) # 更新值 my_dict[1] = "aaaaa" print (my_dict) # 字典的删除操作 my_dict.pop(2) print (my_dict)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
print打印结果：
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
{1: 'aaaaa', 2: 'b', 3: 'c', 4: 'd'}
{1: 'aaaaa', 3: 'c', 4: 'd'}
- 1
- 2
- 3
6 for循环
# coding=utf-8 # for 循环 # 01234 s = "abcde" # 第一种 # print (s[0]) # 第二种 # for i in s: # print (i) l =["a","b","c","d"] for i in s: print (i) t =("a","b","c","d") for i in s: print (i)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
print打印结果：
a
b
c
d
e
a
b
c
d
e
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
第八章 函数的定义与使用
1 函数的返回值
# coding=utf-8 # 函数的返回值 def add(x,y): r = x + y print (22222) return r print (11111) # result = r result =add(1,2) print (result) # r2 = add(3,5) # r2 =8 r2 = add(result,5) print (r2) def add(x,y): if x == 1: return "我们的函数不给你算这么简单的" return x + y print (add(1,2)) print (add(2,3))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
print打印结果：
22222
3
22222
8
我们的函数不给你算这么简单的
5
- 1
- 2
- 3
- 4
- 5
- 6
2 函数的参数
# coding=utf-8 # 函数的参数 # 函数的默认参数 # 函数有的时候也有同学会叫做方法 # 但实际上函数与方法是不同场景下对函数的不同称呼 def calc_bmi(w,h,name="凯学长"): bmi =w / (h**2) return"您好，{}，您的bim指数是：{}".format(name,bmi) r = calc_bmi(185,75) print (r) r = calc_bmi(1.85,75,"小强啊") print (r) # 函数的默认参数，必须放在参数列表的尾部 def calc_bmi(w,h,name="凯学长"): bmi = w / (h**2) return "您好，{}，您的bmi指数是：{}".format(name,bmi) # 函数的不定长参数 # 不定长参数，传入到函数里边的时候，数据类型就变成了元组 def my_function(*param): print (param) print (type(param)) for i in param: print(i) my_function(1,2,3) my_function(1,2,3,4,5) # 指定参数名称 def calc_bmi(w,h,name="凯学长"): bmi =w / (h**2) return"您好，{}，您的bim指数是：{}".format(name,bmi) # 当我们指定参数名称的时候，就不需要按照顺序传入参数了 r = calc_bmi(w=80,h=1.80,name="小强") print (r) # 可变参数，函数接收参数以后，在函数内部就变成了字典数据类型 def my_function(**param): print (param) param(type(param)) for k,v in param.items(): print (k) print (v) my_function(a=1,b=2,c=3) my_function(w=80,h=1.80,name="小强")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
print打印结果：
您好，凯学长，您的bim指数是：0 您好，小强啊，您的bim指数是：0.000328888888889 (1, 2, 3) <type 'tuple'> 1 2 3 (1, 2, 3, 4, 5) <type 'tuple'> 1 2 3 4 5 您好，小强，您的bim指数是：24.6913580247 {'a': 1, 'c': 3, 'b': 2}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
