Python零基础自学2（黑马）

视频链接：https://www.bilibili.com/video/BV1o4411M71o?p=15&share_source=copy_web
课件PDF–链接: https://pan.baidu.com/s/1kYX3FcDasnFMLT8FCuHIGw 提取码: 86hy
以下均为个人笔记

一、循环

循环的分类
在Python中，循环分为 while 和 for 两种，最终实现效果相同。
快速体验

# 循环的计数器
i = 0
while i < 5:
    print('MMT：我怎么这么丑，我错了，你捶我吧')
    i += 1
    print('对方回答：是的')
print('一百遍结束')

1.1while循环嵌套

"""
1.循环打印三次媳妇我错了
2，今天刷晚饭的碗
3，上面是一套惩罚，这一套惩罚要执行三天--一套惩罚要重复执行--放到一个while循环里面
"""
j = 0
while j < 3:
    i = 0
    while i < 3:
        print('媳妇我错了')
        i += 1
    print('今晚的碗我刷')
    j += 1
    print('这一套循环完了')

while循环嵌套应用之打印五角星

"""
1.打印一个星星
2.一行5个，循环--5个星星在一行
3.打印五行星星 ； 循环--一行五个
"""
j = 0
while j < 5:
    i = 0
    while i < 5:
        # 一行星星开始
        print('*', end = '')
        i += 1
    print('')   # 一行星星结束，换行显示下一行
    j += 1

三角形

# 三角形  每行星星的数量与行号数相等
j = 0   # j表示行号
while j < 5:
    i = 0
    # i表示每行里面星星的个数，这个数字要和行号相等，所以i要和j联动
    while i <= j:
        print('*', end ='')
        i += 1
    print()
    j += 1

累加

# 需求：1-100偶数累加和--2+4+6+。。。。。+100 = 结果--输出结果
"""
1.准备累加的数字 开始1 结束100 增量1
2.准备保存结果的变量result
3.循环加法运算--如果是偶数才加法运算--除以2取余数为0
4.输出结果
"""

i = 1
result = 0

while i <= 100 :
    # 条件语句 -- if
    if i % 2 == 0:
       result += i
    i += 1
print(result) 

break

# break:当某些条件成立，退出整个循环
# 循环吃5个苹果，吃完第三个吃饱了，第 4 和第 5 个不吃了（不执行） -- == 4 或 >3
i = 1
while i <= 5:
    if i == 4:
        print('吃饱了，不吃了')
        break
    print(f'吃了第{i}个苹果')
    i += 1

continue

# continue : 当条件成立，退出当前一次循环，继而执行下一次循环
# 吃五个苹果 -- 循环；吃到第3个吃出一个虫子，第三个不吃了，没吃饱，继续吃第四个和第五个苹果 -- 只有第三个不吃

i = 1
while i < 6:
    if i == 3:
        print('吃出一个大虫子，这个苹果不吃了')
        i += 1
        # 在continue之前⼀定要修改计数器，否则会陷⼊死循环
        continue

    print(f'吃了第{i}个苹果')
    i += 1

while九九乘法表

# 多行多个乘法表达式 x * x = x*x

"""
1.打印一个乘法表达式：x * x = x*x
2.一行打印多个表达式--一行表达式的个数和行号都相等--循环， 一个表达式--不换行
3.打印多行表达式 -- 循环 ：一行表达式-- 换行
"""

j = 1
while j <= 9:
    i = 1
    while i <= j:
        print(f'{i} * {j} = {i*j}',end = '\t')
        i += 1
    # 一行表达式结束
    print()
    j += 1

1.2or循环

str1 = 'shbcvjhsgbv'
for i in str1:
    print(i,end='\t')
    #s	h	b	c	v	j	h	s	g	b	v

for循环之break

str1 = 'shbcvejhsgbv'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break
    print(i,end ='\t')
    #s	h	b	c	v	遇到e不打印

for循环之continue

str1 = 'shbcvejhsgbv'
for i in str1:
    if i == 'e':
        print('遇到e不打印',end ='\t')
        continue
    print(i,end ='\t')
#s	h	b	c	v	遇到e不打印	j	h	s	g	b	v	

while…else…

# 需求：道歉5遍媳妇我错了，完成之后执行媳妇媳妇原谅我了
"""
1.书写道歉的循环
2.循环正常结束要执行的代码--else
"""

i = 1
while i <= 3:
    print('媳妇我错了')
    i += 1
else:
    print('媳妇原谅我了')
"""
媳妇我错了
媳妇我错了
媳妇我错了
媳妇原谅我了
"""

whle…else之break

i = 1
while i <= 5:
    if i == 3:
        break
    print('媳妇我错了')
    i += 1
else:         # 非正常结束，else不继续执行
    print('媳妇原谅我了')
"""
媳妇我错了
媳妇我错了
"""

while…else之continue

i = 1
while i <= 5:
    if i == 3:
        i += 1
        continue   # 只是不执行i==3这一次 跳过了第三次
    print('媳妇我错了')
    i += 1
else:
    print('媳妇原谅我了')
"""
媳妇我错了
媳妇我错了
媳妇我错了
媳妇我错了
媳妇原谅我了
"""

for…else之break和continue

# break 的使用
str1 = 'itheima'
for i in str1:
    if i == "e":
        break
        continue
    print(i,end='\t')
else:
    print('else正常循环完毕')
print()

# continue 的使用
str1 = 'itheima'
for i in str1:
    if i == "e":
        continue
    print(i,end='\t')
else:
    print('else正常循环完毕')
#i	t	h	
#i	t	h	i	m	a	else正常循环完毕

二、字符串

a ='hello' \
   'world'
print(a)
print(type(a))

b="TOM"
print(b)

#三引号
e='''i am tom'''
print(e)
print(type(e))

f="""i 
am TOM"""
print(f)
print(type(f))

#I'm Tom 只能使用双引号  或者加入\转义符号
g=' I\'m Yom'

2.1切片

语法：序列[开始位置下标:结束位置下标:步⻓] 1
注意

1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步⻓是选取间隔，正负整数均可，默认步⻓为1。

name = '012345678'

print(name[2:5:1]) #234
print(name[2:5:2]) #24
print(name[2:5]) #234
print(name[:5])  #01234 -- 如果不写开始，默认从0开始选取
print(name[2:])    #2345678 -- 如果不写结束，表示选取到最后
print(name[:])     #012345678 --
print(name[:-1]) #01234567
print(name[::-1])#876543210 -- 步长为负数，倒序
print(name[4:1:1])  #空
print(name[-4:-1])  #567 -- 下标-1表示最后一个数据，
#print(name[-4:-1：-1]) #
print(name[-1:-4:-1])  #876  不能选出数据：从-4开始到-1结束，选取方向从左到右，但是-1步长；从右向左选取
# *** 如果选取方向（下标开始到结束的方向） 和 步长的方向冲突，则无法选取数据
# 全错
"""
print(name[1:4::-1])
print(name[-4:-1::-1])
print(name[4:1::1])
print(name[-1:-4::1])
"""

2.2常⽤操作⽅法

字符串的常⽤操作⽅法有查找、修改和判断三⼤类。

2.2.1查找

所谓字符串查找⽅法即是查找⼦串在字符串中的位置或出现的次数。

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

• index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
  语法：字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
  注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

• rfind()： 和find()功能相同，但查找⽅向为右侧开始。

• rindex()：和index()功能相同，但查找⽅向为右侧开始。

• count()：返回某个⼦串在字符串中出现的次数
  语法：字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
  注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and'))         # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands'))        # -1
print(mystr.rfind('and'))        # 35

mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and'))         # 12
print(mystr.index('and', 15, 30)) # 23
#print(mystr.index('ands'))  找不到会报错
print(mystr.rindex('and'))        # 35 

mystr = "hello world and itcast and itheima and Python"
print(mystr.count('and'))        # 3
print(mystr.count('ands'))       # 0
print(mystr.count('and', 0, 20)) # 1

2.2.2修改

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据

• replace()：替换
  语法：字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
  注意：替换次数如果查出⼦串出现次数，则替换次数为该⼦串出现次数
  注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

mystr = "hello world and itcast and itheima and Python"

print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 1))
# 结果：hello world he itcast and itheima and Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world he itcast he itheima he Python

new_mystr = mystr.replace('and', 'he')
print(new_mystr)
# 结果：hello world he itcast he itheima he Python

• split()：按照指定字符分割字符串
  语法：字符串序列.split(分割字符, num)
  注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
  注意：如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。

mystr = "hello world and itcast and itheima and Python"

print(mystr.split('and'))#-- 分割，返回一个列表，丢失分割字符
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and', 2))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' ', 2))
# 结果：['hello', 'world', 'and itcast and itheima and Python']

• join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
  语法：字符或⼦串.join(多字符串组成的序列)

list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))

• capitalize()：将字符串第⼀个字符转换成⼤写

mystr = "hello world and itcast and itheima and Python"
# 结果：Hello world and itcast and itheima and python
print(mystr.capitalize())

注意：capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。

• title()：将字符串每个单词⾸字⺟转换成⼤写

mystr = "hello world and itcast and itheima and Python"
# 结果：Hello World And Itcast And Itheima And Python
print(mystr.title())

• lower()：将字符串中⼤写转⼩写。

mystr = "hello world and itcast and itheima and Python"
# 结果：hello world and itcast and itheima and python
print(mystr.lower())

• upper()：将字符串中⼩写转⼤写。

mystr = "hello world and itcast and itheima and Python"
# 结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())

• ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。
  语法：字符串序列.ljust(⻓度, 填充字符)
  
• rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。
• center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。
  

2.2.3判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。

• startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
  语法：字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)

mystr = "hello world and itcast and itheima and Python "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))

• endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
  语法：字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)

mystr = "hello world and itcast and itheima and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))

• isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。

mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果：True
print(mystr1.isalpha())
# 结果：False
print(mystr2.isalpha())

• isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())

• isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。

mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())

• isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。

mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())

三、列表 – list

3.1格式

[数据1, 数据2, 数据3, 数据4…]
列表可以⼀次性存储多个数据，且可以为不同数据类型。

3.2列表的常⽤操作

列表的作⽤是⼀次性存储多个数据，程序员可以对这些数据进⾏的操作有：增、删、改、查

3.2.1查找

• 下标
• 函数 （index、count、len）

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1

name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3

• 判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)

案例体验

name_list = ['TOM','Lily','ROSE']

# 需求：注册邮箱，用户输入一个账号名，判断这个账号是否已经存在，如果存在，提示用户，否则提示可以注册
"""
1.用户输入账号
2.判断if...else
"""

name = input('请输入您的邮箱账号名：')

if name in name_list:
    print(f'您输入的账号名是{name},此用户名已存在')
else:
    print('您输入的账号名{name},可以注册')

3.2.2增加

作⽤：增加指定数据到列表中

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

name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)

#如果append()追加的数据是⼀个序列，则追加整个序列到列表
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据。

• extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
  语法：列表序列.extend(数据)

name_list = ['Tom', 'Lily', 'Rose']
#单个数据
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)

#序列数据
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)

• insert()：指定位置新增数据。
  语法：列表序列.insert(位置下标, 数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)

3.2.3删除

• del
  语法：del ⽬标
  删除列表

name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)

删除数据

name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose']
print(name_list)

• pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据
  语法：列表序列.pop(下标)

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)

• remove()：移除列表中某个数据的第⼀个匹配项
  语法：列表序列.remove(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)

• clear()：清空列表

name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []

3.2.4修改

• 修改指定下标数据

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)

• 逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

• 排序：sort()
  语法:列表序列.sort( key=None, reverse=False)

num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

3.2.5复制

函数：copy()

name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)

3.3 列表的循环遍历

需求：依次打印列表中的各个数据。

3.3.1while

name_list = ['Tom', 'Lily', 'Rose'] i = 0
while i < len(name_list):
 print(name_list[i])
 i += 1

3.3.2for

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
 print(i)

3.4 列表嵌套

name_list = [['TOM','Lily','ROSE'],
    ['wangxiaoming','zzhouhaojie','wangqianhua'],['shihan','wtyi','sjkhfuish']]
print(name_list[0][2])

3.5 综合应⽤ – 随机分配办公室

需求：有三个办公室，8位⽼师，8位⽼师随机分配到3个办公室

"""
步骤：
1.准备数据
  1.1 8位老师--列表
  1.2 3个办公室--列表嵌套
2.分配老师到办公室
     ***随机分配
    就是把老师的名字写入到办公室列表--办公室列表追加老师名字数据

3.验证是否分配成功
    打印办公室详细信息：每个办公室的人数和对应的老师名字
"""
import random
# 1.准备数据
teachers = ['A','B','C','D','E','F','G','H']
offices =[[],[],[]]

# 2.分配老师到办公室--取每个老师放到办公室列表--遍历老师列表数据
for name in teachers:
    # 列表追加数据--append(选中)extend insort
    # xx[0]--不能指定是具体某个下标--随机
    num = random.randint(0,2)
    offices[num].append(name)
print(num)
print(offices)

# 为了更贴合生活，把各个办公室子列表加一个序号1,2,3
i = 1
# 验证是否分配成功
for office in offices:
    # 打印办公室人数--子列表数据的个数 len()
    print(f'{i}号办公室的人数是{len(office)},老师分别是:')
    i+=1
    # 打印老师的名字
    # print() -- 每个子列表里面的名字个数不一定-- 遍历--子列表
    for name in office :
        print(name)