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'):
        break
    print(i)
print('-'*90)
for i in range:
    if(i=='e'):
        continue
    print(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)


结果：
<class 'list'> []
<class 'list'> ['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)


结果：
<class 'tuple'> ()
(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、函数