前言

那么多编程语言，为什么学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	print
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 = """

唱歌

跳舞"""

7. 编码

Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -- coding: UTF-8 -- 进行指定。

Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。

8. 输入输出

Python 输出使用 print()，内容加在括号中即可。如下所示：

print('Hello Python')

Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。如下所示：

name = input()

print('Hi',name)

9. 缩进

Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变。如下所示：

if True:

    print(True)

else:

    print(False)

10. 多行

Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示。如下所示：

a = 128

b = 1024

c = 512

d = a + \

    b - \

    c

如果包含在 []、{}、() 括号中，则不需要使用 \。如下所示：

arr = {

    a,

    b,

    c

}

11. 注释

Python 中单行注释使用 #，多行注释使用三个单引号（'''）或三个双引号（"""）。如下所示：

# 我是单行注释

'''

我是多行注释

我是多行注释

'''

"""

我是多行注释

我是多行注释

"""

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

13.2 运算符优先级

运算符	                        描述（由上至下对应优先级由高到低）

**	                        幂运算

~ + -	                        取反、正号、负号

* / % //	                乘、除、取模、取整除

+ -	                        加法、减法

>> <<	                        右移、左移

&	                        与

^ |	                        异或、或

<= < > >=	                比较运算符

== !=	                        是否等于、是否不等于

= %= /= //= -= += *= **=	赋值运算符

is is not	                身份运算符

in not in	                成员运算符

not and or	                逻辑运算符

第二章开始编程前的准备

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-2_alltop_positive~default-2-122915089-null-null.142^v70control,201^v4add_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-2_allbaidu_landing_v2~default-1-127081741-null-null.142^v70control,201^v4add_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. 变量与关键字

变量：

i = 1

print (i)

j = 2

print (j)

print打印结果：1、2

关键字：

import keyword

print (keyword.kwlist)

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!

你好，世界！！

""")

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ml9msswI-1675162173279)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/569d3a7949c0430487288c1bd61c92c1~tplv-k3u1fbpfcp-watermark.image?)]

# \叫做转义字符

print (""")

print打印结果："

3. python基本数据类型

# python中的数据类型

# 整数数据类型  1、2、3、4

# 字符串：是使用一堆儿单引号或双引号包裹起来的字符

# 浮点数 1.23

# 布尔类型 True False

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)

print打印结果：3、-1、2、0

s1 = "hello"

s2 = "world"

print(s1 + s2)

# 字符串与字符串之间不可以相减，相乘，相除

print(s1 - s2)

print(s1 * s2)

print(s1 / s2)

print打印结果：字符串与字符串之间不可以相减，相乘，相除

f1 = True

f2 = False

print(f1 + f2)

print(f1 - f2)

print(f1 * f2)

print(f1 / f2)

print打印结果：不能除

5.数据类型转换

i = 1

print(type(i))

j = 1.2

print(type(j))

x = "aa"

print(type(x))

y = True

print(type(y))

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

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、

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

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...

7 循环语句

当需要多次重复执行时，我们要用到循环语句，Python 提供了 for 循环和 while 循环。

7.1 for 循环

for 循环可以遍历任何序列，比如：字符串。如下所示：

str = 'Python'

for s in str:

print(s)

输出结果：

Python

7.2 while 循环

while 循环，满足条件时进行循环，不满足条件时退出循环。如下所示：

sum = 0

m = 10

while m > 0:

    sum = sum + m

    m = m - 1

print(sum)

输出结果：

7.3 break

break 用在 for 循环和 while 循环语句中，用来终止整个循环。如下所示：

str = 'Python'

for s in str:

if s == 'o':

break

print(s)

输出结果：

Pyth

7.4 continue

continue 用在 for 循环和 while 循环语句中，用来终止本次循环。如下所示：

str = 'Python'

for s in str:

    if s == 'o':

    continue

print(s)

输出结果：

Pythn

8. pass 语句

pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。如下所示：

if True:    pass

9 字符串基本使用

9.1 访问

访问单个字符

s = 'Python'

# 访问第一个字符  P

print(s[0])

访问范围内字符

s = 'Python'

# 访问 yt

print(s[1:3])

# 访问 Pyt

print(s[:3])

# 访问 hon

print(s[3:])

9.2 单个字符编码

Python 使用了 ord() 函数返回单个字符的编码，chr() 函数把编码转成相应字符。如下所示：

s = 'A'

print(ord(s))

print(chr(65))

输出结果：

65A

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')

输出结果：

s1 + s2 --> HelloPythons

1 * 2 --> HelloHellos

1[0] --> H

s1[0:2] --> He

"H" in s1 --> True

"H" not in s1 --> False

\r --> \r

9.5 格式化

当我们需要输出的内容中含有变量时，比如：Hello xxx，xxx 为变量，此时便需要一种格式化字符串的方式，Python 使用 % 格式化字符串，常用占位符如下表所示：

占位符	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数

以字符串为例，如下所示：

print('Hello %s' % 'Python')

输出结果：

Hello Python

我们也可以使用字符串的 format() 方法进行格式化，先看下示例：

print('{0} {1}'.format('Hello', 'Python'))

这种方式是用传入的参数依次替换字符串内的占位符{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])

输出结果：

str[0] str[-6] = P P

str[5] str[-1] = n n

从结果来看，我们使用非负数索引与负数索引得到的结果一致。

2.2 切片

切片操作可以访问一定范围内的元素，语法如下所示：

sname[start : end : step]

sname：表示序列的名称；
start：开始索引位置（包括该位置），默认为 0；
end：表示切片的结束索引位置（不包括该位置），默认为序列的长度；
step：步长。

以字符串为例，如下所示：

str = 'Python'

print(str[:3])

print(str[3:])

print(str[:])

输出结果：

Python

Python

2.3 相加

Python 支持类型相同的序列使用 + 作相加操作，该操作不会去除重复的元素。以字符串为例，如下所示：

str1 = 'Python'

str2 = 'Python'

print('str1 + str2 --> ',str1 + str2)

输出结果：

str1 + str2 -->  PythonPython

2.4 相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，内容为原来序列被重复 n 次的结果。以字符串为例，如下所示：

str = 'Python'

print('2 * str --> ',2 * str)

输出结果：

2 * str -->  PythonPython

2.5 元素是否在序列中

Python 使用 in 关键字检查某元素是否为序列的成员，语法如下：

val in seq

val：要检查的元素；
seq：指定的序列。

通过一个例子作进一步了解，以字符串为例，如下所示：

str = 'Python'

print('on'in str)

输出结果：

True

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

输出结果：

len --> 5

max --> e

sorted --> ['a', 'b', 'c', 'd', 'e']

14. 列表基本使用

➢ 创建

列表中所有元素都放在一个中括号 [] 中，相邻元素之间用逗号 , 分隔，如下所示：

l = [1024, 0.5, 'Python']

➢ 访问

通过索引访问列表中的值，还可以使用 : 截取范围内的元素，如下所示：

l = [1024, 0.5, 'Python']

print('l[0] -->', l[0])

print('l[1:] -->', l[1:])

输出结果：

l[0] --> 1024

l[1:] --> [0.5, 'Python']

➢ 更新

除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素，如下所示：

l = [1024, 0.5, 'Python']

# 修改列表中第二个元素

l[1] = 5

# 向列表中添加新元素

l.append('Hello')

print('l[1] -->', l[1])

print('l -->', l)

输出结果：

l[1] --> 5

l --> [1024, 5, 'Python', 'Hello']

➢ 删除

使用 del 删除列表中元素，如下所示：

l = [1024, 0.5, 'Python']

# 删除列表中第二个元素del l[1]

print('l -->', l)

输出结果：

l --> [1024, 'Python']

➢ 常用方法

① count()

统计列表中某个元素出现的次数，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

print("l.count('d') -->", l.count('d'))

输出结果：

l.count('d') --> 2

② index()

查找某个元素在列表中首次出现的位置（即索引），使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

print("l.index('d') -->", l.index('d'))

输出结果：

l.index('d') --> 0

③ remove()

移除列表中某个值的首次匹配项，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

l.remove('d')

print("l -->", l)

输出结果：

l --> ['b', 'a', 'f', 'd']

④ sort()

对列表中元素进行排序，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

l.sort()

print('l -->', l)

输出结果：

l --> ['a', 'b', 'd', 'd', 'f']

⑤ copy()

复制列表，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

lc = l.copy()

print('lc -->', lc)

输出结果：

lc --> ['d', 'b', 'a', 'f', 'd']

15. 元组基本使用

15.1 简介

元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。

15.2 基本使用

➢ 创建

元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示：

t = (1024, 0.5, 'Python')

➢ 访问

与访问列表中元素类似，如下所示：

t = (1024, 0.5, 'Python')

print('t[0] -->', t[0])

print('t[1:] -->', t[1:])

输出结果：

t[0] --> 1024

t[1:] --> (0.5, 'Python')

➢ 修改

元组中元素不能被修改，我们要用重新赋值的方式操作，如下所示：

t = (1024, 0.5, 'Python')

t = (1024, 0.5, 'Python', 'Hello')

print('t -->', t)

输出结果：

t --> (1024, 0.5, 'Python', 'Hello')

➢ 删除

元组中的元素不能被删除，我们只能删除整个元组，如下所示：

t = (1024, 0.5, 'Python')

del t

print('t -->', t)

输出结果：

NameError: name 't' is not defined

由于元组实例被删除，所以输出了异常信息。

➢ 常用方法

① len()

计算元组中元素个数，使用如下所示：

t = (1024, 0.5, 'Python')

print('len(t) -->', len(t))

输出结果：

len(t) --> 3

② max() 和 min()

返回元组中元素最大、最小值，使用如下所示：

t = ('d', 'b', 'a', 'f', 'd')

print('max(t) -->', max(t))

print('min(t) -->', min(t))

输出结果：

max(t) --> f

min(t) --> a

③ tuple()

将列表转换为元组，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']

t = tuple(l)

print('t -->', t)

输出结果：

t --> ('d', 'b', 'a', 'f', 'd')

16 字典

字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示：

d = {'name':'小明', 'age':'18'}

# 使用 dict 函数

# 方式一

l = [('name', '小明'), ('age', 18)]

d = dict(l)

# 方式二

d = dict(name='小明', age='18')

# 空字典

d = dict()

d = {}

字典中的值通过 key 进行访问，如下所示：

>>> d = dict(name='小明', age='18')

>>> d['name']

'小明'

# 使用 get 方法

>>> d.get('name')

'小明'

修改操作，以修改 age 为例，如下所示：

>>> d = dict(name='小明', age='18')

>>> d['age'] = '20'

>>> d['age']

'20'

清空集合，如下所示：

>>> d = dict(name='小明', age='18')

>>> d.clear()

>>> d{}

获取字典的长度，如下所示：

>>> d = dict(name='小明', age='18')

>>> len(d)

2

17 集合

集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的。

集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例，如下所示：

s = {'a', 'b', 'c'}

# 使用 set 函数

s = set(['a', 'b', 'c'])

# 空集合

s = set()

集合中重复的元素会被自动过滤掉，如下所示：

>>> s = {'a', 'a', 'b', 'c', 'c'}

>>> s

{'a', 'c', 'b'}

添加元素可以使用 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'}

删除元素使用 remove 方法，如下所示：

>>> s = {'a', 'b', 'c'}

>>> s.remove('c')

>>> s

{'a', 'b'}

清空集合使用 clear 方法，如下所示：

>>> s = {'a', 'b', 'c'}

>>> s.clear()

>>> s

set()

获取集合的长度，同样使用 len 方法，如下所示：

>>> s = {'a', 'b', 'c'}

>>> len(s)3

第四章逻辑运算与比较运算

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"）

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")

# 如果判断条件非常多，我们就是用（）将优先级划分明确

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 ("好好想一想，是不是输入有错误了")

print打印结果：

欢迎使用BMI指数计算器，请输入您的体重(单位为千克)：80

请输入您的身高（单位为米）：1.8

您的BMI指数的值是:24.6913580247

您的体重偏重，注意饮食，要略微控制一下

第五章程序中的循环

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 ("代码执行完毕")

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，我要跳出循环

代码执行完毕

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)

print打印结果：

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，那么意味着清除之前的运算，重新开始

"""

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. 字符串格式化

# 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))

print打印结果：我来学习python

我来学习python

我现在学习软件测试有20个小时了

我现在学习软件测试有25.500000个小时了

我跟着凯学长,学习软件测试

我跟着凯学长，学习软件测试,我学习了10小时

欢迎小强,跟着凯学长,学习软件测试.

请保留小数点后2位{:.2f}.format(3.1415926

请保留小数点后2位，保留符号+3.14

请保留小数点后2位，保留符号-3.14

不保留小数点3

保留3位小数点3.142

百分号显示3.142

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 "我跟凯学长学习")

print打印结果：6

-1

True

False

True

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. 列表数据类型的声明与访问

# 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])

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']

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)

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]

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)

"""

列表和元组的区别

列表允许增加，修改和删除操作

元组不允许增加，修改和删除操作

也就是说元组一旦声明了，就不允许更改了

"""

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'])

print打印结果：

{'a': '1', 'b': '2'}

<type 'dict'>

['a', 'b']

['1', '2']

1

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)

print打印结果：

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

{1: 'aaaaa', 2: 'b', 3: 'c', 4: 'd'}

{1: 'aaaaa', 3: 'c', 4: 'd'}

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)

print打印结果：

a

b

c

d

e

a

b

c

d

e

第八章函数的定义与使用

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

print打印结果：

22222

3

22222

8

我们的函数不给你算这么简单的

5

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="小强")

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}

学习python的编程语言的更多相关文章

学习 python 编写规范 pep8 的问题笔记
决定开始Python之路了,利用业余时间,争取更深入学习Python.编程语言不是艺术,而是工作或者说是工具,所以整理并遵循一套编码规范是十分必要的.所以今天下午我根据PEP 8整理了一份,以后都照此 ...
编程语言千千万，为什么学习Python的占一半？
如果让你从数百种的编程语言中选择一个入门语言?你会选择哪一个? 是应用率最高.长期霸占排行榜的常青藤 Java?是易于上手,难以精通的 C?还是在游戏和工具领域仍占主流地位的 C++?亦或是占据 Wi ...
学习Python的三种境界
前言王国维在<人间词话>中将读书分为了三种境界:"古今之成大事业.大学问者,必经过三种之境界:'昨夜西风凋碧树,独上高楼,望尽天涯路'.此第一境也.'衣带渐宽终不悔,为伊消得人 ...
1 python学习——python环境配置
1 python学习--python环境配置要学习python语言,光看书看教程还是不好,得动手去写.当然,不管学习什么编程语言,最佳的方式还在于实践. 要实践,先得有一个Python解释器来解释执 ...
学习Python编程的11个资源
用 Python 写代码并不难,事实上,它一直以来都是被声称为最容易学习的编程语言.如果你正打算学习 web 开发,Python 是一个不错的选择,甚至你想学游戏开发也可以从 Python 开始,因 ...
学习Python编程的11个精品资源
本文由伯乐在线 - atupal 翻译自 Alex Ivanovs.欢迎加入技术翻译小组.转载请参见文章末尾处的要求. 用 Python 写代码并不难,事实上,它一直以来都是被声称为最容易学习的编程 ...
【转】布同：如何循序渐进学习Python语言
大家都知道Python语言是一种新兴的编程语言.1989年,Python就由Guido van Rossum发明.Python一直发展态势很好. 原因有几点:1.跨平台性好.Linux.Windows ...
小白学习Python之路---开发环境的搭建
本节内容 1.Python的介绍 2.发展史 3.安装Python 4.搭建开发环境 5.Hello World程序一.Python的介绍 Python的创始人为荷兰人吉多·范罗苏姆(Guido v ...
初步学习python
自计算机诞生以来,也伴随着计算机语言的诞生,现在,全世界的编程语言有600多种,但流行的编程语言也就20多种. Java和C一直占据着前两名.但是近年来伴随着人工智能的发展,Python发展迅猛,以其 ...
新手如何学习python(python学习路线图)
现在互联网巨头,都已经转投到人工智能领域,而人工智能最好的编程语言就是python,未来前景显而易见.这是小编给大家整理的python学习路线图,按照此教程一步步的学习来,肯定会对python有更深刻 ...

随机推荐

C#中winform DataGridView常用修改点
1.修改列名一般情况下,从数据库里面读取的列名是英文或者拼音,但是,有时候显示需要中文,这样就需要修改列名了. dgv.Columns[0].HeaderCell.Value="编号&qu ...
关于入门深度学习mnist数据集前向计算的记录
import osimport lr as lrimport tensorflow as tffrom pyspark.sql.functions import stddevfrom tensorfl ...
DevOps | 企业内源(内部开源）适合什么样的公司
框架类是否适合企业内源? 框架类都由公司早期来的一些大佬们负责(相当于技术委员会),更新频率非常低.给框架类提MR的人,多数本身就在技术委员会. 如果公司的人员众多,类似BAT级别,几万人使用的框架, ...
图解ReentrantLock底层公平锁和非公平锁实现原理
在面试或者日常开发当中,经常会遇到公平锁和非公平锁的概念. 两者最大的区别如下 1️⃣ 公平锁:N个线程去申请锁时,会按照先后顺序进入一个队列当中去排队,依次按照先后顺序获取锁.就像下图描述的上厕所的 ...
解决win7设置默认程序打开方式失效
问题描述我在设置一个文件(.ui)的默认程序打开,总是失效.设置不成功. 原因正常这个程序应该用 designer.exe 打开,但是我之前设置过(.ui)默认程序打开程序为designer.ex ...
为什么标准库的模板变量都是inline的
最近在看标准库里的type_traits的时候发现了个有趣的地方,几乎所有在标准库里的变量模板都是inline的! 不仅常见的实现上(libstdc++.libc++.ms stl)都是inline的 ...
ssh框架中文保存数据库MySQL乱码
检查后台获取前端页面数据打印到console控制台无乱码:tomcat配置没有问题: 检查MySQL数据库编码设置:字符集:utf8 -- UTF-8 Unicode,排序规则:utf8_genera ...
Go1.20 新版覆盖率方案解读
玩过Go覆盖率的同学当有所了解,Go的覆盖率方案最初的设计目标仅是针对单测场景,导致其局限性很大.而为了适配更多的场景,行业内各种博客.插件.黑科技介绍也层出不穷.当然,过去我们也开源过Go系统测试覆 ...
打印九九乘法表，打印金字塔-java
/** * *** ***** 打印如图金字塔 *=i*2-1 (竖)空格数=列数-1 */ public class Circulate{ public static void main(Strin ...
JavaScript入门②-函数(1)基础{浅出}
01.JS函数基础 1.1.函数定义函数(方法)就是一段定义好的逻辑代码,函数本身也是一个object引用对象.三种函数构造方式: ① 函数申明:function 函数名(参数){代码},申明函数有 ...

学习python的编程语言

前言

那么多编程语言，为什么学python

第一章 python基础

1. 课程整体介绍

2. 反复执行的用例如何提升效率

3. 自动化测试这么厉害可以完全替代我们手工测试吗

4. 标识符

5. 关键字

6. 引号

7. 编码

8. 输入输出

9. 缩进

10. 多行

11. 注释

12. 数据类型

13. 运算符

第二章 开始编程前的准备

1. 测试领域，python能做什么？

2. 测试领域以外，python能做什么

3. python还有什么其他的优点

4. pycharm下载与安装

5. 第一个python程序（右键点击run）

第三章 基本数据类型

1. 变量与关键字

2. 单行打印与多行打印

3. python基本数据类型

4. python中的算法运算

5.数据类型转换

6 条件语句

7 循环语句

7.1 for 循环

7.2 while 循环

7.3 break

7.4 continue

8. pass 语句

9 字符串基本使用

9.1 访问

9.2 单个字符编码

9.3 转义符

9.4 运算符

9.5 格式化

13 序列基本使用

13.1 索引

2.2 切片

2.3 相加

2.4 相乘

2.5 元素是否在序列中

2.6 内置函数

14. 列表基本使用

15. 元组基本使用

15.1 简介

15.2 基本使用

16 字典

17 集合

第四章 逻辑运算与比较运算

1.条件控制逻辑

2.逻辑运算符

3.BMI指数计算器

第五章 程序中的循环

1. 第一个循环-while

2. 赋值运算符

3. 一起写个计算器

4.完善计算器

第六章 字符串进阶

1. 字符串格式化

2. 字符串查找和成员运算

3. 聊天机器人小程序

第七章 高级数据类型

1. 列表数据类型的声明与访问

2. 列表数据类型元素的添加，更新和删除

3 元组数据类型

4 字典数据类型的声明与访问

5 字典数据类型增加、修改和删除操作

6 for循环

第八章 函数的定义与使用

1 函数的返回值

2 函数的参数

学习python的编程语言的更多相关文章

随机推荐

第二章开始编程前的准备

第三章基本数据类型

第四章逻辑运算与比较运算

第五章程序中的循环

第六章字符串进阶

第七章高级数据类型

第八章函数的定义与使用