一、导学
- Pthon语言基础入门
- Pthon语言高阶加强
- 大数据分析PySpark
二、 初识Python
- 你好Python程序
print("Hello World!!")>>Hello World!!
!输入的双引号和括号为英文字符
三、 Python基础语法
(一) 字面量
1. 定义:在代码中,被写下来的固定的值,称之为字面量。
2. 常用的6种值的类型
类型 | 描述 | 说明 |
数字(Number) | 支持(4种子类型)
|
|
字符串(String) | 描述文本的一种数据类型 | 字符串(string)由任意数量的字符组成 |
列表(List) | 有序的可变序列 | Python中使用最频繁的数据类型,可有序记录一堆数据 |
元组(Tuple) | 有序的不可变序列 | 可有序记录一堆不可变的Python数据集合 |
集合(Set) | 无序不重复集合 | 可无序记录一堆不重复的Python数据集合 |
字典(Dictionary) | 无序Key-Value集合 | 可无序记录一堆Key-Value型的Python数据集合 |
3. 字符串
!Python中,字符串需要用双引号包围;
!被双引号包围的都是字符串
66613.14"黑马程序员"print( 666 )print( 13.14 )print( "黑马程序员" )>>666>>13.14>>"黑马程序员"
(二) 注释
1. 单行注释
# 我是单行注释print( "黑马程序员" )
!规范:#号和注释内容一般建议以一个空格隔开
2. 多行注释
""" 我是多行注释 666 13.14 "黑马程序员""""print( 666 )print( 13.14 )print( "黑马程序员" )
(三) 变量
1. 定义:程序运行时,能储存计算结果或表示值的抽象概念。
简单的说,变量就是在程序运行时,记录数据用的
2.定义格式:
变量名称 = 变量的值
# 定义变量money = 5000# print输出变量print( " 钱包还有:" , money )>> 钱包还有: 5000# 买了东西,花费10元money = money - 10print( "买了冰淇淋花费10元,还剩余:" , money , "元" )>>买了冰淇淋花费10元,还剩余: 4990 元
!变量值可变
$练习:
(四) 数据类型
1. type()语句【具有返回值】
1)语法:
type(被查看类型的数据)
2)使用方法:
a = type( 666 )print( a )print( type( 13.14 ) )name = "黑马程序员"name_type = type( name )print( name_type )>> >> >>
2. 变量无类型,查看变量的类型实际上查看的是变量存储数据的类型
!字符串变量:不是字符串是变量,而是变量存储了字符串
(五) 数据类型转换
1. 常见的转换语句
语句(函数) | 说明 |
int( x ) | 将x转换为一个整数 |
float( x ) | 将x转换为一个浮点数 |
str( x ) | 将对象x转换为字符串 |
!此三种语句具有返回值
# 将数字类型 -> 字符串类型num_str = str( 11 )print( type( num_str ) , num_str )float_str = str( 13.14 )print( type( float_str ) , float_str )>> 11>> 13.14
# 将字符串类型 -> 数字类型num = int( "11" )print( type( num ) , num )num2 = float( "13.14" )print( type( float ) , num2 )>> 11>> 13.14
!想要将字符串转换成数字,必须要求字符串内的内容都是数字
num3 = int ( "黑马程序员" )print( type( num3 ) , num3 )>> ValueError: invalid literal for int() with base 10: '黑马程序员'
!浮点数转整数会丢失精度
# 整数 -> 浮点数float_num = float( 11 )print( type( float_num ) , float_num )>> 11.0# 浮点数 -> 整数int_num = int( 13.14 )print( type( int_num ) , int_num )>> 13
(六)标识符
1. 定义:用户在编程时所用的一系列名字,用于给变量、类、方法等命名。
2. 命名规则:
内容限定(英文,中文,数字,下划线_)
!数字不可开头
大小写敏感
不可使用关键字
3. 命名规范:
见名知义
下划线命名法
英文字母全小写
(七) 远算符
1. 算术运算符:+、-、*、/、//、%、**(指数)
2. 赋值运算符:=
3. 复合赋值运算符:+=、-=、*=、/=、//=、%=、**=
(八) 字符串扩展
1. 3种定义方式
1)定义形式:
① 单引号定义法:
name = ‘黑马程序员’
②双引号定义法:
name = “黑马程序员”
③三引号定义法:
name = “””黑马程序员”””
*支持换行操作,使用变量接收它,则为字符串;不使用变量接收,则为多行注释
# 单引号定义法,使用单引号进行包围name = '黑马程序员'print( type(name) )# 双引号定义法,写法和多行注释是一样的name = "黑马程序员"print( type(name) )# 三引号定义法,写法和多行注释是一样的name = """我是黑马程序员"""print( type(name) )>> >> >>
2)字符串的引号嵌套
①单引号法,可以内含双引号;
②双引号定义法,可以内含单引号;
②可以使用转义字符(\)来将引号解除效用,变成普通字符串。
# 字符串内,包含双引号name = '"黑马程序员"'print( name )# 字符串内,包含单引号name = "'黑马程序员'"print( name )# 使用转义字符(\)解除引号的效用name = "\"黑马程序员\""print( name )name = '\'黑马程序员\''print( name )>> "黑马程序员">> '黑马程序员'>> "黑马程序员">> '黑马程序员'
2. 字符串拼接
1)通过+号进行拼接
name = "黑马程序员"print( "我的名字是:" + name + "我可以教大家IT技能" )>> 我的名字是:黑马程序员我可以教大家IT技能
!无法和非字符串类型进行拼接
3. 字符串格式化
1)“%占位符”%变量
2)常用占位符
字符串:%s
整数: %d
浮点数:%f
3)数字精度控制
辅助符号“m.n”来控制数据的宽度和精度
m :控制宽度,要求是数字(很少使用),设置的宽度小于数字本身,不生效
.n:控制小数点精度,要求是数字,会进行小数的四舍五入
%5d:表示将整数的宽度控制在5位,如数字11,被设置为5d,就会变成:[空格][空格][空格]11,用三个空格补足宽度
%5.2f:表示将宽度控制为5,将小数点精度设置为2
小数点和小数部分也算入宽度计算。如:对11.345设置为%7.2后,结果是:[空格][空格]11.35。2个空格补足宽度,小数部分限制2位精度,四舍五入为.35
%.2f:表示不限制宽度,只设置小数点精度为2,如11.345设置为%.2f,结果是11.35
num1 = 11num2 = 11.345print( "数字11宽度限制5,结果:%5d" % num1 )print( "数字11宽度限制1,结果:%1d" % num1 )print( "数字11.345宽度限制7,小数精度2,结果:%7.2f" % num2 )print( "数字11.345不限制宽度,小数精度2,结果:%.2f" % num2 )>> 数字11宽度限制5,结果: 11 # 宽度5,补了3个空格>> 数字11宽度限制1,结果:11 # 宽度小于数字本身,无影响>> 数字11.345宽度限制7,小数精度2,结果: 11.35 # 宽度7,补了2个空格,小数精度2,四舍五入后为.35>> 数字11.345不限制宽度,小数精度2,结果:11.35 # 不限制宽度,小数点后四舍五入后为.35
4)快速写法
语法:
f”内容{变量}”
name = "传智播客"set_up_year = 2006stock_price = 19.99print( f"我是{name},我成立于{set_up_year}。我今天的股票价格是:{stock_price}" )>> 我是传智播客,我成立于2006。我今天的股票价格是:19.99# 不做精度控制,原样输出
!以上字符串格式化均可用于表达式格式化
print( "1 * 1的结果是:%d" % ( 1 * 1 ) )print( f"1 * 1的结果是:{1 * 1}")print( "字符串在Python中的类型是:%s" % type('字符串') )>> 1 * 1的结果是:1>> 1 * 1的结果是:1>> 字符串在Python中的类型是:
$练习:
(九)数据输入
1. 语法
input();
2. 使用:
使用input()语句可以从键盘获取输入
使用一个变量接收(存储)input语句获取的键盘输入数据即可
数据输出:print
数据输入:input
print( "请告诉我你是谁?" )name = input()print( "GET!!你是:%s" % name )>> 请告诉我你是谁?>> XUANseyo>> GET!!你是:XUANseyo
! input()语句可以在要求使用者输入内容之前,输出提示内容的
name = input( "你是谁?" )print( "GET!!你是:%s" % name )>> 你是谁?XUANseyo>> GET!!你是:XUANseyo
!无论input()输入什么,其都会自动转为字符串类型,我们要自行进行数据类型转换
num = input( "你的银行卡密码是:" )print( "你的银行卡密码的类型是:" , type( num ) )>> 你的银行卡密码是:123456>> 你的银行卡密码的类型是:
$练习:
四、 Python判断语句
(一) 布尔类型和比较运算符
1. 布尔类型:判断结果
True:表示真(是、肯定)
False:表示假(否、否定)
# 定义变量存储布尔类型的数据bool_1 = Truebool_2 = Falseprint( f"bool_1变量的内容是:{ bool_1 },类型为:{ type( bool_1 ) }" )print( f"bool_2变量的内容是:{ bool_2 },类型为:{ type( bool_2 ) }" )>> bool_1变量的内容是:True,类型为:>> bool_2变量的内容是:False,类型为:
2. 比较运算和比较运算符:
==、!=、>、=、<=
(二) if语句的基本格式
1. if语句基本格式:
if 要判断的条件:
条件成立时,要做的事情
!首行缩进确定代码块归属
age = 30if age >= 18: print( "我已经成年了。" ) print( f"已经{ age }岁了啊!" )print( "时间过得真快啊!" )>> 我已经成年了。>> 已经30岁了啊!>> 时间过得真快啊!
# 判断语句的结果必须为布尔类型的True或False
True会执行if内的代码语句
False则不会执行
age = 10if age >= 18: print( "我已经成年了。" ) print( f"已经{ age }岁了啊!" )print( "时间过得真快啊!" )>> 时间过得真快啊!
$练习:
(三) if else 语句
1. 基本格式:
if 条件 :
满足条件时要完成的事1
满足条件时要完成的事2
……
else:
不满足条件时要完成的事1
不满足条件时要完成的事2
……
print( "欢迎来到黑马儿童游乐场,儿童免费,成人收费!" )age = input( "请输入您的年龄:" )if int(age) >= 18 : print( "您已成年,游玩需补票10元" )else : print( "您未成年,无需补票" )print( "祝您游玩愉快!!!" )>> 欢迎来到黑马儿童游乐场,儿童免费,成人收费!>> 请输入您的年龄:17>> 您未成年,无需补票>> 祝您游玩愉快!!!
$练习:
(四) if elif else 语句
1. 基本格式:
if 条件1 :
条件1满足时要完成的事
条件1满足时要完成的事
……
elif 条件2::
条件2满足时要完成的事
条件2满足时要完成的事
……
elif 条件n:
条件n满足时要完成的事
条件n满足时要完成的事
……
else:
所有条件不满足时要完成的事
所有条件不满足时要完成的事
……
print("欢迎来到黑马动物园!!")height = int(input("请输入你的身高:"))vip_level = int(input("请输入您的vip级别(1~5):"))if height 3 : print("您的vip级别大于3,可以免费游玩")else : print("不好意思,所有条件均不符合,需要购票10元")print("祝您游玩愉快")>> 欢迎来到黑马动物园!!>> 请输入你的身高:150>> 请输入您的vip级别(1~5):5>> 您的vip级别大于3,可以免费游玩>> 祝您游玩愉快
$练习:
(五) 判断语句的嵌套
1. 基本格式
if 条件1 :
满足条件1时要完成的事1
满足条件1时要完成的事2
……
if条件2:
满足条件2做的事情1
满足条件2做的事情2
……
2. 嵌套的关键点:空格缩进
通过空格缩进,来决定语句之间的:层次关系
(六) 实战案例
import randomnum = random.randint(1,10)m = int(input("第一次才得数字:"))if num == m : print ("猜对啦!")else : if num > m: print("猜小了!") else : print("猜大了!") m2 = int(input("第二次猜测的数字:")) if m2 == num: print("第二次猜对了!") elif num > m2: print("第二次猜小了!") elif num < m2: print("第二次猜大了") guess_num = int(input("第三次输入你要猜测的数字:")) if guess_num == num: print("第三次猜中了") else: print("三次机会用完了,没有猜中。")
五、 Python循环语句
(一) while循环的基本语法
1. 基本格式
while 条件:
条件满足时,做的事情1
条件满足时,做的事情2
…(省略)…
- 只要条件满足,会无限循环执行
- 条件需要布尔类型结果
$练习:
(二) while循环的基础案例
(三) while循环的嵌套应用
1. 基本格式:
while 条件1:
条件1满足时,做的事情1
条件1满足时,做的事情2
…(省略)…
while 条件2:
条件2满足时,做的事情1
条件2满足时,做的事情2
…(省略)…
(四) while循环的嵌套应用
补充:
1. print输出不换行
print("Hello",end=' ')print("World!",end='')>> Hello World!
2. 制表符/t
print("学号\t姓名\t语文\t数学\t英语")print("2022001\t小王\t99\t\t88\t\t0")print("2022002\t小周\t92\t\t45\t\t93")print("2022008\t小黄\t77\t\t82\t\t100")
(五) for循环的基础语法
1. 基础语法
for循环就是将“待办事项”逐个完成的循环机制
- while循环的循环条件是自定义,自行控制循环条件
- for循环是一种“轮询”机制,是对一批内容进行逐个处理
!for循环无法定义循环条件,只能从被处理的数据集中,依次取出内容进行处理
1) 基本格式:
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句
$练习:
2. range语句
1) 功能:获得一个数字序列(可迭代类型的一种)
2) 语法格式:
range(num)
获取一个从0开始,到num结束的数字序列
range(num1,num2)
获取一个从num1开始,到num2结束的数字序列(不含num2本身)
range(num1,num2,step)
获得一个从num1开始,到num2结束的数字序列(不含num2本身)
数字之间的步长,以step为准(step默认为1)
$练习:
3. 变量作用域
(六)for循环的嵌套应用
1. 基本格式:
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句1
循环满足条件时执行的语句2
……
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句1
循环满足条件时执行的语句1
$练习:
(七) 循环中断:break和continue
1. continue关键字作用:中断本次循环,直接进入下一次循环【for循环和while循环即可使用】
2. break关键字作用:所在循环永久中断【for循环和while循环即可使用】
(八) 综合案例
六、 Python函数
(一) 函数介绍
1. 函数:是组织好的,可重复使用的,用来实现特定功能的代码段。
eg. len():实现统计长度这一特定功能的代码段。
2. 函数好处:
* 将功能封装在函数内,可随时随地重复利用
* 提高代码的复用性,减少重复代码,提高开发效率
(二) 函数定义
1. 基本语法:
(1) 函数定义
def 函数名 (传入函数):
函数体
return 返回值
(2) 函数调用
函数名(参数)
!参数可省略
!返回值可省略
!函数必须先定义后使用
$练习:
def printWelcome (): print("欢迎来到黑马程序员!") print("请出示48小时核酸检测证明!")printWelcome()
(三) 函数参数
1. 传入参数的功能:在函数调用时,接受外部提供的数据
!参数之间按顺序传入;使用,进行分隔
$练习:
def printWelcome(x): print("欢迎来到黑马程序员!请出示48小时核酸检测证明!") if x <= 37.5: print(f"体温测量中,您的体温是:{x},体温正常,请进!") else: print(f"体温测量中,您的体温是{x},需要隔离!")y = int(input("请输入您的体温:"))printWelcome(y)
(四) 函数返回值
1. 通过return关键字,可向调用者返回数据
2.. None类型:
(1) None,其类型是
(2) 无返回值的函数,实际上是返回了None这个字面量
(3) 使用:
- 用于函数返回值中【空】
- 用于if判断【None等同于False】
- 用于声明无内容的变量上
(五) 函数说明文档
1. 函数说明文档:对函数进行说明解释,帮助更好地理解函数
2.. 定义语法:
def func(x,y)
“””
函数说明
:param x:参数x的说明
:param x:参数x的说明
:return:返回值的说明
“””
函数体
return 返回值
(六) 函数嵌套使用
1. 函数嵌套:在一个函数中,调用另一个函数。
2. 执行流程:
函数a中执行到调用函数b的语句,会将b全部执行;完成后,继续执行函数a的剩余内容
(七) 变量的作用域
1. 变量作用域:变量的作用范围
2.. 局部变量:定义在函数体内部的变量,只在函数体内部生效
局部变量作用:在函数体内部,临时保存数据,即当函数调用完成后,销毁局部变量
3. 全局变量:在函数体内外都能生效的变量
4. global关键字:可使函数内部声明变量为全局变量
(八) 综合案例
money = 5000000name = Nonedef menu(): name = input("您好!请输入客户姓名:") print("您好,请问您需要什么服务呢?") print("输入1:查询余额") print("输入2:存款") print("输入3:取款") n = int(input("请输入功能号:")) if n == 1: check(money) elif n == 2: x = int(input("请输入您想存入的金额:")) deposit(x, money) elif n == 3: y = int(input("请输入您想取出的金额:")) withdraw(y, money)def check(money): print(f"您好!您的余额为:{money}") menu()def deposit(x, money): money1 = x + money print(f"您好,存款成功后,您的余额为:{money1}") menu()def withdraw(x, money): money2 = money - x print(f"您好,取款成功后,您的余额为:{money2}") menu()menu()
七、 Python数据容器
(一) 数据容器入门
1. 数据容器:一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素。每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
2.. 种类:list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
(二) 数据容器:list(列表)
1. 定义
(1) 基本语法:
# 字面量
[元素1 ,元素2 ,元素3,……]
# 定义变量
变量名称 = [元素1 ,元素2 ,元素3,……]
# 定义空列表
变量名称 = []
变量名称 = list()
(2) 元素:列表中的每个数据
! 列表可以一次存储多个数据,且可以为不同类型,支持嵌套
2. 列表的下标索引
(1) 类型:正向:从前向后,从0开始,依次递增
反向:从后向前,从-1开始,依次递减
(2) 使用:
列表[下标]
! 下标超出范围,则无法取出元素,并且会报错
3. 列表的常用操作(方法)
* 函数:封装的代码单元,可提供特定功能。
如将函数定义为class(类)的成员,则称函数为方法。
编号 | 关键字 | 使用方法 | 作用 |
1 | index | 列表.index(元素) | 查找指定元素在列表中的下标,找不到则报错ValueError |
2 | len | len(列表) | 统计容器中有多少元素 |
3 | count | 列表.count(元素) | 统计此元素在列表中出现的次数 |
4 | del | del 列表[下标] | 删除列表指定的下标元素 |
5 | pop | 列表.pop[下标] | 删除列表指定的下标元素 |
6 | remove | 列表.remove(元素) | 从前向后,删除此元素的第一个匹配项 |
7 | append | 列表.append(元素) | 向列表中追加一个元素 |
8 | extend | 列表.extend(容器) | 将数据容器中的内容依次取出,追加到列表尾部 |
9 | insert | 列表.insert(下标,元素) | 在指定下标处,插入指定的元素 |
10 | clear | 列表.clear() | 清空列表 |
4. 列表的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
$练习:
age = [21, 25, 21, 23, 22, 20]age.append(31)print(age)age.extend([29, 33, 30])print(age)x = age[0]y = age[-1]print(x, y)a = age.index(31)print(a)
(三) list(列表)的遍历
* 遍历:将容器内的元素依次取出,并处理
1. 使用while遍历
- 可以指定循环条件,自行控制
- 可以通过条件控制做到无限循环
- 适用于任何想要循环的场景
2. 使用for遍历
- 不可以指定循环条件,只可以一个个从容器内取出数据
- 理论上不可以无限循环,因为被遍历的容器容量不是无限的
- 适用于遍历数据容器的场景或简单的固定次数循环场景
$练习:
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]l1 = list()l2 = list()i = 0# 取出偶数while i < len(L): if L[i] % 2 == 0: l1 . append(L[i]) i = i + 1 else: i = i + 1print(f"通过while循环,从列表:{L},中取出偶数,组成新列表{l1}")for j in L: if j % 2 == 0: l2 . append(j)print(f"通过for循环,从列表:{L},中取出偶数,组成新列表{l2}")
(四) 数据容器:tuple(元组)
* 元组一旦定义,不可进行修改
1. 元组的定义
(1) 基本语法:
# 字面量
(元素1 ,元素2 ,元素3,……)
# 定义变量
变量名称 =(元素1 ,元素2 ,元素3,……)
# 定义空列表
变量名称 = ()
变量名称 =tuple()
! 元组即使只含有一个数据,这个数据后也要添加,也可进行嵌套
2. 元组的操作(方法)
编号 | 关键字 | 使用方法 | 作用 |
1 | index | index() | 查找指定数据在元组中的下标,找不到则报错 |
2 | len | len(元组) | 统计元组内有多少元素 |
3 | count | count() | 统计某个数据在元组中出现的次数 |
! 不可修改元组内容,否则直接报错
! 可修改元组内list的内容
! 不可以替换元组内list为其他list或其他类型
3. 元组的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
- 可进行循环
- 不可修改
$练习:
T = ('周杰伦', 11, ['football', 'music'])a = T.index(11)n = T[0]print(a,n)del T[2][0]T[2].append('coding')print(T)
(五) 数据容器:str(字符串)
1. 字符串
字符的容器,一个字符串可以存放任意数量的字符。
2. 字符串的下标(索引)
- 从前向后,下标从0开始
- 从后向前,下标从-1开始
! 字符串是一个无法修改的数据容器
! 如果要修改,则会得到一个新的字符串,旧的字符串是无法修改的
3. 字符串的常用操作
编号 | 关键字 | 使用方法 | 作用 |
1 | 字符串[下标] | 根据下标索引取出特定位置字符 | |
2 | index | 字符串.index(字符串) | 查找给定字符的第一个匹配项的下标 |
3 | replace | 字符串.replace(字符串1,字符串2) | 将字符串内的全部字符串1,替换为字符串2 !不会改变原字符串,而是得到一个新的字符串 |
4 | split | 字符串.split(字符串) | 按照给定字符串,对字符串进行分割 !不会改变原字符串,而是得到一个新的列表 |
5 | strip | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
6 | count | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
7 | len | len(字符串) | 统计字符串的字符个数 |
4. 字符串的特点
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复的字符串出现
- 不可以修改
- 支持循环
$练习:
S = "itheima itcast boxuegu"n = S.count("it")print(f"字符串{S}中有{n}个it字符")S1 = S.replace(" ", "|")print(f"字符串{S},被替换空格后,结果{S1}")L = S1.split("|")print(f"字符串{S},按照“|”分割后,得到{L}")
(六) 数据容器的切片
1. 序列
内容连续、有序、可使用下标索引的一类数据容器。(如列表、元组、字符串等)
2. 切片
(序列的常用操作)从一个序列中,取出一个子序列
3. 基本语法
序列[起始下标:结束下标:步长]
* 表示从序列中,从指定位置开始,依次取出指定元素,到指定位置结束,得到一个新序列
* 起始下标表示从何处开始,可以留空,留空视作从头开始
* 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
* 步长表示,依次取元素的间隔
- 步长1表示,一个个取元素
- 步长2表示,每次跳过1个元素取
- 步长N表示,每次跳过N-1个元素取
- 步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记)
$练习:
S = "万过薪月,员序程马黑来,nohtyP学"# 使用“切片”new_S = S[9:4:-1]print(new_S)# 使用字符串常用操作i = -9S1 = S.replace("来", "")S2 = S1.split(",")print(S2)new_S1 = S2[0][9:4:-1]print(new_S1)
(七) 数据容器:set(集合)
1. 集合的基本语法
# 定义集合字面量
(元素,元素,……,元素)
# 定义集合变量
变量名称 = {元素,元素,……,元素}
# 定义空集合
变量名称 = set()
! 去重且无序,无法保证顺序与创建的时候一致
! 不支持:下标索引访问,因此不支持while循环
补充:
定义:
列表[] 可修改、支持重复元素且有序
元组() 不可修改、支持重复元素且有序
字符串“” 不可修改、支持重复元素且有序
集合{} 可修改、不支持重复元素、无序
2. 集合的常用功能
编号 | 关键字 | 使用方法 | 作用 |
1 | add | 集合.add(元素) | 集合内添加一个元素 |
2 | remove | 集合.remove(元素) | 移除集合内指定的元素 |
3 | pop | 集合.pop() | 从集合中随机取出一个元素 |
4 | clear | 集合.clear() | 将集合清空 |
5 | difference | 集合1.difference(集合2) | 得到一个新集合,内含2个集合的差集 原有的2个集合内容不变 |
6 | update | 集合1.difference_update(集合2) | 在集合1中,删除集合2中存在的元素 集合1被修改,集合2不变 |
7 | union | 集合1.union(集合2) | 得到1个新集合,内含2个集合的全部元素原有的2个集合内容不变 |
8 | len | len(集合) | 得到一个整数,记录了集合的元素数量 |
3. 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
- 数据是无序存储的(不支持下标存储)
- 不允许重复数据存在
- 可以修改
- 支持for循环,不支持while循环
$练习:
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']S = set()for i in my_list: S.add(i)print(f"有列表:{my_list}")print(f"存入集合后结果:{S}")
(八) 数据容器:dict(字典、映射)
1. 字典的基本语法
# 定义字典字面量
{key:value,key:value,……,key:value}
# 定义字面变量
my_dict = {key:value,key:value,……,key:value}
# 定义空字典
my_dict = {}
my_dict = dict{}
! 每个元素均为键值对,key和value可以为任意类型数据(key不可为字典)
! key不可重复,重复会对原有数据覆盖
! 不可以使用下标索引,但可通过key值取得对应的value,不可使用while循环
! 字典可嵌套
2. 字典的常用操作
编号 | 关键字 | 使用方法 | 作用 |
1 | 字典[Key] | 获取指定Key对应的Value值 | |
2 | 字典[Key] = Value | 添加或更新键值对 | |
3 | pop | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
4 | clear | 字典.clear() | 清空字典 |
5 | keys | 字典.keys() | 获取字典的全部Key,可用于for循环遍历字典 |
6 | len | len(字典) | 计算字典内的元素数量 |
3. 字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
- 不支持下标索引
- 可以修改
- 支持for循环,不支持while循环
$练习:
D = { "王力鸿":{"部门":"科技部","工资":3000,"级别":1}, "周婕纶":{"部门":"市场部","工资":5000,"级别":2}, "凌俊杰":{"部门":"市场部","工资":7000,"级别":3}, "张雪有":{"部门":"科技部","工资":4000,"级别":1}, "牛德华":{"部门":"市场部","工资":6000,"级别":2}}keys = D.keys()print(D)for key in keys: if D[key]["级别"] == 1: D[key]["工资"] = D[key]["工资"] + 1000print(D)
扩展:数据容器的对比总结
列表 | 元组 | 字符串 | 集合 | 字典 | |
元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key:除字典外任意类型 Value:任意类型 |
下标索引 | ✓ | ✓ | ✓ | × | × |
重复元素 | ✓ | ✓ | ✓ | × | × |
可修改性 | ✓ | × | × | ✓ | ✓ |
数据有序 | ✓ | ✓ | × | × | × |
使用场景 | 可修改、可重复的一批数据的记录 | 不可修改、可重复的一批数据的记录 | 一串字符的记录 | 不可重复的数据记录 | 以Key检索Value的数据记录 |
(九) 数据容器的通用操作
序号 | 功能 | 描述 |
1 | for循环 | 遍历容器(字典是遍历key) |
2 | max() | 容器内最大元素 |
3 | min() | 容器内最小元素 |
4 | len() | 容器内元素个数 |
5 | list() | 转换为列表 |
6 | tuple() | 转换为元组 |
7 | str() | 转换为字符串 |
8 | set() | 转换为集合 |
9 | sorted(序列,[reverse = True]) | 排序,得到一个排好序的列表 reverse = True表示“降序” |
(十)综合案例
# 幸运数字6:# 1. 输入任意数字,如数字8,生成nums列表,元素值为1-8,# 2. 从中选取幸运数字(能被6整除)移动到新列表lucky# 3. 打印nums和luckyn = int(input("请输入您所想的数字:"))i = 1j = 0nums = list()lucky = list()print(n)while i <= n: nums.append(i) i = i + 1print(f"nums列表为:{nums}")for j in nums: if j % 6 == 0: lucky.append(j) j = j + 1print(f"lucky列表为:{lucky}")
# 列表嵌套:# 3个教室[[],[],[]]# 8名讲师['A','B','C','D','E','F','G','H']# 随机分配import randomclassroom = [[],[],[]]teacher = ['A','B','C','D','E','F','G','H']j = random.randint(0,2)for i in teacher: classroom[j].append(i) j = random.randint(0,2)print(f"分配后为:{classroom}")
八、 函数进阶
(一) 函数多返回值
- 按照返回值的顺序,写对顺序的多个变量接收即可
- 变量之间用逗号隔开
- 支持不同类型的数据return
def test_return(): return 1,2x,y = test_return()print(x)print(y)>>1>>2
(二) 函数的多种传参方式
函数参数种类:根据使用方式不同:分为以下4种
1. 位置参数
- 根据函数定义的参数位置来传递参数
! 传递的参数和定义的参数的顺序及个数必须一致
2. 关键字参数
- 函数调用时通过键值对的形式传递参数
! 函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序
3. 缺省参数
- 也称默认参数,用于定义函数,为函数提供默认值,调用函数时可不传该默认参数的值
! 所有位置参数必须出现在默认参数前,包括函数定义和调用
! 函数调用时,如果为缺省参数传值则修改默认参数值,否则使用这个默认值
4. 不定长参数
- 也称可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
! 当调用函数时不确定参数个数时,可以使用不定长参数。
(1) 位置传递
- 传进的所有参数都会被args变量收集,他会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是位置传递
def user(*args): print(args)user('Belly',20,1)>>('Belly', 20, 1)
(2) 关键字传递
- 参数是键值对形式,所有键值对都会被kwargs接受,同时根据键值对组成字典
def user(**kwargs): print(kwargs)user(name = 'Belly',age = 20,sex = 1)>>{'name': 'Belly', 'age': 20, 'sex': 1}
(三) 匿名函数
1. 函数作为参数传递
- 函数本身可以作为参数,传入另一个函数中进行使用
- 函数传入的作用在于:传入计算逻辑,而非传入数据
2. lambda匿名函数
(1) 函数定义:
- def关键字:定义带有名称的函数(可以使用名称进行重复使用)
- lambda关键字:定义匿名函数(只可临时使用一次)
(2) lambda基本语法:
lambda 传入参数:函数体(一行代码)
! 函数体只可写一行代码,无法写多行
def test(compute): result = compute(2,3) print(result)test(lambda x,y:x + y)
九、 Python文件操作
(一) 文件的编码
1. 编码
- 编码是一种规则集合,记录了内容和二进制间进行相互转换的逻辑
- 编码有许多种,最常用的是utf-8
2. 使用编码的原因
- 计算机只能识别二进制数,因此要将文件的内容翻译为二进制数,才能保存进计算机内
- 同时也需要编码,将计算机保存的二进制数,反向编译回可识别的内容
(二) 文件的读取
1. 文件的基本操作步骤
- 打开文件
- 读写文件
- 关闭文件
! 可以只读,不写
2. 文件的基本操作函数
编号 | 关键字 | 使用方法 | 作用 |
1 | open | 文件对象 = open(file,mode,encoding) | 打开文件获得指定文件对象 |
2 | read | 文件对象.read(num) | 读取指定长度字节 不指定num读取文件全部 |
3 | readline | 文件对象.readline() | 读取一行 |
4 | readlines | 文件对象.readline() | 读取全部行,得到列表 |
5 | for | for line in 文件对象 | for循环文件行,一次循环得到一行数据 |
6 | close | 文件对象.close() | 关闭文件对象 |
7 | with open | with open() as f | 通过with open语法打开文件,可以自动关闭 |
! 读取文件后,要用进行关闭,否则文件一直被占用
$练习:
word = open('D:\Desktop\word.txt', 'r', encoding="utf-8")L = word.readlines()num = 0print(L)for i in L: num = num + i.count("itheima")print(num)
(三) 文件的写入
1. 写操作快速入门:
(1) 使用open的“w”模式进行写入
(2) 文件写入:f.write()
(3) 内容刷新:f.flush()
# 打开文件f = open('D:\Desktop\word.txt','w')# 写入文件f.write('hello world!')# 内容刷新f.flush()
! 直接调用write,内容并未真正写入文件,而是积攒在程序的内存中,称为缓冲区
! 当调用flush时,文件才会真正写入文件
! 这样避免频繁的操作硬盘,导致效率下降
2. 注意事项:
- w模式,文件不存在,会创建新文件
- w模式,文件存在,会清空原有内容
- close方法,具有flush方法的作用
(四) 文件的追加
1. 追加写入操作的快速入门
(1) 使用open的“a”模式进行写入
(2) 文件写入:f.write()
(3) 内容刷新:f.flush()
# 打开文件f = open('D:\Desktop\word.txt','a')# 文件写入f.write('I like pyhton!')# 内容刷新f.flush()
2. 注意事项
- a模式,文件不存在,不会创建文件
- a模式,文件存在,会在最后追加写入文件
(五) 综合案例
十、 Pyhon异常、模块与包
(一) 了解异常
1. 异常
- 程序运行的过程中出现了错误
2. bug
- bug就是指异常的意思,因为历史是因为小虫子导致计算机失灵的案例,所以延续至今,bug就代表软件出现错误
(二) 异常的捕获方法
1. 程序出现bug后的情况
- 程序因为一个bug停止运行
- 对bug进行提醒·,整个程序继续运行
2. 为什么要捕获异常?
- 在可能发生异常的方法,进行捕获,当出现异常时,提供解决方式,而不是任由其导致程序无法运行
- 作用:提前假设某处会出现异常,做好提前准备,当真的出现异常的时候,可以有后续手段