把最近看的视频复习一下，都忘了

第一章

1，输出函数print

#可以输出数字
print(520)
print(58.5)

#输出字符串
print('hello world')
#含有运算符的表达
print('3+1')
print("hello")
print(3+1)
#将数据输出到文件中
fp=open('D:/text.txt','a+')
print('hello world',file=fp)
fp.close
a=open('D:/text2.txt','a+')#如果文件不存在就创建，存在就在文件内容后面继续追加
print('hahahah',file=a)
a.close()
#不进行换行输出，输出内容在一行当中
print('hello','world','python')

输出字符串加‘’很基础哦。‘’‘’双引号也是可以的

2.转义字符

定义：反斜杠加想要实现的转移功能首字母

#转义字符
print('hello\nworld')#换行，n是newline
print('hello\tworld')#、t占四个格子，有的话就补成四个，没有填上  ，t是tab
print('hello\rworld')#world将hello进行了覆盖  r是return
print('hello\bworld')#退一个格，backspace
print('老师说:''大家好')
print('老师说：\大家好哦\')
print(r'hello \nworld')#原字符,让转义字符不起作用，在字符串前加r或R，注意事项，最后一个字符不能是一个反斜杠，两个可以

 第一章总结

第二章

1.二进制与字符编码

2，python中的标识符与保留字

3.python中的变量与数据类型

4.python中的注释

2.保留字的查看方法：

import keyword
print(keyword.kwlist)

3.变量的定义和使用，变量的多次赋值

name='玛丽亚'
print(name)#变量由三部分组成：标识 id（obj) 类型 type 值 print将值打印输出
print('标识',id(name))
print('类型',type(name))
print('值',name)
name='玛丽亚'
print(name)
name='楚留冰'
print(name)

4.常见数据类型

​

#数据类型  整数类型 浮点数类型 布尔类型  字符串类型


#整数类型 int
#可以表示，正数 负数 0
n1=90
n2=-39
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可以表示为2，8，10，16进制，默认10进制
print('十进制',118)
print('二进制',0b100010)#二进制前面加0b
print('八进制',0o12322)#八进制前面加0o
print('十六进制',0x1EAF)#十六进制前面加0x


#浮点数类型 float
a=3,14159
print(a,type(a))#未，不太想学了
n1=1.1
n2=2.2
n3=2.1
print(n1+n2)#计算机采用二进制存储，所以浮点数计算时是不精确的，会存在误差
print(n1+n3)#这个是正常的。情况就是这个情况，不要纠结
#通过导入模块decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))


#布尔类型 bool
f1=True  #表示1
f2=False#表示2
print(f1,type(f1))
print(f2,type(f2))
#布尔值可以转换成整数运算
print(f1+1)
print(f2+1)



#字符串类型   str
str1='好想分手'
print(str1,type(str1))
str2="好像分手"
print(str2,type(str2))
str3="""好想
分手"""
print(str3,type(str3))

​

5.数据类型转换

#类型转换 str（）与int（）
name='张三'
age=20
print(type(name),type(age))#name与age的数据类型不相同
print('我叫'+name+'今年,'+str(age)+'岁')#type error 类型错误 #加号是连接符号，当str与int类型进行连接时，报错，解决方案是类型转换
#print('我叫'+name+'今年,'+age+'岁')这是错误的，上面就是通过str()函数将int（）函数转化成了str（）类型，所以不报错

print('——————————————————str()将其他类型转成str类型————————')
a=100
b=False
c=12.2
print(type(a),type(b),type(c))
print(str(a),str(b),str(c))
print(type(str(a)),type(str(b)),type(str(c)))

print('----------int（）将其他类型转化为int类型-----')
s1='123'#这是字符串
f1=89.2
s2='78.99'
ff=True
s3='hello'#直接不弄了，str要转必须整数，文字跟小数都不行
print(type(s1),type(f1),type(s2),type(ff))
print(int(s1),type(int(s1)))#将str转化为int类型，字符串需为数字串
print(int(f1))#将float转化为int类型，截取整数部分，舍掉小数部分
# #print(int(f2))#将str转成in报错，原因是字符串类型为小数串
print(int(ff))
print('----------float（）将其他类型转化为float类型-----')
s1='12.3'
s2='78'#78.0
ff=True
s3='hello'#转不了
i=98#98.0

 第二章知识总结

第三章

1.python的输入函数input（）

2.python中的运算符

算术运算符

赋值运算符

比较运算符

布尔运算符

位运算符

3.运算符的优先级

 

1.输入函数input

#input函数的基本使用

present=input('你想要什么礼物?')
print=(present)


#高级使用

#从键盘录入两个整数，然后计算两个整数的和
a=int(input('请输入一个加数：'))
#a=int(a)#将转换之后的结果存储到a中
b=input('请输入另一个加数:')
b=int(b)
print(a+b)

print(1+1)

2.python中的运算符

 

 算术运算符

#算术运算符


print(1+1)
print(1-1)
print(2*2)
print(1/2)
print(11//2)#整除运算，只取结果的整数部分
print(11%2)#取余运算
print(2**3)#幂运算
print(9//4)
print(-9//-4)#结果同上，都是2
print(9//-4)
print(-9//4)#一正一负向下取整，取比自己小的最大整数
print(9%-4)
print(-9%4)#公式：余数=被除数-除数*商  9-（-4）*（-3） -9-4*（-3）

赋值运算符

#赋值运算符，运算顺序从右往左
a=3+4
print(a)
a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print('----------支持参数赋值')
a=20
a+=30#相当于a=a+30
print(a)
a-=20#相当于a-20赋值给a
print(a)
a*=2
print(a)
print('----------支持系列解包赋值')
a,b,c=10,20,30
print(a,b,c)#左右变量跟值个数需要一样，不然报错
print('----------交换两个变量的值')
a,b=10,20
print('交换之前',a,b)
#交换
a,b=b,a
print('交换之后',a,b)

 

比较运算符

#比较运算符,<,>,<=,>=,!=    ==    is is not  比较结果是true跟false

a,b=10,20
print('a>b吗？',a>b)#比较运算符的结果为bool类型
print('a>=b吗？',a>=b)
print('a==b吗？',a==b)
print('a!=b吗？',a!=b)#a不等于b吗


'''一个=称为赋值运算符，==称为比较运算符
一个变量由三部分组成   标识 类型 值
==比较的的是值
is比较的是标识'''
a=10
b=10
print(a==b)#说明value相等
print(a is b)#说明id标识相等
#以下没学过
lst1={11,22,33,44}
lst2={11,22,33,44}
print(lst1==lst2)#value
print(lst1 is lst2)
print(id(lst1))
print(id(lst2))


print(a is not b)#标识id
print(lst1 is not lst2)

布尔运算符

#布尔运算符
a,b=1,2
print('----------------and 并且')
print(a==1and b==2)
print(a!=1and b==2)
print(a!=1 and b!=2)
print('--------------or 或者')
print(a==1 or b==2)
print(a!=1 or b==2)
print(a!=1 or b!=2)
print('-------------not 对bool类型的操作数取反')
f=True
f1=False
print(not f1)
print(not f)
print('------------in 与not in')
s='hello world'
print('w'in s)
print('k' in s)
print('w' not in s)

位运算符，跟二进制有关，待定，不学了

运算符的优先级

 先算乘除再算加减，有幂运算更先算    算术运算符

位运算

比较运算，结果为true false

布尔运算

赋值运算

（有括号先计算括号）

第三章总结

第四章

1.程序的组织结构

2.顺序结构

3.对象的布尔值

4.分支结构

  单分支if结构

  双分支if else结构

  多分支if  elif  else 结构

  if语句的嵌套

  条件表达式

5.pass空语句

顺序结构与测试对象布尔值

#顺序结构
'''把大象装进冰箱一共分几步'''
print('1,把冰箱打开')
print('2，把大象放冰箱里')
print('3,把冰箱门关上')
print('---------程序结束-----------')

#测试对象的布尔值
print('------------以下对象布尔值为false-----')
print(bool(False))#false
print(bool(0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))#空列表
print(bool(list()))#空列表
print(bool(()))#空元组
print(bool(tuple()))#空元组
print(bool({}))#空字典
print(bool(dict()))#空字典
print(bool(set()))#空集合
print('-------------其他对象的布尔值均为true----')
print(bool(8))
print(bool(True))
'''..........'''

分支结构（很重要

单分支结构  双分支结构

#分支结构，单分支结构
money=1000#余额
s=int(input('请输入取款金额'))#取款金额
#判断余额是否充足
if money >=s:
   money=money-s
   print('取款成功，余额为：',money)

#双分支结构  if...else ,二选一执行
'''从键盘录入一个整数，编写程序，让计算机判断是奇数还是偶数'''
a=int(input('请输入数字'))
if a%2==0:
    print('是偶数')
else:
    print('奇数')

  多分支if  elif  else 结构

'''多分支结构，多选一执行
从键盘录入一个整数
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或大于100为非法数据（不是成绩的有效范围'''
score=int(input('请输入一个成绩'))
#判断
if score >=90 and  score<=100:
    print('A')
elif score>=80 and score<90:
    print('B')
elif 70<=score<80:#python中这种写法也是ok的
    print('C')
elif score>=60 and score<70:
    print('D')
elif score>=0 and score<60:
    print('E')
else:
    print('错误')

  if语句的嵌套

#分支结构，嵌套if的使用
'''会员 >=200 8折
       >=100 9折
       其他不打折
非会员  >=200 9.5折
       其他不打折'''
a=input('你是会员吗？y/n')
#外层判断是否是会员
money=float(input('请输入您的购物金额:'))
if a=='y':#会员
    if money>=200:
        print('付款金额为',money*0.8)
    elif money>=100:
        print('付款金额为',money*0.9)
    else:
        print('付款金额为',money)
else:  #非会员
    if money>=200:
        print('付款金额为',money*0.95)
    else:
        print('付款金额为',money)

        #pass语句 pass可以做占位符

条件表达式

#条件表达式
'''输入两个数字，比较两个数字的大小'''
num1=int(input('请输入第一个数字'))
num2=int(input('请输入第二个数字'))
'''if num1>=num2 :
    print(num1,"大于等于",num2)
else:
    print(num1,'小于',num2)
    这是一般写法'''
print('条件表达式比较大小')
print(str(num1)+'大于等于'+str(num2)  if num1>=num2 else str(num1)+'小于'+str(num2))

为什么要学对象布尔值

#关于为啥要学对象的布尔值
age=int(input('请输入你的年龄：'))
if age:
    print(age)
else:
    print('年龄为',age)#这个代码能运行的原因是0的布尔值为false，可以直接把对象放在条件表达式里
   

第四章总结 

第五章

1.range（）函数的使用

2.while循环

3.for-in循环

4. break .continue 与else语句

5.嵌套循环

range（）函数的使用

   1.用于生成一个整数序列

   2.创建range对象的三种方式

#range的三种创建方式
'''第一种创建方式，只有一个参数（小括号中只给了一个数'''
r=range(10)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，默认从0开始，默认相差1称为步长
print(r)#range(0,10)
print(list(r))#用于查看range对象中的整数序列，list是列表的意思

'''第二种创建方式，给了两个参数（小括号中给了两个数）'''
r=range(1,10)#制定了起始值，从1开始，到10结束，开区间，默认步长1
print(list(r))
'''第三种创建方式，给了三个参数'''
r=range(1,10,2)#range(start,stop,step)
print(list(r))

'''判读指定的整数，在序列中是否存在，in，not in'''
print(10 in r)#false 10不在这个整数序列中
print(9 in r)
print(10 not in r)

  3.返回值是一个迭代器对象

  4.range类型的优点：不管range对象表示的序列有多长，所有range对象占用的空间都是相同的，因为仅仅需要start stop step，只有当用到range对象时，才会去计算序列中的相关元素

  5.in跟not in判断整数序列中是否存在（不存在）指定的整数

循环结构

1.反复做同一件事的情况，称为循环

2.循环结构的流程图

3.循环的分类

·whlie

·for-in

4.语法结构

 5.选择结构if与循环结构while的区别

·if是判断一次，条件为true执行一行

·while是判断n+1次，条件为true执行n次

 whlie循环

#条件表达式中的while循环
a=1
#判断条件表达式
while a<10:
    #执行条件执行体
    print(a)
    a+=1
'''if是判断一次，条件为true执行一行
    while是判断N+1次，条件为True执行N次'''

#应用一波
#计算0到4之间的累加和
'''四步循环法
初始化变量
条件判断
条件执行体（条件为True时所执行的代码）
改变变量
总结：初始化的变量与条件判断的变量与改变的变量为同一个'''
sum=0
a=0
while a<5:
    sum+=a
    a+=1
print(sum)

练习与错误

#计算一到100的偶数和
a=1
sum=0
while a<101:
    if a%2==0:
        sum+=a
    a+=1
print(sum)



'''错误1'''
#计算1到100间的偶数和
a=0
sum=0
while a<101:
  a+=2
  sum+=a
print(sum)
#计算结果2652，比正确结果多了102


'''错误3'''
#算了，我没大搞懂，真难，我数学不咋地，可能不适合编程哎

for-in循环

1.in表达从（字符串，序列）中依次取值，又称为遍历

2.for-in遍历的对象必须是可迭代对象

3.for-in 的语法结构

for 自定义的变量 in 可迭代对象 ：循环体

4.for-in的执行图

5.循环体内不需要自定义变量，可以将自定义变量替换为下划线

#for in 循环
for item in 'python':  #第一IC取出来p，将p赋值给item，将item输出
    print(item)

#range（）产生一个整数序列，--》也是一个可迭代对象
for i in range(10):
    print(i,'hhh')

#如果在循环体中不需要用到自定义变量，可将自定义变量写为_
for _ in range(5):
    print('hhhhh')

练习

#使用for循环，计算1到100之间的偶数和
sum=0
for item in range(1,101):
    if item%2==0:
        sum+=item
print(sum)

#输出100到999间的水仙花数
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    print(ge,shi,bai)
    if ge**3+shi**3+bai**3==item:
      print(item)

break语句

     用于结束循环结构，通常与分支结构if一起使用

​
'''从键盘输入密码，最多输入3次，如果正确就结束循环'''
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

​

continue 语句

    用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

#流程控制语句continue
'''要求输出1到50之间所有五的倍数
5的倍数的共同点是跟5的余数为0'''
for item in range(1,51):
    if item%5==0:
        print(item)

print('------------使用continue')
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

'''break的话 直接就结束了，continue还会继续'''

else语句

   

#else也可以与for 跟while搭配
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，您的三次机会已经用完')

a=0
while a<3:
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
        a+=1
else:
    print('您的机会已经用完')

'''总结一下，就是条件执行体，跟一些循环，'''

嵌套循环

  循环结构中又嵌套了另外完整的循环结构，其中内层循坏作为外层循环的循环体执行

#嵌套循环
'''打印一个三行四列的*列'''
for i in range(1,4):
    for j in range(1,5):
        print('*',end='\t')
    print()



#搞一个九九乘法表
for a in range(1,10):
    for b in range(1,a+1):
        print(a,'*',b,'=',a*b,end='\t')
    print()

二重循环中的break和continue用于控制本层循环

#流程控制语句break与continue在二重循环中的应用
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            #break
            continue
        print(j,end='\t')
    print()

 第五章知识总结

第六章

1.列表的创建与删除

2.列表的查询操作

3.列表元素的增删改操作

4.列表元素的排序

5.列表推导式

一、创建与特点

'''创建列表的第一种方法，[]'''
lst=['hello','world',98]
print(lst)#列表元素按顺序有序排序
print(lst[0],lst[-3])#索引映射唯一一个数据
#列表可以存储重复数据
#任意数据类型混存
#根据需要动态分配和回收内存
'''创建列表的第二种方法，使用内置函数list()'''
lst2=list(['hello','world',98])

二、列表的查询操作

获取指定元素的索引

​
'''获取指定元素的索引'''
lst=['hello','world','89','hello']
print(lst.index('hello'))#如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
#print(lst.index('python'))#value error python不在列表里
#print(lst.index('hello',1,3))#还是错误，因为开区间，不在这个范围里
print(lst.index('hello',1,4))#这样就行了

获取列表中指定元素

​
'''获取列表中的指定元素'''

lst2=['hello','world',898,'hello','world',9382938]
print(lst2[2])#正向索引，从0到n-1
print(lst2[-3])#负向索引，从-n到-1
#print(lst2[9])#超出范围，报错

​

​

获取列表中的多个元素（切片操作）

'''获取列表中的多个元素  形式[start:stop:step]左闭右开'''
lst=[10,20,30,40,50,60,70,80]
#start1 stop6 step1
print(lst[1:6:1])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[2::2])
print(lst[::])
print(lst[::-1])#逆序
print(lst[7:2:-1])

列表元素的判断及遍历

'''列表元素的判断及遍历'''
print(10 in lst)
print(10 not in lst)#判断指定元素

#遍历，for 迭代变量 in 列表名
for item in lst:
    print(item)

三、

列表元素的增加

'''列表元素的添加操作'''
#在列表的末尾添加一个元素append
lst=[10,20,30]
print('添加元素之前',lst)
lst.append(100)
print('添加元素之后',lst)


#在列表末尾至少添加一个元素extend
lst2=['hello','朱国旭']
lst.append(lst2)
print(lst)#将lst2作为一个元素添加到了列表的末尾
#x向列表末尾一次性添加多个元素用extend
lst.extend(lst2)
print(lst)

#在列表任意位置添加一个元素insert
lst.insert(1,20)
print(lst)


#切片，在列表的任意位置至少添加一个元素
lst3=['hahahha','我的好宝贝']
lst[1:]=lst3
print(lst)
lst[1:2]=lst3
print(lst)

删除

'''列表元素的删除操作'''
#remove，一次只删除一个元素，重复元素值删除第一个，元素不存在显示valueerror
lst=[10,20,30,40,20]
lst.remove((20))
print(lst)


#pop 删除一个指定索引上的元素，指定索引不存在会显示indexerror，不指定索引，会删除列表最后一个元素
lst.pop(1)
print(lst)
lst.pop()
print(lst)


#切片，一次至少删除一个元素 ，将产生一个新的列表对象
lst=[1,3,22,4343,56,3]
new_lst=lst[1:4]
print('原列表',lst)
print('新列表',new_lst)


#clear清楚列表 del删除对象
lst.clear()
print(lst)
del lst
#print(lst)这时候已经清除了，所以肯定不会有

修改

​
#列表元素的修改操作
lst=[1,2,3,4]
lst[2]=100
print(lst)#为指定索引元素赋予一个新值
lst[1:3]=[10,20,30,40]
print(lst)#为指定切片赋予新值

四、列表元素的排序

'''列表元素的排序操作'''
lst1=[20,30,2,4,5,45]
print('排序前的列表',lst1)
#开始排序，调用列表对象的sort方法，升序
lst1.sort()
print('排序后的列表',lst1)

#通过指定关键字参数，将列表中的元素进行降序排序
lst1.sort(reverse=True)#reverse=True是降序排序，reverse=False是升序排序
print(lst1)
lst1.sort(reverse=False)
print(lst1)

#使用内置函数sorted对列表进行排序，将产生一个新的列表对象
lst1=[20,30,2,4,5,45]
print('原列表',lst1)
new_lst1=sorted(lst1)
print('新列表',new_lst1)
#通过指定关键字参数，将列表中的元素进行降序排序
new1_lst1=sorted(lst1,reverse=True)
print(new1_lst1)



​

五、列表生成式

'''列表生成式（生成列表的公式）   [i*i(表示列表元素的表达式 for i(自定义变量） in range()]'''
lst2=[i for i in range(1,10)]
print(lst2)

lst2=[i*i for i in range(1,10)]
print(lst2)

#列表中的元素值 为2，4，6，8，10
lst2=[i*2 for i in range(1,6)]
print(lst2)


lst2=[i for i in range(2,11,2)]
print(lst2)

 第六章总结

 第七章 

1.什么是字典

2.字典的原理

3.字典的创建与删除

4.字典的查询操作

5.字典元素的增删改

6.字典推导式

一、什么是字典

字典是python内置的数据结构之一，与列表一样是一个可变序列：以键值对的方式存储数据，字典是一个无序的序列

根据key查找value所在位置（通过hash函数计算key，找到value对应的值所在的位置）

二、字典的创建

#字典是python内置的数据结构之一，与列表一样是一个可变序列：以键值对的方式存储数据，字典是一个无序的序列


#创建字典
'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

'''第二种创建方式，使用dict'''
student=dict(name='jack',age=20)
print(student)


'''空字典'''
d={}
print(d)

三、字典元素的获取

print('------------字典元素的获取------')

scores={'张三':100,'李四':98,'王五':45}
'''第一种方式：使用[]'''

print(scores['张三'])
#print(scores['哈哈'])  KeyError: '哈哈'  键不存在


'''第二种方式，使用get（）'''
print(scores.get('张三'))
print(scores.get('哈哈'))#没有报错
print(scores.get('去你的',99))
print(scores.get('张三',99))#99是不存在时的默认值，如果存在还是那个样

四、字典元素的常用操作

键的判断

print('------------键的判断------')
print('张三' in scores )
print('张三' not in scores)

删除修改新增

print('------------字典元素的删除------')
#用del
del scores['张三']#删除指定的key - value对
#scores.clear()#清空字典的元素
print( scores)




print('------------字典元素的新增------')
scores['陈六']=334
print(scores)


print('------------字典元素的修改------')
scores['陈六']=33
print(scores)

获取字典视图

print('------------字典的视图操作------')

scores={'张三':100,'李四':98,'王五':45}


'''获取所有的key'''
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys))#将所有key组成的视图转换成列表

'''获取所有的values'''
values=scores.values()
print(values)
print(type(values))
print(list(values))


'''获取所有的键值对'''
items=scores.items()
print(items)
print(type(items))
print(list(items))#转换之后的列表是由元组组成的

字典元素的遍历

print('--------------字典元素的遍历---------')
for item in scores:
    print(item,scores[item],scores.get(iteml))

五、字典的特点

'''1.字典所有元素都是一个key-value对，key不允许重复，value可以重复
2.字典中的元素是无序的
3.字典中的key必须是不可变对象（用lst当键肯定不行）
4.字典可以根据需要动态伸缩
5.字典会浪费较大的内存，是一种空间换时间的数据结构'''


#1.
d={'name':'张三','name':'李四'}
print(d)#输出{'name': '李四'}，李四将张三覆盖掉了，key不允许重复。否则会出现值覆盖的情况
d={'name':'张三','nikename':'张三'}
print(d)#输出{'name': '张三', 'nikename': '张三'}，说明value可以重复



#2.
lst=[10,20,30]
lst.insert(1,100)
print(lst)#列表是有顺序的，可以在指定位置插入，但是字典不行。字典是根据键计算值所存在位置，位置是计算出来的，不是人为指定的

六、字典生成式

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
d={item.upper():price  for item,price in zip(items,prices)}
print(d)

 第七章总结