python(b站python视频听课笔记黑马程序员视频方便自己后期复习知识点用）

python总结区：

一.变量解释

图书馆看书，如何快速找到书籍呢？按照管理员对书的的编号找到书放置的位置。就能找到想要的书籍。
这个编号其实就是把书籍存放的位置起了个名字蛮方便后期进行查找。
程序中，数据都是临时存放在内存中，为了更快速的查找或者使用这个数据，我们把存储在内存中的数据定义一个名称，这个名称就叫变量。
（通俗的讲就是：内存地址的名字）

二.定义变量

2.1标识符命名规则：

1. 由字母数字下划线组成
2. 不能数字开头
3. 不能使用内置关键字
4. 严格区分大小写

2.2命名习惯

5. 大驼峰：MyName
   6.小驼峰：myName

三.认识数据类型

1.小知识点：
#dict-- 字典格式–

f={'name':'TOM','age':18}
print(type(f)) 

2.格式化输出：

 age=18
 print('今年我的年龄是%d岁'%age)#注意和c语言不一样，python中间没有逗号。

3.输出两个值

 print('我的名字是%s,今年%d岁了'%(name,age))
 print('我的名字是%s,明年%d岁了'%(name,age+1))

4.#语法f‘{表达式}’

 print(f'我的名字是{name},今年{age}岁了')  

四.三目运算符

语法如下：
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
快速体验：

a=1
b=2
c=a if a>b else b

解释一下：
a>b吗如果是返回a如果不是返回b。c等于返回的数。

五.循环操作

1

while i<= 5;      #注意这里有分号结束
     print("媳妇儿，我错了"）   #注意这个有缩进
     i=i+1  #注意这里没有分号

2
for循环
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
…
例子：

   str1=‘skjadkas’
     for i in str1:
     print(i) #这里有缩进

六.字符串

单引号输入
print('tom’)
双引号输入
print(“tom”)
三引号输入
print("‘tom"’)
区别：
三引号支持回车换行
切片（切片是指对操作的对象截取其中一部分的操作，字符串，列表，元祖都支持切片操作）

1. 语法
序列[开始位置下标:结束位置下标:步长]
2.注意
不包含结束位置下标对应的数据，正负整数均可；
步长是选取间隔，正负整数均可，默认步长为1.

str1=‘abcdef’
#得到整个字符串
print(str1)
#下标得到的下标为某个数字的数据

print(str[2])

**用切片得到abc这三个数据**

  str[0,3,1]

这里重点解释一下：
切片操作左闭右开，左边选的下标在输出中是包括的，右边选的下标在输出中是不包括。因此这里选的是下标从0到2所对应的数据。步长为一表示从初始的下标开始加一选取下一个。
这里str[:]
解释一下：如果不写步长则默认为一，不写开始则默认从头开始，不写结束表示选取到最后，都不写表示从头选到尾。
负数测试：
print(str[::-1]
#从后边往前一个倒序排列。如果步长为负数，表示倒序选取。
一个难点

  str1='012345678'
  print(str1[-4:-1]}
  输出结果567

下标-1表示最后一个数据。倒序最后下标从-1开始不是从0开始。这里-1在结束位置所以输出的时候不包括，然后依次向前推。
字符串常用操作方法：
查找

1.find（）检查某个子串是否包含在这个字符串中，如果在返回这个字串的位置下标，否则则返回-1.
语法
字符串序列.find(子串,开始位置下标，结束位置下标）
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
例子：

mystr="hello world and itcast and itheima and Python"
  print(mysql.find('and'))#返回12下标
  print(mysql.find('and'，15,30)）#返回23

2.index()和find函数一样，只不过find函数找不到之后返回的是-1，index找不到则直接报错。
3.count(‘and’,15,30)#返回查找个数
修改
1.replace():替换
字符串序列.repalce(旧子串，新子串，替换次数)
注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。
例子：

 mystr="hello world and itcast and itheima and Python"
 new_str=mystr.replace('and','he')
 print(mystr)
 print(new_str)

注意这个replace不会重写原来的字符串，返回值是修改后的字符串。这里将原字符串中的and全部替换为he。
调用了replace函数后，发现原有字符串的数据并没有做到修改，修改后的数据是replace函数的返回值
说明字符串是不可变数据类型
2.split()按照指定字符分割字符串
语法
字符串序列.split(分割字符，num)

 list1 = mystr.split('and',2)

用and分隔返回三个数
3.join()用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。
语法
#合并列表里面的字符串数据为一个大字符串

mylist=['aa','bb','cc']

4.capitalize():将字符串第一个字符转换成大写
注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。
5.title():将字符串每个单词首字母转换成大写。
6.strip():删除字符串两侧空白字符。
lstrip():删除字符串左侧空白字符
rstrip():删除字符串右侧空白字符

七.列表

查找
1.下标

name_list=['tom','lily','rose']
print(name_list[0])

输出：tom
index()和count()和字符串里的函数一样的。
len():访问列表长度，即列表中数据的个数。
判断数据是否存在一段列表序列中
1.in:判断指定数据在某个列表序列，如果在返回 true,否则返回False
例子：

name_list=['tom','lily','mike']#这一点注意列表写法不是大括号而是方括号
print('tom' in name_list)

2.not in:判断指定数据不在某个列表序列，如果不在返回true,否则返回False
体验案例：

name_list=['tom','lily','rose']
name=input('请输入您的邮箱账号名：’）
if name in name_list:
   print(f'您的名字是{name},该用户已经存在')
else:
   print(f'您的名字是{name},可以注册！')

增加
1.append():列表结尾追加数据。
语法：
列表序列.append(数据)

name_list.append('xiaoming')
print(name_list)

追加列表测试：

name_list.append([11,22])

注：append函数追加数据的时候如果数据是一个序列，追加整个序列到列表的结尾
2.extend():列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。
语法
列表序列.extend(数据)

name_list.append('xiaoming')

输出的xiaoming中的每个字符都拆开了，然后逐一追加到列表的结尾。
3.insert():指定位置新增数据
语法
列表序列.insert(位置下标，数据)

name_list.insert(1,'aaa')

删除
1.del
语法
del 目标

del name_list 或者这样写
del （name_list）
还可以指定一个数据进行删除：
del name_list[0] 

2.pop()删除指定下标的数据，如果不指定下标，默认删除最后一个数据，无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据。
name_list.pop()执行后会返回删除name_list中的最后一个数据。
3.remove(数据）
name_list.remove(‘ROSE’)
print(name_list)
4.clear()
name_list.clear()
print(name_list)
修改
1.修改指定下标的数据
name_list[0]=‘aaa’
print(name_list)
2.逆序reverse()
list.reverse()
3.sort()排序：升序（默认）和降序
语法
列表序列.sort(key=None,reverse=False升序（默认））
注意：reverse表示排序规则，reverse=True降序，reverse=False升序（默认）

八.元祖

元祖的应用场景：
列表可以一次性存储多个数据，但是列表中的数据允许更改，元祖可以存储多个数据，元祖内的数据是不能修改的。因此像身份证号之类的就可以用元祖存放。
元祖特点：定义元祖使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型
例子：

#多个数据元祖
t1 = (10,20,30)
#单个数据元祖
t2=(10,)

注意：如果定义的元祖只有一个数据，那么这个数据后面最好添加逗号，如果不加就是小括号里的数据类型。比如t2=（10）。这里就是Int型。t2=(‘aaa’)。这里不加逗号就是Str类型。所以元祖单个数据要加逗号。
元祖的常见操作：
元祖不可以修改，只支持查找，具体如下。

1.tuple1=('aa','bb','cc')
print(tuple1[0])

 2.index();查找某个数据，如果存在返回下标值，如果不在则报错，和字符串index一样
 print(puple1.index('aa')) 

3.count():统计某个数据在当前元祖出现的次数
print(touple.count('bb'))

4.len()
print(len(touple))

元祖虽然没法修改但是如果里面包含列表的话就可以修改比如：
t2=（‘aa’,‘bb’,[‘cc’,‘dd’]）
print(t2[2][0])#拿到cc这个数据
进行修改：
t2[2][0]=‘TOM’
print(t2)就将cc的值改成TOM了。

九.字典

字典的应用场景
数据顺序发生变化,每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一标准查找数据呢？
答：字典，字典里面的数据以键值对的形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
字典特点：
符号为大括号
数据以键值对形式出现
各个键值对之间用逗号隔开
有数据字典：
dict1={‘name’:‘Tom’,'age’:‘20’,‘gender’:‘男’}
空字典
dict2={}
dict3=dict()
字典操作新增：
如果不存在则新增，如果存在则可以修改键值对。
dict1[‘id’]=110#这个是不存在的直接加了键值对
dict1[‘name’]=‘rose’#这个是存在的直接将name对应的Tom值修改成rose。
删除数据：
1.del删除字典或者指定的键值对
del(dict1)
print(dict1)
del dict1[‘name’]
2.clear()
dict1.clear()
查找操作：
1.key值查找
dict1={‘name’:‘Tom’,'age’:‘20’,‘gender’:‘男’}
print(dict1[‘name’])
如果当前查找的key存在，则返回对应的值，否则则报错。
1.1.get()
语法
字典序列.get(key,默认值）
注意：如果当前查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None.
dict1.get(‘name’)#返回name对应的值
1.2keys()查找字典中所有的key,返回可迭代的对象
dict1.keys()
1.3values()查找字典中的所有的value,返回可迭代的对象
dict1.values()
1.4items()查找字典中所有键值对返回可迭代对象，里面的数据是元祖的key。元祖数据2是字典key对应的值
dict1.items()
字典的循环遍历：

dict1={'name':'Tom','age’:'20','gender':'男'}
for key,value in dict1.items():
	print(key)
	print(value)
	#或者直接这样写
	print(f'{key}={value}')

十.集合

集合具有去重功能，集合里面的数据不能重复
创建集合使用{}或者set(),但是如果创建空集合只能使用set(),因为{}用来创建空字典。
1.创建有数据的集合
s1={10,20,30}
print(s1)
2.创建空集合:
s2=set()
2.1.增加数据
add()#追加单一数据不能追加一段数据序列
s1=(10,20)
add()
s1.add(100)
输出为（100,10,20）#注意add是插入任意位置
update()增加的数据是序列
s1.update(10,20,30,40,50)
2.2删除数据
remove()删除集合中的指定数据，如果数据不存在则报错。
discard()删除集合中的指定数据，如果数据不存在也不会报错。
pop()
2.3查找数据
in:判断数据在集合序列
not in :判断数据不在集合序列
**

十一.公共操作

**
一.运算符

| 运算符|描述|支持的容器类型
（＋，合并） （ 字符串，列表，元祖）例：(str1+str2),(list1+list2)
（* ，复制 ）（ 字符串，列表，元祖）例：(‘a’*5)
（in ， 元素是否存在 ）（字符串，列表，元祖，字典）例：10 in list1
（not in ， 元素是否不存在 ）（字符串，列表，元祖，字典）例:100 not in list1
补充公共方法还有：
1.len()
2.del或del()
3.max()
4.min()
5.range(start,end,step)生成从start到end的数字(这里前闭后开，后边不包括），步长为step,供for循环使用

例：for i in range(1,10,1):
print(i)
输出结果为：1 2 3 4 5 6 7 8 9
######
例：for i in range(1,10,2):
print(i)
输出结果为：1 3 5 7 9

十二.容器类型转换

1.tuple()#将某个序列转换成元祖
tuple(list1)
2.list()
3.set()

十三.列表推导式

1,list1=[i for i in range(10)]
print(list1)
输出结果：[0,1,2,3,4,5, 6,7,8, 9]
2.list2=[i for i in range(10) if i%2==0]##懒人必备
输出结果：[0,2,4,6,8]
3.多个for循环实现列表推导式##懒人必备
需求：创建列表如下：
[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]
列表推导式代码如下：

list1=[(i,j) for i in range (1,3) for j in range(3)]
print(list1)

正常写的代码如下：

list1 = []
for i in range(1,3):
	for j in range (3):
	list1.append((i,j))
print(list1)      

总结一下：前面写格式，后面写数据如何生成。
推导式的作用：简化代码
推导式写法
#列表推导式
[xx for xx in range()]
#字典推导式
[xx1:xx2 for …in …)
#集合推导式
{xx for xx in …}

十四.函数

1.定义函数

def 函数名（参数）：#只要遇到冒号就要回车换行且缩进去写
      代码1
      代码2
      ........

2.调用函数
函数名（参数）
注意：
(1).不同的需求，参数可有可无
(2).在python中，函数必须先定义后使用
3.return作用：
(1).负责函数返回值
(2).退出当前函数 导致return下方的所有代码（函数体内部）不执行
(3)return a,b写法，返回多个数据的时候，默认是元组类型。
.
.
.
.
.
中间略过一些函数基本知识与操作
.
.
.
拆包：
1.元组拆包

  def return_num():
         return 100,200
    num1,num2=return_num()
    print(num1)#100
    print(num2)#200

2.字典拆包

dict1={'name':'TOM','age':18}
a,b = dict1
#对字典进行拆包，取出来的是字典的key
print(a) # name
print(b) # age
print(dict1[a]) # TOM
print(dict1[b]) #18

十五.学员管理系统

#等待存储所有学员的信息
info=[]
#定义功能界面函数
def info_print():
        print('请选择功能:')
        print('1 添加学员')
        print('2 删除学员')
        print('3 修改学员')
        print('4 查询学员')
        print('5 显示所有学员')
        print('6 退出系统')
        print('-'*20)
#定义添加函数
def add_info():
    #1.用户输入姓名学号手机号
    new_id=input('亲输入学号：')
    new_name=input('亲输入姓名：')
    new_tel=input('亲输入手机号：')
    #2.判断是否添加这个学员，如果学员姓名已经存在报错提示：如果姓名不存在添加数据。
    global info
    #2.1不允许姓名重复：判断学员姓名已经存在报错提示：如果姓名不存在添加数据
    for i in info: #这里的i为列表中的字典元素
        if new_name==i['name']:#判断输入的姓名和字典中的姓名是否重复
            print('此用户已经存在！！！')
            return#这个很重要，return的作用：退出当前函数，后面添加信息的代码不执行。
            
    #2.2如果输入的姓名不存在，添加数据：准备空字典，字典新增数据，列表添加字典
    info_dict={}
    #字典新增数据
    info_dict['id'] = new_id
    info_dict['name']=new_name
    info_dict['tel']=new_tel
    info.append(info_dict)
    print(info)
#删除学员
def del_info():
    #1.用户输入要删除的学员姓名
    del_name=input('请输入要删除的学员姓名')
    #2.判断学员是否存在：存在则删除：不存在提示。
    #2.1声明info是全局变量
    global info
    #2.2遍历列表
    for i in info:  
        if del_name==i['name']:
            info.remove(i)
            print(f'{del_name}学员已删除')
            break
    else:
        print('该学员不存在') 
    print(info)
    
    #2.3判断学员是否存在：存在执行删除（列表里面的字典).break:这个系统不允许重名，删除一个后面不需要遍历，不存在提示学员不存在。
#修改学员函数
def  modify_info():
    #1.用户输入想要修改学员的姓名
    modify_name=input('请输入要修改的学员姓名:')
    #2.判断学员是否存在
    #2.1声明info是全局变量
    global info
    #2.2遍历列表，判断输入的姓名==字典['name']
    for i in info:
        if modify_name==i['name']:
            #将tel这个key修改值，并终止此循环
            i['tel']=input('请输入新的手机号:')
            break
    else:
         print('该学员不存在')
    #3.打印info
    print(info)
#查找学员信息
def search_info():
    #1.用户输入目标学员姓名
    search_name=input('请输入要查询的学员的姓名：')
    #2.检查学员是否存在：存在打印这个学员的信息：不存在则提示
    #2.1 声明info为全局
    global info
    #2.2 遍历info,判断输入的学员是否存在
    for i in info:
        if search_name==i['name']:
           print('该学员信息如下：---------------------') 
           print(f"该学员的学号是{i['id']},姓名是{i['name']},手机号是{i['tel']}")
           break
    else:
       print('查无此人')
#显示全部成员信息
def print_all():
    print('学号\t姓名\t手机号')
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")
while True:
    
 info_print()#1.显示功能界面

 f=int(input('亲输入序号：'))#2.用户输入功能序号
    
    #3.按照用户输入的功能序号，执行不同的功能（函数）
 if f==1:
        add_info()
 elif f==2:
        del_info()
 elif f==3:
        modify_info()
 elif f==4:
        search_info()
 elif f==5:
        print_all()
 elif f==6:
        exit=int(input('确定退出？确定退出按1，取消按2  '))
        if exit==1:
               break
        else:
               print('已取消')
 else:
        print('您输入的功能有误')

十六.一些概念

1.面向对象
总结：面向对象就是将编程当成一个事物，对外界来说，事物是直接使用的，不用管内部的情况，而编程就是设置事物能够做什么事。
2.类和对象
类相当于制造一件东西的图纸，对象相当于造出来的东西。
类：
类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。
特征即是属性
行为即是方法
类比如是制造洗衣机要用到的图纸，也就是说类是用来创建对象。
注意：开发中先有类后有对象,类名要满足大驼峰命名规则。
例：
(1)定义洗衣机类

class Washer():
	def wash():
	  print('能洗衣服')

（2）创建对象
#对象名=类名()

haier = Washer()

(3）验证成果
#打印haier对象
print(haier)
#使用wash功能----实例方法、对象方法-----对象名.Wash()

haier.wash()

.
.
.
.
省略一堆面向对象的知识，感觉都是java里的，不想听了。