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