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='_*_')
    
    

     

版权声明:本文为Mr~吴原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/88hx/p/16800938.html