一、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、数字与字符串之间可以进行乘法运算，相当于复制，例如hello3=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);

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


#  在控制台依次提示用户输入：姓名、公司、职位、电话、邮箱
#  按以下格式输出
# **
# 公司名称：
# 姓名（职位）
# 电话：
# 邮箱
# **
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(‘吴sr\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=ab;
    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()