1、pycharm的常用配置

1.1修改主题配置

• 1、点击菜单file,选择settings选项
• 2、选择editor，点击color scheme配色方案
• 3、在右侧选择对应的主题配置

1.2修改背景颜色

• 1、点击菜单file,选择settings选项
• 2、选择appearance，点击Theme

1.3调整字体大小

• 1、点击菜单file,选择settings选项
• 2、选择editor，点击font
• 3、右侧可以调整字体的大小以及样式，样式建议选择consolas

 1.4pycharm软件的配置目录

1.5设置解释器

 1.6 因没有配置python解释器报错

2、python代码中的三种波浪线和PEP8

2.1红色波浪线

红色波浪线是代码错误，必须处理，代码才能执行；

如果代码没有写完时也会出现红色波浪线；

2.2灰色波浪线

灰色波浪线不影响代码的正常执行，可以使用快捷键ctrl+Alt+L进行消除，或者点击code->reformat code；

符合PEP8就不会展示灰色波浪线；

补充：ctrl+alt+L这个快捷键如果和其他软件冲突，可以进行修改；

2.3绿色波浪线

绿色波浪线不影响代码的正常运行，在引号中，认为你书写的内容不是一个单词，就会给个绿色波浪线提示；

3、python代码运行方式

3.1在cmd终端中运行python代码

python 代码文件中的名字

三种在cmd运行方式

(1). windows+R，输入cmd进入到dos命令窗口中，书写python 代码文件中的名字；

(2). 找到代码所在文件，在路径栏中输入cmd进入到dos命令窗口中，书写python 代码文件的名字；

(3).在pycharm中找到 Terminal,输入python 代码文件中的名字

4、变量

4.1变量的作用

是用来存储数据的（在程序代码中出现的数据，想要保存下来使用，就必须使用变量），如：测试数据，用户名，密码，验证码；

变量注意实现：变量必须先定义（保存数据）后使用（取出数据）；

4.2定义变量

变量名 = 数据值     #可以理解为是将数据值保存到变量中

#比如：

name = '张三'         #定义一个变量 name,存储的数据值是 张三

4.3使用变量

变量定义之后，想要是使用变量中的数据，直接使用变量名即可

#使用变量获取数据，打印

print(name)

4.4代码书写

4.5 变量命名的规范

标识符命名规则是python中定义各种变量名或其他名字的时候的统一规范，具体如下：

• 由数字、字母、下划线组成
• 不能使用数字开头
• 不能使用python内置关键字
• 严格区分大小写
• 建议性的命名
  • 驼峰命名法
    • 大驼峰：每个单词的首字母大写 MyName
    • 小驼峰：第一个单词的首字母小写，其余单词的首字母大写 myName
  • 下划线连接法：每个单词之间使用下划线连接my_name

  • python  中的变量的定义使用的是 下划线连接

  • 见名知意
    • name 姓名 age 年龄 height身高......

python中的关键字：

5、常见数据类型分类

将生活常见的数据划分为不同的类型，因为不同的类型可以进行的操作是不一样的，数字需要加减乘除，文字不需要.....

• 数字类型
  • 整型（int）：就是整数，即不带小数点的数
  • 浮点型（float）：就是小数
  • 布尔类型（bool）：只有两个值
    • 真 True，1
    • 假 False 0,非0即真

    • True和False都是python中的关键字，注意大小写，不要写错了

  • 复数类型3+4i,不会用的
• 非数字类型
  • 字符串：（str）使用引号引起来的就是字符串
  • 列表（list）[1,2,3,4]
  • 元组（tuple）(1,2,3,4)
  • 字典（dict）{"name":"小明","age":18}
• type()函数

  • 可以获取变量的数据类型
    type(变量）
    想要将这个变量的类型在控制台显示，需要使用print输出
    print(type(变量))

6、输入和输出

6.1输入

获取用户使用键盘录入的内容
使用的函数是input()
1.代码从上到下执行，遇到input函数之后，会暂停执行，等待用户的输入，如果不输入会一直等待
2.在输入的过程中，遇到回车，代表本次输入结束
3.会将你输入的内容 保存到等号左边的变量中，并且 变量的数据类型 一定是str

6.2输出

基本输出

输出使用的函数是print()函数，作用，将程序中的数据或者结果打印到控制台（屏幕）
print('hello world')
name = '小明'
print(name)
age = 18
print(name,age)     #可以使用逗号输出多个内容

格式化输出

在字符串中指定的位置，输出变量中存储的值
1、在需要使用变量的地方，使用特殊符号占位
2、使用变量填充占位的数据

• %格式化输出占位符
  • %d 占位，填充 整型数据 digit
  • %f 占位，填充 浮点型数据 float
  • %s 占位，填充 字符串数据 string

name = '小明'
age = 18
height = 1.68
print('我的名字是%s,年龄%d岁，身高%f m'% (name,age,height))
# 小数的默认是6位，可以使用%.nf,n来控制位数
print('我的名字是%s,年龄%d岁，身高%.1f m'% (name,age,height))
# 如果想打印学号00001，可以使用%0nd，n来控制有几个0
xuehao = 1
print('学号：',xuehao)
print('学号是：%06d'%xuehao)
#如果想要打印及格率，可以使用%%来输出%
sum = 90
print("及格率是：%d%%"%sum)

F-string（f字符串的格式化方法）

f-string 格式化的方法，想要使用，python的版本>=3.6
1、需要在字符串的前边加上f""或者F""
2、占位符号统一变为{}
3、需要填充的变量写在{}中

name = '小明'  #姓名
age = 18       #年龄
height = 1.68  #身高
xuehao = 1     #学号
sum = 90       #及格率print(f'我的名字是{name},年龄{age}岁，身高{height}m,学号{xuehao},及格率是{sum}%')
# 换行展示
print(f'我的名字是{name},年龄{age}岁，\n身高{height}m,学号{xuehao},及格率是{sum}%')
print(f'我的名字是{name},年龄{age}岁，身高{height:.3f}m,学号{xuehao:06d},及格率是{sum}%')

字符串.format()

• 1、在需要使用变量的地方用{}占位
• 2、‘{},{},{},...’.format（变量，变量，变量，...）

name = '小明'
age = 18
height = 1.68
xuehao = 1
sum = 90
print('我的名字是{},年龄{}岁，身高{}m,学号{},及格率是{}%'.format(name,age,height,xuehao,sum))
print('我的名字是{},年龄{}岁，身高{:.6f}m,学号{:06d},及格率是{}%'.format(name,age,height,xuehao,sum))

7、类型转换

语法：

变量 = 要转换为的类型（原数据）
1、数据原来是什么类型
2、你要转换为什么类型注意点：数据类型转换，不会改变原来的数据的类型，会生成一个新的数据类型

• int（）将其他类型转换为整型
  • 1、 将float类型转换为整型
  • 2、将整数类型的字符串转换为整型 ，若'3.12'会报错
• float()将其他类型转换为浮点型
  • 1、可以将int类型转换为浮点型
  • 2、可以将数字类型的字符串（整数类型字符串或者小数类型字符串）转换为浮点型
• str()将其他类型转换为字符串类型
  • 1、任何类型都可以使用str()转换为字符串类型，一般都是加上引号

8、快捷键（小操作）

添加引号括号：可以直接选中要添加引号或者括号的内容，书写即可撤销：ctrl+z
删除一行：ctrl+x
复制粘贴一行：ctrl+d快速在代码下方，新建一行：shift+回车

9、运算符介绍

9.1 运算符的作用

• 计算机可以完成的运算分为很多种，不仅仅限于加减乘除
• 不同类型的运算需要依赖不同的符号
• 运算符可以让计算机认识并处理对应的计算逻辑

9.2 运算符的分类

• 算术运算符：完全常规数字运算
• 比较运算符：完成二个值的大小比较运算
• 逻辑运算符：常用业务直之间的逻辑判断
• 赋值运算符：将运算符右侧的值，赋值给左侧容器

9.3运算符的使用

9.4 比较运算符：

比较运算符的使用

9.5 逻辑运算符：

 9.6 赋值运算符

算术运算符的优先级大于比较运算符优先级大于逻辑运算符

书写时可以使用()来区分优先级；

10、if的语法

10.1 if的基本使用

1、if是一个关键字，和后续的判断条件之间需要一个空格
2、判断条件后边需要一个冒号，不要少了
3、冒号之后，回车，代码需要缩进，在pc中会自动缩进，一般是4个空格，或者一个tab键
4、所有在if代码下方的缩进中书写的代码，属于if语句的代码块，判断条件为true的时候会执行
5、if 代码块中的代码，要么都会执行，要么都不执行
6、if代码块结束之后，代码要顶格书写，表示和if无关的代码

10.2 if和else的基本使用

1、else是关键字，后边需要冒号
2、冒号之后回车，同样需要缩进
3、if 和 else 的代码块代码块，只会执行其中一个
4、else需要结合if 使用

 10.3 if elif else的基本使用

if 判断条件1：判断条件1成立，执行的代码
elif 判断条件2：#只有判断条件1不成立，才会判断 判断条件2判断条件2成立执行的代码
else:以上条件都不成立，执行的代码1、elif 也是关键字，后边和判断条件之间需要一个空格，判断条件之后需要冒号
2、冒号之后回车需要缩进，处在这个缩进中的代码表示是elif 的代码块
3、在一个if判断中，可以有很多个elif
4、只有if 的条件不成立，才会去判断elif的条件
5、在一个if中，如果有多个elif,只要有一个条件成立，后续的所有都不在判断

10.4 if的嵌套使用

if 嵌套，是指在一个if（elif else）中嵌套另一个if;
使用场景：判断条件存在递进关系（只有第一个条件满足了，才会判断第二个条件）

语法：

if 判断条件1：判断条件1成立，执行的代码if 判断条件2：判断条件2成立执行的代码else:判断条件2不成立执行的代码
else:判断条件1不成立，执行的代码

案例：

"""
案例：
取款机取钱的过程，假定你的密码是：123456 ，账户余额是1000
1、提示用户输入密码
2、判断密码是否正确
3、密码正确后，提示输入取款的金额
4、判断取款得金额和余额的关系
"""
password = input("请输入密码")
if int(password) == 123456:money = input("请输入取款金额")if int(money) == 1000:print("取款成功")else:print("余额不足")
else:print("密码有误")

11、debug调试代码 

注意点：

可能会出现的bug(pycharm软件的问题)：代码中只有一个断点的时候不能debug调试查看代码的执行过程，解决方案，在代码其他任意地方多加一个断点 

12、循环的基本使用

12.1 while循环的基本使用

使用场景：让执行的代码按照指定的次数重复执行

语法1、设置循环的初始条件（计数器）2、书写循环的判断条件while 判断条件：# 3、需要重复执行的代码#4、改变循环的初始条件（计数器）

无限循环

无限循环的使用一般会在循环中添加一个if判断，当if 条件成立，使用关键字break来终止循环while True:重复执行的代码 #可以在if的上边if 判断条件：break #关键字的作用就是终止循环，当代码执行遇到break,这个循环就不再执行了重复执行的代码 #可以在if的下边

12.2 for循环

for 循环也可以让指定的代码重复执行for循环可以遍历容器中的数据（遍历：从容器中把数据一个一个取出容器：可以简单理解为盒子，盒子中可以存放很多的数据（字符串 str,列表 list,元组 tuple,字典 dict））

语法：

for 变量名 in 容器：重复执行的代码1、for 和in都是关键字
2、容器中有多少个数据，循环会执行多少次（0个数据，执行0次，...）
3、每次循环，会将容器中数据取出一个保存到 in 关键字前边的变量中；

12.3 for做指定次数的循环

for 变量 in range(n):重复执行的代码1、range()是python中的函数，作用使用可以生成[0,n)之间的整数，不包含n的，一个有n个数字，所以这个循环循环n次
2、想让for循环循环多少次，n就是几
3、变量的值也是每次循环从[0,n)取出一个值，第一次取得是0，最后一次取得是n-1;

range()变形

for 变量 in range(a,b):重复执行的代码1、range(a,b) 作用是生成[a,b)之间的整数数字，不包含b

13、break和continue

break和continue是python中的两个关键字，只能在循环中使用# break 和continue 是python中的两个关键字，只能在循环中使用
# break:终止循环，即代码执行遇到break，循环不再执行，立即结束
# continue:跳过本次循环，即代码执行遇到continue,本次循环剩下的代码不再执行，继续下一次循环

range = input("请输入字符串")
for i in range:if(i=='e'):breakprint(i)
print('-'*90)
for i in range:if(i=='e'):continueprint(i)#打印结果
请输入字符串adefgher
a
d
------------------------------------------------------------------------------------------
a
d
f
g
h
r

14、字符串

定义：

• 使用单引号括起来的字符
• 使用双引号括起来的字符
• 使用三引号括起来的字符
• 特殊定义细节
  • 使用\ 转义字符，将字符串本身的引号进行转义
  • 双斜杠转译成单斜杠
  • 字符串前边加上r""原生字符串。字符串中的\不会作为转义字符 文件操作会使用

# 1、使用\ 转义字符，将字符串本身的引号进行转义
my_name = 'I\'m 小明'
print(my_name)
# 2、双斜杠转译成单斜杠
my_name = 'I\\\'m 小明'
print(my_name)
# 3、字符串前边加上r"" 原生字符串。字符串中的\不会作为转义字符   文件操作会使用
my_name = r'I\\\'m 小明'
print(my_name)
my_name = r'I\'m 小明'
print(my_name)

14.1 字符串下标访问

• 可以将字符串当做是装有很多内容的容器，通过编号可以获取到指定位置的字符
• 下标是人为定义的一种计数规则，默认下标从0开始
• 下标的使用语法为字符串名[下标值]

my_str = "qwertyuiokjhgf"
print(my_str[0])
print(my_str[4])
# 打印最后一个字符
print(my_str[-1])
# 打印倒数第二个字符
print(my_str[-2])
# 打印字符串的长度
print(len(my_str))
# 打印最后一个字符
print(my_str[len(my_str)-1])打印结果
q
t
f
g
13
f

注意：如果字符串首尾及中间有空格，也算是一个字符；

14.2 字符串切片

通过切片操作，可以获取字符串中指定部分的字符

语法： 字符串[开始位置下标：结束位置下标：步长]

字符串[start:end:step]
start 是开始位置的下标，end 是结束位置的下标（注意，不能取到这个位置的字符）
step 步长，等差数列的差值，所取的相邻下标之间的差值，默认是1，可以不写

切片示例：

str = "abcdefg"
# 正数下标 0 1 2 3 4 5 6
# 负数下标-7 -6 -5 -4 -3 -2 -1# 1、如果步长是1，可以不写，最后一个冒号也不写
print(str[0:7])
# 2、如果开始位置是0，可以不写，但是冒号必须有
print(str[:7])
# 3、获取efg字符
print(str[4:7])
print(str[-3:7])
print('-'*30)
# 获取ef字符
print(str[-3:-1])
# 4、如果最后一个字符也要取，可以不写，但是冒号必须有
print(str[4:])
# 5、如果开始和结束都不写，获取全部内容，但是冒号必须有
print(str[:])
# 6、获取aceg
print(str[0:7:2])
print(str[::2])
# 逆转字符串，步长是-1
print(str[::-1])结果：
abcdefg
abcdefg
efg
efg
------------------------------
ef
efg
abcdefg
aceg
aceg
gfedcba

14.3 字符串的查找方法

语法及定义：

字符串.find(sub_str,start,end)
作用：在字符串中查找是否存在sub_str这样的字符串
sub_str:要查找的小的字符串
start:开始位置，从哪个下标位置开始查找，一般不写，默认是0
end 结束位置，查找到哪个下标结束，一般不写，默认是len()
返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）：1、如果在字符串中找到了 sub_str,返回sub_str第一次出现的正数下标（sub_str中第一个字符在大字符串中的下标)2、如果没有找到，返回-1

查找方法的示例：

str = "and or not  and"
# 在字符串中查找and
result = str.find("and",0)
print(result)
# 在字符串中查找第二个and
result = str.find("and",result+1)
print(result)
# 在字符串中查找or
print("-----"*30)
result = str.find("or",0)
print(result)
result = str.find("or")
print(result)结果：
0
12
------------------------------------------------------------------------------------------------------------------------------------------------------
4
4

14.4 字符串的替换方法

语法：

字符串.replace(old_str,new_str,count) #将字符串中old_str替换为 new_str
old_str:被替换的内容
new_str:替换为的内容
count:替换的次数，一般不写，默认是全部替换
返回：替换之后的完整的字符串，注意：原来的字符串没有发生改变

替换方法的示例：

str1 = "good good study"
# 1、将str1中所有的g改为G
str2 = str1.replace('g','G')
print('str1:',str1)
print('str2:',str2)
# 2、将str1中第一个good改为GOOD
str3 = str1.replace('good','GOOD',1)
print("str3:",str3)
# 3、将str1中第二个good改为GOOD
# 先将全部的改为GOOD
str4 = str1.replace('good','GOOD',2)
# 再将第一个GOOD改为good
str4 = str4.replace('GOOD','good',1)
print("str4:",str4)结果：
str1: good good study
str2: Good Good study
str3: GOOD good study
str4: good GOOD study

14.5 字符串的拆分

语法：

字符串.split(sep,max_split)#将字符串按照sep进行分割
sep:字符串按照什么进行拆分，默认是空白字符（空格，换行\n,tab键\t)
max_split,分割次数，一般不写，全部分割
注意：如果sep不写，想要指定分割次数 则需要按照如下方式使用
字符串.split(max_split=n) #n是次数

拆分的示例：

str1 = "hello world and itcast and itheima and python"
# 1、将str1按照and 字符串进行拆分
result = str1.split('and')
print(result)
# 2、将str按照and字符进行拆分，拆分一次
result = str1.split('and',1)
print(result)# 3、按照空白字符进行切割
result = str1.split()
print(result)
# 3、按照空白字符进行切割，只切割一次
result = str1.split(maxsplit=1)
print(result)结果：
['hello world ', ' itcast ', ' itheima ', ' python']
['hello world ', ' itcast and itheima and python']
['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'python']
['hello', 'world and itcast and itheima and python']

14.6 字符串的连接方法

语法：

字符串.join(列表) #括号中的内容主要是列表，可以是其他容器
作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
列表中的数据使用：使用逗号隔开的
注意点：列表中的数据必须都是字符串，否则会报错

连接示例：

list1 = ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'python']
# 1、将列表中的字符串使用空格连接起来,注意双引号中间有个空格
str1 = " ".join(list1)
print(str1)
# 2、将列表中的字符串使用and连接起来
str2 = ' and '.join(list1)
print(str2)结果：
hello world and itcast and itheima and python
hello and world and and and itcast and and and itheima and and and python

15、列表的使用

15.1 列表的定义

方法一：用[]定义，数据之间使用英文逗号隔开
name_list = []
name_list = ["","",""]
方式二：通过类实例化方法定义
data_list = list()

代码示例：

list1 = list()
print(type(list1),list1)
# 类型转换 list(容器) 将其他的容器转换为列表
# 转换字符串会将字符串中的每一个字符作为一个数据存放到列表中
list2  = list('hello')
print(type(list2),list2)结果：
 []
 ['h', 'e', 'l', 'l', 'o']

15.2 列表的下标和切片

# 列表支持下标的切片操作，使用方法和字符串中的使用方法一致
# 区别：列表的切片得到的是列表

list1 = ['1','22','333','4444']
# 获取第一个数据
print(list1[0])
# 获取最后一个数据
print(list1[3])# 第一到第3个数据
print(list1[0:3])# 列表也支持len()
print(list1[len(list1)-1])
print(len(list1))结果：
4444
['1', '22', '333']
4444
4

15.3 列表的查询操作

列表.index(数据，start,end)使用和find方法一样，同时在字符串中也有index方法
区别：返回，index()方法，找到返回第一次出现的下标，没有找到代码直接报错

list = ['1','2','4','3','4','5','2']
result = list.index('4')
print(result)结果：
2

查找-判断是否存在
判断容器中某一个数据是否存在可以使用in关键字
数据 in 容器 #如果存在返回True，如果不存在，返回False

if 6 in list:num = list.index("6")print(num)
else:print("不存在数据")结果：
不存在数据

查找-统计出现的次数
统计出现的次数，使用的是count()方法
列表.count(数据) #返回数据出现的次数

if list.count("2")>=2:num = list.index("2")print(num)结果：
1

15.4 列表的添加方法

尾部添加（最常用）
1、列表.append(数据) #将数据添加到列表的尾部
返回：返回的None（关键字，空）一般就不再使用变量来保存返回的内容想要查看添加后的列表，需要打印的是列表

my_list = []
# 1、想要在列表中添加数据
my_list.append("1")
my_list.append("2")
my_list.append("3")
print(my_list)结果：
['1', '2', '3']

2、指定下标位置添加
列表.insert(下标，数据)    #在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会右移
返回：返回的None（关键字，空）一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要打印的是列表

my_list = []
my_list.insert(1,"张")
print(my_list)结果：
['张']

3、列表合并
列表1、extend(列表2)    #将列表 2中的所有数据逐个添加到列表1的尾部
返回：返回的None（关键字，空）一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要打印的是列表

list1 = ['1','2','3','4']
list2 = ['男','女']
list1.extend(list2)
print(list1)
list2.extend(list1)
print(list2)结果：
['1', '2', '3', '4', '男', '女']
['男', '女', '1', '2', '3', '4', '男', '女']

15.5 列表的修改操作

# 1、想要修改列表中的指定下标位置的数据
# 列表[下标] = 数据
# #字符串中字符不能使用下标修改

my_list = ['1','2']
my_list[1] = '杨'
print(my_list)
# 修改最后一个位置的数据，改成hello
my_list[-1] = 'hello'
print(my_list)结果：
['1', '杨']
['1', 'hello']

15.6 列表的删除操作

删除操作：在列表中删除中间的数据，那么后面的数据会向前移动
1、根据下标删除
列表.pop(下标)  #删除指定下标位置对应的数据
(1)、下标不写，默认删除最后一个数据（常用）
(2)、书写存在的下标，删除对应下标位置的数据
返回：返回的删除的数据2、根据数据删除
列表.remove（数据值）   #根据数据值删除
返回：None
注意：如果要删除的数据不存在，会报错
3、清空数据
列表.clear()

my_list = ['1','2','3','4','5','6',7,'8']
# 1、删除最后一个位置的数据
result = my_list.pop()
print(my_list)
print(result)
# 删除下标为1的数据
result = my_list.pop(1)
print(result)
print(my_list)
# 删除数据为7的数据
result = my_list.remove(7)print(result)
print(my_list)结果：
['1', '2', '3', '4', '5', '6', 7]
8
2
['1', '3', '4', '5', '6', 7]
None
['1', '3', '4', '5', '6']

15.7 列表的反转和逆置

列表中反转和倒置
1、列表[::-1]  #使用切片的方法，会得到一个新列表，原列表不会发生改变
2、列表.reverse()   #直接修改原列表，返回Non

my_list = ['1','2','3','4','5','6']
# 1、使用切片的方法会得到一个新列表
list2 = my_list[::-1]
print(my_list)
print(list2)
# 2、使用reverse方法，直接修改原列表
my_list.reverse()
print(my_list)
result = my_list.reverse()
print(result)结果：
['1', '2', '3', '4', '5', '6']
['6', '5', '4', '3', '2', '1']
['6', '5', '4', '3', '2', '1']
None

15.8 列表的复制

1、使用切片
变量 = 列表[:]
2、使用copy 方法
变量= 列表.copy()

list02 = my_list.copy()
print(list02)
my_list.reverse()
print(list02)结果：
[7, 6, 5, 4, 3, 2, 1]
[7, 6, 5, 4, 3, 2, 1]

15.9 列表的排序

列表的排序，一般来说都是对数字进行排序的
列表.sort() 按照升序排列，从小到大
列表.sort(reverse = True) 降序排列，从大到小

my_list = [1,4,5,4,]
# 升序排列
my_list.sort()
print(my_list)
# 降序排列
my_list.sort(reverse=True)
print(my_list)结果：
[1, 4, 4, 5]
[5, 4, 4, 1]

15.10 列表的嵌套

# 列表嵌套，列表中的内容还是列表
# 使用下标来确定获取的是什么类型的数据，然后确定可以继续进行什么操作

person_info = [['前端','01','18'],['后端','33','18'],['测试','22','44']]
print(person_info[1])        #['后端', '33', '18']
print(len(person_info))      #3
print(person_info[0][2])     #18
print(person_info[0][0][0])  #前

15.11 列表去重

 列表中存在多个数据，需求，去除列表中重复的数据；

方式1、遍历原列表中的数据判断在新列表中是否存在，如果存在，不管，如果不存在放入新的列表中

遍历：for循环实现

判断是否存在：可以用in

存入数据：append()

方式2、

在python汇总还有一种数据类型（容器），称为是集合（set）

特点：集合中不能有重复的数据（如果有重复的数据会自动去重）

可以使用集合的特点对列表去重

1、使用set()类型转换将列表转换为集合类型

2、再使用list()类型转换将集合转换为列表

缺点：不能保证数据在原列表中出现的顺序（一般来说，也不考虑这件事）

my_str = [5,4,1,2,3,4,1,2,3,4,5,6,3,2,1]
print(set(my_str))
new_str = set(my_str)
print(list(new_str))
str = []
for i in my_str:if i not in str:str.append(i)
print(str)

16、元组的使用

元组：tuple,元组的特点和列表非常相似
1、元组中可以存放任意类型的数据
2、元组中可以存放任意多个数据

区别：
1、元组中的数据内容不能改变，列表中的可以改变的
2、元组使用(),列表使用[]

应用：在函数的传参或者返回值中使用，保证数据不会被修改

元组的定义：

# 定义
# 1、使用类实例化的方式
# 2、直接使用()方式

代码示例：

# 1、类实例化的方式
# 1.1定义空元组（不会使用的）
my_tuple1 = tuple()
print(type(my_tuple1),my_tuple1)
# 1.2类型转换
# 可以将列表转换为元组，只需要将[],变为(),同时可以将元组转换列表，将()变为[]
my_tuple2 = tuple([1,2,3])
print(my_tuple2)# 转换字符串，和列表中一样，只是将列表的[]变为()
my_tuple3 =tuple ('hello')
print(my_tuple3)结果：
 ()
(1, 2, 3)
('h', 'e', 'l', 'l', 'o')

# 2.直接使用（）定义
my_tuple4 = (1,'杨',3.14,False)
print(my_tuple4)# 3、将元组转换为列表
my_tuple11 = list(("杨","张"))
print(my_tuple11)# 3、元组可以使用+连接生成新的元组
my_tuple12 = ("杨","张")+("张","杨")
print(my_tuple12)
# 3.特殊点，定义只有一个数据的元组时，数据后边必须有一个逗号
my_tuple5 = (1,)
print(my_tuple5)结果：
(1, '杨', 3.14, False)
['杨', '张']
('杨', '张', '张', '杨')
(1,)

常用的方法：

由于元组中的数据不能修改，所以只有查看的方法
1、在元组中也可以使用下标和切片获取数据
2、在元组中存在index方法,查找下标，如果不存在会报错
3、在元组中存在count方法，统计数据出现的次数
4、在元组中可以使用in操作，判断数据是否存在
5、len()统计个数
以上方法的使用和列表中一样的

代码示例：

my_tuple6 = ("1",'2','3','4','5')
print(my_tuple6[-1])
# 倒序输出,步长为-1
my_tuple7 = my_tuple6[::-1]
print(my_tuple7)
# 正序输出，步长为1
my_tuple10 = my_tuple6[::1]
print(my_tuple10)
print('__'*800)
# 倒序输出
my_tuple8 = reversed(my_tuple6)
print(tuple(my_tuple8))print('---'*800)
# 元组的反转
A=[(4,5),(4,6),(6,9),(3,6)]
B=[k[::-1] for k in A]
print(B)
C=[(4,5),(4,6),(6,9),(3,6)]
D=[tuple(reversed(k) for k in A)]
print(B)E = (1,2,3,3,3,4,4,5,5,0)
F = E.count(9)
print(F)
if 3 in E:print(E)
print('__'*800)结果：
5
('5', '4', '3', '2', '1')
('1', '2', '3', '4', '5')
____________________________________________________________
('5', '4', '3', '2', '1')
------------------------------------------------------------------------------------------
[(5, 4), (6, 4), (9, 6), (6, 3)]
[(5, 4), (6, 4), (9, 6), (6, 3)]
0
(1, 2, 3, 3, 3, 4, 4, 5, 5, 0)
____________________________________________________________

17、字典的使用

定义：

1、字典dict，字典中的数据是由键值对组成的（键表示数据的名字，值就是具体的数据）2、在字典中一组键值对是一个数据，多个键值对之间使用逗号隔开
变量={key:value,key:value,...}
3、一个字典中的键是唯一的，不能是重复的，值可以是任意数据
4、字典中的键 一般都是字符串，可以是数字，不能是列表

# 1、使用类实例化定义
my_dict = dict()
print(my_dict)# 2、使用{}定义
# 2.1空字典
my_dict1 = dict()
print(type(my_dict1),my_dict1)
# 2.2非空字典
my_dict2 = {"name":"杨","age":18,"is_man":False,"like":["跳绳","跑步","冲浪"]}
print(my_dict2)

注意：不能转元组、列表或者字符串

17.1 添加和修改数据

字典[键] = 数据值
1、如果键已经存在，就是修改数据值
2、如果键不存在，就是添加数据（即添加键值对）

my_dict = {"名字":"小明","age":"18","like":["上网","喝酒","抽烟"]}
print(my_dict)# 添加性别 sex="男" 只能在后面添加
my_dict ["sex"] = "男"
print(my_dict)# 修改年龄为19
my_dict["age"] = 19
print(my_dict)# 添加一个爱好学习,本质是向列表中添加一个数据
my_dict["like"].append("学习")
print(my_dict)

17.2 删除数据

1、删除指定键值对
del 字典[键]
# 2、清空
字典.clear()

my_dict = {'名字': '小明', 'age': 19, 'like': ['上网', '喝酒', '抽烟', '学习'], 'sex': '男'}
# 删除名字的键值对  del   或者    pop
del my_dict["名字"]
print(my_dict)# my_dict.pop("名字")
# print(my_dict)# 删除爱好中的喝酒  本质是删除列表中的数据
# my_dict["like"].pop(1)
# print(my_dict)
my_dict["like"].remove("喝酒")
print(my_dict)# 清空键值对
my_dict.clear()
print(my_dict)

17.3 查询-获取对应的数据

字典中没有下标的概念，想要获取数据值，要使用key(键)来获取
使用 字典[键]：
1、如果键存在，返回键对应的数据值
2、如果键不存在，会报错
使用 字典.get（键）
字典.get(键，数据值)
1、数据值一般不写，默认是None
返回 :
1.如果键存在，返回键对应的数据值
2、如果键不存在，返回的是 括号中书写的数据值（None)
一般建议使用get方法

y_dict = {"名字":"小明",'age': 19, 'like': ['上网', '喝酒', '1', '抽烟', '学习']}
# 获取名字小明
print(my_dict["名字"])
print(my_dict.get("名字"))
# 字典中有键值对名字，获取名字时无论数据传了什么都会打印字典中对应的数据
print(my_dict.get("名字","zzz"))# 2、获取sex姓名
print(my_dict.get("sex"))    # None
# print(my_dict["sex"])    代码会报错。因为字典中没有键sex
# 字典中没有键值对sex，获取性别时传了数据男 ，  打印结果是男
print(my_dict.get("sex","男"))  #男
# 3、获取第二个爱好
print(my_dict["like"][1])
print(my_dict.get("like")[1])

17.4 字典的遍历

对字典中的键进行遍历

for 变量 in 字典：print(变量)  #变量就是字典的 key,键
for 变量 in 字典.keys():     #字典.keys()  可以获取字典中所有的键print(变量)

my_dict ={'名字': '小明', 'age': 19, 'like': ['上网', '喝酒', '抽烟', '学习'], 'sex': '男'}
for k in my_dict:print(k)        #获取字典中所有的键
for k in my_dict.keys():  #获取字典中所有的键print(k)

对字典中的值进行遍历

for 变量 in 字典.values():    #字典.values()可以获取字典中所有的值print(变量)

for k in my_dict.values():    #获取字典中所有的值print(k)

对字典中的键值对进行遍历

#变量1是键，变量2是键对应的值
for 变量1，变量2 in 字典.items():  #字典.itens()  获取键值对print(变量1，变量2)

for i, j in my_dict.items(): #获取字典中所有的键值对print(i,j)

补充

# 1、字符串，列表，支持加法运算
# 2、字符串 列表 元组 支持 乘一个数字
# 3、len()在容器中都可以使用
# 4、in关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在

18、函数