一、Python 安装

一、Python 应用场景

1.Web应用开发
2.自动化运维
3.科学计算
4.桌面软件
5.服务器软件
6.游戏
7.人工智能
8.数据分析

二、Python3 开发环境搭建

1、Python2

​ 在大多数Linux系统上都已经有集成好了 Python2 开发环境，不需要安装就可以执行Python代码了

①.验证 Python2 环境是否搭建好：Ctrl + Alt + t 打开终端输入命令

$ python

②.退出 Python2 环境命令：exit() 或 Ctrl+d

2、Python3

1、在 /opt 目录下创建目录

$ rm -rf ./*
$ mkdir datas
#用于存放数据
$ mkdir software
#用于存放软件包
$ mkdir app
#用于存放程序

2、安装

1.首先安装依赖
$ yum -y install openssl-devel openssl-static zlib-devel lzma tk-devel xz-devel bzip2-devel ncurses-devel gdbm-devel readline-devel sqlite-devel gcc libffi-devel 

2.下载并安装软件包	官网：www.python.org
$ tar -zxf Python-3.7.6.tgz -C /opt/app/

3.进入Python目录 执行配置文件
$ cd /opt/app/Python-3.7.6/
$ ./configure 

4.编译安装
$ make && make install

5.生成python3的软连接
$ ln -s /opt/app/Python-3.7.6/python /usr/bin/python3
#方便命令的使用

6.验证是否安装成功
$ python3	
#能够进入python3的交互式命令行代表成功。

三、Python 执行过程解析

1、解析过程

Python语言写的程序不需要编译成二进制代码。 可以直接从源代码运行程序。 在计算机内部， Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。

2、Python 解释器

① CPython：这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。CPython是使用最广的Python解释器

② IPython：IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。 CPython用>>>作为提示符， 而IPython用In [序号]:作为提示符。

③ PyPy：PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术， 对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。 绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。 如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

④ Jython：Jython是运行在Java平台上的Python解释器， 可以直接把Python代码编译成Java字节码执行。

⑤ IronPython：IronPython和Jython类似， 只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

小结：Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

四、Python 写程序

1、方式

第一种通过终端输入python或python3进入终端交互模式
第二种通过编辑器，如vim编写Python程序

2、配置 Python 解释器

在代码第一行写入执行时的 Python 解释器路径，编辑完后需要对此 Python 文件添加 ‘x’ 权限

#!/usr/bin/python      #指定 python 解释器的版本为Python2.X
# -*- coding:utf-8 -*-  #Python2.x 要指定编码，否则不支持中文，Python3不需要，默认就是utf-8编码
# coding=utf-8

二、IPython 安装

一、ipython 简介

​ IPython 是一个 python 的交互式 shell，比默认的pythonshell 好用得多，支持变量自动补全，自动缩进，支持bash shell 命令，内置了许多很有用的功能和函数。

二、IPython 安装

1.查看pip3的版本
$ pip3 -V
# pip 19.2.3 from /usr/local/lib/python3.7/site-packages/pip (python 3.7)

2.更新pip版本命令
$ pip3 install --upgrade pip 

3.安装ipython
$ pip3 install ipython
# 需要切换到root用户进行安装
# 如果报错，原因是网络不行

4.进入命令
$ ipython

5.退出
$ exit()  or  exit   or  Ctrl+d

三、Python 基础

一、注释

注释的分类：
1.单行注释：以#开头， #右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用
# 注释单行内容
2.多行注释：
‘’‘三对单引号注释多行’’’
“”“三对双引号注释多行”""

二、变量以及数据类型

变量就是用来存东西的
程序就是用来处理数据的，而变量就是用来存储数据的
变量起名要有意义

数据类型

三、标识符和关键字

1、标识符的组成

​ 标识符由字母、下划线和数字组成，且数字不能开头，且不能是关键字

标识符是区分大小写的
Andy 和 andy 
Cat 和 cat
Person 和 person 
上面两个是不同的变量

2、标识符起名规则

驼峰命名法

① 小驼峰命名法：第一个单词以小写字母开始，第二个单词往后首字母大写。比如： myName、 firstName、 lastName
② 大驼峰命名法：每一个单词的首字母都采用大写字母。比如：FirstName、 LaseName

​ 在python语言中支持下划线连接多个单词。比如：first_name 、 last_name

3、关键字

​ Python一些具有特殊功能的标识符，这就是所谓的关键字
​ 关键字，是Python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标识符

可以通过以下命令进行查看当前系统中Python的关键字，在交互模式下：

import keyword
keyword.kwlist

四、输入函数

1、Python2

① raw_input()
特点：raw_input() 接收输入的内容不论是整数型、字符型还是浮点型，它都会当成字符串类型来处理
示例：

#!/usr/bin/python
#-*-coding:utf-8-*-
passwd = raw_input("请输入密码:")
print "您刚刚输入的密码是:%s" % passwd

② input()
input() 函数与 raw_input() 类似，但其接受的输入必须是表达式（数字类型）int 和 float 类型。
示例：

>>> a = input("输入内容：")
输入内容：2
>>> b = input("输入内容：")
输入内容：3
>>> c = a+b
>>> c
5

2、Python3

python3版本中没有raw_input()函数，只有input()，并且 python3中的input与python2中的raw_input()功能一样

① 若需要计算，需要强制转换为 int 类型
示例：

In [1]: a = int(input("输入内容："))
输入内容：2

In [2]: b = int(input("输入内容："))
输入内容：3

In [3]: c = a+b

In [4]: c
Out[4]: 5

五、输出函数

① print
示例：

In [5]: a=10

In [6]: print("我今年%d岁了"%a)
我今年10岁了

In [7]: a+=1

In [8]: print("我今年%d岁了"%a)
我今年11岁了

格式化输出

格式符号	转换
%c	字符
%s	通过str() 字符串转换来格式化
%d	有符号十进制整数
%f	浮点实数

示例：

In [9]: age = 28

In [10]: name = "阿福"

In [11]: print("我的姓名是%s\n年龄是%d"%(name,age))
我的姓名是阿福
年龄是28
# 支持换行符 \n		制表符 \t

六、运算符

1、运算符

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 7
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 3
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 10
/	除	x除以y a/ b 输出结果 2， python2中是2， python3中是2.5
//	取整除	取商， 5//2得2；返回商的整数部分 9//2 输出结果 4 。
%	取余	返回除法的余数 a % b 输出结果 1
**	幂	返回x的y次幂 a**b 为5的2次方， 输出结果 25

2、赋值符

运算符	描述	实例
=	赋值运算符	把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7
+=	加法赋值运算符	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

eval 函数：可以将字符串中的表达式提取出来进行运算
示例：

In [33]: a = input("请输入内容：")
请输入内容：5+5

In [34]: type(a)
Out[34]: str

In [35]: b = eval(a)

In [36]: b
Out[36]: 10

四、Python 语法

一、if

1、运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真	如a=3,b=3则(a == b)为Ture
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真	如a=1,b=3则(a != b)为Ture
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。 Python和在Pascal等特有方式，Java和c没有，在Python3中废弃了	如a=1,b=3则(a <> b)为Ture。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立	如a=7,b=3则(a>b)为Ture
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立	如a=7,b=3则(a<b)为Ture
>=	检查左操作数的值是否大于右或等于操作数的值，如果是，则条件成立	如a=3,b=3则(a>=b)为Ture
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立	如a=3,b=3则(a<=b)为Ture

2、比较运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"——如果x为False，x and y 返回False，否则它返回y的计算值
or	x or y	布尔"或"——如果x为Ture，它返回Ture，否则它返回y的计算值
not	not x	布尔"非"——如果x为Ture，返回False，如果x为False，它返回Ture

3、随机数

import random
a = random.randint(0,5)
print(a)

二、while

Where循环的书写方式：

num = 1
while num <= 10:
	print(num)
	num += 1 

while循环注意事项：
i=i+1别忘记写,否则条件永远满足， 一直执行。
循环嵌套中，外层循环执行一次，内层循环执行一遍。

示例：打印直角三角形
i=1
while i<=5:
    j=1
    while j<=i:
        print("*",end="\t")		#这里的 end 表示不换行
        j+=1
    print()
    i+=1

结果：
*	
*	*	
*	*	*	
*	*	*	*	
*	*	*	*	*

三、for

1、for循环的格式

for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码

示例：
'''
试想如何打印以下效果：
当name = “abcdefg”
打印效果：
a
b
c
……
'''
name="abcdefg"
for i in name:
    print(i)

2、for-else循环的格式

for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
else:
循环不满足条件时执行的代码

示例：试想如何打印以下效果：
'''
当name = “abcdefg”
打印效果：
a
b
c
d
……
'''
name = ''
for x in name:
	print(x)
else:		# 这里的 else 下的内容一定会被执行一次
	print("没有数据")		

3、for-循环中的break和continue

break：遇到它跳出整个循环， 如果是循环嵌套， break在内循环，退出的是内循环。
continue：遇到它跳出本次循环， 紧接着执行下一次的循环。
如果实在嵌套循环中，break 和 continue 支队最近的一层循环起作用。
注意：break 和 continue 只能用在循环中，除此之外不能单独使用。

4、if的各种真假判断

假：					真：
if "":					if 1：
if {
   
    }:					if 2：
if []:					if -1：
if none:				if a:
if 0:
						非 0 则为真

5、range()函数的使用

函数语法
range(start, stop, step)
参数说明：
•start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5） ;
•stop: 计数到 stop 结束，但不包括 stop。例如： range（0， 5） 是[0, 1, 2, 3, 4]没有5
•step：步长，默认为1。例如： range（0， 5） 等价于 range(0, 5, 1)

示例：计算1-100的数字和
sum=0
for i in range(1,101,1):
    sum = sum + i
print(sum)
结果：5050

总结

"""
if语句总结：
if往往用来对条件是否满足进行判断

1.基本方法
if 条件：
    满足时要做的事情
    
2.满足与否执行不同的事情
if 条件：
    满足时要做的事情
else：
    不满足时要做的事情
    
3.多个条件的判断
    if 条件：
        满足条件时要做的事情
    elif 条件2：
        满足条件2时要做的事情2
    elif 条件3：
        满足条件3时要做的事情3
    else:
        条件都不满足时要做的事情
        
4.if嵌套
if 条件1：
    满足条件1时要做的事情1
    if 条件2：
        满足条件2时要做的事情2
        
while循环一般通过数值是否满足来确定循环条件
for循环一般是对能保存多个数据的变量，进行遍历

if、while、for 等其它语句可以随意组合，这样往往可以完成复杂的功能

"""

五、字符串

一、字符串

1、表现形式

a = "100"
b = "hello world"
c = 'hello world'
d = '100'
e = '18.20520'
f = """我在北京宏福"""
g = '''
<!DOCTYPE html>
<html lang=”en“>
<head>
<title>办公系统</title>
</head>
<body class="login-body">
欢迎登录办公管理系统！
</body>
</html>
'''

len 函数返回对象的长度或者个数

In [13]: a='100'

In [14]: len (a)
Out[14]: 3

组成字符串的另外一种方式：字符串会拼接，数字会相加

In [15]: a = 'zhang'
In [16]: b = 'san'
In [17]: c = a + b
In [18]: c
Out[18]: 'zhangsan'
In [19]: f = '=====' + a + b + '====='
In [20]: f
Out[20]: '=====zhangsan====='
   
In [25]: d = 1
In [26]: e = 2
In [27]: g = d + e
In [28]: g
Out[28]: 3

2、字符串的输入输出

1、输入：input

In [29]: name = input("请输入你的名字：")
请输入你的名字：

In [30]: position = input("请输入你的职业：")
请输入你的职业：

2、输出：print

In [34]: print("姓名:%s\n职业:%s"%(name,position))
姓名:
职业:

3、format 的使用语法：格式化的方式展示数据，并可以通过多种方式展示数据。

①通过位置

格式一：
In [37]: print("{0},{1}".format("张三",20))
张三,20

格式二：
In [38]: print("{},{}".format("张三",20))
张三,20
# 大括号内的数字代表下标位置，大多数下标从0开始

②通过关键字参数

In [40]: print("{name},{age}".format(name = "张三",age = 20))
张三,20

③通过映射list

In [42]: alist = [ '曹操','中国',20]		#创建列表

In [43]: print('my name is {0[0]},from {0[1]},age is {0[2]}'.format(alist))		# {}内表示第几个列表，[]内表示列表内的第几个字符串
my name is 曹操,from 中国,age is 20

4、字符串输入
在 python3 中 input 获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存

5、下标
下标索引 index 所谓"下标"，就是编号。

In [46]: name = "txbing"

In [47]: name[0]
Out[47]: 't'

In [48]: name[-1]
Out[48]: 'g'
    
In [50]: name[len(name)-1]
Out[50]: 'g'

6、切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法： [起始:结束:步长]

In [55]: name = "txbing"

In [56]: print(name[0:3:1])
txb

In [58]: print(name[3:])		# 表示从下标3到结尾
ing

In [60]: print(name[1:-1])		# -1表示字符串倒数第一个字符
xbin

In [64]: print(name[::-1])		# 逆序
gnibxt

注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)
注意：如果不写步长默认是1。步长是控制方向的，正数从左往右取，负数是从右到左取

下标和切片小结

[:] 提取从开头（默认位置0）到结尾的整个字符串
[start:] 从start 提取到结尾
[:end] 从开头提取到end - 1
[start:end] 从start 提取到end - 1
[start:end:step] 从start 提取到end - 1，每step 个字符提取一个
[::-1]逆序 

3、字符串常见函数

必须要掌握的字符串函数
find()、 rfind ()、 index ()、 rindex ()、 replace ()、 split ()、 parttion ()、 rparttion ()、splitlines ()、 startswith ()、 endswith ()、 lower ()、 upper ()

find() 从左往右查找

In [68]: mystr = 'hello world yanzilu and yanziluPython'

In [69]: mystr.find('yanzilu')
Out[69]: 12		# 字符串开头的下标位置

rfind() 从右往左查找

In [68]: mystr = 'hello world yanzilu and yanziluPython'

In [70]: mystr.rfind('yanzilu')
Out[70]: 24
    
In [71]: mystr.rfind('zhangsan')
Out[71]: -1		# 返回值为 -1 表示搜索值不存在
    
In [73]: mystr.find('yanzilu',0,len(mystr))		# 表示从开始到结尾查找，在不知道结尾多长时，可用len函数
Out[73]: 12

index () 与 find 功能差不多，只是搜索内容不存在时报错

In [74]: mystr.index('yanzilu')
Out[74]: 12

In [75]: mystr.index('zhangsan')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-75-6bc6d4c79c0e> in <module>
----> 1 mystr.index('zhangsan')

ValueError: substring not found

rindex () 从后往前搜索

In [76]: mystr.rindex('yanzilu')
Out[76]: 24

replace () 将字符串中的字符进行替换

In [77]: mystr.replace('yanzilu','zhangsan')		# 不指定替换几个时默认全部替换
Out[77]: 'hello world zhangsan and zhangsanPython'

In [78]: mystr.replace('yanzilu','zhangsan',1)		# 只替换一个
Out[78]: 'hello world zhangsan and yanziluPython'

split () 分割字符串,不包含切割者本身

In [81]: mystr.split()		#默认以空格进行分割，包含换行符\n 与 制表符\t
Out[81]: ['hello', 'world', 'yanzilu', 'and', 'yanziluPython']

In [82]: mystr.split('and')		# 以字符 and 进行分割，不包含 and
Out[82]: ['hello world yanzilu ', ' yanziluPython']

parttion () 分割字符串,包含切割者本身，默认将字符串切割为三个部分，前、切割者本身、后

In [83]: mystr.partition('and')
Out[83]: ('hello world yanzilu ', 'and', ' yanziluPython')

rparttion () 从后往前切割

In [85]: mystr.rpartition('yanzilu')
Out[85]: ('hello world yanzilu and ', 'yanzilu', 'Python')

splitlines () 按行分割

In [89]: mystr = 'hello\nworld\nyanzilu\nand\nyanziluPython'

In [90]: print(mystr)
hello
world
yanzilu
and
yanziluPytho

In [91]: mystr.splitlines()
Out[91]: ['hello', 'world', 'yanzilu', 'and', 'yanziluPython']

startswith () 检查字符串以什么内容开头，是，返回 Ture ，否， 返回 False

In [92]: mystr = 'hello world yanzilu and yanziluPython'

In [93]: mystr.startswith('hello')
Out[93]: True

In [94]: mystr.startswith('Hello')
Out[94]: False

endswith () 检查字符串以什么内容结尾，是，返回 Ture ，否， 返回 False

In [97]: mystr = 'hello world yanzilu and yanziluPython'

In [98]: mystr.endswith('Python')
Out[98]: True

In [99]: mystr.endswith('python')
Out[99]: False

lower () 将字符串中的所有字符替换为小写

In [104]: mystr.lower()
Out[104]: 'hello world yanzilu and yanzilupython'

upper () 将字符串中的所有字符替换为大写

In [100]: mystr.upper()
Out[100]: 'HELLO WORLD YANZILU AND YANZILUPYTHON'

center() 将字符串居中

In [105]: music = "那一夜我伤害了你"

In [106]: music.center(30)		# 左右各加15各空格
Out[106]: '           那一夜我伤害了你           '

lstrip() 删除左边的空格

In [112]: a = '           那一夜我伤害了你           '
  
In [114]: a.lstrip()
Out[114]: '那一夜我伤害了你           '

rstrip() 删除右边的空格

In [112]: a = '           那一夜我伤害了你           '
    
In [115]: a.rstrip()
Out[115]: '           那一夜我伤害了你'

strip() 删除所有空格

In [112]: a = '           那一夜我伤害了你           '
    
In [113]: a.strip()
Out[113]: '那一夜我伤害了你'

isspace() 如果字符串中只包含空格，是，返回 Ture ，否， 返回 False

In [116]: name = 'lisi'

In [117]: name.isspace()
Out[117]: False

In [120]: name = ' '

In [121]: name.isspace()
Out[121]: True

count() 统计字符有多少个

In [97]: mystr = 'hello world yanzilu and yanziluPython'

In [122]: mystr.count('hello')
Out[122]: 1

In [123]: mystr.count('o')
Out[123]: 3

capitalize() 将字符串的第一个字母大写，并且后面全部为小写

In [126]: mystr = 'hello world yanzilu and yanziluPython'

In [127]: mystr.capitalize()
Out[127]: 'Hello world yanzilu and yanzilupython'

title() 将每个单词的首字母大写

In [126]: mystr = 'hello world yanzilu and yanziluPython'

In [128]: mystr.title()
Out[128]: 'Hello World Yanzilu And Yanzilupython'

ljust() 将字符串移动到左边，右边填充空格

In [105]: music = "那一夜我伤害了你"

In [130]: music.ljust(30)
Out[130]: '那一夜我伤害了你                      '

rjust() 将字符串移动到右边，左边填充空格

In [105]: music = "那一夜我伤害了你"

In [131]: music.rjust(30)
Out[131]: '                      那一夜我伤害了你'

isalpha() 判断一个字符串是否为连续的字符，是，返回 Ture ，否， 返回 False。
字符只包括两种：utf-8 和 英文字母，不包含数字

In [105]: music = "那一夜我伤害了你"
In [133]: music.isalpha()
Out[133]: True

In [126]: mystr = 'hello world yanzilu and yanziluPython'
In [134]: mystr.isalpha()
Out[134]: False

isdigit() 判断是否只包含数字，是，返回 Ture ，否， 返回 False。

In [135]: A = "123"
In [136]: A.isdigit()
Out[136]: True

In [137]: A = "123abc"
In [138]: A.isdigit()
Out[138]: False

isalnum() 判断是否只包含字母数字，是，返回 Ture ，否， 返回 False。

In [137]: A = "123abc"
In [139]: A.isalnum()
Out[139]: True

In [140]: A = "123"
In [141]: A.isalnum()
Out[141]: True

六、列表及循环遍历

1、列表的格式

变量 names_list 的类型为列表
可以存字符串，数字，列表，元组，字典等

In [12]: names_list = ['刘备','曹操','孙权']

In [13]: print(names_list[0],names_list[1],names_list[2])
刘备 曹操 孙权

#使用for循环遍历列表
names_list = ['刘备','曹操','孙权',"貂蝉","吕布"]
for name in names_list:
    print(name)

#使用while循环
print("====使用while循环打印====")
i = 0
while i<len(names_list):		# len统计字符串长度
    print(names_list[i])
    i+=1

2、列表的增删改查

① 列表添加元素("增"append, extend, insert)
append可以向列表添加元素
extend将另一个集合中的元素逐一添加到列表中
insert在指定位置index前插入元素

#列表的增加
#第一种方式：使用append追加元素
names = ['刘备','曹操','孙权',"貂蝉","吕布"]
for name in names:
    print(name)

print("修改之后输出：")

temp = input("请输入要添加的姓名：")
names.append(temp)
for name in names:
    print(name)

#第二种方式：使用extend合并列表
anames = ["张三",'李四','王五']
names.extend(anames)
print(names)

#第三种，在指定位置插入 insert
print("使用insert插入输入之后：")
names.insert(0,"曹丕")
print(names)

② 删除元素("删"del, pop, remove)
del根据下标进行删除
pop删除最后一个元素
remove根据元素的值进行删除

#列表的删除
names = ['刘备','曹操','孙权',"貂蝉","吕布"]
#指定下标删除
del names[1]
print(names)

#pop删除最后一个元素
names.pop()
print(names)

#remove根据元素的值进行删除
names.remove("貂蝉")
print(names)

③ 通过下标修改元素(“改”)

#修改列表
names = ['刘备','曹操','孙权',"貂蝉","吕布"]
names[1]="我是谁"
print(names)

④ 查找元素("查"in, not in, index, count)
python中查找的常用方法为：
in（存在） ,如果存在那么结果为True，否则为False
not in（不存在），如果不存在那么结果为True，否则False
index和count
index和count与字符串中的用法相同

names = ['刘备','曹操','孙权',"貂蝉","吕布","刘备"]
print(names)

find_name = input("请输入要查找的姓名：")
if find_name in names:
    print("已经找到：%s"%find_name)
    print("%s的下标是：%s"%(find_name,names.index(find_name)))
    print("总共有%s个%s："%(names.count(find_name),find_name))
else:
    print("没有找到：%s" % find_name)

#运行结果：
['刘备', '曹操', '孙权', '貂蝉', '吕布', '刘备']
请输入要查找的姓名：貂蝉
已经找到：貂蝉
貂蝉的下标是：3
总共有1个：貂蝉

⑤ 排序(sort, reverse)
sort 方法是将 list 按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序， 由大到小。
reverse方法是将list逆置。

# sort 排序
a = [1,2,5,6,7,4,3,7,5,7,9]
a.sort()
print(a)
[1, 2, 3, 4, 5, 5, 6, 7, 7, 7, 9]

# reverse 倒叙
a.reverse()
print(a)
[9, 7, 7, 7, 6, 5, 5, 4, 3, 2, 1]

# 结合使用
a.sort(reverse=True)
print(a)
[9, 7, 7, 7, 6, 5, 5, 4, 3, 2, 1]

3、列表嵌套
类似while循环的嵌套，列表也是支持嵌套的
一个列表中的元素又是一个列表，那么这就是列表的嵌套

school_names = [['北京大学','清华大学'],['南开大学','天津大学'],['贵州大学','青海大学']]
#print(school_names[0][1])
#print(school_names[2][1])

for school in school_names:
    print(school)
    for x in school:
        print(x)

#运行结果：
['北京大学', '清华大学']
北京大学
清华大学
['南开大学', '天津大学']
南开大学
天津大学
['贵州大学', '青海大学']
贵州大学
青海大学

七、元组

元组定义：Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组和字符串都是不可变序列.

语法：定义元组语法 () 和 ,

In [1]: a = (1,)

In [2]: type(a)
Out[2]: tuple

访问元组：和列表一样

修改元组： Python中不允许修改元组的数据， 包括不能删除其中的元素。元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。但是，如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变

In [3]: a = (1,2,["b","c"])

In [4]: a[2].append("d")	# a[2]:元组 a 的下标为2的元素

In [5]: print(a)
(1, 2, ['b', 'c', 'd']

tuple函数
tuple函数的功能与list函数基本上一样的，以一个序列作为参数并把它转换为元组，如果参数是元组， 那么该参数就会被原样返回。

# 元组转列表
In [3]: a = (1,2,["b","c"])
In [6]: ab = list(a)
In [7]: type(ab)
Out[7]: list
In [8]: ab
Out[8]: [1, 2, ['b', 'c', 'd']]

# 列表转元组
In [9]: ab = tuple(a)
In [10]: ab
Out[10]: (1, 2, ['b', 'c', 'd'])
In [11]: type(ab)
Out[11]: tuple

多维列表/元祖访问 a [ ] [ ]

In [12]: a = (("刘备","刘禅"),("曹操","曹植"),("孙策","孙权"))

In [13]: a[0]
Out[13]: ('刘备', '刘禅')

In [14]: a[0][0]
Out[14]: '刘备'

元组的优点
与列表相比， 元组的优点：
① 通常将元组用于不同的数据类型，将列表用于相同（或相似）的数据类型。
② 由于元组不可变，所以遍历元组比列表要快（较小的性能提升）。
③ 元组可以用作字典的Key， 而列表不行。因为字典的Key 必须是不可变的，元组本身就是不可变的。
④ 如果数据不需要更改，将其作为元组来实现，可以确保“写保护”。

八、字典

字典定义：键值对
字典使用大括号，成对出现，以冒号分割

1、字典访问

访问不存在的键则会报错，解决方法：get()
使用get(‘key’)不存在不会报错，而且可以设置默认值，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值.

In [15]: student= {
   
    'name':'宋江', 'id':100, 'sex':'男', 'address':'中国'}
In [16]: print(student['name'])
宋江
In [17]: print(student['id1'])
-----------------------------------