Python
Python是用来编写应用程序的高级编程语言。Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、
数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用Python开发，许多功能不必从零
编写，直接使用现成的即可。
除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你
开发的代码通过很好的封装，也可以作为第三方库给别人使用。
Python适合开发哪些类型的应用呢？
首选是网络应用，包括网站、后台服务等等；
其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
另外就是把其他语言开发的程序再包装起来，方便使用。
优点:
跨平台
Python是跨平台的，它可以运行在Windows、Mac和各种Linux/Unix系统上。在Windows上写Python程
序，放到Linux上也是能够运行的。
缺点:
第一个缺点就是运行速度慢，和C程序相比非常慢，因为Python是解释型语言，你的代码在执行时会一
行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。而C程序是运行前直接编译成
CPU能执行的机器码，所以非常快。
第二个缺点就是代码不能加密。如果要发布你的Python程序，实际上就是发布源代码，这一点跟C语言
不同，C语言不用发布源代码，只需要把编译后的机器码（也就是你在Windows上常见的xxx.exe文件）
发布出去。要从机器码反推出C代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型
的语言，则必须把源码发布出去。
编程语言
编程语言：编程语言是人与计算机沟通的工具，用于编写计算机程序，作用类似“翻译官”，将人类逻辑转换为
计算机可识别的二进制指令
机器语言：直接使用二进制代码（0和1）表达指令，是计算机硬件可直接识别和执行的语言，特点是执行效率极高，
但编写难度大、可读性差。
汇编语言：使用助记符（如`MOV`、`ADD`）与机器语言指令一一对应，降低了编写难度，但仍依赖硬件架构，可移
植性较差，需通过汇编器转换为机器语言后执行。
高级语言：接近自然语言和数学逻辑的编程语言（如Python、Java、C++等），无需关注硬件细节，可读性强、开发
效率高，但需通过编译器（如C++编译为机器码）或解释器（如Python逐行解释执行）转换为机器语言才能运行。
下载安装
目前，Python有两个版本，一个是2.x版，一个是3.x版，这两个版本是不兼容的。由于3.x版越来越普及，
所以采用3.8版本，下载链接如下:
https:
下载和安装完成后，打卡CMD窗口输入python，会进入Python交互式环境中，可以输入任何Python代码，
回车后会立刻得到执行结果。
如果窗口显示：'python' is not recognized as an internal or external co│
│mmand, operable program or batch file.
则需要在环境变量中配置python.exe的位置(参考Java JDK的配置 指定一下path即可)
Python解释器
当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，
就需要Python解释器去执行.py文件。
目前python的解释器有如下几种:
1.CPython
CPython是使用最广的Python解释器。当我们从Python官方网站下载并安装好Python 3.x后，我们就直接获
得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行
python就是启动CPython解释器。
2.IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执
行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
3.PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译，
所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython
有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要
放到PyPy下执行，就需要了解PyPy和CPython的不同点。
4.Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
5.IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把
Python代码编译成.Net的字节码。
运行Python
Python交互模式的代码是输入一行，执行一行,Python交互模式主要是为了调试Python代码用的，也便于
初学者学习，它不是正式运行Python代码的环境！
命令行模式下直接运行.py文件是一次性执行该文件内的所有代码.
编写一个.py文件,内容如下:print('你好，Python')
Python输出print函数
print('张三','李四')
print('--------------')
print('张三','李四',sep='|')
print('--------------')
print('张三','李四',sep='|',end='!')
print('--------------')
输出:
张三 李四
--------------
张三|李四
--------------
张三|李四!--------------
进程已结束，退出代码为 0
`sep`参数：自定义分隔符，默认为空格。
示例：`print("Hello", "World", sep="-")`，输出结果为`Hello-World`。
`end`参数：控制输出结尾字符，默认为换行符`\n`。
示例：
`print("Hello", end="!")`；
`print("World")`，输出结果为`Hello!World`（两行内容合并为一行）。
print写入文件
a=open('1.txt','w',encoding='utf-8')
print('我想变强',file=a)
a.close();
Python输入input函数
input函数无论用户输入数字、文本还是符号，`input()`函数均返回字符串类型（str）。
示例：`age = input("请输入年龄：")`，即使输入“18”，`age`的数据类型仍为`str`。
#input()输入函数
name = input("请输入您的姓名:");
#print()输出函数
print("~~~~~~~~~~~~~~~~~~~~~\n");
print("键盘输出姓名:"+name);
address = input('请输入您的家庭地址:')
idno = input('请输入您的身份证号:')
print(f'我的家庭地址{address},我的身份证号{idno}') #f格式化占位符输出
age=int(input('请输入您的年龄'))
phone=input('请输入您的手机号')
print(f'我的年龄{age}',f'我的手机号{phone}')
Python关键字
Python内置`keyword`模块可查看当前版本关键字列表及相关信息。
***关键字严格区分大小写，例如`True`是关键字，而`true`是普通变量名；
`None`是关键字，`none`不是。
变量
`变量`是存储数据的空间
`变量名 = 变量值`
1.由字母、数字、下划线组成。
2.不能以数字开头。
3.不能使用Python内置函数名。
4.不推荐使用中文命名。
5.严格区分大小写
6.特殊字符不能命名
数据类型-整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，
例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f
表示，例如：0xff00，0xa5b4c3d2，等等。
对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写
成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
#代码展示
print(100);
print("-------");
print(-100);
print("-------");
#Python允许在数字中间以_分隔 增强可读性
print(100_00_00_00);
print("-------");
print(100000000);
输出结果:
100
-------
-100
-------
100000000
-------
100000000
注意:
Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，
例如Java对32位整数的范围限制在-2147483648-2147483647。
数据类型-浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变
的，比如，1.23x10^9和12.3x10^8是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但
是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者
12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），
而浮点数运算则可能会有四舍五入的误差。
#代码展示
print(10.5 / 2);
print(22.0 / 2);
print(6.3 / 2.0);
输出结果
5.25
11.0
3.15
注意：
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
数据类型-字符型
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种
表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，
那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
#代码展示
print('abc');
print("张三上山打老虎");
输出结果
abc
张三上山打老虎
`字符串切片`
# 0 1 2 3 4 5 6 7 正索引
# H e l l o d l
#-8-7-6-5-4-3-2-1 负索引
s1='Hello dl'
print(s1)
#从字符串s1截取出Hello
print(s1[0:5]) #正索引 从0开始（最左边） [n:m]包含n不包含m索引值
print(s1[-8:-3]) #负索引 从-1开始(最右边) [n:m]包含n不包含m索引值
数据类型-字符型（常用方法）
| 函数 | 作用 |
|---|
| replace() | 返回替换后的字符串，可将字符串中指定的子串替换成新的内容 |
| split() | 返回切割后的列表序列，能把字符串按照指定分隔符拆分，转换为列表形式 |
| join() | 用一个字符或子串合并字符串，可将多个字符串通过指定的连接符拼接成新的字符串 |
| index() | 查找给定字符的第一个匹配项的下标，能快速定位字符在字符串中的首次出现位置 |
| strip() | 移除首尾的空格和换行符或指定字符串，用于清理字符串首尾的冗余内容 |
| count() | 统计字符串内某字符串的出现次数，可统计指定子串在原字符串中出现的频次 |
| len() | 统计字符串的字符个数，注意这是内置函数，不是字符串方法，用于获取字符串长度 |
| lower() | 将字符串转换为小写，可把字符串中的大写字母全部转为小写 |
| upper() | 将字符串转换为大写，可把字符串中的小写字母全部转为大写 |
字符串格式化
# %() %s输出字符串 %d十进制整数 %f浮点数类型
name='张三'
age=18
weight=175.5
print('%s今年%d岁，体重%f斤' %(name,age,weight))
# f格式化输出
print(f'{name}今年{age}岁，体重{weight}斤')
# format()格式
print('{}今年{}岁，体重{}斤'.format(name,age,weight))
数据类型-布尔类型
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False。
在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or和not运算。
#代码展示
print(True)
print(False)
print(True and True)
print(True or False)
print(not True)
输出结果
True
False
True
True
False
整数对应：
True 等价于整数 1，
False 等价于整数 0，
支持基础数值运算（如 `True + 1 = 2`，`False * 5 = 0`）。
### 自动转换规则
非0值/非空值：非零数值（如 `10`）、非空字符串（如 `hello`）、非空列表/字典等转换为 True。
0值/空值：整数 `0`、空字符串 `""`、空列表 `[]`、空字典 `{}` 等转换为 False。
数据类型相互转换
s1=10.8
s2=int(s1) #int 向下取整
print(s2,type(s2))
print('---------------')
s3=10
s4=float(s3)
print(s4,type(s4))
print('---------------')
s5=188
s6=str(s5)
print(s6,type(s6))
print('---------------')
s7=99
print(float(s7),type(s7))
print(type(s7))
eval函数
eval函数是Python的内置函数，其核心功能是去掉字符串最外侧的引号，并将其内容当做Python语
句执行。
运算符
| 运算符 | 描述 | 实例 |
|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除（浮点数结果） | 10 / 2 输出结果为 5.0 |
| // | 整除（取整结果） | 9 // 4 输出结果为 2 |
| % | 取余（取模） | 9 % 4 输出结果为 1 |
| ** | 幂指数 | 2 ** 4 输出结果为 16 |
| () | 小括号（运算优先级） | (1 + 2) * 3 输出结果为 9 |
赋值运算符
| 运算符 | 描述 | 实例 |
|---|
| = | 赋值 | 将右侧结果赋值给左侧变量 |
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等价于 c = c ** a |
比较运算符
| 运算符 | 名称及规则 | 示例 |
|---|
| == | 等于：判断两个操作数是否相等，相等则条件为True，否则为False | 如 a=3, b=3，则 (a == b) 为 True |
| != | 不等于：判断两个操作数是否不相等，不相等则条件为True，否则为False | 如 a=1, b=3，则 (a != b) 为 True |
| > | 大于：左侧操作数大于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a > b) 为 True |
| < | 小于：左侧操作数小于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a < b) 为 False |
| >= | 大于等于：左侧操作数大于或等于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a >= b) 为 True；如 a=3, b=3，则 (a >= b) 为 True |
| <= | 小于等于：左侧操作数小于或等于右侧则条件为True，否则为False | 如 a=3, b=3，则 (a <= b) 为 True |
逻辑运算符
| 运算符 | 表达式 | 规则说明 | 示例 |
|---|
| and | x and y | 布尔“与”：若x为False，返回False；否则返回y的值。 | True and False 返回 False |
| or | x or y | 布尔“或”：若x为True，返回True；否则返回y的值。 | False or True 返回 True |
| not | not x | 布尔“非”：若x为True，返回False；若x为False，返回True。 | not True 返回 False，not False 返回 True |
IF判断语句
'''
if 条件:
执行True条件成立语句
'''
num = int(input('请输入一个正整数:'))
if num % 2 == 0:
print("您输入的是偶数")
print('-------------------------')
'''
if 条件:
执行True条件成立语句
else:
指定False条件不成立
'''
num = int(input('请输入一个正整数:'))
if num % 2 == 0:
print("您输入的是偶数")
else:
print("您输入的是奇数")
'''
if 条件1:
elif 条件2:
elif 条件3:
elif ...:
elif ...:
else:
'''
age =int(input("请输入您的年龄:"))
if age <18:
print("您还未成年")
elif age >=18 and age <30:
print("您已成年")
elif age >=30 and age <50:
print("您正值壮年")
elif age >=50 and age <60:
print("您正在老去")
else:
print("黄土马上盖过头顶")
#代码展示
age = 10;
if age > 5:
print("你的年龄超过5岁");
print("现在通知您,");
print("赶紧买票");
----------------------------
#代码展示
age = 1;
if age > 5:
print("你的年龄超过5岁");
print("现在通知您,");
print("赶紧买票");
else:
print("您的年龄没有超过5岁");
print("可以不用买票");
----------------------------
#代码展示
age = 6;
if age > 5:
print("你的年龄超过5岁");
elif age > 6:
print("您的年龄超过6岁");
elif age > 7:
print("您的年龄超过7岁");
else:
print("未知年龄");
输出结果:
你的年龄超过5岁
注意:
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略
掉剩下的elif和else。
if判断条件还可以简写，只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
#代码展示
x = 1;
if x:
print("摇摇晃晃");
三目运算符
num1=10
num2=20
max = num1 if num1>num2 else num2
print(f'最大值为:{max}')
Pass
`pass`是Python中的关键字，作为空语句占位符，用于语法结构中确保代码完整且不报错，本身无实际功能。
序列
序列是用于存储多个值的连续空间，每个值对应一个唯一整数(索引)。
s='Hello World'
print(s[0:5:2]) #索引从0开始，到5结束（不包含5），步长2
print(s[:5:2]) #省略开始位置，start默认从0开始
print(s[0::1]) #省略结束位置，默认到最后一个元素
print(s[5::]) #省略结束位置和步长
print(s[::2]) #省略开始和结束位置，步长2
| 操作符/函数 | 描述说明 |
|---|
| x in s | 若x是s的元素，返回True，否则False |
| x not in s | 若x不是s的元素，返回True，否则False |
| len(s) | 返回序列s的长度（元素个数） |
| max(s) | 返回序列s中的最大元素 |
| min(s) | 返回序列s中的最小元素 |
| s.index(x) | 返回序列s中第一次出现x的位置（索引） |
| s.count(x) | 返回序列s中元素x出现的次数 |
数据类型-空值
空值是Python里一个特殊的值，用None表示。
None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
#代码展示
print(None)
输出结果
None
转义字符
| 转义字符 | 作用 |
|---|
| \n | 代表换行符（键盘的Enter键） |
| \t | 代表制表符（键盘的Tab键） |
| \ | 代表反斜杠（\） |
| \r | 代表返回后面的字符串 |
| \b | 代表退格 |
转义字符\可以转义很多字符。
print('hello\nworld')#\n 代表换行符（键盘的Enter键）
print('------------')
print('hello\tworld')#\t 代表制表符（键盘的Tab键）
print('------------')
print('hello\world')#\ 代表反斜杠（\）
print('------------')
print('hello\rworld')#\r 代表返回后面的字符串 只返回world
print('------------')
print('hello\bworld')#\b 代表退格 相当于删除前面一个字符
print('------------')
print(r'hello\bworld')#r或R 表示关闭转移字符
print(R'hello\bworld')#
强制不转义
Python还允许用r''|r""表示''|""内部的字符串默认不转义
#代码展示
print(r'\'\'\'\'\'\'\'\'\'');
print(r"\"\"\"\"\"\"");
print(r"\n")
print(r"制表符")
print(r"\t")
#输出结果
\'\'\'\'\'\'\'\'\'
\"\"\"\"\"\"
\n
制表符
\t
格式化多行内容
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''XXX'''的格式表示多
行内容。
#代码展示
print('''
你好，Python
大数据学习
未来可期
~~~~~~
''');
输入结果：
你好，Python
大数据学习
未来可期
~~~~~~
变量
变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可
以是任意数据类型。
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
，比如：
#代码展示
a = 123;
print("整数变量:");
print(a);
a = "张三";
print("字符串变量:");
print(a);
a = True;
print("布尔值变量");
print(a);
输出结果
整数变量:
123
字符串变量:
张三
布尔值变量
True
注意：
这种变量本身类型不固定的语言称之为动态语言。
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名
表示常量：
PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表
示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。
#代码展示
PI = 3.14159265359;
print("PI的值:");
print(PI);
PI = 9999;
print("PI的值发生变化:")
print(PI)
输出结果
PI的值:
3.14159265359
PI的值发生变化:
9999
除法运算
在Python中，有两种除法，一种除法是：/
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
#代码展示
print(10 / 2);
输出结果
5.0
-------------------------------------------------------------
还有一种除法是：
称为地板除，两个整数的除法仍然是整数：
#代码展示
print(10
print(10
输出结果
5
3
注意：整数的地板除永远是整数,因为地板除只取结果的整数部分。
Python字符串
在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
#代码展示
v1 = ord('张');
print(v1);
print('\n');
print(chr(65));
输出结果
24352
A
bytes类型
Python对bytes类型的数据用带b前缀的单引号或双引号表示:
x = b'ABC'
以Unicode表示的str通过encode()方法可以编码为指定的bytes
v1 = '中文'.encode('UTF-8');
print(v1);
v2 = 'bca'.encode('ASCII');
print(v2);
输出结果
b'\xe4\xb8\xad\xe6\x96\x87'
b'bca'
注意:
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，
就需要用decode()方法：
#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87';
print(v1.decode('UTF-8'));
v2 = b'bca';
print(v2.decode('ASCII'));
输出结果
中文
bca
注意：
如果bytes中包含无法解码的字节，decode()方法会报错
Traceback (most recent call last):
File "E:\2021-11-12-python\project01\com\ldd\main\main.py", line 3, in <module>
print(v1.decode('UTF-8'));
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x88 in position 6: invalid start byte
如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节
#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87\x88';
print(v1.decode('UTF-8',errors='ignore'));
中文
len()函数
要计算str包含多少个字符，可以用len()函数：
#代码展示
v1 = "张三坐错车";
print(len(v1));
输出结果
5
-------------------------------------------------------
len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
v1 = "张三坐错车".encode('UTF-8');
print(len(v1));
输出结果
15
格式化占位符
最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是
xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的
方式。
#代码展示
v1 = 'Hello %s' % 'World';
print(v1);
v2 = '%s同学,在%s，打卡出校门' % ('张三','2021-10-10 12:12:12');
print(v2);
输出结果：
Hello World
张三同学,在2021-10-10 12:12:12，打卡出校门
----------------------------------------------
#代码展示
v1 = 'Age: %s. Gender: %s' % (25,True);
print(v1);
输出结果：
Age: 25. Gender: True
注意：%s它会把任何数据类型转换为字符串
----------------------------------------------
#代码展示
v1 = '%%' % ();
print(v1);
输出结果：
%
注意: 格式化字符串 用%%来表示一个%
format函数使用
格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……
#代码展示
v1 = '{0}同学，最近在{1}口吐狂言'.format("张三","东营路");
print(v1);
输出结果：
张三同学，最近在东营路口吐狂言
List操作
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
#代码展示
nameList = ['张三','李四','王五'];
print(nameList);
print(len(nameList));
print("-----------");
print(nameList[0]);
print(nameList[1]);
print(nameList[2]);
print("-----------");
print(len(nameList)-1);
输出结果:
['张三', '李四', '王五']
3
-----------
张三
李四
王五
-----------
2
#list创建 list里面的元素可以是任意类型
list1=['a','b','c']
print(list1)
print('-----------')
#使用内置函数list()创建
list2=list('qwer')
print(list2)
print('-----------')
list3=[1,'张三',2.5]
print(list3)
print('-----------')
del list3
print(list3) #报错 因为list3已经被删除
1.list是一个可变的有序表，所以，可以往list中追加元素到末尾。
#代码展示
nameList = ['张三','李四','王五'];
nameList.append("马六");
nameList.append("牛七")
print(nameList);
输出结果：
['张三', '李四', '王五', '马六', '牛七']
2.insert把元素插入到指定的位置
#代码展示
nameList = ['张三','李四','王五'];
nameList.insert(0,"爸一");
nameList.insert(1,"爸二");
print(nameList);
输出结果：
['爸一', '爸二', '张三', '李四', '王五']
3.remove操作
3.要删除list末尾的元素，用pop()方法,要删除指定位置的元素，用pop(i)方法，其中i是索引位置
#代码展示
nameList = ['张三','李四','王五'];
nameList.pop();
print(nameList);
print("-----------");
nameList.pop(0);
print(nameList);
输出结果:
['张三', '李四']
-----------
['李四']
4.list其他操作
#代码展示
nameList = ['张三','李四','王五'];
#要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
nameList[0] = "张子墨";
print(nameList);
print("----------");
#list里面的元素的数据类型也可以不同
varList = ["Hello",100,True,False,200.20];
print(varList);
print("----------");
#list元素也可以是另一个list
allList = ["Hello",["张三",100,True,["张思",200,False]],"World"];
print(allList);
#获取allList
#allList[1]里面第一个数组,allList[1][3]第一个数组里面的数组,allList[1][3][0]张思
print(allList[1][3][0]);
输出结果:
['张子墨', '李四', '王五']
----------
['Hello', 100, True, False, 200.2]
----------
['Hello', ['张三', 100, True, ['张思', 200, False]], 'World']
张思
#代码展示
nullList = [];
#如果一个list中一个元素也没有，就是一个空的list，它的长度为0
print(nullList);
print(len(nullList));
输出结果:
[]
0
5.list其他操作
list1=['a','b','c','a']
list1.remove('a')#移除第一个匹配到的元素
print(list1)
print("--------------")
list1=['a','b','c','a']
del list1[1] #del删除list1索引为1的元素
print(list1)
print("--------------")
list1=['a','b','c','a']
n=list1.index('c') #返回第一个匹配元素的索引值
print(n)
print("--------------")
list1=['a','b','c','a']
count=list1.count('a') #统计元素a出现的次数
print(count)
print("--------------")
list1=[1,3,8,3,6,5,6,7,7]
list1.sort()#升序排序
print(list1)
print("--------------")
list1.sort(reverse=True)#倒序排序
print(list1)
tuple
tuple有序列表叫元组,tuple和list非常类似，但是tuple一旦初始化就不能修改。
它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的。
#代码展示
nameTuple = ("张三","李四","王五");
print(nameTuple);
print(nameTuple[0]);
print(nameTuple[1]);
print("-----------");
输出结果:
('张三', '李四', '王五')
张三
李四
-----------
#定义一个空的tuple，可以写成()
varTuple = ();
print(varTuple);
print("-----------");
输出结果:
()
-----------
#定义只有一个元素的tuple
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产
生了歧义。
#oneTuple = (1);#因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
#定义一个元素的元组，必须加上`,`
oneTuple = (1,);
print(oneTuple);
print(len(oneTuple));
print(oneTuple[0]);
输出结果:
(1,)
1
1
注意：tuple的不可变表示tuple内部元素指向不可变。比如说tuple里面存入的是一个list，你不能把这个
list变成字符串或者数据，但是list内部中的元素可以发生改变(懒的写案例了)
int()函数
#代码展示
x = "123";
print(x);
#int()函数，将字符串转成int
print(int(x));
for in循环遍历
#代码展示
nameList = ["张三","李四","王五"];
for name in nameList:
print("name:"+name);
#range(10) 产生从0开始 小于10的整数序列 0~9
#list()函数将整数序列，转换成list
numberList = list(range(10));
numSum = 0;
for num in numberList:
numSum +=num;
print("0~9数值总和是:"+str(numSum));
输出结果:
name:张三
name:李四
name:王五
0~9数值总和是:45
str1 = 'Python'
for s in str1:
print(s)
print('----------')
输出:
P
y
t
h
o
n
----------
range函数
#range(10) 生成0-5的数字（不包含5）
num = range(5)
print(num)
for n in num:
print(n)
print('---------------------')
#range(1,5) 生成1-5的数字（不包含5）
num2 = range(1,5)
print(num2)
for n in num2:
print(n)
print('---------------------')
#range(0,5,2) 生成0-5的数字,每次递增+2（不包含5）
num3 = range(0,5,2)
print(num3)
for n in num3:
print(n)
print('---------------------')
while循环遍历
#代码展示
num = 99;
sum = 0;
while num >0:
sum +=num;
num -=2;
print(sum);
输出结果:
2500
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
if num == 97:
break
sum +=num;
num -=2;
print(sum)
输出结果：
99
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
if num % 2 ==0:
continue
sum +=num;
num -=2;
print(sum)
输出结果：
2500
dict数据结构
1.Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值
（key-value）存储，具有极快的查找速度。
2.dict在内部可以直接计算出key对应存放value的“页码”，所以速度非常快。这种key-value存储方式，
在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。
dict有以下几个特点：
1.查找和插入的速度极快，不会随着key的增加而变慢。
2.需要占用大量的内存，内存浪费多。
3.dict的key必须是不可变对象。
4.这个通过key计算位置的算法称为哈希算法（Hash）。
5.在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。
#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
print(dictMap);
print(dictMap.get("name"));
print(dictMap.get("hobby"));
输出结果:
{'name': '张三', 'age': 18, 'hobby': ['篮球', '游戏', '吉他']}
张三
['篮球', '游戏', '吉他']
#把数据放入dict的方法，除了初始化时，还可以通过key放入
dictMap["name"] = "李四";
print(dictMap["name"]);
输出结果:
李四
#由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
dictMap["name"] = "王五";
dictMap["name"] = "马六";
print(dictMap.get("name"));
输出结果:
马六
#通过dict()函数来创建
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
#通用两个列表来创建dict字典
keys=['name','age','address']
values=['汤米',18,'麻吉岛长春大道19号']
dict1=dict(zip(keys,values))
print(dict1)
输出结果:
{'name': '汤米', 'age': 18, 'address': '麻吉岛长春大道19号'}
#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
#通过in判断key是否存在
print("name" in dictMap);
输出结果:
True
#通过dict提供的get()方法，如果key不存在，可以返回None或者自己指定的value
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
print(dictMap.get("hello"));
print(dictMap.get("hello","key不存在"));
dictMap.pop("name");#要删除一个key，用pop(key)方法，对应的value也会从dict中删除
print(dictMap.get("name"));
输出结果:
None
key不存在
None
#通过key给dict数据结构存入元素
dict1=dict()
dict1['name']='张三'
dict1['age']=18
print(dict1)
输出结果:
{'name': '张三', 'age': 18}
#del 删除元素
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
print('---------')
del dict1['city']
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
---------
{'name': '张三', 'age': 18}
#update 更新字典元素
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
print('---------')
dict1.update({'name':'李四'})
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
---------
{'name': '李四', 'age': 18, 'city': '中国'}
Set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
#代码展示
#重复元素在set中自动被过滤
#显示的顺序也不表示set是有序的
nameSet = set(["张三","李四","张三"]);
print(nameSet);
print("--------------");
nameSet.add("王五");
nameSet.add("赵六");
nameSet.add("赵六");
print(nameSet);
print("--------------");
nameSet.remove("张三");
print(nameSet);
输出结果:
{'张三', '李四'}
--------------
{'王五', '张三', '李四', '赵六'}
--------------
{'王五', '李四', '赵六'}
#代码展示
nameOneSet = set(["张三","李四","张三"]);
nameTwoSet = set(["赵六","李四","马飞飞"]);
#set做交集
print(nameOneSet & nameTwoSet);
print("---------------------");
#set做并集
print(nameOneSet | nameTwoSet);
输出结果:
{'李四'}
---------------------
{'赵六', '马飞飞', '张三', '李四'}
内置函数
#代码展示
#常用内置函数
#绝对值
print(abs(100));
print(abs(-30));
#最大值
print(max(100,200,300,400,500));
#数据类型转换
print(int("123"));
print(float("12.34"));
print(str("1.34"));
print(bool(1));
print(bool(0));
print(bool(''));
输出结果:
100
30
500
123
12.34
1.34
True
False
False
自定义函数
| 要素名称 | 作用描述 |
|---|
| 函数声明：def关键字 | 使用def关键字创建函数，是函数定义的起始标识，用于告知Python解释器此处为函数定义。 |
| 函数名 | 紧跟def关键字的名称，需符合Python命名规范，用于后续通过函数名调用函数，是函数的唯一标识。 |
| 参数列表 | 函数名后括号内可定义零个或多个参数，用于接收外部传递给函数的值，实现数据输入，是传递数据的入口。 |
| 函数体 | 由冒号后缩进的代码组成，包含执行特定任务的语句，是函数功能实现的核心部分。 |
| 返回值 | 通过return语句返回值给调用者，若无return语句，函数隐式返回None，用于传递函数执行结果。 |
#定义自定义函数
def showModd(name):
return name+"心情贼差劲";
print(showModd("大马猴"));
print("---------");
#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return;
def noneReturn():
return;
print(noneReturn());
print("---------");
#定义一个空函数，实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个
pass，让代码能运行起来。
def nop():
pass;
print(nop());
输出结果:
大马猴心情贼差劲
---------
None
---------
None
isinstance类型判断函数
num = "123";
if not isinstance(num,(int,float)):
print("num类型不属于int或float");
else:
print("num类型属于int或float");
输出结果：
num类型不属于int或float
自定义函数-返回多个值
def mostParam():
return "张三",123,["李四","王五"];
x,y,z = mostParam();
print(x);
print(y);
print(z);
print("----------");
print(mostParam());
print(mostParam()[0]);
print(mostParam()[1]);
输出结果:
张三
123
['李四', '王五']
----------
('张三', 123, ['李四', '王五'])
张三
123
注意:Python函数返回的仍然是单一值，这种多参数的返回，其实是返回一个tuple类型，按位置赋给对应的值。
定义函数-默认参数
#定义函数 y默认值为3
def defaultParam(x,y=3):
return x * y;
#defaultParam(2),未传入参数y,将会使用默认值。
print(defaultParam(2));
print("--------------");
print(defaultParam(2,3));
#指定参数名称传递默认参数
def defaultMoreParam(name,age=18,city="北京",sex="男"):
print("姓名:"+name+",年龄:"+str(age)+",城市:"+city+",性别:"+sex);
#city使用传递的值，age,sex使用默认值 (这种通过参数名指定的方式，不用考虑默认参数的位置)
defaultMoreParam("张三",city='西安');
输出结果:
6
--------------
6
姓名:张三,年龄:18,城市:西安,性别:男
def defaultParam(list = []):
list.append("end");
return list;
print(defaultParam([1,2,3]));
print("-------------------");
#注意：因为默认参数list也是一个变量，它指向对象[]，每次调用该函数，如果改变了list的内容，则下次
调用时，默认参数的内容就变了，不再是函数定义时的[]了。
print(defaultParam());
print(defaultParam());
print(defaultParam());
输出结果:
[1, 2, 3, 'end']
-------------------
['end']
['end', 'end']
['end', 'end', 'end']
Process finished with exit code 0
修正-----------------------------------------
用None这个不变对象来实现
#定义函数 y默认值为3
def defaultParam(list = None):
if list is None:
list = [];
list.append("end");
return list;
print(defaultParam([1,2,3]));
print("-------------------");
print(defaultParam());
print(defaultParam());
print(defaultParam());
输出结果:
[1, 2, 3, 'end']
-------------------
['end']
['end']
['end']
Process finished with exit code 0
定义函数-可变参数
def dynamicVariable(*numbers):
for num in numbers:
print("num的值:"+str(num));
return;
#调用
dynamicVariable(1,2,3,4,"张三","李四");
print("--------------");
#如果已经有一个list或者tuple，要调用一个可变参数,在list或tuple前面加一个*号，把list或tuple的元
素变成可变参数传进去。
numList = [100,200,300];
dynamicVariable(*numList);
print("--------------");
#没有加*相当于单个参数
dynamicVariable(numList);
输出结果:
num的值:1
num的值:2
num的值:3
num的值:4
num的值:张三
num的值:李四
--------------
num的值:100
num的值:200
num的值:300
--------------
num的值:[100, 200, 300]
定义函数-关键字参数
1.关键字参数允许你传入0个或任意个参数名的参数，这些关键字参数在函数内部会自动组装为一个dict。
def dictParam(name,age,**key):
print("name:",name,"age:",str(age),"key",key);
return ;
dictParam("张三",18);
print("----------");
dictParam("李四",28,city="西安");
print("----------");
dictParam("李四",28,city="北京",hobby="篮球,跑步");
print("----------");
dictMap = {"city":"上海"};
dictParam("李四",28,city=dictMap.get("city"));
print("----------");
dictMapTwo = {"city":"成都","drinks":"小酒"};
dictParam("李四",28,**dictMapTwo);
输出结果:
name: 张三 age: 18 key {}
----------
name: 李四 age: 28 key {'city': '西安'}
----------
name: 李四 age: 28 key {'city': '北京', 'hobby': '篮球,跑步'}
----------
name: 李四 age: 28 key {'city': '上海'}
----------
name: 李四 age: 28 key {'city': '成都', 'drinks': '小酒'}
注意:最后一个案例，**dictMapTwo表示把dictMapTwo这个dict的所有key-value用关键字参数传入到函数
的**key参数，key将获得一个dict，注意key获得的dict是dictMapTwo的一份拷贝，对key的改动不会影响
到函数外的dictMapTwo。
