python学习笔记(上)

2020-05-15  吴水荣 

后端代码,学习过的有C、C++、Java、python,前端的学过html css js等等,但这些基本都是大学期间学的,笔记什么的,估计就在吉大的某个垃圾角里分解完多年了吧。python却是新学习的,但是类封装后面的知识点,因为种种原因没有学完,打算这段时间补上,先把之前的笔记存好,接下来学的,就算是(下)吧。

一、Python开发环境
计算机软件、硬件系统
1、计算机是能够进行数值运算、逻辑运算,并且具有存储功能的电子设备
2、计算机由硬件系统和软件系统构成
3、计算机所有程序的运行都是在内存中进行的
4、操作系统的作用就是来管理硬件,为普通用户和开发者提供一种间接控制硬件的方式
5、操作系统为普通用户提供了终端、图形化操作硬件的方式
6、操作系统为开发者提供了系统调用操作硬件的方式
7、驱动程序扮演操作系统和硬件之前的桥梁

编程语言:
是人们为了控制计算机而发明的一种符号和文字的组合,从而实现向计算机发出指令。
Python语言就是一种编程语言,由符号和文字组成的,使用Python语言的目的就是为了控制计算机硬件进行工作


解释器
编程语言是文字和符号的组合,而CPU只认0和1,所以需要解释器来负责将文字和符号转为机器指令,其本质上就是一个运行在操作系统上的程序

二、基本语法:
1、注释
使用#开头并且加空格
多行注释是按着shift键按2次双引号,会出现一对三引号,在中间写多行注释
"""
这是多行注释
"""
选中多行,按ctrl+/   会把多行一起加上#号

2、变量:存储程序运行过程中产生的临时数据
定义变量:变量名=值
 
变量类型约定数据之间的运算规则

数据类型:
1)数字类型(number):整型(int)、浮点型(float)
2)bool:True     False
3) 字符串类型(str)

PS:在python里面定义变量不需要指定类型,根据赋的值来判断变量的类型,可以用
type()函数来查看变量的类型;

运算符:
1、数字和数字 之间可以进行所有的运算
2、字符串之间只支持加法运算
3、数字与字符串之间可以进行乘法运算,相当于复制,例如hello*3=hellohellohello

程序中的输入和输出:
普通输出:print();
格式化输入输出:
例如:
name='项与';
age=19;
salary=100.98;
my_format='他的名字是%s,他的年龄是%d,他的工资是%f。'%(name,age,salary);
print(my_format);

#  输出的是“他的名字是项与,他的年龄是19,他的工资是100.980000。"
如果想要小数点后面只有2位,则:%.2f
其中%d这种是占位符,%号是固定格式
%s   string
%d  digit  数字
%f  float
%%   输出百分号
例如:
print('游戏胜率:%d%%' %87);


输入函数:input()
input_content=input("请输入姓名:");
print("欢迎您:%s!"%input_content);

运行时,在请输入姓名后输入”吴水荣“然后按回车,显示:
欢迎您:吴水荣!


#  在控制台依次提示用户输入:姓名、公司、职位、电话、邮箱
#  按以下格式输出
# ****************
# 公司名称:
# 姓名(职位)
# 电话:
# 邮箱
# ****************
name=input('请输入姓名:')
company=input("请输入公司:")
title=input("请输入职位")
phone=input('请输入电话')
email=input('请输入邮箱')
print('*'*20);
print(name);
print();
print("%s (%s)"%(company,title));
print();
print("电话:%s"%phone);
print()
print('邮箱:%s'%email);
print()
print('*'*20);

类型转换:
int(val)
float(val)
str(val)

例子:计算器
# 使用input函数完成加法计算器程序
# 1、保存用户输入的两个值
# 2、对2个值进行加法计算,并且保存这个结果
# 3、直接输出打印结果
left_number=input('请输入被加数:');
right_number=input('请输入加数:');
left_number_int=int(left_number);          
right_number_int=int(right_number);
result=left_number_int+right_number_int;
#print(result);
print('%d+%d 的结果是%d'%(left_number_int,right_number_int,result));

3:分支语句:
if分支语法:

一个分支:
if 条件一:
   执行一行或多行特定代码

例1:
a = 30
b = 20
if a     ret=a+b
else:
    ret=a-b
print('ret=%d'%ret)

输出:ret=10

例2:
#登录系统,只有输入登录名为admin时可以正确登录系统
input_username=input('请输入用户名');
correct_name='admin';
if(input_username==correct_name):
    print('欢迎%s登录系统'%correct_name);
else:
    print('登录失败');

例子补充:

input_username=input('请输入用户名:');
input_password=input('请输入您的密码:');
correct_name='admin';
correct_pass='123456';
if(input_username==correct_name):
    if(input_password==correct_pass):
     print('欢迎%s登录系统'%correct_name);
    else:
        print('您的用户名或密码错误');

else:
    print('登录失败');


使用逻辑运算符:and   or  not
input_username=input('请输入用户名');
input_password=input('请输入密码');
if input_username=='admin' and input_password=='123456':
    print('登录成功');
else:
    print('登录失败');

#and
非0为真,0为假
如果第一个条件为假,第二个条件没有必要去执行了,直接返回第一个条件的结果
如果第一个条件为真,则第二个条件必须执行,直接返回返二个条件的结果;

# or
如果第一个条件为真,第二个条件不用执行,直接返回第一个条件的结果
如果第一个条件为假,第二个条件需要执行,直接返回第二个条件的结果

例子:
a=10
b=20
if a>b:
   ret=a
else:
ret=b

简化写法: ret=a>b and a or b
先判断a>b and a              a>b为假,则直接返回假,不用管a了
然后判断  假 or b              第一个条件是假,第二个条件还是要执行的,b是20,非0为真,返回20

如果是    ret=a                                                         or的情况下,第一个条件已经是真了,第二个条件不用再执行,直接返回第一个条件的结果是10就行了


#not
ret=not(a>b)            先判断a>b是真还是假,a=10,b=20,为假,然后使用not来取反,最终返回true



elif:
分数等级案例:根据分数显示档位
1)获取输入的分数
2)将分数从字符串类型转换成数字类型
3)根据分数分档:
     90-100    A档
     80-90      B
     70-80     C
     60-70      D
      60以下   E

score=int(input('请输入分数'));

if(score>=0 and score<=100):
    if (score >= 90 and score <= 100):
        print('太棒了');
    elif (score >= 80 and score < 90):
        print('优秀');
    elif (score >= 70 and score < 80):
        print('良好');
    elif (score >= 60 and score <= 0):
        print('及格');
    else:
        print('你完了');
else:
    print('输入错误');


猜拳游戏
1、用户输入的石头(0)、剪刀(1)、布(2)
2、电脑随机产生一个石头剪刀布
3、判断胜负

#导入random模块
import random;
user_fist=int(input('请出拳  石头(0)、剪刀(1)、布(2):'));
computer_fist=random.randint(0,2);
print(computer_fist);
if (user_fist==0 and computer_fist==1) or (user_fist==1 and computer_fist==2) or (user_fist==2 and computer_fist==0):
    print('你赢了');
elif user_fist==computer_fist:
    print('平手');
else:
    print('你输了');


4、循环语句:
while 条件:
    重复执行的一行或多行代码

 #打印1-100之间的所有偶数
i=1;
while i<=100:
    if i%2==0:
        print(i);
    i+=1;
print('end');
        

#打印1-100之间所有数的累加和
start=1;
total=0; #  保存累加和
while start<=100:
    total=total+start;
    start+=1;
print(total);

#计算1-100之间的奇数和
i = 1;
my_sum = 0;
while i <= 100:
    if i % 2 != 0:
        my_sum = my_sum+i;
    i += 1;
print(my_sum);

#打印星星
i=1;
while i<=5:
    print('*' * i);
    i+=1;



#continue关键字   跳出本次循环

# #打印1-100之间所有数的累加和,但是如果遇到50就跳过
index=1;
my_sum=0;
while index <=100:
    if index==50:
        index+=1;    #  这一行如果不加,则执行到index==50后,就会continue跳出本次循环,又开始执行到while这里,然后继续index==50,
        # 再continue,一直死循环;加上index+=1后,当执行完continue后,返回while<=100,然后判断index==50,然后index+=1后变成51
        continue;    #  continue是跳出本次循环,当执行到continue,其后面的代码不再执行,直接回到while;只有在循环里才能写continue
    my_sum+=index;
    index+=1;
print(my_sum);


也可以这样子写:
index=1;
my_sum=0;
while index <= 100:
    if index!=50:
        my_sum += index;
    index += 1;
print(my_sum);

#break 关键字            退出循环
print('循环开始...');
i=0;
while i<=100:
    if i>50:
        break;       #  只打印到50就不再执行后面的代码了
    print(i);
    i+=1;


#while里面再写一个while
i=0;
while i<=3:
    j=0;
    while j<3:
        print(j);
        j+=1;
    i+=1;
以上结果是打印4次0 1 2

如果写成这样子,把j=0写到外面:
i=0;
j = 0;
while i<=3:

    while j<3:
        print(j);
        j+=1;
    i+=1;

以上代码只打印一次0 1 2   因为while i<=3的时候,执行里面的代码,while j<3,则打印j,然后j+=1了,是会最终大于等于3
然后执行到i+=1的时候,会跳到while i<=3,再进来,j已经不满足j<3的条件了,不再执行。因此只打印一次 0 1 2

如果条件很多,使用while就建议这样子写:

i=0;
my_sum=0;
while True:
    if i>100:
        break;
    if i==50:
        i+=1;
        continue;
    my_sum+=i;
    i+=1;
print('my_sum:',my_sum);

#弄一个简易的假装的员工管理系统
# 1、接收用户输入:输入1就展示所有员工信息、输入2就新增一个员工、输入
# 3就修改员工信息、输入4就删除一个员工信息、输入5就退出员工管理系统

print("欢迎使用员工管理系统V1.0");
while True:                #  在这里写循环,并且在最后写上continue可以重复进行以下5步操作
    print("*"*10+'操作菜单'+'*'*10);
    print('1就展示所有员工信息');
    print('2就新增一个员工信息');
    print('3就修改一个员工信息');
    print('4就删除一个员工信息');
    print('5就退出员工管理系统');
    print('*'*27);
    my_operation=int(input('请输入操作'));
    if my_operation==1:
        print('姓名\t年龄\t性别')
        print('吴水荣\t33\t女')
        print('钟一一\t5\t男')
        print('钟二二\t1\t男')
    elif my_operation==2:
        name=input('请输入姓名:')
        age=input('请输入年龄:')
        sex=input('请输入性别:')
        print('新增员工 %s 成功' %name)
    elif my_operation==3:
        name=input('请输入要修改的员工姓名:')
        print('员工%s 的信息修改成功' %name)
    elif my_operation == 4:
        name = input('请输入要删除的员工姓名:')
        print('员工%s 的信息删除成功' % name)
    elif my_operation==5:
        print('退出系统,欢迎下次再来')
    else:
        print('输入有误')
    continue;


5、函数
函数就是实现某个功能的代码
好处:减少代码的冗余,减少维护量,功能的封装,降低学习成本,提升开发速度。

语法:
def 函数名():
     一行或多行代码                                    #  是函数体,内部定义的变量,在外部是不能使用的

#打印星星的函数
#函数定义
def print_stars():
    i=1
    while i<=5:
        print('*'*i);
        i+=1;
#函数调用,可以在任何地方调用.如果不调用,定义的函数不会自己执行
print_stars();
print('我再来调用一次:')
print_stars();


函数参数:
def my_add(a,b):                #  a,b是形参
    ret=a+b;
    print('a+b=',ret);
my_add(10,20);                 # 10,20是实参。实参要按照形参的顺序一一传值,缺一不可,顺序也不可乱
print('我再调用一次:')
my_add(11,22);
print('我再调用一次:')
my_add(a=20,b=90);      #这种是关键字参数,a,b的顺序可以改变

结果:
a+b= 30
我再调用一次:
a+b= 33
我再调用一次:
a+b= 110



返回值:return

return 关键字:
1)当函数执行到return 关键字时,函数就会立马终止;
2)函数中可以出现多个return,但是有且只有一个会执行
3)return None; 等价于return;

def my_add(a,b):
    ret=a+b;
    return ret;                #这里必须有return,函数体里的ret,在下一行调用的时候才可以使用
ret=my_add(10,20);
final_ret=ret+100;
print('最终结果:',final_ret);


#print 函数和return 语句的区别:
1)print是一个函数,只是一个功能,return是一个语句,和def,if类似
2)print会将数据打印到屏幕上,return会将数据返回到程序 中,给函数的调用者用。


#函数是否应该有返回值,由需求决定,
例如给一个参数(水果)给罐头工厂,则这个函数应该有返回值(给我水果罐头);
如果是投了一个稿给新闻社,那它只需要发表,不需要给我报纸,则不用返回值


使用调试模式:
1)先加断点。
2)启动调试模式

实例:
def my_add(a,b):
    ret=a+b;
    print('a+b=',ret);       
ret=my_add(10,20);             # 在这一行设置断点,然后点击调试模式,此时这一行代码会出现一条蓝色波浪线,意味着即将运行到这一行代码
                                             #然后点击step over按钮,右边出现“ret={NoneType}None ” 这么一个结果,表示它什么都没有返回。因此要将
                                             #这一行代码改成return ret来保存返回值。否则函数体里的ret不能在函数外面使用,因此调用不了
final_ret=ret+100;
print('最终结果:',final_ret);


#编写一个函数用于计算从star 开始到 end 结束之间所有数字的累加和。
#先把要实现的功能写出来,然后放到函数里,把不能写死的部分改成参数,然后写出返回
def leijiazhi(start,end):
   if start>end:
       print('start 应该小于end!');
       return None;
    i=start;
    my_sum=0;
    while i<=end:
        my_sum+=i;
        i+=1;
    return my_sum;
#定义一个新的变量用于保存函数的返回值
ret=leijiazhi(1,100);
print('1到100的累加值是:',ret);



#编写一个函数根据传入的运算符,进行相应的加减乘除运算

def my_caculator(left,right,operator):
    a=left
    b=right
    if operator=='+':
        ret=a+b;
    elif operator=='-':
        ret=a-b;
    elif operator=='*':
        ret=a*b;
    elif operator=='/':
        ret=a/b;
    else:
        print('您输入的操作符有误!');
        ret=None;
    return ret;
final_ret=my_caculator(5,9,'/');
print(final_ret);


函数的缺省参数(默认参数):
当函数调用中省略了实参时自动使用的一个值
语法与使用:
1、在函数声明或定义时,直接对参数赋值,这就是默认参数
2、在函数调用时,省略部分或全部参数,这时可以用默认参数来代替

def my_function(a,b=20,c=30):
        return a+b+c

my_function(10)        #返回10+20+30
my_function(10,100)   #返回10+100+30
my_function(10,100,1000)       #返回10+100+1000

注意:带有默认值的参数一定要位于参数列表的最后面。


全局变量和局部变量:
全局变量在所有函数外部定义的变量,在当前的python文件的所有地方都可以使用;
局部变量,在函数内部定义的,仅能在此函数内部使用

作用域:表示变量名能够被访问到的范围

例1:全局变量
g_val=100;
def my_function1():
    print(g_val)
def my_function2():
    print(g_val)

my_function1();
my_function2();

结果:打印2次100


例2:全局变量和局部变量
my_num=100
def my_function():
    my_num=200
    print(my_num)
my_function()
print(my_num)

结果:打印200和100


如果函数内部先使用再定义,根据就近原则,会报错误:UnboundLocalError: local variable 'my_num' referenced before assignment
所以要先定义再使用
命名冲突时,python会使用它最近的变量

my_num=100
def my_function():
    print(my_num)
    my_num=200

my_function()
print(my_num)


函数文档
先把光标放在函数名上,按ctrl+q会弹出其相应的解释文档,看到其功能的详细描述

例如:
def my_add(num1,num2):
    """计算2个整数的和,
    :param int num1:加法运算的左操作数
    :param int num2:加法运算的右操作数
    :return 返回两个操作数相加的结果"""
    result=num1+num2;
    print(result);
    return result;
my_add(10,11);


按ctrl+q弹出来的内容是:(如此,别人无需去读代码就能知道该函数是做什么用的,都有什么内容了,但是一般无需写这么详细,就描述一下功能作用就行了)

def my_add(num1: int,
           num2: int) -> int
计算2个整数的和, :param int num1:加法运算的左操作数 :param int num2:加法运算的右操作数 :return 返回两个操作数相加的结果
Params:
num1 – 加法运算的左操作数
num2 – 加法运算的右操作数
Returns:
返回两个操作数相加的结果


函数单一职责原则:RSB
一个函数只负责一个事情,因为如果一个函数承担的职责过多,就等于把这些职责混合在一起,一个职责
变化可能 会影响其他职责的能力

定义:就一个函数而言,应该仅有一个引起它变化 的原因,简单的说,一个函数中应该是一组相关性很高的类的封装,
即一个类只负责一项职责,而不应该同时负责多个职责。

三、容器(其本质还是变量)

容器类型:
之前学习的变量类型只能存储单一元素,如果要存储全班100个学生的成绩,需要定义
100个变量。如果将所有的元素放在同一个容器中,一个容器变量就可以存储多个元素,减少了变量的不亦乐乎。

容器类型提供多个类型,根据存储数据的特点,分为序列式容器和非序列式容器
1、序列式窗口的元素在存放时都是连续存放的,包括字符串、列表、元组。支持根据下标存取元素。
2、非序列式容器在存储元素时不是连续存放的,包括字典、集合

窗口类型存储多个元素,也提供了一些方法对容器中的元素操作,例如添加、删除、修改一个元素,对容器中的元素排序等

1、字符串:
定义:使用一对单引号或双引号或三引号来定义。其中三引号可以定义多行字符串,但一般不用
遍历   不重复地访问容器中的每一个元素
索引支持正数索引,也支持负数索引

例子:
my_str='hello word';
i=0;
while i<11:
    print(my_str[i],end=' ');
    i+=1;

打印出来的是:h e l l o   w o r d

使用for循环来遍历:
my_str='hello word';
for v in my_str:
    print(v,end=' ')

打印出来的是:h e l l o   w o r d

2、字符串替换
my_str='我是一个神奇的人类,我会做一些神奇的事情,你说神奇不神奇';
new_str=my_str.replace('神奇','奇怪',1);   #  如果后面加了1,返回的结果是“我是一个奇怪的人类,我会做一些神奇的事情,你说神奇不神奇”,只改了第一个
                                                                    如果后面加了2,返回的结果是“我是一个奇怪的人类,我会做一些奇怪的事情,你说神奇不神奇”,改了前面2个神奇,
                                                                     如果后面没有加数字,返回的结果是全部都改
print(new_str);

#replace 方法并不会替换原本的字符串,替换完毕后返回一个新的字符串。因为python里的字符串是不允许修改的

#字符串通过点的方式调用专属的函数

#字符串的特点:
1)字符串一旦定义不允许修改
2)字符串容器中的元素都是字符类型的。

3、字符串查找和切片
字符串提供了一种语法,用来获取字符串中的一个子串

# user_email='shuirong_111@163.com'
# 需求:获取用户名和获取邮箱域名分别存储
# 1、找到字符串中@的位置
# 2、获取字符串中的字串
user_email='shuirong_111@163.com'
position=user_email.find('@')      #返回@第一次出现的位置。如果是@123,返回的是@第一次出现的位置,如果查找不到,返回-1
if position==-1:
    print('@不存在,邮箱不合法');
else:
    print('@的位置是:',position);

    # 切片语法,左闭右开
print(user_email[0:4]);  #打印的是0、1、2、3下标的子串  shui
#获得容器元素的个数
string_length=len(user_email);
print(user_email[13:string_length]);  #打印的是字符串下标从13开始到字符串长度(开区间)的字母,刚好是163.com
print(user_email[:12]); # 前面什么都不写,默认为开始    shuirong_111
print(user_email[13:]);  #后面什么都不写,默认为到最后。如果2个都不写,表示从头到尾    163.com

#步长
print(user_email[0:12:1]); #shuirong_111
print(user_email[0:12:2]); #surn_1 隔1个取
print(user_email[0:12:3]); #sin1  隔2个取

#将字符串逆序
print(user_email[::-1]); #moc.361@111_gnoriuhs


重新写这个例子:
# 需求:获取用户名和获取邮箱域名分别存储
# 1、找到字符串中@的位置
# 2、获取字符串中的字串
user_email='shuirong_111@163.com'
position=user_email.find('@')      #返回@第一次出现的位置。如果是@123,返回的是@第一次出现的位置,如果查找不到,返回-1
if position==-1:
    print('@不存在,邮箱不合法');
else:
    user_name=user_email[:position];
    yumin=user_email[position+1:];
print('邮箱名是:',user_name);
print('邮箱域名是:',yumin);

结果是:
邮箱名是: shuirong_111
邮箱域名是: 163.com


使用另外一个方法来完成这个例子:
split 分割
my_str='aa#bb423#abc4#我是第四个#2332';
ret=my_str.split('#');
print(ret);    #结果是:['aa', 'bb423', 'abc4', '我是第四个', '2332']



# 需求:获取用户名和获取邮箱域名分别存储

user_email=input('请输入您的邮箱地址:')
print(user_email);
#获得@字符串在user_email中出现的次数
char_count=user_email.count('@');
if char_count>1 or char_count<1:
    print('你的邮箱不合法!');
else:
    result = user_email.split('@');
    print('用户名是:', result[0]);
    print('邮箱域名是:', result[1]);

第一次输入:shuirong_111
结果是“你的邮箱不合法”
第二次:
请输入您的邮箱地址:shuirong_111@163.com
shuirong_111@163.com
用户名是: shuirong_111
邮箱域名是: 163.com
第三次:
请输入您的邮箱地址:shuirong@23432@163.com
shuirong@23432@163.com
你的邮箱不合法!

# 字符串去除两侧空格、校验是否全为字母
# 例如网站进行会员注册,其处理流程如下:
# 1、获得用户输入的注册用户名
# 2、用户在输入用户名时,可能在用户名2侧不小心输入多个空格,我们需要支除掉
# 3、判断用户名是否全为字母(由需求确定,例如要包含字母数字和下划线等)
# 4、处理完毕后,显示注册成功
register_username=input('请输入您的用户名:');
register_username=register_username.strip();  #  去除两侧空格
if register_username.isalpha():   #检验是否全为字母,如果加上or register_username.isdigit(),则数字也可以
    print('欢迎您:',register_username);
else:
    print('注册失败');

3、列表:
1)、字符串中的元素不能修改,而且元素类型单一,而列表中的元素可以修改,并且可以存放多种类型的元素。


#列表是序列式容器,支持索引、切片
#遍历
my_list=[[1,2,4],[2,5,6],[4,6,7],'Trump',60,3.14];
index=0;

while index     print(my_list[index]);
    index+=1;

#或者使用for循环                      break  continue也可以在for循环里使用
for val in my_list:
    print(val);


结果是打印2遍:
[1, 2, 4]
[2, 5, 6]
[4, 6, 7]
Trump
60
3.14


#遍历嵌套列表里的所有元素
my_list=[[1,2,4],[2,5,6],[4,6,7],[7,9,0]];
i=0;
while i     j=0;
    while j         print(my_list[i][j]);
        j+=1;
    #print(my_list[i]);
    i+=1;

结果是:
1
2
4
2
5
6
4
6
7
7
9
0

如果 #print(my_list[i]);的注释去掉,则是:
1
2
4
[1, 2, 4]
2
5
6
[2, 5, 6]
4
6
7
[4, 6, 7]
7
9
0
[7, 9, 0]

# 使用for循环
for o in my_list:
    for v in o:
        print(v);


2)列表支持位置删除(尾部删除、指定位置删除)、值删除
3)尾部插入效率最高,指定位置插入效率较低,因为需要移动元素位置。删除同理
4)列表的缺点:根据关键字查找效率很低,根据位置查找效率很高

例子:
my_list=[];

#append 追加  在尾部插入元素
my_list.append(10);
my_list.append(20);
my_list.append(30);

#insert 可以在指定位置插入
my_list.insert(2,40);           #至此,结果是:[10, 20, 40, 30]
my_list.insert(2,50);              #[10, 20, 50, 40, 30]

#删除元素:值删除、位置删除
#pop方法  用于位置删除,默认删除最后一个位置的元素,如果指定了位置,删除该位置
my_list.pop();        #结果是:[10, 20, 50, 40]
my_list.pop(1);       #结果是:[10, 50, 40]

#remove 移除,根据值删除
my_list.remove(40);       # 结果是:[10,50]
my_list.append(50);        #此时有2个50
my_list.remove(50);        #结果是:[10,50]   remove默认把第一个出现的值删除掉

print(my_list);

#clear  清除  清空
my_list.clear();
print('列表长度是:',len(my_list));       #列表长度是: 0



#列表排序
例子:
#需求:创建一个列表,包含了10个随机数
import random
my_list=[];
i=0;
while i<10:
    random_number=random.randint(1,100)
    #将随机数插入列表中
    my_list.append(random_number);
    i+=1;
print(my_list);

#逆序
my_list.reverse();
print(my_list);

#对列表中的元素进行排序
#sort 排序默认是从小到大,升序排序

my_list.sort();
print(my_list);

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



最终结果是:
[37, 60, 82, 17, 59, 28, 60, 19, 68, 52]   #  随机生成的数        这组数在每一次运行代码时生成的都不一样,因为是随机的,但是下面3个顺序是一样的
[52, 68, 19, 60, 28, 59, 17, 82, 60, 37]    #把列表里的数字顺序倒过来
[17, 19, 28, 37, 52, 59, 60, 60, 68, 82]    #默认升序排序
[82, 68, 60, 60, 59, 52, 37, 28, 19, 17]    #  将reverse的默认值改为True,即可将其改成降序排序



#查找元素,并根据位置进行修改其值
my_list=[10,20,30,40];
old_value=30;
new_value=200;
#index 用于根据值查询,如果查询失败,则会报错,因此先判断一下
if old_value in my_list:
    #查找到值为old_value的位置
    position=my_list.index(old_value);
    #根据位置修改值
    my_list[position]=new_value;
print(my_list);             #[10, 20, 200, 40]

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



#例子:一个学校,有3个办公室,现在有8位老师等待工位的分配,请编写程序,完成随机分配
#定义学校和办公室
# school=[[],[],[]];
# #建一个老师列表
# teacher_list=[];
# index=1;
# while index<=8:
#     #创建老师的名字
#     teacher_name='老师'+str(index);
#     #把老师装进容器里
#     teacher_list.append(teacher_name);
#     index+=1;
# print(teacher_list);

#上面部分代码相当于以下代码,一般使用函数的方式
school=[[],[],[]];
def create_teachers():
    """创建老师列表的函数"""
    teacher_list=[];
    index=1;
    while index<=8:
        teacher_name='老师'+str(index);
        teacher_list.append(teacher_name);
        index+=1;
    return teacher_list;

teachersList=create_teachers();
print(teachersList);
#techersList2=create_teachers();
#print(techersList2);            #跟上面的调用返回的内容是一样的,但实际上是2个长得一样的列表
#每次调用这个函数,都返回一个新的对象



#分配老师
for teacher in teacherList:
    #产生一个办公室编号的随机数
    office_number=random.randint(0,2);
    #给老师随机分配办公室
    school[office_number].append(teacher);
#查看一下各个办公室里的老师
for office in school:
    for person in office:
        print(person,end=' ');
    print();

结果是:(以下结果是可变的,因为是随机分配,每次执行代码得到的结果都不一样)
老师1 老师3 老师7
老师2 老师5 老师6 老师8
老师4


4、元组
可以从语法的层面来限制数据的意外修改
元组比列表更节省空间
使用小括号来定义
my_tuple=(10,20,30)
my_tuple=((10,20),(20,30))

如果元组中只有一个元素,则元素后面加上逗号
例如:my_tuple=(10,)
         my_tuple=((10,),)

元组的元素不能修改。 支持索引
my_tuple=(10,20)
my_tuple[0]=100        #这样子赋值是会报错的,因为不支持修改

支持遍历
my_tuple=(10,20,30);
for v in my_tuple:
    print(v)

支持查询:count、 index
my_tuple=(10,20,30);
pos=my_tuple.index(30);
print(pos)   #结果是2。即30的位置是在下标为2的元素

my_tuple=(10,20,30,10,20,20,3);
my_count=my_tuple.count(20);
print(my_count)    #结果是3,20这个值出现过3次


5、字典   非序列式容器    不支持索引、切片操作。字典的查询性能优于列表
查找效率比较高,但是比较占内存。以空间换时间
 字典是另一种可存储任意类型对象,字典的每个键值  key=>value 对用冒号(:)分割,每个键值对之间用逗号分割
整个字典包括在花括号{}中
my_dict={key1:value1,key2:value2}

注意:键一般是唯一的,如果衙复最后的一个键值对替换前面的,值不需要唯一

字典的操作:
#字典操作

def test01():                                  #使用函数定义着,等需要用此函数时再调用
    """1、字典定义"""
    my_dict={'name':'Obama','age':18,'gender':'男'}
    print(my_dict['name']);
    my_dict['gender']='女';          #  支持修改
    print(my_dict);
test01();      #结果是:Obama
                #{'age': 18, 'gender': '女', 'name': 'Obama'}


def test02():
    """获得字典的值"""
    my_dict = {'name': 'Obama', 'age': 18, 'gender': '男'};
    #使用中括号这种访问字典中元素的方式,如果键不存在则会报错,程序终止:
    print(my_dict['age']);#age存在会打印18出来
    #print(my_dict['age1']);#报错:KeyError: 'age1'
    #因此使用 get 方法,如果key不存在默认返回None,也可以指定默认值
    print(my_dict.get('age'));   #打印18
    print(my_dict.get('age1'));   #None
    print(my_dict.get('age1','我是默认值'));   #  我是默认值
test02();

def test04():
    """添加和修改元素"""
    my_dict = {'name': 'Obama', 'age': 18, 'gender': '男'};
    #如果 key存在的话就修改元素,不存在则新增元素
    my_dict['score']=99;
    my_dict['name']='我是新的名字'
    print(my_dict);
test04();   #{'gender': '男', 'age': 18, 'score': 99, 'name': '我是新的名字'}



#字典的删除操作
my_dict={'aaa':10,'bbb':20,'ccc':30}
del my_dict['aaa'];
print(my_dict);  #{'bbb': 20, 'ccc': 30}
#del  不但能够删除字典中的某个键值对
# 1、还能删除某个变量
a=10
print('a=',a);
del a
#print('a=',a)   #报错NameError: name 'a' is not defined

#2、删除列表中的元素
my_list=[1,2,4]
del my_list[1];
print(my_list)  #[1, 4]

#清空字典
my_dict.clear();
print(my_dict);   #{}

#3、遍历字典中的元素
my_dict={'aaa':10,'bbb':20,'ccc':30}
#如果用for in 循环,默认只能遍历出来键
for val in my_dict:
    print(val)      #aaa
                    #ccc
                    #bbb
#因此不能用for循环

key_list=my_dict.keys();
print(list(key_list));   #转换成列表元素  ['aaa', 'ccc', 'bbb']

value_list=my_dict.values();
print(list(value_list));#[10, 30, 20]

key_value_list=my_dict.items();
print(list(key_value_list));  #[('bbb', 20), ('aaa', 10), ('ccc', 30)]

for key_value in key_value_list:
    print(key_value);       #('bbb', 20)
                            # ('aaa', 10)
                            # ('ccc', 30)

#使用while 循环遍历字典
my_list=list(my_dict.items())
i=0;
while i      print(my_list[i]);     #('aaa', 10)
                            # ('bbb', 20)
                            # ('ccc', 30)
     i+=1;



#功能需求
# 1、员工信息:编号、姓名、工资、性别
# 2、编号不允许修改,不允许重复
# 3、功能实现:
# 1)新增员工信息
# 2)根据员工编号删除员工信息
# 3)根据员工编号 修改员工信息
# 4)查看所有员工信息
# 5)退出员工管理系统
#
# 思路分析
# 1)确定员工信息使用哪种容器来存储
# 2)搭建系统的业务框架
# 3)具体实现每个系统功能



#1、存储员工信息
employee={};
#2、搭建业务框架
def show_menu():
    """显示系统功能菜单"""
    print('*'*10+'员工管理系统菜单'+'*'*10);
    print('员工管理系统 V1.0');
    print('1)新增员工信息');
    print('2)删除员工信息');
    print('3)修改员工信息');
    print('4)显示所有员工信息');
    print('5)退出员工管理系统');
    print('*'*30);

def add_new_employee():
    """添加员工信息"""
    #1、获得员工编号、姓名、性别、工资
        # 1)判断员工编号是否存在,如果存在则拒绝添加,并提示:员工编号重复,添加失败
        # 2)如果不重复则进行下面的操作
    #2、将员工信息保存到字典中
        # 1)编号作为键、剩下信息作为值
        # 2)1001:{'name':xxx,'gender':xxx,'salary':xxx}

    employee_id=input('请输入员工的编号:');
    all_employee_id=list(employee.keys());
    if employee_id in all_employee_id:
        print('员工编号重复,添加失败');
        return;
    employee_name=input('请输入员工姓名:');
    employee_gender = input('请输入员工性别:');
    employee_salary = input('请输入员工工资:');
    employee_info={'name':employee_name,'gender':employee_gender,'salary':employee_salary};
    employee[employee_id]=employee_info;
    print('员工编号为 %s 的员工信息添加成功' %employee_id);

def remove_employee():
    """删除员工信息"""
    #1、获得要删除的员工编号
    #1)如果员工编号不存在,提示错误信息,并终止函数执行
    #2)如果存在,则删除对应编号的员工信息
    employee_id=input('请输入你要删除员工的编号:')
    all_employee_id = list(employee.keys());
    if employee_id not in all_employee_id:
        print('员工编号不存在,删除失败');
        return;
    del employee[employee_id];
    print('员工编号为 %s 的员工信息删除成功' %employee_id);


def show_employee():
    """显示员工信息"""
    for employees in employee.items():
        print('%s\t\t%s\t\t%s\t\t%s' %(employees[0],employees[1]['name'],employees[1]['gender'],employees[1]['salary']))

def edit_employee():
    """修改员工信息"""
    #1、拿到要修改员工的编号
    employee_id=input('请输入您要修改的员工的编号:')
    #1)如果不存在,则提示错误信息,并且终止函数执行
    all_employee_id = list(employee.keys());
    if employee_id not in all_employee_id:
        print('员工编号不存在,修改失败');
        return;
    #2)如果存在,则修改对应信息:显示原来的信息,然后再修改
    new_employee_name=input('您的姓名是:%s,要修改为:' %employee[employee_id]['name']);
    new_employee_gender = input('您的性别是:%s,要修改为:' % employee[employee_id]['gender']);
    new_employee_salary = input('您的工资是:%s,要修改为:' % employee[employee_id]['salary']);
    #如果用户直接回车,表示没有任何输入,则不更新
    if new_employee_name!='':
        employee[employee_id]['name']=new_employee_name;
    if new_employee_gender!='':
        employee[employee_id]['gender']=new_employee_gender;
    if new_employee_salary!='':
        employee[employee_id]['salary']=new_employee_salary;

    print('员工编号 %s 的信息修改成功' %employee_id);
while True:
    #1、显示系统菜单
    show_menu();
    #2、获得用户输入的菜单
    my_operate=input('请输入您的操作:');
    #3、根据用户输入来判断做什么事情
    if my_operate=='1':
        add_new_employee();
        print(employee);
    elif my_operate=='2':
        remove_employee();
    elif my_operate=='3':
        edit_employee();
    elif my_operate=='4':
        show_employee();
    elif my_operate=='5':
        print('欢迎下次使用我们的系统')
        break;
    else:
        print('您的输入有误');



5、文件
文件的打开和关闭
使用open函数可以打开一个已经存在的文件,或者创建一个文件。使用close方法来关闭一个文件

f=open('E:/全栈测试笔记/数据库笔记.txt','r');
f.close();

文件打开分来读、写、追加模式,这三种模式分别再分为文本模式和二进制模式
r   只读     文件的指针将会放在文件的开头。这是默认模式
w   只写      如果该文件已存在则将其覆盖,如果不存在则创建新文件
a    用于追加    如果该文件已存在,指针放在文件的结尾。如果不存在,创建新文件进行写入
rb   以二进制格式打开一个文件用于只读
wb 以二进制格式打开一个文件用于只写
ab  以二进制格式打开一个文件用于追加

打开文件用的文本模式,会进行换行符的转换    文字文件
如果是二进制模式打开则不会进行换行符的转换   图片文件

#1、文件打开模式
def test01():
    """以只读方式打开文件"""
    f=open('abc.txt','r');
    content=f.read();
    print(content);
    f.close();

def test02():
    """以写的方式打开文件
    W模式默认是会覆盖文件中的数据的
    如果文件不存在,则会新建一个文件"""
    f=open('a.txt','w');
    f.write('hello world')
    f.close();

def test03():
    """a 追加模式"""
    f=open('a.txt','a');
    f.write('我是追加的内容');
    f.close();
test01();
test02();
test03();

写文件  write  writelines
def test04():
    """1  write函数的用法"""
    f=open('a.txt','w');
    #write函数一次写一行
    f.write('hello word')      #会把文件里原有的内容替换掉
    #writelines 一次可以写多行,参数是一个列表
    lines=['第一行\n','第二行\n','第三行\n','第四行\n'];
    f.writelines(lines);
    f.close();

#test04();
#运行结果是:
# hello word第一行
# 第二行
# 第三行
# 第四行

def test05():
    """读操作"""
    f=open('a.txt','r');
    content=f.read(20);   #read 没有指定参数,则读取文件中的所有数据、指定参数,则读取参数指定个数的数据
    print(content);
    f.close();
#test05(); #运行结果是:    hello word第一行
                        # 第二行
                        # 第三

def test06():
    """一次读取一行"""
    f=open('a.txt','r');
    content1=f.readline();   #  hello word第一行
    content2=f.readline();   #  第二行      第二次调用会读取第二行的内容
    print(content1);
    print(content2);
    f.close();
test06();

def test07():
    """一次读取所有行"""
    f=open('a.txt','r');
    #content=f.readlines();   # 读出来的是一个列表:['hello word第一行\n', '第二行\n', '第三行\n', '第四行\n']
    #print(content);
    lines=f.readlines();
    for line in lines:
        if line[-1]=='\n':
            print(line[:-1])    #如果不写这个条件,运行结果就是每行之间换了两次行,写了之后只换一次行
        else:
            print(line);
    f.close();
test07();   #注释掉读出来是一个列表的2行再运行,结果是:   hello word第一行
                                                        # 第二行
                                                        # 第三行
                                                        # 第四行


#文件拷贝
#获得要拷贝的文件名
old_file_name=input('请输入您要拷贝的文件名:');
#获取 文件的名字和后缀
point_position=old_file_name.rfind('.')
if point_position>0:
    suffix=old_file_name[point_position+1:]
    #拼接新的文件名
    new_file_name=old_file_name[:point_position]+'备份.'+suffix;
else:
    new_file_name=old_file_name+'备份';
#以读的方式打开旧文件
old_file=open(old_file_name,'rb');
#以写的方式打开新文件
new_file=open(new_file_name,'wb');
new_file.writelines(old_file.readlines());

old_file.close();
new_file.close();



#简单的写法
old_file_name=input('请输入您要拷贝的文件名:')  #abc.txt      --->abc.txt.bk
new_file_name=old_file_name+'.bk';
f_old=open(old_file_name,'rb');
f_new=open(new_file_name,'wb');
old_file_content=f_old.read();
f_new.write(old_file_content);
f_old.close();
f_new.close();



#文件和目录操作
import os           #首先要导入模块
def file_rename():
    """文件重命名"""
    # os.rename('abc.txt.bk','new_abc.txt');       #相对路径
    os.rename('C:/Users/wushuirong/Desktop/students.sql.txt','C:/Users/wushuirong/Desktop/学生信息数据.sql.txt');#绝对路径
file_rename();

def file_remove():
    """文件删除"""
   # os.remove('a备份.txt');
    os.remove('C:/Users/wushuirong/Desktop/mynewfile.txt')
file_remove();




四、类和对象
1、类是对一群具有相同特征或者行为的事物的一个统称、是抽象的、不能直接使用
特征被 称为属性
行为被称为方法
对象是由类创建出来的一个具体存在,可以直接使用
由哪一个类创建出来的对象,就拥有在哪一个类中定义的属性和方法

2、关系:类是模板,对象是根据类这个模板创建出来的,应该先有类再有对象
类只有一个,而对象可以有很多个
不同的对象之间属性可能 会各不相同

3、类的设计
在程序开发中,设计一个类要满足三个要素:
1)、类名    满足大驼峰命名法(每一个单词的首字母大写、单词与单词之间没有下划线)
2)、属性   这类事物具有什么样的特征
3)、方法  这类事物具有什么样的行为

3.1 类名的确定:
名词提炼法       分析整个业务流程,出现的 名词,通常就是找到的类

3.2 属性和方法的确定
对 对象的特征描述,通常可以定义成 属性
对象具有的行为(动词),通常可以定义成 方法

# 需求1:
# 小明今年18岁,身高1.75,每天早上跑完步,会去吃东西
# 小美今年17岁,身高1.65,小美不跑步,她喜欢 吃东西。
# 分析:
# 首先应该建一个类
# 类名:Person
# 属性:name、age 、height
# 方法:run()、eat()

# 需求2:
# 一只黄色的狗狗叫大黄
# 看见生人汪汪叫
# 看见家人摇尾巴
# 类名:Dog
# 属性:name、color
# 方法:shout()、shake()

63°|604 人阅读|3 条评论

我是小叮咚  2020-05-15

好实用简洁的学习笔记,谢谢分享!


我是小叮咚  2020-05-15

冒昧问一下,楼主现在是做自动化测试还是测试开发呢?


吴水荣  2020-05-15

@我是小叮咚 我现在被安排待岗,暂时做全职妈妈

登录 后发表评论