python开发环境和基础语法

最新推荐文章于 2024-11-14 13:48:50 发布

青空是没有云的空

最新推荐文章于 2024-11-14 13:48:50 发布

阅读量253

点赞数

分类专栏：软件测试文章标签：软件测试 while循环 if循环 return python

本文链接：https://blog.csdn.net/weixin_45860034/article/details/103263360

版权

软件测试专栏收录该内容

5 篇文章 0 订阅

订阅专栏

随机存储就是内存，断电数据丢失，优点是读写数据的速度很快

外存储器即硬盘，优点是断电数据仍然保存，缺点是督读写数据速度慢

操作系统

是一组具有特殊功能的程序，扮演了用户和硬件之间桥梁的作用，能简化对硬件的操作

Python开发环境搭建包含两部分：

编辑Python代码的编辑器
运行Python代码的解释器

Python集成开发环境（IDE）

变量可以在程序运行过程中，临时存储程序所需要处理的数据

变量命名规则：

标识符由字母、下划线、数字组成，数字不能开头
标识符是区分大小写的
变量名一般用小写加下划线组成
不能和关键字以及已有名字相冲突
变量名一定要有意义，提升代码的可读性

变量中的数据类型
在这里插入图片描述
算术运算符

复合赋值运算符

小数float，整数int，字符串str，%.2f表示小数点后只显示两位

占位符
在这里插入图片描述
变量之间的运算规则：

字符串和字符串之间只能进行加法运算
数字与数字之间都可运算
数字和字符串之间只能进行乘法运算

if分支语句：如果条件成立(True)则执行；不成立(Flase)则不执行
在这里插入图片描述
登录案例

input_username = input('您的用户名是:')
input_password = input('您的密码是:')

if input_username == 'admin':
    if input_password == 'ab123' :
        print('欢迎 %s 登录系统!' % input_username)
    else:
        print('您的用户名或密码错误!')
else :
    print('登录失败')

逻辑判断条件：and和、or且、not非

猜拳游戏

import random

user = int(input('请输入：拳头（0），剪刀（1），布（2）:'))
computer = random.randint(0,2)

if (user == 0 and computer == 1) or \
        (user == 1 and computer == 2) or \
        (user == 2 and computer == 0) :
    print('您赢了')
elif user == computer :
    print('平局')
else :
    print('您输了')

while语句

如果条件永远满足，则意味着循环永远被执行，叫做死循环，这是无意义的

# 写出1——100的偶数
i = 1
while i <= 100 :
    if i % 2 == 0 :
        print(i)
    i += 1

print('end')

函数的优点：

减少代码冗余，减少维护量，实现功能的封装，降低学习成本，提升开发速度
调用函数时既传递参数问题，又传递关键字参数，应注意：位置参数一定要在关键字参数前面

函数的返回值：return关键字

当函数执行到return时，函数会马上停止执行
函数中可以出现多个return，但是有且只有一个return会执行
return后面可以不跟值，return可以单独使用，等价于return None

若（a，20），在调用函数时传递的真实数据（20）叫实参，代表指定数据（a）的叫形参

按照从左到右的顺序传递叫做位置参数，按照形参名字传递叫做关键字参数

注意点：

continue即跳过本次循环，如果在while嵌套，内层循环执行了continue，对外层循环没有任何影响，break（退出循环）同理
print、return表示函数，执行一个功能；while（循环语句）、if（分支语句、def（定义函数）是一个语句
print只负责将内容输出到屏幕上，而return会将函数计算结果返回给函数的调用者
看到冒号，下面的函数体需要缩进
给函数形参某个位置设置了默认参数，那么该位置之后的所有参数都必须设置默认参数（a=10,b=20),b不能单独写

全局变量（g_val)：在函数外部定义的变量，可以被python文件内的所有函数直接使用

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

变量要先定义再使用，遵循就近原则

作用域：表明变量能够被访问到的范围

函数文档相当于函数注释，解释函数的作用，快捷键是ctrl+q

函数应当满足单一职责原则：一个函数负责一个功能

容器：一个容器可以存储多个变量元素，能减少变量的定义

序列式容器：在存放时是连续存放的，包括字符串、列表、元组；支持索引
非序列式容器：不连续存放的，包括字典、集合

序列式容器中，会给每一个元素赋予一个编号，该编号从0开始计算，支持根据下标存取元素

遍历：不重复地访问容器中的每一个元素

索引支持正数索引，也支持负数索引

正数：0——10+

负数：字符串倒数-1～-10+

my_str = 'hello'

my_str = "hel"

print(my_str[0])# 0是索引，下标

for v in my_str:
    print(v)

replace并不会替换原本的字符串，替换完毕之后会返回一个新的字符串

sentence = '我有一个梦想，是成为称霸世界的海贼王，我相信我会成功的！'
my_sen = sentence.replace('我', '她')
print(my_sen)
print('') # 用于换行
my_sen = sentence.replace('我', '她',2)
print(my_sen)
# 她有一个梦想，是成为称霸世界的海贼王，她相信她会成功的！
# 
# 她有一个梦想，是成为称霸世界的海贼王，她相信我会成功的！

# 后面的数字是几，替换到第几个字

字符串一旦定义不允许修改
字符串容器中的元素都是字符类型的

user_mail = '1995xrbmfk@gmail.com'
print(user_mail[2])
# 返回的结果是'9'

# 如何获取@的位置 find方法默认从字符串（0）位置开始查找，也可指定位置，返回结果即查找结束位置
my_mail = user_mail.find('5')
print(my_mail)
# 返回的结果是'3',即计数从0开始

# 切片语法，左闭右开，右边出现的最后一个结果不显示

# 冒号第一位默认为0，冒号两边的数字可写可不写
print(user_mail[0:10])
# 返回的结果是'1995xrbmfk'

#获得容器的个数，即获取字符串长度
str_length = len(user_mail)
print(user_mail[9:str_length])
# 返回的结果是'k@gmail.com'

#步长：即根据数字选取其倍数位置的值，第二个冒号后的数字定义步长
print(user_mail[0:17:4])
# 返回的结果是'1xfm.'

#步长可以为负数，相当于字符串逆序
print(user_mail[::-1])
# 返回的结果是'moc.liamg@kfmbrx5991'
print(user_mail[-2:-7:-1])
# 返回的结果是'oc.li'

邮箱案例

user_mail = 'xbrhui@gmail.com'
position = user_mail.find('@')
# 如果查找得到，则会返回子串第一次出现的位置
# 如果查找不到@，返回结果是-1

if position == -1:
    print('邮箱不合法')
else :
    user_name = user_mail[:position]
    houzhui = user_mail[position+1:]
    print('用户名是：', user_name)
    print('邮箱后缀是：', houzhui)

split函数：将原字符串分割为多个部分，以列表的形式返回结果

count函数：计算指定数值出现的次数

# -*-coding:utf-8-*-

from __future__ import print_function
# 使print中的值不换行且中文输出

user_name = '1999shxbe@qq.com'
count_name = user_name.count('@')
if count_name > 1 :
    print('您的邮箱不合法!')
else :
    user_name = user_name.split('@')
    print('您的邮箱用户名是：',user_name[0])
    print('您的邮箱后缀名是：',user_name[1])

strip函数默认去除字符串两侧的空格，中间的不去

isalpha函数判断字符串所有元素是否都是字母

isdigit函数判断字符串所有元素是否都是数字

user_name = str(input('请输入您的用户名：'))

user =user_name.strip()

if user.isalpha():
    print('注册成功！')
else :
    print('注册失败！')

字符串中的元素不能修改，而且元素类型单一；列表中元素可以修改，且能自定义，支持索引、切片

# 空列表
my_list = []
# 列表可存放多个多种类型的元素，为了运行方便，尽量使用同种类型元素
my_list = [10,20,30]
my_list = ['aaa', 'bbb', 'ccc']
my_list = [1,2], [3,6] ,[7,8]
my_list = ['Trump', 60,3.14, [1,2]]

列表与遍历

my_list = [10,20,30,40]
print(my_list[0:2])
print(my_list[0],my_list[2])

# 1.
my_list = [[10,20,30],[40,50,60],['aa','bb','cc']]
i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1
print('#'*30)
# 2. for 循环一般用于容器中元素的遍历
for v in my_list:
    print(v)
"""
返回结果是：
[10, 20, 30]
[40, 50, 60]
['aa', 'bb', 'cc']
"""
print("#"*30)
# 1.寻找列表中的列表数据
my_list = [[10,20,30],[40,50,60],['aa','bb','cc']]
i = 0
while i < len(my_list):
    j = 0
    while j <len(my_list[i]):
        print(my_list[i][j])
        j += 1
    i += 1

print("#"*30)

# 2.
for i in my_list:
    for v in i :
        print(v)
"""
返回结果是：
10
20
30
40
50
60
aa
bb
cc
"""

列表：支持位置删除（尾部删除、指定位置删除）

缺点：根据关键字查找效率低；在指定位置插入和删除元素，会造成数据元素的移动

优点：列表根据位置、索引进行查找时效率较高；对于列表而言，尾部插入／删除数值效率更高，不需要移动原有元素位置

列表元素排序

# 创建一个包含了10个随机数的列表
import random
my_list = []
i = 0
while i < 10:
    # 产生随机数，并将随机数插入到列表中
    random_num = random.randint(1,1000)
    my_list.append(random_num)
    i += 1
print(my_list)

# 对列表中的元素进行排序，sort，默认排序从小到大
my_list.sort()
print(my_list)

# 将sort函数的reverse默认值改为True，即可实现从大到小降序排列
my_list.sort(reverse = True)
print(my_list)

# 逆序，reverse函数
my_list.reverse()
print(my_list)

列表查找

my_list = [10,20,30,300]
old_num = 30
new_num =200
# index用于根据值查询值的所在位置，如果查询值不存在则失败，会报错
if old_num in my_list:
    #查找到old_num的位置
    pos = my_list.index(old_num)
    # 根据位置修改定义新的值
    my_list[pos] = new_num
print(my_list)

# extend 将一个列表中的所有元素追加到当前列表的尾部
my_list2 = ['aa','bb']
my_list.extend(my_list2)
print(my_list)
# 返回结果是：[10, 20, 200, 300, 'aa', 'bb']

列表案例练习

# 需求：一个学校有3个空余办公室，将8个新老师随机分配到自己的工位上

import random
# 1.先定义学校和办公室
school = [ [],[] ,[] ]

# 3.定义一个列表型的函数
def c_teacher():
# 2.定义列表保存老师
    teacher_list = []
    index = 1
    while index <= 8 :
        # 创建老师的名字
        teacher_name = '老师'+ str(index)
        #把老师装进盒子里
        teacher_list.append(teacher_name)
        index += 1
    return teacher_list# 此为局部变量

# 此teacher_list为外部变量，新的赋值，含义不同，修改上面一个teacher_list不会影响下面一个teacher_list
# 函数调用多次，每次返回一个新的值
teacher_list = c_teacher()
print(teacher_list)
teacher_list = c_teacher()
print(teacher_list)

# 4.分配老师
for teacher in teacher_list:
    office_num = random.randint(0,2)
    school[office_num].append(teacher)
print(school,end='')
print()

# 5.查看每个办公室有哪些老师
for office in school:
    for teacher in office:
        print(teacher,end = ' ')
    print()

元组

python中的元组和列表类似，不同之处在于元组的元素不能修改，元组使用小括号，创建元组只需要在括号中添加元素，并使用逗号隔开即可

元组是序列式容器，支持遍历、查找、切片等操作

作用：从语法的层面来限制数据的意外修改

元组相对来说比列表更节省空间

my_tuple = (10,20,30)
print(my_tuple[0])
# 返回结果是：10

# 注意：元组中如果只有1个元素的话，需要在元素后面添加一个逗号
my_tuple = (10,)
print(my_tuple)

# 元组可以嵌套元组
my_tuple = ((1,2),(3,4))
print(my_tuple)

my_tuple = (1,2,3)
for v in my_tuple:
    print(v)

# 查询1在元组中的位置
pos = my_tuple.index(1)
print(pos)

字典

查找效率比较高，但是占用内存高，以时间换空间

字典的每个键值key=>value对用冒号分割，多个键值对用逗号分割

键一般是唯一的，若重复，则最后的一个键值对会替换前面的，值不需要唯一

字典是非序列容器，不支持索引、切片操作、字典的查询性能优于列表

my_dict = {'name':'虾皮','age':18,'sex':'女'}

print(my_dict['name'])
# 返回结果是：虾皮

my_dict['sex'] = '男'
print(my_dict)
# 返回结果是：{'name': '虾皮', 'age': 18, 'sex': '男'}

# 使用 get 方法，如果查找的key不存在，返回结果是 None
print(my_dict.get('age1'))

# 也可以自定义指定返回默认值
print(my_dict.get('age1','输入key错误'))
# 返回结果是：输入key错误

# 如果key不存在，则添加键值对
my_dict['score']='95'
print(my_dict)
# 返回结果是：{'name': '虾皮', 'age': 18, 'sex': '男', 'score': '95'}

# 如果key存在，则修改键值对
my_dict['name']='夏天'
print(my_dict)
# 返回结果是：{'name': '夏天', 'age': 18, 'sex': '男'}

字典的增删改查

my_dict = {'name':'Obama','age':20,'socre':50,'sex':'男'}

# 删除字典里的元素，也可删除列表中的元素
del my_dict['age']
print(my_dict)

# 清空字典
my_dict.clear()
print(my_dict)

#遍历字典
my_dict = {'name':'Obama','age':20,'socre':50,'sex':'男'}

# keys 方法获取所有的键列表
key_list = my_dict.keys()
print(list(key_list))
# 返回结果是：['sex', 'age', 'socre', 'name']

# keys 方法获取所有的值列表
value_list = my_dict.values()
print(list(value_list))
# 返回结果是：['男', 20, 50, 'Obama']

# items 里面返回的值是元组形式，列表中的每组数据都是一条键值对
key_value_list = my_dict.items()
print(list(key_value_list))
# 返回结果是：[('socre', 50), ('age', 20), ('name', 'Obama'), ('sex', '男')]

# 用for 循环遍历键值对
for key_value in key_value_list :
    print(key_value)
# 返回的结果是：
# ('name', 'Obama')
# ('age', 20)
# ('socre', 50)
# ('sex', '男')

# 使用 while循环遍历字典
my_list = list(my_dict.items())
i = 0
while i < len(my_list):
    print('key:',my_list[i][0],'value:',my_list[i][1])
    i += 1
# 返回结果是：
# key: sex value: 男
# key: socre value: 50
# key: name value: Obama
# key: age value: 20

文件：作用就是计算机存储数据

文件打开分为读、写、追加模式，其中又分为文本模式和二进制模式
在这里插入图片描述

打开文件用的文本模式，会进行换行符转换
打开文件用的是二进制模式的话，不会进行换行符转换
文件本质上都是以二进制方式存储在磁盘上的

# 在文件中写入数据
f = open('a.txt','w')
my_content = '你在桥上看风景，窗边的人在看桥上的你'
f.write(my_content)
f.close()

# 读取文件中的数据
f = open('a.txt','r')
my_content = f.read()
print(my_content)
f.close()

# write会将已有内容覆盖掉
# 如果原文件不存在，则添加文件
def test01():
    f = open('hh.txt','w')
    f.write('只缘身在此山中')
    f.close()
test01()


def test02():
    fa = open('hh.txt','r')
    my_content = fa.read()
    print(my_content)
    fa.close()
test02()

# 在文件中追加数据，"\n"代表换行
def test03():
    fb = open('hh.txt','a')
    my_content = fb.write('\n'+'一个孤独的人')
    fb.close()
test03()

文件拷贝

# 需求：将a.txt的文件拷贝到新文件中

old_file_name = input('请输入您想要拷贝的文件名：')
new_file_name = old_file_name + '.bk'
open(old_file_name,'rb')
open(new_file_name,'wb')

new_file_name.write()

new_file_name.close()
old_file_name.close()

文件和目录的操作

# 对文件的操作需要在 import os 中进行
import os

# 文件重命名，将文件'a.txt'的名称改为'xia.txt'
os.rename('a.txt','xia.txt')

# 文件删除 括号里应当写 文件完整路径+文件名
# 要注意路径问题，如果只写文件名，默认在当前目录下找文件，如果找不到会报错
os.remove('/Users/chenzhenyuan/Desktop/1.jpg')

# 创建目录
os.mkdir('/Users/chenzhenyuan/Desktop/abc.txt')
# 删除目录
os.rmdir('/Users/chenzhenyuan/Desktop/abc.txt')

# 获得指定目录下的文件列表
print(os.listdir())

# 获得和设置工作目录  cwd:current work directory
print(os.getcwd())

# 将默认的工作目录转换为我的桌面 括号里的为新路径
os.chdir('/Users/chenzhenyuan/Desktop')