python三万字长文，绝对细致，麻烦观众老爷三连，我实在肝不动了，整个人都麻了python基础总结，从基础到函数，看完python你就懂了一半了，关键是就是，就算你还没有学过python也能看懂

欢迎各位观众老爷的到来，有不懂的地方欢迎评论区交流，废话不多说，上干货！！！！！！

---

一、认识python

1、python

1.1名称

python这个名称因为创始人(龟叔)追剧(英国喜剧团体Moty python)，并且是Moty python的狂热粉丝，然后就用了偶像团的名G字python。

1.2创始人

荷兰人，吉多·范罗苏姆(Guido van Rossum)中的Guido（吉多），拼音（哥威龟）Gui 龟，被中国程序员戏称为“龟叔”。

1.3解释器

Python的解释器如今有多个语言实现，我们常用的是CPython(官方版本的C语言实现)，其他还有Jython(可以运行在Java平台)、IronPython(可以运行在.NET和Mono平台)、PyPy(Python实现的，支持JIT即时编译）dPython目前有两个版本，Python2和Python3，最新版分别为2.7.12和3.5.2，现阶段大部分公司用的是Python2，2020年，Python2将停止更新。

1.4版本

A.Python:python经过长时间的优化、更新、演变，等,至如今已经有很多版本了。
例如:
python 3.6.6
python 3.7.0
python 3.8.2
python 3.9.0
python 3.9.5
…
支持正版（重要的事情说三遍）
此链接为python下载官网->https://www.python.org/downloads/点此跳转
此链接为python下载官网->https://www.python.org/downloads/点此跳转
此链接为python下载官网->https://www.python.org/downloads/点此跳转

2、PyCharm

2.1简介

PyCharm是一种Python IDE（Integrated Development Environment，集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。文本来源
Python的解释器如今有多个语言实现，例如常用的CPython(官方版本的C语言实现)，其他还有Jython(可以运行在Java平台)、IronPython(可以运行在.NET和Mono平台)、PyPy(Python实现的，支持JIT即时编译）

2.2下载地址

支持正版（重要的事情说三遍）
此链接为PyCharm下载官网->https://www.jetbrains.com/pycharm点此跳转/
此链接为PyCharm下载官网->https://www.jetbrains.com/pycharm/点此跳转
此链接为PyCharm下载官网->https://www.jetbrains.com/pycharm/点此跳转

此后所有编译软件版本
解释器 python-3.7.7-amd64
编辑器 PyCharm 2020.1 (Professional Edition)

二、python基础

2.1、注释

注释->作用：通过自己熟悉的语言在程序中对代码进行标注说明！

单行注释：#+注释内容 （快捷键Ctrl+/）
多行注释：""“注释代码”"" ‘’‘注释代码’’’ 要注释的代码应放在三对双引号或者是单引号之内

# #号注释，可注释在代码上面也可以注释在一句代码后面
print("hello world!!!")  # 打印输出 你好世界！！！并且换行
结果；
hello world!!!

2.2、bug

bug:编写程序时出现的错误叫bug
出现bug->后果->导致程序运行结果错误或无法运行
解决方法:纠正错误->打断点->Debug调试（多用于循环）

2.3、变量

变量->作用:存储数据(输入理解：存储一个数据时，当前数据所在的内存地址的名称)

2.4、变量名规范

   A、由字母、数字、下划线组成
   B、不能数字开头 ，可以用下划线开头
   C、不能使用内置关键字，解决方法->可以在关键字后面加数字或者是下划线。
   D、严格区分大小写

2.4、变量名命名习惯

	      A、见名知义，易懂，最好一眼可以认出变量意思或作用
          B、大驼峰：每一个单词首字母都要大写
          例如：MyNameIsDaWei
          C、小驼峰：第二个以后的单词字母大写
          例如：myNAMEISDAWEI
          D、下划线组成：单词与单词之间下划线链接
          例如：my_name_is_dawei

变量名 (需要遵循标识符命名习惯) = 值 (等号右边的值赋给等号左边的变量名)
例：

number = 521   # 将521这个数字赋值给number
print(number)  # 打印number
# 结果：
number

2.5、转义字符

常用转义字符(记住常用的，其余的了解即可)
\n -> 换行
\t -> 制表符->一个Tab键(4个空格)在与print一起运用时，\t在前面后面是4个空格，在中间是两个空格
例如

print("\tAdministrator")   # 前面4个空格即一个制表符
print("Admini\tstrator")   # 中间两个空格
print("Administrator\t")   # 后面4个空格即一个制表符
结果：
	Administrator
Admini	strator
Administrator	# 后面有4个空格

其余不常用转义字符

 \(在行尾时) ->续行符
 \\         ->反斜杠符号
 \'         ->单引号
 \”         ->双引号
 \a         ->响铃
 \b         ->退格(Backspace)
 \e         ->转义
 \000       ->空
 \n         ->换行
 \v         ->纵向制表符
 \t         ->横向制表符
 \r         ->回车
 \f         ->换页
 \oyy       ->八进制数，yy代表的字符，例如：\o12代表换行
 \xyy       ->十六进制数，yy代表的字符，例如：\x0a代表换行
 \other     ->其它的字符以普通格式输出

2.6、print结束符

print自带换行效果,end="“可以取消掉print的换行效果，end=”"中引号内容作用在输出内容中

print("hello")
print("world!!!")
print("hello", end=" ")
print("world!!!")
结果：
hello
world!!!
hello world!!!

三、认识数据类型

3.1、type函数

检测数据类型关键字->type（功能：检测数据类型）
七大数据类型
七大数据类型：3简单+4复杂

3.2、三简单数据类型

3.2.1、数值型

a、int （整型）->整数 ，例如：1， 2， 3， 4，19，88
b、float（浮点型）->带有小数点的数据 ， 例如：1.1 ， 1.01 ，9.999

num_1 = 10
num_2 = 1.01
print(type(num_1))  # type()->括号内放要检测的数据
print(type(num_2))
print(type(3.9))
结果：
<class 'int'>
<class 'float'>
<class 'float'>

3.2.2布尔型

------------a、True（真） 布尔型两种形态多用于判断
----------- b、False（假）

num_3 = True
num_4 = False
print(type(num_3))
print(type(num_4))
 结果
 <class 'bool'>    # 无论是True还是False都是布尔型（bool）
 <class 'bool'>

 == 判断等号右边是否等于等号左边  例如：
print(10 == 9)       # 9不等于10 为假
print(10 == 10)      # 10等于10 为真
结果
False   # 假
True    # 真

3.2.3、字符串类型

str ->凡是加了引号的数据都属于字符串

num_5 = "12"
num_6 = "2.01"
num_7 = "hello world!"
num_8 = "false"
print(type(num_5))     # 结果均为str（字符串类型）
print(type(num_6))
print(type(num_7))
print(type(num_8))
结果：
<class 'str'>
<class 'str'>
<class 'str'>
<class 'str'>

3.3、四复杂数据类型

3.3.1列表 list

num_9 = [10, 20, 30]  # 中间英文逗号隔开
print(type(num_9))
结果： 
 <class 'list'>

3.3.2、元组 tuple

num_10 = (11, 21, 31)
print(type(num_10))
 结果：
<class 'tuple'>

3.3.3、集合 set

num_11 = {12, 22, 33}
print(type(num_11))

结果：
<class ‘set’>

3.3.4、字典 dict

->放的是键值对 ：键: 值

num_12 = {"name": "cnm", "age": 30, "gender": "man"}
# 键值中间需要有英文状态冒号，左边为键右边为值->该代码数据类型为字符串类型，可去掉“值”的引号
print(type(num_12))

结果：
<class ‘dict’>

3.4 、格式化输出

格式化符号->输出的数据类型
%s —> 字符串
%d -> 整型
%f -> 浮点型

# 例如：伍六七今年17岁体重21.01学号id为1314521
name_1 = "wu li uqi"
age_1 = 17
weight_1 = 21.01
stu_id = 1314521
print("姓名:%s" % name_1)
print("年龄:%d" % age_1)
print("体重:%f" % weight_1)  # 默认为六位小数
print("学号ID:%d" % stu_id)

结果：
姓名:wu li uqi
年龄:17
体重:21.010000 # 默认六位小数
学号ID:1314521

对于我这种有强迫症的人来说真的是太难了，数字不对齐，体重后面居然显示六位小数，直接头也麻了，于是将代码略作修改，现在好看多了
print("姓名   :%s" % name_1)
print("年龄   :%d" % age_1, "岁")
print("体重   :%.2f" % weight_1, "公斤")     # %.2f表示小数点后面显示2位小数
print("学号ID :%07d" % stu_id)              # %07d表示输出的整数显示位数为7位，不足7位的 以0补全，超出7位则原样输出

结果：
姓名 :wu li uqi
年龄 :17 岁
体重 :21.01 公斤
学号ID :1314521

# 想了想觉得还是不靠谱，怎么可以打这么多print，试试把他们一行输出
print("姓名：%s\n年龄：%d\n体重：%3.02f\n学号：%d" % (name_1, age_1, weight_1, stu_id))

结果：
姓名：wu li uqi
年龄：17
体重：21.01
学号：1314521

3.5、格式化输出拓展

想了想仍然觉得不靠谱，各种类型直接让我头大，于是想到了f格式化
语法：f"{表达式或者是变量}"

print(f"姓名：{name_1}\n年龄：{age_1}\n体重：{weight_1}\n学号{stu_id}")  # B格满满

结果：
姓名：wu li uqi
年龄：17
体重：21.01
学号1314521

四、输入和类型

4.1input输入

语法 input(“提示信息”)->提示信息是给用户看的
作用，接收用户的数据
name_2 = input(“请输入姓名：”)

print("%s你天天压榨我" % name_2)  # ->输入的数据类型统一为字符串类型

结果：
请输入姓名：张三
张三你天天压榨我

4.2、数据类型转换

int(x) ->将x转换为整型
float(x) ->将x转换为浮点数
str(x) ->将x转换为字符串
repl(x) ->将对象转换为表达式字符串
eval(str) ->用来计算在字符串中的有效python表达式，并返回一个对象
tuple(s) ->将序列s转换为一个元组
list(s) ->将序列s转换为列表
chr(x) ->将一个整数转换为一个Unicode字符
complex([real[, imag]]) ->创建一个复数，real为实部，imag为虚部

还是那行熟悉的代码

name = input("请随便输入一个内容：")   # 输入的数据类型默认为字符串
print(type(name))  # 打印输入内容的数据类型
print(type(int(name)))  # 对内容进行数据转换
print(type(float(name)))
print(type(str(name)))

结果：
<class ‘str’> ->数据类型结果为字符串
<class ‘int’> ->数据类型结果为整型
<class ‘float’> ->数据类型结果为浮点型
<class ‘str’> ->数据类型结果为字符串类型

4.3、序列转换

tuple(序列)->将序列转换为元组，序列：列表，元组，集合，字典

例如：
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))    # 将列表转换为元组

结果：
[10, 20, 30]

list(序列)->将序列转换为列表

t1 = (10, 20, 30)
print(list(t1))
print(type(list(t1)))

结果：
<class ‘list’>

4.4、字符串转换为原本数据

eval(字符串)->小括号内只能放字符串，将字符串转换为它原本的数据类型

num0 = "1"
num1 = "1.1"
num2 = "False"
num3 = "{10, 20, 30}"
print(type(eval(num0)))
print(type(eval(num1)))
print(type(eval(num2)))
print(type(eval(num3)))

结果：
<class ‘int’>
<class ‘float’>
<class ‘bool’>
<class ‘set’>

五、运算符

5.1、运算符

5.1.1、算数运算符

＋ ->加

print(2 + 3)

结果：5
- ->减

print(3 - 2)

#结果：1

• （星号） ->乘

print(2 * 3)

结果：6
/ ->除

print(4 / 2)

结果：2.0

5.1.2、整除和取余运算

// ->整除

print(9 // 4)  # 9除4=2余1  取整：结果为2

结果：2

% ->取余

print(9 % 4)  # 9除4=2余1  取余： 结果为1

结果：1

** ->指数

print(2 ** 4)  # 2乘2乘2乘2

结果：16
( )->提高运算符优先级

5.2、优先级

优先级顺序

()  ->  **  ->  *,/,//,%    ->   +,-

5.3、赋值运算符

5.3.1、单个赋值

num_1 = 1
print(num_1)

结果：1

5.3.2、多个赋值

多个赋值->多对多，等号左右个数要相等，顺序一一对应

int_1, float_1, str_1 = 55, 52.1, "hell world!!!"
print(int_1)
print(float_1)
print(str_1)

结果:
55
52.1
hell world!!!

5.3.3、多对一赋值

多对一 ->多变量赋相同的值

a = b = c =d =10
print(a, b, c, d)

结果：10 10 10 10

5.4、复合赋值运算符，例如：

5.4.1、加法赋值运算符

加法赋值运算符：+= b+=c等价于b=b+c
num_2 = 10
num_2 += 3 # 等价于num_2=num_2 + 3 ->num_2 = 10 +3 ->13
print(num_2)
结果：13

5.4.2、整除赋值运算符

整除赋值运算符：//= b //= c ->等价于 b = b // c
num_3 = 9
num_3 //= 4
print(num_3)
结果：2

5.4.3、次方运算符

次方运算符： **= b **= c ->等价于 b = b ** c

num_4 = 5
num_4 **= 2
print(num_4)

结果：
25

5.4.4、比较运算符

比较运算符 比较时，数据类型要一致
== ->判断左右是否相等,结果只有两种 True(真）和False(假)，都是布尔型

  != ->判断结果是否不相等
 <  ->小于号
 >  ->大于号
 <= ->小于等于
 >= ->大于等于

5.4.5、逻辑运算符

and ：全真为真，一假则假
or ：一真则真，全假则假

5.5、not

not ：取反义 例如：

print(not True)

结果:
False

六、if语句

6.1、if应用

一、if语句->多用于判断
语法：
if 条件:
条件成立执行的第一行代码
条件成立执行的第二行代码
等等

age = int(input("请输入你的年龄："))
#  上方input前不加int，会报错TypeError: '<=' not supported between instances of 'str' and 'int',输入数据默认为str(字符串类型)
if age <= 18:   # age为字符串类型，18为整型 ，类型不一致，无法比较会出现报错
    print("年龄小于18，可以玩天线宝宝玩具")
else:  # 否则
    print("年龄大于18，可以玩天线宝宝手办")  # 出现if自动缩进，没有缩进的代码不属于if语句中
print("循环打印结束")  # 不属于if语句中``

结果：
请输入你的年龄：20
年龄大于18，可以玩天线宝宝手办
循环打印结束

6.2、if…elif…判断

多重判断 ->适合多个条件
if 条件1: ->一个if语句里面只能有一个if和一个else，elif可以有多个。
elif 条件二:
elif 条件三:
else:
例如：

"""
判断法外狂徒张三是否是在合适的工作年龄
18岁<合法年龄>60岁
"""
age = input("狂徒张三请输入您的年龄：")
age = int(age)
if age < 18:
    print("张三同学，由于您未满18，属于童工，不予以招收")
elif (age >= 18) and (age < 60):
    print("狂徒张三，明天来工作，可不要迟到了，董事长姓铁，叫铁公鸡！！！")
else:
    print("法外狂徒张三，您退休了，这份工作不适合你！")
结果：
狂徒张三请输入您的年龄：57
狂徒张三，明天来工作，可不要迟到了，董事长姓铁，叫铁公鸡！！！

elif与else的区别
a、elif后面接条件，else后面不接条件
b、有两种情况以上用elif，两种情况一下用else

6.3、if嵌套练习

if嵌套

"""
上次狂徒张三虽然找到了工作，但是因为老板是铁公鸡不发工资，两人闹掰，怒发冲冠之下，张三不出意外，坑了老板一顿后，辞职了。
现在张三继续在面试之路上找工作，今天进入一家老板姓周的私企面试：
"""
print("狂徒张三：敲门~~~~咚咚咚~~~~")
print("面试官：请进！")
age = int(input("面试官：张三先生今年多少岁了？\n请输入年龄:"))
if (age >= 18) and (age < 60):
    print("面试官：张三先生，很高兴您的年龄符合要求!")
    print("不过您的简历上写，您上一份工作把老板坑了。请问在这一份工作里面您还会继续坑老板吗？\n")
    YorN = input("请输入：坑老板或者是不坑老板：")
    if YorN == "不坑老板":
        print("面试官：狂徒张三，明天来工作，可不要迟到了，对了，董事长姓周，叫周扒皮！！！")
    elif YorN == "往死里坑":
        print("面试官：张三先生，这是车费，你拿着回去吧！！！")
    else:
        print("面试官：这份工作不适合你，你回去吧")
else:
    print("面试官：这份工作不适合你，你回去吧")
print("面试结束！！！")
结果：
三：敲门~~~~咚咚咚~~~~
面试官：请进！
面试官：张三先生今年多少岁了？
请输入年龄:56
面试官：张三先生，很高兴您的年龄符合要求!
不过您的简历上写，您上一份工作把老板坑了。请问在这一份工作里面您还会继续坑老板吗？
请输入：坑老板或者是不坑老板：坑老板
面试官：这份工作不适合你，你回去吧
面试结束！！！

6.4、三木运算符

三木运算符（也叫：三元运算符、三元表达式 ）->作用：化简if语句代码，减少if语句代码行数

对a，b两个数据进行比较大小，并打印出a，b中较大数据
a = "521"
b = "520"
c = a if a > b else b  # 先if对a b进行比较，如果a大，则将if前数据 a 传给c，如果b大则将else后数据 b 传给c，
print(c)
结果：
521
条件成立表达式 if 条件 else 条件不成立表达式
print(a) if a > b else print(b)  # 同理先if对a b进行比较，如果a大，则执行if前语句，如果b大则执行else后语句
结果：
521

6.5、三木与if嵌套

三木运算符if语句嵌套写法

num = 1 if 1 > 2 else (2 if 2 > 3 else 3)  # 大致就是else后面继续if嵌套，原理很简单，我下面多写几个，你们一看应该就明白了
print(num)
结果：
3
num1 = 1 if 1 > 2 else (2 if 2 > 3 else (3 if 3 > 4 else 4))
print(num1)
结果：
4
num2 = 1 if 1 > 2 else (2 if 2 > 3 else (3 if 3 > 4 else (4 if 4 > 5 else 5)))
三木if嵌套，在else后加一个英文状态括号，括号内继续写三木if嵌套，如果不需要继续嵌套直接else后填写执行代码，如果需要继续嵌套则，继续else后括号，写要if判断的代码
print(num2)
结果：
5

七、while循环

7.1、循环

循环分为while循环和for循环

7.2、while循环

while循环
格式：
while 条件:
条件成立执行的代码1
条件成立执行的代码2
…

“”"
自昨日狂徒张三表示不坑老板，并成功应聘门卫的工作后，坐在门卫室时脑海里刻想着冷静二字，并且给自己立下一个规定，每天写冷静和戒怒这4个字100遍，并且发下毒誓，中断一天就yw三年，刚开始还好，可是时间一久这每天400字的心动摇了。终究，在3秒的心理斗争之后，把目光转向了while循环。
“”"

i = 1
o = 0
while i <= 100:
    print("冷静 戒怒", i)
    i += 1
结果：
冷静 戒怒 1
冷静 戒怒 2
......
冷静 戒怒 50
......
冷静 戒怒 99
冷静 戒怒 100

7.3、break和continue

break和continue ->多用于循环
break ->终止操作
continue ->跳过此次循环 注意终止条件
“”"
还是熟悉的配方还是熟悉的味道！
不知不觉，狂徒张三已经工作一个多月有余了，可是老板铁公鸡还没有发工资，于是张三除了每天一百遍的冷静 戒怒的任务外，还有一百遍的嘀咕：“一毛不拔快发工钱”
今天恰巧老板在张三”完成任务“路过，路过时间是张三在说第88遍一毛不拔快发工钱的时候
“”"

i_1 = 1   # 作为起始条件 和 自加，达到循环结束条件。
while i_1 <= 100:
    print("冷静 戒怒", i_1)    # 后面的i_1用于记录到了多少遍，有利于读者观察
    if i_1 == 88:
        print("老板下来视察工作！")
        put_1 = input("请输入”发现老板“或者是”没发现老板“：")
        if put_1 == "发现老板":  
            print("张三瞬间一头冷汗，停止嘀咕！")
            print("老板并未回头，直接走过去了！")
            i_1 += 1
            continue                                       # 发现老板，跳过这次嘀咕老板，直接继续提醒自己戒怒 冷静
        else:
            print("狂徒张三继续嘀咕：一毛不拔快发工钱", i_1)
            print("铁公鸡：你居然敢嘀咕我，明天不用来了！！！")
            break                                          # 被开除，不再戒怒 冷静和嘀咕老板，直接终止循环。
    print("狂徒张三：一毛不拔快发工钱", i_1)
    i_1 += 1
print("故事结束")
结果：
冷静 戒怒 1
狂徒张三：一毛不拔快发工钱 1
冷静 戒怒 2
狂徒张三：一毛不拔快发工钱 2
......
狂徒张三：一毛不拔快发工钱 85
冷静 戒怒 86
狂徒张三：一毛不拔快发工钱 86
冷静 戒怒 87
狂徒张三：一毛不拔快发工钱 87
冷静 戒怒 88
老板下来视察工作！
请输入”发现老板“或者是”没发现老板“：发现老板
张三瞬间一头冷汗，停止嘀咕！
老板并未回头，直接走过去了！
冷静 戒怒 89
狂徒张三：一毛不拔快发工钱 89
冷静 戒怒 90
狂徒张三：一毛不拔快发工钱 90
......
冷静 戒怒 100
狂徒张三：一毛不拔快发工钱 100
故事结束

7.4、while循环嵌套

while循环嵌套
格式：
while 条件一:
条件一成立执行的代码
…
while 条件二:
条件二成立执行的代码
…
打印三角形

i_1 = 1
while i_1 <= 5:
    j = 1
    while j <= i_1:
        print(" *", end="")
        j += 1
    print()
    i_1 += 1
结果：
 *
 * *
 * * *
 * * * *
 * * * * *

八、for循环

8.1、for循环基础

for循环，控制代码重复执行
语法
for 临时变量 in(关键字) 序列(列表，元组，字典，集合，字符串)
重复执行的代码
重复执行的代码i
…

str1 = "狂徒张三"
for i in str1:
    print(i)
结果：
狂
徒
张
三

# 列表
list1 = [16, "张三", 100]
for j in list1:
    print(j)

结果：
16
张三
100

8.2、range 函数

for循环1到100相加偶数和
range -> 功能函数
range (开始，结束位置不取第二个数字，步长第三个数字)->作用：
例如： range(0, 10)
生成0到9一共10个数字，即从0开始到9，括号内第二个数字10为结束位置，不计入

for i in range(0, 101):  # 注：第二个数字是100，即最大为99
    print(i)
结果：
0
1
2
...
49
50
51
...
97
98
99
# for 循环输出1到100所有偶数和，使用range函数
j = 0
for i in range(0, 101):
    if i % 2 == 0:
        j += i
print(j)
# 结果:
2550
例如： range(0, 10, 2)
生成0，2，4，6，8一共5个数字，即从第一个数字0开始，每次加2(第三个数字)，到9(第二个数字为结束位置不取，所以只会到9，可理解为第一个数字到第二个数字减一，即10-1）结束
for i in range(0, 101, 2):  # 注：第二个数字是101，即最大为100
    print(i)
# 结果：
0
2
4
...
48
50
52
...
96
98
100

# for 循环输出1到100所有偶数和，使用range函数
j = 0
for i in range(0, 101, 2):
    j += i
print(j)
结果：
2550

8.3、for循环的break和continue

break->当条件成立时，终止整个循环，直接结束循环。
continue->当条件成立时，跳过当前循环，继续执行下一个循环
a、break
吃鸡不带吧，文明你我他！

str1 = "大吉大利，今晚吃鸡吧!"
for o in str1:
    if o == "吧":
        break  # 观察结果，遇到”吧“字后直接终止循环，感叹号（!）也未打印
    print(o)
结果：
大
吉
大
利
，
今
晚
吃
鸡

    # 感叹号缺失
continue的使用
同样的药方，依旧是吃鸡
str1 = "大吉大利，今晚吃鸡吧!"
for o in str1:
    if o == "吧":
        continue  # 观察结果，遇到”吧“字后跳过该次循环循环，感叹号（!）继续打印
    print(o)
结果：
大
吉
大
利
，
今
晚
吃
鸡
!

8.4、while和for与while的配合使用！

else使用:当循环正常结束之后要执行的代码 ——>需要正常结束，如果不是正常结束不会执行代码
例如：

while与else组合
j = 0
while j < 5:
    if j == 3:
        break  # break属于终止，不是正常结束，所以不会打印else
        j += 1
    print("生活不易，程序袁叹气！！！")
    j += 1
else:
    print("叹气完毕，继续肝！")
结果：
生活不易，程序袁叹气！！！
生活不易，程序袁叹气！！！
生活不易，程序袁叹气！！！

j = 0
while j < 5:
    if j == 3:
        j += 1
        continue  # break属于终止，不是正常结束，所以不会打印else
        # 1
    print("生活不易，程序袁叹气！！！")
    j += 1
else:
    print("叹气完毕，继续肝！")
结果：
生活不易，程序袁叹气！！！
生活不易，程序袁叹气！！！
生活不易，程序袁叹气！！！
生活不易，程序袁叹气！！！
叹气完毕，继续肝！

for与else组合
str1 = "狂徒张三，和帮凶李四！"
for j in str1:
    if j == "和":
        break
    print(j)
else:
    print("结束！！")
结果：
狂
徒
张
三
，

str1 = "狂徒张三，和帮凶李四！"
for j in str1:
    if j == "和":
        continue
    print(j)
else:  # for循环中同理，只要是遇到break那么else就不起作用，如果是continue跳过循环，那么else后的程序会执行
    print("结束！！")
结果：
狂
徒
张
三
，
帮
凶
李
四
！
结束！！

九、、字符串和下标

9.1、切片

切片-> 下标 ->索引-获取字符串当中某一片段字符的操作
切片:指对操作的对象截取其中一部分的操作，字符串、列表、元组都支持切片操作
语法:序列名[开始位置下标:结束位置下标:步长]
注意:
1、不包含结束符位置下标对应的数据，正负整数均可
2、步长是选取间隔，正负整数均可,默认步长为1

字符串，字符串是python中最常见的数据类型，我们一般使用引号来创建字符串，创建字符串只要分配一个值即可
例如

name_1 = 'Ton1'
name_2 = """Ton2"""  # 三个单引号或者是三个双引号都可以
name_3 = "Ton3"
print(f"{name_1}\n{name_2}\n{name_3}")
# 结果：
Ton1
Ton2
Ton3

9.2、下标

下标->下标又叫索引，就是编号，比如火车站座位号，座位号的作用，按照编号快速找到对应的座位，同理下标也是类似，通过编号快速找到相应数据

str1 = "zhangsan"  # 字母从零开始，一一对应。张三拼音共8个字母，从0开始到7结束
"""
打印张三拼音的开头首字母即z和s
"""
print(str1[0])  # 写法 序列名，加下标  即序列名[下标]
print(str1[5])
# 结果：
z
s

str1 = "ZhangSan"
# 需求，只打印ZS
print(str1[0], str1[5])
# 结果：
Z S
# 把Zhang作为一个整体，从字符串当中截取出来——切边
print(str1[0:4:1])  # 如果步长是1，可以省略，默认步长为1
# 结果：
Zhan

str2 = "0123456789"
print(str2[5:8:1])  # 注意，结束位置下标不打印，所以是5：8
print(str2[:5])  # 开始位置不取，默认从零开始取下标
print(str2[6:])  # 结束位置下标不写，选取到最后
print(str2[:])  # 如果开头和结尾都不写，默认选取所有
# 结果：
567
01234
6789
0123456789

步长为负

print(str2[::-1])  # 步长为负，表示倒叙选取
# 结果：
9876543210
print(str2[-4::-1])  # 当下标有-1，负1表示最后一个数，在例子中为9，没有0
# 结果：
6543210
print(str2[-4:-1:-1])  # 不能选取，因为步长负1表示倒叙选值即源数据的从右往左，而开始位置到结束位置是正序，即方向为从左到右，方向冲突
# 结果
不会出现结果，显示空白，有回车
print(str2[-1:-4:-1])  # 选取方向不冲突
987  # -4为结束位置，不打印

9.3、字符串常用操作

字符串常用操作->对字符串进行增删改查

9.3.1、查找

查找：查找子串在字符串中的位置或出现的次数

9.3.2、find函数

find():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1
语法：字符串序列.find(子串, 开始位置下标, 结束位置下标)

str1 = "hello1 world! hello DaWei hello wei."
print(str1.find("world"))  # 里面有相同的字符串，会显示该字符串下标
# 结果：
7  #  从零开始，空格也算一个下标
print(str1.find("wei1"))  # 里面没有相同的字符串，会显示-1
 # 结果：
 -1
print(str1.find("hello", 18, 35))
# 结果：
26

9.3.3、index函数

index()：和find()调用方式和功能相同。

str1 = "hello How are you ! How"
print(str1.index("How"))  # . 表调用 作用，找出How开始位置的下标
# 结果
6
print(str1.index("How!"))  # 如果没有这个字符串会直接报错，不同于find(),遇到找不到的字符串会报-1
# 结果：报错
"""
Traceback (most recent call last):
  File "D:/Pycharm/xiangmu/python课程/day06字符串.py", line 63, in <module>
    print(str1.index("How!"))  # 如果没有这个字符串会直接报错，不同于find(),遇到找不到的字符串会报-1
ValueError: substring not found
"""

print(str1.index("How", 19, 26))  # 可以指定子串（字符串）范围
# 结果：
20

9.3.4、count函数

count()：返回某个字符串在字符串中出现的次数,如果字符串不存在，结果为0

print(str1.count("How"))
# 结果：
2
print(str1.count("How", 18, 26))  # 指定范围，该范围内How出现一次
# 结果：
1

9.3.5、rfind()函数

rfind:和find功能相同，但查找方向为右侧开始

print(str1.rfind("How"))  # 查找方向为从右侧，往从左侧，下标不变依旧是从左往右，从零开始。
# 结果
20
print(str1.rfind("How1"))  # 不存在结果报-1
# 结果：
-1

9.3.6、rindex()函数

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

print(str1.rindex("How"))  # 从右侧开始，
# 结果：
20
print(str1.rindex("How1"))  # 不存在会出现报错，不会显示-1
# 结果：
报错

b、修改
str_1 = “hello world，hello my friend， hello” #

9.4替换

替换->替换字符串中的数据

9.4.1、replace函数

replace() # 用其他字符串替换已有字符串
使用方式 .replace(旧子串，新子串，替换次数)

print(str_1.replace("hello", "Hello"))  # 用后面一个Hello替换前面一个hello ，默认替换所有
print(str_1.replace("hello", "Hello", 2))  # 只替换2个，如果替换次数超过子串出现次数，将替换所有
# 结果：
Hello world，Hello my friend， Hello
Hello world，Hello my friend， hello

9.5分割

分割->按照指定字符分割字符串
split() # 按照指定字符分割字符串，返回一个列表数据类型
使用方式 .split(分割字符, 分割次数)

num1 = str_1.split("hello")  # 分割所有
print(num1)
# 结果：
['', ' world，', ' my friend， ', '']
num2 = str_1.split("hello", 2)  # 只分割前两个
print(num2)
# 结果;
['', ' world，', ' my friend， hello']

9.6合并

合并->用一个字符或子串合并字符串
join() # 用一个字符或者子串合并字符串
使用方式 子串.join(字符串组成的序列)

list1 = ["a1", "b1", "c1"]  # 列表，一个中括号里面放多个数据
效果a1...b...c1...
list2 = "...".join(list1)
print(list2)
# 结果
a1...b1...c1

9.7小大写转换

转换字符串的大小写

9.7.1、capitaize函数

capitalize() # 将字符串第一个字符转换成大写 *打点调用

str_1 = "hello world，hello my friend， hello"  
print(str_1.capitalize())   # 该一行的首字母大写
# 结果：
#Hello world，hello my friend， hello

9.7.2、title函数

.title() # 该句所有单词首字母统统大写

print(str_1.title())
# 结果：
Hello World，Hello My Friend， Hello

9.7.3、upper函数

.upper() # 全部小写转大写

print(str_1.upper())
# 结果：
HELLO WORLD，HELLO MY FRIEND， HELLO

.lower() # 全部大写转小写

print(str_1.lower())
# 结果
hello world，hello my friend， hello

9.8删除空白字符

删除字符串中的空白字符

str3 = "  ab   cd   "
# .lstrip()  # 删除前面（左侧）的空白字符
print(str3.lstrip())
# .rstrip  # 删除后面，右侧的空白字符
print(str3.rstrip())
# .strip  # 删除两侧空白字符
print(str3.strip())
# 结果
ab   cd
  ab   cd# 后面的空白被删除
ab   cd

9.9、字符对齐

使原字符串字符对齐

str4 = "world"
# .ljust()  # 填充字符使原字符串左对齐
print(str4.ljust(10, "."))  # 填充字符使原字符串左对齐->一共10个位，空白部分用.填充,默认空格填充
# .rjust()  # 填充字符使字符串右对齐
print(str4.rjust(10, "-"))  # 字符串右对齐，10个位，不足用-填充
# .center()  # 中间对齐
print(str4.center(15, "."))  # 填充字符奇数时候前面的默认多一个后面的少一个
# 结果：
world.....
-----world
.....world.....

十、列表常用操作

10.1、判断

——>判断
str5 = “hello my friend”

10.1.1、statswith() 函数

.statswith() # 判断字符串是否以某个子串开头，小括号内放子串，结果为布尔类型True和False

print(str5.startswith("hello"))  # 结果：True
print(str5.startswith("he"))     # 结果：True

10.1.2、endswith() 函数

.endswith() # 判断字符串是否以某个子串结尾，小括号内放子串，结果为布尔类型True和False

print(str5.endswith("end"))  # True

10.1.3、isalpha()函数

isalpha() # 判断字符串中是否都是字母

print(str5.isalpha())  # 结果：False（其中穿插有空格）

10.1.4、isdigit函数

.isdigit判断字符串里面都是数字

str6 = "678"
print(str6.isdigit())  # 结果：True

10.1.5、isalunm()函数

isalnum()判断是否都是字母，或者是数字，或者是字母和数字的组合

str9a = "123abc"
str9b = "123456"
str9c = "abcdef"
print(str9a.isalnum())
print(str9b.isalnum())
print(str9c.isalnum())
# 结果：
True
True
True

10.1.6、isspace()函数

.isspace()判断字符串里面是否都是空格

str10 = "     "
print(str10.isspace())  # True

十一、列表常用操作

11.1、查找

查找
a、列表名[下标] 函数描述

name1 = ["xwa", "xla", "xza", "xwa"]
print(name1[2])
# 结果
xza

11.1.1、index函数

.index(数据)存在返回下标，否则报错

print(name1.index("xwa", 1, 4))  # 可以限制查找范围，否则默认找到该列第一个数据下标
# 结果：
3

11.1.2、count函数

.count(数据) 返回指定数据在列表中的次数

print(name1.count("xwa"))
# 结果
2

11.1.3、len函数

len(列表名) 返回列表的长度，长度指列表中有多少个数据

print(len(name1))
# 结果:
4

11.2、判断和增加

11.2.1、in函数

in：数据in列表，判断数据是否在列表中 两种结果布尔型True或False

print("xza" in name1)  # 结果 True
print("xza1" in name1)  # 结果 False

11.2.2、not in函数

not in：数据not in 列表，判断数据是否不在列表中

print("xla" not in name1)  # False
print("xla1" not in name1)  # True

11.2.3、append()函数

append():列表名.append(数据)列表结尾追加数据

name1.append("lie")
print(name1)
# 结果：
['xwa', 'xla', 'xza', 'xwa', 'lie']

11.2.4、extend()函数

extend():列表名.extend(数据)数据是序列的话列表结尾逐一追加

name1.extend("lie")  # 字符串拆分成一个个然后在结尾添加
print(name1)
# 结果：
['xwa', 'xla', 'xza', 'xwa', 'l', 'i', 'e']

11.2.5、insert()函数

insert():列表名.insert(下标,数据) 指定位置新增数据

name1.insert(2, "xxa")  #
print(name1)
# 结果：
['xwa', 'xla', 'xxa', 'xza', 'xwa']

11.3、删除

name2 = [“lw”, “ll”, “lw”, “lh”]

11.3.1、del函数

del 目标 ：del列表名或del列表名[下标]，删除列表或列表中的数据

del name2  # 删除列表
print(name2)
列表删除，报错
del name2[2]
print(name2)
# 结果：
['lw', 'll', 'lh']

11.3.2、pop()函数

pop()：列表名（下标），删除指定下标的数据，并且返回该数据(删掉的数据)

del_name = name2.pop(1)
print(del_name)
print(name2)
# 结果
ll
['lw', 'lw', 'lh']

del_name2 = name2.pop()
print(del_name2)  # 删除的数据
print(name2)  # 删除后剩余的数据
# 结果
lh
['lw', 'll', 'lw']

11.3.3、remove()函数

remove():列表名.remove(数据)，删除列表中某个数据的第一个配置项(两个相同的数据时候的第一个数据)

name2.remove("lw")  # 删除第一个lw
print(name2)
# 结果
['ll', 'lw', 'lh']

11.3.4、clesr函数

.clesr():列表名.clear() ,清空列表(删掉列表里面的所有数据

name2.clear()
print(name2)
# 结果
[]

11.4、修改和复制

name3 = [“yul”, “kun”, “yud”, “yul”]

11.4.1、下标修改

列表名[下标] = 新数据 ：列表名[下标] = 型数据，按照下标修改指定数据

name3[2] = "lll"
print(name3)
# 结果
['yul', 'kun', 'lll', 'yul']

11.4.2、reverse()函数

reverse():列表名.reverse(),实现列表中的数逆序，倒序

name3.reverse()
print(name3)
# 结果：
['yul', 'yud', 'kun', 'yul']

11.4.3、sort()函数

sort:列表名.sort() ,实现列表升序排序 # 数字从小到大，字母从a到z，汉字不规则，可能是按照拼音或者是笔画

name4 = [3, 5, 2, 9, 1, 8, 0]
name3.sort()
name4.sort()
print(name3)
print(name4)
# 结果：
['kun', 'yud', 'yul', 'yul']
[0, 1, 2, 3, 5, 8, 9]

11.4.4、sort、函数

sort：列表名.sort(reverse = False),reverse = True降序，reverse = False升序（默认） reverse表示排序的规则

name4.sort(reverse=True)  # 降序
print(name4)
# 结果；
[9, 8, 5, 3, 2, 1, 0]

name4.sort(reverse=False)  # 升序
print(name4)
# 结果：
[0, 1, 2, 3, 5, 8, 9]

11.5、复制

复制：copy():列表名.copy() ,复制存储原数据

name3 = name4.copy()
print(name3)
print(name4)
# 结果;
[3, 5, 2, 9, 1, 8, 0]
[3, 5, 2, 9, 1, 8, 0]

十二、列表的嵌套使用

12.1、列表嵌套

列表嵌套：指的是一个列表里面包含了其他的子列表。

name5 = [[["xl", "yul", ["yy"]], "xw", "xz"], ["1", "2", "3"], ["a", "b", "c"]]  # 列表嵌套，[下标][下标]...都是从零开始
print(name5[1][2])   # 3
print(name5[0][0][2][0])  # yy

12.2、列表的循环遍历

列表的循环遍历:依次打印列表的各个数据

list1 = ["wang", "li", "zang"]
# for循环
for i in list1:
    print(i)
# 结果：
wang
li
zang

12.3、while循环遍历

while循环遍历

i = 0  # 下标从零开始
while i < len(list1):  # 当不知道列表中有多少数据用len函数
    print(list1[i])
    i += 1
# 结果：
wang
li
zang

应用

"""
10个宝珠，随机分配给张三团伙三人
宝珠：["a", "b", "c", ...]
张三团伙三人[[][][]]
"""
# 导入随机模块和函数
import random  # 导入random随机模块
# num = random.randint(0, 2)  # 放在这里只程序开始时候运行一次，
# 准备宝珠
bead = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
san = [[], [], []]
# 分配宝珠到张三哪里
for z in bead:
    # 把宝珠z添加到张三三人的子列[[], [], []]那里去，使用append函数添加，append(数据)， 列表名[下标] = 新数据，按照下标修改指定数据
    # 随机分配：导入随机函数
    num = random.randint(0, 2)  # 再通过random模块导入随机函数，包前后0，1，将随机数给num，
    san[num].append(z)
print(san)
# 结果：三次运行
[['a', 'b', 'c', 'g', 'i', 'j'], ['d', 'h'], ['e', 'f']]
[['c', 'e', 'g', 'h', 'i'], ['d', 'j'], ['a', 'b', 'f']]
[['a', 'd', 'e', 'i'], ['b', 'g', 'j'], ['c', 'f', 'h']]

十三、元组

13.1、元组应知

一个元组里面可以存储多个数据，且元组内的数据不能进行修改，与列表不同，列表可修改
格式；
(数据1， 数据2， 数据3，…)

yz = (1, 2, 3, 45, 657)
print(type(yz))  # 结果： <class 'tuple'>

注意，如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型

yz10 = (123,)
yz11 = ("wan")
yz12 = (123)
print(type(yz10))
print(type(yz11))
print(type(yz12))
# 结果：
<class 'tuple'>
<class 'str'>
<class 'int'>

13.2、元组查找

元组可查找，不支持修改

13.2.1、按下标查找数据

a、元组名[下标]:按下标查找

yz2 = ("a", "b", "c", "a")
print(yz2[2])
# 结果：
c

13.2.2、按函数查找

a、index()：元组名.index(数据)，存在返回下标，否则报错

print(yz2.index("b"))
# 结果:
1

b、count()：元组名.count(数据)，返回指定数据在元组中的次数

print(yz2.count("a"))
# 结果：
2

c、len()：len(元组名)，返回序列的长度，元组也可以使用

print(len(yz2))
# 结果：
4

修改：a、元组内的直接数据如果修改则立即报错，但是如果元组里面有列表，修改列表里面的数据是支持的

十四、集合与字典

14.1、集合

集合格式：{数据1， 数据2， 数据3，…}
特点、a.集合中的数值不重复，去重,
b、集合是无序，不支持下标操作
常用操作

14.2、集合的创建

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

创建空集合用set(), {}是用来创建空字典

s1 = {}
print(type(s1))
# 结果：
<class 'dict'>  # 字典
s2 = set()
print(type(s2))
# 结果：
<class 'set'>
s2 = set("hufs")  #
print(s2)
# 结果：
{'f', 'u', 's', 'h'}

创建有数据的集合，会有去重和无序，也不支持下标操作和切片操作

s3 = {10, 20, 30}
print(s3)
s4 = {12, 34, 56, 12}
print(s4)
# 结果 ：
{10, 20, 30}
{56, 34, 12}

如果说数据不能修改，那就存到元组内，如果数据需要去重，并且无序，那么存到集合中，如果数据没有特殊要求，直接存列表

14.2.1、集合的增加

增加
a、add():集合名.add(数据)，添加的是数据，序列会报错

y1 = {9, 99, 999, 9}
y1.add(100)
print(y1)
# 结果：
{9, 99, 100, 999}
y1.add([10, 20])  # 结果报错
print(y1)
# 结果：
Traceback (most recent call last):
...

b、update()集合名.update(序列)，添加的是序列(字符串，列表，集合，元组 ，字典)，添加数据会报错

y1.update([120, 20, "65"])
print(y1)
# 结果
{99, 999, '65', 9, 20, 120}
y1.update(12)
print(y1)
# 结果：
Traceback (most recent call last):
...

14.2.2、集合的删除

删除
a、remove():集合名.remove(数据)，删除指定数据，不存在会报错

y2 = {1, 2, 3, 6, 9}
y2.remove(2)
print(y2)
# 结果：
{1, 3, 6, 9}
y2.remove(8)
print(y2)
# 报错：
Traceback (most recent call last):
...

b、discard():集合名.discard(数据)，删除指定数据，不存在不会报错

y2.discard(5)
print(y2)
# 结果：
{1, 2, 3, 6, 9}

d、pop():集合名.pop(数据)，删除第一个一个数据(又因为集合无序，所以算是无序)，并返回该数据，

print(y2)
y3 = y2.pop()
print(y3)
print(y2)
# 结果：
{1, 2, 3, 6, 9}
1
{2, 3, 6, 9}

集合里面有0,0会跑第一个去

y4 = {7, 3, 89, 9, 3, 0}
print(y4)
print(y4.pop())
print(y4)
# 结果：
{0, 3, 7, 9, 89}
0
{3, 7, 9, 89}

14.2.3、集合的查找

常用查找操作->查找判断
in判断某个数字是否在集合序列中
not in判断某个数据是否不在集合序列中

y5 = {89, 67, 35, 0}
print(35 in y5)
print(78 not in y5)
# 结果：
True
True

14.3、字典

字典的作用：可以在不支持下标操作的情况下，数据顺序发生变化之后依然可以查找到数据。
字典内为键值对，寻找数据时候，即通过key拿到key对应的值，key为键，值为vaiue
字典的格式：{“name”:“lilei”,“age”:20,“gender”:“男”}
字典的特点：
1、符号为大括号
2、数据为键值对形式出现
3、各个键值对之间用逗号隔开

14.3.1、字典的创建

创建空字典：{}或dict()

dict1 = {}
dict2 = dict()
print(type(dict1))
print(type(dict2))
结果：
<class 'dict'>
<class 'dict'>
创建非空字典
dict3 = {"yb": "xuh", "eb": "pz", "xz": "xxx"}
print(dict3)
# 结果
{'yb': 'xuh', 'eb': 'pz', 'xz': 'xxx'}

14.3.2、字典的增加

增加，写法：字典序列[kay] = 值

dict4 = {"name": "tom", "age": "8", "gender": "女"}
dict4["id"] = 100
print(dict4)
# 结果：
{'name': 'tom', 'age': '8', 'gender': '女', 'id': 100}

14.3.3、字典的修改

修改，写法：字典序列[key] = 值

dict4["name"] = "mei"  # ”键“要在字典中
print(dict4)
# 结果:
{'name': 'mei', 'age': '8', 'gender': '女'}

14.3.4、字典的删除

删除
a.del()：del 字典名或del(字典名)，删除整个字典或者键值对
删除字典

del dict4
print(dict4)
# 结果：
报错，字典未定义
Traceback (most recent call last):
...

删除键值对

del dict4["name"]  # 删除整个键值对
print(dict4)
# 结果:
{'age': '8', 'gender': '女'}
del(dict4["age"])
print(dict4)
# 结果：
{'name': 'tom', 'gender': '女'}

b.clear()：字典名.celar()，清空字典中的数据

dict4.clear()
print(dict4)
# 结果：
{}

14.3.5、字典的查找

查找

a、按key查找：字典名[key]，存在返回key对应的值，不存在报错

dict5 = {"name": "tom", "age": "8", "gender": "女"}
print(dict5["gender"])
# 结果：
女

b0、按函数查找

dict6 = {"name": "tom", "age": "8", "gender": "女"}

b1、get():字典名.get(key)，存在返回key对应的值，不存在返回None—>空

print(dict6.get("name"))  # tom
print(dict6.get("names"))  # Nome

b2、Keys：字典名.keys()，查找字典中所有的key,并返回 可迭代对象->即序列，可以用for循环循环的对象(如：str 字符串，list 列表，tuple 元组，srt 集合，dict 字典)

print(dict6.keys())
# 结果：
dict_keys(['name', 'age', 'gender'])  # 返回列表

b3、valuse():字典名.values()，查找字典中所有的values,并且返回可迭代对象

print(dict6.values())
# 结果;
dict_values(['tom', '8', '女'])  # 返回列表

b4、items():字典名.items()，查找字典中所有的键值对，并且返回可迭代对象:列表中数据的数据类型是元组

print(dict6.items())
# 结果：
dict_items([('name', 'tom'), ('age', '8'), ('gender', '女')]) 

14.4、字典的遍历循环

字典的循环遍历——>通过循环拿出里面的键值对

dict7 = {"name": "tom", "age": "8", "gender": "女"}

a、遍历所有key

for key in dict7.keys():
    print(key)
# 结果：
name
age
gender

b、遍历所有values

for va in dict7.values():
    print(va)
# 结果：
tom
8
女

c、遍历元素->元素指数据也等于键值对

for item in dict7.items():
    print(item)
# 结果：
('name', 'tom')
('age', '8')
('gender', '女')

d、遍历键值对，一个键一个值进行拆分

for key, val in dict7.items():
    print(key)
    print(val)

for key, val in dict7.items():
    print(f"{key} = {val}")
# 结果;
name
tom
age
8
gender
女

name = tom
age = 8
gender = 女

14.5、拆包与组包

拆包与组包
将一个序列的数据拆开为多个数据这个行为叫拆包
将多个数据(值)赋给一个变量默认类型为元组，这个行为叫组包

zb = 10, 20, "sjb"
print(type(zb))
结果：
<class 'tuple'>

十五、运算符公共方法和推导式

15.1、运算符，支持容器类型

运算符，支持容器类型

# 多个变量同赋值，一一对应，
str1, str2 = "abc", "def"  # 字符串
list1, list2 = [1, 2], [3, 4]  # 列表
t1, t2 = (11, 21), (31, 41)  # tuple元组
set1, set2 = {10, 11}, {20, 21}  # 集合
dict2 = {"name": "qao", "age": 99}  # 字典

a、+: 合并，支持字符串，列表，元组

print(str1 + str2)  # 结果：abcdef
print(t1 + t2)  # 结果：报错，集合和字典不支持合并

b、*: 复制，支持字符串，列表，元组

print(t1 * 3)  # 结果：(11, 21, 11, 21, 11, 21)
print(dict2 * 4)  # 报错：集合和字典不支持复制

c、in: 元素是否存在，支持字符串，列表，元组，字典，结果返回布尔型为True和False

print("a" in str1)  # 结果：True
print("qao" in dict2)  # 结果：False

d、not in: 元素是否不存在，支持字符串，列表，元组，字典，结果返回布尔型为True和False

print("a" not in str1)  # 结果：False
print("qao" not in dict2)  # 结果：True

15.2、字典的in和not in用法

字典的in和not in用法

print("age" in dict2)  # 结果：True
print(dict2["name"] in dict2.values())  # 结果：True

公共方法

str3 = "abcd"  # 字符串
list3 = [1, 2, 4, 6, 1]  # 列表
t3 = (12, 22, 32, 42)  # tuple元组
set3 = {500, 400, 300, 200, 100}  # 集合
dict3 = {"xm": "guy", "age": 60, "id": 123456}  # 字典

15.3、字典中的函数

len():计算容器中元素个数

print(len(t3))
print(len(dict3))
# 结果：
4
3

del或del(): 删除，有根据下标删除，没有下标根据k删除

del set3  # 根据集合名称删除
print(set3)
# 结果：
列表不存在，会报错

del list3[2]  # 根据下标删除
print(list3)
# 结果：
[1, 2, 6, 1]
del(dict3["xm"])
print(dict3)
# 结果：
{'age': 60, 'id': 123456}

c、max(): 返回容器中元素最大值
d、min()：返回容器中元素最小值

print(max(str3))
print(min(str3))  # 英文大小的排序是按照字母的排序
# 结果：
d
a
print(max(set3))
print(min(set3))
# 结果：
500
100
print(max(dict3))
print(min(dict3))
# 结果：
id
age

range(start,end,step): 生成从start到end的数字，步长为step，供for循环使用
生成1到10中间的数字

for i in range(1, 11):  # 包前不包后，步长不写，默认为1
    print(i)
# 结果：
1
2
3
4
5
6
7
8
9
10

for i in range(1, 11, 2):  # 包前不包后，步长不写，默认为1,步长就是增量
    print(i)
# 结果：
1
3
5
7
9

for i in range(10):  # 代表开始不写，默认从零开始，步长为1
    print(i)
# 结果：
0
1
2
3
4
5
6
7
8
9

f、enumerate(可遍历对象): 函数用于将一个可遍历的数据对象(如列表、元组或字符串)结合为一个索引序列 ，同时列出数据和数据下标，一般用于for循环当中，用于改变序列中序列下标的起始值
for i in enumerate(list3):  # 返回的数据类型是元组，元组中第一个数字是序列中数字对应的下标，第二个数字是序列中的数字
     print(i)
# 结果：
(0, 1)
(1, 2)
(2, 6)
(3, 1)

for i in enumerate(list3, start=2):  # start设置下标的起始值
    print(i)
# 结果：
(2, 1)
(3, 2)
(4, 6)
(5, 1)

15.4、容器类型转换

list4 = [11, 22, 33, 44, 55]                     # list 列表
t4 = (10, 20, 30, 40, 50)                        # tuple 元组
s4 = {13, 23, 33, 43, 53}                        # set 集合
dict4 = {"name": "gao", "age": 34, "id": 65535}  # dict 字典

a、tuple()：将序列转换为元组

print(tuple(list4))
print(tuple(t4))
print(tuple(s4))
print(tuple(dict4))  # 将字典转换为其他序列类型时，会丢失val值
# 结果：
(11, 22, 33, 44, 55)
(10, 20, 30, 40, 50)
(33, 43, 13, 53, 23)
('name', 'age', 'id')

b、list():将序列转换成列表

print(list(list4))
print(list(t4))
print(list(s4))
print(list(dict3))  # age类型为整型，不再转换类型内，可以录入时候以字符串类型录入，然后再转化为整型
# 结果：
[11, 22, 33, 44, 55]
[10, 20, 30, 40, 50]
[33, 43, 13, 53, 23]
['age', 'id']

c、set():将序列转换为集合
注意
1、集合可以快速完成列表去重
2、集合不支持下标

print(set(list4))
print(set(t4))
print(set(s4))
print(set(dict4))
# 结果：
{33, 11, 44, 22, 55}
{40, 10, 50, 20, 30}
{33, 53, 23, 43, 13}
{'id', 'age', 'name'}

d、dict（）没有将其他类型转换为字典的函数，因为字典含有键值对，其他类型缺少键或值

print(dict(list4))
# 结果：
无法运行，退出代码为1

15.5、列表推导式

推导式作用：简化序列写法的写法
列表的推导式：用一个表达式创建一个有规律的列表或控制一个有规律列表，列表推导式又叫列表生成式

# 使用while，for，和列表推导式，创建一个1到10的列表
# while循环
i = 1
list5 = []  # 创建空列表
while i <= 10:  # 生成1到10之间的数字
    list5.append(i)  # 循环将i（生成的数值添加到空列表），append()添加函数
    i += 1
print(list5)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# for循环
list6 = []  # 创建空列表
for j in range(1, 11, 1):  # range生成1到10这几个数，步长为1
    list6.append(j)
print(list6)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 列表推导式，一般都是配合for循环使用
list7 = [d for d in range(1, 11)]
print(list7)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

15.6、带if和for的列表推导式

创建一个有1~10范围的偶数数字的列表
1、使用range步长为2去控制
2、使用if语句去控制实现：for循环后面接if加条件

list8 = [a for a in range(1, 11) if a % 2 == 0]
print(list8)
# 结果：
[2, 4, 6, 8, 10]

多个for循环实现列表推导式
实现效果[(1, 0),(1, 1),(1, 2),(2, 0),(2, 1),(2, 2)]
for循环实现
元组的数据1：1 2->range(1, 3)元组的数据2、0 1 2->range(3)

list9 = []
for i1 in range(1, 3):
    for i2 in range(3):
        list9.append((i1, i2))  # 列表中添加元组
print(list9)
# 结果：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

多个for循环实现列表推导式，格式：for循环(外) for循环(内)

list10 = [(t, b)for t in range(1, 3) for b in range(3)]
print(list10)
# 结果：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

15.7、字典和集合推导式

字典推导式->作用：快速合并列表为字典或提取字典中目标数据。
创建一个字典，字典key是1-5数字，value是这个数字的2次方

dc1 = {i3: i3 ** 2 for i3 in range(1, 6)}
print(dc1)
# 结果;
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

拼接下方两个列表成为一个字典

ls1 = ["name", "age", "gender", "id"]  # 当需要合并的两个列表长度不同，拼接时尽量以列表长度短的为准
ls2 = ["jak", 20, "man", 95279527]
dc2 = {ls1[i4]: ls2[i4] for i4 in range(len(ls1))}  # len函数，计算列表长度，range内也可以直接填0， 4（包前不包后）
print(dc2)
# 结果：
{'name': 'jak', 'age': 20, 'gender': 'man', 'id': 95279527}

提取value大于等于2000

dc3 = {"hua": 3000, "viv": 1998, "opp": 2001, "mi": 2500}
# 字典推导式
dc4 = {key: value for key, value in dc3.items() if value >= 2000}
print(dc4)
# 结果：
{'hua': 3000, 'opp': 2001, 'mi': 2500}

集合推导式
创建集合，数据是下方列表数据的2次方

lt1 = {1, 2, 3, 4, 5, 6}
set1 = {i ** 2 for i in lt1}
print(set1)
# 结果：
{1, 4, 36, 9, 16, 25}

没有元组推导式