python笔记

Python

语言的分类

计算机只认识 二进制（0和1）
编程语言是人和计算机沟通的语言
编程语言分类：编译型语言，解释型语言

目标：
1，学习掌握python的基本语法
2，在代码中遇到常见的错误，自己能够动手解决
​
Python只是一个编程语言，在工作中需要结合其他的工具使用
Python + selenium web 自动化（功能测试转换为代码）
Python + appium 移动（手机端APP）自动化
Python + requests 接口

Python 环境配置

Python 解释器（必须有）;将我们书写的Python代码转换为二进制，建议 版本>=3.6

pycharm(选装)：是Python中最好用的IDE（集成开发环境）之一，是用来书写代码运行代码，调试代码的…

vscod,idle,记事本…

python解释器的安装

1，双击安装包

2，选择安装方式（可以默认安装，可以自定义），不要忘记勾选添加path环境变量

path环境变量：将一个软件或者程序添加到path环境变量之后，就可以使用
终端（cmd）在任意路径下使用 这个软件（如果没有环境变量，只能在安装目录使用

print函数的简单使用

print("hello world")
print()是python中自带的函数，作用在控制台中输出 括号中的内容
后续看到这个函数就是输出打印 数据的，或者想要在控制台中显示某个内容，就是要使用print（）函数
​
print()主要学习阶段使用，便于我们确认结果的正确性
在实际工作的代码中，基本不会使用print，会使用 其他的内容代替（日志模块）
​
print()函数中是什么内容，就会显示什么内容，里边的文字信息 可以使用单引号，也可以使用双引号

注释

1，注释是对代码解释说明的文字，不会执行，可以增加代码的可读性
2，PYthon中的注释分为两种，单行注释和多行注释

单行注释

使用 井号空格进行注释（单独一个# 也可以）
​
快捷键 Ctrl /

多行注释

多行注释中的内容 可以换行书写
​
多行注释可以使用3对 双引号或者3对单引号，三对引号包括的内容就是注释的内容
​
三对引号的注释，一般写在文件的最开始部分，或者文档注释处（函数）

Python代码中三中波浪线和PEP8

红色

红色波浪线是代码的错误，必须处理，代码才能执行
​
注意：在后续课程中，某些代码没有写完，也会出现红色波浪线

灰色

灰色波浪线，不会影响代码的正常执行，基本上所有的灰色波浪线都是PEP8造成的
​
PEP8：是Python代码的书写规范，如果不按照这个规范书写，会给灰色波浪线提示，建议的书写按照PEP8的规范书写
​
1，可以书写代码的时候注意PEP8的代码规范
2，可以在书写完之后，使用快捷键Ctrl Alt l来按照PEP的规范自动格式化代码

绿色

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

变量

变量
作用：是用来存储数据的（在程序代码中出现的数据，想要保存下的使用，就必须使用变量），如：测试数据，用户名密码，验证码
变量注意事项;变量必须先定义（保存数据）后使用（取出数据）

定义变量

变量名=数据值  #可以理解为 是将数据值保存到变量中
#比如
name=‘张三’#定义一个变量name，存储的数据值是 张三

使用变量

变量定义后，想要是使用变量中的数据，直接使用变量名即可
​
#使用变量获取数据，打印
print（name）

变量名的命名规范

起名字的规范，标识符的规则

1，必须由字母，数字和下划线组成，并且不能以数字开头

2，不能使用Python中的关键字作为变量名

关键字;python自带的已经使用的标识符，具有特殊的作用

3，区分大小写

4，建议性的命名

驼峰命名法

大驼峰：每个单词的首字母大小写NyName

小驼峰：第一个单词的首字母小写，其余单词的首字母大写myName

下划线连接法：每个单词之间使用下划线连接my_name

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

见名知意

name 姓名 age 年龄 height 身高 ....

数据类型

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

数字类型

整型（int），就是整数，即不带小数点的数

浮点型（float），就是小数

布尔类型（bool），只有两个值

真true，1

假False 0,非0即真

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

复数类型3 + 4i，不会用的

非数字类型

字符串（str）使用引号引起来的就是字符串

列表（list）[1,2,3,4]

元组（tuple)(1,2,4,4)

字典（dict){‘name’: ‘小明’，’age’:18}

type()函数

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

输入

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

类型转换

根据代码的需要，将一种数据类型转换另一种数据类型（将 input 输入得到的
数字转换为整型

语法：

变量 = 要转换为的类型（原数据）
1，数据原来是什么类型
2，你要转换为什么类型

注意点：数据类型转换，不会改变原来的数据类型，会生成一个新的数据类型

int（）将其他类型转换为int类型

1，可以将float类型的数字转换为整数

2，可以将整数类型的字符串转换为整型3 123

float（）将其他类型转换为浮点型

1，可以将int类型转换为浮点型float（3） —>3.0

2, 可以将数字类型的字符串（整数类型和小数类型）转换为浮点型

str（）将其他类型转换为字符串类型

任何类型都可以使用str（）将其转换为字符换，一般都是直接加上引号

输出

输出使用的函数是print（）函数，作用，将程序中的数据或者结果打印到控制台（屏幕）

print（'hello world'）
name = '小明'
print(name)
age = 18
print(name,age)  #可以使用逗号输出多个内容

格式化输出

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

%格式化输出占位符号

○ %d 占位，填充 整型数据 digit

○ %f 占位， 填充 浮点型数据 float

○ %s 占位， 填充 字符串数据 string

补充： 其实 %s 的占位符，可以填充任意类型的数据

# 定义变量 姓名   年龄   身高
name = '小明'  # 可以使用 input 输入
age = 18  # 可以使用input 输入
height = 1.71  # 可以使用input 输入

# 要求按照以下个数输出个人信息
# 我的名字是xx, 年龄是 xx, 身高是 xx m
# 使用格式化输出实现
# print（'我的名字是 name， 年龄 age， 身高是 height m')
print('我的名字是%s，年龄是 %d，身高是%f m' % (name, age, height))
# 小数默认显示6位， 如果想要指定显示小数点后几位， %，nf , n需要换成具体的整数数字，即保留小数的位置
print('我的名字是 %s, 年龄是 %d, 身高是 %.2f m' %(name, age, height))  # 两位小数
print('我的名字是 %s, 年龄是 %d, 身高是 %.1f m'(name, age, height))  # 一位小数

# 补充
stu_num = 1  # 学号
# 我的学号是 000001
print('我的学号是%d' % stu_num)
# %0ed n 需要换成具体的整数数字， 表示整数一共占几位
print('我的学号是%06d' % stu_num)

num = 90  # 考试的几个率
# 某次考试的及格率为 90%， 如果在 格式化中需要显示%， 在书写的使用 需要使用 两个 %% 才可以
print('某次考试的及格率为 %d%%' % num)

快捷键

添加引号或括号：可以直接选中要添加引号或者括号的内容，书写即可

撤销：Ctrl Z
删除一行：Ctrl x
复制粘贴一行： Ctrl d

快速 在代码下方，新建一行： shift 回车

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

f-string格式化的方法，想要使用 ，Python 的版本 >= 3.6

1, 需要在字符串的前边加上 f""或者F""
2,占位符号统一变为{}
3，需要填充的变量 写在{}中

# 定义变量 姓名  年龄 身高
name = '小明'  # 可以使用input输入
age = 18  # 可以使用input输入
height = 1.71 # 可以使用 input 输入
stu_num =1  # 学号
num = 90  # 及格率

# print('我的名字 xx, 年龄是 xx, 身高是 xx m, 学号 xx, 本次考试的及格率为 xx%')
print(f'我的名字 {name}, 年龄是 {age}, 身高是 {height} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')
# 一般不会有这样的需求
print(f'我的名字 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格率为 {num}%')

# 在字符串中想要输出换行 \n(转义字符)
print(f'我的名字 {name}, 年龄是 {age}, 身高是 {height} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')

运算符

/ 除 得到的是浮点类型

// 求商 被除数+除数=商…余数

% 求余

** 幂运算 2**3=2 * 2 *2

优先级：先算谁，在算谁（不确定优先级，就使用（））
（）>**>* / // % > + -

比较运算符

比较运算符得到都是bool 类型
<  >  ==  =<  >=

今日内容

字符串格式化的补充

运算符

判断语句 if elif else

循环语句基础while

字符串格式的补充

字符串.format()可以在任意版本中使用

1,在需要使用 变量的地方使用{}占位
2，'{},{}...'.format（变量，变量，。。。）

print('我的名字 {}, 年龄是 {}, 身高是 {} m, 学号 {}, 本次考试的及格率为 {}%'.format(name,age,height,stu_num,num))

运算符

逻辑运算符

逻辑运算符 可以连接多个条件
and 逻辑与 和，并且 and连接两个条件，都必须为True,整体结果才为true，即一假为假（当第一个条件为False的时候，第二个条件就不在判断）

or 逻辑或 或者   or连接的两个条件，只要有一个条件为true，整体结果就为true，即一真为真（当第一个条件为true的时候，第二个条件就不在判断）

not 逻辑非 取反   not后边的条件，如果本来是true，变为False,本来False,变为true

赋值运算符

赋值运算符 =，作用就是将等号右边的值保存到等号左边的变量中

复合赋值运算符（将算数运算符和赋值运算符进行结合）
+= -=  *=  /=  //=  %=

a  += b  ===> a =a+b

运算符优先级

不需要刻意去记忆优先级，因为可以使用（）改变优先级

判断

日常生活中说的  如果...否则...，这个就是判断，在程序代码中需要使用
if(如果)  elif(如果)  else(否则)  三个关键字来实现

在代码中有判断语句，待会不会全部执行，会有一部分不会执行

IF的基本结构

即 只有 如果的情况， 如果的条件成立， 会执行的代码，会做的事

基本语法

if 判断条件：
     书写条件成立（真），执行的代码
     书写条件成立（真），执行的代码
顶格书写，没有缩进的代码，和if无关，不管条件是否成立，都会执行

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

1，使用input获取用户的年龄
2，判断年龄是否满足18岁
3，如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'

# 1，使用input获取用户的年龄
age = input('请输入你的年龄：')
# 2，判断年龄是否满足18岁
if int(age) >= 18:
    print('满18岁了，可以进入网吧为所欲为')
# 3，如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'

print('我和if没有关系不管怎么样都会执行')

练习

1，获取用户输入的用户名信息
2，如果用户名信息是admin，就在控制台输出出来

# 1，获取用户输入的用户名信息
name = input('请输入你的用户名：')
if name == 'admin':
    print('欢迎admin')

# 2，如果用户名信息是admin，就在控制台输出出来

if else 结构

如果 条件成立 做什么事 否则（条件不成立） 做另一件事

基本语法

if判断条件 ：
   书写条件成立（真），执行的代码
   书写条件成立（真），执行的代码
else：
   书写条件不成立（假），执行的代码
   书写条件不成立（假），执行的代码
   
   
# 1， else是关键字，后边需要冒号
# 2， 冒号之后回车，同样需要缩进
# 3， 处于else代码下方缩进中的内容，属于else的代码块
# 4， if 和else的代码块，只会执行其中的一个
# 5， else需要结合if使用

代码案例

1.使用 input获取用户的年龄
2.判断年龄是否满足18岁
3.如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'
4.如果不满足，输出'不满18 岁，回去写作业'

# 1，使用input获取用户的年龄
age = input('请输入你的年龄：')
# 2，判断年龄是否满足18岁
if int(age) >= 18:
    print('满18岁了，可以进入网吧为所欲为')
# 3，如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'

else:
    print('不满足回去写作了')

练习

1，获取用户输入的用户名信息
2，如果用户名信息是admin，就在控制台输出出来
3，如果用户名信息不是admin，就在控制台输出“用户名错误”

if和逻辑运算符结合使用

案例一

1，获取用户输入的用户名和密码
2，判断用户名是admin并且密码是123456时，控制台输出：登录成功！
3，否则在控制台输出：登录信息错误

# 1，获取用户输入的用户名信息
name = input('请输入用户信息：')
pwd = input('请输入密码：')

# 2，如果用户名信息是admin，就在控制台输出出来
if name == 'admin' and pwd == '123456':
    print('登录成功！')


# 3，如果用户名信息不是admin，就在控制台输出“用户名错误”
else:
    print('登录信息错误')

案例二

1,获取用户输入的用户名
2，判断用户名是admin时，在控制台输出；欢迎admin登录！
3，用户名是test时，在控制台：欢迎test登录！
4，如果是其他信息，在控制台输入：查无此人

if elif else 结构

如果某个判断条件有多个，此时建议使用 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，只要有一个条件成立，后续的所有都不在判断

if 判断条件1：
   执行代码
if 判断条件2：
   执行代码
if 判断条件3：
   执行的代码
    
# 多个 if 的结构， 每个 if 都会进行判断，之间没有关联系

案例

1，定义score变量记录考试分数
2，如果分数是大于等于90分应该显示优
3，如果分数是大于等于80分并且小于90分应该显示良
4，如果分数是大于等于70分并且小于80分应该显示中
5，如果分数是大于等于60分并且小于70分应该显示差
6，其他分数1显示不及格

# 1，定义score变量记录考试分数
score = int(input('请输入你的分数'))
# 2，如果分数是大于等于90分应该显示优
if score >= 90:
    print('优')
# 3，如果分数是大于等于80分并且小于90分应该显示良
elif (score >=80) and score < 90:
    print('良')
# 4，如果分数是大于等于70分并且小于80分应该显示中
elif score >= 70:
    print('中')
# 5，如果分数是大于等于60分并且小于70分应该显示差
elif score >= 60:
    print('差')
# 6，其他分数1显示不及格
else:
    print('不及格')

多个if的实现

# 1，定义score变量记录考试分数
score = int(input('请输入你的分数'))
# 2，如果分数是大于等于90分应该显示优
if score >= 90:
    print('优')
# 3，如果分数是大于等于80分并且小于90分应该显示良
if (score >=80) and score < 90:
    print('良')
# 4，如果分数是大于等于70分并且小于80分应该显示中
if score >= 70 and score < 80:
    print('中')
# 5，如果分数是大于等于60分并且小于70分应该显示差
if score >= 60 and score < 70:
    print('差')
# 6，其他分数1显示不及格
if score < 60:
    print('不及格')

Debug 调试代码

debug 在代码中出现问题错误（bug），可以使用debug来调试代码，查找错误，
我们使用debug主要用来 查看代码的执行步骤

1，打断点

在pycharm中，代码和行号之间进行点击，出现小红点即打断点，再次点击小红点会取消断点

断点的位置，一般开说会在代码的第一行（在程序运行的时候，想要在什么地方停下来）

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

if 嵌套

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

• 语法

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

• 练习

  假定某网站用户名固定'admin',密码固定为‘123456’，验证码 固定为‘8888’
  1,获取用户输入的用户名，密码和验证码
  2，先判断验证码是否正确，如果正确打印输出验证码正确，在判断用户名和密码是否正确
  3，如果验证码不正确，直接输出，验证码不正确，请重新输入
  

   

money = 1000
pwd = '123456'

password = input('请输入密码')
if password == pwd:
    print('密码正确，登录成功')
    get_money = int(input('请输入取款金额'))
    if money >= get_money:
        print('取款成功')
    else:
        print('取款失败')


else:
    print('密码错误')

案例：猜拳游戏

案例的步骤：
1，自己出拳（石头（1）/剪刀（2）/布（3））input （player）
2.电脑随机出拳（待完成） （computer）
3,判断输赢
3,1 玩家胜利
3,1,1 player==1 and computer== 2
or
3,1,1 player==2 and computer== 3
or
3,1,1 player==3 and computer== 1
3.2 平局 player == computer
3.3 玩家输了 else

随机出拳

案例中需要电脑随机出拳，即随机出 1 2 3
在Python中想要随机获得整数数字可以使用如下方法
# 1，导入随机数工具包
import random
# 2， 使用工具包中的工具产生指定范围内的数字
random.randint(a,b) # 产生[a,b]之间的随机整数，包含a b 的

import random

num = random.randint(1,3)
print(num)

import random
# 1，自己出拳（石头（1）/剪刀（2）/布（3））input （player）
player = int(input('石头（1）/剪刀（2）/布（3）'))  # 不要忘了数据转换
# 2.电脑随机出拳（待完成） （computer）
computer = random.randint(1, 3)
# 3,判断输赢
# 3,1 玩家胜利
if player == (player ==1 and computer == 2) or (player ==2 and computer == 3) or(player ==3 and computer == 1):
   print('玩家胜利')
# 3.2 平局 player == computer
elif player == computer:
    print('平局')
# 3.3 玩家输了 else
else:
    print('再接再厉')

• 语法

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

• 代码

  # 1.设置循环的初始条件（记录说了几遍 我错了）
  i = 0
  
  # 2. 书写判断条件
  while i < 5:
      # 3.重复执行的代码
      print（'肚肚，我错了'）
      # 4. 改变初始条件，
      # i = i + 1
      i +=1
  

死循环和无限循环

死循环：一般是由写代码的人不小心造成的bug，代码一直不停的运行下去

无限循环：写代码的人故意让代码无限制的去执行，代码一直不停的运行下去
无限循环的使用场景：在书写循环的时候，不确定循环要执行多少次
无限循环的使用一般会在循环中添加if判断，当if条件成立，使用关键字break来终止循环

while True:
    重复执行的代码 # 可以在if的上边
    if判断条件：
     break # 关键字的作用就是终止循环，当代码执行遇到break，这个循环就不会在执行了
        重复执行的代码 # 可以在if的下边

书写循环的技巧：
确定这行代码执行几次，如果执行多次，就放在循环的缩进中，如果只执行一次，就不要在循环的缩进

import random
# 1，自己出拳（石头（1）/剪刀（2）/布（3））input （player）
while True:
    player = int(input('石头（1）/剪刀（2）/布（3）/退出（0）'))  # 不要忘了数据转换
    # 2.电脑随机出拳（待完成） （computer）
    if player == 0:
        break
    computer = random.randint(1, 3)
    # 3,判断输赢
    # 3,1 玩家胜利
    if player == (player ==1 and computer == 2) or (player ==2 and computer == 3) or(player ==3 and computer == 1):
       print('玩家胜利')
    # 3.2 平局 player == computer
    elif player == computer:
        print('平局')
    # 3.3 玩家输了 else
    else:
        print('再接再厉')

使用循环求1-100之间数字的和

1+2+3+4+....+100

# 1.定义变量 保存求和的结果
num = 0
# 2 定义循环获取1-100 之间的数字并求和
# 2.1定义初始条件
i = 1
# 2.2书写循环的条件
while i <=100:
    num +=i
    i +=1
print('数字的和为：',num)

使用循环求1-100之间偶数的和

方法一

直接找到1-100之间所有偶数，进行相加
2,4,6,8...98 100

# 1.定义变量 保存求和的结果
num = 0
# 2 定义循环获取1-100 之间的数字并求和
# 2.1定义初始条件
i = 2
# 2.2书写循环的条件
while i <=100:
    num +=i
    i +=2
print('数字的和为：',num)

方法二

1,找1-100之间

num = 0
i = 1
while i<= 100:
    if i%2 == 0:
        num +=i

    i += 1
print('求和的结果是：',num)

今日内容

• 循环

  • for循环

  • break和countinue

• 字符串的操作

• 列表介绍

for循环

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

• 语法：

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

  # 定义字符串
  my_str = 'hello'
  # 遍历字符串 # 字符串中有 5 个字符， 循环就会执行 5 次
  for i in my_str:  # 每次循环i 的值为字符串中的字符
      # 重复执行的代码
      print('我',i)
  

   

• for做指定次数的循环

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

• range()变形

  # 需求：使用 for 循环获取 5 到 10 之间的数字
  for 变量 in range(a,b):
      重复的代码
      
  # range(a,b) 作用是生成[a,b)之间的整数数字，不包含b
  

   

break 和 continue

break 和 countinue 是Python中的两个关键字，只能在循环中使用

break：终止循环， 即代码执行遇到break，循环不在执行，立即结束

countinue：跳过本次循环，即代码执行遇到break，本次循环剩下的代码不在执行，继续下一次循环

# 获取你输入的字符串
result = input('请输入一个字符串：')
# 遍历打印这个字符串
for i in result:
    # 在遍历的时候，如果这个字符是e，不打印（即后续的代码不执行）
    if i == 'e':
        continue  # 本次循环后续的代码不执行，执行下一次循环
    print(i)

print('-'* 30)

for i in result:
    # 3. 在遍历的时候如果这个字符是e，不打印（即后续的代码不执行）
    # 如果这个字符不是e，打印
    if i != 'e':
        print(i)

容器

容器：也可以称为是数据序列，或者高级数据类型， 也是 Python中的数据类型
容器中可以存放多个数据

字符串

字符串是容器，因为字符串中可以包含多个字符

定义

定义：使用引号（单引号，双引号，三引号）引起来的内容就是字符串

# 1，使用单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))
# 2,使用双引号定义
my_str2 = "hello"
print(my_str2,type(my_str2))
# 3,使用三引号定义
my_str3 = """hello"""
print(my_str3,type(my_str3))
my_str4 = '''hello'''
print(my_str4,type(my_str4))
# 4,字符串本身包含引导I'm小明
# 4.1字符串本身包含单引号，则在定义的时候不能使用单引号
# 4.2字符串本身包含双引号，则在定义的时候不能使用双引号
my_str5 = "I'm 小明"
print(my_str5)

# 5. 字符串本身包含单引号，在定义的时候，我就是想使用单引号
# 5.1 使用 \ 转义字符，将字符本身的引号进行转义\'-->'   \"-->"
my_str6 = 'I\'m 小明'
print(my_str6)
# 5.2 字符串 I\'m 小明  \\ --> \
my_str7 = 'I\\\'m 小明'
print(my_str7)

# 5.3 字符串前边加上r"" 原生字符串，字符串中 的\不会作为转义字符，文件操作会用一下
my_str8 =r'I\'m 小明'
print(my_str8)
my_str9 = r'I\\\'m小明'
print(my_str9)

下标

下标（索引）：就是指字符在字符串中的位置编号，这个编号就是下标

这个编号一般来说都是从左到右进行编号的，从0开始的（Python中支持负数下标
从右到左进行编号的，从-1开始）

下标作用：可以使用下标获取字符串某个位置的字符

语法：
字符串[下标]  # 获取指定位置的字符
0  1  2  3  4  5  6  正数下标
a  b  c  d  e  f  g  字符串
-7 -6 -5 -4 -3 -2 -1 负数下标

str1 = 'qwerty'

# 1.打印字符串中最开始位置的字符
print(str1[0])

# 2,打印最后一个位置的数据
print(str1[-1])

# 3,打印倒数第二个位置的字符
print(str1[-2])

# 打印下标为2的数据
print(str1[2])

# 获取字符串中字符的个数（获取字符串的长度）
# len(字符串） # length（长度）
num = len(str1)
print(num)
# 长度-1的下标位置是最后一个字符
print(str1[num-1])  # 最后一个字符，倒数第一个

print(str1[len(str1)-1])

切片

切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）

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

# 切片会得到一个字符串，即可以获取字符串中的多个字符

str1 = 'abcdefg'

# 1, 获取 abc 字符
print(str1[0:3:1])
# 1.1 如果步长是1 可以不写，最后一个冒号也不写
print(str1[0:3])
# 1.2 如果开始位置为0 ，可以不写，但是冒号必须有
print(str1[:3])

# 2. 获取efg字符
print(str1[4:7])
print(str1[-3:7])
# 2.1 如果最后一个字符也要取，可以不写，但是冒号必须有
print(str1[4:])
# 2.2 如果开始和解释都不写，获取全部内容，但是冒号必须有
print(str1[:])  

# 3. 获取 aceg # 0 2 4 6 ，所有步长为 2
print(str1[0:7:2])
print(str1[::2])

# 4.特殊应用，步长为负数，开始和结束不写，意思全变，一般不用管，只有一种使用场景
# 反转（逆置）字符串  字符串[::-1]
print(str1[: :-1])

字符串的查找方法 find

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

str1 = "and itcast and intheima and python"

# 在字符串中查找 and
num = str1.find('and')
print(num)

# 在字符串中查找 第二个 and 出现的下标，从第一次出现的后一位开始找
num1 = str1.find('and',num+1)
print(num1)

字符串的替换方法replace

字符串.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
# 3.1 先将全部的 good --> GOOD
str4 =str1.replace('good',"GOOD")
# 3.2 在将第一个 GOOD --> good
str4 = str4.replace('GOOD','good',1)
print('str4',str4)

字符串的拆分 split

字符串.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 字符进行拆分
result1 = str1.split('and')
print(result1)

# 2. 将 str1 按照 and字符进行拆分，拆分一次
result2 = str1.split('and',1)
print(result2)

# 3. 按照空白字符进行切割
result3 = str1.split()
print(result3)

# 4. 按照空白字符进行切割，拆分一次
result4 = str1.split(maxsplit=1)
print(result4)

字符串的链接 join

字符串.join(列表)  # 括号中的内容主要是列表，可以是其他容器

# 作用：将字符串插入列表中每相邻的两个数据之间，组成一个新的字符串
-列表中的数据使用 逗号隔开的
-注意点： 列表的数据必须都是字符串，否则会报错

list1 = ['good', 'good','study']

# 1.将列表中的字符串使用空格连接起来
str1 = ' '.join(list1)
print(str1)

# 2. 将 列表中的字符串使用and连接起来
str2 = ' and '.join(list1)
print(str2)

列表

type（）是把数据类型打印出来

列表 list, 是使用最多的一种容器（数据类型）
列表中可以存储多个数据，每个数据之间使用逗号隔开
列表中可以存放任意类型的数据

# 1. 类实例化的方式（不常用）
# 1.1 定义空列表（没有任何数据的列表）
# 变量 = list（）
list1 = list()
print(type(list1), list1)  # <class 'list'> []

# 1.2 类型转换 list（容器） 将其他的容器转换为列表
# 转换字符串会将字符串中的每一个字符作为一个数据存入到列表中
list2 = list('hello')
print(type(list2), list2)  # <class 'list'> ['h', 'e', 'l', 'l', 'o']

# 2, 直接使用[] 进行定义（常用）
# 2.1 定义空列表
my_list = []
print(my_list) # []

# 2.2 定义非空列表
my_list = [1, '小明', 3.14, False]
print(my_list)

列表支持下标和切片

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

list1 = ['小明', 18, 1.71, True]

# 获取第一个数据，名字
print(list1[0])

# 获取最后一个数据
print(list1[-1])

#  第一个第二个数据
print(list1[0:2])  # ['小明', 18]

# 列表页支持 len()求长度的，求数据元素个数
print(len(list1))

查找列表中数据下标的方法

在字符串中使用的find方法查找下标的，不存在返回的是-1
在列表中没有find 方法，想要查找数据的下标，使用的index（）方法

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

查找-判断是否存在

判断容器中某个数据是否存在可以使用 in 关键字

数据 in容器  # 如果存在返回True,如果不存在，返回False

查找-统计出现的次数

统计出现的次数，使用的是 count（）方法
列表.count（数据）  # 返回 数据出现的次数

my_list =[1, 3, 5, 7, 2, 3]

# 找 数据 3 出现的下标
num =my_list.index(3)
print(num)

# 找数据 4 出现的下标
# num =my_list.index(4) # 代码会报错
if 4 in my_list:
    num1 = my_list.index(4)
    print(num1)
else:
    print('无此数字')
    
# my_list.count(4) 统计 数据4 出现的次数
if my_list.count(4)>0:
    num1 = my_list.index(4)
    print(num1)
else:
    print('无此数字')

添加数据的方法

• 尾部添加（最常用）

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

   

• 指定下标位置添加

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

   

• 列表合并

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

   

my_list = []
print(my_list)

# 1.想列表中添加数据 平平
my_list.append('平平')
print(my_list)

# 2.向列表的尾部添加 安安
my_list.append('安安')
print(my_list)  # 直接接着第一个后面添加

# 3.在下标位置为1的位置添加数据 菟菟
my_list.insert(1,'菟菟')
print(my_list)  # ['平平', '菟菟', '安安']

# 4.定义新的列表list1
list1 = ['吴吴','婷婷']
# 将list中数据逐个添加到my_list中
my_list.extend(list1)
print(my_list)  # ['平平', '菟菟', '安安', '吴吴', '婷婷']

# 将list作为一个整体添加到my_list
my_list.append(list1)
print(my_list)  # ['平平', '菟菟', '安安', '吴吴', '婷婷', ['吴吴', '婷婷']]

今日内容

• 列表

• 元组

• 字典

• 函数的基本概念

定义

变量 =[数据，数据，...]

添加

列表.append(数据)

查询

列表.index(数据)
列表.count(数据)

修改操作

想要修改列中的指定下标位置的数据，使用的语法是：

列表[下标] = 数据

# 字符串中字符不能使用下标修改

# 定义列表
my_list = [1, 3, 5, 7]

# 想要将下标 1 的数据修改为 22
my_list[1] = 22
print(my_list)

# 修改最后一个位置的数据， 改为 'hello'
my_list[-1] = 'hello'
print(my_list)

# 不存在的小标就会报错

删除操作

在列表中删除中间的数据，那么后面的数据会向前移动

• 根据下标删除

  列表.pop(下标) # 删除指定下标位置对于的数据
  1.下标不写，默认删除最后一个数据（常用）
  2.书写存在的下标，删除对于下标位置的数据
  
  返回：返回的删除的数据
  

   

• 根据数据值删除

  列表.remove（数据值） # 根据数据值删除
  
  返回：None
  注意：如果要删除的数据不存在，会报错
  

   

• 清空数据（一般不用）

  列表.clear()
  

   

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 1.删除最后一个位置的数据
num = my_list.pop()
print(my_list)
print('删除的数据为：',num)  # [1, 3, 5, 7, 9, 2, 4, 6, 8]

# 2.删除下标为1 的数据 3
my_list.pop(1)
print(my_list)  # [1, 5, 7, 9, 2, 4, 6, 8]

# 3,删除数据为7的数据
my_list.remove(7)  # 注意，如果列表中有多个7，只能删除第一个，如果数据不存在，会报错的
print(my_list)  # [1, 5, 9, 2, 4, 6, 8]

# 清空
my_list.clear()
print(my_list)  # []

列表的反转（倒置）

字符串中 反转倒置： 字符串[::-1]

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

my_list = [1, 3, 5, 7 , 8, 9]

# 使用切片的方法反转，会得到一个新列表

list1 = my_list[::-1]
print('my_list:',my_list)
print('list1:',list1)

# 使用 reverse 方法， 直接修改愿列表
my_list.reverse()
print('my_list:',my_list)

列表的复制

将列表中的数据复制一份，给到一个新的列表
# 使用场景： 有一个列表，需要修改操作列表中的数据，修改之后，需要和原数据进行
对比，即原数据不能改

1， 使用切片
变量 = 列表[:]
2, 使用copy 方法
变量 = 列表.copy

my_list = [1, 2, 3]
my_list1 = my_list[:]
print('my_list:',my_list)
print('my_list1:',my_list1)
my_list1[1] = 22
print('my_list:',my_list)
print('my_list1:',my_list1)
print('-'* 30)

my_list2 = my_list.copy()
print('my_list:',my_list)
print('my_list2:',my_list2)
my_list2[2] = 33
print('my_list:',my_list)
print('my_list2:',my_list2)

print('-'* 30)
my_list3 = my_list  # 这是同一个列表，多了一个名字，引用
print('my_list:',my_list)
print('my_list3:',my_list3)
my_list3[] = 11
print('my_list:',my_list)
print('my_list3:',my_list3)

列表的排序

列表的排序， 一般来说都是对数字进行排序的

列表.sort() # 按照升序排序， 从小到大

列表.sort(reverse=True)  # 降序排序， 从大到小

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 升序
my_list.sort()
print(my_list)

# 降序
my_list.sort(reverse=True)
print(my_list)

列表嵌套

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

person_info = [["张三", "18", "功能测试"],["李四", "20", "自动化测试"]]

print(len(person_info))  # 2
print(person_info[0])  # ['张三', '18', '功能测试']

print(person_info[0][0])  # 张三

print(person_info[0][0][0])  # 张

# 将 18 改为 19
person_info[0][1] = '19'
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试']]

# 给 李四 所在的列表添加一个性别 信息
person_info[1].append('男')
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试', '男']]

# 将张三的年龄信息删除
# person_info[0].pop(1)
person_info[0].remove('19')
print(person_info)  # [['张三', '功能测试'], ['李四', '20', '自动化测试', '男']]

元组

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

区别：
1.元组中的数据内容不能改变，列表中的可以改变的
2.元组使用（），列表 使用[]

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

定义

1. 使用类实例化的方式
2. 直接使用（）方式

常用方法

由于元组中的数据不能直接修改，所有只能查看的方法

1，在元组中也可以使用 下标和切片获取数据
2，在元组中存在 index 方法
3，在元组中存在 count 方法
4，在元组中可以使用 in 操作
以上方法的使用 和列表中一样的

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

# 2.直接使用（） 定义
mu_tuple4 = (1, "小王", 3.14, False)
print(mu_tuple4)

# 3.特殊点，定义只有一个数据的元组时，数据后边必须有一个逗号
mu_tuple5 = (1,)
print(mu_tuple5)  # (1,)

print(mu_tuple4[1])  # 小王

字典

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

定义

# 1. 使用 类实例化的方法
my_dict = dict()
print(type(my_dict),my_dict)

# dict() 不能转列表和元组，字符串

# 2. 直接使用{}定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1),my_dict1)  # <class 'dict'> {}

# 2.2 非空字典，"name": "小明", "age": 18, "height": 1.71, "is_men": True,"like": ["抽烟", "喝酒", "烫头"]}
my_dict2 ={"name": "小明", "age": 18, "height": 1.71, "is_men": True,"like": ["抽烟", "喝酒", "烫头"]}
print(my_dict2)
print(len(my_dict2))

增加和修改操作

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

# 定义字典 小明 18 爱好

my_dict = {"name": "小明", "age": 18, "like":['抽烟','喝酒', '烫头']}

print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头']}
# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict)  {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 2.修改年龄为 19
my_dict['age'] = 19
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 3.添加一个爱好，学习--> 本质是向列表中添加一个数据
my_dict['like'].append('学习')
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

删除

• 删除指定键值对

  del 字典[键]
  
  字典.pop（键)  # 键必须书写
  

• 清空

  字典.clear
  

  my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
  
  # 删除 sex 键值对
  del my_dict['sex']
  print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']
  
  # 字典.pop（'键')
  my_dict.pop('age')
  print(my_dict)  # {'name': '小明', 'like': ['抽烟', '喝酒', '烫头', '学习']}
  
  # 删除抽烟的爱好 --->本质操作是在列表中删除 数据值
  # my_dict['like'].pop(0)
  my_dict['like'].remove('抽烟')
  print(my_dict)  # {'name': '小明', 'like': ['喝酒', '烫头', '学习']}
  
  # 清空键值对
  my_dict.clear()
  print(my_dict)  # {}
  

   

查询-根据键获取对应的值

字典中没有下标的概念，想要获取数据值，要使用key（键）来获取

• 使用 字典1[键]

  字典[键]
  1.如果键存在 返回键对应的数据值
  2.如果键不存在，会报错
  

• 使用 字典.get(键)

  字典.get（键， 数据值）
  1. 数据值一般不写，默认是 None
  返回：
  1.如果键存在 返回键对应的数据值
  2.如果键不存在，返回的是 括号中书写的数据值（None）
  
  一般建议使用get方法
  

   

my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}

# 1. 获取 名字
print(my_dict['name'])  # 小明
print(my_dict.get('name'))  # 小明
print(my_dict.get('name', 'zzz'))  # 小明

# 2. 获取 sex 性别
# print(my_dict.get['sex']) # 代码会报错， 原因 key不存在 
print(my_dict.get('sex'))  # None
print(my_dict.get('sex', '保密'))  # 保密

# 3.获取 第二个爱好
print(my_dict['like'][1])  # 喝酒
print(my_dict.get('like')[1])  # 喝酒

字典的遍历

对字典的键 进行遍历

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

对 字典的值 进行遍历

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

对字典的键值对 进行遍历

# 变量1 就是 键， 变量2 就是键对应的值
for 变量1， 变量2 in 字典.items（）： # 字典.items() 获取键值对
     print（变量1，变量2）

# 定义字典
my_dict = {'name': '小明', 'age': '18', 'sex': '男'}

# 1. 遍历字典的键
for k in my_dict:
    print(k)

for k in my_dict.keys():
    print(k)

print('-'*30)

# 2. 遍历字典的值
for v in my_dict.values():
    print(v)

print('-' * 30)

# 3. 遍历键值
for k, v in my_dict.items():
    print(k, v)

容器部分 总结

# 1. 字符串， 列表， 元组 支持加法运算
str1 = 'hello' + 'world'  # 'hello world'
list1 = [1, 2] + [3, 4]  # [1, 2, 3, 4]
tuple1 = (1, 2) + (3, 4)  # (1, 2, 3, 4)

# 2, 字符串 列表 元组 支持 乘一个数字
'hello' * 3 # ===> 'hello hello hello'
[1, 2] * 3 # ===> [1, 2, 1, 2, 1, 2]
(1, 2) * 3 # ===> (1, 2, 1, 2, 1, 2)

# 3. len() 在 容器中都可以使用

# 4. in 关键字在容器中都可以使用， 注意， 在字典中判断的是字典的键是否存在

函数

print()
input()---> str
type()

概念

函数，就是把 具有独立功能的代码块 组成为一个小模块， 在需要的时候 调用

函数，通俗理解， 将多行代码写在一块，起个名字， 在需要这多行代码的时候
可以直接使用这个名字来代替

函数好处：减少代码的冗余（重复的代码不用多写），提高程序的编写效率

def login():
    print('1.输入用户名')
    print('2.输入密码')
    print('3.输入验证码')
    print('4.点击登录')
    
    
login()

print('-'*30)

login()

函数定义

1, 将多行代码放在一块，起名字的过程，称为函数定义
2，函数必须先定义后调用

• 语法

  def 函数名（）：
      函数中的代码
      函数中的代码
      
      
  # 1. def 是关键字， 用来定义函数的 define的缩写
  # 2. 函数名需要遵守标识符的规则
  # 3. 处于 def 缩进的代码，称为函数体
  # 4. 函数定义的时候，函数体中的代码不会执行， 在调用的时候才会执行
  

• 函数定义小技巧

  在前期，书写不熟练的时候
  1. 可以先不管函数，先把功能写出来
  2. 给多行代码起名字
  3. 选中多行代码， 使用 tab 键进行缩进
  

   

函数的调用

1.使用多行代码的时候，被称为函数调用

• 语法

  函数（）
  
  # 1.函数调用的时候会执行函数体中代码
  # 2.函数调用的代码，要写在 函数体外边
  

  def say_hello():
      print('hello 1')
      print('hello 2')
      print('hello 3')
      
  # 调用
  say_hello()
  
  say_hello()
  
  
  

文档注释

文档注释的本质，还是注释，只不过书写的位置和作用比较特殊

1，书写位置，在函数名的下方使用 三对双引号进行的注释
2, 作用：告诉别人这个函数如何使用的， 干什么的
3. 查看， 在调用的时候， 将光标放到函数名上，使用快捷键 ctrl q(Windows)  Mac (ctrl j)

ctrl(cmd) B 转到函数声明中查看（按住Ctrl（cmd）鼠标左键点击）

函数的嵌套调用

在一个函数定义中调用另一个函数

1. 函数定义不会执行函数体中的代码
2. 函数调用会执行函数体中的代码
3. 函数体中代码执行结束会回到函数被调用的地方继续向下执行

def func1():
    print(1)
    print('func1')
    print(2)
    
    
def fun2():
    print(3)
    func1()
    print(4)
    
print(5)
fun2()
print(6)

今日内容

• 补充：列表去重

• 函数基本知识（返回值（返回），参数）

• 变量进阶（理解，Python底层原理，面试题）

• 函数进阶（返回值，参数）

列表去重

列表去重：列表中存在多个数据，需求， 去除列表中重复的数据，
方式1. 思路
遍历列表中的数据判断在新列表中说否存在，如果存在，不管，如果不存在放
入新的列表中
遍历： for 循环实现
判断是否存在： 可以 使用 in
存在数据;append()

方法 2:
在 Python 中国还有一种数据类型（容器），称为是 集合（set）
特点： 集合中不能有重复的数据（如果有重复的数据自动去重）
可以使用集合的特点对列表去重
1， 使用 set（）类型转换将列表转换为 集合类型
2， 在使用 list（） 类型转换集合 转换为列表

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

my_list = [1,2,3,4,1,2,3,4]
set(my_list)
{1,2,3,4}
list(set(my_list))
[1,2,3]

my_list = [3, 2, 4, 1, 2, 3, 3, 3 , 4, 1]
# print(list(set(my_list)))
#
# new_list = list(set(my_list))
# print(new_list)

new_list = []
for i in my_list:
    # 判断新列表中是否存在 i
    if i in new_list:

         pass  # continue
    else:
         new_list.append(i)
print(new_list)

for i in my_list:
    if i not in new_list:
        new_list.append(i)

函数基础

函数的参数

# 1.定义一个函数， my_sum ,对两个数字进行求和计算
def my_sum():
    num1 = 10
    num2 = 20
    num = num1 + num2
    print(num)

my_sum()

# 函数存在的问题，这个函数只能对 10 和 20 进行求和， 不能对任意的函数进行求和计算

# 问题的解决; 想要解决这个问题，可以使用函数参数来解决
函数参数： 在函数定义的时候，使用变量代替具体的数值（进行占位），在函数调用的时候传参具体的数据值
好处：让函数更加通用，能够解决以类问题，而不是单纯的一个

# 定义一个函数， my_sum ,对两个数字进行求和计算


# num1 和 num2 是函数定义时候的参数，起到占位的作用，没有具体的数据值，称为 形式参数， 简称 形参
def my_sum(num1, num2):
    num = num1 + num2  # 在什么时候定义参数，函数中使用的数据会变化的时候，就可以定义为参数
    print(num)


my_sum(1, 2)  # 在函数调用的时候， 括号中的数据会传递给形参，是具体的数据值，称为实际参数，简称 实参
# 目前书写的函数，在定义的时候如果有形参，那么在调用的时候，必须传递实参值，个数要对应，否则会报错
#中间空两行  PEP8 建议在函数的定义前后 有两个空行，否则灰色波浪线提示
Ctrl alt L

函数的返回值

函数的返回值，可以理解为是 函数整体执行的结果是什么
什么上班需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据
作为返回值返回，以供后续使用

print（） --->None
input()  --->键盘输入的内容
type()   --->类型
len()    ---数据的长度（元素的个数）

在函数中想要将一个数据作为返回值  返回， 需要使用return 关键字（只能在函数中使用）
作用：
1，将数据值作为返回值返回
2，函数代码执行遇到return，会结束函数的执行

def my_sum(a, b):
    num = a + b
    # print(num) # 代码中没有返回值，只有 print,这个结果只能在函数中用一次，不能后续使用
    # 我们想要将这个求和的结果 在后续的代码中使用，需要使用 return 将求和的结果进行返回
    return num #将这个结果返回到调用的地方法
    # return 之后的代码会执行吗
    print('我是 return 之后的代码， 我会执行吗 ---》不会执行')


# 1. 函数中没有 print,只有return，想要查看结果，需要在调用的时候使用print
print(my_sum(1, 2))

# 2,想要将函数中返回的结果，在后续代码中使用，即需要将这个数据保存下来，需要使用变量来接收（保存） 函数的返回值（执行结果）
# 变量 = 函数（）
result = my_sum(10, 20)  #将求和的结果保存到变量 result 中， 可以在后续代码中使用
print('使用：1，直接打印：', result)
print('使用： 2,对数字 加 10：', result + 10)

• 返回值的说明

  def 函数名（）：  # 返回值  None
      pass # 代码中没有 return
  
  
  def 函数名()：
      return  # return 后边没有数据，返回值 None
  
  def 函数名（）：
      return xx  # 返回值是xx
  

变量进阶[理解 知道]

在这一部分 我们了解 Python 底层是如何处理数据的

变量的引用

1. 在定义变量的时候 变量 = 数据值， Python 解释器会在内存中开辟两块空间
2. 变量和数据都有自己的空间
3. 日常简单理解， 将数据保存到变量的内存中， 本质是 将 数据的地址保存到变量对应的内存中
4. 变量中存储数据地址的行为 就是引用 （变量引用了数据的地址，简单说就是变量中存储数据），存储的地址称为 引用地址
5. 可以使用id() 来获取变量中的引用地址（即数据的地址），如果两个变量的 ID（） 获取的引用地址一样，即代表着， 两个变量引用了同一个数据，是同一个数据
6. 只有 赋值运算符=， 可以改变变量的引用（等号左边数据的引用）
7. python 中数据的传递，都是传递的引用

可变类型和不可变类型

数据类型; Int float bool str list tuple dict set

可变不可变是指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型（不使用=，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的）

可变类型： 列表 list， 字典 dict，集合 set
列表.append()
字典.pop(键)
不可变类型：int float bool str tuple

my_list = [1, 2, 3]
my_list1 = [1, 2, 3]

print('my_list:', id(my_list), id(my_list[1]))
print('my_list:', id(my_list1))
my_list[1] = 10
print(my_list)
print('my_list :', id(my_list), id(my_list[1]))

my_tuple =(1, 2,[3, 4])  # 元组中存储的是 1 的地址，2 的地址， 和 列表地址
# 元组中的数据不能改变，是值 这个三个地址不能改变
print(my_tuple, id(my_tuple[-1]))
my_tuple[-1][0] = 10  # 修改的是列表中下标为 0 的位置的引用地址，列表的地址没变，元组中的内容没有变化
print(my_tuple, id(my_tuple[-1]))

题目4 交换两个变量的值

a = 10
b = 20
# 方法一： 常规方法 引入第三个变量

# c = a
# a = b
# b = c
# print(a, b)

# 方法二： 不使用第三个变量， 使用数学中的方法
# a = a + b
# b = a - b
# a = a - b
# print(a, b)

# 方法三，重点掌握，Python 特有
a, b = b, a
print(a, b)

组包和拆包

组包（pack）：将多个数据值使用逗号连接，组成元组

拆包（UNpack）：将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持一致

赋值运算符，都是先执行等号右边的代码，执行的结果，保持到等号左边的变量中

# 组包

c =b, a  #组包
print(type(c), c)  # <class 'tuple'> (20, 10

# 拆包
a, b = c
print(a, b)

x, y, z = [1, 2, 3]
print(x, y, z)

局部变量和全局变量

变量：根据变量的定义位置， 可以将变量分为局部变量和全局变量
特点：
1， 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
2， 在不同函数中，可以定义名字相同的局部变量， 两者之间没有影响
3， 生存周期（生命周期，作用范围）--> 在那 能用
在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用

所有函数中的局部变量的值，如果想要在函数外部使用，需要使用return 关键字，将这个值进行返回

def func1():
    num = 10  # num 就是局部变量
    print(f"func1 函数中 {num}")
    
    
def fun2():
    num = 100  # 可以在不同函数中定义名字相同的局部变量，没有影响
    print("func1 函数中 {num}")
    
    
fun2()
func1()

全局变量

局部变量： 在函数内部（函数的缩进中）定义的变量，称为是局部变量
特点：
1. 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
2. 在不同函数中，可以定义名字相同的局部变量，两者之间没有影响
3.生命周期（生命周期， 作用范围）--->在那 能用
在函数被调用的时候，局部变量被创建， 函数调用结束， 局部变量的值被销毁（删除）， 不能使用

所以函数中的局部变量的值，如果想要在函数外部使用，需要使用 return 关键字，将这个值进行返回

g_num = 10  # 全局变量


def func1():
    print(f'func1 中 {g_num}')  # 在函数中可以读取全局变量的值
    

def func2():
    g_num = 20  # 定义局部变量， 不会影响全局变量
    print(f'func2 中 {g_num}')
    
    
def func3():
    global  g_num  # 这个函数中使用的 g_num 都是全局变量
    g_num = 30  # 修改了全局变量
    print(f'func3 中 {g_num}')
    
    
func1()  # 10
func2()  # 20
func1()  # 10 
func3()  # 30
func1()  # 30
print(g_num)

函数进阶

返回值-函数返回多个数据值

函数中想要返回一个数据值， 使用return 关键字

将 多个数据值组成容器进行返回，一般是元组（组包）

def calc(a, b):
    num = a + b
    num1 = a - b
    return num, num1

# 书写一
result = calc(10, 5)
print(result, result[0], result[1])

# 书写二， 直接拆包
x, y = calc(20, 10)
print(x, y)

函数参数

• 位置传参：

  在函数调用的时候，按照形参的顺序，将实参值传递给形参
  

• 关键字传参

  在函数调用的时候，指定数据值给到那个形参
  

• 混合使用

  1，关键字传参必须写在位置传参的后面
  2，不要给一个形参传递多个数据值
  

  def func(a, b, c):
      print(f'a: {a}, b: {b}, c: {c}')
      
      
  # 位置传参
  func(1, 2, 3)
  
  # 关键字传参
  func(a=2, b=2, c=3)
  
  # 混合使用
  func(1, 3, c=5)
  

  缺省参数

  缺省参数，默认参数
  列表.pop()  # 不写参数，删除最后一个
  列表.sort(reverse=True)
  
  1.定义方式
  在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数， 注意， 缺省参数的书写
  要放在普通参数的后边
  2. 特点(好处)
  缺省参数，在函数调用的时候，可以传递参值，也可以不传递实参值
  如果传参，使用的就是传参的实参值， 如果不传参，使用的就是默认值
  

  def show_info(name, sex'保密')：
      print(name, sex)
      
      
  show_info('小王')
  show_info('小王', '男')
  

   

多值参数[可变参数/不定长参数]

print(1)
print(1, 2)
print(1, 2, 3)
print(1, 2, 3, 4)

当我们在书写函数的时候， 不确定参数的具体个数时， 可以使用 不定长参数

• 不定长位置参数（不定长元组参数）

  1.书写，在普通参数的前边，加上一个 *， 这个参数就变为不定长位置参数
  2.特点，这个形参可以接受任意多个 位置传参的数据
  3.数据类型，形参的类型是 元组
  4.注意.不定长位置参数 要写在普通的参数的后面
  5.一般书写，不定长位置参数的名字为 args, 即（*args） # arguments
  

• 不定长关键字参数（不定长字典参数）

  1.书写，在普通参数的前边，加上 两个*， 这个参数就变为不定长关键字参数
  2.特点，这个形参可以接受任意多个 关键字传参的数据
  3.数据类型，形参的类型是 字典
  4，注意， 不定长关键字参数，要写在所有参数的最后边
  4.一般书写，不定长关键字参数的名字为kwargs,即（**kwargs), keyword arguments
  

• 完整的参数顺序

  def 函数名（普通函数， *args, 缺省参数， **kwargs):
      pass
  
  # 一般在使用的时候， 使用 1-2中， 按照这个顺序挑选书写即可
  

  def func(*args, **kwargs):
      print(type(args), args)
      print(type(kwargs), kwargs)
      print('--'* 30)
      
      
  func()
  func(1, 2, 3)  # 位置传参，数据都给args
  func(a=1, b=2, c=3)  # 关键字传参， 数据都给 kwargs
  func(1, 2, 3, a=4, b=5, c=6)
  

  print解析

  # print()
  # sep=' ', 多个位置参数之间的间隔
  # end='\n' 每一个 print函数结束， 都会打印的内容 结束符
  print(1, end='')
  print(2, end='')
  print(3)
  
  print(1, 2, 3, 4, 5, 6, sep='_')
  print(1, 2, 3, 4, 5, 6, sep='_*_')
  
  

   

原文地址：http://www.cnblogs.com/88hx/p/16800938.html