python学习笔记(1)

一、python之循环

while循环

while循环的语法

 while 条件：
	条件成立重复执行的代码

例子1：复打印5次：i am error

i=0
while i<5:
    print("i am error")
    i+=1

例子2：计算1-100累加和

i=1
result=0
while i<=100:
    result+=i
    i+=1
print("结果为:{}".format(result))

例子3：计算1-100之间的偶数累加和

i=1
result=0
while i<=100:
    if i%2==0:
        result+=i
    i+=1
print(result)

break和contiune的区别

break和contiune：是循环中满足一定条件退出循环的两种不同模式

break:一共有5个苹果，如果第三个吃饱了，就不需要吃剩下的苹果，吃苹果的动作停止，这就是break:终止此循环；

continue:如果吃的过程中，吃到第三个吃出了虫子，这个苹果就不吃了，开始吃第4个苹果，这就是continue,即退出当前循环继而执行下一次循环代码。

break的例子

i=1
while i<=5:
    if i==4:
        print("吃饱了,不吃了")
        break
    print("吃了{}个苹果".format(i))
    i+=1

continue的例子
注意：如果使用continue,一定要在continue之前加上计数器，否则会进入死循环

i=1
while i<=5:
    if i==3:
        print("有大虫子")
        i+=1
        continue
    print("吃了{}个苹果".format(i))
    i+=1

while循环嵌套的例子：

1、循环打印3遍i am wrong;clear the window;2、1是一套惩罚，这一套惩罚要执行3天

j=0
while j<3:
    i=0
    while i<3:
        print("i am wrong")
        i+=1
    print("clear the window")
    print("---------------一套惩罚结束-----------------")
    j+=1

while循环嵌套应用

1.需求：想要实现如图的效果

代码实现：

j=1
while j<=5:
    #一行*开始
    i=1
    while i<=5:
        print("*",end="")
        i+=1
    #一行*结束，该换行执行下一行了，利用print默认结束符换行
    print()
    j+=1

2.需求：打印9*9乘法表

j=1
while j<=9:
    i=1
    while i<=j:
        print(f'{i}*{j}={i*j}',end="\t") #\t就是为了乘法表对齐用的
        i+=1
    print()
    j+=1

循环的else简介

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码；如果是break终止循环的情况,else下方缩进的代码将不执行

while 条件:
	条件成立执行的代码
else:
	循环正常结束之后要执行的代码

例子1：

i=1
while i<=5:
    print("i am wrong")
    i+=1
else:
    print("原谅你了")

例子2:带break的例子

i=1
while i<=5:
    if i==3:
        print("你说的不真诚")
        break
    print("i am wrong")
    i+=1
else:
    print("原谅你了")

效果如下：

例子3：带continue的例子

i=1
while i<=5:
    if i==3:
        print("你说的不真诚")
        i+=1
        continue
    print("i am wrong")
    i+=1
else:
    print("原谅你了")

效果如下：

for循环

for循环的语法：

for 临时变量  in 序列：
	重复执行的代码

搭配continue的例子：

str="nihao"
for i in str:
    if i=="h":
        print("h不打印")
        continue
    print(i)
else:
    print("print is over")

效果如下：

循环的总结

1.break是退出整个循环；continue是退出本次循环，继续执行下一次重复执行的代码
2.else:
while和for都可以搭配使用else
else下方缩进的代码含义：当循环正常结束后执行的代码
break终止循环，不会执行else下方缩进的代码
continue退出循环，执行下方缩进的代码

二、python之字符串

切片

切片语法：

序列[开始位置下标:结束位置下标:步长]
左包右不包，默认步长为1

print(str[::-1])  表示倒序
print(str[-4:-1:-1]) 执行为空
-4开始到-1结束，选取方向是从左向右；但是-1步长，是从右向左
选取方向如果和步长的方向冲突，则无法选取数据
print(str[-1:-4:-1])这样选取方向就一致了

常用操作方法

1、查找

所谓字符串查找方法：查找子串在字符串中的位置或出现的次数
find():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1
index():效果和find一样，不存在就会执行报错
rfind()和rindex():是从右向左查找
语法：

字符串序列.find(子串，开始位置下标，结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找

举例如下：

a="ni hao and python"
print(a.find("ni",6,10))

结果为-1

2、修改

1、所谓修改字符串，指的就是通过函数的形式修改字符串中的数据
replace():替换

语法：

字符串序列.replace(旧子串，新子串，替换次数)
注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数

例子如下：

a="ni hao and ni python"
print(a.replace("ni","you"))

效果如下：

2、split():按照指定字符分割字符串，会返回一个列表，丢失分割字符

语法：

字符串序列.split(分割字符，num)
num表示的是分割字符出现的次数

例子如下：

a="ni hao and ni python and ni it"
print(a.split("and",1))

效果如下：

3、join():用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串，合并列表里面的字符串数据为一个大字符串

语法：

字符或子串.join(多字符串组成的序列)

例子如下：

list=["a","b","c"]
new_str='...'.join(list)
print(new_str)

效果如下：

4、strip():删除字符串两侧空白字符，还有lstrip()和rstrip()
ljust():左对齐，just():右对齐,center():居中

对齐的例子：

5、startswith(),endswith():判断字符串的开头或结尾是否正确，返回值为true或false

str="hello li yu"
print(str.startswith("he"))

返回值为True

6、isalpha():字符串都是有字母组成，则返回True,否则返回False
isdigit():如果字符串值包含数字则返回True,否则返回False
isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,反之为False
isspace():如果字符串中只包含空格，则返回True,反之为False

例子如下：

str="hello li yu"
print(str.isalpha())

结果为False,因为有空格

str="1234"
print(str.isdigit())

结果为True
例子如下：

str="1234tui"
print(str.isalnum())

结果为True

str="  is "
print(str.isspace())

结果为False

三、python之列表

1、列表的格式
【数据1,数据2，数据3，数据4】
列表可以一次性存储多个数据，且可以为不同数据类型
列表的常用操作：增删改查
1.查找
使用函数查找之index():查找数据的下标

name_list=["lili","rose","tom"]
print(name_list.index("lili"))

count():统计指定数据在列表中出现的次数

name_list=["lili","tom","rose"]
print(name_list.count("lili"))

len():计算列表中数据的个数，即长度

name_list=["lili","tom","rose"]
print(len(name_list))

2、判断是否存在

in:指定的数据在列表之中，在就返回True,不在就返回False
not in:不在就返回True,在就返回False

name_list=["lili","tom","rose"]
print("tom"in name_list)

体验案例：

需求：查找用户输入的名字是否已经存在

代码如下：

name_list=["lili","tom","rose"]
name=input("请输入您要搜索的名字：")
if name in name_list:
    print(f"您输入的名字是{name},此用户已存在")
else:
    print(f"您输入的名字{name}不存在，可以注册")

3、增加数据

增加指定数据到列表中

1、append():列表结尾增加数据

用法：列表序列.append(数据)

例子如下：

name_list=["lili","tom","rose"]
name_list.append("yuyu")
print(name_list)

结果为：[‘lili’, ‘tom’, ‘rose’, ‘yuyu’]

name_list=["lili","tom","rose"]
name_list.append(["yuyu","jack"])
print(name_list)

结果为：[‘lili’, ‘tom’, ‘rose’, [‘yuyu’, ‘jack’]]
由此可见：列表是可变类型
2、extend():在列表结尾追加数据，与append不同的是，增加序列时，append是整体追加，而extend是将序列的数据拆开再逐一添加到列表中

name_list=["lili","tom","rose"]
name_list.extend("xiaoli")
print(name_list)

结果为：[‘lili’, ‘tom’, ‘rose’, ‘x’, ‘i’, ‘a’, ‘o’, ‘l’, ‘i’]
追加列表的例子如下：

name_list=["lili","tom","rose"]
name_list.extend(["xiaoli","xiaohong"])
print(name_list)

结果为：[‘lili’, ‘tom’, ‘rose’, ‘xiaoli’, ‘xiaohong’]
3、insert():指定位置新增数据

语法：列表序列.insert(位置下标，数据)

name_list=["lili","tom","rose"]
name_list.insert(1,"yuyu")
print(name_list)

结果为:[‘lili’, ‘yuyu’, ‘tom’, ‘rose’]
4、删除
1、del：删除整个列表或者指定的数据

语法：del 目标

删除列表

name_list=["lili","tom","rose"]
del name_list
print(name_list)

结果为：

删除指定数据

name_list=["lili","tom","rose"]
del name_list[0]
print(name_list)

结果为：[‘tom’, ‘rose’]
2、pop():删除指定下标的数据，如果不指定下标，会默认删除最后一个数据；无论是按照下标还是删除最后一个数据，pop都会返回这个被删除的数据

name_list=["lili","tom","rose"]
del_name=name_list.pop()
print(del_name)
print(name_list)

结果为：
rose
[‘lili’, ‘tom’]
3、remove():删除指定数据

name_list=["lili","tom","rose"]
del_name=name_list.remove("lili")
print(name_list)

结果为：[‘tom’, ‘rose’]
4、clear():清空列表的数据

name_list=["lili","tom","rose"]
name_list.clear()
print(name_list)

结果为:[]
5、修改
修改指定下标数据

list=[1,2,3]
list[0]="5"
print(list)

结果为：[5, 2, 3]
逆置：reverse()

list=[1,2,3]
list.reverse()
print(list)

结果为：[3, 2, 1]
排序sort:列表序列.sort(key=None,reverse=False)

list=[1,3,2,5,4,6]
list.sort()
print(list)

结果为：[1, 2, 3, 4, 5, 6]，可见默认排序是升序，reverse=False
降序的例子：

list=[1,3,2,5,4,6]
list.sort(reverse=True)
print(list)

结果为：[6, 5, 4, 3, 2, 1]
6、复制
如果我们要对现有数据做修改，删除，就会复制保存一份旧数据，以免出错，这时候就会用到copy()。

name_list1=["tom","lili","rose"]
name_list2=name_list1.copy()
print(name_list1)
print(name_list2)

结果为：
[‘tom’, ‘lili’, ‘rose’]
[‘tom’, ‘lili’, ‘rose’]
6、列表的循环遍历
while循环：
需求：依次打印列表中的各个数据

name_list=["tom","lili","rose"]
i=0
while i<len(name_list):
    print(name_list[i])
    i+=1

结果为：
for循环：

name_list=["tom","lili","rose"]
for i in name_list:
    print(i)

7、列表的嵌套
所谓的列表嵌套就是一个列表里面包含了其他的子列表
应用场景：要存储一二三年级的学生姓名，且每个班级的学生名在一个列表里
如何查找到数据:tom?

name_list=[["tom","lili","rose"],["张三","李四","王五"],["小红","小明","小绿"]]
print(name_list[0][0])

8、综合应用
将8个老师随机分配到3个办公室里

结题步骤：
1、准备数据：老师，办公室，用列表
2、分配老师到教室：random模块，办公室列表追加老师名字
3、验证是否分配成功

代码如下：

import random
teachers=["a","b","c","d","e","f","g","h"]
offices=[[],[],[]]
#分配老师到办公室，取到每个老师到办公室列表，遍历老师列表数据
for name in teachers:
    #不能指定某个具体下标，所以在1-3中随机下标
    num=random.randint(0,2)
    #列表追加数据，append(选中),insert,extend
    offices[num].append(name)
#print(offices)
#为了更加贴合生活，把各个办公室的列表都加上编号，1,2,3
i=1
#验证是否分配成功
for office in offices:
    #打印办公室的人数,len()
    print(f"办公室{i}的人数为{len(office)},老师分别为:")
    #打印老师的名字，每个子列表的名字个数不一定，所以遍历子列表
    for name in office:
        print(name)
    i+=1

效果如下：

办公室1的人数为1,老师分别为:
h
办公室2的人数为3,老师分别为:
b
c
e
办公室3的人数为4,老师分别为:
a
d
f
g

四、python之元组

1、元组的应用场景：
如果想要存储多个数据，但是这些数据是不能修改的数据，就用到元组了。列表数据可以修改
2、元组的定义

定义多个数据
t1=(10,20,30)
print(type(t1)) #<class 'tuple'>

定义单个数据的元组，一定要加逗号
t2=(45,)
print(type(t2))  #<class 'tuple'>
t2=(45)
print(type(t2))  #<class 'int'>
t4=("aaa")
print(type(t4))  #<class 'str'>

3、元组的常见操作
1、查找
元组数据不支持修改，只支持查找，具体如下：
按下标查找数据

t1=("a","b","c")
print(t1[0])

index():查找某个数据，在就返回对应下标，不在就报错

t1=("a","b","c")
print(t1.index("b"))

count():统计某个数据在当前元组出现的次数

t1=("a","b","c","c")
print(t1.count("c"))

len():统计元组中数据的个数

t1=("a","b","c","c")
print(len(t1))

2、修改
元组内的直接数据如果修改立即报错

t2=("a","b",["cc","dd"])
t2[0]="d"

结果如下：

元组里面如果嵌套了列表，就可以修改

t2=("a","b",["cc","dd"])
t2[2][0]="bb"
print(t2)

结果为：(‘a’, ‘b’, [‘bb’, ‘dd’])

五、python之字典

1、字典的应用场景
如果有多个数据，例如：“tom”,“男”,20,如何快速存储
2、创建字典的语法

字典的特点：

1. 符号为大括号
   2.数据为键值对形式出现
   3.各个键值对之间用逗号隔开

3、字典的常见操作
1、增

写法：字典序列【key】=值
注意：如果key值存在，则修改这个key的值；如果key不存在，就新增此键值对

dict1={"name":"tom","age":19,"sex":"男"}
dict1["name"]="rose"
print(dict1)
结果为：{'name': 'rose', 'age': 19, 'sex': '男'}

dict1={"name":"tom","age":19,"sex":"男"}
dict1["id"]=110
print(dict1)
结果为：{'name': 'tom', 'age': 19, 'sex': '男', 'id': 110}

2、删
删除指定键值对

dict1={"name":"tom","age":19,"sex":"男"}
del dict1["name"]
print(dict1)
结果为：{'age': 19, 'sex': '男'}

删除字典

dict1={"name":"tom","age":19,"sex":"男"}
del dict1
print(dict1)
结果为：NameError: name 'dict1' is not defined

清空字典

dict1={"name":"tom","age":19,"sex":"男"}
dict1.clear()
print(dict1)
结果为：{}

3、改
和1里面的新增一样的，key存在就是修改key值，key不存在就变成了新增

dict1={"name":"tom","age":19,"sex":"男"}
dict1["name"]="rose"
print(dict1)
结果为：{'name': 'rose', 'age': 19, 'sex': '男'}

4、找
1、key值查找

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1["name"])  #查找的key值不存在就会报错

2、使用函数查找：
1、get()

语法：字典序列.get(key,默认值)
如果当前查找的key不存在就会返回第二个参数（默认值），如果省略第二个参数，则返回None

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.get("name"))
结果为：tom

如果key值不存在

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.get("id"))
结果为：None
设置参数的例子如下：
dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.get("id",110))
结果为：110

2、keys()

打印字典中所有的key

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.keys())
结果为：dict_keys(['name', 'age', 'sex'])

3、values()

打印字典中所有的值

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.values())
结果为：dict_values(['tom', 19, '男'])

4、items()

查找字典中所有的键值对，里面的数据是元组

dict1={"name":"tom","age":19,"sex":"男"}
print(dict1.items())
结果为：dict_items([('name', 'tom'), ('age', 19), ('sex', '男')])

六、字典的循环遍历

1、遍历字典的key(用到我们上面说的keys())

dict1={"name":"tom","age":19,"sex":"男"}
for key in dict1.keys():
    print(key)
结果为：
name
age
sex

2、遍历字典中的value（用到上面说的values()）

dict1={"name":"tom","age":19,"sex":"男"}
for value in dict1.values():
    print(value)
结果为：
tom
19
男

3、遍历字典的元素(items())

dict1={"name":"tom","age":19,"sex":"男"}
for item in dict1.items():
    print(item)
结果为：
('name', 'tom')
('age', 19)
('sex', '男')

4、字典的循环遍历之键值对拆包

dict1={"name":"tom","age":19,"sex":"男"}
for key,value in dict1.items():
    print(f"{key}:{value}")
结果为：
name:tom
age:19
sex:男

七、python之集合

1、创建集合

创建集合用{}或者set(),但是如果要创建空集合只能使用set(),因为{}用来创建空字典

s1={10,20,30,40,50,30}
print(s1)
结果为：{40, 10, 50, 20, 30}

由此可见，顺序变化了，不支持下标，而且会去重
创建空集合

s2=set()
print(type(s2))
结果为：<class 'set'>

使用set创建集合

s1=set("abcddeffg")
print(s1)
结果为：{'f', 'a', 'b', 'd', 'c', 'g', 'e'}

2、常见操作之增删改
1、增
add():增加单个数据

s1={10,20}
s1.add(100)
print(s1)

由此可见集合是可变类型
update():增加的数据是序列，增加单个数据会报错

s1={10,20}
s1.update([10,20,30,40])
print(s1)
结果为：{40, 10, 20, 30}

2、删
1、remove():删除集合中的指定数据，如果数据不存在就会报错
删除不存在的数据

s1={10,20,30}
s1.remove(200)
print(s1)

结果为：

2、discard():删除集合中的指定数据，数据不存在不会报错
删除不存在的数据

s1={10,20,30}
s1.discard(200)
print(s1)
结果为：{10, 20, 30}

3、pop():随机删除一个数据，并返回这个数据

s1={2,3,4}
s2=s1.pop()
print(s2)
print(s1)
结果为：
2
{3, 4}

3、查
in():判断数据在集合序列

s1={2,3,4}
print(2 in s1)
结果为：True

not in():判断数据不在集合序列

s1={2,3,4}
print(2 not in s1)
结果为：False

八、公共操作之运算符

运算符	支持的容器类型
+(合并)	字符串，列表，元组
*（复制）	字符串，列表，元组
in	字符串，列表，元组，字典
not in	字符串，列表，元组，字典

+(合并)的例子：

list1=[1,2]
list2=[3,4]
t1=(1,2)
t2=(3,4)
dict1={"name":"python"}
dict2={"age":24}
str1="aa"
str2="bb"
print(str1+str2)
print(list1+list2)
print(t1+t2)
结果为：
aabb
[1, 2, 3, 4]
(1, 2, 3, 4)

*(复制)的例子：

print(str1*10)
print(list1*3)
print(t1*3)
结果为：
aaaaaaaaaaaaaaaaaaaa
[1, 2, 1, 2, 1, 2]
(1, 2, 1, 2, 1, 2)

in和not in的例子

print(2 in t1)
print("python" not in dict1.values())
结果为：
True
False

九、python之公共方法

公共方法就是指学过的数据类型都能使用的公共函数

函数	描述
len()	计算容器中的元素个数
del()或del	删除
max()/min()	返回容器中元素最大/小值
range(start.end,step)	生成从start到end的数字，步长为step,