ziwu1226

大学生精通 python+大数据学习从由浅入深（Python篇）【更新中】

看到这位头发浓密大叔了吗！1989年，为了打发圣诞节假期，龟叔(吉多·范·罗苏姆)开始写Python语言的编译器。
1991年，第一个Python编译器诞生
Python这个名字，来自龟叔所挚爱的电视剧Monty Python’s Flying Circus (蒙蒂·蟒蛇的飞行马戏团）

我们为什么要学习这一项语言，Python有以下几个优点

技术趋势：Python自带明星属性多年稳居编程语言前三
简单：Python开发代码少，阅读一个良好的Python程序就感觉像是在读英语一样，Python的这种代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。
易学：就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法，在开发同等业务下，相比C语言、java语言，Python语言开发的代码精简的多。
免费、开源：Python开源的。简单地说，你可以自由地阅读它的源代码、对它做改动、这是为什么Python如此优秀的原因之一，它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。
可移植性：由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上），所有Python程序无需修改就可以在下述任何平台上面运行。
丰富的库：Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。
解释性：Python编程语言不需要编译，直接运行

接下来我们开始我们python的学习吧！

目前，Python有两个大版本，分别是 Python2 和 Python3，我们本次教程主要为Python3大版本
Python官网：python.org

第一章

1.1 Python环境的安装

在学习一项语言之前，我们必须下载相关的安装包并配置相关环境，然而在生产环境中，我们⼀般不会选择最新版本的Python，因为可能会存在未知Bug，所以⼀般强烈建议大家在选择软件版本时，向前推1 ~ 2个版本。本节内容我们将来配置Python环境。
Python官网：python.org

①下载好Python解释器后我们可以开始安装

点击 Next

出现这个页面就完事啦！

②验证是否安装完成
调出cmd窗口命令，并输入python，若出现版本号，则成功！

1.2 用python输出“Hello，World”

作为程序员学习一项语言的例行公事，怎么能不对世界说你好呢！

1.2 Python解释器以及开发工具

前面我们下载的python其实包含了python解释器，我们在运用python时需要通过python解释器，因此要在窗口命令行输入 python，但在Python的开发领域，其开发工具非常非常多，EditPlus、Notepad++、Sublime Text3、Visual Studio Code、PyCharm（目前功能最强大的IDE）接下来我们要下载python开发工具，当下全球Pyhon开发者我使用最频繁的工具软件PyCharm继承开发工具（IDE）
Pycharm下载网站
下载配置完后市这样子的，各式各样开发工具千奇百态，选择自己喜欢的工具就行了哦，这里就不多赘述了！

1.2.1 Pycharm常用快捷键
1、代码补全：回车、换行
2、代码保存：CTRL+S
3、代码撤销、恢复：CTRL+Z、CTRL+Y

第二章

2.1 Python基础-关键字和标识符

关键字是指的是在Python语言中，已经使用的一些词语，具有特殊意义。
在创建名字时，不能创建与关键字同名！
我们可以使用keywork库进行查看Python中的关键字

# 1.导入库
import keyword

# 2. 列出关键字
print(keyword.kwlist)

Tip：代码规范快捷键：ctrl+Alt+L

标识符
标识符，相当于调用内存地址的一个映像外号。

标识符要遵守五个命名规范：

见名知意

由数字、字母、下划线组成，且开头不为数字

区分大小写

不能和关键字同名

长度没有限制，但是最好不要超过15个字符

常见的命名方法

（1）小驼峰命名法
（2）大驼峰命名法
（3）下划线来_来链接所有词语

为了给Python标识符新增一些额外的要求，常见的有

变量名/函数名/方法名：所有字母i笑傲写，且单词之间用下环线_连接

模块名：所有字母均小写；

类名：遵循大驼峰命名法

常量：都大写

2.1 Python基础-字面量

在代码中，被写下来固定的值，称之为字面量，我们在学习其他语言的时候，也学习过一些相关的数值类型，现在下面将用一个表格举例Python常见的值类型。
Python常见的值类型：

定义字符串的的时候需要用（）包裹起来

2.2 Python基础-注释

注释指的是：在程序，对代码进行解释说明的文字
首先强调一件事：Python代码 => Python解析器 => 机器语言，但是注释经过了Python的解释器并不会解析与执行。
注释对代码有解释说明，这样可以让别然可以看得懂代码的作用，增强了程序的可读性。

在Python中，注释分为两类

单行注释：对一小行代码做局部注释说明

语法:

# 内容

多行注释： 1、定义类、模块，要做多行注释，能让读者知道含义；2、定义函数:在函数名的第1行代码处做多行注释。

语法：

"""
	内容
"""

演示效果

Tip：快速注释快捷键：ctrl+/

2.3 Python基础-变量

变量就是程序在运行时，数值会改变的量，比如 a = 10;
变量的格式：变量名 = 值

注：等号的两边都要保留一个空格，其实Python中建议符号的两边尽量都要保留一个空格

2.3.1 Python基础-变量-命名规则

在Python程序中，我们可以给很多东西取名字，比如：变量的名字·、变量的方法、类的名字等，这些名字我们统一称之为标识符，用来做内容的标识
标识符在命名中，只允许出现英文、中文、数字、下划线(_)，但是不推荐使用中文

举个栗子：

① abc、abc123、_abc、hello（合理）

② 123abc、@abc、abc-123（不合理）

③ _（下划线） => 请问这可以是一个变量名称么？答：可以

for _ in range(10):
    ...

注意：在Python变量命名时，不建议使用_开头，因为其与后面要学习的私有属性会冲突

④ 变量abc和变量ABC是同一个变量么？答：不一样，这是两个完全不同的变量（不区分大小写）

2.4 Python基础-数据类型

变量的定义非常的简单，我们在学习其他编程语言的时候已经接触过一些数据类型，当然在python也不例外，为了应对不同的业务需求，也会把数据分为不同的类型，如下图所示：

面试题：请手写出Python中的7种数据类型？

答：数值类型、布尔类型、字符串类型、列表类型、元组类型、集合类型、字典类型

问题：如何判断一个变量到底是什么类型？

答：① 使用type(变量名称)方法，返回变量的数据类型 ② isinstance(变量名称,数据类型)，只能返回True或False（真的还是假的）

上述我们问题二中提到了如何获取该数据的数据类型语句：type(变量名称)

例题：

# 方式1：使用print直接输出类型信息
name = 'Tom'
age = 18
print(type(age))
name = '大白菜'
price = 3.5
print(type(price))

# 方式2：使用变量存储type（）语句的结果
string_type = type("ziwu")
print(string_type)

# 方式3：使用type（）语句，查看变量存储的数据类型信息
name = 666
name_type = type(name)
print(name_type)

2.4.1 Python基础-print输出函数

print是一个函数，用于输出信息内容

函数名	含义
print（arg）	用于在Python中，输出信息内容

另外的，如果想要让print()输出更美观些，也可以使用转义字符来处理。
转义字符，指的是无法直接表达本身含义，就需要转化含义来显示。
转义字符有：

字符	名称	含义
\n	换行符	换行
\t	制表符	缩进一个Tab键（4个空格）
\\	反斜杠	表示一个反斜杠
\"	单个双引号	表示单个双引号

若要给一个字符转义，通常要加入转义符 \

**tip:快速上下移动代码：**ctrl+shift+↑/↓

2.4.1 Python基础-数据类型-布尔类型

布尔类型的数值与逻辑相关，只有两个值：True（真）、False（假）
例如我们上文提到的isinstance(变量名称,数据类型)

num = 10
print(isinstance(num,int))  # True
print(isinstance(num,str))   # False

2.5 Python基础-数据类型转换

数据类型在特定的场景下，可以互相转换的，如字符串转数字、数字转字符串

# 将数字转字符串
num_str = str(11)
float_str = str(3.1415)
print(type(num_str),num_str)
print(type(float_str),float_str)

# 将字符串转数字
num = int("11")
num2 = float(3.14185)
print(type(num),num)
print(type(num2),num2)

万物均可以转成字符串，但是转成数字的话，必须要求字符串内的内容时数字

2.6 Python基础-运算符

所谓的算数运算符就是我们日常生活中的加减乘除等待。
①算数运算符

②赋值运算符

③复合赋值运算符

2.7 Python基础-字符串拓展-字符串格式化

目前为止，我们所有的输出都是直接通过print(变量名称)形式直接打印的。但是实际工作中，我们可能需要对变量的输出进行格式化操作（按照一定格式进行输出）。
基本语法:

...
print(变量名称)
print('字符串%格式' % (变量名称))
print('字符串%格式 %格式 %格式' % (变量名称1, 变量名称2, 	变量名称3))

荔枝：

name = "ziwu"
age= 18
print("IT大牛是%s" %(name))
print("我的名字是%s,我的年龄仅仅%d" %(name,age))

其中的，%s
% 表示：我要占位
s 表示：将变量变成字符串放入占位的地方
d 表示：将变量变成整数放入占位的地方
所以，综合起来的意思就是：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置
当多个表变量占位，变量要用括号括起来，并按照占位符顺序填入

当然不仅仅只有%s可以使用，下列表格列出了 python 中常见%格式。

2.8 Python基础-字符串拓展-字符串格式化精度控制

在%d、%f中我们可以使用辅助符号"m.n"来控制数据的宽度和精度

m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入，而整形不考虑小数位置，因此%d不考虑控制精度

示例：
%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度。
%5.2f：表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

多值一起案例：

name = "ziwu"
year = 3
money = 100000.56
print("我的名字是%s,工作%d年了，工资%.2f元了" % (name, year, money))

2.9 Python基础-字符串拓展-format方法简写形式格式化输出

format格式：

print('字符串{}'.format(变量名称1))
print('{}字符串{}'.format(变量名称1, 变量名称2))

原来的 format 格式输出比较繁琐，在Python3.6以后版本，为了简化format输出操作，引入了一个简写形式：
语法：f"内容{变量}"

name = "ziwu"
age= 18
print("IT大牛是{},年龄为{}".format(name,age))
print(f"IT大牛是{name}，年龄为{age}")

特点：

不理会类型直接插入

不做精度控

适合对精度没有要求的时候快速使用

当然，你也可以对format做精度控制：

a = 132.456
print(f"这个数字是{a:.2f}")

还有一种方法，用字符串切片的方式，我们会在第五章讲解：

a = 132.456
result = str(a)
result = result[:result.index(".")+3]
print(result)

2.10 Python基础-字符串拓展-格式化输出中的转义符号

在字符串中，如果出现了\t和\n，其代表的含义就是两个转义字符

\t ：制表符，一个tab键（4个空格）的距离
\n ：换行符

案例：

print('*\t*\t*')
print('hello\nworld')

特别说明：默认情况下，每个print()方法执行完毕后，都会输出一个\n换行符。如果不想让print()方法换行，可以添加一个end参数

print('*', end='')

2.11 Python基础-数据输入

到目前为止，我们所有的程序都只能把数据输出给用户。但是实际工作中，我们经常输入获取用户的输入信息，如银行系统中的密码输入、淘宝中的用户登录验证，以下介绍Python中怎么进行数据输入
语法：input()

也可以在input（）的括号中输入内容，寓意为在前面print一串内容

input()默认接收的都是字符串，如果想接受数据，请自行进行类型转换！

小结：
① input()可以用于接收由外部设备输入的信息，但是如果用户没有输入任何内容，则input()函数会中止当前代码的继续执行，处于等待状态，直到用户输入结束。
② 所有由input()方法获取的数据都是字符串类型，如果要使用，则要进行类型转换，下列是类型转换表。
③eval(str) 用来将已转换后的数据结果，重新转换为原始数据类型。

a = "True"
b = "3.14"
print(type(eval(a)))
print(type(eval(b)))

第三章判断

3.1 Python判断语句-布尔值和比较运算符

布尔值字面量：

True 表示真
False 表示假

定义变量存储布尔值类型数据：
变量名称 = 布尔值字面量在定义时需要注意True、False开头字母为大写

比较运算符

逻辑运算符（与或非）

not：就是取反，只有一个表达式not 表达式，如果表达式为True，则not以后就返回False。反之，则返回True。
and ：逻辑与，只有当两边的表达式全部为真，则最终结果返回为真，否则返回为假。
or ：逻辑或，只要有一方为真，则整个表达式的返回结果就为真。除非两边的表达式都为假，则整个结果返回为假。

扩展：短路运算(逻辑运算符)
在Python代码中，逻辑运算符的运算，要遵循短路运算原则。
① 表达式1 and 表达式2，如果表达式1条件为真，则最终的运算结果由右边的表达式2来决定。如果表达式1条件为假，则最终结果为假。其右边的表达式2不需要在进行运算。
② 表达式1 or 表达式2，如果表达式1为真，则最终的运算结果由表达式1来决定，为真。如果表达式1为假，则最终结果由表达式2来决定。如果表达式2为真，则最终结果为真，如果表达式2为假，则最终结果为假。

在逻辑运算中，不一定逻辑运算符的两边都是纯表达式，也可以是数值类型的数据或字符串类型的数据。
Python把0、空字符串和None看成 False，其他数值和非空字符串都看成 True，所以： 空字符串就是只有一对引号的字符串，''或""

3.2 Python判断语句-if语句的基本格式

这是java中的条件判断语句:

if (条件判断) {
    则执行某段代码...
}

但是Python中，不需要使用这么多复杂的符号，直接可以编写条件判断及执行某段代码

Python：

if 判断条件:
	(Tab缩进)条件成立时，要进行的语句
# 例题
age = 18
if age >= 18
	print("我是老八，我已过18！")

if单分支语句选择原理图：学编程除了会写代码还不行，还要回画图（流程图）

3.3 Python判断语句-if else语句的基本格式

相比3.2，此条件语句可以列举出条件不成立时执行的语句

if 要判断的条件:
	条件成立时，要进行的语句
else：
	条件不成立时执行的语句
# 例题
age = 18
if age >= 18
	print("我是老八，我已过18！")
else：
	print("我未成年")

else关键字不能单独使用，使用时要注意好格式

if…else…双分支语句结构原理图：

3.4 Python判断语句-if elif else语句的基本格式

相比3.3，此条件语句可以列举出多条件成立时执行的语句

if 要判断的条件:
	条件成立时，要进行的语句
elif 要判断的条件
	条件成立时的语句
else：
	条件不成立时执行的语句
# 例题
age = int(input("动物园门票购买，请输入你的身高"))
if age < 120:
	print("免费")
elif age >= 120:
	print("缴费60元")
else:
	print("神秘代码，系统出错")

if多分支语句多重条件判断原理图：

3.5 Python判断语句-判断语句的嵌套

if 外层条件判断:
    # 如果条件为True，则执行以下语句段
    if 内层条件判断:
        # 如果内层条件为True，则执行以下语句段
else:
    # 如果条件为False，则执行以下语句段

嵌套结构看起来异常复杂，但是我们在编写时要遵循一个原则：先编写外层判断，所有语句编写完成后，在编写内层条件判断结构。
第二个if，属于第一个if里面，只有第一个if执行成功，第二个if才开始执行
接下来写一段猜数字代码

# 构建一个随机的变量
import random
num = random.randint(1,10)

guess_num = int(input("输入你想要猜测的数据："))

# 判断语句
if guess_num == num:
    print("真厉害，一次猜中")
else:
    if guess_num > num:
        print("你猜测的数字大了")
    else:
        print("你猜测的数字小了")

    guess_num = int(input("请再次输入你想要猜测的数据："))

    if guess_num == num:
        print("第二次就猜中了，好厉害呀！")
        exit(0)
    else:
        if guess_num > num:
            print("你猜测的数字大了")
        else:
            print("你猜测的数字小了")

        guess_num = int(input("请最后输入你想要猜测的数据："))

        if guess_num == num:
            print("第三次就猜中了，好厉害呀！")
        else:
            print("没有机会了，告辞")

综合案例：剪刀石头布
参与游戏的角色有两个（玩家与电脑），玩家手工出拳，电脑随机出拳，根据石头剪刀布判断输赢。

玩家：player（玩家手工输入石头0、剪刀1、布2）

电脑：computer（随机出拳）

输赢结果很重要，有三种情况：

① 玩家赢

☆ player：石头赢 computer：剪刀

☆ player：剪刀赢 computer：布

☆ player：布赢 computer：石头

② 平局

只要player 与 computer出拳相等，就代表平局

③ 电脑赢

如果不满足以上两个条件，则电脑获胜！

未知知识点：如何让计算机随机出拳 => 随机

3.6 Python判断语句-三目运算符

1、什么是三目运算符

在Python中三目运算符也叫三元运算符，其主要作用：就是用于简化if…else…语句。

if 条件判断:
    # 语句段1
else:
    # 语句段2

转换为三目运算符

语句段1 if 条件判断 else 语句段2

第四章循环

在Python中，循环一共分为两大类：while循环与for循环

思考问题：while循环和for循环如何选择呢？

① 对于循环次数已知的情况，建议使用while循环

② 对于循环次数未知的情况，建议使用for循环
但是有了 range 关键字的加入，for循环更加精简！在后期使用时，优先推荐for循环

4.1 Python循环语句-while循环的基础

基本语法：

# ① 定义一个计数器（初始化一个计数器）
i = 0或1
# ② 编写while循环结构
while 循环条件(判断 计数器 是否达到了目标位置):
	循环体1
	循环体2
	...
	# ③ 在循环内部更新计数器
	i = i + 1 或 i += 1

# 例题
i = 0
while i < 100
	print("喵喵喵")
	i += 1

# 1~100的和
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

# 猜数字
#定义随机数
import random
num = random.randint(1,100)

input_num = int(input("请输入数字"))
count = 0
while input_num != num:
    if input_num<num:
        print("小了")
        input_num = int(input("请输入数字："))
        count += 1
    else:
        print("大了")
        input_num = int(input("请输入数字:"))
        count += 1

print(f"猜对了,你一共猜了{count}次")

while循环流程图：

4.2 Python循环语句-while循环的嵌套运用

我们运用案例来了解while的嵌套运用

# 我们小明每天表白100天，且要送10朵玫瑰
# 外层： 表白100天
# 内层： 送玫瑰花
i = 1
# 外层
while i <= 100:
    print(f"今天时第{i}天，准备表白")

    #内层
    j = 0
    while j < 10:
        print(f"送给小妹第{j}朵玫瑰花")
        j += 1

    print("小妹我喜欢你！")
    i += 1

# 九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{j}*{i}={i * j}\t", end='')
        j += 1

    i += 1
    print()

常见错误：

i = 1
result = 0
while i <= 100:
    if i % 2 == 0:
        result += i
        i += 1 ##这里语句是在 if内的，不在while外循环内
print(f'1~100之间所有偶数的和：{result}')

问题的原因：在于i += 1缩进了2次，导致其和if形成了一个整体。while循环中计数器无法更新，最终导致以上代码出现了死循环。

4.3 Python循环语句-for循环的基础语法

for循环时一种“轮询”机制，是对一批内容进行“逐个处理”！for循环也被称为遍历循环
另外当循环次数未知的情况，建议使用for循环。

for 临时变量 in 序列:
    循环满足条件时执行的代码

Python中的for寻魂与其他高级语言中的for循环用法不一致，Python中的for循环时无法定义循环条件的，只能从处理数据集中，依次取出内容进行处理

# 数字符中一共有多少个i
name = 'itziwu is brand of itcast'
flag = 0
for x in name:
    if x == 'i':
        flag += 1

print(f"式子中一共有{flag}个i")

拓展1:
for与else搭配使用：

for 零时变量 in 序列:
	循环满足条件时执行的代码
else：
	当for循环[正常]执行结束后，再执行此代码
	
# 例子
for temp in "itziwu"
	print(temp)
else:
	print("代码遍历完毕")

拓展2:
for死循环（没意义这样写）:

lists = [1,2,2,3,4]
# 使 for 循环条件的序列范围无限
for temp in lists:
	lists.append(temp)

4.4 Python循环语句-for循环-range语句、randint语句

Python2 range() 函数返回的是列表，而在Python3中 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。（由于我们还未学习面向对象，为了方便大家理解，你可以简单的将其理解为一个序列结构）

主要作用：获取一个简单的数字序列

语法1：range(num)获取一个从0开始，到num的一个数字序列，不包括num本身，例如range（5）取得的数字序列为【0，1，2，3，4】
语法2：range(num1，num2)获取一个从num1开始，到num2的一个数字序列，不包括num本身,例如range（1,5）取得的数字序列为【1，2，3，4】
语法2：range(num1，num2,step)获取一个从num1开始，到num2的一个数字序列，不包括num本身,数字之间的差值为step,例如range（1,6,2）取得的数字序列为【1，3，5】

#1~100（不包含100）的偶数有多少个
count = 0
for x in range(1,100):
    if x % 2 == 0:
        count += 1

print(f"偶数有{count}个")

range有一个口诀：只顾头不顾尾，包含头部信息，但是不包含尾部信息，如range(10)，则返回0~9之间的序列，又比如range(0, 5)代表返回0 ~ 4之间的序列。

在Python中，要使用要随机数，首先先要导入随机数 random 包

import random

random 包中产生随机数的函数:

函数	含义
randint(a,b)	返回[a,b]之间的整数，并能取值a和b，例如randint(0,5)，则取值为0 、1 、2 、3、4 、5中的一个值。

与 range 不同，括号内的两个数分别都能取到它本身

例题猜数字：

4.5 Python循环语句-for循环嵌套运用

for循环之间的嵌套与while嵌套一致

# 表白100天，每天送10朵花

for i in range(1,101):
    print(f"今天是u第{i}天！")
    for x in range(1,11):
        print(f"送第{x}只玫瑰花，妹妹我爱你")
print("表白成功")

# 九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j} * {i} = {j * i}\t",end='')
    print()

4.6 Python循环语句-循环中断continue、break

在python循环中，经常会遇到两个常见的关键词：break 与 continue , 这两个语句都是都能改变流程控制。
break：代表着终止整个循环
contiune：代表着终止当前本次循环，继续下一次循环

# 某公司，账户余额有1W元，给20名员工发工资。
# 员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
# 领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资，换下一位
# 如果工资发完了，结束发工资。
import random
money = 10000
#外循环员工
for x in range(1,21):
    if money <= 0:
        break
    else:
        point = random.randint(1, 10)
        if point < 5:
            print(f"员工{x}的绩效为{point},低于5，不发工资")
        else:
            print(f"员工{x}的绩效为{point},发工资1000元")
            money -= 1000

4.6 Python循环语句-死循环

在编程中一个无法自我停止的循环被称为”死循环“
在Python中，我们也可以使用while True来模拟死循环

while True
	print("我停不下来啦！")

第五章

5.1 字符串常用的函数

Python容器为字符串提供了很多方法变量名.函数名（参数），接下来我们分别一一分析。

字符串索引下标

如果有字符串: name = 'abcdef' ，在内存中的实际存储如下: 【要定义了变量，就会在电脑内存中开辟一块空间(内存地址值)，用于表示变量。】

例如，我们要获取name中的b和c，要怎么获取(变量名[索引])，若查看字符串的长度，可以使用如下函数：len(变量名)

# 定义
name = "abcdef"
# 取第一个和最后一个字符
print(name[0])
print(name[5])
print(name[len(name)-1])

不可变类型的内存变化：不可变类型的变量内容变化了，地址值也变化了；而可变类型无论内容变化，都用的是同一个地址值。而我们的字符串是不可变类型（id(变量名)查看地址值）

strs = "Hello"
print(id(strs))
# 2405697181680

strs2 = strs + "World"
print(id(strs))
# 2405697543664

字符串切片

字符串切片，就是将字符串一部分内容截取，同样与range()相同，左闭右开。
语法:

变量名[起始下标:结束下标(:步长)]
# 括号内容为附加，没括号内容默认步长为1

注意：选取的区间属于左闭右开型，即从“起始”位开始，到“结束”位的前一位结束(注意：不包含结束位本身)。
逆向排序：print(strs[::-1])；第一种: 循环第二种 :[::-1] 第三种:.reverse()

5.1.1 查找find(),index(),count()

所谓字符串查找的方法即是查找子串（元素）在字符串中的位置或者出现次数

语法	作用
`find(“内容”)`	检查变量中是否含有内容，如果是，则返回内容所开始的下标（索引）值，否则返回-1.稳定
`index("内容"`)	与find()方法几乎一致，但是若没找到内容则报错，不会返回值
`rfind("内容"`)	(从右往左)找子串在字符串的某个位置。
`count("内容"`)	判断内容在字符串中的总次数

srs = "hello world and itcast and itziwu and Python"
#查找字符
print(srs.find("orld"))	#输出为7
print(srs.index("orld"))	#输出为7
print(srs.count("i"))	#输出为2

5.1.2 修改replace(),split()

语法	作用
`replace(old,new[,max])`	把字符串中的旧字符(old)替换成新字符(new)，如果有第三个参数，则替换次数不超过max次
`split(sep[,num])`	通过指定分隔符对字符串进行切割，如果参数num有指定值，则仅分隔num个子字符串，分隔后的结果为列表类型的值。
`strip`	用于去除字符串中的空白字符

src = srs.replace("itziwu", "itheima")
print(srs.replace("itziwu", "itheima"))
print(src)

srr = "java#11116#6742#ziwu"
print(srr.split("#"))
# 输出结果为['java', '11116', '6742', 'ziwu']

5.1.3 居中center()

语法	作用
`变量名.center(长度，‘填充字符’)`	填充n个字符，默认用空白填充

# 定义
name = "abcdef"

print(name.center(20))
print(name.center(20, '#'))

5.1.4 大小写操作

语法	作用
`upper()`	字符串全部大写
`lower()`	字符串全部小写
`.capitalize()`	字符串首字母大写
`.swapcase()`	字符串大小写互换

name = "abcdef"
new_name = name.upper()
print(new_name)
# ABCDEF

new_name = name.lower()
print(new_name)
# abcdef

new_name = name.capitalize()
print(new_name)
# Abcdef

new_name = name.swapcase()
print(new_name)
# ABCDEF

特殊语句

语法	作用
`.title()`	用特殊字符隔开的首字母大写
`.strip()`	删除前后字符，默认是删除空格

# 定义
name = 'abc&)#de#$ffs@#dffbd'
new_name = name.title()
print(new_name)
# 输出为：Abc&)#De#$Ffs@#Dffbd

s = '  alexW%Usir  %2%  '
s9_1 = s.strip()   
#删除字符串前后的空格

print(s9_1)   
#alexW%Usir  %2%

ss = '% alexW%Usir  %2%  %%%%'
s9_2 = ss.strip('%')   
#删除字符串前后的%

print(s9_2)  
# alexW%Usir  %2%

应用例子：
在没输入数据前，或输入完数据后，屏蔽空格，大大加高用户体验！

username = input('请输入名字：').strip()
if username == '小明':
    print('你好呀 主人')

5.1.6 is系列

函数名	含义
`.isdigit`	判断字符是否由数字组成
`.isalpha`	判断字符是否由字母组成
`.isalnum`	判断字符是否字母或者数字组成
`.isspace`	判断字符串是否全为空格

5.2 Python数据容器-列表的语法定义

一种可以容纳多份数据的数据类型，每容纳的一个容器称之为一个元素，可以是任意数据类型。
语法：

# 定义变量
变量名称 = [元素1, 元素2，元素3……]	# 多个元素之间使用,分割

# 定义空列表
变量名称 = []
变量名称 = list()

# 例子
name_list = ['itziwu','itcase', 'python']
my_list = ['itziwu',666,True]
new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]

上述例子我们可以看到，数据容器内可以同时存放多个不同类型的数据，数据容器之间也可以相互嵌套！接下来我们就学习如何利用列表的下标取出数值！

列表中每个元素的下标索引从前到后，从0开始，依次递增；也可以反向取元素从-1开始，依次递减，对应元素从后向前；嵌套列表也同理，先取第一个列表，在从中取其中的元素（[0][1]）如下文例子

name_list = ['itziwu','itcase', 'python']
print(name_list[0])
# 输出结果为itziwu
print(name_list[-1])
# 输出结果为python

new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]
print(new_list[0][1])
# 输出结果为666
print(new_list[1][2])
# 输出结果为python

此外我们可以用len（）查看列表有多少函数！

lists = ["深圳大学","深圳理工大学","南方科技大学"]
print(len(lists))

遍历列表

使用while循环遍历
使用for循环遍历

lists = ["西瓜", "香蕉", "火龙果"]
# for循环
for temp in lists:
    print(temp)

# while循环
i = 0
while i < len(lists):
    print(lists[i])
    i += 1

5.2 Python数据容器-列表的常用操作

列表-增操作

语法	作用
`列表.append(元素)`	追加一个元素到尾部
`列表.extend(其他数据容器)`	将其他容器的内容取出，依次追加到尾部

new_list = ['itziwu',666,True]
new_list.append("新插入位置1")
print(new_list)
# 输出值为 ['itziwu', 666, True , '新插入位置1']

new_list = ['itziwu',666,True]
old_list = ['ziwu',888,False]
new_list.extend(old_list)
print(new_list)
# 输出值为 ['itziwu', 666, True, 'ziwu', 888, False]

插入值

语法：列表.inser(下标,元素)

new_list = ['itziwu',666,True]
new_list.insert(1,"新插入位置1")
print(new_list)
# 输出值为 ['itziwu', '新插入位置1', 666, True]

列表-删操作

语法	作用
`del 列表[下标]`	删除指定下标元素
`列表.remove(元素)`	该方法为从前到后匹配元素删除！
`列表.pop(下标)`	删除指定下标元素，默认删除最后一个（栈排序）

new_list = ['itziwu',666,True,888]
del new_list[0]
new_list.pop(1)
new_list.remove(888)
print(new_list)
# 输出值为 666

列表-改操作

语法	作用
`列表[索引]= 修改后的值`	修改指定元素在列表的下标，可以使用下标(正向、反向均可)直接进行赋值（覆盖）

new_list = ['itziwu',666,True]
new_list[1]= 888
print(new_list[1])
# 输出为 888

列表-查操作

语法	作用
`列表.index(元素)`	查找指定元素在列表的下标，如果找不到则报错ValuError
`len（列表名）`	查看长度
`元素 in 列表`	判断指定数据在某个列表序列，如果在返回True，否则返回False。

new_list = ['itziwu',666,True]
# 访问下标
index = new_list.index("itziwu")
print(index)
# 输出为" 0 "

lists = ["192.168.1.15","172.168.46.128","177.32.25.44"]
# 访问长度
print(f"现在黑名单一共：{len(lists)}")
ip = input("输入你的ip")

# 是否存在
if ip in lists:
    print("黑名单")
else:
    print("访问成功")

列表-其他操作

语法	作用
`reverse()`	将数据序列进行倒叙排序。
`sort()`	对列表进行从小到大进行排序。通过对参数reverse=True改为倒叙，即是由大到小（reverse默认值为False，且只对数值类型起效，否则会报错或者None）

例题：动态验证码：

import random

strs = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
code = ""
for temp in range(0, 6):
    index = random.randint(0, len(strs) - 1)
    text = strs[index]	# 随机抽取元素
    code += text
print(f"当前验证码为：{code}")

5.3 Python数据容器-元组

元组也与列表一样，可以存储不同类型的数据，但是与列表不同的时，元组的数据不可以修改、不可以删除、不可以添加，只可以查询。
语法:元组变量名 = (元素1,元素2,元素3,...)

元组的语法和用法都和列表类似，但元组只可以查询，所以元组能使用：变量名【索引】、index()、len()、in()

city = ("北京","天津","南京")

print(city)
#   ('北京', '天津', '南京')

print(city[0])
#   北京

print(city.index("北京"))
#   0-为北京的索引

print(len(city))
#   3-有三个元素

if "南京" in city:
    print("在")
else:
    print("否")

元组的遍历与列表一致，这里就不多赘述了

5.4 Python数据容器-字典

5.4.1 字典的基本使用

如何访问已经定义字典的值？变量名[键]，若访问不存在的键，则会报错。

函数名	含义
`变量名[键]`	字典中返回键所对应的值,访问不存在的值会报错
`.get(键(,默认值))`	返回指定键的值，若值不在字典中，则返回None；若在后填入默认值，若字典中无值，则为默认值，若有值，则输出该值

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫无间"}
print(ziwu_message["name"])

注意：

字典元素的key是唯一的，否则所对应value的值只会保留最后赋值的那一个，位置在第一个key的书写位置，且key值为不可变类型数据：字符串、数字、元组

value值可以重复

一般的定义键的类型是字符串

字典的元素所在的位置没有先后顺序之分

字典-增操作：

格式	作用
`字典名[new key]=new value`	在末尾增加一对新的值

例子：

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫无间"}
ziwu_message["number"] = "119"
print(ziwu_message)
# {'name': 'ziwu', 'age': '18', 'hobby': '永劫无间', 'number': '119'}

字典-删操作：

格式	作用
`del 字典名["key"]`	删除指定元素（key：value）
`字典名.clear()`	清空列表值

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}
del message["hobby:"]
print(message)
# {'name': 'ziwu', 'age': '18'}
message.clear()
print(message)
# {}

字典-改操作：

格式	作用
`字典名[key]=new value`	修改键对应的值

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}
message["hobby:"] = "打kun球"
print(message)
# {'name': 'ziwu', 'age': '18', 'hobby:': '打kun球'}

字典-查操作：

格式	作用
`字典名[key]`	查找键对应的值
`len()`	查看字典中”键“的个数
`keys()`	返回字典中包含所有的key的列表
`values()`	返回字典中包含所有value的列表
`item()`	返回字典中包含(key，value)元组的列表
`in \ not in`	判断key是否在字典中

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}

print(len(message))
# 3
print(message.keys())
# dict_keys(['name', 'age', 'hobby:'])
print(message.values())
# dict_values(['ziwu', '18', '打电动'])
print(message.items())
# dict_items([('name', 'ziwu'), ('age', '18'), ('hobby:', '打电动')])

字典的遍历

键（key）的遍历：直接对字典变量进行for遍历，默认遍历的是键，但代码不好阅读，我们统一以字典名.key()的方式书写！

message = {"name": "ziwu", "age": "18", "hobby:": "打电动"}

for temp in message:
	print(temp)

第六章

公共运算符

运算符	描述	支持的容器
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

# 1. 字符串
str1 = "Hello"
str2 = str1 + "WORLD"
print(str2)	# HelloWORLD
print(str1 * 3) # HelloHelloHello

# 列表
lists1 = [1, 2]
lists2 = [3, 4]
result = lists1 + lists2
print(result)	# [1, 2, 3, 4]
print(1 in result)	# True
print(100 in result)	# False

6.1 函数的基础定义

函数是组织封装好的，可以重复使用的，因此可以使用函数解决重复代码的问题。
语法：

def 函数名(参数):
    函数体
    [return 返回值]
函数名()