2022.4.6学习总结

1.python容器

'''
列表
变量=[数据，数据。。。。。]

添加
列表.append(数据)

查询
列表.index(数据)  #如果不存在会会报错
列表.count(数据)

修改指定下标位置的数据
列表[下标]=数据
'''
'''
  #定义列表
hetun_list[1]=22   #修改下标为1的数据，改为22
print(hetun_list)
hetun_list[-1]= '宝宝' #修改最后一个位置的数据
print(hetun_list)
hetun_list[55]=33  #报错
'''
'''
删除操作
在列表中删除中间的数据，那么后面的数据会向前移动
根据下标删除
列表.pop(下标)  删除指定下标位置对应的数据
1.下标不写，默认删除最后一个数据（常用）
根据值删除
列表.remove(数据值)  
返回：None
如果删除的数据不存在会报错
清空数据（一般不用）
列表.clear()
'''
'''
he_tun = [1,5,85,9,4,1,2,3,20]
he_tun.pop()  #删除最后一个位置的数据
print(he_tun)

he_tun.pop(2)  #删除下标为2的数据
print(he_tun)

he_tun.remove(1)  #删除数据值为1的数据，只能删除第一个，如果不存在会报错
print(he_tun)

he_tun.clear()  #删除
print(he_tun)  
'''
'''
列表的反转（倒置）
字符串中反转倒置：字符串[::-1]

列表中反转和倒置：
1、列表[::-1]  使用切片的方法，会得到一个新的列表，原列表不会发生改变
2. 列表.reverse()    这个方法会直接修改原列表
'''
'''
bao_bao = [2,58,8,5,1,8,4,5,14,8,4,4]
bao_bao1 =bao_bao[::-1]  #列表反转，得到新列表，原列表不变
print(bao_bao)
print(bao_bao1)

bao_bao.reverse()    #原列表反转，也被修改了
print(bao_bao)
'''
'''
列表的复制
将列表中的数据复制一份，给到一个新的列表
使用场景：有一个列表，需要修改，修改后与修改前须臾奥作对比，先复制再修改
1.使用切片
变量 = 列表[:]
2.copy方法
变量=列表.copy()
'''
'''
hetun = [2,3,4,4]
hetun1 = hetun[:]  #切片hetun，复制到hetun1
print(hetun1)

hetun1[1] =22  #修改hetun1里面的数据
print(hetun1)

hetun2=hetun.copy()  #copy方法复制
print(hetun2)

hetun3 =hetun  #直接等于起不到复制的作用，这样相当与把hetun列表起了一个别名，是同一个列表
print(hetun3)
hetun3[0]=3333   #一改全改
print(hetun3)
print(hetun)
'''
'''
列表的排序
列表的排序，一般来说都是按数字排序
列表.sort()  升序，从小到大
列表.sort(reverse=Ture)  降序，从大到小
'''
'''
hu_tun = [1,2,32,3,2]
hu_tun.sort()    #直接改了原列表的顺序
print(hu_tun)
hu_tun.sort(reverse=True)
print(hu_tun)
'''
'''
列表的嵌套
列表嵌套，列表中的内容还是列表，列表中的列表
使用下标来确定获取的是什么类型的数据，再操作
'''
'''
hetun =[[3,'4',34,],['呵呵','哈哈']]
print(len(hetun))
print(hetun[1])
print(hetun[0][1])  #第0个元素中的第一个元素
print(hetun[1][0])  #第1个元素中的第0个元素

hetun[0][1]='55'  #改数据
print(hetun)

hetun[1].append('哈哈')  #选定位置加数据
print(hetun)

hetun[0].pop(2)  #删除第0个元素中的第2个元素
print(hetun)

hetun[1].remove('哈哈')  #删除一个数据
print(hetun)
'''
'''
元组
元组：tuple [tʌpl]，和列表差不多

1.元组中可以存放任意类型的数据
2.元组中可以存放多个数据

和列表区别
1、元组中的数据内容不能改变，列表中的可以改变
2、元组用()，列表用[]

元组的应用：函数的传参或者返回值中使用，保证数据不会被修改

定义
直接用()定义

因为元组不饿能修改所以之只能查看
1.元组也可以用下标和切片获取数据
2.在元组中可以用index方法，查找下标，如果不存在会会报错
3.在元组中存在count方法，统计数据出现的次数
4.在元组中可以使用in操作，判断数据是否存在
5.len(统计个数)
以上方法和列表一样
'''
'''
hetunbaobao =tuple()   #定义空元组，不会使用的
print(hetunbaobao)

hetun = tuple([1,2,4,43,2]) #类型转换，列表转元组同理元组也可以转列表
print(hetun)

heutn2 =tuple('baobao')  #类型转换，字符串转元组，把字节拆开了，和字符串转列表是一样的
print(heutn2)

hetun3 =(2,3,24,12,2)  #直接用（）定义
print(hetun3)

hetun4 =(2,)  #元组中只有一个数据的时候，后面必须加逗号，
print(hetun4)
'''

'''
字典
1.字典dict，字典中的数据是由键key和值value对组成的
2.在字典中一组键值是一个数据，多个键值对之间用逗号隔开
3.变量={key:value,key:value.....}
4.key唯一，value可以重复可以是任意数据
5.key一般是字符串或者数字，不能是列表
6.和列表，元组，字符串之间不能类型转换
'''
'''
hetunbaibai = dict()   #直接定义一个空的字典
print(hetunbaibai)

hetunbebe = {}   #直接定义一个空的字典
print(hetunbebe)

hetun ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}   #非空字典
print(hetun)
'''

'''
字典的增改
语法
字典[键]=数据值
1.如果键已存在，就是修改数据值
2.如果键不存在，就是添加
'''
'''
hetun ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}
hetun['喵喵']='吃猫粮'  #修改喵喵的值
print(hetun)

hetun['兔兔']='吃草'  #添加key
print(hetun)
'''

'''
删除
del字典[键]
或者
字典.pop()

清空
字典.clear
'''
'''
hetun ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}
del hetun['喵喵']  #删除喵喵
print(hetun)

hetun1 ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}
hetun1.pop('喵喵')  #删除喵喵
print(hetun1)

hetun1.clear()  #清空了
print(hetun1)
'''
'''
查询-根据键获取对应的值
字典中没有下标的概念，想要获取数据的值，要用key 来获取
key不存在会报错
语法
1.字典.get(键)
2.字典[键]
'''
'''
hetun ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}
print(hetun['喵喵'])  #获取喵喵的值
print(hetun.get('喵喵')) #获取喵喵的值

print(hetun['狗狗'][1])    #获狗狗列表第一个值
'''
'''
字典的遍历
对字典的键 进行遍历
for 变量 in 字典:
 print(变量)    #变量就是获取字典的key
 
 
for 变量 in 字典.keys()；   #字典可以获取字典中所有key
  rint(变量)  
  
对字典的值进行遍历
for 变量 in 字典.values():  #字典.values可以获取字典中所有的值
 print(变量)
 
对字典中的键值对进行遍历
for 变量1，变量2 in 字典.items():   #字典.items获取字典中所有键值对
 print(变量1,变量2)   #变量1对应键，变量2对应值
 '''
'''
hetun ={'喵喵':'吃鱼','狗狗':['吃骨头','吃shi'],'猪猪':['吃菜叶','吃泔水']}
for i in hetun:
    print(i)

for i in hetun.keys():    #注意这里是keys  注意加s
    print(i)

for i in hetun.values():  #同样要加s,values
    print(i)

for i1,i2 in hetun.items():   #itenms,注意加s
    print(i1,i2)
 '''
'''
#容器部分总结和延申
#1.
hetun = 'da'+'hetun'   #字符串支持加法，拼起来
print(hetun)

hetun1 =[1,2]+[2,3]  #列表支持加法，拼起来
print(hetun1)

hetun2 =(2,3)+(3,54)  #元组支持加法，拼起来
print(hetun2)

#2.
print('haha'*3)
print([1,2,3,4]*4)
print(('d',3,4,32)*5)    #字符串和列表元组都支持乘法，×一个数字

#3.len()在容器里都可以使用
print(len('haha'*3))
print(len([1,2,3,4]*4))
print(len(('d',3,4,32)*5))

#4.in关键字在容器里都可以使用，在字典中判断的是字典的键是否存在
 '''
#5.列表去重
'''
列表去重：列表中存在多个数据，需要去重
方法1.思路，for遍历，判断是否存在用in,不存在加入，存在就不用管
存入数据append
'''
hetun=[1,3,4,2,3,23,1,23,4,21,3,124,3,23]
hetun1=[]
for i in hetun:
    if i not in hetun1:  #这里也可以用 in ，if in然后就pass，过
     hetun1.append(i)
print(hetun1)

#方法2，还有一种容器叫集合set(),set中不允许有重复的值，所以可以将列表类型转换两次
#缺点：顺序不保证，会自动排序
hetun=[1,3,4,2,3,23,1,23,4,21,3,124,3,23]
hetun2=list(set(hetun))
print(hetun2)

2.函数

'''
函数
函数，就是把 具有独⽴功能的代码块 组织为⼀个⼩模块，在需
要的时候 调⽤
函数,通俗理解, 将多⾏代码写在⼀块,起个名字, 在需要这多⾏
代码的时候,可以直接使⽤这个名字来代替
函数好处: 减少代码的冗余(重复的代码不⽤多写), 提⾼程序的
编写效率

'''
'''
函数定义
1.将多行代码放在一起，起名字的郭晨，称为函数定义
2.函数必须先定义后调用

语法

def 函数名()
    函数中的代码
    函数中的代码

1.def是关键字，用来定义函数的，define的缩写
2.函数名需要遵守标识符的规则
3.处于def缩进中的代码，称为函数体
4.函数定义的时候，函数体中的代码不会执行，在调用的时候才会执行

tips：
前期,书写不熟练的时候,
1. 可以先不管函数,先把功能写出来,
2. 给多⾏代码起名字
3. 选中多⾏代码, 使⽤ tab 键进⾏缩进

函数的调用
语法

函数名()

1.函数调用的时候执行函数体中代码
2.函数调用的代码，要卸载函数体外面
3.注释：书写位置, 在函数名的下⽅使⽤ 三对双引号进⾏的注释
'''

'''
def hetunshuo():     #定义函数
   三单引号  注释内容  三单引号
    print('nihao')
    print('woshi')
    print('hetunbaobao')

hetunshuo()  #调用函数，鼠标悬浮在函数上可看到注释
'''
'''
函数的嵌套调用

在一个函数定义中调用另一个函数
1.函数定义不会执行函数体中的代码
2.函数调用会执行函数体中的代码
3.函数体中代码执行结束会回到被调用的地方继续向下执行
'''
'''
def ff1():
    print(1)
    print(2)

def ff2():
    print(3)
    ff1()
    print(4)

ff2()
'''

#函数基础
# 案例1. 定义⼀个函数, my_sum ,对两个数字进⾏求和计算.
'''
def my_sum():
    num1 = 10
    num2 = 20
    num = num1 + num2
    print(num)

my_sum()
'''
#那么问题来了。这样只能算死的数，要算任意数的话要引入函数参数
'''
def my_sum(num1,num2):    #num1 和num2就是参数，代码里面要用到的变量，形式参数，简称形惨参
    sum = num1 + num2
    print(sum)

my_sum(3,4)   #这里3，4是具体的值了，键实际参数，简称实参
'''
'''
函数的返回值
函数的返回值,可以理解为是 函数整体执⾏的结果是什么
什么上班需要书写返回值: 函数中得到的数据在后续的代码中还
要使⽤,这个时候就应该将这个数据作为返回值返回,以供后续使
⽤
print() ---> None
input() ---> 键盘输⼊的内容
type() ---> 类型
len() ---> 数据的⻓度(元素的个数)
在函数中想要将⼀个数据作为返回值 返回, 需要使⽤ return
关键字(只能在函数中使⽤)
作⽤:
1. 将数据值作为返回值返回
2. 函数代码执⾏遇到 return, 会结束函数的执⾏
3，没有返回值就是None
'''
'''
def hetun(a,b):
    baobao=a+b
    return baobao     

print(hetun(2,43))    #整个函数就是敲出来就是返回值

haha=hetun(22,22)   #我们一般将需要使用的东西用一个变量来保存
'''
'''
变量进阶[理解 知道]
变量的引用
1. 在定义变量的时候 变量 = 数据值, Python 解释器会在内存
中开辟两块空间
2. 变量和数据都有⾃⼰的空间
3. ⽇常简单理解, 将数据保存到变量的内存中, 本质是 将 数
据的地址保存到变量对应的内存中
4. 变量中存储数据地址的⾏为 就是引⽤ (变量引⽤了数据的地
址, 简单说就是变量中存储数据), 存储的地址称为 引⽤地址
5. 可以使⽤ id() 来获取变量中的引⽤地址(即数据的地址),
如果两个变量的 id() 获取的引⽤地址⼀样, 即代表着, 两个变
量引⽤了同⼀个数据,是同⼀个数据
6. 只有 赋值运算符=, 可以改变变量的引⽤(等号左边数据的引
⽤)
7. python 中数据的传递,都是传递的引⽤
'''
'''
baobao =10086
print(id(baobao))

hetun = baobao
print(id(hetun))

boaboa =1341
print(id(hetun))
'''

'''
可变类型和不可变类型
数据类型:int float bool str list tuple dict set
可变不可变是指: 数据所在的内存是否允许修改, 允许修改就是
可变类型, 不允许修改就是不可变类型(不使⽤=, 变量引⽤的数
据中的内容是否会变化,会变化是可变的, 不会变化是不可变的)
可变类型: 列表 list, 字典 dict, 集合 set
列表.append()
字典.pop(键)
不可变类型:int float bool str tuple


案例就不写了，用到了再说，看着就感觉用处不大
'''
'''
经典面试题
def func(list1):
    list1.append(10)

my_list = [1, 2]
func(my_list)
print(my_list)
① [1, 2] ② [1, 2, 10]   这里我选2 √
----------------------------------------------
def func(list1):
    list1[0] = 10
my_list = [1, 2]
func(my_list)
print(my_list)
① [1, 2] ②[10, 2]   这里我选2  √
------------------------------------------------
def func(list1):
    list1 = [2, 1]
my_list = [1, 2]
func(my_list)
print(my_list)
① [1, 2] ②[2, 1]  这里我选2 ×  有点无法理解了 ps:看懂了，这里是函数变量（应该是ptyhon变量都有？）(确实都有)的一个特性，定义函数时候用到的变量和外面使用的变量是两个东西，调用
该函数的时候，此时两个变量引用是一致的，但是函数里面有改变引用的话，改变的是函数里面的变量引用，外面变量的引用没有变
'''
'''
def func(list1):      
    list1 = [2, 1]    
list1= [1, 2]
func(list1)
print(list1)

'''
'''
def func(tuple1):      
    tuple1 = (2,1)
tuple1= (1,2)
func(tuple1)
print(tuple1)
'''
'''
def func(dic1):
    dic1= {'da':23,'www':22}
dic1= {'www':22,'da':23}
func(dic1)
print(dic1)
'''
'''
def func(a):
    a=3
a='4343'
func(a)
print(a)
'''
'''
a=10
b=a
a=5
print(b) #这里是10
'''
'''
列表的+=操作
def func(list1):
list1 += [1, 2]
my_list = ['a', 'b']
func(my_list)
print(my_list) ===> ?
① ['a', 'b'] ② ['a', 'b', 1, 2]  这里我选① ×   +=并没有改变引用
'''
'''
def func(list1):
 list1 = list1+[1, 2]
my_list = ['a', 'b']
func(my_list)
print(my_list)   #  ['a', 'b']

def func(list1):
 list1 +=[1, 2]     #没有直接使用=就没有改变引用引用，牛逼了，这里+=相当于extend，形参的数据会改变实参的值
my_list = ['a', 'b']
func(my_list)
print(my_list)   #['a', 'b', 1, 2]

hetun = [3,4,4]
hetun.extend([11,2,2,2])   #extend
print(hetun)
'''
'''
def f(l=[]):
    l.append(1)
    return l
f()              #默认参数是同一个l
f()               #默认参数是同一个l
print(f())
'''
'''
题⽬ 4 交换两个变量的值
a = 10
b = 20
# ⽅法⼀: 常规⽅法 引⼊第三个变量
# c = a # 将 变量 a 中的值先保存起来 10
# a = b # 将变量 b 中的值 给 a
# b = c # 将变量 c中的值(即最开始 a 的值) 10 给 b
# print(a, b)
# ⽅法⼆, 不使⽤第三个变量, 使⽤数学中的⽅法
# a = a + b # a 的值 30
# b = a - b # 30 - 20 ===> 10
# a = a - b # 30 - 10 ===> 20
# print(a, b)
# ⽅法三, 重点掌握, Python 特有
a, b = b, a
print(a, b)
'''
'''
a = 10
b = 20
a, b = b, a
print(a, b)
'''
'''
组包和拆包
组包（pack）：将对各数据值使用逗号连接，组成元组
拆包（unpack）：将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持一致
赋值运算符, 都是先执⾏等号右边的代码, 执⾏的结果,保存到等
号左边的变量中
'''
'''
a = 10
b = 20
c=b,a   #组包
print(type(c),c)

a,b=c  #拆包
print(a,b)

x,y,z=[1,2,3]   #拆包
c=x,y,z  #组包，成元组了
print(c,x,y,z)
'''
'''
局部变量和全局变量
变量：根据变量的定义位置，可以将变量分为局部变量和全局变量
局部变量
局部变量: 在函数内部(函数的缩进中)定义的变量,称为是局部变
量
特点:
1. 局部变量只能在当前函数内部使⽤, 不能在其他函数和函数外
部使⽤
2. 在不同函数中,可以定义名字相同的局部变量, 两者之间没有
影响
3. ⽣存周期(⽣命周期, 作⽤范围)--> 在哪 能⽤
在函数被调⽤的时候,局部变量被创建, 函数调⽤结束, 局部变量
的值被销毁(删除), 不能使⽤
所以函数中的局部变量的值, 如果想要在函数外部使⽤, 需要使
⽤ return 关键字, 将这个值进⾏返回
'''
'''
def hetun():
    num =10
    print(num)
def hetun1():
    num =100
    print(num)   #互补影响
hetun()
hetun1()
'''
'''
全局变量
定义位置: 在函数外部定义的变量, 称为是 全局变量
特点:
1. 可以在任何函数中读取(获取) 全局变量的值
2. 如何在函数中存在和全局变量名字相同的局部变量, 在函数中
使⽤的是 局部变量的值(就近)
3. 在函数内部想要修改全局变量的引⽤(数据值), 需要添加
global 关键字, 对变量进⾏声明为全局变量
4. ⽣命周期
代码执⾏的时候被创建, 代码执⾏结束,被销毁(删除)
''''''
hetun = 20  #这里的hetun是全局变量
def hetun1():
    hetun=100
    print(hetun)   #这里的hetun是布局变量
hetun1()

def hetun2():
    global hetun
    print(hetun)   #这里的hetun是全局变量
hetun2()
'''
'''
函数进阶
返回值-函数返回多个数据值
函数中想要返回一个数据值，使用return关键字
将多个数据值组成容器进行返回，一般是元祖
''''''
def hetun(a,b):
    num=a+b
    num1=a-b
    return num,num1
baobao=hetun(22,33)
print(baobao)
'''
'''
函数参数
传参
位置传参
在函数调用的时候，按照形参的顺序，将实参传递给形参
关键字传参
在函数调用的时候，指定数据位置给到那个形参
混合使用
1.关键字传参必须写在位置传参的后面
2.不要给一个形参传递多个数据值
'''
'''
def hetun(a,b,c):
    print(f'a:{a},b:{b},c:{c}')

hetun(1,2,3)  #位置传参
hetun(a=3,b=4,c=5)  #关键字传参
hetun(2,3,c=9)  #混合使用
'''
'''

缺省参数
缺省参数, 默认参数
列表.pop() # 不写参数,删除最后⼀个
列表.sort(reverse=True)
1. 定义⽅式
在函数定义的时候, 给形参⼀个默认的数据值, 这个形参就变为
缺省参数, 注意, 缺省参数的书写要放在普通参数的后边
2. 特点(好处)
缺省参数, 在函数调⽤的时候, 可以传递实参值, 也可以不传递
实参值
如果传参,使⽤的就是传递的实参值, 如果不传参,使⽤的就是默
认值
'''
'''
def hetun(a,b='喵喵'):
    print(a,b)
hetun('哈哈')   #没穿参数，使用的是默认值
hetun('哈哈','嘿嘿')
'''
'''
多值参数[可变参数/不定⻓参数]
当我们在书写函数的时候, 不确定参数的具体个数时, 可以使⽤不定⻓参数
不定⻓位置参数(不定⻓元组参数）
1. 书写, 在普通参数的前边,加上⼀个 *, 这个参数就变为
不定⻓位置参数
2. 特点, 这个形参可以接收任意多个 位置传参的数据
3. 数据类型, 形参的类型是 元组
4. 注意, 不定⻓位置参数 要写在普通的参数的后⾯
5, ⼀般写法, 不定⻓位置参数的名字为 args, 即(*args)
 # arguments
 
 不定⻓关键字参数(不定⻓字典参数)
 1. 书写, 在普通参数的前边,加上 两个 *, 这个参数就变
为不定⻓关键字参数
2. 特点, 这个形参可以接收任意多个 关键字传参的数据
3. 数据类型, 形参的类型是 字典
4, 注意, 不定⻓关键字参数,要写在所有参数的最后边
5, ⼀般写法, 不定⻓关键字参数的名字为 kwargs, 即(**kwargs), keyword arguments
 
 完整的参数顺序
 def 函数名(普通函数, 
*args, 缺省参数, 
**kwargs):
 pass
⼀般在使⽤的时候, 使⽤ 1-2种, 按照这个顺序挑选书写即
可
'''
'''
def hetun(*args,**kwargs):
    print(type(args),args)
    print(type(kwargs),kwargs)
hetun()
hetun(1,2,3)  #位置传参，给到了args里面,元祖
hetun(k=3,l=4,y=4)  #关键字传参，给到了kwargs里面，字典
hetun(2,4,3,k=2,ll=3,o=2)
'''
'''
print(1,end=' ')  #取消换行，变空格
print(2,end=' ')
print(3)
print(4)

print(1,2,2,4,4,sep='_')  #sep=,多个参数之间的空格填充
print(1,2,2,4,4,sep='haha')
'''

3.明日计划，函数剩余，面向对象，文件